@ahood/cli 0.8.8 → 0.9.0

package/dist/commands/update.js

@@ -1,6 +1,6 @@
 import { LOCKFILE_PATH, parseOwnerSkill } from "../spec.js";
 import { readLockfile } from "../lockfile.js";
-import { add, fetchVersionMeta, updateMcpEntry } from "./add.js";
+import { add, fetchVersionMeta, readMcpConfig, updateMcpEntry } from "./add.js";
 import { UsageError } from "../usage-error.js";
 const USAGE = "Usage: ahood skill update [<owner>/<skill> ...] [--dry-run] [--json]";
 async function previewSkill(ownerSlashSkill, currentVersion) {
@@ -15,6 +15,40 @@ async function previewSkill(ownerSlashSkill, currentVersion) {
         changelog_md: upToDate ? null : meta.changelog_md ?? null,
     };
 }
+// Whether .mcp.json currently holds something that could actually start this
+// skill's server (ahood-cli#139). Anything ahood itself writes is a non-empty
+// JSON object -- buildMcpServerConfig always emits at least a `command` or a
+// `url` -- so a missing key, `null`, `{}`, or a bare scalar all mean the same
+// thing operationally: the server is gone, whatever the lockfile still pins.
+// An emptied entry is reported broken but is NOT self-healed by overwriting:
+// falling through hands it to updateMcpEntry, whose fingerprint check refuses
+// it (before any download or prompt) with the "delete it by hand, then
+// `ahood skill add`" message. ahood never writes `{}` or `null`, so something
+// else did, and quietly stamping over an entry ahood cannot prove is its own
+// is exactly what that check exists to prevent -- an actionable refusal beats
+// both a silent overwrite and today's false "already up to date".
+//
+// Deliberately narrow: an entry that is present and non-empty but doesn't
+// match its recorded fingerprint is NOT reported as broken here. That's a
+// hand-edit, `update` has always left those alone when the pin was already at
+// latest, and turning every locally-tweaked entry into a per-entry failure
+// would be a regression of its own.
+//
+// readMcpConfig() throws on an unreadable or malformed .mcp.json rather than
+// being caught and treated as "no entry": update.ts's per-entry catch turns
+// that into one `Failed to update <skill>: ...` line and a non-zero exit
+// without stopping the rest of the batch, which is what the version-differs
+// path has always done (updateMcpEntry reads the same file through the same
+// function). Swallowing it here would instead print "already up to date"
+// about an entry sitting in a file nothing can parse -- the same false
+// all-clear #139 is about.
+function mcpEntryIsIntact(skill) {
+    const mcpServers = readMcpConfig().mcpServers;
+    if (!Object.prototype.hasOwnProperty.call(mcpServers, skill))
+        return false;
+    const entry = mcpServers[skill];
+    return typeof entry === "object" && entry !== null && Object.keys(entry).length > 0;
+}
 function padRow(cells, widths) {
     return cells.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
 }
@@ -109,13 +143,25 @@ export async function update(args) {
             const meta = await fetchVersionMeta(owner, skill, "latest");
             if (meta.kind === "mcp") {
                 const currentEntry = lockfile[ownerSlashSkill];
-                if (currentEntry && currentEntry.version === meta.version) {
+                if (currentEntry && currentEntry.version === meta.version && mcpEntryIsIntact(skill)) {
                     // Matches skill/agent update's own "nothing to do" case for a
                     // pin that's already at latest -- not a warning (nothing's
                     // wrong), and, unlike skill/agent (which always blindly
                     // re-extracts even when nothing changed), skipped here
                     // specifically so an up-to-date mcp entry with a secret in its
                     // env never re-triggers a masked prompt for no reason.
+                    //
+                    // Conditioned on the entry actually being there (ahood-cli#139):
+                    // .mcp.json is merged into rather than owned (see CLAUDE.md), so
+                    // losing an entry to a merge or a hand cleanup is ordinary, and
+                    // matching versions alone said "already up to date" about a server
+                    // that no longer existed -- the one kind `update` could not repair,
+                    // where skill/agent are restored by add() below regardless of
+                    // version. Falling through runs updateMcpEntry's self-heal (see the
+                    // "If the entry is missing entirely" case in add.ts), which does
+                    // have to prompt for secrets there is no on-disk entry to carry
+                    // forward; on the unattended path its allowNonTtyPrompt: false
+                    // turns that into a named-variable error instead of a hang.
                     console.log(`${ownerSlashSkill} is already up to date (v${meta.version}).`);
                     continue;
                 }

package/dist/flags.js

@@ -11,22 +11,114 @@ import { UsageError } from "./usage-error.js";
 //                    value, verbatim, even if it starts with "--" -- this is
 //                    the unambiguous escape hatch for values that genuinely
 //                    start with "--" (e.g. a tagline like "--fast and cheap").
+// A repeated value flag is refused rather than resolved. `flagValue` used to
+// return the FIRST match and stop, while the stripping below skipped EVERY
+// occurrence's neighbour, so `snap search foo --tags a --tags bar` searched for
+// "foo" tagged "a" and deleted "bar" from the query outright -- the user got
+// results for a command they did not type, at exit 0 (ahood-cli#136). Both
+// last-wins and first-wins are silent guesses about which fragment of a
+// command reassembled from shell history is the stale one; the CLI already
+// refuses flags it doesn't recognize, and refusing here is the only option that
+// cannot discard a value the user typed. The cost is one retry with the
+// duplicate deleted, which is also the edit the user has to make anyway.
+function assertFirstOccurrence(seen, flag) {
+    if (seen.has(flag)) {
+        throw new UsageError(`${flag} given more than once. Pass it once -- repeating it would silently discard one of the values` +
+            // Safe to say unconditionally for --tags: every --tags in this CLI
+            // (publish/edit/snap create/list/search) is one comma-separated value,
+            // and "it accumulates" is the misconception that produces the repeat.
+            (flag === "--tags" ? `; pass multiple tags as one comma-separated value (--tags a,b)` : "") +
+            `.`);
+    }
+    seen.add(flag);
+}
 export function flagValue(args, flag) {
     const prefix = `${flag}=`;
+    const seen = new Set();
+    let found;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg.startsWith(prefix)) {
-            return arg.slice(prefix.length);
+            assertFirstOccurrence(seen, flag);
+            found = arg.slice(prefix.length);
+            continue;
         }
         if (arg === flag) {
             const value = args[i + 1];
             if (value === undefined || value.startsWith("--")) {
                 throw new UsageError(`${flag} requires a value.`);
             }
-            return value;
+            assertFirstOccurrence(seen, flag);
+            found = value;
+        }
+    }
+    return found;
+}
+// Returns the tokens left over after stripping the flags a command declares:
+// `booleanFlags` stand alone (--json), `valueFlags` consume the following token
+// and also accept the --flag=value form. Whatever remains is something the
+// command does NOT accept -- an unrecognized "--" flag or a stray positional --
+// and it's the caller's job to reject it (or, for a query/id command, to
+// interpret it as the positional).
+//
+// Lives here rather than inline in each command because hand-rolling this check
+// per command is exactly how `snap list` ended up with no check at all while
+// its sibling `snap search` had one, so `snap list --tag ci` (singular typo)
+// issued an UNFILTERED request and printed every snap as though it were the
+// filtered set (ahood-cli#135). parseSearchQuery below is now a caller of this
+// helper rather than a second copy of it (folded in by ahood-cli#136, whose bug
+// existed in both copies); tagsSnap still carries its own inline copy -- fold it
+// in when the queued snap-parsing fixes (ahood-cli#137/#138) next touch it,
+// rather than growing a third variant again.
+export function unrecognizedArgs(args, booleanFlags, valueFlags) {
+    return unrecognizedIndices(args, booleanFlags, valueFlags).map((i) => args[i]);
+}
+// The same stripping rules as unrecognizedArgs, reporting WHERE the leftovers
+// sat rather than what they were -- and the primitive the two share, so there
+// is still exactly one copy of those rules (the whole point of #135's helper;
+// a second hand-rolled variant is the mistake it exists to stop).
+//
+// `snap create` needs the positions, not just the tokens: its leftovers are the
+// words of a freeform note, so "starts with --" is the only thing it can reject
+// outright, and the one remaining signal that a bare token was misplaced is that
+// the leftovers sit on BOTH sides of a flag the command consumed -- which is
+// precisely `snap create "note" --tags deploy bugfix` folding "bugfix" into the
+// note body (ahood-cli#134). Positions are the only way to see that gap.
+export function unrecognizedIndices(args, booleanFlags, valueFlags) {
+    const indices = [];
+    const seen = new Set();
+    // Which index (if any) the value flag just seen actually consumed. The test
+    // used to be `valueFlags.includes(args[i - 1])`, which stripped the neighbour
+    // of EVERY occurrence -- so a repeated --tags ate a word nothing had read
+    // (ahood-cli#136). Tracking the consuming occurrence means exactly one token
+    // per accepted flag disappears, and assertFirstOccurrence refuses the repeat
+    // with the same message flagValue gives, so a caller that reaches this helper
+    // first can't report the duplicate as "Unknown flag: --tags" instead.
+    let consumedAt = -1;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (i === consumedAt)
+            continue;
+        if (booleanFlags.includes(arg))
+            continue;
+        if (valueFlags.includes(arg)) {
+            assertFirstOccurrence(seen, arg);
+            // Same swallow-protection as flagValue: a following "--" token is not
+            // this flag's value, it's the next flag, so leave it to be judged on its
+            // own (flagValue throws "requires a value" for it first in every caller).
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("--"))
+                consumedAt = i + 1;
+            continue;
+        }
+        const equalsForm = valueFlags.find((f) => arg.startsWith(`${f}=`));
+        if (equalsForm !== undefined) {
+            assertFirstOccurrence(seen, equalsForm);
+            continue;
         }
+        indices.push(i);
     }
-    return undefined;
+    return indices;
 }
 // Shared by every "<verb> <query> [--json] [--limit <n>]" command (skill
 // search, snap search) -- factored out after this exact logic was
@@ -43,11 +135,11 @@ export function flagValue(args, flag) {
 // a flag that command doesn't implement instead of silently ignoring it and
 // returning unfiltered results.
 export function parseSearchQuery(args, usage, valueFlags = []) {
-    const stripped = ["--limit", ...valueFlags];
-    const queryParts = args.filter((a, i) => a !== "--json" &&
-        !stripped.includes(a) &&
-        !stripped.some((f) => a.startsWith(`${f}=`)) &&
-        !stripped.includes(args[i - 1]));
+    // Delegated to unrecognizedArgs rather than re-filtering here: this was the
+    // second hand-rolled copy of those stripping rules, and it carried the same
+    // repeated-flag bug (ahood-cli#136) that the first one did -- which is the
+    // duplication hazard #135's helper was extracted to end.
+    const queryParts = unrecognizedArgs(args, ["--json"], ["--limit", ...valueFlags]);
     const unknownFlag = queryParts.find((a) => a.startsWith("--"));
     if (unknownFlag)
         throw new UsageError(`Unknown flag: ${unknownFlag}\n${usage}`);

package/dist/help.js

@@ -283,14 +283,17 @@ export const SNAP_COMMANDS_HELP = [
         summary: "Capture a new private snap, from an argument or piped stdin.",
         desc: "Capture a new private snap. Pass the content as an argument, or omit it and pipe content on stdin " +
             "(e.g. `echo \"...\" | ahood snap create`, or a piped heredoc) -- useful for capturing a whole session's " +
-            "worth of freeform text at once. Prints the new snap's id on success.",
+            "worth of freeform text at once. Prints the new snap's id on success. An unrecognized flag is refused " +
+            "rather than folded into the note; pass content that itself starts with `--` after a bare `--`.",
         flags: [
             "--tags <comma,separated>   Attach tags to the new snap.",
             "--json                     Emit {id, created_at} instead of just the bare id.",
+            "--                         End of options: everything after it is content, verbatim.",
         ],
         examples: [
             'ahood snap create "Debugged the flaky CI step, root cause was a race in the cache key." --tags deploy,bugfix',
             'echo "..." | ahood snap create',
+            'ahood snap create -- "--json broke the parser"',
         ],
     },
     {
@@ -346,13 +349,24 @@ export const SNAP_COMMANDS_HELP = [
         flags: ["--yes    Skip the interactive confirmation, for scripts/CI."],
     },
     {
-        usage: "ahood snap tags <id> [tag1,tag2,...] [--json]",
-        summary: "Replace a snap's tags (omit the tag list, or pass an empty one, to clear all tags).",
-        desc: "Replace the full set of tags on a snap -- this is not a merge, so any existing tags not listed are " +
-            "dropped. Omitting the tag list entirely, or passing an empty string, clears all tags. No confirmation " +
-            "prompt: unlike remove/unshare this only touches metadata, never the snap's content or shareability.",
-        flags: ["--json    Emit {id, tags} instead of a plain-text summary."],
-        examples: ["ahood snap tags snap_123 deploy,bugfix", 'ahood snap tags snap_123 ""'],
+        usage: "ahood snap tags <id> [tag ...] [--clear] [--json]",
+        summary: "Print a snap's tags, or replace them with the tags given.",
+        desc: "With no tag list, prints the snap's current tags and changes nothing. With a tag list, replaces the " +
+            "full set -- this is not a merge, so any existing tags not listed are dropped. Tags may be given as " +
+            "separate arguments, comma-separated, or both; quote a tag that contains a space. Clearing every tag " +
+            "is explicit: pass --clear or an empty string. Each tag prints quoted, so one multi-word tag never " +
+            "looks like two. No confirmation prompt: unlike remove/unshare this only touches metadata, never the " +
+            "snap's content or shareability, and the tags it replaces can be read back first.",
+        flags: [
+            "--clear   Remove every tag from the snap.",
+            "--json    Emit {id, tags} instead of a plain-text summary.",
+        ],
+        examples: [
+            "ahood snap tags snap_123",
+            "ahood snap tags snap_123 deploy bugfix",
+            "ahood snap tags snap_123 deploy,bugfix",
+            "ahood snap tags snap_123 --clear",
+        ],
     },
 ];
 // Exported so other consumers of the command list (e.g. shell completion) can

package/dist/http.js

@@ -1,5 +1,6 @@
 import { getApiUrl } from "./config.js";
 import { resolveToken } from "./credentials.js";
+import { sanitizeForTerminal } from "./terminal-safe.js";
 import { CLI_NAME, CLI_VERSION } from "./version.js";
 export class ApiError extends Error {
     status;
@@ -31,8 +32,12 @@ export async function apiFetch(path, init = {}) {
         });
     }
     catch (error) {
-        const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
-        const message = error instanceof Error ? error.message : String(error);
+        // The `instanceof Error` guard on the cause is load-bearing, not defensive
+        // noise: `cause` is `unknown`, and optional-chaining into `.message`
+        // instead would print a bare "undefined" as the reason a request failed
+        // (ahood-cli#129). Dropping the reason entirely is the better failure mode.
+        const cause = error instanceof Error && error.cause instanceof Error ? `: ${sanitizeForTerminal(error.cause.message)}` : "";
+        const message = sanitizeForTerminal(error instanceof Error ? error.message : error);
         throw new NetworkError(`Request to ${getApiUrl()}${path} failed (${message}${cause})`);
     }
 }
@@ -44,23 +49,8 @@ const MAX_ERROR_MESSAGE_LENGTH = 500;
 // sits on every apiJson call in the CLI -- including `add`, which prints
 // server-sourced text immediately before a masked secret prompt, the exact
 // moment a cursor-movement/line-clear sequence can repaint what the user sees.
+// See src/terminal-safe.ts for what that substitution does and why.
 //
-// Control characters are replaced with a space rather than deleted so that
-// stripping can't silently glue two tokens into one misleading word.
-//
-// Newlines (\x0a) and carriage returns (\x0d) are inside this range and are
-// deliberately flattened too: a forged prompt line ("...\n\nEnter your token:")
-// needs no escape sequence at all, just a newline, so preserving them would
-// leave the spoofing half of the threat model open while closing the escape
-// half. The readability cost is small because anything reaching this branch is
-// already capped at MAX_ERROR_MESSAGE_LENGTH -- a few lines' worth of text, not
-// a stack trace.
-//
-// Known duplication: this is the same substitution as `sanitizeForTerminal` in
-// src/commands/add.ts (ahood-cli#122). It is copied rather than shared on
-// purpose -- promoting a shared helper means editing add.ts's call sites, which
-// is follow-up refactor work kept out of this security fix; see ahood-cli#127.
-const CONTROL_CHARACTERS = /[\x00-\x1f\x7f-\x9f]/g;
 // Defense in depth (ahood-cli#31): the API is expected to never forward a raw
 // upstream error body (an HTML block page from a proxy/WAF, a giant stack
 // trace, etc.) into `error`, but this CLI shouldn't trust that unconditionally
@@ -69,8 +59,11 @@ const CONTROL_CHARACTERS = /[\x00-\x1f\x7f-\x9f]/g;
 // a normal error string is replaced with a short, safe summary instead.
 export function sanitizeErrorMessage(message) {
     const looksLikeHtml = /<!DOCTYPE|<html[\s>]/i.test(message);
+    // The length argument is belt-and-braces, not behavior: this branch already
+    // guarantees `message.length <= MAX_ERROR_MESSAGE_LENGTH`, and an oversized
+    // body takes the generic-summary path below instead.
     if (!looksLikeHtml && message.length <= MAX_ERROR_MESSAGE_LENGTH)
-        return message.replace(CONTROL_CHARACTERS, " ");
+        return sanitizeForTerminal(message, MAX_ERROR_MESSAGE_LENGTH);
     // No preview of the raw content: an HTML-shaped body's first bytes are
     // exactly where infra details (e.g. a Cloudflare block page's title, Ray
     // ID) live, so a "helpful" excerpt would leak the same details this