@inetafrica/open-claudia 3.0.44 → 3.1.1

package/test-tool-manifest.js

@@ -106,5 +106,37 @@ const approvals = require("./core/approvals");
   approvals.decide(rec3.id, "denied", "c1");
   assert.strictEqual(await approvals.waitForDecision(rec3.id, { timeoutMs: 5000, pollMs: 50 }), "denied");
 
+  // ── B10: missing keyring creds are preflighted BEFORE the one-shot approval
+  // token is consumed. The old order burned the human's decision on a run that
+  // could never start; the same token must survive and redeem after the key
+  // is set, with the byte-identical command.
+  const toolCli = require("./bin/tool");
+  const b10src = path.join(tmp, "vaulted.sh");
+  fs.writeFileSync(b10src, "#!/usr/bin/env bash\necho ran-vaulted\n");
+  tools.addTool(b10src, { name: "vaulted", description: "needs a cred", risk: "destructive", requires: ["vaulted_api_key"] });
+  const b10cmd = approvals.formatApprovedCommand(["open-claudia", "tool", "run", "vaulted", "go"]);
+  const b10rec = approvals.create({ tool: "vaulted", tier: "destructive", command: b10cmd, channelId: "c1", adapter: "tg" });
+  approvals.decide(b10rec.id, "approved", "c1");
+  const errs = [];
+  const realErr = console.error;
+  console.error = (...a) => errs.push(a.join(" "));
+  try {
+    process.exitCode = 0;
+    await toolCli.run(["run", "vaulted", "go", "--approval", b10rec.id]);
+    assert.strictEqual(process.exitCode, 1, "missing creds refuse the run with exit 1, not an approval error");
+    assert.ok(errs.some((l) => /missing keyring keys vaulted_api_key/.test(l)), "failure names the missing key");
+    assert.ok(errs.some((l) => /NOT consumed/.test(l)), "agent is told the token survived");
+    assert.strictEqual(approvals.read(b10rec.id).consumedAt, undefined, "the approval token is NOT burned by the creds failure");
+
+    fs.writeFileSync(process.env.KEYRING_FILE, JSON.stringify({ vaulted_api_key: "k" }));
+    process.exitCode = 0;
+    await toolCli.run(["run", "vaulted", "go", "--approval", b10rec.id]);
+    assert.strictEqual(process.exitCode, 0, "the same token redeems once the key exists");
+    assert.ok(approvals.read(b10rec.id).consumedAt, "token consumed exactly by the real run");
+  } finally {
+    console.error = realErr;
+    process.exitCode = 0;
+  }
+
   console.log("tool manifest OK");
 })().catch((e) => { console.error(e); process.exit(1); });

package/test-tools.js

@@ -490,4 +490,35 @@ assert.ok(tools.removeTool("hello"), "removeTool returns the removed tool");
 assert.strictEqual(tools.findTool("hello"), null, "removed tool is gone");
 assert.ok(!fs.existsSync(path.join(process.env.TOOLS_DIR, "hello")), "removed tool's directory is gone");
 
+// ── keyring durability (B6/B13): atomic save + .bak fallback on corruption ──
+// A half-written keyring must not silently strip every tool of credentials:
+// save() snapshots the last-good file, load() falls back to it and says so
+// loudly on stderr (once per process) instead of returning {} in silence.
+const keyring = require("./core/keyring");
+const KR = process.env.KEYRING_FILE;
+fs.rmSync(KR, { force: true });
+fs.rmSync(KR + ".bak", { force: true });
+keyring.set("kr_a", "1");
+assert.ok(!fs.existsSync(KR + ".bak"), "first save has no previous version to snapshot");
+keyring.set("kr_b", "2");
+assert.deepStrictEqual(JSON.parse(fs.readFileSync(KR + ".bak", "utf-8")), { kr_a: "1" },
+  "second save snapshots the previous good version to .bak");
+assert.strictEqual(fs.statSync(KR).mode & 0o777, 0o600, "keyring file is 0600 from birth");
+const krErrs = [];
+const realErr = console.error;
+console.error = (...a) => krErrs.push(a.join(" "));
+try {
+  fs.writeFileSync(KR, "{truncated-by-crash"); // simulate a torn write
+  assert.deepStrictEqual(keyring.all(), { kr_a: "1" }, "corrupt primary falls back to .bak snapshot");
+  assert.strictEqual(keyring.get("kr_a"), "1", "get() reads through the fallback");
+  keyring.all();
+  assert.strictEqual(krErrs.filter((l) => /corrupt/.test(l)).length, 1, "corruption is warned exactly once per process");
+} finally {
+  console.error = realErr;
+}
+keyring.set("kr_c", "3"); // next save repairs the primary from the fallback view
+assert.deepStrictEqual(JSON.parse(fs.readFileSync(KR, "utf-8")), { kr_a: "1", kr_c: "3" },
+  "save after corruption rewrites a valid primary from the recovered data");
+assert.ok(!fs.readdirSync(tmp).some((f) => f.endsWith(".tmp")), "no stray temp files left behind by atomic writes");
+
 console.log("tools OK");