skillrepo 4.8.0 → 4.8.2

package/src/test/commands/init.test.mjs

@@ -15,8 +15,8 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runInit } from "../../commands/init.mjs";
-import { readConfig } from "../../lib/config.mjs";
+import { runInit, directoryHasContent } from "../../commands/init.mjs";
+import { readConfig, writeConfig } from "../../lib/config.mjs";
 import { CliError, EXIT_AUTH, EXIT_VALIDATION } from "../../lib/errors.mjs";
 import { AGENT_REGISTRY } from "../../lib/agent-registry.mjs";
 import { createMockServer } from "../e2e/mock-server.mjs";
@@ -2154,3 +2154,160 @@ describe("runInit — v3.1.2 step 6 auto-install (npx)", () => {
     assert.equal(settings.hooks.SessionStart[0].hooks.length, 1);
   });
 });
+
+// ── Non-fatal write-failure warnings (#646) ──────────────────────────
+//
+// init writes .env.local and .gitignore as best-effort steps AFTER the
+// config is already saved. A failure on either must produce a warning
+// and let init continue — never abort setup. These catch/warn branches
+// had no coverage. Triggered cross-platform by occupying the target
+// path with a directory so the write throws (no chmod needed).
+describe("runInit — non-fatal write-failure warnings", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("warns but completes when .env.local cannot be written", async () => {
+    mkdirSync(join(process.cwd(), ".env.local"), { recursive: true });
+    await assert.doesNotReject(
+      () =>
+        runInit(
+          ["--key", VALID_KEY, "--url", serverUrl, "--yes", "--agent", "claude", "--no-session-sync"],
+          { stdout, stderr },
+        ),
+      "a .env.local write failure must NOT abort init (config is already saved)",
+    );
+    assert.match(stdout.text() + stderr.text(), /Could not write \.env\.local/);
+  });
+
+  it("warns but completes when .gitignore cannot be written", async () => {
+    mkdirSync(join(process.cwd(), ".gitignore"), { recursive: true });
+    await assert.doesNotReject(
+      () =>
+        runInit(
+          ["--key", VALID_KEY, "--url", serverUrl, "--yes", "--agent", "claude", "--no-session-sync"],
+          { stdout, stderr },
+        ),
+      "a .gitignore write failure must NOT abort init",
+    );
+    assert.match(stdout.text() + stderr.text(), /Could not update \.gitignore/);
+  });
+});
+
+// ── Credential prompt + stale-key recovery (#1923, deps.promptFn seam) ──
+//
+// Exercises the step-1 interactive credential prompt and the step-2
+// stale-key re-prompt recovery (including BOTH reportInitFailure telemetry
+// call sites) via the deps.promptFn seam — no real TTY/stdin. A server
+// with a fixed validKey makes any other key 401, so the re-prompt can fail
+// twice. Every path here THROWS at step 2 (validate), so it never reaches
+// the later interactive steps (5 MCP / 6 session-sync).
+describe("runInit — credential prompt + stale-key recovery", () => {
+  let sb, srv, srvUrl, origCwd, origHome, origDetect, out, err;
+  const RIGHT = "sk_live_init_right_key";
+
+  beforeEach(async () => {
+    sb = mkdtempSync(join(tmpdir(), "cli-init-cred-"));
+    mkdirSync(join(sb, "project"), { recursive: true });
+    mkdirSync(join(sb, "home"), { recursive: true });
+    origCwd = process.cwd();
+    origHome = captureHome();
+    origDetect = {};
+    for (const n of DETECTION_ENV_VARS) {
+      origDetect[n] = process.env[n];
+      delete process.env[n];
+    }
+    process.chdir(join(sb, "project"));
+    setSandboxHome(join(sb, "home"));
+    delete process.env.SKILLREPO_ACCESS_KEY;
+    delete process.env.SKILLREPO_URL;
+    // Only RIGHT validates; any other sk_live_ key → 401 on every call.
+    srv = createMockServer({}, { validKey: RIGHT });
+    const port = await srv.start();
+    srvUrl = `http://127.0.0.1:${port}`;
+    out = createCaptureStream();
+    err = createCaptureStream();
+  });
+
+  afterEach(async () => {
+    if (srv) await srv.stop();
+    process.chdir(origCwd);
+    restoreHome(origHome);
+    for (const n of DETECTION_ENV_VARS) {
+      if (origDetect[n] === undefined) delete process.env[n];
+      else process.env[n] = origDetect[n];
+    }
+    if (sb) rmSync(sb, { recursive: true, force: true });
+    srv = null;
+  });
+
+  it("step-1 prompt fires when no key/config; a wrong typed key fails validate (else branch + telemetry)", async () => {
+    // No --key, no existing config, not --yes → the interactive
+    // promptForKey branch runs. The injected prompt returns a wrong key →
+    // validate 401 → non-recoverable else branch (no existingConfig) →
+    // reportInitFailure + rethrow. Covers the step-1 prompt branch and the
+    // step-2 else reportInitFailure call site.
+    let prompted = 0;
+    const promptFn = async () => {
+      prompted++;
+      return "sk_live_wrong_typed";
+    };
+    await assert.rejects(
+      () => runInit(["--url", srvUrl], { stdout: out, stderr: err }, { promptFn }),
+      (e) => e instanceof CliError && e.exitCode === EXIT_AUTH,
+    );
+    assert.equal(prompted, 1, "the step-1 credential prompt must have fired exactly once");
+  });
+
+  it("stale config key → 401 → re-prompt → still 401 → reportInitFailure + rethrow", async () => {
+    writeConfig({ apiKey: "sk_live_stale_old_key", serverUrl: srvUrl });
+    let prompted = 0;
+    const promptFn = async () => {
+      prompted++;
+      return "sk_live_still_wrong_key";
+    };
+    await assert.rejects(
+      () => runInit(["--url", srvUrl], { stdout: out, stderr: err }, { promptFn }),
+      (e) => e instanceof CliError && e.exitCode === EXIT_AUTH,
+    );
+    assert.equal(prompted, 1, "the stale-key re-prompt must have fired");
+    assert.match(out.text() + err.text(), /invalid key|re-prompt/i, "must warn before re-prompting");
+  });
+
+  it("stale config key → 401 → re-prompt with an invalid-format key → validation error", async () => {
+    writeConfig({ apiKey: "sk_live_stale_old_key", serverUrl: srvUrl });
+    const promptFn = async () => "not-a-valid-key"; // no sk_live_ prefix
+    await assert.rejects(
+      () => runInit(["--url", srvUrl], { stdout: out, stderr: err }, { promptFn }),
+      (e) => e instanceof CliError && e.exitCode === EXIT_VALIDATION,
+    );
+  });
+});
+
+// ── directoryHasContent (exported helper) ─────────────────────────────
+describe("directoryHasContent", () => {
+  it("swallows a readdirSync error (path is a file, not a dir) → false", () => {
+    // existsSync(file) is true but readdirSync(file) throws ENOTDIR — the
+    // catch must treat it as "no content" (false), not crash. Cross-
+    // platform: ENOTDIR fires identically on POSIX and Windows.
+    const tmp = mkdtempSync(join(tmpdir(), "dhc-"));
+    const filePath = join(tmp, "a-file");
+    writeFileSync(filePath, "x");
+    try {
+      assert.equal(directoryHasContent(filePath), false);
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("true for a non-empty dir; false for empty and absent dirs", () => {
+    const tmp = mkdtempSync(join(tmpdir(), "dhc2-"));
+    try {
+      assert.equal(directoryHasContent(tmp), false, "empty dir");
+      writeFileSync(join(tmp, "x"), "1");
+      assert.equal(directoryHasContent(tmp), true, "non-empty dir");
+      assert.equal(directoryHasContent(join(tmp, "nope")), false, "absent dir");
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});