@minhspark/codex-mcp-bridge 1.10.0

package/scripts/install-codex-mcp.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { PLATFORM_LABEL, resolveCodexBin, spawnEnv } from "../src/platform.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const codexBin = resolveCodexBin(process.env.CODEX_EXE);
+const serverName = process.env.CLAUDE_BRIDGE_NAME ?? "claude-bridge";
+const entry = path.join(root, "src", "claude-bridge.mjs");
+const remove = process.argv.includes("--remove");
+
+if (!fs.existsSync(entry)) throw new Error(`bridge entry point missing: ${entry}`);
+if (!path.isAbsolute(codexBin) || !fs.existsSync(codexBin)) {
+  throw new Error(`codex binary not found (resolved to "${codexBin}"). Set CODEX_EXE to its absolute path.`);
+}
+
+const run = (args) => execFileSync(codexBin, args, { env: spawnEnv(), stdio: "pipe" }).toString().trim();
+
+if (remove) {
+  console.log(run(["mcp", "remove", serverName]) || `removed ${serverName}`);
+  process.exit(0);
+}
+
+try {
+  run(["mcp", "remove", serverName]);
+} catch {
+  // not registered yet
+}
+
+const args = ["mcp", "add", serverName];
+const peerName = process.env.CLAUDE_BRIDGE_PEER_NAME;
+if (peerName) args.push("--env", `CLAUDE_BRIDGE_PEER_NAME=${peerName}`);
+args.push("--", process.execPath, entry);
+
+run(args);
+
+console.log(`platform: ${PLATFORM_LABEL}`);
+console.log(`registered MCP server "${serverName}" with Codex:`);
+console.log(run(["mcp", "get", serverName]));
+console.log("\nRestart the Codex app (or start a new Codex session) to load the bridge.");
+console.log(`remove: node scripts/install-codex-mcp.mjs --remove`);

package/scripts/install-launch-agent.mjs

@@ -0,0 +1,93 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { IS_MACOS, LAUNCH_AGENT_LABEL, launchAgentPath, resolveCodexBin, spawnEnv } from "../src/platform.mjs";
+
+if (!IS_MACOS) {
+  throw new Error("install-launch-agent.mjs is macOS-only. On Windows use a Startup shortcut or a scheduled task.");
+}
+
+const plistPath = launchAgentPath();
+const uninstall = process.argv.includes("--uninstall");
+const domain = `gui/${process.getuid()}`;
+
+function bootout() {
+  try {
+    execFileSync("launchctl", ["bootout", `${domain}/${LAUNCH_AGENT_LABEL}`], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (uninstall) {
+  const wasLoaded = bootout();
+  if (fs.existsSync(plistPath)) fs.rmSync(plistPath);
+  console.log(`removed ${plistPath}${wasLoaded ? " (agent unloaded)" : ""}`);
+  process.exit(0);
+}
+
+const codexBin = resolveCodexBin(process.env.CODEX_EXE);
+if (!path.isAbsolute(codexBin) || !fs.existsSync(codexBin)) {
+  throw new Error(`codex binary not found (resolved to "${codexBin}"). Set CODEX_EXE to its absolute path.`);
+}
+
+const url = process.env.CODEX_APP_SERVER_URL ?? "ws://127.0.0.1:8791";
+const logDir = path.join(os.homedir(), "Library", "Logs", "codex-mcp-bridge");
+fs.mkdirSync(logDir, { recursive: true });
+fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+
+const escapeXml = (value) =>
+  value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+
+const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(codexBin)}</string>
+    <string>app-server</string>
+    <string>--listen</string>
+    <string>${escapeXml(url)}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(spawnEnv().PATH)}</string>
+    <key>HOME</key>
+    <string>${escapeXml(os.homedir())}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(path.join(logDir, "app-server.out.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(path.join(logDir, "app-server.err.log"))}</string>
+</dict>
+</plist>
+`;
+
+fs.writeFileSync(plistPath, plist, "utf8");
+bootout();
+execFileSync("launchctl", ["bootstrap", domain, plistPath], { stdio: "inherit" });
+execFileSync("launchctl", ["enable", `${domain}/${LAUNCH_AGENT_LABEL}`], { stdio: "pipe" });
+
+console.log(`installed ${plistPath}`);
+console.log(`endpoint: ${url}`);
+console.log(`logs:     ${logDir}`);
+console.log(`status:   launchctl print ${domain}/${LAUNCH_AGENT_LABEL} | head -20`);
+console.log(`remove:   node scripts/install-launch-agent.mjs --uninstall`);

package/scripts/smoke.mjs

@@ -0,0 +1,50 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const cwdForTest = process.env.SMOKE_CWD ?? root;
+
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [path.join(root, "src", "index.mjs")],
+  env: { ...process.env, CODEX_BRIDGE_ALLOWED_ROOTS: process.env.CODEX_BRIDGE_ALLOWED_ROOTS ?? cwdForTest },
+  stderr: "inherit",
+});
+const client = new Client({ name: "smoke", version: "1.0.0" });
+await client.connect(transport);
+
+const tools = await client.listTools();
+console.log("TOOLS:", tools.tools.map((t) => t.name).join(", "));
+
+const listed = await client.callTool({ name: "list_codex_threads", arguments: { limit: 3 } });
+console.log("\n--- list_codex_threads ---\n" + listed.content[0].text.slice(0, 900));
+
+const created = await client.callTool({
+  name: "start_codex_thread",
+  arguments: { cwd: cwdForTest },
+});
+console.log("\n--- start_codex_thread ---\n" + created.content[0].text);
+const threadId = created.content[0].text.match(/threadId: ([0-9a-f-]+)/)?.[1];
+if (!threadId) throw new Error("could not parse threadId");
+
+const first = await client.callTool({
+  name: "send_to_codex_thread",
+  arguments: { threadId, prompt: "Remember the codeword PAPAYA. Reply with only: SAVED", timeoutSec: 180 },
+});
+console.log("\n--- send #1 ---\n" + first.content[0].text);
+
+const second = await client.callTool({
+  name: "send_to_codex_thread",
+  arguments: { threadId, prompt: "What codeword did I give you? Reply with only that word.", timeoutSec: 180 },
+});
+console.log("\n--- send #2 (same thread, must recall) ---\n" + second.content[0].text);
+
+const read = await client.callTool({ name: "read_codex_thread", arguments: { threadId, limit: 6 } });
+console.log("\n--- read_codex_thread ---\n" + read.content[0].text.slice(0, 900));
+
+const ok = /PAPAYA/i.test(second.content[0].text);
+console.log("\nRESULT:", ok ? "PASS - thread continuity works" : "FAIL - Codex did not recall the codeword");
+await client.close();
+process.exit(ok ? 0 : 1);

package/scripts/sync-version.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * `codex_bridge_status` reports a version constant that lives in the source,
+ * and `npm version` only ever rewrites package.json. Left to a human the two
+ * drift, and a drifting version turns every bug report into a guess about
+ * which build is actually running - so this runs from the `version` lifecycle
+ * script, between the bump and the commit npm makes for it.
+ */
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const entry = path.join(root, "src", "index.mjs");
+const { version } = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+
+const before = fs.readFileSync(entry, "utf8");
+const after = before.replace(/^const VERSION = "[^"]+";$/m, `const VERSION = "${version}";`);
+
+if (!after.includes(`const VERSION = "${version}";`)) {
+  throw new Error(`could not find the VERSION constant in ${entry}`);
+}
+
+if (before !== after) fs.writeFileSync(entry, after);
+console.log(`src/index.mjs VERSION -> ${version}`);

package/src/app-server-client.mjs

@@ -0,0 +1,414 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+
+import { PLATFORM_LABEL, resolveCodexBin, spawnEnv } from "./platform.mjs";
+import { assertAllowedAppServerUrl } from "./security-policy.mjs";
+
+const DEFAULT_URL = "ws://127.0.0.1:8791";
+const CONNECT_ATTEMPTS = 2;
+const CONNECT_RETRY_DELAY_MS = 750;
+
+function httpBase(wsUrl) {
+  return wsUrl.replace(/^ws:/, "http:").replace(/^wss:/, "https:").replace(/\/+$/, "");
+}
+
+/**
+ * Opening a thread in the desktop app while this bridge still holds it produces
+ * a message with no cause attached to it - the app just says the thread is open
+ * somewhere else. Saying so at the moment of opening turns that into something
+ * the reader can act on.
+ */
+export function writerLockWarning(threadId) {
+  return [
+    "",
+    `NOTE: this bridge still holds the writer lock on thread ${threadId}, because its app-server has the`,
+    "thread loaded. Until that app-server stops, the Codex app will refuse to write to it and show",
+    '"open in another application". Release it with stop_codex_app_server when the hand-off is done;',
+    "the bridge starts a new app-server the next time it needs one.",
+  ].join("\n");
+}
+
+export class AppServerError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "AppServerError";
+    this.code = code;
+  }
+}
+
+export class CodexAppServerClient {
+  constructor(options = {}) {
+    this.url = options.url ?? process.env.CODEX_APP_SERVER_URL ?? DEFAULT_URL;
+    assertAllowedAppServerUrl(this.url);
+    this.codexBin = resolveCodexBin(options.codexBin);
+    this.autoStart = options.autoStart ?? process.env.CODEX_BRIDGE_AUTOSTART !== "0";
+    this.log = options.log ?? (() => {});
+    const requestedApproval = options.approval ?? process.env.CODEX_BRIDGE_APPROVAL ?? "deny";
+    const autoApproveAcknowledged = options.allowAutoApprove ?? process.env.CODEX_BRIDGE_AUTO_APPROVE_ACK === "1";
+    this.approval = requestedApproval === "approve" && !autoApproveAcknowledged ? "deny" : requestedApproval;
+    this.clientInfo = options.clientInfo ?? { name: "codex-mcp-bridge", version: "1.0.0" };
+
+    if (requestedApproval === "approve" && !autoApproveAcknowledged) {
+      this.log("CODEX_BRIDGE_APPROVAL=approve ignored without CODEX_BRIDGE_AUTO_APPROVE_ACK=1");
+    }
+
+    this.ws = null;
+    this.connecting = null;
+    this.nextId = 0;
+    this.pending = new Map();
+    this.threadListeners = new Map();
+    this.disconnectListeners = new Set();
+    this.attachedThreads = new Set();
+    this.threadCwds = new Map();
+  }
+
+  async isServerUp() {
+    try {
+      const res = await fetch(`${httpBase(this.url)}/readyz`, {
+        signal: AbortSignal.timeout(2000),
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async startServer() {
+    this.log(`starting shared app-server on ${PLATFORM_LABEL}: ${this.codexBin} app-server --listen ${this.url}`);
+    const needsShell = /\.(cmd|bat)$/i.test(this.codexBin);
+    const child = spawn(this.codexBin, ["app-server", "--listen", this.url], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      shell: needsShell,
+      env: spawnEnv(),
+    });
+    child.on("error", (err) => this.log(`spawn error: ${err.message}`));
+    child.unref();
+
+    for (let i = 0; i < 40; i += 1) {
+      await delay(500);
+      if (await this.isServerUp()) return true;
+    }
+    return false;
+  }
+
+  /**
+   * The shared app-server keeps running after the bridge stops using it, and
+   * alongside the desktop app it competes for the same ~/.codex sqlite state.
+   * Stopping it on demand is what keeps the Codex app responsive between
+   * delegations.
+   */
+  async stopServer() {
+    if (!(await this.isServerUp())) return { stopped: false, reason: "no app-server was listening" };
+    const port = this.url.replace(/^wss?:\/\//, "").split("/")[0].split(":").pop();
+    const { execFileSync } = await import("node:child_process");
+    const pids = execFileSync("/usr/sbin/lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+      env: spawnEnv(),
+    })
+      .toString()
+      .split("\n")
+      .map((line) => Number(line.trim()))
+      .filter(Boolean);
+    if (!pids.length) return { stopped: false, reason: `nothing is listening on port ${port}` };
+    this.ws?.close();
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch (err) {
+        this.log(`could not stop pid ${pid}: ${err.message}`);
+      }
+    }
+    return { stopped: true, pids };
+  }
+
+  /**
+   * A freshly booted machine hands out transient failures: the app-server is
+   * still opening its sqlite state under ~/.codex, or an old one is shutting
+   * down yet still answering /readyz. Retrying once turns those into a slower
+   * first call instead of a failed tool call the user has to repeat by hand.
+   */
+  async connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
+    if (this.connecting) return this.connecting;
+
+    this.connecting = (async () => {
+      let lastError = null;
+      for (let attempt = 1; attempt <= CONNECT_ATTEMPTS; attempt += 1) {
+        try {
+          await this.#openConnection();
+          return;
+        } catch (err) {
+          lastError = err;
+          this.log(`connect attempt ${attempt}/${CONNECT_ATTEMPTS} failed: ${err.message}`);
+          if (attempt < CONNECT_ATTEMPTS) await delay(CONNECT_RETRY_DELAY_MS);
+        }
+      }
+      throw lastError;
+    })();
+
+    try {
+      await this.connecting;
+    } finally {
+      this.connecting = null;
+    }
+  }
+
+  async #openConnection() {
+    if (!(await this.isServerUp())) {
+      if (!this.autoStart) {
+        throw new AppServerError(
+          `No Codex app-server reachable at ${this.url}. Start one with: codex app-server --listen ${this.url}`,
+        );
+      }
+      const ok = await this.startServer();
+      if (!ok) {
+        throw new AppServerError(`Failed to start a Codex app-server at ${this.url} within 20s.`);
+      }
+    }
+
+    const ws = new WebSocket(this.url);
+    await new Promise((resolve, reject) => {
+      const timer = globalThis.setTimeout(
+        () => reject(new AppServerError(`Timed out connecting to ${this.url}`)),
+        15000,
+      );
+      ws.onopen = () => {
+        globalThis.clearTimeout(timer);
+        resolve();
+      };
+      ws.onerror = (event) => {
+        globalThis.clearTimeout(timer);
+        reject(new AppServerError(`WebSocket error against ${this.url}: ${event?.message ?? "unknown"}`));
+      };
+      ws.onclose = () => {
+        globalThis.clearTimeout(timer);
+        reject(new AppServerError(`Connection to ${this.url} closed during the handshake`));
+      };
+    });
+
+    ws.onmessage = (event) => this.#handleMessage(event.data);
+    ws.onclose = () => {
+      if (this.ws !== ws) return;
+      this.log("app-server connection closed");
+      this.ws = null;
+      this.attachedThreads.clear();
+      this.threadCwds.clear();
+      for (const [, entry] of this.pending) {
+        entry.reject(new AppServerError("Connection to Codex app-server closed"));
+      }
+      this.pending.clear();
+      this.#notifyDisconnect();
+    };
+    ws.onerror = (event) => this.log(`websocket error: ${event?.message ?? "unknown"}`);
+
+    this.ws = ws;
+    const init = await this.request("initialize", {
+      clientInfo: this.clientInfo,
+      capabilities: { experimentalApi: true },
+    });
+    this.#send({ jsonrpc: "2.0", method: "initialized", params: {} });
+    this.log(`connected to app-server (codexHome=${init?.codexHome ?? "?"})`);
+  }
+
+  #send(payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new AppServerError("Not connected to Codex app-server");
+    }
+    this.ws.send(JSON.stringify(payload));
+  }
+
+  #handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      this.log(`ignored non-JSON frame (${String(raw).slice(0, 80)})`);
+      return;
+    }
+
+    if (msg.id !== undefined && msg.method === undefined) {
+      const entry = this.pending.get(msg.id);
+      if (!entry) return;
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        entry.reject(new AppServerError(msg.error.message ?? JSON.stringify(msg.error), msg.error.code));
+      } else {
+        entry.resolve(msg.result);
+      }
+      return;
+    }
+
+    if (msg.id !== undefined && msg.method) {
+      this.#handleServerRequest(msg);
+      return;
+    }
+
+    if (msg.method) this.#dispatchNotification(msg);
+  }
+
+  #dispatchNotification(msg) {
+    const threadId = msg.params?.threadId;
+    if (!threadId) return;
+    const listeners = this.threadListeners.get(threadId);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      try {
+        listener(msg);
+      } catch (err) {
+        this.log(`listener error: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Every server->client request must get a reply. The app-server blocks the
+   * turn until it hears back, so an unanswered method does not surface as an
+   * error - the turn simply stops mid-run and looks like Codex paused itself.
+   * The ten methods below are the full ServerRequest set of the app-server
+   * protocol (identical in codex-cli 0.147 and 0.148), each answered with the
+   * response shape its own schema declares - they are not interchangeable.
+   */
+  #handleServerRequest(msg) {
+    const approve = this.approval === "approve";
+    const respond = (result) => {
+      try {
+        this.#send({ jsonrpc: "2.0", id: msg.id, result });
+      } catch (err) {
+        this.log(`failed to answer ${msg.method}: ${err.message}`);
+      }
+    };
+    const refuse = (message) => {
+      try {
+        this.#send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message } });
+      } catch (err) {
+        this.log(`failed to refuse ${msg.method}: ${err.message}`);
+      }
+    };
+
+    this.log(`server request ${msg.method} -> ${approve ? "approve" : "deny"}`);
+
+    try {
+      switch (msg.method) {
+        case "item/commandExecution/requestApproval":
+        case "item/fileChange/requestApproval":
+          respond({ decision: approve ? "accept" : "decline" });
+          return;
+        case "item/permissions/requestApproval":
+          respond({
+            permissions: approve ? (msg.params?.permissions ?? {}) : {},
+            scope: "turn",
+          });
+          return;
+        case "execCommandApproval":
+        case "applyPatchApproval":
+          respond({ decision: approve ? "approved" : "denied" });
+          return;
+        case "item/tool/requestUserInput":
+          respond({ answers: {} });
+          return;
+        case "mcpServer/elicitation/request":
+          respond({ action: "decline", content: null });
+          return;
+        case "item/tool/call":
+          respond({
+            success: false,
+            contentItems: [
+              { type: "text", text: "codex-mcp-bridge registers no dynamic tools." },
+            ],
+          });
+          return;
+        case "attestation/generate":
+        case "account/chatgptAuthTokens/refresh":
+          refuse(`codex-mcp-bridge cannot serve ${msg.method}; run this thread from the Codex app instead.`);
+          return;
+        default:
+          refuse(`codex-mcp-bridge does not handle ${msg.method}`);
+      }
+    } catch (err) {
+      refuse(`codex-mcp-bridge failed handling ${msg.method}: ${err.message}`);
+    }
+  }
+
+  async request(method, params, { timeoutMs = 60000 } = {}) {
+    const id = ++this.nextId;
+    const promise = new Promise((resolve, reject) => {
+      const timer = globalThis.setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AppServerError(`Request ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          globalThis.clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (err) => {
+          globalThis.clearTimeout(timer);
+          reject(err);
+        },
+      });
+    });
+    this.#send({ jsonrpc: "2.0", id, method, params: params ?? {} });
+    return promise;
+  }
+
+  async call(method, params, opts) {
+    await this.connect();
+    return this.request(method, params, opts);
+  }
+
+  /**
+   * A turn waits on `turn/completed`, which can only arrive over a live socket.
+   * Without an explicit disconnect signal a dropped app-server - the machine
+   * sleeping, a reboot, the desktop app reclaiming the state - leaves the
+   * caller blocked until its own timeout expires, four minutes by default.
+   */
+  subscribeDisconnect(listener) {
+    this.disconnectListeners.add(listener);
+    return () => this.disconnectListeners.delete(listener);
+  }
+
+  #notifyDisconnect() {
+    for (const listener of [...this.disconnectListeners]) {
+      try {
+        listener();
+      } catch (err) {
+        this.log(`disconnect listener error: ${err.message}`);
+      }
+    }
+  }
+
+  subscribe(threadId, listener) {
+    if (!this.threadListeners.has(threadId)) this.threadListeners.set(threadId, new Set());
+    this.threadListeners.get(threadId).add(listener);
+    return () => {
+      const set = this.threadListeners.get(threadId);
+      if (!set) return;
+      set.delete(listener);
+      if (set.size === 0) this.threadListeners.delete(threadId);
+    };
+  }
+
+  async ensureThreadAttached(threadId, resumeParams = {}) {
+    await this.connect();
+    if (this.attachedThreads.has(threadId)) return { resumed: false, thread: this.threadCwds.get(threadId) };
+    const result = await this.request("thread/resume", { threadId, ...resumeParams });
+    this.attachedThreads.add(threadId);
+    if (result?.thread?.cwd) this.threadCwds.set(threadId, result.thread);
+    return { resumed: true, thread: result?.thread };
+  }
+
+  /**
+   * The app-server takes the per-thread writer lock when it loads a thread and
+   * keeps it until it exits, so a thread this bridge has attached cannot be
+   * written to from anywhere else - the desktop app included.
+   */
+  holdsThread(threadId) {
+    return this.attachedThreads.has(threadId);
+  }
+
+  markAttached(threadId, thread = null) {
+    this.attachedThreads.add(threadId);
+    if (thread?.cwd) this.threadCwds.set(threadId, thread);
+  }
+}