create-evda 0.1.9 → 0.1.11

package/lib/keychain.mjs

@@ -15,8 +15,16 @@
 // EVDA_KEYCHAIN_FALSIFY=<mode,...>, for the tests:
 //   no-keychain    keychainAvailable() always says no, so a credential file is never redacted
 //   write-fails    every "security add-generic-password" fails, so the value stays in the file
+//
+// HQ-2051: under node's test runner, nothing here may reach the default (login) keychain. A test run
+// that names no keychain, or names one that does not exist (`security` then falls back to the
+// default instead of failing), throws before `security` runs. On Hestia's CI runner the default
+// keychain does not exist under the throwaway HOME, so such a call raised a "Keychain Not Found"
+// dialog that sat on the screen for hours and failed every Mac journey. A test that truly means the
+// login keychain sets EVDA_KEYCHAIN_ALLOW_DEFAULT=1; none does.
 
 import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { CRED_LINE } from "./gather.mjs";
 import { secretShape } from "./references.mjs";
 
@@ -40,17 +48,33 @@ export function keychainAvailable() {
   }
 }
 
+// True inside a `node --test` run: its children carry NODE_TEST_CONTEXT, and so does every CLI a
+// test spawns with the inherited env; --test-isolation=none runs in-process with --test in execArgv.
+export function underTestRunner(env = process.env, execArgv = process.execArgv) {
+  return Boolean(env.NODE_TEST_CONTEXT) || execArgv.some((a) => a === "--test" || a.startsWith("--test-"));
+}
+
+// Throws when a test run would reach the default keychain. Every Keychain call below goes through it.
+export function assertKeychainAllowed(keychainPath, env = process.env) {
+  if (!underTestRunner(env) || env.EVDA_KEYCHAIN_ALLOW_DEFAULT === "1") return;
+  if (!keychainPath) throw new Error("evda refuses the default keychain under a test run: pass a throwaway keychainPath or set EVDA_KEYCHAIN_FALSIFY (HQ-2051)");
+  if (!existsSync(keychainPath)) throw new Error(`evda refuses a keychain that does not exist under a test run (${keychainPath}): \`security\` would fall back to the default keychain (HQ-2051)`);
+}
+
 const keychainArgs = (keychainPath) => (keychainPath ? [keychainPath] : []);
 
 // `security add-generic-password`, overwriting an item already at this account (a second gather of
 // the same file lands on the same value). Throws on failure; the caller decides what that means.
 export function addSecret({ account, value, keychainPath = null } = {}) {
   if (falsified("write-fails")) throw new Error("EVDA_KEYCHAIN_FALSIFY=write-fails");
+  assertKeychainAllowed(keychainPath);
   execFileSync("security", ["add-generic-password", "-a", account, "-s", SERVICE, "-w", value, "-U", ...keychainArgs(keychainPath)], { stdio: ["ignore", "ignore", "pipe"] });
 }
 
-// Never throws: revert removes what it can and says what it removed.
+// Never throws on a missing item: revert removes what it can and says what it removed. Under a test
+// run it does throw when it would reach the default keychain (HQ-2051).
 export function removeSecret({ account, keychainPath = null } = {}) {
+  assertKeychainAllowed(keychainPath);
   try {
     execFileSync("security", ["delete-generic-password", "-a", account, "-s", SERVICE, ...keychainArgs(keychainPath)], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
@@ -61,6 +85,7 @@ export function removeSecret({ account, keychainPath = null } = {}) {
 
 // The value at an account, or throws (no item, or the Keychain refused to read it).
 export function readSecret({ account, keychainPath = null } = {}) {
+  assertKeychainAllowed(keychainPath);
   return execFileSync("security", ["find-generic-password", "-a", account, "-s", SERVICE, "-w", ...keychainArgs(keychainPath)], { stdio: ["ignore", "pipe", "ignore"] }).toString("utf8").replace(/\n$/, "");
 }
 
@@ -70,12 +95,17 @@ export function readSecret({ account, keychainPath = null } = {}) {
 // label of its own, so it is numbered "secret", "secret 2", ... in the order it appears. A labeled
 // line whose value is empty (the code sits on the next line instead) is left alone: multi-line values
 // are out of this first version's scope.
+// A line already holding a pointer is not a value, so a file sealed once has nothing left to move
+// (HQ-2622: the migration's second run is a no-op because of this). Two lines with the same label
+// ("password" twice, or a "secret:" line beside a bare token) get "<label> 2", "<label> 3", ... so
+// each lands on its own Keychain account and neither overwrites the other.
 export function extractSecrets(text) {
   const lines = text.split("\n");
   const out = [];
   let bare = 0;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
+    if (POINTER.test(line)) continue;
     const m = CRED_LINE.exec(line);
     if (m) {
       const label = (m[1] ?? m[2]).toLowerCase().replace(/[\s_-]+/g, " ");
@@ -89,6 +119,13 @@ export function extractSecrets(text) {
       out.push({ index: i, label: bare === 1 ? "secret" : `secret ${bare}`, prefix: "", value: line, whole: true });
     }
   }
+  const used = new Set();
+  for (const s of out) {
+    let label = s.label;
+    for (let n = 2; used.has(label); n++) label = `${s.label} ${n}`;
+    used.add(label);
+    s.label = label;
+  }
   return out;
 }
 

package/lib/manifest.mjs

@@ -18,7 +18,9 @@ export const KNOWN_LAYERS = ["record", "ledger", "circles"];
 // lib/day-file.mjs filingOf reads it for every agent and hook.
 // `every_chat` (HQ-2205) is, per chat app, whether the owner put the every-chat line in that app's
 // settings ("set") or does not want it ("declined"); lib/every-chat.mjs reads it, evda_every_chat writes it.
-export const KNOWN_KEYS = ["evda", "id", "name", "owner", "created", "layers", "mapping", "subrecords", "read_by", "filing", "every_chat", "sync"];
+// `corrections` (HQ-2325) is the file a correction is appended to, when the owner keeps them in
+// their own file rather than the operating layer's "What I have been taught"; lib/corrections.mjs reads it.
+export const KNOWN_KEYS = ["evda", "id", "name", "owner", "created", "layers", "mapping", "subrecords", "read_by", "filing", "every_chat", "sync", "corrections"];
 
 // Whether a record's circles stop at its sub-records (HQ-1371). A sub-record is a directory below
 // the root holding its own evda.json. "bounded": the parent's circles, coverage, scan and release

package/lib/mcp-http.mjs

@@ -54,6 +54,23 @@ function limiter() {
   };
 }
 
+// HQ-2330: what a request carries beyond the protocol, by NAME only, so the log can show whether an
+// app sends something that names the conversation (claude.ai reuses one Mcp-Session-Id across chats).
+// Values are never logged: a header or a _meta value can carry anything.
+const PLAIN_HEADERS = new Set(["host", "content-type", "content-length", "authorization", "accept", "accept-encoding", "accept-language", "user-agent", "connection", "origin", "mcp-session-id", "mcp-protocol-version", "last-event-id", "via", "forwarded", "x-real-ip", "cache-control", "pragma", "te", "keep-alive"]);
+const clipName = (k) => String(k).replace(/[^\x21-\x7e]/g, "").slice(0, 64);
+export function extraNames(headers, params) {
+  const out = {};
+  const h = Object.keys(headers ?? {}).map((k) => k.toLowerCase()).filter((k) => !PLAIN_HEADERS.has(k) && !k.startsWith("x-forwarded-") && !k.startsWith("tailscale-") && !k.startsWith("sec-fetch-")).map(clipName).slice(0, 20);
+  if (h.length) out.header_names = h;
+  const meta = params?._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const m = Object.keys(meta).map(clipName).slice(0, 20);
+    if (m.length) out.meta_keys = m;
+  }
+  return out;
+}
+
 const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 const shortId = (s) => auth.sha256(String(s)).slice(0, 8);
 
@@ -167,7 +184,7 @@ export function createMcpHttpServer({ dir, version, publicUrl, env = process.env
       if (batch.length !== 1) return send(400, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "initialize must be sent alone" } });
       evictSessions(now);
       newSid = randomBytes(24).toString("hex");
-      session = { family: grant.family, last: now, ctx: { version, log: (s) => log(s), clock, env: readerEnv, evda: () => openEvda(dir), session: newSession(), caller: callerFrom({ env: readerEnv }) } };
+      session = { family: grant.family, last: now, ctx: { version, log: (s) => log(s), clock, env: readerEnv, evda: () => openEvda(dir), session: newSession(), caller: callerFrom({ env: readerEnv }), keepsToolList: true } };
       sessions.set(newSid, session);
     } else {
       if (!sid) return send(400, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "Mcp-Session-Id header required; initialize first" } });
@@ -188,6 +205,7 @@ export function createMcpHttpServer({ dir, version, publicUrl, env = process.env
         const line = { call: method === "tools/call" ? (TOOL_NAMES.has(tool) ? tool : "unknown_tool") : METHODS.has(method) ? method : "unknown_method", status: st, ms: clock() - t0, session: shortId(sid ?? newSid), conn: note.who };
         // Which app connected (HQ-2207): initialize's clientInfo name and version, nothing else of it.
         if (method === "initialize") { const ci = clientInfoOf(one.params); line.client_name = ci.name; line.client_version = ci.version; }
+        Object.assign(line, extraNames(req.headers, one.params));
         if (auth.FALSIFY("log-content", env)) line.args = one.params?.arguments;
         record(line);
       }