mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
d24e72bfd952fc146bfa078de4c214ca665c0ffd
1265
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
7ec788dea4 |
feat(mcp): accept agy and antigravity-cli as MCP targets (#670)
The agy CLI keeps its MCP servers in the file the antigravity client writes, and plugins and hooks already call it antigravity-cli, but mcp --target and --from rejected that name. Map agy and antigravity-cli to antigravity when the flags are parsed, so the source still stores one client name. Document the aliases in the MCP command reference, its four translations and the built-in skill reference. Closes #669 |
||
|
|
7f268e88d7 |
fix(update): allow lazy blob fetches between partial clone and candidate (#668)
Tracked repos are shallow blob:none partial clones, so they lack the blobs of intermediate commits. Since git 2.45.1, a local upload-pack refuses to lazy-fetch missing objects, so both the candidate clone and the publish fetch back into the checkout failed with "fetch-pack: invalid index-pack output" once more than one upstream commit arrived. Re-enable lazy fetching only for these two local transports, whose source is our own checkout, and pass origin's auth env so private repos can supply the blobs. Fetched blobs are hash-addressed, so the published tree still matches the audited revision. Closes #667 |
||
|
|
85bcf589a7 |
feat(sync): recognize and route agent-specific skill variants (#649)
* docs(proposals): propose agent-specific skill variants Tracked repositories can ship different files for the same skill across agents. Counting and syncing each copy independently sends incompatible instructions to every target unless users maintain routing filters. Propose repository-scoped logical identity and exact variant routing while preserving source files, explicit controls, and existing naming behavior. Leave activation and compatibility decisions for maintainer review. Refs #648 * docs(proposals): clarify variant routing compatibility Explain how recognition affects universal-only targets and how existing per-variant overrides preserve the desired routing. Fix the precedence between variant identity and generic host-style path inference. Include analyze, move, and catalog consumers while preserving physical identifiers and actual context-cost accounting. Refs #648 * docs(proposals): clarify activation assumptions and scope Make acceptance cases conditional on maintainer-approved recognition being enabled for the tracked source. Separate the provisional implementation estimate from this proposal-only PR so its size is clear. Refs #648 * docs(proposals): qualify naming and opt-in assumptions State that the reproduced routing behavior uses default flat target naming. Leave any opt-in surface with the maintainer's activation decision without ruling out future CLI or config fields. Refs #648 * feat: recognize and route tracked agent skill variants Count tracked variants as logical skills in source and repository summaries, while preserving physical paths, sync operations, and context costs. Select matching canonical agent variants, including account targets, through shared discovery and selection with existing explicit routing precedence. Refs #648 * fix: count logical skills in sync inventory summaries Use shared logical and physical inventory counts in global and project sync closing lines while preserving each target's operation totals. Refs #648 * fix: preserve variant routing diagnostics across previews Resolve target selections once so CLI and server previews keep ambiguity reasons and physical skip counts. Explain managed variants removed by automatic agent routing, and report logical inventory in doctor. Keep warning rows read-only, document upgrade recovery in translated filtering references, and remove the optional README-only addition. Refs #648 * fix: align sync matrix previews with shared variant selection Classify the full source selection once per target so matrix previews honor canonical aliases, account identity, exact-agent routing, and ambiguous variant skips. Preserve each rejected physical path's existing diagnostic and draft filter disambiguation; skipped preview rows remain read-only. Refs #648 * test: expect singular skill wording in doctor source checks Keep the undiscovered-link count assertion aligned with logical source inventory formatting for one skill in global and project mode. Refs #648 * fix: retain selection diagnostics in catalog and diff verdicts Report warning-only diff targets as requiring attention while preserving local-only folder semantics. Reuse shared per-path selection diagnostics in target-scoped catalogs without applying target naming to served paths. Compute source counts once in summary callers and require variant counts in the source status formatter. Refs #648 * test: tighten tracked variant preview fixtures Use a real committed tracked repository for status counts, verify sync preview banners retain server warnings, and use emitted ambiguity reason text in target preview fixtures. Refs #648 * fix(sync): keep agent variants in shared target folders Compatible targets sharing a skills folder need a combined selection so Codex and universal do not prune one another in merge or copy mode. Carry every shared reader through selection, pruning and previews, including project targets, account identities and path aliases. Require a matching skill suffix under two distinct agents before inferring variants, keeping ordinary agent-named categories unrestricted. Separate naming warnings from ambiguous selection in diff and explain ambiguous removals. Add global/project regression coverage for repeated sync, target-only sync, status JSON, diff and API consumers. * fix(variants): align consumer counts, hints and diagnostics Use logical source counts in list, tracked install and init summaries while matching audit caches against physical variants. Restore localized dashboard skip hints and explain symlink routing limits in status and doctor, including project and JSON output. Document paired-agent detection and compatible shared-folder selection in the proposal, built-in skill and English plus translated command pages. Add focused regressions for the affected consumers. * fix(sync): cover initial sync and ignored variant diagnostics Init syncs a fresh in-memory config, so resolve shared target identities before its first sync as well as when loading saved configuration. A whole-directory symlink exposes ignored skills too. Diagnose agent variants using physical inventory when active discovery has none, while keeping logical counts and merge/copy selection restricted to enabled skills. Cover global/project JSON status and doctor with regressions. Reuse sourcewalk directory and canonical-path helpers so traversal guards remain enforced and path resolution has a single existing owner. * fix(variants): address conversion, counts and selection diagnostics Ignore runtime agent identities when comparing convertible project targets and count logical skills during init. Keep selection warnings separate from naming warnings and preserve agent-named parent skills as ordinary skills. Cover account sync/prune, project ambiguity and overrides in merge/copy modes, and init/status agreement. Focused verification ran in an isolated Linux Codex container, not the devcontainer, as authorized. * refactor(variants): remove obsolete selection helpers Remove the unused FilterSkillsByTarget wrapper and prune agent parameter, cache canonical target aliases once, and restore catalog skip ordering to avoid an unrelated behavior change. Completes the optional cleanup from PR 649 review. * fix(ui): expose localized variant selection diagnostics Show target warnings with source paths, localize ambiguity across preview and detail consumers, and let skipped preview rows add a physical exclude pattern. Show tracked repository variant counts alongside logical skills. Drop display-only rendered cases while retaining mutation protection and plain TypeScript logic coverage. Inspect target states in Clean/Playful light/dark and Traditional Chinese. * docs(variants): explain diagnostics and add sync runbook Document doctor variant_routing and logical/physical counts, diff selection skips, and the nested parent-skill boundary. Keep all four command translations aligned and add isolated account/project E2E scenarios. Both runbook steps passed in the authorized Linux Codex container with separate HOME/XDG/TMPDIR fixtures. Website typecheck and all five locale builds passed. * test(config): use native paths in project conversion fixture The shared-agent regression fixture appended slash-separated suffixes to Windows temporary paths, so project path matching returned no candidates. Build each path with filepath.Join and preserve all conversion assertions. Focused project configuration tests passed in the authorized isolated Linux Codex container, not the devcontainer. Windows CI verifies the platform-specific fixture correction. * fix(ui): recompute shared skill routing for filter previews Evaluate edited include/exclude settings in the complete target map before classifying the draft, so a formerly shared folder no longer keeps its old union when the filters differ. Preserve the saved target configuration. * fix(mcp): keep parent skills when peer variants route elsewhere Do not treat an otherwise eligible variant for another agent as an unserved nested skill. Continue blocking parent publication for explicitly filtered, disabled, ambiguous, or invalid children so filters still hide their files. * fix(ui): distinguish agent selection from naming skips Expose separate naming and selection skip counts on target summaries. Show each applicable remedy in target details and sync previews so ambiguity keeps its filter/override guidance alongside naming and collision hints. * fix(list): include disabled rows in tracked repository counts Count the complete inventory that list displays, including ignored skills and physical variants, without changing the enabled counts used by status, install, or sync. Clone rows before counting to preserve disabled state. * docs: align variant counts and routing recovery guidance Show logical skill and physical variant counts in list/install documentation and keep the four translations aligned with the filtering examples. Explain that agent-named skill parents keep ordinary nested skills and retain the devcontainer-only runbook environment. Removal warnings now recommend a source-local override, since include filters cannot undo agent routing. * fix(mcp): preserve explicit target restrictions on nested variants Limit the differently routed child exemption to automatic layout inference. Frontmatter targets and dashboard source-local overrides must still prevent a parent from publishing files explicitly restricted to another target. * fix(ui): fill target name in naming warning guidance Pass the current target name when rendering localized warning hints so the same naming guidance shown beside the controls does not expose a placeholder in the warning banner. Verified in the populated target preview. --------- Co-authored-by: Willie <egg358358@gmail.com> |
||
|
|
23c9453f87 |
fix(update): serialize checkout updates across skillshare processes (#666)
Two dashboards (or a dashboard and the CLI) serving the same source ran "Update all" at once. The server mutex only covers one process, so both pulled into the same checkouts: one saw the other's half-applied merge as "local changes would be overwritten", and concurrent fetches into a blob:none clone failed with "fetch-pack: invalid index-pack output". update.TrackedRepo, install --track --update, and the in-place pull of a git-installed skill now hold a flock in the checkout's git directory; a second process waits up to a minute, then fails with a clear message. Force on a git-installed skill only skipped the local-modification check and then ran a plain pull, which refused to merge over the edits the docs say --force discards. It now fetches and resets to upstream, so a failed fetch still keeps the edits. Followed checkouts keep pulling, since they must be clean and may hold the user's unpushed commits. The pull error dropped the file list git indents under it, and the finished-update subtitle said everything was up to date even when items had failed. |
||
|
|
89ae7068d5 |
fix(config): honor OMP agent directory for default skills path (#652)
* fix(config): honor OMP skills directory overrides OMP reads global skills below PI_CODING_AGENT_DIR, but unpinned built-in targets still selected the default home. Resolve that runtime default without changing the canonical template used to derive named accounts. Keep account scan paths independent of the override and document explicit path precedence in target guidance and its existing translations. * fix(config): preserve inferred OMP paths across saves Saving an unpinned OMP target serialized its resolved skills path, so a later agent-directory override no longer selected the native location. Track this fallback with the existing derived-path marker so config saves preserve its inferred status while explicit paths remain pinned. Cover save/reload after environment changes and filter edits, and fold redundant account and project-alias checks into their existing cases. * docs(config): clarify when OMP skills paths stay fixed Initialization and target addition save their selected destination, while an OMP entry with no configured skills path follows later environment changes. Clarify that distinction in public and built-in target guidance and all four existing translations. Keep project alias coverage in its existing owner test and remove redundant OMP matcher and generic save assertions. * test(config): normalize explicit OMP account paths The explicit-path fixture combines a native temporary root with a forward slash suffix. Clean the actual path for comparison so mixed separators match the native expected path on Windows, retaining the original path in failure output. * test(config): use portable OMP whitespace override fixture Windows normalizes a directory component ending in a space during native absolute-path resolution. Use a leading-space component to preserve the check that override values are not trimmed without depending on trailing space filename behavior. * fix(config): preserve default OMP home in account shells Keep plain OMP skills on the canonical home when its environment override matches a declared account, so the unfiltered default target cannot bypass account filters. Share account-aware defaults with discovery and dashboard selection, and keep canonical account templates separate from runtime homes. Require an OMP install before automatic detection because Pi shares the same override. Trim surrounding whitespace, ignore relative overrides, and retain explicit saved paths. Cover account filtering, aliases, symlinks, saves, discovery, and existing environment-selected file homes with regressions. |
||
|
|
ee96aeea56 |
fix(config): keep env-derived default skills paths on save (#662)
A pathless deepseek-harness or gitlab-duo target resolves its skills path from DSH_HOME, GLAB_CONFIG_DIR, or XDG_CONFIG_HOME, and the docs promise it keeps following those overrides. decodeConfig filled the omitted path in, though, and the next save (editing filters, changing mode) wrote it back as an explicit path, so later environment changes were ignored. Mark a default that came from targetConfigHome as derived, reusing the mechanism that already keeps config_dir paths out of the saved file. Closes #661 Release-As: 0.27.1 |
||
|
|
eb9b2b28f9 |
feat(plugin): add --all flag to plugin update and enable antigravity-cli updates (#656)
* Add --all flag to plugin update and enable agy Add -a/--all to skillshare plugin update so users can update all tracked plugins in a single command without tying slow target CLI runs to skillshare update --all or sync --all. - Reject --all outside plugin update or when combined with a plugin name or --source-ref - Share source repository discoveries and discovery errors across the Preview and Apply lifecycle via Service.WithDiscoveryCache so multi- plugin marketplaces are cloned at most once per command - Isolate source, manifest, and target failures per binding when --all is active so healthy plugins update while partial failures exit non-zero and leave failed bindings unchanged in config.yaml - Skip unfiltered OMP bindings during --all updates so sibling targets on the same package still update without failing the batch - Enable plugin update for antigravity-cli while skipping disabled plugins when agy extensions list reports an entry as disabled Closes #653 * Add plugin update --all to docs and completions Advertise -a/--all for skillshare plugin across all five shell completion scripts and document the bulk update workflow and antigravity-cli update support in the user and built-in skill docs. - Add --all and -a to plugin completions in bash, zsh, fish, PowerShell, and Nushell with TestPluginCompletionsIncludeAllFlag - Document update [NAME | --all], -a/--all, and antigravity-cli source updates in website/docs/reference/commands/plugin.md (and its zh-Hans, zh-Hant, ja, and ko translations), sharing-plugins.md, and quick-reference.md - Document plugin update --all and antigravity-cli enablement checks in skills/skillshare/references/plugins.md * Require known enabled state for native updates Require a matching EnabledKnown && Enabled inventory entry before updating copilot or antigravity-cli bindings, and align the localized plugin workflow pages with the English docs. - Skip copilot and antigravity-cli updates in Service.Preview and refuse reinstallation in applyNativeTarget when the binding is absent from native inventory or not known to be enabled - Cover absent native inventory in TestAntigravityCLIUpdateRespectsEnablement - Synchronize plugin update [name | --all] and Antigravity CLI update guidance across the ja, ko, zh-Hans, and zh-Hant copies of quick-reference.md and sharing-plugins.md |
||
|
|
efc492fd7a |
fix(update): audit tracked candidates before publication (#647)
* fix(update): audit tracked candidates before publication Prevent rejected tracked-update bytes from becoming readable through published target links by staging and auditing a private candidate before updating the active checkout. Publish the exact approved revision without a second upstream pull. Preserve sparse state, audit metadata, followed checkouts, and compatible edits. Recover staged and unstaged changes after failed forced publication, including deletions, renames, and sparse exclusions. Cover the boundary deterministically and align error messages and localized documentation. * fix(update): preserve local bytes across Git line-ending conversion Overlay dirty worktree bytes after staging candidate patches so core.autocrlf does not silently rewrite local edits. Cover staged, unstaged, and cancelled worktree changes while retaining their index state. Make permission-failure coverage explicitly POSIX-only and compare private checkout contents to their original bytes. Align red-team assertions with candidate rejection and register private temporary cleanup with the raw-write guard. * test(install): normalize checkout after configuring line endings Windows fixtures initially inherit core.autocrlf=true. Reset the isolated checkout after selecting the subtest setting so changing it to false does not turn untouched upstream files into local edits. |
||
|
|
cbcb7a21ab |
refactor(sync): build agent ignore reports from the synced snapshot (#611)
Dashboard sync and project sync JSON scanned the agents source again just for the ignore summary. Carry the full discovery snapshot through sync so the response describes the agents that were synced, including ignored ones. Skills-only syncs keep the existing fallback scan. Cover the handler and project JSON paths when the source changes after discovery. Check syncProject returns ignored agents and an empty discovery stays non-nil through execution, so neither path silently rescans. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
5729eee088 |
feat(project): manage global registrations from the CLI (#603)
Add global project list, show, add, edit, sync and remove so setup scripts can register repositories without editing YAML or opening the dashboard. Keep dry runs read-only and report completed work when a target fails. Reuse the shared project service and sync runners. Include command docs, translations, completions and regression coverage. Quote overlap hints for their shell and log partial project syncs consistently with ordinary sync. |
||
|
|
2e22257520 |
fix(check): report failed update checks as failures (#643)
Return nonzero exit status for failed skill and agent checks while preserving JSON results. Propagate agent remote errors and prioritize dashboard check failures over the up-to-date summary. Add regression coverage and document exit status in all command reference locales. Related to runkids/skillshare-app#85. |
||
|
|
6ea5b91843 |
test(server): cover selected global config in dashboard log handlers
The handler test used the default test config directory, so it passed without the oplog routing fix. Select a config in a folder named skillshare so list, stats and clear prove they use the state-dir log. Refs #609 |
||
|
|
61eedffe1e |
fix(oplog): keep selected global config logs in the state dir (#609)
SKILLSHARE_CONFIG can select a global config in a directory named skillshare or .skillshare. Treating it as a project config puts logs and a .gitignore beside the shared config and labels global logs as project logs. Exclude selected and read-only global config paths from project routing. Share the check with the log command so readers and writers agree. Run the legacy config regression explicitly in Windows CI so it is exercised without enabling unrelated tests that still need Windows fixes. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
3cb1fa4984 |
test(plugins): require JSON flag in native lifecycle inventory
Match the complete plugin list --json command so dropping the JSON flag no longer passes the native lifecycle test. |
||
|
|
fad3305060 |
fix(plugins): support native JSON array for Antigravity CLI inventory (#640)
Pass --json to agy plugin list and parse the top-level JSON array returned by the Antigravity CLI. Keep fallback handling for empty text output and legacy wrapped envelopes. Closes #639 |
||
|
|
1a79971df4 |
feat(ui): show skill descriptions in the list and redesign package rows (#635)
* feat(ui): show skill descriptions in the list and let expand all open packages Reviewing a large library meant opening each detail page just to read what a skill does (#627, proposal in #631). The resources list response now carries each skill's and agent's frontmatter description, read in the same pass as manual-only, and the list shows it truncated under the name with the full text on hover. The read now decodes the frontmatter once for both fields. An unquoted ": " in a description is invalid YAML, so a failed decode falls back to the line scanner instead of dropping the description and manual-only. Editing a skill refreshes the list too, so the new description shows right away. Expand all / Collapse all also opens and closes nested-skill packages from #624; before, it only touched source and folder groups. Closes #627 * feat(ui): redesign list packages as an inset panel with a description switch The chevron-in-a-column nesting read as a second, unrelated table and gave no room for the descriptions #627 asks for. A count pill after the package name now opens its skills in one quiet inset panel, with deeper packages indented under a faint guide, so the hierarchy stays readable at any depth. The rest closes the gaps left against #627: a Show > Descriptions switch keeps the compact list one click away, keyboard focus reveals the full description, a search opens only the packages holding a match without overwriting what the user left open, and the selection bar says how many selected items are out of view. Only the name opens the detail page, since whole-row clicks were easy to trigger by accident once rows held more text. * fix(ui): keep linked-folder matches when searching a folder group Searching while grouped by folder took package ancestors only from skills whose folderOf matched the group key, but groupByFolder keys a linked folder's skills by the link name. Every skill in a linked folder fell out of its own group, so the header counted a match and drew no row. The ancestor pool is now each folder group's unfiltered skills, keyed by groupByFolder itself, which always contains the group's matches. * fix(ui): keep the .ss-r .nm.m rule the design token export reads Merging it into :is(.ss-r, .ss-nr) .nm.m removed the exact selector that scripts/design/tokens.py looks up for the row name type scale, so the design token tests failed in CI. |
||
|
|
51cecbeab4 |
test(testutil): align sandbox paths with symlinked temp dirs (#610)
On macOS, TMPDIR sits under /var, a symlink to /private/var. Sandbox paths kept the unresolved form while the CLI reports canonical paths, so tests needed per-case EvalSymlinks workarounds. NewSandbox now resolves its root once. RunCLIInDir and RunCLIInDirWithInput pass an explicit Env, so os/exec does not set PWD and the child inherits the test process's PWD. The CLI then falls back to getcwd and reports the canonical path even when invoked through a symlinked directory, unlike a real shell. Set PWD to the requested dir so the helper matches shell behavior. The affected integration tests now create explicit symlink aliases so they keep covering aliased working directories and config paths. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
2d196c286b |
feat(check): show what changed in a skill since install (#623)
* feat(check): show what changed in a skill since install #622 made a hand-edited skill visible as modified and kept update from overwriting it, but there was still no way to see the edits before deciding to keep or discard them (#621). LocalChanges compares the skill's files with the hashes recorded at install, fetches the source at the recorded commit only when a recorded file changed, and diffs each file against it, so the diff shows the user's edits even after upstream moves on. A skill without a recorded commit is refused rather than diffed against HEAD, which would show upstream changes as the user's. It backs `check <name> --diff`, GET /api/resources/{name}/local-changes, and the dashboard: the Modified locally dialog on the skill page lists the diffs, and the Updates tab links a modified skill to it. update's skip hints now point at --diff. The route looks up the exact record and refuses non-local names, so a nested or ../ path cannot borrow a top-level skill's record or read outside the source. The file diff helper moved to textdiff so the CLI and server share it. * fix(install): diff local changes against the full installed commit entry.Version holds the short SHA from `rev-parse --short`. A targeted fetch needs the full SHA, so checkoutCommit fell back to fetching every branch and tag with --unshallow: viewing one edited skill could download the repository's whole history, and fail when the commit is only reachable by its full SHA. Use entry.Commit, the full SHA install records, when it is the same commit as Version; a Commit left from an older install, or a legacy record without one, falls back to Version. * test(install): keep checkout line endings when editing in LocalChanges test On Windows git checks the installed copy out with CRLF, so overwriting SKILL.md with LF content made every line differ and the expected diff failed. Edit the installed file in place, as an editor would, and compare the diff without carriage returns. |
||
|
|
7a7cceefab |
feat(update): flag and protect skills edited since install (#622)
* feat(update): flag and protect skills edited since install A skill installed from a repository and then edited by hand looked exactly like an untouched one: check said up to date, and update either reported it current or silently reinstalled it over the edit (#621). Install already records each file's hash, so check now compares a remote skill's files with those hashes and reports "modified", and update skips such a skill until --force (CLI single, --all/--group, dashboard). --force, the dashboard's Force Retry on the skipped row, or the confirmation on the skill page discards the edit and reinstalls. Two hash paths had to be made reliable for this to be trusted: the dashboard's folder-wide target edit refreshed hashes by basename, so a nested skill looked edited after skillshare's own change, and a skill whose files cannot be hashed now counts as modified instead of being overwritten. * fix(server): keep earlier local edits when a target change rewrites SKILL.md Changing a skill's targets in the dashboard rewrites its SKILL.md, and both the folder-wide and the single-skill handler then re-hashed the whole directory as the new baseline. An edit the user had already made to any file in the skill was absorbed into that baseline, so the skill stopped counting as modified and the next update overwrote the edit without --force. Both handlers now move only SKILL.md's recorded hash, and only when the file still matched it before the rewrite. skillshare's own target edit no longer reads as a local change, and an earlier edit still does. The whole-directory refresh helpers lost their last callers and are removed. |
||
|
|
265f518cc4 |
fix(version): refetch the skill version when a newer CLI release is cached (#620)
The skill and CLI version checks keep separate 24-hour caches. The CLI check refetches once the installed version catches up with its cache, but the skill check did not, so right after a release the dashboard, status and doctor could offer the CLI update while calling the built-in skill up to date. Both ship in the same release, so a cached CLI release newer than the cached skill version now means the skill cache predates the release. |
||
|
|
330114bd6a |
fix(install): use frontmatter names for generic skill directories (#617)
* fix(install): use frontmatter names for generic skill directories Resolve meaningful defaults for generic containers while preserving explicit names, tracked paths, existing update destinations, and directory-based source selection. Fall back on unsafe or colliding names to prevent overwrites. Cover global and project installs, local and Git sources, naming overrides, tracked reports, collision safety, and updates. Closes #616. * fix(install): preserve names during source-based updates Resolve source-based updates against existing metadata before choosing destinations. Reject ambiguous or colliding update targets before writes, and reserve case-insensitive discovery names across filesystems. Add global/project regressions for local and Git source updates, legacy destinations, grouping, and upstream-added collisions. * fix(install): retain update ownership and selection checks Only allow a metadata-verified same-source update to bypass destination conflicts. Reject occupied fallback destinations for both local and Git sources unless overwrite is explicitly forced. Resolve destinations after skill selection so unrelated conflicts do not block filtered updates. Cover cross-source and unmanaged destinations, selected/excluded updates, and collision aborts in global and project modes. |
||
|
|
d23a44aec9 | refactor(projects): share safe dashboard and CLI operations (#602) | ||
|
|
dabe06a297 |
feat(targets): support OpenCode config directory accounts (#594)
* feat(targets): support OpenCode config directory accounts OpenCode v2 introduces support for custom configuration directories via OPENCODE_CONFIG_DIR, storing opencode.json and agent directories. Previously, skillshare rejected OpenCode accounts configured with a custom config directory because OpenCode was missing config_dir and was excluded from accountAgents in hooks and MCP services. - Define default config_dir (~/.config/opencode) in targets.yaml - Add OpenCode to account agents and register OPENCODE_CONFIG_DIR across hooks and MCP service handlers - Route OpenCode account MCP configuration to opencode.json inside the account config directory Resolves #593. * fix(targets): add OpenCode to schemas, completions and docs Add opencode to the targetConfig.agent enum and config_dir description in schemas/config.schema.json so configurations containing OpenCode account targets pass schema validation. Include opencode in the target --agent completion scripts for Bash, Zsh, Fish, PowerShell, and Nushell. Update website documentation and built-in skill references to describe OpenCode accounts and OPENCODE_CONFIG_DIR management alongside other account agents. * fix(targets): support plugin accounts and overlap Add OpenCode account recognition and OPENCODE_CONFIG_DIR resolution to the plugin service so plugin sync works for OpenCode account targets. Introduce TargetScanPaths to resolve cross-runtime scan paths using TargetConfig.Agent for account targets while retaining the account's own primary directory. Update path overlap detection, doctor checks, and LeakedSkills to warn about leaked skills for account targets. Update localized docs (zh-Hans, zh-Hant, ja, ko) and plugin references to document OpenCode account targets and OPENCODE_CONFIG_DIR. Update the available targets handler test to expect OpenCode's configDir. * fix(targets): isolate OpenCode accounts and scan paths Reject OPENCODE_CONFIG overrides when operating on OpenCode accounts and clear OPENCODE_CONFIG in the account execution environment so plugin operations target the account directory. In TargetScanPaths, remap config-root paths to the account directory while preserving external scan paths like Codex's ~/.agents/skills. * fix(plugins): use account target in OpenCode update probe Pass c.Target instead of a hardcoded "opencode" when probing whether OpenCode supports plugin updates, ensuring account-configured CLI binaries and account environment variables are used during preview. * test(mcp): isolate XDG_CONFIG_HOME in account test service Isolate XDG_CONFIG_HOME to the temporary test directory in agentAccountService to prevent runner environment variables from leaking into TestAccountEnvOverrideDoesNotPruneDefaultHome when testing OpenCode account shell overrides. --------- Co-authored-by: Willie <egg358358@gmail.com> |
||
|
|
2bba224cdf |
fix(ui): update agents from the Updates tab and repo detail page (#601)
The Agents Updates tab updates through /api/update/stream, which resolved every name against the skills source, so agent updates failed there. The agent detail page names a tracked repo by its folder, which updateAgent did not resolve, so updating an agent inside a repo failed with "agent not found". The stream now takes a kind and routes agent names to updateAgent, which also resolves an agent repo folder under the agents source. The tab sends its kind to the stream and to Prune, and matches update results by kind and by the agent's path, so a nested agent is marked up to date after it updates. Closes #600 |
||
|
|
7b952c02a9 |
fix(update): honor accepted findings in dashboard tracked updates (#599)
* fix(update): honor accepted findings in dashboard tracked updates The dashboard ignored findings accepted through the CLI, so a tracked repo that `update --force` let through was blocked again on the next dashboard update, and every dashboard Force Retry had to be repeated. Regular skill updates in the dashboard already honored and recorded acceptances, so only tracked repos differed. Tracked-repo updates now always honor accepted findings and record the ones an override lets through, for both callers. The opt-in option and the AuditGate flag it fed are removed, since no caller turns them off. Dashboard agent tracked repos passed an empty source dir, so a nested repo kept acceptances in its group folder under a different key than the CLI. They now pass the agents source, as the CLI does. * fix(update): reload the agents store after agent repo refresh Dashboard agent tracked repos now refresh metadata in the agents source, but a metadata change reloaded the skills store, leaving the agents store as it was until the next request. Reload the store that matches the source. Every caller of update.TrackedRepo now passes a source dir, so the empty-dir guard and its doc no longer describe a supported mode. The new agent test reuses the tracked fixture instead of rebuilding it. |
||
|
|
e10304eb81 |
test(theme): enable Windows CI coverage (#589)
Correct Unix-only resolution expectations on Windows and pin terminal and renderer state so the package is deterministic. Add theme to the Windows test job to catch future platform regressions. Related to #344. |
||
|
|
829cbb176d |
fix(plugins): honor native OMP marketplace builds (#588)
* fix(plugins): honor native OMP marketplace builds Resolve OMP entries from their native marketplace when present and inspect package.json extension-only plugins. Keep target-specific source paths, marketplace identities and components so Claude adoption and hybrid manifests remain valid.\n\nShow separate builds in text discovery without changing logical JSON selection, and cover native precedence, invalid catalogs, manifestless and hybrid packages, global/project materialization and CLI output with regression tests. Update the plugin docs and existing translations.\n\nFixes #587 * fix(plugins): preserve native build metadata across consumers Keep OMP catalog versions in target discovery metadata and materialized marketplace entries so previews, cache guards, and native installs use the same version, including legacy catalog fallback. Cover catalog versions that differ from package manifests. Show each dashboard discovery target's own version, components, and source path instead of presenting a merged candidate as one build. * fix(plugins): avoid ambiguous shared build versions Derive candidate versions from agreement across supported targets and recompute after catalog overrides. No-Agent records and lists no longer inherit an arbitrary native build version; equal versions remain available and unknown versions stay unknown. Keep Cursor and Antigravity inventory target-specific when manifests disagree. Cover no-Agent preview and persistence, equal and unknown versions, catalog overrides, and mixed-manifest local inventories. Align English and translated plugin references. * fix(plugins): accept Pi extension manifests for OMP catalogs Reuse the existing OMP extension detector instead of requiring an OMP-specific manifest key. Native OMP accepts Pi extension manifests too, so the extra gate rejected supported native catalog entries. Cover Pi-only discovery with scoped package names and global/project materialization. Align the English plugin references and all existing translations. |
||
|
|
f6e7265414 |
feat(hooks): read hook code and scripts from files next to the config (#586)
* feat(hooks): read hook code and scripts from files next to the config
Code Agent extensions and command scripts lived as strings in
config.yaml, so a longer Pi extension or shell script was edited inside
a YAML block scalar with no editor support, and nothing type-checked or
linted it. A breaking change in an Agent's extension API went unnoticed
because the generated file is not part of any tsconfig.
A binding now takes `codeFile: path` instead of `code`, and a `files`
value may be `{from: path}` instead of the contents. Paths resolve
against the folder of the config that holds the entry and are read
every time the config is read, so the regular typecheck or shellcheck
can cover the real source. The revision and drift checks use the
resolved contents, so a file edited after a preview fails the apply as
stale.
Saving keeps the references: enable/disable, `hooks edit` and the
dashboard write `codeFile` and `{from}` back instead of inlining the
contents. JSON carries the contents plus `codeFile`/`filesFrom`, and an
entry echoed back with both must match the file, so an edit is refused
rather than silently dropped. Paths must stay inside the config folder
without symlinks, so a cloned project cannot pull in files from
elsewhere. References are taken from the YAML tree before one strict
decode, which keeps unknown-field checks and anchors shared across
bindings working.
Closes #585
* fix(hooks): refuse an emptied file sent with its reference
An empty files value stood for "contents not sent", so a file cleared in
the dashboard's Git YAML editor while its filesFrom reference stayed was
treated as unsent: the file was read again from disk and the save
reported success with the user's edit discarded.
A value read from {from: path} now keeps a dedicated mark until it is
resolved, so an empty value is compared with the file like any other
contents and refused when they differ. Code keeps using empty as unsent,
since a code binding can never be empty.
* fix(hooks): render referenced files as they are on disk
RenderNative rendered the contents the caller sent. The dashboard sends
the entry it loaded, so after a referenced file changed, View
configuration still showed the old contents while describing them as
what sync would write.
Render now drops sent contents for codeFile and {from} references and
reads every reference again, like preview and save. Draft, render and
config decoding are the only paths that take an entry, and all three now
resolve references.
* fix(hooks): accept file references in JSON entries and anchored values
Two inputs that config.yaml accepts failed to load elsewhere.
A `{from}` value carrying its own YAML anchor, aliased from another
binding, lost its anchor because the value node was replaced instead of
rewritten, so the alias no longer resolved. The node is now rewritten in
place with its anchor kept.
An entry JSON file (`hooks add|edit --file x.json`) could not write a
files value as `{"from": path}`, because JSON decoded straight into
string contents. Binding now decodes JSON files values as contents or a
reference, strictly, like YAML, so both entry formats and the Web API
take the same shapes.
|
||
|
|
36d04b526b |
fix(hooks): keep a YAML block scalar's final newline in entry files (#584)
ParseEntry trimmed the whole document before decoding it, which was
meant only to detect a leading `{` for JSON. The YAML branch decoded
the trimmed bytes, so a `code: |` block scalar ending the file lost
its final newline: under clip chomping the line break survives only
if it is present. A Pi or OMP extension added from such a file was
written without a trailing newline and failed formatters such as
`prettier --check`. JSON input was unaffected because its newline is
escaped inside the string.
The YAML branch now decodes the original bytes.
|
||
|
|
70ceacca9b |
feat(mcp): serve an Executor skill index from mcp serve --http (#583)
* feat(mcp): serve an Executor skill index from mcp serve --http Executor apps load remote skills with wellKnownSkills, but could only reach Skillshare's skills through a copy in Git, so an edit saved with apply_skill_edit never reached them without a commit and push. With --http, mcp serve now also answers /.well-known/agent-skills/index.json and the files it lists, built from the same catalog and token, so Executor sees an edit on its next check. The format is the one Executor's loader reads, not the agent-skills discovery draft v0.2. One skill that loader rejects fails its whole load, so the index leaves out skills it would reject (non-text metadata, license or allowed-tools, files over 2 MB, non-UTF-8 files, file names decodeURIComponent cannot handle, names used twice) and lists them in --check and on stderr at startup. Versions are digests of each skill's paths and file digests, and the output is stable while nothing changes, because the loader reads the index twice and compares the bytes. An index over Executor's file or byte limits answers with an error naming --target. Manifest files now record their path within the listing skill: a parent's entry otherwise took its nested skill's paths, which would have listed SKILL.md twice. The index route repeats the MCP handler's DNS rebinding check for loopback servers without a token. Closes #574 * fix(mcp): accept proxied hosts with a token and use Executor's app accounts Behind the documented TLS proxy, a loopback mcp serve sees the proxy's public Host, and the DNS rebinding check answered 403 even with a valid bearer token. The index route had it, and so did the MCP endpoint through the go-sdk's localhost protection. A rebinding page cannot send the token, so both checks now apply only when no token is set; the docs say a tokenless server behind a proxy needs a loopback Host. The Executor example used the account form apps 0.0.1-beta.90 removed (`{ accounts }` and `ctx.accounts`, now typed as never). It declares the token as an app account and reads ctx.app.accounts, in all five locales. The wellKnownSkills loader itself is unchanged at the v2 head (b98424d9). |
||
|
|
578790c416 |
feat(mcp): write per-Agent native fields from the source (#579)
* feat(mcp): write per-Agent native fields from the source Some MCP settings have no portable form, such as Codex's default_tools_approval_mode or Claude Code's per-server timeout. Sync kept them only while an entry survived, so a recreated entry (for example after a rename) lost them, and every machine needed them added by hand again. A server's `options` now holds these fields per Agent, and sync writes them as given. The field ledger that piOptions used is extended to every Agent, so sync removes an option it wrote once the source drops it, and reports a conflict when the Agent changed it since. Options are refused when they could break the entry or leak a secret: fields Skillshare writes (including portable names some Agents rename), values a native format cannot write back (null, arrays of tables), options.pi (piOptions covers Pi), disabled entries, and credentials as plain text, since the Agent's file may be committed. The dashboard has no editor for options yet but keeps them on save. Refs: #578 * fix(mcp): close gaps in per-Agent options found in review - A credential option passed if it merely contained "${", so text around a reference, or another Agent's syntax, was written out as plain text. It must now be a whole-value reference in the Agent's own syntax, and Codex and Antigravity options, which read no references, cannot hold one. - The Kilo Code project check looked only at portable env references, so an {env:VAR} in options reached a project file Kilo refuses to load. - A replace resolution left the dropped-option conflict in place, so the plan stayed blocked; replace now lets the source win and prunes those fields. - Adopting an entry that already matched skipped writing its options until a later sync; the takeover now writes them. * fix(mcp): refuse numeric credentials and constrain option values in the schema - YAML reads an unquoted secret such as clientSecret: 123456 as a number, which the credential check skipped, so sync wrote it out as plain text. A mapping under a sensitive name such as credentials also hid its plainly named fields. Sensitivity now carries down through mappings and lists, and a number under a sensitive name is refused. - The schema allowed any value inside an Agent's options, so editors accepted null or nested lists that LoadSource then rejects. A recursive optionValue definition now matches the runtime rules. * docs(mcp): name every Agent whose options cannot hold a credential The docs named only Codex and Antigravity, but Claude Desktop, Goose, Junie, LM Studio and Warp read no environment references there either, so a source such as options.goose.apiKey: "${GOOSE_KEY}" looked valid while LoadSource refused it. |
||
|
|
4a5dacac6b |
feat(mcp): let mcp serve clients edit listed skills (#577)
* feat(mcp): let mcp serve clients edit listed skills A remote assistant that reaches skills only through `mcp serve` could read them but had to hand every change back to a person (#540). Skills listed in `mcp.serve.edit.skills` can now be changed one existing file at a time: `preview_skill_edit` writes nothing and returns the full diff, the audit result and a preview id, and `apply_skill_edit` saves exactly that preview, once. Every save is tied to the revision the client read, so a file changed in the meantime fails with a conflict instead of being overwritten. Skills that `update` would overwrite stay read-only: tracked repos, upstream installs, and skills nested inside an install. The skill is validated and audited in a temporary copy before anything is written; as with install, a finding at or above `audit.block_threshold` refuses the edit unless it was accepted with `--force`, and findings are marked new or existing so the client can see what its change adds. The write is atomic, keeps the file mode, goes through sourcefs link checks, and is recorded in the operation log. Native Skills extension clients still see the edit tools, since the extension cannot write. * fix(mcp): close gaps in mcp serve skill editing Codex review of #577 found five ways the edit tools could do more, or record less, than they promise: - A blank pattern in mcp.serve.edit.skills was dropped by the filter, and no patterns match every skill, so `skills: [' ']` made every skill editable. Blank patterns are now a config error. - preview_ttl was only checked when skills were listed, so the dashboard could save an invalid value that later stopped mcp serve. It is now checked whenever edit is present. - Apply compared only the edited file's digest, so two previews of different files, or an edit made elsewhere in between, could save a skill state that was never validated or audited. Apply now checks and audits the skill again as it will be saved. - Edit audits were not written to audit.log, so blocked attempts left no trace in `skillshare log --audit`. Each preview and apply audit is now logged like install's audit gate. - The writability check migrated legacy metadata, so a "writes nothing" preview (and --check) could rewrite .metadata.json and delete registry.yaml. It now reads the store without migrating; a legacy registry.yaml keeps every skill read-only, and a legacy sidecar marks its skill as installed. |
||
|
|
fdca87a1ff |
feat(mcp): mark the mcp serve skill tools read-only
Clients and gateways that gate tools by annotation treat a tool without readOnlyHint as one that changes data. Executor v2 does, so every list_skills or read_skill call could stop for approval even though both only read the skills source. Marking them read-only lets those clients call them without asking. Refs: #540. |
||
|
|
0c69dad6c2 |
fix(update): stop trusting tree hashes for skills with symlinks (#573)
* fix(update): stop trusting tree hashes for skills with symlinks Install copies a file symlink's target, but git stores the link as a blob holding the target path, so a skill's subtree hash stays the same when a target outside the folder changes. Batch update skipped such skills as current and check reported them up to date, leaving stale content installed. A subdir that holds a symlink now has no usable tree hash: install records none, update falls back to a reinstall, and check reports the skill as update_available. Check lists entries with -z so links with non-ASCII names are not missed behind git's path quoting. Closes #572 * fix(check): split ls-tree -z output on NUL only parseLsTreeOutput also split on newlines so the old newline fixtures kept passing, but with -z a newline belongs to the path. A directory or symlink whose name holds a newline was cut in two, and a symlink under it was missed. The fixtures now use NUL-terminated entries like real -z output. Also writes both shortcut comments in the repo's one-line form and uses testutil.RunGit in the new update test instead of a raw exec call. * docs(update): note that skills with symlinks always reinstall The update page says grouped updates leave skills whose folder did not change alone. A skill with a symlink no longer has a usable tree hash, so it is reinstalled whenever the upstream commit moves. State that exception on the English page and its four translations. |
||
|
|
c4b183f6ef |
fix(update): read store in batch fast path (#569)
* fix(update): read store in batch fast path The grouped update fast path read per-skill .skillshare-meta.json sidecars. The migration to .metadata.json deletes those files, so the check never matched and update --all reinstalled every skill on every run. Read the central store instead, and refresh version and commit there instead of writing a sidecar. Require SKILL.md on disk so the update restores a deleted install. --force now skips the check and reinstalls everything. * test(update): cover legacy grouped metadata keys Grouped skills can still be stored under a basename key with a Group field. Check that the current-skill lookup finds that entry and that the version refresh updates it in place instead of adding a new key. * feat(update): report up-to-date skills The summary lumped skills the fast path skipped in with failures. Count them as "up to date" in the summary and as up_to_date in --json output. * feat(update): log up-to-date count in oplog The operations log recorded updated, skipped, pruned, and blocked counts for update but not the new up-to-date count. Record it as up_to_date so the log matches the summary and --json output. * test(update): cover up-to-date batch skills update --all reinstalled every grouped skill on every run. Check that unchanged skills report as up to date in global and project mode, that an upstream change updates only the changed skill, and that --force reinstalls everything. * docs(update): describe up-to-date batch skills Describe how update --all and --group leave unchanged skills alone and report them as up to date, the up_to_date JSON field, and the new meaning of --force. * fix(update): keep lock pins on tree-only matches A tree-hash match after upstream HEAD moved refreshed the full commit in the store. A project lock pin follows that field, so an unrelated upstream commit rewrote skills.lock.json even though the skill's files did not change. Refresh only the version, as the old sidecar refresh did. check compares the version, so it still reports the skill as up to date. The help text, docs and skill reference said --all and --group skip current skills. The skip lives in the batch path, which runs for any update of several skills, and a single skill always takes the reinstall path. Say that instead. * fix(update): load the store once per batch Each skill skipped as current reloaded .metadata.json before comparing its version, so an unchanged batch reparsed the whole store once per skill. Compare the version already read from the snapshot first, and refresh the skills that do lag HEAD with one load and save after the loop. An unchanged batch of 400 skills drops from about 520ms to 64ms. The help text and docs said any update of several skills takes this path. In global mode, named and glob targets carry no metadata and reinstall on the standalone path. Name what does take it: --all, --group, and several skills named in project mode. --------- Co-authored-by: Willie <egg358358@gmail.com> |
||
|
|
fe92a50b1b |
fix(upgrade): preserve UI assets for the pre-upgrade version (#571)
An already-running UI server still reads lazy-loaded chunks from its versioned cache after the CLI binary is upgraded. Preserve the pre-upgrade version alongside the downloaded version so upgrade cleanup does not break page navigation. Add a multi-version cleanup regression test and document the retention policy and accepted consecutive-upgrade limitation across all website locales. |
||
|
|
1094668408 |
fix(install): keep git tokens out of process arguments (#566)
Token auth rewrote the clone URL with url.<user>:<token>@host.insteadOf. git hands the rewritten URL to git-remote-https as an argument, so any user on the machine could read the token with ps for as long as a clone or fetch ran. Every platform token (GitHub, GitLab, Bitbucket, Azure DevOps, Gitea, CNB) went through the same rewrite. git now gets the token from a credential helper scoped to the host, which reads it from SKILLSHARE_GIT_AUTH_PASSWORD; printf is a shell builtin, so the token never reaches an argv. An empty helper entry first clears the user's own helpers for that host, so git neither asks their keychain nor erases from it on a 401, and no longer stores the skillshare token there as the URL rewrite did. An http.extraHeader was tried first and dropped: the header goes out before any 401, so a stale token broke installs from public repos, and after a rejection git fell back to the user's helper and erased their stored credentials. Refs #565 |
||
|
|
ac1d4b4387 |
fix(list): show every target sync placed a skill or agent in (#562)
* fix(list): show every target sync placed a skill or agent in The Targets row of the list detail panel only looked for a symlink named after the skill's flat name in the target's skills folder. It therefore left out targets that sync fills in copy mode, targets linked whole in symlink mode, targets using standard or prefixed naming, and every agent target (agents were looked up in the skills folder). Targets with skills turned off were still listed. The row now asks sync's own name resolution and manifest which entry a target holds for the skill, and checks agents in their resolved agents folder by mode or extension output. Each target is resolved once per load so moving through a large source under standard naming stays fast. * fix(list): drop a skill's targets as soon as it is disabled in the TUI Pressing t updated the row's disabled flag but not the discovered skills that sync's name resolution reads, so the open list kept showing the skill's targets while a reopened list, which rediscovers it as disabled, showed none. The toggle now updates that flag too, so both agree: a disabled skill lists no target, since the next sync removes its entries. |
||
|
|
6cc790965a |
feat(mcp): pin tool definitions in mcp check --live and warn when they change (#560)
* feat(mcp): pin tool definitions in mcp check --live and warn when they change An Agent reads a server's tool names and descriptions as instructions, and a server can change them after the user reviewed it (a "rug pull"). The MCP spec 2026-07-28 local-server security guide notes the protocol does nothing about this and advises clients that re-prompt on a changed definition; most clients do not. `mcp check --live` now records one SHA-256 per tool over name, description and inputSchema the first time a server answers, in mcp/tool-pins.json of the state directory, keyed by scope and server. Later probes report a changed or new tool as a `tool-change` warning and a removed one as info, until `--accept-tools` (only with --live) records the current definitions. Without --live the pins are never read or written. An unreadable pin file is never rewritten, since it may hold other servers' pins. The dashboard words both warnings in every locale. * fix(mcp): keep schema numbers exact, name the scope to accept in, and log acceptance Codex review on #560: - Tool definitions were decoded through float64 before hashing, so a schema bound changed from 9007199254740992 to 9007199254740993 hashed the same and raised no warning. Numbers now keep their literal text. - The suggested accept command left out -g/-p; run from inside a project after a global check, it would accept the project's server instead. It now names the scope of the check that warned. - Accepting changed tool definitions approves a possible rug pull, but left no record. --accept-tools now writes an operations log entry with the servers it accepted. * fix(mcp): log a tool acceptance only when its baseline was saved Codex review on #560: when comparing succeeded but writing tool-pins.json failed (lock held, state directory unwritable), the report kept its "accepted" finding, so the operations log listed the server as accepted with status ok although its old pins remained. Such a server is now logged under `failed` and the entry's status is error. * fix(mcp): log first pins as accepted and report errors in the accept entry Codex review on #560: - A check that accepted one server but found an error on another still logged status ok, while the command itself exited 1. A server with an error is now listed under `failed` and the entry's status is error. - --accept-tools on a server's first probe records its baseline, but the finding says "pinned", so the entry listed nothing as accepted. A first pin counts as accepted now. * chore(release): request version 0.25.11 The MCP pin checks (#559, #560) and the backup staging fix (#558) ship as 0.25.11 instead of the computed 0.26.0, per maintainer decision. Release-As: 0.25.11 |
||
|
|
4382a8c8c8 |
feat(mcp): warn when a local server runs an unpinned package or image (#559)
* feat(mcp): warn when a local server runs an unpinned package or image An entry such as `npx -y some-mcp` fetches whatever the registry serves at every Agent start, so a compromised release reaches the machine on the next launch without anyone noticing. The MCP local-server security guide (spec 2026-07-28) names version pinning as a baseline and points out that a container tag can move while a digest cannot. `mcp check` now adds a `pin` finding from command and args alone, with no network: npx, uvx and `pipx run` with no version or `latest`, and `docker`/`podman run` with no tag or `latest`, are warnings; an image pinned by tag but not by `@sha256:` digest is info. Value-taking run flags are skipped so hardened lines such as `--cap-drop ALL` are not read as the image. Warnings keep the exit code at 0, as before. * fix(mcp): check every npx package, word pin warnings in the dashboard, document them in doctor Codex review on #559: - npx accepts --package more than once and fetches each one, but the pin check stopped at the first, so `npx --package=lodash@4.17.21 --package=cowsay cowsay` passed although cowsay is unpinned. Every --package/-p value is now checked. - The dashboard words env, command and dns findings in the viewer's language but showed the new pin warning in English. It now has its own sentence for an unversioned package and for an untagged image in every locale. The dashboard hides info findings, so the digest note needs none. - doctor promotes check warnings, so an unpinned launcher now shows there; its docs list the pin check. The mcp check runbook gains a step for the pin check. * fix(mcp): check uvx --with packages and ignore environment markers in pins Codex review on #559: - uvx --with (-w) installs each named package beside the tool, so an unpinned one moves just like an unpinned tool, but the pin check skipped it as a flag value. Every --with requirement is now checked next to the --from or command package. - In `--from 'mcp-server; python_version == "3.12"'` the == belongs to the environment marker, not to the package, yet it read as a pinned version. Only the requirement before ';' is inspected now. * fix(mcp): treat only exact versions as pins, and pin the docs' own examples Codex review on #559: - npm resolves a dist-tag (`@next`) or a range (`@^1.2.3`) to whatever release matches at launch, yet any selector but `latest` passed as pinned. An npx package is pinned now only by an exact semver version, the rule Pi bindings already use. - `==1.*` is a prefix match in Python version specifiers, so `uvx --from 'mcp-server==1.*'` can pick up a new 1.x release; it is no longer read as a pin. - The Context7, Playwright and filesystem examples in the docs and the built-in skill launched unpinned packages, so copying them produced the new warning at once. They now name the current registry version. |
||
|
|
cf5783ee88 |
fix(backup): reclaim abandoned staging directories safely (#558)
* fix(backup): reclaim abandoned staging directories safely Interrupted backup copies leave hidden .snapshot-* directories that retention cleanup never discovers. Hold a shared process lock during copies and use an exclusive cleanup lock to reclaim orphaned staging without deleting active work. Share retention planning with non-mutating dry runs, report busy manual cleanup in the CLI and API, and align dashboard messages and translated docs. Cover process interruption and automatic cleanup with regression tests and an executable E2E runbook. Closes #556 * fix(backup): address staging cleanup review findings Keep cleanup reachable for staging-only dashboard backups and disclose abandoned incomplete directory deletion in every confirmation locale. Cover the empty-state confirmation with a regression test. Read staging entries before a read-only lock probe so first-use dry runs cannot count a newly active writer. Refresh entries only under the acquired lock and classify both backup-root reads in the filesystem guard. * fix(backup): align cleanup guides and doctor status Disclose abandoned incomplete directory removal in backup help, completion descriptions, and the daily backup guide with all four translations. Add help and completion regressions so these consumers stay aligned with cleanup. Keep the doctor Backups row visible when only the persistent lock remains after cleanup, preserving the existing JSON check and covering the lock-only state. * fix(backup): complete cleanup documentation disclosure Cleanup reclaims abandoned incomplete directories regardless of retention, so retention-only summaries understated the action. Align the backup synopsis, option table and previews, related workflow guides, built-in reference and all four website translations. Scope the retention defaults to completed snapshots. |
||
|
|
bfc402fe96 |
feat(mcp): open an Agent's MCP config folder, and project files, from the dashboard (#554)
* feat(mcp): open an Agent's MCP config folder, and project files, from the dashboard A user who wants their own editor (Notepad++ on Windows) found setting both PATH and $EDITOR too much just to open a config file, and could not find any entry point for the MCP files of an mcp.projects root (#538). Each Agent row on the MCP page now also has Open folder, which opens the folder holding the file in the file manager, so any program can open it from there. Before the Agent has written its file, it opens the closest folder that exists. The project MCP tab gets the same Agents list for that project's files. The open endpoint resolves project paths from the config, as it does global ones, so a request still cannot name another file, and folder and file opens keep the same-machine and headless guards. The file manager launch is shared with the extensions folder. * fix(mcp): keep a project's existing Agent files listed for remote viewers Codex review: the project MCP tab built its Agents list from the project's targets plus the files this viewer could open. A viewer on a LAN address or behind a proxy can open none, so an existing file of an Agent outside the project's targets dropped off the list, although the docs say it shows with its path and only the open buttons go. The list now returns which files exist apart from whether this viewer may open them, and the page shows the open buttons only when local. * fix(mcp): list the Agents a project's own servers write to in its file rail Codex review: a server that exists only in one project can pick Agents outside the project's targets, and sync writes their project files, but the project tab listed only the project's targets and files that already existed. Before the first sync such an Agent had no row, so its path could not be copied and its folder could not be opened. The list now also takes the targets of the project's own servers. Global servers reach a project only through its targets, so they add nothing. The rule lives in mcpView as projectFileTargets, with a unit test. |
||
|
|
2d5849a0ef |
fix(config): keep YAML anchors and aliases when a command writes the config (#551)
* fix(config): keep YAML anchors and aliases when a command writes the config Every writer re-encodes the in-memory struct, which has no anchors, so a command such as `target a --add-exclude` expanded `&shared` / `*shared` under targets and projects and the lists stopped following each other. The comment pass added for #525 already pairs each old node with the one that replaced it; relinkAliases uses the same pairs to put anchors back and turn unedited alias values into aliases again. An anchored node keeps its anchor and the aliases that still hold its old value follow its new value, as the file declares. An alias that was edited keeps its own list and leaves the anchored one alone. Output is sorted by name, so the anchor moves to the first place the group appears: an alias may not precede its anchor. Fixes #546 * fix(config): keep YAML merge keys when a command writes the config A command rewrites config.yaml from the Go struct, which holds the merged keys of `<<: *base` and not the merge itself, so every merge key was written out expanded and later edits of the anchored mapping no longer reached the mappings that merged it. relinkAliases already restored anchors and aliases from the old/new node pairing; relinkMerge now does the same for merge keys, including `<<: [*a, *b]`, merges in nested mappings and in project-config target items. A key stays written out when the old mapping set it itself, or when its value is no longer the one its merge source gives it. yaml.v3 merges are shallow, so such a key replaces the merged value as a whole and what is written always decodes to the config the command meant to save. A source that was removed, or that holds a key the mapping no longer has, is not merged back. Output order is not the old file's order, so an anchor that would follow its first merge key moves onto it (`<<: &base`). The next write pairs that mapping with the alias that still shows its value, so the file stays stable. The runbook steps for anchors now write their own config: mdproof re-runs the setup before each step, so step 7 and 8 never saw the config of step 6 (Codex review on #551). Steps for merge keys are added the same way. * fix(config): let edits of an anchored mapping that add or remove a key reach its mergers A command that added a key to an anchored mapping (the first `agents:` block via `target base --agent-mode copy`) made relinkMerge refuse the merge source: the merging mapping's pre-edit data lacked the key, which was read as "the command removed it". The merge key was dropped and the merger written out expanded, so later edits of the anchor no longer reached it. A source is now refused only when the merging mapping had a key before the write and the command removed it. A key the source gained does not count. The symmetric case is fixed with it: a key removed from the anchored mapping stayed written out under a merger that still held the old merged value. An unedited key that the merger did not set itself now follows the source that gave it, whatever that source now says (a changed value, a removed key, or the next source of `<<: [*a, *b]`). A key the merger set itself, or that the command edited, stays written out. Tests cover add, remove and change of a key on the anchored mapping and on the merging mapping, a key from either source of a merge list, nested merges, projects, project-config target items and chained merges. Runbook step 11 covers the real binary. * fix(config): keep every comment when a write relinks merge keys and aliases Rewriting a merge key replaced the original merge items and covered keys with new nodes and carried over only the comments of the key and the list itself, so a comment on an item of `<<:` followed by `- *a # note` was lost on any write, and so was the trailing comment of a removed key when the mapping was left with keys the merge supplies. Comments now follow the entry they were on: a merge item's to the alias that replaces it, those of an item that is no longer merged to the next item, and those of a key the merge supplies to the next key still written, or in front of the merge key when none is. The merge list keeps its flow or block style so item comments stay on their lines. Sweeping the rest of the relink paths for the same loss found more places where yaml.v3 drops or moves a comment: the comment after an anchor on a block mapping collided with its first key's comment, a line comment on a block collection or on a key with an empty value is not written, and an anchored collection's head comment moved on the next write. These are settled once on the written tree, and the body of an inline merge source gets its comments paired too. |
||
|
|
9e935b35fb |
fix(ui): accept a quoted editor path in $EDITOR (#553)
Open in editor split $VISUAL and $EDITOR on whitespace, so a Windows path such as "C:\Program Files\Notepad++\notepad++.exe" broke at the space and no editor was found. A user asked to open files in Notepad++, which is not on PATH by default (#538). Double or single quotes now keep a field together. Backslashes stay literal, since Windows paths use them. |
||
|
|
7ee08b913d |
feat(mcp): open an Agent's MCP config file from the dashboard (#552)
* feat(mcp): open an Agent's MCP config file from the dashboard Users asked to jump from the MCP page straight into a client's config file, such as opencode.json or .cursor/mcp.json, instead of copying the path and opening it by hand (#538). The open uses the same editor chain as a skill's Open in editor, so the dashboard opens files one way. The endpoint takes a target, not a path, and only opens a file the MCP page already lists. It answers only requests from the machine running the dashboard, because the editor starts on that machine. The list now reports which files exist, so the button is hidden for a client detected before it has a file. * fix(mcp): hide Open in editor where the server would refuse it Codex review: the dashboard can be opened through a LAN IP, but the open endpoint answers only loopback requests, so the button showed and every click returned 403, while the docs promised it would open. The list now reports `openable` instead of `existing`: the files that exist, and only when the request comes from the dashboard's machine. A viewer elsewhere does not see the button, and the docs say where it appears. * fix(mcp): don't treat a reverse proxy's viewers as local for Open in editor Codex review: the documented Nginx and Caddy setups connect from 127.0.0.1, so the loopback socket check let any browser behind the proxy see the button and launch editors on the server. The browser now counts as local only when the socket and the Host it used are both loopback and no proxy forwarding header is present. Both documented proxies keep the browser's Host and add X-Real-IP or X-Forwarded-For, so their viewers no longer qualify. |
||
|
|
656437c2b5 |
fix(sync): limit project adoption writes to moved skills (#548)
* fix(sync): limit project adoption writes to moved skills A stale install record could trigger a full project reconcile during sync, adding unrelated remote installs to the manifest, ignore rules and lockfile. Skip project writes when nothing was re-keyed, and update only moved declarations, ignore rules and existing pins while preserving full explicit reconcile behavior. Cover the visible project directory sharing its global source with byte-identical no-move checks and a real move that preserves unrelated entries and audit acceptances. * fix(sync): preserve existing move destination declarations The adoption-only config rewrite could duplicate a destination already declared in the project manifest. Keep that destination declaration and remove the moved old entry, matching full reconcile behavior while preserving the destination fields. Add a regression that fails with duplicate entries and passes with the existing destination branch retained. Re-run make check after the fix. |
||
|
|
ffdf9e57ab |
fix(plugin): stop evaluating Pi rules whose meaning depends on the Pi version (#549)
Pi 1.2.0 (earendil-works/pi#10765) runs normalizePath on resource-filter patterns before matching, so `~`, `~/`, `file://` and, on Windows, `~\` and Git Bash/MSYS/Cygwin/WSL drive paths now match files that older Pi never matched. Skillshare supports Pi 0.99.2 and later without knowing which one evaluates the rules, so it reported a definite selection that could be wrong and let the write guard reason from it. Such rules now evaluate as unknown, and the dashboard names the rule instead of a generic message. Exact rules also missed Pi's normalizeExactPattern in every version: a leading ".\" is dropped on all platforms and backslashes become slashes on Windows. Skillshare only dropped "./", so `-.\extensions\a.ts` looked unmatched and produced a duplicate missing row. |
||
|
|
fd18cda655 |
fix(plugin): read plugin sources through their real path on macOS (#544)
Adding a plugin from a Git URL to Oh My Pi on macOS was always blocked with "linked or non-directory OMP path component", which the dashboard shows as "The reviewed OMP runtime destination must be verified empty". The source is cloned into os.MkdirTemp, which lives under /var/folders, and /var links to /private/var. The OMP install check reads the source's package.json through ompSafePath, which rejects any linked component, so Skillshare's own temp clone failed it. A local source under a linked parent failed the same way. acquireRef now hands callers the resolved root of the temp clone and of a local directory, while the recorded source stays as given. Links inside the source are still handled as before; cleanup still removes the original temp directory. |
||
|
|
12dd041288 |
fix(plugin): accept OMP 18.6.1 and later instead of exactly 18.6.1 (#543)
* fix(plugin): accept OMP 18.6.1 and later instead of exactly 18.6.1 The OMP adapter pinned the native version to exactly 18.6.1, so every newer release was refused: the dashboard reported "Installation requires OMP 18.6.1" for a user on 18.8.7, and removal and standalone extension selection were blocked the same way. The sources the adapter depends on (marketplace cache/manager/types, plugin-cli output, the project anchor in discovery/helpers.ts, extension loading and the pi-natives file lock) are unchanged from v18.6.1 through v18.10.2, so the pin is now a minimum. The install, removal and selection gates share one check built on the existing plainVersion helper; unparsable, prerelease and older versions stay blocked. Messages, all dashboard locales, the plugin reference docs and the built-in skill now state 18.6.1+. A test keeps the English guidance text in en.json equal to the Go strings the dashboard matches on. * fix(docs): record the OMP 18.6.1+ boundary in the cache safety report The safety report still said installation is allowed only for OMP 18.6.1 and that an unknown version blocks it, which no longer matches the gate. It now states the minimum, which versions stay blocked, and the source comparison and native 18.8.7 run that justify replacing the pin. The two OMP runbooks no longer require exactly 18.6.1. |
||
|
|
f540daf601 |
fix(mcp): turn off a global server in OpenCode 2 projects (#541)
* fix(mcp): turn off a global server in OpenCode 2 projects
OpenCode 2 replaces a global server with the project entry of the same
name, and silently drops an entry without its type and command or url.
The project switch Skillshare wrote, {"enabled": false}, therefore left
the server on in OpenCode 2, while OpenCode 1 merged it by field.
Checked against OpenCode 2.0.27 and 1.19.0: OpenCode 2 still reads the
flat mcp.<name> shape and turns enabled: false into disabled: true, and
both read an entry with type and command or url. So no version detection
is needed. When the global config under mcp.projects defines the server,
the OpenCode switch now carries its type and executable, or its url
without the query, next to enabled: false. Args, env, headers and the
query stay out of a project file that may be committed, as the Pi switch
once did. A switch that already carries the endpoint keeps it when the
global server later leaves the config, unless it was edited since sync.
In project mode, or when the global config lacks the server, only the
bare switch can be written; the plan now says OpenCode 2 ignores it, in
the CLI and the dashboard.
Import also reads OpenCode 2's mcp.servers section, which its own
`mcp add` writes, instead of reporting it as one broken server.
Refs #538
* fix(mcp): keep secrets in a URL path out of the OpenCode switch
The OpenCode switch dropped only the query of the global server's URL.
Some MCP services put the key in the path instead, and an absolute
executable path names the user's home directory; both then reached a
project file that may be committed. A disabled server never starts, and
OpenCode 2 accepts any type with a command or url, so the switch now
carries only the executable's name or the URL's scheme and host.
Refs #538
* fix(mcp): skip OpenCode 2's timeout defaults when importing
OpenCode 2 keeps server defaults in mcp.timeout next to mcp.servers, so
import listed timeout as a broken server. It is dropped only together
with a recognized servers section, where it cannot be a v1 server.
Refs #538
* fix(mcp): read an empty OpenCode 2 servers section
An empty mcp.servers object was not recognized as OpenCode 2's section,
so import listed servers and timeout as broken servers instead of
finding no entries. The dashboard help for disabled also still said only
the switch is written, which is no longer true for opencode.
Refs #538
* fix(mcp): keep an OpenCode endpoint switch next to its own fields
The kept switch was matched by the whole native entry, so a field only
OpenCode reads, such as a per-server timeout, made the next sync drop the
type and command or url once the global server left the config, and
OpenCode 2 then ignored the switch. Match the fields Skillshare manages.
Refs #538
* fix(mcp): show the OpenCode endpoint switch in the dashboard preview
The dashboard renders a project's server alone, so the preview never saw
the same-named global server and showed the bare switch that OpenCode 2
ignores, while sync wrote the switch with the endpoint. Resolve the
global server the way sync does.
Refs #538
* fix(plugin): read OpenCode 2's version output
OpenCode 2 prints "opencode v2.0.27" for --version, while OpenCode 1
prints only "1.19.0". The adapter trimmed a leading "v" only, so plugin
sync to OpenCode 2 failed as an unrecognized version and imported
updates were skipped as if OpenCode 1 had no update command. Read the
last field, and decide the update check with the same parser.
Refs #538
|