skillrepo 4.8.0 → 4.8.2

package/src/test/commands/session-sync.test.mjs

@@ -27,7 +27,10 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runSessionSync } from "../../commands/session-sync.mjs";
-import { buildHookCommand } from "../../lib/mergers/session-hook.mjs";
+import {
+  buildHookCommand,
+  resolveSkillrepoBinary,
+} from "../../lib/mergers/session-hook.mjs";
 import { SESSION_HOOK_FINGERPRINT } from "../../lib/artifact-registry.mjs";
 import { createCaptureStream } from "../helpers/capture-stream.mjs";
 import { CliError, EXIT_VALIDATION } from "../../lib/errors.mjs";
@@ -146,6 +149,43 @@ describe("session-sync enable", () => {
     assert.ok(hasHook, "SkillRepo hook must be present");
   });
 
+  it("reports 'updated' when an existing SkillRepo hook has a stale command", async () => {
+    // INTENT: a prior SkillRepo hook pointing at a DIFFERENT binary path
+    // (e.g. from an older install location) must be upgraded in place —
+    // not duplicated, not left stale. This is the 'updated' branch of
+    // printEnableResult, which no test exercised (only installed/unchanged
+    // were covered).
+    ASSERT_HOME_ISOLATED();
+    mkdirSync(join(process.cwd(), ".claude"), { recursive: true });
+    const settingsPath = join(process.cwd(), ".claude", "settings.local.json");
+    const staleCommand = buildHookCommand("/old/location/skillrepo");
+    assert.ok(
+      staleCommand.includes(SESSION_HOOK_FINGERPRINT),
+      "precondition: seeded command is a SkillRepo hook",
+    );
+    writeFileSync(
+      settingsPath,
+      JSON.stringify(
+        { hooks: { SessionStart: [{ hooks: [{ type: "command", command: staleCommand }] }] } },
+        null,
+        2,
+      ),
+    );
+
+    await runSessionSync(["enable"], { stdout, stderr });
+
+    assert.match(stdout.text(), /updated/i, "a stale SkillRepo hook must report 'updated'");
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const skillrepoHooks = parsed.hooks.SessionStart.flatMap((g) => g.hooks)
+      .map((h) => h.command)
+      .filter((c) => c.includes(SESSION_HOOK_FINGERPRINT));
+    assert.equal(skillrepoHooks.length, 1, "must not duplicate the SkillRepo hook");
+    assert.ok(
+      !skillrepoHooks.includes(staleCommand),
+      "the stale command must be replaced with the current one",
+    );
+  });
+
   it("is idempotent — second enable returns 'unchanged'", async () => {
     // INTENT: users re-running `session-sync enable` must get a clear
     // "nothing to do" response, not a duplicate hook.
@@ -219,16 +259,103 @@ describe("session-sync disable", () => {
     assert.match(stdout.text(), /removed/i);
   });
 
+  it("--global removes the hook from the user-wide settings file", async () => {
+    // Symmetry with `enable --global`: disabling with --global must strip
+    // the hook from ~/.claude/settings.local.json (not the project file).
+    // enable --global was tested; disable --global was the gap.
+    ASSERT_HOME_ISOLATED();
+    await runSessionSync(["enable", "--global"], { stdout, stderr });
+    const globalSettings = join(process.env.HOME, ".claude", "settings.local.json");
+    assert.ok(existsSync(globalSettings), "precondition: global hook installed");
+    stdout.clear();
+
+    await runSessionSync(["disable", "--global"], { stdout, stderr });
+
+    const parsed = JSON.parse(readFileSync(globalSettings, "utf-8"));
+    const hasHook = (parsed.hooks?.SessionStart ?? [])
+      .flatMap((g) => g?.hooks ?? [])
+      .some((h) => h?.command?.includes(SESSION_HOOK_FINGERPRINT));
+    assert.ok(!hasHook, "SkillRepo hook must be gone from the global file after disable --global");
+    assert.match(stdout.text(), /removed/i);
+  });
+
   it("reports cleanly when disable runs on a file without the hook", async () => {
     // INTENT: a user running `session-sync disable` when the hook
     // isn't installed must get a clear "nothing to do" response, not
     // an error. This is how automation scripts confirm the final
     // state is "disabled" regardless of prior state.
+    //
+    // NOTE: there is NO settings file here, so the remover returns
+    // `skipped` (no error) and printDisableResult takes the
+    // "no settings file" branch (lines 148-151). The "unchanged"
+    // branch (lines 132-136) is covered by the next test, which
+    // seeds a file that EXISTS but has no SkillRepo hook.
     ASSERT_HOME_ISOLATED();
     await runSessionSync(["disable"], { stdout, stderr });
     assert.match(stdout.text(), /not enabled|not installed|nothing to do/i);
   });
 
+  it("reports 'was not installed — nothing to do' when the file exists but has no SkillRepo hook", async () => {
+    // INTENT: distinct from the no-file case above. The settings file
+    // EXISTS and is valid JSON, but carries only a user-authored hook —
+    // no SkillRepo entry. The remover returns `unchanged` (not
+    // `skipped`), and printDisableResult must take the "was not
+    // installed" branch (lines 132-136), NOT the "no settings file"
+    // fallback. This is the branch the no-file test does NOT hit.
+    ASSERT_HOME_ISOLATED();
+    mkdirSync(join(process.cwd(), ".claude"), { recursive: true });
+    writeFileSync(
+      join(process.cwd(), ".claude", "settings.local.json"),
+      JSON.stringify(
+        {
+          hooks: {
+            SessionStart: [
+              { hooks: [{ type: "command", command: "echo hi" }] },
+            ],
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    await runSessionSync(["disable"], { stdout, stderr });
+
+    const out = stdout.text();
+    assert.match(
+      out,
+      /was not installed|nothing to do/i,
+      "an existing file with no SkillRepo hook must report 'was not installed — nothing to do'",
+    );
+    // It must NOT claim the file is absent — that's the other branch.
+    assert.doesNotMatch(
+      out,
+      /No settings file/i,
+      "must not take the 'no settings file' branch when the file exists",
+    );
+  });
+
+  it("--json emits the 'unchanged' action when the file exists without a SkillRepo hook", async () => {
+    // Locks the structured-output counterpart of the human branch
+    // above: the remover's `unchanged` action surfaces verbatim in
+    // --json mode.
+    ASSERT_HOME_ISOLATED();
+    mkdirSync(join(process.cwd(), ".claude"), { recursive: true });
+    writeFileSync(
+      join(process.cwd(), ".claude", "settings.local.json"),
+      JSON.stringify(
+        { hooks: { SessionStart: [{ hooks: [{ type: "command", command: "echo hi" }] }] } },
+        null,
+        2,
+      ),
+    );
+
+    await runSessionSync(["disable", "--json"], { stdout, stderr });
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "unchanged");
+  });
+
   it("preserves user-authored hooks in the same settings file", async () => {
     // INTENT: disable must only strip SkillRepo's entry — everything
     // the user added must survive.
@@ -350,3 +477,102 @@ describe("session-sync — flag ordering tolerance", () => {
     assert.equal(json.action, "installed");
   });
 });
+
+// Skipped on Windows: this scrubs process.env.PATH to a single empty dir,
+// which is unsafe on the Windows runner (an empty PATH can stall process
+// machinery the test harness relies on). The "skipped" branch is platform-
+// agnostic and covered on the Linux/macOS CI run.
+describe("session-sync enable — binary unresolvable (skipped)", { skip: process.platform === "win32" }, () => {
+  // This block deliberately does NOT install the PATH shim. The
+  // standard `setup` installs a `skillrepo` shim so mergeSessionHook
+  // can resolve a binary path; here we need the OPPOSITE — an
+  // environment where `skillrepo` is UNresolvable so mergeSessionHook
+  // returns `{ action: "skipped", reason: ... }` and printEnableResult
+  // takes the "Could not enable session sync" branch (lines 123-124),
+  // the only enable branch no other test exercised.
+  let localSandbox;
+  let localOriginalCwd;
+  /** @type {import("../helpers/sandbox-home.mjs").HomeEnvSnapshot} */
+  let localHomeEnv;
+  let savedPath;
+  let localStdout;
+  let localStderr;
+
+  beforeEach(() => {
+    localSandbox = mkdtempSync(join(tmpdir(), "cli-cmd-session-sync-noshim-"));
+    mkdirSync(join(localSandbox, "project"), { recursive: true });
+    mkdirSync(join(localSandbox, "home"), { recursive: true });
+    // An empty bin dir is the ENTIRE PATH — guarantees `skillrepo` is
+    // not resolvable from anywhere (no global install can leak in).
+    mkdirSync(join(localSandbox, "emptybin"), { recursive: true });
+    localOriginalCwd = process.cwd();
+    localHomeEnv = captureHome();
+    process.chdir(join(localSandbox, "project"));
+    setSandboxHome(join(localSandbox, "home"));
+
+    // Replace PATH with a single empty directory. resolveBinaryOnPath
+    // scans PATH dirs for a `skillrepo` file and finds none → returns
+    // null → mergeSessionHook short-circuits to "skipped". Save the
+    // real PATH so teardown restores it (other suites depend on it).
+    savedPath = process.env.PATH;
+    process.env.PATH = join(localSandbox, "emptybin");
+
+    assertHomeIsolated(tmpdir(), "session-sync skipped test");
+
+    localStdout = createCaptureStream();
+    localStderr = createCaptureStream();
+  });
+
+  afterEach(() => {
+    process.chdir(localOriginalCwd);
+    if (savedPath === undefined) {
+      delete process.env.PATH;
+    } else {
+      process.env.PATH = savedPath;
+    }
+    restoreHome(localHomeEnv);
+    if (localSandbox) rmSync(localSandbox, { recursive: true, force: true });
+  });
+
+  it("reports 'Could not enable session sync' when no skillrepo binary is on PATH", async () => {
+    // Precondition: prove the binary genuinely can't be resolved, so
+    // the test isn't silently passing for the wrong reason (e.g. a
+    // global install leaking onto PATH).
+    assert.equal(
+      resolveSkillrepoBinary(),
+      null,
+      "precondition: skillrepo must be unresolvable on the scrubbed PATH",
+    );
+
+    await runSessionSync(["enable"], { stdout: localStdout, stderr: localStderr });
+
+    const out = localStdout.text();
+    assert.match(
+      out,
+      /Could not enable session sync/i,
+      "the skipped branch must surface the human 'Could not enable' message",
+    );
+    // The skipped reason points the user at how to fix it.
+    assert.match(out, /skillrepo/i, "the reason text must be present");
+    // No settings file should have been written.
+    assert.ok(
+      !existsSync(join(process.cwd(), ".claude", "settings.local.json")),
+      "a skipped enable must not write a settings file",
+    );
+  });
+
+  it("--json emits the skipped action + reason when the binary is unresolvable", async () => {
+    // Structured-output counterpart: automation needs to detect the
+    // skipped state programmatically.
+    assert.equal(resolveSkillrepoBinary(), null, "precondition: unresolvable");
+
+    await runSessionSync(["enable", "--json"], {
+      stdout: localStdout,
+      stderr: localStderr,
+    });
+
+    const json = JSON.parse(localStdout.text());
+    assert.equal(json.action, "skipped");
+    assert.ok(json.reason, "reason field must be present in JSON output");
+  });
+});

package/src/test/commands/uninstall.test.mjs

@@ -31,6 +31,8 @@ import {
   readFileSync,
   writeFileSync,
   existsSync,
+  symlinkSync,
+  chmodSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -771,4 +773,218 @@ describe("runUninstall — error handling", () => {
     const giSurvivors = readFileSync(join(projectDir, ".gitignore"), "utf-8");
     assert.doesNotMatch(giSurvivors, /SkillRepo/);
   });
+
+  // ── Basename safety-net (removeDirectoryArtifact 145-151) ─────────
+  //
+  // The inline directory remover resolves `.claude/skills` with
+  // `realpathSync` BEFORE rmSync and refuses to recurse if the
+  // resolved basename is neither "skills" nor "skillrepo". The prior
+  // structural test only greps the source for the assertion text; the
+  // two tests below actually EXERCISE the guard at runtime by pointing
+  // `.claude/skills` at a symlink whose real target is a directory with
+  // a dangerous basename ("important-data"). This is the exact attack
+  // the architect's round-1 review flagged: a `.claude/skills` symlink
+  // pointing at `/home/user/important-data/` whose string-basename is
+  // "skills" but whose rmSync target is the user's real data.
+  //
+  // POSIX-only: symlink semantics differ on Windows and the guard's
+  // realpath-then-basename logic is exercised identically by these
+  // tests on POSIX, so we skip on win32 rather than fight junction
+  // semantics. The guard's source is the same on both platforms.
+  it(
+    "dry-run + json: basename guard surfaces a refusal error for a symlinked skills dir",
+    { skip: process.platform === "win32" ? "POSIX-only symlink test" : false },
+    async () => {
+      ASSERT_HOME_ISOLATED();
+      // `.claude/skills` → <project>/important-data (target EXISTS, so
+      // existsSync passes and realpathSync resolves — the only way to
+      // reach the basename branch, since a dangling symlink would
+      // short-circuit at the earlier existsSync check).
+      const dangerous = join(projectDir, "important-data");
+      mkdirSync(dangerous, { recursive: true });
+      writeFileSync(join(dangerous, "keepme.txt"), "user data");
+      mkdirSync(join(projectDir, ".claude"), { recursive: true });
+      symlinkSync(dangerous, join(projectDir, ".claude", "skills"));
+
+      await runUninstall(["--dry-run", "--json"], { stdout, stderr });
+
+      const json = JSON.parse(stdout.text());
+      assert.equal(json.action, "dry-run");
+      const dirError = json.errors.find((e) => e.id === "skills-dir-project");
+      assert.ok(
+        dirError,
+        "the symlinked skills dir must appear in errors[] during scan",
+      );
+      assert.match(dirError.error, /Refusing to recursively remove/);
+      assert.match(dirError.error, /important-data/);
+      // Nothing was touched — dry run.
+      assert.ok(existsSync(join(dangerous, "keepme.txt")));
+    },
+  );
+
+  it(
+    "execute: basename guard refuses rmSync, reports the error, and leaves the target intact (covers stderr error summary + EXIT_DISK)",
+    { skip: process.platform === "win32" ? "POSIX-only symlink test" : false },
+    async () => {
+      ASSERT_HOME_ISOLATED();
+      const dangerous = join(projectDir, "important-data");
+      mkdirSync(dangerous, { recursive: true });
+      writeFileSync(join(dangerous, "keepme.txt"), "user data");
+      mkdirSync(join(projectDir, ".claude"), { recursive: true });
+      symlinkSync(dangerous, join(projectDir, ".claude", "skills"));
+
+      // Non-JSON so the human-readable stderr error summary path
+      // (the "⚠ Some artifacts could not be removed" block) runs.
+      let thrown;
+      try {
+        await runUninstall(["--yes"], { stdout, stderr });
+      } catch (err) {
+        thrown = err;
+      }
+
+      // Aggregated failures propagate as EXIT_DISK.
+      assert.ok(thrown, "a refused removal must throw");
+      assert.equal(thrown.exitCode, 3, "must carry EXIT_DISK");
+
+      // The stderr summary block rendered the refusal.
+      assert.match(stderr.text(), /Some artifacts could not be removed/);
+      assert.match(stderr.text(), /Refusing to recursively remove/);
+      assert.match(
+        stderr.text(),
+        /re-run `skillrepo uninstall`/,
+        "the remediation hint must render",
+      );
+
+      // CRITICAL: the symlink target survived. The guard did its job.
+      assert.ok(
+        existsSync(join(dangerous, "keepme.txt")),
+        "the symlink target must NOT be removed by rmSync",
+      );
+    },
+  );
+
+  // ── Thrown-remover catch (execute phase 311-321) ─────────────────
+  //
+  // The corrupt-JSON test above covers a remover that RETURNS an error.
+  // This one covers a remover that THROWS during the execute phase — a
+  // different branch (the `catch (err)` that wraps the result). We make
+  // the .gitignore remover throw by making the project directory
+  // read-only AFTER seeding: the scan phase only reads (succeeds), but
+  // the execute phase's atomic write (temp-file + rename) fails with
+  // EACCES, which `writeFileAtomic` re-throws.
+  //
+  // POSIX-only: chmod 0555 has no equivalent enforcement on Windows.
+  it(
+    "continues and aggregates when a remover throws mid-execute (read-only project dir)",
+    { skip: process.platform === "win32" ? "POSIX-only chmod test" : false },
+    async () => {
+      ASSERT_HOME_ISOLATED();
+      // Seed ONLY a .gitignore section so exactly one artifact is in the
+      // scanned set — keeps the assertion focused on the throw path.
+      seedInstalledProject({
+        mcpSkillrepo: false,
+        envLocalHasKey: false,
+        gitignoreHasSection: true,
+        skillsDir: false,
+      });
+
+      chmodSync(projectDir, 0o555);
+      let thrown;
+      try {
+        await runUninstall(["--yes", "--json"], { stdout, stderr });
+      } catch (err) {
+        thrown = err;
+      } finally {
+        // Restore write permission so teardown's rmSync can clean up.
+        chmodSync(projectDir, 0o755);
+      }
+
+      assert.ok(thrown, "a throwing remover must still produce EXIT_DISK");
+      assert.equal(thrown.exitCode, 3);
+
+      const json = JSON.parse(stdout.text());
+      assert.equal(json.action, "partially-uninstalled");
+      const giError = json.errors.find((e) => e.id === "gitignore-entries");
+      assert.ok(giError, ".gitignore write failure must be aggregated");
+      assert.match(giError.error, /EACCES|permission denied|Cannot write/i);
+    },
+  );
+
+  // ── Color wrappers (GREEN/YELLOW/BOLD under a TTY stdout) ─────────
+  //
+  // The three ANSI color helpers only run when stdout is a TTY and
+  // NO_COLOR is unset (`makeColors`). The capture stream is not a TTY
+  // by default, so these wrappers are never exercised — they show as
+  // uncovered functions. We force `isTTY = true` on the capture stream
+  // and seed a state with BOTH a successful removal (green ✓ + bold
+  // header) AND a refused artifact (yellow ⚠) so all three wrappers
+  // fire in a single run. We assert the ANSI escape leaked into the
+  // captured (non-real) stream — proof the colored branch ran.
+  //
+  // POSIX-only: relies on the symlink basename guard to produce the
+  // yellow error branch.
+  it(
+    "emits ANSI color codes when stdout is a TTY (covers GREEN/YELLOW/BOLD)",
+    { skip: process.platform === "win32" ? "POSIX-only symlink test" : false },
+    async () => {
+      ASSERT_HOME_ISOLATED();
+      // makeColors gates on NO_COLOR too — neutralize it for this test
+      // and restore afterward so we don't leak env state across tests.
+      const savedNoColor = process.env.NO_COLOR;
+      delete process.env.NO_COLOR;
+      stdout.isTTY = true;
+      stderr.isTTY = true;
+
+      // A removable artifact (green ✓) ...
+      seedInstalledProject({
+        mcpSkillrepo: false,
+        envLocalHasKey: false,
+        gitignoreHasSection: true,
+        skillsDir: false,
+      });
+      // ... plus a symlinked skills dir that the basename guard refuses
+      // (yellow ⚠).
+      const dangerous = join(projectDir, "important-data");
+      mkdirSync(dangerous, { recursive: true });
+      mkdirSync(join(projectDir, ".claude"), { recursive: true });
+      symlinkSync(dangerous, join(projectDir, ".claude", "skills"));
+
+      let thrown;
+      try {
+        await runUninstall(["--yes"], { stdout, stderr });
+      } catch (err) {
+        thrown = err;
+      } finally {
+        if (savedNoColor === undefined) delete process.env.NO_COLOR;
+        else process.env.NO_COLOR = savedNoColor;
+      }
+
+      assert.ok(thrown, "the refused artifact still drives EXIT_DISK");
+      // ANSI escape (\x1b[) present → the colored branch ran. bold is
+      // in the preview header on stdout, green on the removed line,
+      // yellow on the stderr warning.
+      assert.match(stdout.text(), /\x1b\[/, "stdout must carry ANSI codes under TTY");
+      assert.match(stderr.text(), /\x1b\[33m/, "the yellow warning wrapper must run");
+    },
+  );
+
+  // ── Unknown-flag rejection (parseUninstallFlags acceptPositional) ──
+  //
+  // An unrecognized arg falls through `parseUninstallFlags`'s
+  // acceptPositional callback (which returns `false`), so resolveFlags
+  // raises a validationError. Covers the `return false` tail of the
+  // callback.
+  it("rejects an unknown flag with a validation error", async () => {
+    ASSERT_HOME_ISOLATED();
+    seedInstalledProject();
+
+    await assert.rejects(
+      () => runUninstall(["--bogus"], { stdout, stderr }),
+      (err) => {
+        assert.equal(err.exitCode, 5, "unknown flag must be a validation error");
+        assert.match(err.message, /Unknown argument/);
+        return true;
+      },
+    );
+  });
 });