The CLI and dashboard update a tracked repo through update.TrackedRepo,
which never looked for submodules. A pull that turned a skill directory
into a submodule reported success and the skill vanished on the next
sync. TrackedRepoResult now carries the skipped-submodule warnings and
both callers show them.
Refs #433
skillshare never fetches submodules, so a gitlink is an empty directory
after any clone. Installing that path reported success with nothing in
it, a path inside it failed with a misleading "does not exist", and
whole-repo discovery dropped its skills without a word.
Refuse a subdir that is or lies inside a submodule, naming the
submodule, its pinned commit and upstream URL, and warn for each
submodule skipped by whole-repo discovery and --track.
Refs #433
Release-As: 0.25.1
The pages added with the block modes covered what they write, not what
the review fixes made them do. The sharing guide still said sync
overwrites a modified target, which is wrong for a block: sync stops
until the edit is collected or the block is rewritten.
The guide, the extras reference and the built-in skill now cover the
block's Collect and Rewrite choices, block statuses, the target file
dialog, what a mode change removes, how restore treats a block, and
the cases a block target is refused. Common errors gains an Extras
section for the four new messages. The --mode help of extras init,
--add-target and the mode command listed only import among the
single-file modes; it now lists prepend and append too.
Refs #436
Review of the shared uninstall operation found that RemoveByNames still
matched a bare key: removing top-level "foo" pruned the legacy entry
"foo" with Group "frontend", which belongs to the installed
frontend/foo. Entries are now matched by their full path only.
Also from review: a dry run no longer runs git status for tracked
repos (it reports no git state), the unused Outcome.Removed is gone,
the two single-item handlers share one status mapping, and the CLI
reports a single target in one place instead of three flag checks.
Refs #442
The dashboard update of N tracked repos loaded the metadata store 2N times
under the server lock, and each load walks the whole source tree. The refresh
now returns before loading when the repo has no root SKILL.md, reports
whether it saved a change, and the server reloads its store only then,
through the existing reloadSkillsStore.
The CLI single-repo path tracked its output with two flags and a OnceFunc.
The caller hook now runs once for every outcome, so the spinner stop, the
discard warning and the pull summary live in one place and print in the same
order as before.
auditGateFailClosed rebuilt three of its messages by hand; they are
AuditGateError's own wording with another subject, so both now come from one
function.
Refs #443
The uninstall sequence (move-out check, dirty check, move to trash,
.gitignore cleanup, metadata prune) lived in the CLI and in three
dashboard handlers, and the copies had drifted: three different prune
rule sets, no dirty check on DELETE /api/repos, and no metadata prune
at all on DELETE /api/resources, which left the removed skill's entry
and target overrides in .metadata.json.
internal/uninstall now owns the sequence for resolved items. Callers
keep name resolution, prompts, output, HTTP status and oplog.
MetadataStore.RemoveByNames is the single prune rule set: an entry goes
when it is a removed path or lies below one, by key or by Group, plus
the tracked legacy group of a top-level repo.
Behaviour changes, all intended:
- DELETE /api/repos/{name} refuses a dirty tracked repo, or one whose
git status cannot be read, with 409 unless ?force=true.
- DELETE /api/repos/{name} refuses a followed link whose folder is
itself a skill, like every other uninstall path.
- DELETE /api/resources/{name} prunes the skill's metadata.
- Removing top-level "foo" no longer prunes "frontend/foo" (CLI), and
removing repo "_team" no longer prunes the untracked group "team"
(dashboard batch); both dropped metadata of skills still installed.
Refs #442
Updating a tracked repo is a fail-closed sequence: check for uncommitted
changes, pull, audit what was pulled, reset to the pre-pull commit when the
audit blocks. The CLI had two copies of the pull flow, the dashboard a third,
and the audit gate existed four times (CLI, dashboard, and two in install).
The copies had drifted: the dashboard ignored a failed git status and never
refreshed root-skill metadata, and each copy worded a failed rollback on its
own.
update.TrackedRepo now owns the sequence and returns a structured result;
install.AuditGate is the only gate. internal/update is a new package because
internal/git already imports internal/install. The CLI keeps its spinner,
rows and the "Apply anyway?" prompt, passed in as one Confirm callback; the
dashboard turns the result into its JSON item.
Behaviour changes, all towards the stricter copy:
- the dashboard reports a failed git status as an error instead of pulling;
- the dashboard refreshes root-skill metadata after an update, like the CLI;
- a prompt that fails rolls the update back instead of leaving it applied;
- the rollback-failed and rollback-unavailable texts come from one place.
Accepted findings stay as they were (CLI honours and records them, the
dashboard does neither), now as the explicit AcceptedFindings input. The
"blocked and rolled back" texts are unchanged per caller because the
dashboard matches on them.
Refs #443
Tools without an @import directive (codex, gemini, cursor) could only
take a shared instruction file as a symlink or copy, which replaces the
target's own file. Teams that want one shared AGENTS.md plus the user's
own notes in the same file had no way to express that.
prepend and append write the source into the target file as a managed
block fenced by skillshare:extra markers that carry the source path and
a content hash. Sync inserts the block once and then rewrites it in
place, status reports modified when the block body no longer matches
its hash, Collect copies the edited body back to the source, Reapply
rewrites the block from the source, and restore removes only the
block. Lines outside the block, and markers inside code fences, are
never touched. Several managed blocks (and an import line) may share
one target file; the connection validator only rejects a file when a
replacing mode (symlink, copy, merge) is involved.
Refs #436
The CLI, GET /api/check and the check stream each wrote out the same
sequence: group skills by URL and branch, ask the remote hash, skip the
tree fetch when every skill matches, otherwise compare tree hashes and
assign a status. A fix such as branch handling had to be made three
times, and the sequence could only be tested against real repositories.
internal/check now owns it as Plan and Resolution.Run, with the remote
hash source injected and a per-remote progress callback. The CLI
progress bar and the SSE counter are adapters on that callback; the JSON
handler passes none.
The callers disagreed in two places, and both behaviours are kept: the
dashboard reports a skill removed upstream as update_available where the
CLI says stale, and gives no source or version for a skill without a
remote. The server adapter narrows the result accordingly.
Refs #444
The CLI, GET /api/check and the check stream each carry their own copy of
the resolution sequence, and only its leaf helpers were tested. Pin what
each caller reports for every outcome, against local bare remotes, so the
copies can be merged without changing output.
Refs #444
The review fixes left the per-file size and digest split across two
packages: a stat-based budget in the walk, a second bounded read in the
catalog, a SKILL.md special case hashed once per file, and the digest
format written out three times. skillpkg.Load now reads every file once
within one package budget and records its digest and size, so the
catalog only maps them, and skillpkg.Digest is the one digest format.
Also: Build settles skills in one deepest-first loop, the skills/list
cursor uses sort.Search, ParseFrontmatterMap splits the file once, mcp
serve names each value flag once, and the migration report is not
called twice in main.
A non-loopback --http listener accepted a bearer token over plain HTTP,
so anyone on the path could read the token and the skills. Off loopback
it now also needs --tls-cert and --tls-key and serves HTTPS; loopback
stays plain, so a TLS-terminating proxy in front still works.
The first command after an upgrade reports legacy data it moved. For
mcp serve that notice landed on stdout ahead of the handshake, so it now
goes to stderr like serve's other messages.
A SKILL.md that opens frontmatter but never closes it could still parse,
so serve published a file hosts read as having no frontmatter; it is now
skipped with a warning.
Size and mtime cannot prove a file is unchanged (cp -p, rsync -t), and a
stale digest makes hosts that verify digests reject the file for good,
so every rebuild hashes every file again; 1,000 skills rebuild in about
140 ms, at most once per refresh interval.
Serve errors now go to stderr: stdout is the protocol stream, and a
startup error printed there is not JSON-RPC.
SKILL.md must begin with its frontmatter, as the Agent Skills format
requires; a later --- block no longer passes.
A root under mcp.projects is served from the global config, where its
project targets (app@claude) live, so the Skillshare tab now offers that
project's targets beside the global ones and saves no -p, which would
fail in a folder with no .skillshare/.
A nested skill skipped for any reason, not only one left unselected, now
skips its parents too: they were settled before the child was validated
and published its files as their own.
Also from review: a skill whose frontmatter JSON cannot carry (a
non-string key) is skipped instead of failing the whole skills/list page;
a listed file with a backslash in its name can be read; and stdio serve
exits 0 on SIGINT/SIGTERM without writing to stdout after the session.
Status, doctor, diff, the dashboard's target and diff handlers and analyze each
repeated FilterSkills followed by FilterSkillsByTarget, and only some dropped
disabled skills first. Routing them through SelectTargetSkills keeps their
answers identical to sync and mcp serve when a selection rule changes.
The callers that did not drop disabled skills get discoveries without them, so
their output does not change.
Agents on a disposable VM, in a hosted assistant or behind an MCP gateway can
reach an MCP endpoint but not the folder skills sync to, so they got tools and
none of the user's skills (#428).
`skillshare mcp serve` is a read-only server for the skills skillshare already
manages. It declares io.modelcontextprotocol/skills and implements skills/list,
skills/get and resources/read: one entry per skill, its URI from the source
path, the full frontmatter, and every file with a sha256 digest and size.
--target applies that target's selection, and the source is reread at most
every 5 seconds so install, update, enable and disable show up without a
restart; unchanged files keep their digest. stdio is the default; --http
serves Streamable HTTP and needs SKILLSHARE_MCP_TOKEN off loopback.
Skills the extension cannot carry are skipped with a warning instead of being
published incomplete: a name that breaks the Agent Skills rules or differs from
its directory, more than 512 files or 16 MiB, or a nested skill that is not
served. --check lists them without serving. The naming rules moved to
internal/skillpkg so sync and the server share them.
Few clients support the extension yet, so the server also offers list_skills
and read_skill tools. A client that declares the extension does not see them,
so it never gets each skill twice.
sync.SelectTargetSkills is the one place that turns discovered skills into a
target's selection (enabled, include/exclude, frontmatter targets).
Refs: #428
The audit names a result relative to the source it was given. With the
runner's 8.3 TEMP the source was the short form and the scan target the
long one, so the name became a chain of ../ segments.
Refs #344
The windows-latest runner's TEMP is an 8.3 short path
(C:\Users\RUNNER~1\...), while the product reports the resolved long
path. Four tests compared the short form and failed only on the runner;
the local guest has no short names. Resolve the expected path first.
Refs #344
These packages were left out of the windows-test job because of failures
that came from test assumptions (POSIX paths, permission bits, HOME,
bash shims posing as git), not product behavior. Fix them and add the
packages to the list so they stay green.
Two failures were real product bugs:
- swapStagedIntoSource named its backup like the temp that
sourcefs.MoveIn creates beside it. On a coarse clock (Windows) both
names matched, the failed move removed the temp and with it the
backup, and the old skill was lost.
- MetadataStore.GetByPath looked up OS-native paths in slash-form keys,
so `update --group` missed nested skills on Windows.
The test sandbox now also sets USERPROFILE, which os.UserHomeDir reads
on Windows; tests were reading the real profile.
Refs #344
`update --all` only consulted the follow policy for `_`-prefixed
directories, so a followed checkout linked under another name (for
example via `link --name dev-skills`) whose root holds a SKILL.md with
recorded metadata was scheduled as a regular skill and `git pull`ed, and
reset under `--force`, against the user's own checkout. Followed links
carry no naming requirement, so run the guard for every directory before
the tracked-repository naming rules apply, in both the global and project
update loops.
Follow-up to the Codex review on #417.
link -h loaded the config first, so it failed with "config not found"
without one and, with --project, could create .skillshare files just to
print help. Detect help among the option arguments before loading the
scope. Pass --name as a value flag to parseModeArgs so "--name -g" no
longer selects global mode (#422).
A followed checkout whose root is a skill is classified as a tracked
repository, so a dirty checkout hit the uncommitted-changes preflight and
was told to retry with --force before the linked-root guard ran. Run the
guard right after target validation for every mode so the answer is always
"use unlink".
POST /api/source-links with enable: true left the new link in the source
when the config could not be saved, so the dialog reported a failure the
filesystem did not match and a retry failed with "already exists". Share
one sourcelink.Discard rollback between the CLI and the handler.
Pass value-taking options to the shared mode parser so command values cannot select a scope or create false mode conflicts. Preserve the end-of-options delimiter and reuse it for MCP command arguments.
Cover existing CLI entry points, including audit rules, enable/disable, and backup deletion, with regression tests and document the parser contract.
The write ratchet flags raw os writes below the skills source; the
rollback added for a failed --enable removed the fresh link with
os.Remove. Go through sourcefs.Unlink so only the link entry goes and
the boundary stays enforced.
link --enable created the link, logged success, and only then wrote the
config; a failed config write left a link discovery ignores behind a
logged success, and a retry failed with "already exists". Enable before
logging and remove the fresh link when enabling fails so the command,
the filesystem, and the operation log agree.
Hub index, built-in search, and draft candidates discovered only the source path, dropping the follow policy used by the inventory. Add optional walk options to the shared Hub functions and pass the operation policy from dashboard handlers and CLI indexing.
Explicit CLI sources use the active config policy while retaining configuration-free indexing. Cover global/project modes, enabled/disabled following, all three handlers, and CLI source overrides; document the behavior in all website locales and built-in guidance.
Standard target naming uses frontmatter names, so matching target entry names misclassified unavailable source skills as broken and suggested pruning. Read the stored link destination, resolve relative paths, and compare it with unavailable source roots; retain name matching only when the link target cannot be read.
Cover absolute and relative destinations and an unrelated broken link whose name resembles a followed skill. Document that standard target names receive the same waiting classification.
Followed worktrees and submodules were discovered as tracked repos but bypassed guards that required a .git directory. Widen IsGitRepo to accept a directory or regular gitdir file and reuse it in discovery and reconciliation. All existing callers classify checkouts or run Git commands; none requires the directory layout, so a separate predicate would retain inconsistent decisions.
Exercise actual followed worktrees in CLI and dashboard update fixtures, including project mode and force retries, and document that they receive the same checkout guards.
Filtered checks dropped the follow policy when resolving a basename, so a linked checkout visible in an unfiltered check was reported as not found by its name. Forward the operation policy to the resolver and cover both global and project checks against a local Git remote.
Document checking followed checkouts by link name in the command reference and built-in guidance.
Missing-repo discovery ignored the operation follow policy, so tracked metadata added a skipped checkout back to update --all and allowed --force to reset it. Thread the policy through missing-repo detection and its CLI/server callers, including rehydration, so existing followed checkouts remain excluded.
Cover global and project updates with dirty tracked checkouts and force, as well as shared and dashboard rehydration. Document that --force does not override the batch skip.
* feat(omp): add native Oh My Pi support
Support OMP skills, instructions, MCP, code hooks and guarded extension selection using its verified native contracts rather than Pi aliases.
Add reviewed marketplace plugin installation, cache-preserving scoped removal and fresh-cache reinstall. Align Pi/OMP extension cards and localize inventory guidance while keeping native ownership and read-only constraints.
Include regression coverage, isolated E2E runbooks, documentation and verification policies. Native plugin updates and unverified runtime platforms remain guarded.
Refs #409
* fix(omp): guard runtime ownership and localize inventory guidance
Native install recursively replaces its runtime destination, and a missing cache manifest could leave the real runtime link installed after removal. Bind and recheck an absent reviewed destination, and recover removal names only from verified scope-local links.
Localize fixed backend reasons and warnings across dashboard locales while preserving paths and external diagnostics. Restore the reviewed source in the existing reinstall fixture and record real native verification.
* fix(omp): allow forgetting natively removed plugins
A different plugin can retain node_modules after native uninstall deletes this installation. When its cache, registration and known runtime state are absent, forget only the stale Skillshare binding instead of demanding runtime-name proof for unrelated files.
Extend the existing removal recovery test with a failing-before-fix case that verifies the binding is dropped and unrelated native lock bytes and plugin files are preserved. make check passes.
Dry runs returned before the linked-root guard, so text preview claimed a trash move and JSON listed a root-skill link as removed even though real execution refused it.
Run the existing non-mutating move check before either preview and extend the root-link fixture to verify text and JSON refusals without claiming removal.
A root skill discovered through a followed source link occupies the link entry itself. Moving that entry to trash silently unlinks every nested skill instead of removing one skill.
Share the root-skill guard across single and batch API handlers and CLI uninstall, report the unlink action clearly, and preserve explicit unlink and nested skill removal.
Stop parsing mode and command options after -- so valid link names and relative paths beginning with a hyphen can be addressed. Document the unlink form in every command locale and verify that -g and -p after the terminator remain names.
follow_source_links only follows a link the user made by hand, so the
guards (source or parent, sync target overlap, link chain) surfaced in
doctor only after the link existed, and Windows users had to pick
between a junction and mklink /D themselves.
link checks the prospective target with Follow.Allow, which shares the
guard rules and reason strings with the walk, before creating a junction
on Windows or an absolute symlink elsewhere. It warns when the target is
not a git checkout and leaves follow_source_links alone unless --enable
is given. unlink moves only the link entry to trash, the same way
uninstall removes a first-level link, so the target is never touched and
trash restore undoes it. internal/sourcelink holds both operations so the
dashboard can call them too.
Refs #419
Keep one follow policy per list and status operation and report its skipped links without hiding healthy inventory. Send JSON diagnostics to stderr and expose sourceLinkWarnings in the dashboard resources response, reusing the sync warning formatter.
Pass the operation follow policy into basename and glob resolution so linked Git checkouts and full skill paths can be updated explicitly. Keep update --all skipping user-owned followed checkouts with its existing warning.
uninstall --group on a followed link is now refused, and restore no
longer creates parents with a raw MkdirAll, so the ratchet allowance
for it is stale.
sync --json showed pruned: 0 and success while a link was unavailable,
so automation could not tell a held-back prune from nothing to prune.
The run's source link warnings now ride along as warnings.
uninstall --group <followed link> moved every skill out of the user's
checkout, while uninstall <link> removes only the link entry. The group
form is refused with a pointer to the by-name forms.
Restore skills through sourcefs with the active global or project follow policy so nested links and disabled following cannot redirect writes or consume the trash copy. Preserve relative link traversal when relocating links, and keep link rows in the trash TUI on their detail view.