@ahood/cli 0.7.3 → 0.8.1

package/dist/commands/remove.js

@@ -1,69 +1,114 @@
-import { existsSync, readdirSync, readFileSync, rmSync, rmdirSync, unlinkSync } from "node:fs";
-import { dirname } from "node:path";
-import { removeLockfileEntry } from "../lockfile.js";
+import { existsSync, rmSync, unlinkSync } from "node:fs";
+import { confirm } from "../confirm.js";
+import { readLockfile, removeLockfileEntry, withLock, writeJsonFileAtomic } from "../lockfile.js";
 import { LOCKFILE_PATH, parseOwnerSkill, skillDir, agentPath, MCP_CONFIG_PATH } from "../spec.js";
+import { readMcpConfig, hashMcpServerConfig } from "./add.js";
 import { UsageError } from "../usage-error.js";
-const USAGE = "Usage: ahood skill remove <owner>/<skill>";
+const USAGE = "Usage: ahood skill remove <owner>/<skill> [--yes]";
 export async function remove(args) {
     const spec = args[0];
     if (!spec)
         throw new UsageError(USAGE);
+    const yes = args.includes("--yes");
     const { owner, skill } = parseOwnerSkill(spec, USAGE);
     const key = `${owner}/${skill}`;
+    // Flat owner@skill directory (see skillDir's comment in spec.ts) -- no
+    // owner-namespace folder to sweep afterward, unlike the old nested layout.
     const dir = skillDir(owner, skill);
     const dirExisted = existsSync(dir);
-    if (dirExisted)
-        rmSync(dir, { recursive: true, force: true });
-    // Sweep the owner directory once it holds nothing, so uninstalling an
-    // owner's last skill doesn't leave an empty namespace folder behind (npm
-    // does the same with node_modules/@scope). Guarded on emptiness, so another
-    // skill by the same owner is never touched.
-    const ownerDir = dirname(dir);
-    if (existsSync(ownerDir) && readdirSync(ownerDir).length === 0)
-        rmdirSync(ownerDir);
     // An agent installs as a single flat file (.claude/agents/<owner>@<skill>.md),
-    // never a directory under .claude/skills/ -- skillDir's rmSync above never
-    // touches it. Without this, removing an installed agent silently left the
-    // file on disk (still loaded by Claude Code forever) while reporting
-    // success and clearing the lockfile entry, so a later `update` wouldn't
-    // catch it either (ahood-cli final review finding #2).
+    // never a directory under .claude/skills/ -- distinct from the dir check above.
     const agentFile = agentPath(owner, skill);
     const agentExisted = existsSync(agentFile);
-    if (agentExisted)
-        unlinkSync(agentFile);
-    const hadLockfileEntry = removeLockfileEntry(LOCKFILE_PATH, key);
+    const lockEntry = readLockfile(LOCKFILE_PATH)[key];
+    const hadLockfileEntry = lockEntry !== undefined;
     if (!dirExisted && !agentExisted && !hadLockfileEntry) {
         console.error(`${key} was not installed -- nothing to remove.`);
         process.exitCode = 1;
         return;
     }
+    // Matches unpublish.ts/group.ts's confirm-before-destroy pattern (CLAUDE.md:
+    // "Destructive commands ... prompt for confirmation unless --yes is passed").
+    // Checked only once something is actually installed, so a no-op remove of an
+    // uninstalled skill never blocks on a prompt (ahood-cli#98).
+    const confirmed = yes ? true : await confirm(`Remove ${key} from this project? Type "yes" to confirm: `);
+    if (!confirmed) {
+        console.log("Aborted.");
+        return;
+    }
+    if (dirExisted)
+        rmSync(dir, { recursive: true, force: true });
+    if (agentExisted)
+        unlinkSync(agentFile);
+    removeLockfileEntry(LOCKFILE_PATH, key);
     // An mcp-kind install has no directory or agent file on disk -- its only
     // footprint here is the lockfile entry just cleared above and a live
     // entry in .mcp.json (which add.ts's installMcpEntry merged in, possibly
-    // holding a resolved secret in its `env`). remove() doesn't attempt a real
-    // mcp removal, but staying silent about that entry repeats the exact
-    // false-assurance bug already fixed once for agent installs above: a user
-    // who removes an mcp artifact because they no longer trust it would be
-    // told it's gone while the MCP server (and its credential) still runs on
-    // the next Claude Code start -- and since the lockfile pin is now cleared,
-    // nothing will ever surface this again via `list`/`update`. So: warn
-    // instead of pretending it's gone.
-    if (existsSync(MCP_CONFIG_PATH)) {
-        try {
-            const parsed = JSON.parse(readFileSync(MCP_CONFIG_PATH, "utf-8"));
-            const mcpServers = parsed?.mcpServers;
-            if (mcpServers &&
-                typeof mcpServers === "object" &&
-                !Array.isArray(mcpServers) &&
-                Object.prototype.hasOwnProperty.call(mcpServers, skill)) {
-                console.warn(`WARNING: ${key} still has an entry in ${MCP_CONFIG_PATH} (which may contain secrets you entered) -- remove it manually.`);
+    // holding a resolved secret in its `env`). Real removal (delete that one
+    // key) only happens when the on-disk entry's fingerprint still matches
+    // what was recorded at install/update time -- same posture as add.ts's
+    // own assertNoCollision: never blind-write/delete something this process
+    // didn't verify it still owns. Without SOME check here, "Removed" would
+    // repeat the exact false-assurance bug already fixed once for agent
+    // installs above (a user told it's gone while the MCP server, and its
+    // credential, still runs on the next Claude Code start) -- but a hand-
+    // edited entry (fingerprint mismatch, or no fingerprint recorded at all,
+    // e.g. an mcp entry installed before this field existed) is left in
+    // place and warned about instead, exactly as before this fix.
+    let removedMcpEntry = false;
+    let mcpEntryModified = false;
+    let mcpEntryPresent = false;
+    let recordedHash;
+    try {
+        const fileContents = readMcpConfig();
+        const mcpServers = fileContents.mcpServers;
+        mcpEntryPresent = Object.prototype.hasOwnProperty.call(mcpServers, skill);
+        if (mcpEntryPresent) {
+            recordedHash = lockEntry?.mcp_config_hash;
+            const currentHash = hashMcpServerConfig(mcpServers[skill]);
+            if (recordedHash !== undefined) {
+                mcpEntryModified = recordedHash !== currentHash;
             }
         }
+    }
+    catch {
+        // A malformed .mcp.json isn't this command's problem to fix or crash
+        // on -- add.ts's readMcpConfig is the strict validator for that path.
+        // mcpEntryPresent stays false, so there's nothing to warn about either:
+        // if we can't even read the file, we can't know whether this skill has
+        // an entry in it.
+    }
+    if (mcpEntryPresent && recordedHash !== undefined && !mcpEntryModified) {
+        try {
+            // Re-check under lock rather than trusting the read above -- another
+            // process could have changed or removed the entry in between,
+            // mirroring add.ts's own re-check-under-lock before it writes. This
+            // try/catch is deliberately separate from the read above: a failure
+            // HERE (a lock-acquisition timeout, an EACCES/ENOSPC/etc. write
+            // failure) must still fall through to the warning below rather than
+            // being silently swallowed -- letting it share the read's catch block
+            // was the exact bug that let a failed delete print a bare "Removed"
+            // with the credential still live (the false-assurance case this
+            // whole mechanism exists to prevent).
+            withLock(MCP_CONFIG_PATH, () => {
+                const fresh = readMcpConfig();
+                const freshServers = fresh.mcpServers;
+                if (Object.prototype.hasOwnProperty.call(freshServers, skill) &&
+                    hashMcpServerConfig(freshServers[skill]) === recordedHash) {
+                    delete freshServers[skill];
+                    writeJsonFileAtomic(MCP_CONFIG_PATH, fresh);
+                    removedMcpEntry = true;
+                }
+            });
+        }
         catch {
-            // A malformed .mcp.json isn't this command's problem to fix or crash
-            // on -- add.ts's readMcpConfig is the strict validator for that path.
-            // Skip the warning rather than throw here.
+            // removedMcpEntry stays false -- falls through to the warning below.
         }
     }
-    console.log(`Removed ${key}`);
+    if (mcpEntryPresent && !removedMcpEntry) {
+        console.warn(`WARNING: ${key} still has an entry in ${MCP_CONFIG_PATH} (which may contain secrets you entered)` +
+            (mcpEntryModified ? " -- it appears to have been modified since install" : "") +
+            ` -- remove it manually.`);
+    }
+    console.log(removedMcpEntry ? `Removed ${key} (including its ${MCP_CONFIG_PATH} entry)` : `Removed ${key}`);
 }

package/dist/commands/search.js

@@ -1,5 +1,5 @@
 import { apiJson } from "../http.js";
-import { flagValue } from "../flags.js";
+import { flagValue, parseSearchQuery } from "../flags.js";
 import { UsageError } from "../usage-error.js";
 const USAGE = "Usage: ahood skill search <query> [--json] [--limit <n>]";
 export async function searchSkills(query, limit) {
@@ -12,13 +12,7 @@ export async function searchSkills(query, limit) {
 export async function search(args) {
     const jsonOutput = args.includes("--json");
     const limitStr = flagValue(args, "--limit");
-    const queryParts = args.filter((a, i) => a !== "--json" && a !== "--limit" && args[i - 1] !== "--limit");
-    const unknownFlag = queryParts.find((a) => a.startsWith("--"));
-    if (unknownFlag)
-        throw new UsageError(`Unknown flag: ${unknownFlag}\n${USAGE}`);
-    const query = queryParts.join(" ");
-    if (!query)
-        throw new UsageError(USAGE);
+    const query = parseSearchQuery(args, USAGE);
     if (limitStr !== undefined && (!/^\d+$/.test(limitStr) || Number(limitStr) < 1)) {
         throw new UsageError(`--limit must be a positive integer (got "${limitStr}").\n${USAGE}`);
     }
@@ -33,7 +27,11 @@ export async function search(args) {
         return;
     }
     for (const skill of skills) {
-        console.log(`${skill.profiles.username}/${skill.slug} - ${skill.name}${skill.tagline ? `: ${skill.tagline}` : ""} (${skill.downloads_count} downloads)`);
+        // profiles comes from a server-side join that can plausibly be null for
+        // an individual row (orphaned skill, deleted owner account) -- degrade
+        // that one row instead of crashing the whole command (ahood-cli#106).
+        const username = skill.profiles?.username ?? "(unknown)";
+        console.log(`${username}/${skill.slug} - ${skill.name}${skill.tagline ? `: ${skill.tagline}` : ""} (${skill.downloads_count} downloads)`);
     }
     if (limit !== undefined && skills.length >= limit) {
         console.log(`(showing up to ${limit} results -- pass a higher --limit for more)`);

package/dist/commands/snap.js

@@ -0,0 +1,248 @@
+import { apiJson } from "../http.js";
+import { flagValue, parseSearchQuery } from "../flags.js";
+import { confirm } from "../confirm.js";
+import { UsageError } from "../usage-error.js";
+const CREATE_USAGE = "Usage: ahood snap create <content> [--tags tag1,tag2] (or pipe content on stdin)";
+const LIST_USAGE = "Usage: ahood snap list [--json] [--limit <n>]";
+const SEARCH_USAGE = "Usage: ahood snap search <query> [--json] [--limit <n>]";
+const SHOW_USAGE = "Usage: ahood snap show <id> [--json]";
+const REMOVE_USAGE = "Usage: ahood snap remove <id> [--yes]";
+const SHARE_USAGE = "Usage: ahood snap share <id> [--json]";
+const UNSHARE_USAGE = "Usage: ahood snap unshare <id> [--yes]";
+const TAGS_USAGE = "Usage: ahood snap tags <id> [tag1,tag2,...] [--json] (omit or pass an empty value to clear all tags)";
+// There's no existing "read stdin to completion" helper in this codebase to
+// reuse -- confirm.ts and secret-prompt.ts both only ever read a single
+// line via readline, never an arbitrary-length paste/pipe. Standard Node
+// read-to-end pattern: accumulate 'data' chunks until 'end'.
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+function validateLimit(limitStr, usage) {
+    if (limitStr !== undefined && (!/^\d+$/.test(limitStr) || Number(limitStr) < 1)) {
+        throw new UsageError(`--limit must be a positive integer (got "${limitStr}").\n${usage}`);
+    }
+}
+// Shared by list/search -- both print the same one-line-per-snap shape and
+// the same --json passthrough (the raw `snaps` array, matching
+// search.ts/list.ts's convention of emitting just the result array, not the
+// whole {snaps, next_cursor} envelope -- neither command exposes cursor-based
+// pagination today, only --limit, per ahood-cli#107's spec).
+function printSnaps(jsonOutput, snaps, emptyMessage) {
+    if (jsonOutput) {
+        console.log(JSON.stringify(snaps));
+        return;
+    }
+    if (snaps.length === 0) {
+        console.log(emptyMessage);
+        return;
+    }
+    for (const snap of snaps) {
+        // content_preview can plausibly contain the note's own internal
+        // newlines (it's freeform text) -- collapsed to spaces and re-truncated
+        // here so one snap never spills across multiple terminal lines and
+        // breaks the "one line per snap" contract.
+        const flat = snap.content_preview.replace(/\s+/g, " ").trim();
+        const preview = flat.length > 60 ? `${flat.slice(0, 60)}...` : flat;
+        // ?? [] -- see listSnaps/searchSnaps' identical degrade-on-null guard
+        // below; a snap predating the tags column, or a degraded response,
+        // should just show no tags rather than crashing on undefined.length.
+        const tags = snap.tags ?? [];
+        const tagsSuffix = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+        console.log(`${snap.id} - ${preview} (${snap.created_at})${snap.shared ? " (shared)" : ""}${tagsSuffix}`);
+    }
+}
+export async function createSnap(args) {
+    const jsonOutput = args.includes("--json");
+    const tagsArg = flagValue(args, "--tags");
+    // Joined, not just args[0] -- an unquoted multi-word note (e.g. `ahood
+    // snap create Debugged the flaky CI step`) arrives as multiple positional
+    // tokens, and taking only the first one silently dropped the rest with no
+    // error. Mirrors searchSnaps' own query-joining below. --tags and its
+    // value (both "--tags x" and "--tags=x" forms) are stripped the same way
+    // --json is, so they never leak into the joined content.
+    const positionals = args.filter((a, i) => a !== "--json" && a !== "--tags" && !a.startsWith("--tags=") && args[i - 1] !== "--tags");
+    const positional = positionals.length > 0 ? positionals.join(" ") : undefined;
+    let content;
+    if (positional !== undefined) {
+        content = positional;
+    }
+    else {
+        // No positional content -- fall back to stdin (echo "..." | ahood snap
+        // create, or a piped heredoc), same convention as e.g. `git commit -F
+        // -`. A TTY with nothing piped in would otherwise hang forever waiting
+        // for input that will never arrive -- this CLI must never hang
+        // indefinitely for unattended/agent use (same reasoning as http.ts's
+        // 30s request timeout) -- so that case fails fast with the usage error
+        // instead of blocking on readStdin().
+        if (process.stdin.isTTY)
+            throw new UsageError(CREATE_USAGE);
+        content = await readStdin();
+    }
+    if (!content.trim())
+        throw new UsageError(CREATE_USAGE);
+    // Same comma-split convention as `ahood skill publish --tags`/`edit
+    // --tags`. Omitted entirely when --tags wasn't passed at all, so the
+    // request body matches the "omitting tags is equivalent to []" contract
+    // exactly instead of always sending an (empty) tags array.
+    const body = { content };
+    if (tagsArg !== undefined) {
+        body.tags = tagsArg
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    const created = await apiJson("/api/v1/snaps", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (jsonOutput) {
+        console.log(JSON.stringify(created));
+        return;
+    }
+    console.log(created.id);
+}
+export async function listSnaps(args) {
+    const jsonOutput = args.includes("--json");
+    const limitStr = flagValue(args, "--limit");
+    validateLimit(limitStr, LIST_USAGE);
+    const qs = new URLSearchParams();
+    if (limitStr !== undefined)
+        qs.set("limit", limitStr);
+    const query = qs.toString();
+    const { snaps } = await apiJson(`/api/v1/snaps${query ? `?${query}` : ""}`);
+    // ?? [], not a bare destructure -- a degraded response (snaps: null)
+    // must degrade to "no snaps" instead of crashing, matching list.ts/
+    // search.ts's own guard for the identical shape (ahood-cli#106).
+    printSnaps(jsonOutput, snaps ?? [], "You have no snaps yet. Run `ahood snap create <content>` to make one.");
+}
+export async function searchSnaps(args) {
+    const jsonOutput = args.includes("--json");
+    const limitStr = flagValue(args, "--limit");
+    const query = parseSearchQuery(args, SEARCH_USAGE);
+    validateLimit(limitStr, SEARCH_USAGE);
+    const qs = new URLSearchParams({ q: query });
+    if (limitStr !== undefined)
+        qs.set("limit", limitStr);
+    const { snaps } = await apiJson(`/api/v1/snaps?${qs}`);
+    // ?? [] -- see listSnaps' identical guard above (ahood-cli#106).
+    printSnaps(jsonOutput, snaps ?? [], "No snaps found.");
+}
+export async function showSnap(args) {
+    const jsonOutput = args.includes("--json");
+    const id = args.find((a) => !a.startsWith("--"));
+    if (!id)
+        throw new UsageError(SHOW_USAGE);
+    const snap = await apiJson(`/api/v1/snaps/${encodeURIComponent(id)}`);
+    if (jsonOutput) {
+        console.log(JSON.stringify(snap));
+        return;
+    }
+    // Plain mode prints the raw content verbatim -- no formatting/labels/
+    // trailing decoration -- mirroring read.ts's own plain-mode contract
+    // exactly, process.stdout.write and not console.log: console.log
+    // unconditionally appends its own "\n", which double-adds a trailing
+    // blank line when the content already ends in one (ahood-cli#108).
+    process.stdout.write(snap.content);
+}
+export async function removeSnap(args) {
+    const id = args.find((a) => !a.startsWith("--"));
+    if (!id)
+        throw new UsageError(REMOVE_USAGE);
+    const yes = args.includes("--yes");
+    // Matches remove.ts/group.ts's confirm-before-destroy pattern (CLAUDE.md:
+    // "Destructive commands ... prompt for confirmation unless --yes is
+    // passed") -- deletion is irreversible per the API contract, same class
+    // of mistake ahood-cli#98/#99 already fixed for other commands.
+    const confirmed = yes ? true : await confirm(`Delete snap ${id}? Type "yes" to confirm: `);
+    if (!confirmed) {
+        console.log("Aborted.");
+        return;
+    }
+    await apiJson(`/api/v1/snaps/${encodeURIComponent(id)}`, { method: "DELETE" });
+    console.log(`Deleted snap ${id}.`);
+}
+export async function shareSnap(args) {
+    const jsonOutput = args.includes("--json");
+    const id = args.find((a) => !a.startsWith("--"));
+    if (!id)
+        throw new UsageError(SHARE_USAGE);
+    // POST .../share is documented idempotent -- mints a link on first call,
+    // returns the same existing one on any later call -- so this never needs
+    // a confirm() gate: re-running it can't clobber or duplicate anything.
+    const { share_url } = await apiJson(`/api/v1/snaps/${encodeURIComponent(id)}/share`, {
+        method: "POST",
+    });
+    if (jsonOutput) {
+        console.log(JSON.stringify({ share_url }));
+        return;
+    }
+    console.log(share_url);
+}
+export async function unshareSnap(args) {
+    const id = args.find((a) => !a.startsWith("--"));
+    if (!id)
+        throw new UsageError(UNSHARE_USAGE);
+    const yes = args.includes("--yes");
+    // Not destructive in the data-loss sense -- the snap itself is untouched,
+    // and re-sharing mints/returns a link exactly as before (share is
+    // idempotent). But whoever the old link was handed to loses access the
+    // instant this runs, with no warning otherwise -- a real effect even
+    // though it's recoverable by re-running `share`. Gated the same way as
+    // every other snap verb with a live, external side effect (remove,
+    // and by analogy group.ts's removeMember/leaveGroup) for consistency
+    // across this command group, rather than carving out a silent exception
+    // here just because the data itself survives.
+    const confirmed = yes ? true : await confirm(`Revoke the share link for snap ${id}? Type "yes" to confirm: `);
+    if (!confirmed) {
+        console.log("Aborted.");
+        return;
+    }
+    await apiJson(`/api/v1/snaps/${encodeURIComponent(id)}/share`, { method: "DELETE" });
+    console.log(`Unshared snap ${id}.`);
+}
+export async function tagsSnap(args) {
+    const jsonOutput = args.includes("--json");
+    const positionals = args.filter((a) => a !== "--json");
+    const id = positionals[0];
+    if (!id)
+        throw new UsageError(TAGS_USAGE);
+    // PATCH replaces the full tag set (not a merge) -- omitting the tags
+    // argument, or passing an empty string, both clear every tag, matching
+    // the "pass [] to clear" contract of the endpoint itself. Joined, not
+    // just positionals[1] -- an unquoted "tag1, tag2" arrives as multiple
+    // positional tokens, and taking only the first one silently dropped the
+    // rest with no error, the same bug createSnap's own content-joining
+    // above already fixed.
+    const tagsArg = positionals.slice(1).join(" ");
+    const tags = tagsArg
+        ? tagsArg
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean)
+        : [];
+    // No confirm() gate, unlike remove/unshare -- this only replaces metadata
+    // (tags), never the snap's content or its shareability, and re-running
+    // `tags` with the old set restores it exactly. Per ahood-cli#114's spec.
+    const updated = await apiJson(`/api/v1/snaps/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tags }),
+    });
+    if (jsonOutput) {
+        console.log(JSON.stringify(updated));
+        return;
+    }
+    // ?? [] -- see printSnaps' identical degrade-on-null guard above
+    // (ahood-cli#106): a degraded response shouldn't crash on undefined.length.
+    const updatedTags = updated.tags ?? [];
+    console.log(updatedTags.length > 0 ? `Tags for ${updated.id}: ${updatedTags.join(", ")}` : `Cleared tags for ${updated.id}.`);
+}

package/dist/commands/update.js

@@ -1,6 +1,6 @@
 import { LOCKFILE_PATH, parseOwnerSkill } from "../spec.js";
 import { readLockfile } from "../lockfile.js";
-import { add, fetchVersionMeta } from "./add.js";
+import { add, fetchVersionMeta, 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) {
@@ -99,18 +99,27 @@ export async function update(args) {
         try {
             // add() always hits the .mcp.json collision check for an mcp-kind
             // entry that's already installed (that's the very definition of
-            // "already installed" for that kind), so calling it unconditionally
-            // here would make `ahood skill update` with no arguments permanently
-            // report a failure and exit 1 for every user who has ever installed
-            // an mcp artifact, even when nothing needs updating. fetchVersionMeta
-            // already resolves `kind` as part of the normal "latest" lookup add()
-            // itself does, so resolving it here first lets this skip cleanly
-            // instead of updating and hitting that guaranteed error. This is a
-            // skip-and-report-cleanly fix, not real mcp-update support.
+            // "already installed" for that kind), so it can never be called
+            // unconditionally here the way it is for skill/agent kinds below --
+            // fetchVersionMeta resolves `kind` as part of the normal "latest"
+            // lookup add() itself does, so resolving it here first lets an
+            // mcp-kind entry route to updateMcpEntry (ahood-cli#169's real
+            // mcp-update support) instead.
             const { owner, skill } = parseOwnerSkill(ownerSlashSkill, USAGE);
             const meta = await fetchVersionMeta(owner, skill, "latest");
             if (meta.kind === "mcp") {
-                console.warn(`Skipping ${ownerSlashSkill}: mcp artifacts aren't updatable via this command yet.`);
+                const currentEntry = lockfile[ownerSlashSkill];
+                if (currentEntry && currentEntry.version === meta.version) {
+                    // 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.
+                    console.log(`${ownerSlashSkill} is already up to date (v${meta.version}).`);
+                    continue;
+                }
+                await updateMcpEntry(owner, skill, meta, currentEntry);
                 continue;
             }
             await add([ownerSlashSkill]); // no @version -- resolves to latest again

package/dist/flags.js

@@ -28,3 +28,21 @@ export function flagValue(args, flag) {
     }
     return undefined;
 }
+// Shared by every "<verb> <query> [--json] [--limit <n>]" command (skill
+// search, snap search) -- factored out after this exact logic was
+// duplicated verbatim between them, which is exactly how ahood-cli#105's
+// "--limit=5 misparsed as an unknown flag" bug could have silently come
+// back in one copy while being fixed in the other. Strips --json and
+// --limit (both "--limit N" and "--limit=N" forms) from the positional
+// args, rejects any other unrecognized "--" flag, and joins what's left
+// into a single query string.
+export function parseSearchQuery(args, usage) {
+    const queryParts = args.filter((a, i) => a !== "--json" && a !== "--limit" && !a.startsWith("--limit=") && args[i - 1] !== "--limit");
+    const unknownFlag = queryParts.find((a) => a.startsWith("--"));
+    if (unknownFlag)
+        throw new UsageError(`Unknown flag: ${unknownFlag}\n${usage}`);
+    const query = queryParts.join(" ");
+    if (!query)
+        throw new UsageError(usage);
+    return query;
+}