A Check button next to Backups runs the check only when clicked, so the
page never does DNS or PATH lookups on load. The result note sits above
the unmanaged-servers note, and each server row with findings gets a
count tag and a fold listing them.
The component tests land here with the locale strings they assert on,
since the parity-checked locale files belong to this commit.
The MCP page needs to show what `mcp check` found without reading
terminal output. These pieces fetch GET /api/mcp/check on demand, keep
the result in memory only, summarize it in a note, and list each error
or warning under its server with the Agent it concerns. Env, command,
and DNS findings are phrased from the new subject field so they can be
translated; other checks fall back to the backend message.
The dashboard needs to phrase each finding in the reader's language, so a
finding now names what it is about (variable name, command, or host) in a
separate subject field instead of only inside the English message. The
value of a variable is still never included.
GET /api/mcp/check serves the same report as `mcp check --json` so the MCP
page can run the check on demand. It is read-only, writes no oplog entry,
returns 200 when findings include errors, and accepts ?dns=0 to skip host
lookups.
Users and agents need to know what the check verifies, which findings fail
it, and the JSON shape scripts can rely on. English only; translations are
left for a follow-up.
Exercises the built binary: exit code 1 and the JSON shape when a variable
is missing, exit code 0 after sync with the variable set and no value
printed, and the known-server list for an unknown name.
The check takes several names and --no-dns, which the shared MCP option
parser rejects, so it is dispatched before that parser runs. Kept to its
own commit so the hook rebases cleanly over concurrent mcp.go edits.
A synced server can still fail when its Agent starts it: a referenced
variable is unset, the command is not on PATH, the host does not resolve,
or the Agent's entry drifted from the source. Nothing reported this without
starting the server.
Service.Check answers it without starting anything or sending requests. It
reuses the sync plan for per-target state and renders each server alone per
target, so a client rule names the Agent that refuses it and does not hide
the other servers' state. DNS is the only network access and can be skipped.
Support Pi 0.99.0 built-in MCP alongside existing adapter and extension modes, with mode-aware paths, imports, and per-server options.
Preserve custom native settings and remove cleared options only when explicitly requested and ownership is unchanged. Align CLI, dashboard previews, exposure controls, and localized documentation; simplify complex MCP components.
Add regression coverage for import dialects, escaped values, mode selection, option pruning, conflicts, and migration previews. Verified in the devcontainer with Go vet and tests, MCP integration, make check, UI build and 527 tests, five-language website build, and ai-context validation.
Dev builds always report a simulated CLI update so the upgrade flow can be
tested, which made the dialog pop up on every dashboard load. Skip the
auto-open when the server reports cliDevMode; ?update-test still forces it.
The toolchain update left two copies of @codemirror/state (and of view,
language, commands, @lezer/common and @lezer/lr) in the lockfile. Extensions
built against one copy fail instanceof checks in the other, so the file editor
crashed with "Unrecognized extension value in extension set" and Lezer trees
could silently lose highlighting.
Pin each package with pnpm overrides so the graph resolves to a single copy.
Record the sync partial-failure work, the tracked-repo git status fix
and the dashboard fixes since 0.21.17. The version moves to 0.22.0
because several changes alter exit codes and API responses that
scripts may rely on; they are listed under Breaking Changes.
TestSyncExtras_ProjectJSONReportsResolvedPath failed on the macOS CI
runner: the CLI reports the real target path, and the macOS temp dir
sits behind the /var -> /private/var symlink, so it no longer matched
the unresolved path the test built. Resolve the expected path the same
way, as json_output_test.go already does.
The project dashboard resolved every target's path on startup and before
each API request, so one custom target without `skills.path` kept
`skillshare ui -p` from starting and made every request of a running
dashboard fail with "failed to reload config". Targets that cannot
resolve are now left out with a startup warning, and the dashboard sync
reports them as failed with part "config", like `sync -p` does.
ResolveProjectTargets keeps failing for the commands that need every
target.
When every skills target failed, including when every target's settings
were invalid, the dashboard sync returned 500 with only the first error.
The page lost the failed list and its explanations, agents were never
synced, and the dashboard's extras and MCP steps did not run. The sync
now finishes like any partial failure: it returns 200 with every target
in `failed`, and the operation log still records it as `error`.
`sync -p agents` skipped config validation and wrote no operation log
entry, unlike `sync agents` and `sync -p`. A target with invalid
settings still got agents synced into it, and the run was missing from
`log` and the dashboard's Last sync card. It now skips invalid targets
and reports them as failed, exits non-zero, and logs one sync entry with
targets_failed and failed_targets.
`sync -p` resolved every target's path before validating the config, so
one custom target without `skills.path` stopped the whole project sync
with "unknown target ... (missing path)" before any target ran. Sync now
validates first and resolves only the valid targets; the target without
a path is reported as "invalid config: missing path" and the others
still sync, as they already did for other invalid settings.
The project sync dialog reported only a toast, so a target that failed
while the others synced was easy to miss, and its error was lost once
the toast closed. It now shows the same result panel as the Sync page:
the failed targets with their error and a plain-language explanation,
then the other warnings. The dialog has no Force switch, so a symlink
conflict links to the target instead of offering to turn Force on.
A failed target showed only the raw error, such as "mkdir ...: not a
directory", which says what the OS refused but not what to do. The
result panel now adds a one-line explanation for the common causes: a
symlink pointing elsewhere, permission denied (including Windows'
"Access is denied"), a read-only file system, a file where a folder
belongs, a missing path, and a target skipped for invalid settings
(the new "config" part). Unknown errors keep the raw text only.
The card showed "partial" and a target count, but not which targets
failed, so finding them meant opening the log. It now adds a Failed row
naming the targets from the log's failed_targets, or the count for
entries written before that field existed.
Any per-target config problem, such as a skills path that is a file or
an unknown mode, made `skillshare sync`, `sync -p` and the dashboard
refuse to sync anything. That contradicts the policy that sync runs
every target and reports the ones that failed. Sync now validates the
config as a whole first and still stops on global problems (source,
global mode or naming, git_root, extras); a target whose own settings
are invalid is skipped for skills and agents and reported as failed
("invalid config" in CLI output and --json details, part "config" in
the dashboard's failed list). Config validation on save is unchanged.
The log counted only skills targets as failed. The CLI wrote its sync
entry before `sync --all` ran agents, `sync agents` logged empty stats,
and the dashboard left agent failures out of targets_failed, so a run
that lost a target's agents still read "ok" and Last sync could not
say what failed. CLI and dashboard now log once after every part ran:
targets_failed counts each failed target once, the new failed_targets
lists their names, and targets_total is every target in scope.
A dashboard sync that lost a target reported it only as a warning
string, next to backup notes and prune hints, under a "Sync complete"
toast, so a partial failure was easy to miss and nothing said how to fix
it. The sync API now returns a "failed" list (target, part, error, the
matching warning text, and whether a symlink conflict caused it);
"warnings" is unchanged. The Sync page shows failed targets first with
their part and error, offers Turn on Force for a symlink conflict,
marks the target in the change list, and toasts a warning instead of
success.
runSync threw at the first extras target with an error, after skills
and agents had already synced. The Sync page then dropped their result
and warnings, never wrote MCP, and showed one error without naming the
extra or target. It now collects every failed extras target and carries
on, matching `sync --all`; the page lists each as "<extra> → <target>:
<error>".
Since 191bdec3 a dashboard sync keeps going after a skills target
fails, but the Sync row only described the happy path. It now says what
the page actually shows: failures as warnings with the run marked
partial, an error when every skills target fails, and an extras failure
that stops before MCP is written.
uninstall has failed a tracked repo whose git status cannot be read
since 8e5a09c4, but --help still listed only the uncommitted-changes
check. The tracked repositories page also said a dirty repo only warns
and that the directory is removed, while uninstall stops unless --force
and moves the repo to trash.
uninstall now fails a tracked repo whose git status cannot be read
unless --force, but the command page and built-in skill still described
only the uncommitted-changes check. The recent list, status, sync,
update and uninstall changes were also English-only, while this site
updates every locale alongside the English page.
The recent refactors consolidated sync loops into internal/sync runners,
server body decoding into decodeJSON, and UI kind queries into kindQuery.
Without pointers in the topics an agent would likely reimplement these
inline and reintroduce the drift the refactors removed.
Global and project uninstall each carried their own resolve, preflight,
confirm, execute, gitignore and finalize steps, about 1700 lines in two
files that had drifted. One runUninstallSkills flow now serves both,
with an uninstallMode struct holding what differs: source and trash
dirs, config, glob and --json support, prompt and hint wording, gitignore
handling, and project lock pruning.
Output, prompts, JSON, oplog entries and exit codes are unchanged; the
characterization tests from 60732db3 pass as before. The one change in
how it runs: project mode now checks tracked repos' git status in
parallel like global, printing the same lines in the same order once the
checks finish.
On the .skillignore and .agentignore tabs, Revert reset the config.yaml
editor and left the ignore file's edits in place, so the button looked
like it did nothing. It now resets whichever file the tab has open.
resources.ts and audit.ts appended ?kind= unencoded while backups.ts
encoded it. Every call now uses kindQuery in http.ts, which encodes.
Today's kind values are fixed words, so requests do not change; the
helper keeps a future value from breaking the query string.
The project wrapper logged every call, including --help (recorded as a
skill named "--help"), resolve errors, declined prompts and dry runs, and
always with zero succeeded, so a partial uninstall never showed as
partial. Project uninstall now logs once when it has run, with the real
succeeded count, exactly like global. The project list TUI, which calls
it directly, now logs its uninstalls too, as the global one already did.
Project uninstall had its own name resolver that turned every problem
into "not found", hiding that a name matched several nested skills or
pointed at a file. It now uses the global resolver, so both modes report
the same specific errors; only the not-found wording still names the
project's skills directory.
Close to thirty components and pages each spelled out the same query key,
fetcher and stale time for these shared queries. They now call one hook
per query and pass only what differs per page: enabled flags, polling,
and the MCP stale time, which pages already disagreed on and keep.
uninstall, update, status, list and the Web API now report "failed to
check git status: <err>", but the error was only "exit status 128"
because IsDirty dropped what git printed on stderr. The message now says
why git status failed, such as a corrupt index.
status and list discarded the error from the uncommitted-changes check,
so a tracked repo whose git status could not be read was shown as
up-to-date. They now show it as unknown with a warning naming the repo
and error; status --json sets the existing status and message fields.
The commands still succeed, since they only report.
Project uninstall backfills logs/, trash/ and backups/ into a gitignore
for projects created before v0.17.3. Since 60e19f96 ensureProjectGitignore
takes the .skillshare directory, but this caller still passed the project
root, so those entries landed in the project's own .gitignore.
About 57 handlers decoded request bodies with no size limit, and the few
that had one each picked their own. They now go through decodeJSON with a
1 MiB default; handlers that need more keep their larger limit. An
oversized body gets 413 instead of whatever the handler returned for bad
JSON (MCP and plugin requests used to answer 400). Every other decode
error keeps the handler's existing status and message.
Before merging the two uninstall flows, pin where they differ today
(glob expansion, resolve errors, --json support, preflight messages,
prompts, dry-run and gitignore output, lock pruning, oplog) so the merge
and the fixes that follow show up as deliberate test changes.
ConfigPage repeated the same load, dirty-tracking, save and reset state
for config.yaml, .skillignore and .agentignore. One hook now holds it,
with tests, and each editor passes only its own save call.
The discard check for the extensions tab no longer reads the .agentignore
dirty flag, which the old three-way ternary returned for any other tab.
update discarded the error from the uncommitted-changes check, so a repo
whose git status could not be read was treated as clean and pulled over
whatever local edits it had. It now fails that repo with "failed to check
git status: <err>" unless --force, matching uninstall and the Web API.
Batch update counts these as failed instead of skipped and exits non-zero.
The audit and log TUIs each hard-coded 70 columns in three places as the
width below which they drop to a vertical layout. It is now one named
constant next to tuiMinSplitWidth, the separate 80-column threshold the
list and trash TUIs use.
The skip added in b062a113 was only tested in global mode, where agent
target paths are absolute. Project mode resolves relative paths against
the project root, so it gets its own test.
audit.go had grown to 1821 lines mixing result scoring, skill and content
scanning, markdown link checks and content integrity. Each now lives in
its own file, matching how the tests were already split. Code is moved
verbatim; only package and import headers were added.
hub (five subcommands) and search still inlined the auto-mode check that
resolveAutoMode already implements, so a change to auto-detection would
have to be repeated in six more places.
Search kept its own name check, which rejected mixed-case names such as
"MySkill" that install happily accepts, so those skills never showed up
in results. It now uses validate.SkillName, the rule install applies.
Names install rejects, such as a leading underscore, stay hidden.
`sync extras` already exits non-zero and logs "partial" when a target
fails, but `sync --all` only printed a warning and exited 0, and its
--json path ignored extras errors entirely. The Web API always logged
"ok". Both now follow the CLI: `sync --all` exits non-zero on an extras
failure in text and JSON, global and project, without holding back MCP;
the Web API oplog records the error count with status "partial", or
"error" when every target that ran failed. The HTTP status stays 200.
After the server fixes, the CLI's collect*SyncResult functions and the
Web API loop ran the same merge/copy/symlink and prune logic twice. Both
now call sync.SyncSkillTarget and only render its result: the CLI keeps
its parallel grouping and progress output, the server stays sequential.
The stats helpers this orphaned are removed.
The server's "pruned" list is now always an array; it could be null
when a prune removed nothing.