@mnemom/mnemom 0.17.2-next.3 → 0.17.2-next.4

package/dist/mcp/handoff-server.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+// mnemom-handoff — the stdio MCP server `mnemom agent` registers (behind the OFF-by-default
+// `context_handoff` setting, MNE-7564) exposing exactly ONE tool: `handoff(note)`.
+//
+// WHY .mjs, NOT .ts
+// This file must exist BYTE-IDENTICAL at the same relative path in both the source tree and
+// the built `dist/` tree, exactly like `rc-proxy.mjs` next to it: `commands/agent.ts`
+// resolves it relative to its OWN `import.meta.url`, which is the SOURCE path under `vitest`
+// (dev/test — no `tsc` has run) and the DIST path once installed. A `tsc`-compiled `.ts` file
+// only exists post-build, so it would be unresolvable in dev/test. Consequently this file is
+// self-contained (only Node builtins + global `fetch`, no local imports) — see
+// `scripts/copy-assets.mjs`, which copies it (and rc-proxy.mjs) verbatim into `dist/`.
+//
+// Deliberately hand-rolled rather than `@modelcontextprotocol/sdk`: MCP over stdio is
+// newline-delimited JSON-RPC 2.0, small enough to hand-roll for one tool in a CLI that
+// otherwise carries four small deps. Only `initialize`, `tools/list` and `tools/call` are
+// implemented — the whole surface Claude Code's MCP client needs for a stdio tool.
+//
+// Config rides on env vars the launcher sets via the `--mcp-config` file's `env` block
+// (`buildHandoffMcpConfig`, cli/src/lib/agent.ts) — never argv, so nothing here is visible to
+// `ps`. The Anthropic key itself is never IN that file, for any launch shape: the launcher hands
+// this process `MNEMOM_HANDOFF_ANTHROPIC_KEY_ENV_NAME` naming a var this process already
+// inherits from its OWN parent env (every stdio MCP server inherits the full parent env —
+// verified experimentally for MNE-7564), and this process reads the key from THAT var at
+// request time instead. A terminal launch names `ANTHROPIC_CUSTOM_HEADERS` (parsed for its
+// `x-api-key:` line); Remote Control names a dedicated `MNEMOM_HANDOFF_KEY` its launcher sets
+// directly, since RC's child env strips every ANTHROPIC_* var (see `HandoffAnthropicKeySource`
+// in cli/src/lib/agent.ts for the full rationale). This process never logs either var's name or
+// value.
+
+import { createInterface } from "node:readline";
+import { pathToFileURL } from "node:url";
+
+/** The gateway route this tool calls (gateway/src/context-handoff.ts, MNE-7563). */
+export const HANDOFF_PATH = "/mnemom/context/handoff";
+
+const TOOL_NAME = "handoff";
+
+const TOOL_DESCRIPTION =
+  "Hand off to your successor context. Call this at a natural stopping point in your own " +
+  "work, OR as soon as you see a '[mnemom context warning]' line from the gateway telling you " +
+  "the fold budget is nearly spent — that line means the gateway will fold on its own soon, so " +
+  "calling `handoff` first lets YOU choose what your successor reads. A good note is short and " +
+  "covers: the goal, what is already done, the next concrete action, and any open questions or " +
+  "blockers. The note is stored byte-exact and rendered to your successor verbatim — it is not " +
+  "summarized, so write it as you want it read.";
+
+const TOOL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    note: {
+      type: "string",
+      description:
+        "Goal, what's done, the next action, and open questions — byte-exact to your successor.",
+    },
+  },
+  required: ["note"],
+  additionalProperties: false,
+};
+
+/** Required env vars the launcher always sets when it registers this server. */
+const REQUIRED_ENV = [
+  "MNEMOM_HANDOFF_GATEWAY_HOST",
+  "MNEMOM_HANDOFF_ANTHROPIC_KEY_ENV_NAME",
+  "MNEMOM_HANDOFF_AGENT",
+  "MNEMOM_HANDOFF_CONVERSATION_ID",
+];
+
+/**
+ * Recover the Anthropic key from an env var NAME this process itself inherited from its parent
+ * (never a value written into the `--mcp-config` file). `ANTHROPIC_CUSTOM_HEADERS` is a
+ * multi-line header BLOCK (`buildCustomHeaders`, cli/src/lib/agent.ts) whose first line is
+ * `x-api-key: <key>` — extract just that. Any other name is treated as carrying the key value
+ * directly.
+ * @param {string} name
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {string} the key, or "" if the named var is absent/unusable.
+ */
+function resolveKeyFromEnvName(name, env) {
+  const value = env[name] ?? "";
+  if (name === "ANTHROPIC_CUSTOM_HEADERS") {
+    const m = value.match(/^x-api-key:\s*(.+)$/im);
+    return m ? m[1].trim() : "";
+  }
+  return value.trim();
+}
+
+/**
+ * Read the tool's config from env. Throws (message never contains the key value) when a
+ * required var is missing, or when the named key-source var resolves to no usable key.
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {{gatewayHost: string, anthropicKey: string, agent: string, conversationId: string, sessionConfigB64?: string}}
+ */
+export function configFromEnv(env) {
+  const missing = REQUIRED_ENV.filter((k) => !(env[k] ?? "").trim());
+  if (missing.length) {
+    throw new Error(`mnemom-handoff: missing required env var(s): ${missing.join(", ")}`);
+  }
+  const keyEnvName = env.MNEMOM_HANDOFF_ANTHROPIC_KEY_ENV_NAME.trim();
+  const anthropicKey = resolveKeyFromEnvName(keyEnvName, env);
+  if (!anthropicKey) {
+    throw new Error(
+      `mnemom-handoff: MNEMOM_HANDOFF_ANTHROPIC_KEY_ENV_NAME names '${keyEnvName}', but this ` +
+        "process's own inherited environment has no usable value for it.",
+    );
+  }
+  return {
+    gatewayHost: env.MNEMOM_HANDOFF_GATEWAY_HOST.trim(),
+    anthropicKey,
+    agent: env.MNEMOM_HANDOFF_AGENT.trim(),
+    conversationId: env.MNEMOM_HANDOFF_CONVERSATION_ID.trim(),
+    sessionConfigB64: env.MNEMOM_HANDOFF_SESSION_CONFIG?.trim() || undefined,
+  };
+}
+
+/**
+ * Build the fetch call. Exported so a test can assert the wire shape without mocking fetch.
+ * @param {{gatewayHost: string, anthropicKey: string, agent: string, conversationId: string, sessionConfigB64?: string}} cfg
+ * @param {string} note
+ */
+export function buildHandoffRequest(cfg, note) {
+  const headers = {
+    "content-type": "application/json",
+    "x-api-key": cfg.anthropicKey,
+    "x-mnemom-agent": cfg.agent,
+  };
+  if (cfg.sessionConfigB64) headers["x-mnemom-session-config"] = cfg.sessionConfigB64;
+  return {
+    url: `${cfg.gatewayHost.replace(/\/+$/, "")}${HANDOFF_PATH}`,
+    init: {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ conversation_id: cfg.conversationId, note }),
+    },
+  };
+}
+
+/** Pull `{code, message}` out of the gateway's canonical error envelope; tolerant of anything else. */
+function extractGatewayError(body) {
+  if (!body || typeof body !== "object") return {};
+  const err = body.error;
+  if (!err || typeof err !== "object") return {};
+  return {
+    code: typeof err.code === "string" ? err.code : undefined,
+    message: typeof err.message === "string" ? err.message : undefined,
+  };
+}
+
+/**
+ * Call the route and render the result. NEVER throws: a network failure, a non-2xx status, or
+ * an unparseable body all come back as `{ok:false, message}` for the caller to surface as an
+ * MCP tool error — the tool must never crash the server or the session over a bad response.
+ * @param {{gatewayHost: string, anthropicKey: string, agent: string, conversationId: string, sessionConfigB64?: string}} cfg
+ * @param {string} note
+ * @param {typeof fetch} fetchImpl
+ */
+export async function callHandoff(cfg, note, fetchImpl) {
+  const { url, init } = buildHandoffRequest(cfg, note);
+  let res;
+  try {
+    res = await fetchImpl(url, init);
+  } catch (err) {
+    return {
+      ok: false,
+      message: `could not reach the gateway: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+
+  const text = await res.text().catch(() => "");
+  let body;
+  try {
+    body = text ? JSON.parse(text) : undefined;
+  } catch {
+    body = undefined;
+  }
+
+  if (!res.ok) {
+    const { code, message } = extractGatewayError(body);
+    const detail = message ?? (text || `HTTP ${res.status}`);
+    return {
+      ok: false,
+      message: `handoff request failed (${res.status}${code ? ` ${code}` : ""}): ${detail}`,
+    };
+  }
+
+  const parsed = body ?? {};
+  const pending = parsed.pending === true;
+  const level = typeof parsed.level === "string" ? parsed.level : "none";
+  const generation = typeof parsed.generation === "number" ? parsed.generation : 0;
+  const line = pending
+    ? `handoff queued (level: ${level}, generation ${generation}) — the gateway will fold at your next request`
+    : `handoff acknowledged (level: ${level}, generation ${generation}) — no fold scheduled`;
+  return { ok: true, line };
+}
+
+class MethodNotFoundError extends Error {}
+
+/** True for a JSON-RPC NOTIFICATION (no `id` key at all) — never gets a response. */
+function isNotification(msg) {
+  return !("id" in msg);
+}
+
+function textContent(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+function errorContent(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+
+/**
+ * Run the server against injected streams (tests use in-memory ones; `main()` wires real
+ * stdio). Handles one message per line; a line that isn't valid JSON, or errors while handling
+ * a request, is reported back as a JSON-RPC error for that message's id and never crashes the
+ * loop — one bad message must not take the whole tool down.
+ * @param {{input: NodeJS.ReadableStream, output: NodeJS.WritableStream, config: object, fetchImpl?: typeof fetch}} opts
+ */
+export function runHandoffServer(opts) {
+  const fetchImpl = opts.fetchImpl ?? ((url, init) => fetch(url, init));
+  const write = (msg) => {
+    opts.output.write(`${JSON.stringify(msg)}\n`);
+  };
+  const respond = (id, result) => {
+    if (id === undefined) return; // notification — no response
+    write({ jsonrpc: "2.0", id, result });
+  };
+  const respondError = (id, code, message) => {
+    if (id === undefined) return;
+    write({ jsonrpc: "2.0", id, error: { code, message } });
+  };
+
+  const rl = createInterface({ input: opts.input, terminal: false });
+
+  rl.on("line", (raw) => {
+    const line = raw.trim();
+    if (!line) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return; // not JSON-RPC we can respond to — drop it
+    }
+    const id = "id" in msg ? msg.id : undefined;
+    const method = typeof msg.method === "string" ? msg.method : "";
+
+    handle(method, msg.params, isNotification(msg))
+      .then((result) => respond(id, result))
+      .catch((err) => {
+        const code = err instanceof MethodNotFoundError ? -32601 : -32603;
+        respondError(id, code, err instanceof Error ? err.message : String(err));
+      });
+  });
+
+  async function handle(method, params, notification) {
+    switch (method) {
+      case "initialize":
+        return {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "mnemom-handoff", version: "1.0.0" },
+        };
+      case "notifications/initialized":
+        return undefined; // no-op; notification anyway (never responded to)
+      case "tools/list":
+        return {
+          tools: [
+            { name: TOOL_NAME, description: TOOL_DESCRIPTION, inputSchema: TOOL_INPUT_SCHEMA },
+          ],
+        };
+      case "tools/call":
+        return callTool(params);
+      case "ping":
+        return {};
+      default:
+        if (notification) return undefined;
+        throw new MethodNotFoundError(`unknown method '${method}'`);
+    }
+  }
+
+  async function callTool(params) {
+    const p = params ?? {};
+    if (p.name !== TOOL_NAME) {
+      return errorContent(`unknown tool '${String(p.name)}'`);
+    }
+    const args = p.arguments ?? {};
+    const note = args.note;
+    if (typeof note !== "string" || note.trim() === "") {
+      return errorContent("handoff requires a non-empty string `note` argument.");
+    }
+    const outcome = await callHandoff(opts.config, note, fetchImpl);
+    return outcome.ok ? textContent(outcome.line) : errorContent(outcome.message);
+  }
+
+  return {
+    close: () => rl.close(),
+  };
+}
+
+async function main() {
+  let config;
+  try {
+    config = configFromEnv(process.env);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+    return;
+  }
+  runHandoffServer({ input: process.stdin, output: process.stdout, config });
+}
+
+/**
+ * Only auto-start when run directly (`node handoff-server.mjs`), never on import (tests).
+ * `argv1`/`moduleUrl` default to the real `process.argv[1]`/`import.meta.url` at the call site
+ * (main()'s own check, below) but are accepted as params — like `configFromEnv(env)` above —
+ * so a test can drive every branch (no entry, an unconvertible entry, a real match/mismatch)
+ * without touching the real process's argv.
+ * @param {string | undefined} [argv1]
+ * @param {string} [moduleUrl]
+ */
+export function isMain(argv1 = process.argv[1], moduleUrl = import.meta.url) {
+  if (!argv1) return false;
+  try {
+    return pathToFileURL(argv1).href === moduleUrl;
+  } catch {
+    return false;
+  }
+}
+
+if (isMain()) {
+  void main();
+}

package/dist/rc-proxy.mjs

@@ -13,9 +13,10 @@
 //
 // WHAT IT DOES
 //   * Listens on 127.0.0.1 (ephemeral port) as an HTTP CONNECT proxy.
-//   * Terminates TLS for api.anthropic.com ONLY, with an ephemeral CA + leaf minted at
-//     startup into a private 0700 tmpdir (CA key deleted right after signing, dir removed on
-//     exit). Every other host is tunnelled byte-for-byte (telemetry, Datadog, MCP servers…).
+//   * Terminates TLS for api.anthropic.com ONLY, with an ephemeral CA (397 days, key held in
+//     memory only) minted at startup into a private 0700 tmpdir (removed on exit), and a 7-day
+//     leaf re-minted every 24 h and hot-swapped (see below). Every other host is tunnelled
+//     byte-for-byte (telemetry, Datadog, MCP servers…).
 //   * Inside api.anthropic.com, only `POST /v1/messages[?…]` is rewritten to the Mnemom
 //     gateway door: the real Anthropic key rides as `x-api-key` (API-key billing), plus
 //     `x-mnemom-agent`, `x-mnemom-conversation-id`, and optionally `x-mnemom-api-key`,
@@ -79,6 +80,7 @@ import net from "node:net";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import crypto from "node:crypto";
 import { execFileSync } from "node:child_process";
 
 const MITM_HOST = "api.anthropic.com";
@@ -140,14 +142,27 @@ try {
 }
 if (!secrets.anthropic) die("the Anthropic key (stdin line 1) is empty");
 
-// --- ephemeral CA + leaf for api.anthropic.com ------------------------------------------
-// Private 0700 dir under the OS tmpdir; the CA key is deleted as soon as the leaf is signed
-// (only the leaf key is needed to serve sessions) and the whole dir goes on exit. Works with
-// macOS's system LibreSSL (3.3+) and OpenSSL 1.1.1+ (`-addext`).
+// --- ephemeral CA + rotating leaf for api.anthropic.com ---------------------------------
+// Private 0700 dir under the OS tmpdir, removed on exit. Claude Code reads NODE_EXTRA_CA_CERTS
+// once at process start, so the CA it trusts can never change mid-session: the CA is valid for
+// CA_DAYS and its private key lives in memory only (read into a Buffer, then deleted from disk).
+// The leaf is short-lived and re-minted from that key every LEAF_ROTATE_MS — and on demand when
+// it has under LEAF_MIN_LEFT_MS left — then hot-swapped with setSecureContext, so a running
+// session picks it up on its next TLS handshake. (A 2-day CA + leaf with the CA key deleted at
+// startup broke every session older than 48 h with "SSL certificate has expired".) openssl only
+// takes the CA key from a file, so each signing writes it 0600 into caDir and deletes it right
+// after. Works with macOS's system LibreSSL (3.3+) and OpenSSL 1.1.1+ (`-addext`).
+// MNEMOM_RC_LEAF_ROTATE_MS / MNEMOM_RC_LEAF_DAYS exist for tests only.
+const CA_DAYS = 397;
+const LEAF_DAYS = Number(env.MNEMOM_RC_LEAF_DAYS || 7);
+const LEAF_ROTATE_MS = Number(env.MNEMOM_RC_LEAF_ROTATE_MS || 24 * 60 * 60 * 1000);
+const LEAF_MIN_LEFT_MS = 24 * 60 * 60 * 1000;
 const caDir = fs.mkdtempSync(path.join(os.tmpdir(), "mnemom-code-rc-ca-"));
 fs.chmodSync(caDir, 0o700);
 const p = (f) => path.join(caDir, f);
+let rotateTimer = null;
 const cleanup = () => {
+  clearInterval(rotateTimer); // a no-op while still null
   try {
     fs.rmSync(caDir, { recursive: true, force: true });
   } catch {
@@ -156,8 +171,12 @@ const cleanup = () => {
 };
 process.on("exit", cleanup);
 for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(sig, () => process.exit(0));
+const ossl = (...a) => execFileSync("openssl", a, { stdio: ["ignore", "ignore", "pipe"] });
+// openssl's own stderr when it has any, else the error itself (spawn / fs failures).
+const osslErr = (e) => (e.stderr && e.stderr.length ? e.stderr.toString().trim() : e.message);
+
+let caKey; // Buffer — never on disk outside mintLeaf()'s signing call
 try {
-  const ossl = (...a) => execFileSync("openssl", a, { stdio: ["ignore", "ignore", "pipe"] });
   ossl(
     "req",
     "-x509",
@@ -171,7 +190,7 @@ try {
     "-out",
     p("ca.pem"),
     "-days",
-    "2",
+    String(CA_DAYS),
     "-subj",
     "/CN=mnemom agent local CA (ephemeral)",
     "-addext",
@@ -179,6 +198,19 @@ try {
     "-addext",
     "keyUsage=critical,keyCertSign,cRLSign",
   );
+  caKey = fs.readFileSync(p("ca.key"));
+  fs.rmSync(p("ca.key"));
+  fs.writeFileSync(
+    p("leaf.ext"),
+    `subjectAltName=DNS:${MITM_HOST}\nbasicConstraints=CA:FALSE\nkeyUsage=digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n`,
+  );
+} catch (e) {
+  fs.rmSync(p("ca.key"), { force: true });
+  die(`could not mint the ephemeral CA with openssl: ${osslErr(e)}`);
+}
+
+// Mint a fresh leaf key + cert signed by the in-memory CA key. Returns { key, cert, notAfter }.
+function mintLeaf() {
   ossl(
     "req",
     "-newkey",
@@ -193,32 +225,41 @@ try {
     "-subj",
     `/CN=${MITM_HOST}`,
   );
-  fs.writeFileSync(
-    p("leaf.ext"),
-    `subjectAltName=DNS:${MITM_HOST}\nbasicConstraints=CA:FALSE\nkeyUsage=digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n`,
-  );
-  ossl(
-    "x509",
-    "-req",
-    "-in",
-    p("leaf.csr"),
-    "-CA",
-    p("ca.pem"),
-    "-CAkey",
-    p("ca.key"),
-    "-CAcreateserial",
-    "-out",
-    p("leaf.pem"),
-    "-days",
-    "2",
-    "-extfile",
-    p("leaf.ext"),
-  );
-  fs.rmSync(p("ca.key"));
+  try {
+    fs.writeFileSync(p("ca.key"), caKey, { mode: 0o600, flag: "wx" });
+    ossl(
+      "x509",
+      "-req",
+      "-in",
+      p("leaf.csr"),
+      "-CA",
+      p("ca.pem"),
+      "-CAkey",
+      p("ca.key"),
+      "-CAcreateserial",
+      "-out",
+      p("leaf.pem"),
+      "-days",
+      String(LEAF_DAYS),
+      "-extfile",
+      p("leaf.ext"),
+    );
+  } finally {
+    fs.rmSync(p("ca.key"), { force: true });
+  }
+  const cert = fs.readFileSync(p("leaf.pem"));
+  return {
+    key: fs.readFileSync(p("leaf.key")),
+    cert,
+    notAfter: Date.parse(new crypto.X509Certificate(cert).validTo),
+  };
+}
+
+let leaf;
+try {
+  leaf = mintLeaf();
 } catch (e) {
-  die(
-    `could not mint the ephemeral CA with openssl: ${e.stderr ? e.stderr.toString() : e.message}`,
-  );
+  die(`could not mint the ephemeral CA with openssl: ${osslErr(e)}`);
 }
 
 // --- request handling ---------------------------------------------------------------------
@@ -299,6 +340,23 @@ const THREAD_400 = Buffer.from(
   }),
 );
 let localSeq = 0;
+
+// The Claude Code session ids seen on the /v1/messages leg (`x-claude-code-session-id`, not a
+// secret): each NEW one is logged once as `cc-session=<id>`, so the server shape (many sessions in
+// one proxy) gets a local conversation ↔ CC session record. Bounded; the id is clipped to a
+// uuid-ish charset so a hostile header cannot forge log lines.
+const CC_SESSION_SEEN_MAX = 256;
+const ccSessionsSeen = new Set();
+function noteCcSession(raw) {
+  const id = String(raw ?? "")
+    .replace(/[^A-Za-z0-9._:-]/g, "")
+    .slice(0, 64);
+  if (!id || ccSessionsSeen.has(id)) return;
+  if (ccSessionsSeen.size >= CC_SESSION_SEEN_MAX) ccSessionsSeen.clear();
+  ccSessionsSeen.add(id);
+  log(`cc-session=${id} conversation=${CONV}`);
+}
+
 function rejectThread(res, tag, thread) {
   res.writeHead(400, {
     "content-type": "application/json",
@@ -344,6 +402,7 @@ function handle(req, res, viaPlain) {
       path: GATEWAY.pathname.replace(/\/$/, "") + urlPath,
       agent: gatewayAgent,
     };
+    noteCcSession(headers["x-claude-code-session-id"]);
     delete headers.authorization; // the OAuth bearer stays local
     headers["x-api-key"] = secrets.anthropic;
     headers["x-mnemom-agent"] = AGENT;
@@ -398,10 +457,12 @@ function handle(req, res, viaPlain) {
       }
       ur.pipe(res);
       const goalRev = ur.headers["x-mnemom-goal-revision"];
+      const goalThread = ur.headers["x-mnemom-goal-thread"];
       const steer = ur.headers["x-mnemom-goal-steer"];
       const ident = toGateway
         ? ` agent=${ur.headers["x-mnemom-agent"] || "-"} verdict=${ur.headers["x-mnemom-goal-verdict"] || "-"}` +
           (goalRev ? ` goal-rev=${goalRev}` : "") +
+          (goalThread ? ` goal-thread=${goalThread}` : "") +
           (steer ? ` steer=${steer}` : "")
         : "";
       ur.on("end", () => {
@@ -459,18 +520,33 @@ function handle(req, res, viaPlain) {
   }
 }
 
-const tlsServer = https.createServer(
-  { key: fs.readFileSync(p("leaf.key")), cert: fs.readFileSync(p("leaf.pem")) },
-  (req, res) => handle(req, res, false),
+const tlsServer = https.createServer({ key: leaf.key, cert: leaf.cert }, (req, res) =>
+  handle(req, res, false),
 );
 tlsServer.on("tlsClientError", (e) => log(`tls client error: ${e.code || e.message}`));
 
+// Re-mint the leaf and hot-swap it; established TLS connections keep the old one, every new
+// handshake gets the new one. A failed re-mint keeps serving the current leaf.
+function rotateLeaf(why) {
+  try {
+    leaf = mintLeaf();
+    tlsServer.setSecureContext({ key: leaf.key, cert: leaf.cert });
+    log(`leaf rotated (${why}) notAfter=${new Date(leaf.notAfter).toISOString()}`);
+  } catch (e) {
+    log(`leaf rotation FAILED (${why}), keeping the current leaf: ${osslErr(e)}`);
+  }
+}
+rotateTimer = setInterval(() => rotateLeaf("interval"), LEAF_ROTATE_MS);
+rotateTimer.unref();
+
 const proxy = http.createServer((req, res) => handle(req, res, true));
 proxy.on("connect", (req, sock, head) => {
   const [host, portStr] = req.url.split(":");
   const port = Number(portStr || 443);
   sock.on("error", () => {});
   if (host === MITM_HOST && port === 443) {
+    // A timer can run late (laptop sleep): never hand out a leaf that is about to expire.
+    if (leaf.notAfter - Date.now() < LEAF_MIN_LEFT_MS) rotateLeaf("expiring");
     sock.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     if (head && head.length) sock.unshift(head);
     tlsServer.emit("connection", sock);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.2-next.3",
+  "version": "0.17.2-next.4",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {