skillrepo 4.8.0 → 4.8.2

package/src/test/e2e/uninstall-interactive.test.mjs

@@ -0,0 +1,93 @@
+/**
+ * `skillrepo uninstall` interactive DECLINE path.
+ *
+ * uninstall is destructive (it deletes skill placements + config from the
+ * project). When run without --yes/--json it prompts "Proceed? (y/N)" and
+ * a "no" answer MUST remove nothing. The whole in-process suite uses
+ * --yes/--json/--dry-run and never drives this prompt — so the abort path
+ * (the single most safety-critical branch in the command) had zero
+ * coverage. confirm() reads process.stdin via readline (no TTY required),
+ * so we spawn the real binary and pipe "n" to stdin.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// This file lives at src/test/e2e/ — three levels below packages/cli/.
+const CLI_BIN = resolve(__dirname, "../../../bin/skillrepo.mjs");
+
+let sandbox;
+let home;
+let project;
+let skillDir;
+
+function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-uninstall-decline-"));
+  home = join(sandbox, "home");
+  project = join(sandbox, "project");
+  mkdirSync(home, { recursive: true });
+  // Seed a SkillRepo artifact so uninstall has something to remove and
+  // therefore reaches the confirmation prompt (it short-circuits with
+  // "nothing to remove" otherwise).
+  skillDir = join(project, ".claude", "skills", "dummy");
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, "SKILL.md"), "---\nname: dummy\ndescription: d\n---\nbody\n");
+}
+
+function teardown() {
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+}
+
+function runUninstallWithInput(input) {
+  return spawnSync(process.execPath, [CLI_BIN, "uninstall", "--key", "sk_live_dummy"], {
+    cwd: project,
+    encoding: "utf-8",
+    input,
+    timeout: 10_000,
+    env: {
+      ...process.env,
+      HOME: home,
+      USERPROFILE: home,
+      NO_COLOR: "1",
+      CI: "true", // silence the update-check nudge
+      SKILLREPO_ACCESS_KEY: "",
+      SKILLREPO_TIMEOUT_MS: "2000",
+    },
+  });
+}
+
+describe("uninstall — interactive decline removes nothing", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("answering 'n' at the prompt cancels and leaves all artifacts intact", () => {
+    const r = runUninstallWithInput("n\n");
+    const out = (r.stdout ?? "") + (r.stderr ?? "");
+    assert.match(out, /Cancelled\. Nothing was removed\./, "decline must print the cancel message");
+    assert.ok(
+      existsSync(join(skillDir, "SKILL.md")),
+      "the skill placement MUST survive a declined uninstall",
+    );
+    // It must NOT have printed a per-artifact removal confirmation.
+    assert.doesNotMatch(out, /has been removed from this project/);
+  });
+
+  it("answering 'y' at the prompt proceeds with removal (control — proves the prompt is live)", () => {
+    // Without this control, the decline test could pass simply because
+    // the prompt never fired. A "y" answer must actually remove the
+    // artifact, proving the prompt gates a real deletion.
+    const r = runUninstallWithInput("y\n");
+    const out = (r.stdout ?? "") + (r.stderr ?? "");
+    assert.doesNotMatch(out, /Cancelled/);
+    assert.ok(
+      !existsSync(join(skillDir, "SKILL.md")),
+      "accepting the prompt must remove the skill placement",
+    );
+  });
+});

package/src/test/e2e/update-check-suppression.test.mjs

@@ -0,0 +1,135 @@
+/**
+ * Dispatcher npm update-check: nudge emission + --json suppression (#1554).
+ *
+ * The closest analog to the #1911 class of "command reports success while
+ * silently doing the wrong thing": the dispatcher gates the post-command
+ * upgrade nudge on `if (!rest.includes("--json"))`. If that guard ever
+ * regressed, every `--json` invocation would leak human text into a
+ * structured stream — invisible to the per-command tests (which call
+ * runX() directly and never reach the dispatcher's post-command hook) and
+ * to npm-update-check.test.mjs (which tests the module, not the binary).
+ *
+ * This spawns the REAL binary and arms the update-check cache so a nudge
+ * fires deterministically WITHOUT a network call (a cache hit resolves
+ * synchronously, before the dispatcher's Promise.race timer). Then it
+ * proves: nudge present on a normal command, fully absent under --json.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { createMockServer } from "./mock-server.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// This file lives at src/test/e2e/ — three levels below packages/cli/.
+const CLI_BIN = resolve(__dirname, "../../../bin/skillrepo.mjs");
+const PKG = JSON.parse(readFileSync(resolve(__dirname, "../../../package.json"), "utf-8"));
+const CURRENT_VERSION = PKG.version;
+const NUDGE = /A newer .*skillrepo.* is available/;
+
+let sandbox;
+let home;
+let server;
+let serverUrl;
+
+/**
+ * Write a fresh positive cache entry advertising a much higher published
+ * version. currentCliVersion MUST equal the live version or isCacheFresh
+ * discards the entry and falls back to a (here, unroutable) network fetch.
+ */
+function armCacheNudge() {
+  const dir = join(home, ".claude", "skillrepo");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, ".npm-version-check"),
+    JSON.stringify({
+      schemaVersion: 1,
+      checkedAt: new Date().toISOString(),
+      currentCliVersion: CURRENT_VERSION,
+      latestPublishedVersion: "999.0.0",
+      fetchOk: true,
+    }),
+  );
+}
+
+async function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-update-nudge-"));
+  home = join(sandbox, "home");
+  mkdirSync(home, { recursive: true });
+  server = createMockServer({});
+  const port = await server.start();
+  serverUrl = `http://127.0.0.1:${port}`;
+  server.setEtag('"v1"');
+  server.setLibraryResponse({ skills: [], removals: [], syncedAt: "2025-01-01T00:00:00Z" });
+}
+
+async function teardown() {
+  if (server) await server.stop();
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  server = null;
+}
+
+function runCli(args, extraEnv = {}) {
+  return new Promise((res) => {
+    execFile(
+      process.execPath,
+      [CLI_BIN, ...args],
+      {
+        encoding: "utf-8",
+        timeout: 10_000,
+        env: {
+          ...process.env,
+          HOME: home,
+          USERPROFILE: home,
+          NO_COLOR: "1",
+          // Force the update-check ON: CI auto-disables it, and the test
+          // suite itself often runs under CI=true. Clear both switches.
+          CI: "",
+          SKILLREPO_NO_UPDATE_CHECK: "",
+          SKILLREPO_ACCESS_KEY: "",
+          SKILLREPO_TIMEOUT_MS: "2000",
+          ...extraEnv,
+        },
+      },
+      (err, stdout, stderr) =>
+        res({ stdout: stdout ?? "", stderr: stderr ?? "", status: err ? (err.code ?? 1) : 0 }),
+    );
+  });
+}
+
+describe("dispatcher — update-check nudge + --json suppression (#1554)", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("emits the upgrade nudge on stderr after a successful non-JSON command", async () => {
+    // This is BOTH a real assertion and the control that proves the next
+    // test isn't vacuous: if the armed cache didn't produce a nudge here,
+    // the suppression test would pass for the wrong reason.
+    armCacheNudge();
+    const r = await runCli(["list", "--key", "sk_live_x", "--url", serverUrl]);
+    assert.equal(r.status, 0, `list should succeed; stderr: ${r.stderr}`);
+    assert.match(r.stderr, NUDGE, "armed cache must produce the upgrade nudge on a non-JSON command");
+    assert.match(
+      r.stderr,
+      new RegExp(`${CURRENT_VERSION.replace(/\./g, "\\.")}.*999\\.0\\.0`),
+      "nudge shows current → latest version",
+    );
+  });
+
+  it("suppresses the nudge entirely under --json (stdout pure JSON, stderr nudge-free)", async () => {
+    armCacheNudge();
+    const r = await runCli(["list", "--key", "sk_live_x", "--url", serverUrl, "--json"]);
+    assert.equal(r.status, 0, `list --json should succeed; stderr: ${r.stderr}`);
+    assert.doesNotMatch(r.stderr, NUDGE, "no nudge on stderr under --json");
+    assert.doesNotMatch(r.stdout, NUDGE, "no nudge on stdout under --json");
+    assert.doesNotThrow(
+      () => JSON.parse(r.stdout),
+      "stdout under --json must be pure JSON even with an armed update-check cache",
+    );
+  });
+});

package/src/test/integration/update-list-contract.integration.test.mjs

@@ -883,6 +883,72 @@ describe("remove → list cross-command contract", () => {
     assert.equal(state.etag, '"v1"', "remove must not clobber the library etag");
   });
 
+  it("remove → re-add round trip: skill lands again and list shows it current (#1911 acceptance)", async () => {
+    // #1911 acceptance criterion that had no test: "Remove then re-add an
+    // older skill → re-delivered." remove.mjs purges the .last-sync
+    // baseline entry specifically so a future re-add doesn't compare
+    // against a stale baseline and mis-report drift. Exercise the full
+    // round trip and prove the re-added skill is on disk AND reported
+    // `current` (not `edited`/`missing` from a leftover baseline).
+    process.env.CLAUDECODE = "1";
+
+    // 1) Seed: sync the skill so it's on disk + tracked in .last-sync.
+    server.setEtag('"v1"');
+    server.setLibraryResponse({
+      skills: [makeSkill("alice", "roundtrip", "1.0.0")],
+      removals: [],
+      syncedAt: "2026-01-01T00:00:00Z",
+    });
+    await runUpdate(["--key", VALID_KEY, "--url", serverUrl], { stdout });
+    const dir = resolvePlacementDir("claudeProject", "roundtrip");
+    assert.ok(existsSync(join(dir, "SKILL.md")), "precondition: roundtrip on disk after sync");
+    assert.ok(readLastSync().skills["alice/roundtrip"], "precondition: tracked in .last-sync");
+
+    // 2) remove: deletes local files + purges the baseline entry.
+    server.setRemoveResponseForAny({
+      status: 200,
+      body: { removed: { owner: "alice", name: "roundtrip" } },
+    });
+    await runRemove(["@alice/roundtrip", "--key", VALID_KEY, "--url", serverUrl], { stdout });
+    assert.ok(!existsSync(join(dir, "SKILL.md")), "remove deletes the local directory");
+    assert.equal(
+      readLastSync().skills["alice/roundtrip"],
+      undefined,
+      "remove purges the .last-sync baseline entry",
+    );
+
+    // 3) re-add the SAME skill.
+    server.setAddResponseForAny({
+      status: 201,
+      body: { added: { owner: "alice", name: "roundtrip", version: "1.0.0", addedAt: "2026-02-01T00:00:00Z" } },
+    });
+    server.setSkillResponse("alice", "roundtrip", makeSkill("alice", "roundtrip", "1.0.0"));
+    stdout = createCaptureStream();
+    await runAdd(["@alice/roundtrip", "--key", VALID_KEY, "--url", serverUrl], { stdout });
+    assert.ok(
+      existsSync(join(dir, "SKILL.md")),
+      "re-added skill MUST land back on disk",
+    );
+
+    // 4) list: must report `current`, proving the re-add wrote a fresh
+    //    baseline rather than colliding with the purged-then-stale one.
+    server.setEtag('"v2"');
+    server.setLibraryResponse({
+      skills: [makeSkill("alice", "roundtrip", "1.0.0")],
+      removals: [],
+      syncedAt: "2026-02-01T00:00:00Z",
+    });
+    stdout = createCaptureStream();
+    await runList(["--key", VALID_KEY, "--url", serverUrl, "--json"], { stdout });
+    const [item] = JSON.parse(stdout.text());
+    assert.equal(item.name, "roundtrip");
+    assert.equal(
+      item.state,
+      "current",
+      "re-added skill must be current — remove must have cleared the stale baseline",
+    );
+  });
+
   it("removing a skill that was never in .last-sync is idempotent (no throw, no spurious write)", async () => {
     // Edge case: user runs `skillrepo remove @alice/never-synced`
     // for a skill that was never on disk and was never tracked. The

package/src/test/lib/browser-open.test.mjs

@@ -184,4 +184,47 @@ describe("openBrowser", () => {
     });
     assert.equal(calls[0].options.shell, undefined);
   });
+
+  // ── default-parameter branches (no options object) ────────────────
+
+  it("falls back to process.platform when `platform` is omitted", () => {
+    // Covers the `platform ?? process.platform` default. We inject a spawnFn
+    // so no real browser launches; the host CI platform (darwin/linux on the
+    // Linux+macOS runners, win32 on the Windows runner) is supported, so the
+    // default resolves to a real launch command and the spawn fires.
+    const { spawnFn, calls } = makeSpawnStub();
+    const result = openBrowser("https://skillrepo.dev/cli/auth", { spawnFn });
+    assert.equal(result, true);
+    assert.equal(calls.length, 1);
+    // Platform-agnostic: darwin → "open", linux → "xdg-open", win32 →
+    // "cmd.exe". Asserting a specific command would break on whichever host
+    // runs the suite; a non-empty resolved command proves the default fired
+    // (an undefined platform would make resolveLaunchCommand return false).
+    assert.ok(
+      typeof calls[0].command === "string" && calls[0].command.length > 0,
+      `the default host platform must resolve to a launch command, got ${calls[0].command}`,
+    );
+  });
+
+  it("falls back to the real child_process.spawn when `spawnFn` is omitted", () => {
+    // Covers the `spawnFn ?? nodeSpawn` default WITHOUT actually
+    // launching anything: an unsupported platform returns false from
+    // resolveLaunchCommand BEFORE the spawn call, so the default
+    // nodeSpawn is selected (exercising the `??`) but never invoked.
+    const result = openBrowser("https://skillrepo.dev/cli/auth", {
+      platform: "plan9",
+    });
+    assert.equal(result, false, "unsupported platform returns false before spawning");
+  });
+
+  it("works with no options object at all (both defaults resolve)", () => {
+    // The signature defaults the whole options object to `{}`. Calling
+    // with a rejected URL exits at the `isLaunchableUrl` guard before
+    // touching the defaults — but calling with a real http URL on the
+    // host platform exercises both `?? process.platform` and
+    // `?? nodeSpawn`. We can't safely launch a real browser in CI, so we
+    // assert the early-return path with an invalid URL instead, which is
+    // the safe way to call the zero-arg form deterministically.
+    assert.equal(openBrowser("not-a-url"), false);
+  });
 });

package/src/test/lib/config.test.mjs

@@ -138,6 +138,36 @@ describe("readConfig", () => {
     writeFileSync(path, "[]");
     assert.equal(readConfig(), null);
   });
+
+  it("returns null when the JSON parses to a non-object primitive (e.g. `null`)", () => {
+    // `!parsed || typeof parsed !== "object"` — a file containing the
+    // literal `null` parses successfully but is falsy, so readConfig
+    // bails on the !parsed branch. The `[]`/`{}` cases above are both
+    // `typeof === "object"` and never reach this branch.
+    const path = globalConfigPath();
+    mkdirSync(join(process.env.HOME, ".claude", "skillrepo"), { recursive: true });
+    writeFileSync(path, "null");
+    assert.equal(readConfig(), null);
+  });
+
+  it("returns null when the JSON parses to a number (typeof !== object)", () => {
+    const path = globalConfigPath();
+    mkdirSync(join(process.env.HOME, ".claude", "skillrepo"), { recursive: true });
+    writeFileSync(path, "42");
+    assert.equal(readConfig(), null);
+  });
+
+  it(
+    "returns null when readFileSync throws (path is a directory → EISDIR)",
+    { skip: process.platform === "win32" },
+    () => {
+      // existsSync(path) is true (the directory exists) but readFileSync
+      // on a directory throws EISDIR → the read try/catch returns null.
+      const path = globalConfigPath();
+      mkdirSync(path, { recursive: true });
+      assert.equal(readConfig(), null);
+    },
+  );
 });
 
 // ── writeConfig ────────────────────────────────────────────────────────
@@ -275,6 +305,46 @@ describe("writeConfig", () => {
       chmodSync(grandParent, 0o755);
     }
   });
+
+  it(
+    "throws diskError when the temp file can't be written (tmp path is a directory)",
+    { skip: process.platform === "win32" },
+    () => {
+      // The parent dir exists and is writable, but `<path>.tmp` is itself
+      // a directory, so writeFileSync(tmpPath) throws EISDIR → the
+      // temp-write try/catch surfaces a diskError. This covers the
+      // tmp-write failure branch distinct from the parent-dir branch.
+      const path = globalConfigPath();
+      mkdirSync(join(process.env.HOME, ".claude", "skillrepo"), { recursive: true });
+      mkdirSync(`${path}.tmp`, { recursive: true });
+      assert.throws(
+        () => writeConfig({ apiKey: "sk_live_abc", serverUrl: "https://example.com" }),
+        (err) => err instanceof CliError && err.exitCode === EXIT_DISK,
+      );
+    },
+  );
+
+  it(
+    "throws diskError when the rename fails and still cleans up the temp file",
+    { skip: process.platform === "win32" },
+    () => {
+      // Destination `path` is a NON-EMPTY directory: the temp write +
+      // chmod succeed, but renameSync(tmp, path) throws (can't replace a
+      // non-empty dir with a file). This exercises the rename try/catch
+      // AND the best-effort tmp cleanup (the .tmp file must be removed so
+      // a live key isn't left on disk).
+      const path = globalConfigPath();
+      mkdirSync(path, { recursive: true });
+      // Make the destination directory non-empty so rename can't clobber it.
+      writeFileSync(join(path, "occupant"), "x");
+      assert.throws(
+        () => writeConfig({ apiKey: "sk_live_abc", serverUrl: "https://example.com" }),
+        (err) => err instanceof CliError && err.exitCode === EXIT_DISK,
+      );
+      // The temp file must have been cleaned up (no live key left behind).
+      assert.ok(!existsSync(`${path}.tmp`), "stale .tmp must be unlinked on rename failure");
+    },
+  );
 });
 
 // ── clearConfig ────────────────────────────────────────────────────────
@@ -293,4 +363,21 @@ describe("clearConfig", () => {
     assert.equal(clearConfig(), true);
     assert.ok(!existsSync(globalConfigPath()));
   });
+
+  it(
+    "throws diskError when the path can't be unlinked (path is a non-empty directory)",
+    { skip: process.platform === "win32" },
+    () => {
+      // existsSync(path) is true so clearConfig attempts unlinkSync, but
+      // unlinking a non-empty directory throws (EISDIR/ENOTEMPTY/EPERM) →
+      // the catch surfaces a diskError rather than silently swallowing.
+      const path = globalConfigPath();
+      mkdirSync(path, { recursive: true });
+      writeFileSync(join(path, "occupant"), "x");
+      assert.throws(
+        () => clearConfig(),
+        (err) => err instanceof CliError && err.exitCode === EXIT_DISK,
+      );
+    },
+  );
 });

package/src/test/lib/crypto-shas.test.mjs

@@ -156,6 +156,23 @@ describe("computeSkillShas", () => {
     assert.equal(result.filesSha256, sha256Utf8(expectedProjection));
   });
 
+  it("handles equal paths in the sort comparator (returns 0 arm)", () => {
+    // The internal byte-order comparator's equal-path arm
+    // (`a.path === b.path → 0`) is only reached when two entries share
+    // a path. computeSkillShas does not dedupe (that's validateSkill's
+    // job upstream), so identical paths are valid input here and must
+    // not crash. With two identical entries the projection is the same
+    // line twice, joined by "\n".
+    const result = computeSkillShas([
+      { path: "dup.md", content: "one\n" },
+      { path: "dup.md", content: "one\n" },
+    ]);
+    const shaDup = sha256Utf8("one\n");
+    const expectedProjection = `dup.md|${shaDup}\ndup.md|${shaDup}`;
+    assert.equal(result.filesSha256, sha256Utf8(expectedProjection));
+    assert.equal(result.skillMdSha256, null);
+  });
+
   it("throws TypeError on non-array input", () => {
     assert.throws(() => computeSkillShas(null), TypeError);
     assert.throws(() => computeSkillShas(undefined), TypeError);