skillrepo 4.8.0 → 4.8.2

package/src/test/lib/mcp-merge.test.mjs

@@ -185,6 +185,163 @@ describe("mergeMcpForVendors — preview messages", () => {
     // The merge should fail, not merge
     assert.equal(results[0].outcome, "failed");
   });
+
+  it("previews warning when existing JSON is valid but not an object (array)", async () => {
+    // Parses fine but `typeof config !== "object"`-style guard: an
+    // array is typeof "object" yet semantically wrong, and a bare
+    // number/string is the real non-object case. Use a JSON number.
+    writeFileSync(join(process.cwd(), ".mcp.json"), "42");
+    const results = await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /not a JSON object/);
+    // The underlying merger still runs on "yes" and throws (number is
+    // not a valid config), so the outcome is "failed".
+    assert.equal(results[0].outcome, "failed");
+  });
+
+  it("previews warning when existing JSON is null", async () => {
+    // JSON `null` parses to null → the `!config` half of the guard.
+    writeFileSync(join(process.cwd(), ".mcp.json"), "null");
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /not a JSON object/);
+  });
+
+  it("previews 'add skillrepo entry to empty mcpServers' when no other servers", async () => {
+    // Existing file with an empty mcpServers object and no skillrepo
+    // entry → the "no other servers" add branch.
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({ mcpServers: {} }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /add skillrepo entry to empty mcpServers/);
+  });
+
+  it("previews 'update existing (no other servers)' when only skillrepo present", async () => {
+    // skillrepo entry exists and is the only server → the existingEntry
+    // + otherServers.length === 0 branch.
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({ mcpServers: { skillrepo: { url: "https://old.example" } } }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://new.example/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /update existing skillrepo entry \(no other servers\)/);
+  });
+
+  it("previews singular server count for one other server (add branch)", async () => {
+    // One other server, no skillrepo → singular "1 existing server".
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({ mcpServers: { only: { url: "https://only.example" } } }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /1 existing server preserved/);
+    assert.doesNotMatch(stdout.text(), /1 existing servers preserved/);
+  });
+
+  it("previews plural server count for multiple other servers (add branch)", async () => {
+    // Two other servers, no skillrepo → plural "2 existing servers"
+    // (covers the "s" arm of the add-branch ternary).
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          alpha: { url: "https://alpha.example" },
+          beta: { url: "https://beta.example" },
+        },
+      }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /2 existing servers preserved: alpha, beta/);
+  });
+
+  it("previews update with one other server (singular update branch)", async () => {
+    // skillrepo entry present + exactly one other server → the update
+    // branch's singular "1 other server preserved".
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          skillrepo: { url: "https://old.example" },
+          alpha: { url: "https://alpha.example" },
+        },
+      }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://new.example/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /update existing skillrepo entry \(1 other server preserved: alpha\)/);
+  });
+
+  it("previews update with multiple other servers (plural update branch)", async () => {
+    // skillrepo entry present + two other servers → the update branch's
+    // plural "2 other servers preserved".
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          skillrepo: { url: "https://old.example" },
+          alpha: { url: "https://alpha.example" },
+          beta: { url: "https://beta.example" },
+        },
+      }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://new.example/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /update existing skillrepo entry \(2 other servers preserved: alpha, beta\)/);
+  });
+
+  it("previews 'add to empty mcpServers' when the mcpServers key is absent entirely", async () => {
+    // Valid object with NO mcpServers key → the `?? {}` fallback on
+    // config.mcpServers fires, yielding an empty server set.
+    writeFileSync(
+      join(process.cwd(), ".mcp.json"),
+      JSON.stringify({ unrelated: true }),
+    );
+    await mergeMcpForVendors({
+      vendors: ["claudeCode"],
+      mcpUrl: "https://x.com/mcp",
+      yes: true,
+      io: { stdout, stderr },
+    });
+    assert.match(stdout.text(), /add skillrepo entry to empty mcpServers/);
+  });
 });
 
 // ── mergeMcpForVendors — user declined ─────────────────────────────────

package/src/test/lib/npm-update-check.test.mjs

@@ -655,6 +655,186 @@ describe("constants", () => {
   });
 });
 
+// ── readCache field-validation branches (each malformed shape → miss) ──
+//
+// readCache parses the on-disk file then rejects it field-by-field. Each
+// of these seeds a JSON-parseable cache file that passes the prior gates
+// but trips exactly one validation branch, proving the entry is treated
+// as a miss (a re-fetch fires). The "wrong schemaVersion" case is already
+// covered above; these cover the remaining per-field guards.
+
+describe("checkForCliUpdate (readCache field validation → cache miss)", () => {
+  const validFetch = () =>
+    makeIo({ fetchResult: { ok: true, json: async () => ({ version: "4.5.0" }) } });
+
+  it("treats a non-object JSON cache (e.g. `null`) as a miss", async () => {
+    mkdirSync(join(testHome, ".claude", "skillrepo"), { recursive: true });
+    writeFileSync(cachePath(), "null", "utf-8");
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1, "non-object cache must force a re-fetch");
+    assert.equal(result.nudged, true);
+  });
+
+  it("treats a missing checkedAt (non-string) as a miss", async () => {
+    writeCacheFile({
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      // checkedAt intentionally a number, not a string
+      checkedAt: 12345,
+      currentCliVersion: "4.3.0",
+      latestPublishedVersion: "4.5.0",
+      fetchOk: true,
+    });
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1);
+    assert.equal(result.nudged, true);
+  });
+
+  it("treats a missing currentCliVersion (non-string) as a miss", async () => {
+    writeCacheFile({
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      checkedAt: new Date().toISOString(),
+      // currentCliVersion intentionally missing
+      latestPublishedVersion: "4.5.0",
+      fetchOk: true,
+    });
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1);
+    assert.equal(result.nudged, true);
+  });
+
+  it("treats a non-boolean fetchOk as a miss", async () => {
+    writeCacheFile({
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      checkedAt: new Date().toISOString(),
+      currentCliVersion: "4.3.0",
+      latestPublishedVersion: "4.5.0",
+      fetchOk: "yes", // not a boolean
+    });
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1);
+    assert.equal(result.nudged, true);
+  });
+
+  it("treats a latestPublishedVersion of the wrong type (number) as a miss", async () => {
+    // latestPublishedVersion may be a string OR null; a number is
+    // neither and must invalidate the entry.
+    writeCacheFile({
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      checkedAt: new Date().toISOString(),
+      currentCliVersion: "4.3.0",
+      latestPublishedVersion: 450, // wrong type
+      fetchOk: true,
+    });
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1);
+    assert.equal(result.nudged, true);
+  });
+
+  it("treats an unparseable checkedAt timestamp as not-fresh (isCacheFresh re-fetches)", async () => {
+    // The field IS a string (passes readCache) but Date.parse can't
+    // parse it → isCacheFresh's `Number.isFinite(checkedAtMs)` is false
+    // → re-fetch.
+    writeCacheFile({
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      checkedAt: "not-a-real-date",
+      currentCliVersion: "4.3.0",
+      latestPublishedVersion: "4.5.0",
+      fetchOk: true,
+    });
+    const fixture = validFetch();
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(fixture.getFetchCalls().length, 1, "unparseable checkedAt must re-fetch");
+    assert.equal(result.nudged, true);
+  });
+});
+
+// ── fetchLatestVersion + emitNudge + no-fetch edge branches ────────────
+
+describe("checkForCliUpdate (fetch body + emit + no-fetch edges)", () => {
+  it("a JSON body that is not an object (null) yields no result", async () => {
+    // `!body || typeof body !== "object"` — the registry returns a bare
+    // `null` JSON body. fetchLatestVersion bails before reading
+    // `.version`, the cache records fetchOk:false, and no nudge fires.
+    const fixture = makeIo({
+      fetchResult: { ok: true, json: async () => null },
+    });
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(result.nudged, false);
+    assert.equal(JSON.parse(fixture.getWriteCalls()[0].contents).fetchOk, false);
+  });
+
+  it("a no-result is treated identically when no fetch impl is available", async () => {
+    // `typeof resolvedIo.fetch !== "function"` — a truthy-but-not-callable
+    // fetch (defensive against a misconfigured DI) short-circuits with
+    // reason "no-fetch" and never attempts a network call or cache write.
+    const fixture = makeIo({
+      fetchResult: { ok: true, json: async () => ({ version: "4.5.0" }) },
+    });
+    fixture.io.fetch = 42; // truthy, not a function
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    assert.equal(result.nudged, false);
+    assert.equal(result.reason, "no-fetch");
+    assert.equal(fixture.getWriteCalls().length, 0, "no cache write without a fetch impl");
+  });
+
+  it("a throwing stderrWrite during the nudge is swallowed (never crashes)", async () => {
+    // emitNudge wraps the stderr write in try/catch so a closed pipe
+    // can't break the user's flow. Inject a stderrWrite that throws and
+    // assert the call still resolves nudged:true.
+    const fixture = makeIo({
+      fetchResult: { ok: true, json: async () => ({ version: "4.5.0" }) },
+    });
+    fixture.io.stderrWrite = () => {
+      throw new Error("EPIPE: write to closed stream");
+    };
+    const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+    // The nudge "fired" (we attempted to write) even though the write
+    // threw — the return value reflects the decision, not the I/O outcome.
+    assert.equal(result.nudged, true);
+  });
+});
+
+// ── dim/bold ANSI styling under a TTY without NO_COLOR ─────────────────
+
+describe("checkForCliUpdate (nudge styling — TTY color branch)", () => {
+  it("emits ANSI dim/bold escapes when stderr is a TTY and NO_COLOR is unset", async () => {
+    // The `dim`/`bold` helpers gate on `process.stderr.isTTY &&
+    // !process.env.NO_COLOR`. Every other test runs under a piped
+    // (non-TTY) stderr, so only the no-color branch is exercised. Force
+    // the TTY branch deterministically and assert the emitted nudge
+    // carries the ANSI escape codes.
+    const originalIsTTY = process.stderr.isTTY;
+    const prevNoColor = process.env.NO_COLOR;
+    delete process.env.NO_COLOR;
+    Object.defineProperty(process.stderr, "isTTY", {
+      value: true,
+      configurable: true,
+    });
+    const fixture = makeIo({
+      fetchResult: { ok: true, json: async () => ({ version: "4.5.0" }) },
+    });
+    try {
+      const result = await checkForCliUpdate({ currentVersion: "4.3.0", io: fixture.io });
+      assert.equal(result.nudged, true);
+      const out = fixture.getStderrWrites().join("");
+      assert.ok(out.includes("\x1b[2m"), "dim() must emit the ANSI dim escape on a TTY");
+      assert.ok(out.includes("\x1b[1m"), "bold() must emit the ANSI bold escape on a TTY");
+    } finally {
+      Object.defineProperty(process.stderr, "isTTY", {
+        value: originalIsTTY,
+        configurable: true,
+      });
+      if (prevNoColor === undefined) delete process.env.NO_COLOR;
+      else process.env.NO_COLOR = prevNoColor;
+    }
+  });
+});
+
 // ── Notes on coverage gaps ─────────────────────────────────────────────
 //
 // 1. The `--json` suppression lives in `bin/skillrepo.mjs`. Asserting

package/src/test/lib/placement-walk.test.mjs

@@ -29,6 +29,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 
 import { walkDetectedPlacements, walkPlacementTarget } from "../../lib/placement-walk.mjs";
 import { computeSkillShas } from "../../lib/crypto-shas.mjs";
@@ -348,6 +349,137 @@ describe("walkPlacementTarget", () => {
     assert.equal(result.length, 1);
     assert.equal(result[0].skillName, "cohort-skill");
   });
+
+  it("returns empty array when the parent root exists but is unreadable (readdir EACCES)", () => {
+    // Covers the `catch` around readdirSync(parentDir): the root dir
+    // exists (so the existsSync gate passes) but cannot be listed.
+    // chmod 000 makes readdir throw EACCES → the walker swallows it and
+    // returns []. Skipped on Windows (chmod is a no-op) and root (root
+    // bypasses permission checks).
+    if (process.platform === "win32" || process.getuid?.() === 0) return;
+
+    const parent = join(process.cwd(), ".claude", "skills");
+    mkdirSync(parent, { recursive: true });
+    seedSkill(parent, "hidden", [
+      { path: "SKILL.md", content: skillMd("hidden") },
+    ]);
+    chmodSync(parent, 0o000);
+    try {
+      assert.deepEqual(walkPlacementTarget("claudeProject"), []);
+    } finally {
+      chmodSync(parent, 0o755);
+    }
+  });
+
+  it("skips a root entry whose lstat fails (no-exec parent dir)", () => {
+    // Covers the `catch` around lstatSync(skillDir) for an entry at the
+    // parent root. A directory with read but NOT execute (search)
+    // permission lets readdirSync enumerate the names but makes
+    // lstatSync on each child fail with EACCES. The walker `continue`s
+    // past the unstatable entry, yielding an empty result rather than
+    // crashing.
+    if (process.platform === "win32" || process.getuid?.() === 0) return;
+
+    const parent = join(process.cwd(), ".claude", "skills");
+    mkdirSync(parent, { recursive: true });
+    seedSkill(parent, "unstatable", [
+      { path: "SKILL.md", content: skillMd("unstatable") },
+    ]);
+    // 0o444 = read but no execute/search → readdir lists, lstat denied.
+    chmodSync(parent, 0o444);
+    try {
+      const result = walkPlacementTarget("claudeProject");
+      // The entry could not be stat'd, so it is skipped entirely.
+      assert.deepEqual(result, []);
+    } finally {
+      chmodSync(parent, 0o755);
+    }
+  });
+
+  it("produces null SHAs when a skill contains an unreadable SUBDIRECTORY (recursive readdir EACCES)", () => {
+    // Covers the `catch` around the recursive readdirSync(currentDir)
+    // for a nested directory inside a skill. The subdir exists but
+    // chmod 000 makes its listing fail → onError fires → readError set
+    // → computeShasFromDir gate returns null SHAs.
+    if (process.platform === "win32" || process.getuid?.() === 0) return;
+
+    const parent = join(process.cwd(), ".claude", "skills");
+    const skillDir = join(parent, "bad-subdir");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd("bad-subdir"), "utf8");
+    const subDir = join(skillDir, "references");
+    mkdirSync(subDir, { recursive: true });
+    writeFileSync(join(subDir, "note.md"), "# note\n", "utf8");
+    chmodSync(subDir, 0o000);
+    try {
+      const result = walkPlacementTarget("claudeProject");
+      assert.equal(result.length, 1);
+      assert.equal(result[0].skillName, "bad-subdir");
+      assert.equal(result[0].skillMdSha256, null);
+      assert.equal(result[0].filesSha256, null);
+    } finally {
+      chmodSync(subDir, 0o755);
+    }
+  });
+
+  it("skips a non-regular-file entry inside a skill (FIFO / named pipe)", () => {
+    // Covers the `if (!stat.isFile()) continue` guard in the recursive
+    // walk: an entry that is neither a symlink, a directory, nor a
+    // regular file (a FIFO here) is skipped — only the real SKILL.md is
+    // hashed. POSIX-only: FIFOs require `mkfifo`, which Windows lacks,
+    // and Node has no portable FIFO-creation API.
+    if (process.platform === "win32") return;
+    let mkfifoOk = true;
+    const parent = join(process.cwd(), ".claude", "skills");
+    const skillDir = join(parent, "with-fifo");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd("with-fifo"), "utf8");
+    try {
+      execFileSync("mkfifo", [join(skillDir, "pipe")]);
+    } catch {
+      // mkfifo not available on this runner — nothing to assert.
+      mkfifoOk = false;
+    }
+    if (!mkfifoOk) return;
+
+    const result = walkPlacementTarget("claudeProject");
+    assert.equal(result.length, 1);
+    assert.equal(result[0].skillName, "with-fifo");
+    // The FIFO contributed nothing; the SHAs reflect SKILL.md alone.
+    const expected = computeSkillShas([
+      { path: "SKILL.md", content: skillMd("with-fifo") },
+    ]);
+    assert.equal(result[0].skillMdSha256, expected.skillMdSha256);
+    assert.equal(result[0].filesSha256, expected.filesSha256);
+  });
+
+  it("produces null SHAs when a nested entry's lstat fails (recursive lstat EACCES)", () => {
+    // Covers the `catch` around the recursive lstatSync(fullPath) for an
+    // entry inside a subdirectory. The subdir is readable (readdir lists
+    // its children) but has no execute bit, so lstat on each child fails
+    // → onError → readError → null SHAs.
+    if (process.platform === "win32" || process.getuid?.() === 0) return;
+
+    const parent = join(process.cwd(), ".claude", "skills");
+    const skillDir = join(parent, "bad-nested-stat");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd("bad-nested-stat"), "utf8");
+    const subDir = join(skillDir, "references");
+    mkdirSync(subDir, { recursive: true });
+    writeFileSync(join(subDir, "note.md"), "# note\n", "utf8");
+    // 0o444 → readable (readdir lists "note.md") but not searchable
+    // (lstat on note.md denied).
+    chmodSync(subDir, 0o444);
+    try {
+      const result = walkPlacementTarget("claudeProject");
+      assert.equal(result.length, 1);
+      assert.equal(result[0].skillName, "bad-nested-stat");
+      assert.equal(result[0].skillMdSha256, null);
+      assert.equal(result[0].filesSha256, null);
+    } finally {
+      chmodSync(subDir, 0o755);
+    }
+  });
 });
 
 // ── walkDetectedPlacements ──────────────────────────────────────────────

package/src/test/lib/skill-walk.test.mjs

@@ -11,7 +11,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -110,6 +110,44 @@ describe("walkSkillFiles", () => {
     assert.deepEqual(paths, ["SKILL.md"]);
   });
 
+  it("returns an empty array when the skill directory does not exist (ENOENT)", async () => {
+    // readdir on a missing root throws ENOENT — the walker swallows it
+    // and returns [] rather than propagating.
+    const walked = await walkSkillFiles(join(sandbox, "does-not-exist"));
+    assert.deepEqual(walked, []);
+  });
+
+  it("re-throws non-ENOENT readdir errors (ENOTDIR when the path is a file)", async () => {
+    // readdir on a regular file throws ENOTDIR, which is NOT swallowed —
+    // it must propagate so the caller learns the path is not a directory.
+    const filePath = join(sandbox, "not-a-dir.txt");
+    writeFileSync(filePath, "x");
+    await assert.rejects(
+      () => walkSkillFiles(filePath),
+      (err) => err && err.code === "ENOTDIR",
+    );
+  });
+
+  it(
+    "skips symlink entries (not regular files)",
+    { skip: process.platform === "win32" },
+    async () => {
+      // A symlink-to-file is not `entry.isFile()`, so the walker skips
+      // it via the `if (!entry.isFile()) continue` guard. Only the real
+      // SKILL.md is collected.
+      file("SKILL.md");
+      const realTarget = join(sandbox, "real.md");
+      writeFileSync(realTarget, "real");
+      symlinkSync(realTarget, join(sandbox, "link.md"));
+
+      const walked = await walkSkillFiles(sandbox);
+      const paths = walked.map((f) => f.relativePath);
+      assert.ok(!paths.includes("link.md"), "symlink should be excluded");
+      assert.ok(paths.includes("SKILL.md"));
+      assert.ok(paths.includes("real.md"));
+    },
+  );
+
   it("returns absolute paths + sizes for each file", async () => {
     file("SKILL.md", "ab");
     file("references/a.md", "abc");