@linzumi/cli 0.0.97-beta → 0.0.99-beta

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.97-beta --version
+npx -y @linzumi/cli@0.0.99-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -14705,7 +14705,16 @@ function linzumiMcpServerConfig(options) {
       ...options.toolScope === void 0 || options.toolScope === "all" ? [] : ["--tool-scope", options.toolScope]
     ],
     env: {
-      ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken }
+      ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken },
+      // The Linzumi metadata MCP is launched by codex as a STDIO child whose
+      // `command` may be the Electron app binary. That binary only behaves as a
+      // plain Node process (and thus boots the MCP server instead of a GUI
+      // shell) when ELECTRON_RUN_AS_NODE=1 is present in its env. Newer codex
+      // sanitizes MCP-child env to an allowlist that drops ELECTRON_RUN_AS_NODE,
+      // so we both (a) pin it here and (b) explicitly forward it via
+      // codexMcpConfigArgs / codexMcpConfigToml below. For a real Node `command`
+      // this flag is a harmless no-op, so we always include it.
+      ELECTRON_RUN_AS_NODE: "1"
     }
   };
 }
@@ -14714,7 +14723,16 @@ function codexMcpConfigArgs(config) {
     "-c",
     `mcp_servers.${config.name}.command=${JSON.stringify(config.command)}`,
     "-c",
-    `mcp_servers.${config.name}.args=${tomlStringArray(config.args)}`
+    `mcp_servers.${config.name}.args=${tomlStringArray(config.args)}`,
+    // Explicitly forward the server env (ELECTRON_RUN_AS_NODE,
+    // LINZUMI_MCP_ACCESS_TOKEN, …) so codex passes it to the stdio child
+    // regardless of its env-forwarding/sanitization allowlist. Without this,
+    // newer codex strips ELECTRON_RUN_AS_NODE and the Electron-binary `command`
+    // boots a GUI shell that pollutes the MCP stdout JSON-RPC framing.
+    ...Object.entries(config.env).flatMap(([key, value]) => [
+      "-c",
+      `mcp_servers.${config.name}.env.${key}=${JSON.stringify(value)}`
+    ])
   ];
 }
 function linzumiMcpCommandForProcess(processExecPath, scriptPath, execArgv = []) {
@@ -19785,7 +19803,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.97-beta";
+    linzumiCliVersion = "0.0.99-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -24561,6 +24579,17 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
   }
   const dynamicChannelSessions = /* @__PURE__ */ new Map();
   const dynamicChannelSessionAttachInFlight = /* @__PURE__ */ new Map();
+  const dynamicChannelSessionAttachWaiters = /* @__PURE__ */ new Map();
+  const resolveDynamicChannelSessionAttachWaiters = (codexThreadId, session) => {
+    const waiters = dynamicChannelSessionAttachWaiters.get(codexThreadId);
+    if (waiters === void 0) {
+      return;
+    }
+    dynamicChannelSessionAttachWaiters.delete(codexThreadId);
+    for (const waiter of waiters) {
+      waiter(session);
+    }
+  };
   const dynamicChannelSessionCodexClients = /* @__PURE__ */ new Map();
   const codexTurnFailureGuards = /* @__PURE__ */ new Map();
   const lossReportPushes = [];
@@ -24622,6 +24651,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     dynamicChannelSessions.clear();
     dynamicChannelSessionCodexClients.clear();
+    dynamicChannelSessionAttachWaiters.clear();
     const claudeSessions = [...activeClaudeCodeSessions.values()];
     for (const session of claudeSessions) {
       try {
@@ -24698,6 +24728,28 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
     return true;
   };
+  const resolveLiveDynamicChannelSession = async (codexThreadId, options2 = {}) => {
+    const existing = dynamicChannelSessions.get(codexThreadId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const inFlight = dynamicChannelSessionAttachInFlight.get(codexThreadId);
+    if (inFlight !== void 0) {
+      const attached = await inFlight;
+      if (attached !== void 0) {
+        return attached;
+      }
+    }
+    const settled = dynamicChannelSessions.get(codexThreadId);
+    if (settled !== void 0 || options2.waitForSiblingSpawn !== true) {
+      return settled;
+    }
+    return await new Promise((resolve12) => {
+      const waiters = dynamicChannelSessionAttachWaiters.get(codexThreadId) ?? [];
+      waiters.push(resolve12);
+      dynamicChannelSessionAttachWaiters.set(codexThreadId, waiters);
+    });
+  };
   const attachThreadSessionWithCodex = async (args) => {
     const { control, cwd, codexThreadId, sessionCodex } = args;
     const portForwardWatcherRootPid = args.portForwardWatcherRootPid;
@@ -24737,6 +24789,11 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
             threadId: rebuildArgs.kandanThreadId,
             codexThreadId: rebuildArgs.codexThreadId,
             cwd,
+            // Carry the conversation context through the rebuild-replay so
+            // the respawned worker's developer instructions match what the
+            // server would have replayed (parity with the live reconnect
+            // control built above at channelSession.linzumiContext).
+            ...control.linzumiContext === void 0 ? {} : { linzumiContext: control.linzumiContext },
             ...integerValue(control.rootSeq) === void 0 ? {} : { rootSeq: integerValue(control.rootSeq) },
             sourceSeq: message.seq,
             workDescription: message.body,
@@ -24746,19 +24803,42 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
             ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
             ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
           };
-          const liveSession = dynamicChannelSessions.get(
-            rebuildArgs.codexThreadId
-          );
+          const replayOntoLiveSession = async (options2) => {
+            const liveSession = await withCodexStartRequestTimeout(
+              "thread/attach",
+              resolveLiveDynamicChannelSession(rebuildArgs.codexThreadId, {
+                waitForSiblingSpawn: options2.waitForSiblingSpawn
+              })
+            );
+            if (liveSession === void 0) {
+              throw new Error(
+                `dead-worker rebuild could not resolve a live session for codex thread ${rebuildArgs.codexThreadId}`
+              );
+            }
+            await liveSession.startThreadMessageTurn({
+              seq: message.seq,
+              body: message.body,
+              actorSlug: message.actorSlug,
+              actorUserId: message.actorUserId,
+              boundStartTimeout: true
+            });
+          };
           try {
-            if (liveSession !== void 0 && rebuilt) {
-              await liveSession.startThreadMessageTurn({
-                seq: message.seq,
-                body: message.body,
-                actorSlug: message.actorSlug,
-                actorUserId: message.actorUserId
-              });
+            if (rebuilt) {
+              await replayOntoLiveSession({ waitForSiblingSpawn: false });
             } else {
-              await startThreadRunnerProcess(reconnectControl, cwd);
+              const startResult = await startThreadRunnerProcess(
+                reconnectControl,
+                cwd
+              );
+              if (threadStartDelegatedToSibling(startResult)) {
+                log2("runner.thread_dead_worker_rebuild_replay_on_sibling", {
+                  codex_thread_id: rebuildArgs.codexThreadId,
+                  kandan_thread_id: rebuildArgs.kandanThreadId,
+                  seq: message.seq
+                });
+                await replayOntoLiveSession({ waitForSiblingSpawn: true });
+              }
             }
             rebuilt = true;
           } catch (error) {
@@ -24830,6 +24910,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       });
       dynamicChannelSessions.set(codexThreadId, session);
       dynamicChannelSessionCodexClients.set(codexThreadId, sessionCodex);
+      resolveDynamicChannelSessionAttachWaiters(codexThreadId, session);
       threadSessionRegistry.upsert({
         workspace: workspaceSlug,
         channel: channelSlug,
@@ -25949,6 +26030,9 @@ function controlTargetsInstance(control, instanceId) {
 function controlInstanceId(control) {
   return "instanceId" in control ? control.instanceId : void 0;
 }
+function threadStartDelegatedToSibling(startResult) {
+  return startResult !== void 0 && startResult.delegated === true && startResult.threadProcess === "already_started";
+}
 function shouldUseThreadProcesses(options) {
   if (options.threadProcess?.role === "thread") {
     return false;
@@ -26506,7 +26590,10 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     threadId: codexThreadId,
     ...resumeOverrides
   };
-  const resumeResponse = await codex.request("thread/resume", resumeParams);
+  const resumeResponse = await withCodexStartRequestTimeout(
+    "thread/resume",
+    codex.request("thread/resume", resumeParams)
+  );
   if (!("error" in resumeResponse)) {
     return;
   }
@@ -26524,7 +26611,10 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
       `failed to prepare Codex thread before reconnect: ${injected.error.message}`
     );
   }
-  const verified = await codex.request("thread/resume", resumeParams);
+  const verified = await withCodexStartRequestTimeout(
+    "thread/resume",
+    codex.request("thread/resume", resumeParams)
+  );
   if ("error" in verified) {
     throw new Error(
       `failed to verify Codex thread before reconnect: ${verified.error.message}`
@@ -27089,7 +27179,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
         ensureCodexProjectTrusted(cwd.cwd);
       }
       const runtimeSettings = startInstanceRuntimeSettings(options, control);
-      const startedThreadSession = onStartedThread === void 0 ? void 0 : await onStartedThread(control, cwd.cwd, codexThreadId);
+      const startedThreadSession = onStartedThread === void 0 ? void 0 : await withCodexStartRequestTimeout(
+        "thread/attach",
+        onStartedThread(control, cwd.cwd, codexThreadId)
+      );
       if (workDescription !== void 0) {
         const rootSeq = integerValue(control.rootSeq);
         const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
@@ -27115,7 +27208,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           seq: sourceSeq,
           body: workDescription,
           actorSlug: identity.actorUsername,
-          actorUserId: identity.actorUserId
+          actorUserId: identity.actorUserId,
+          boundStartTimeout: true
         });
       }
       return {
@@ -27780,10 +27874,9 @@ async function startCodexProviderInstance(args) {
   let startedThreadSession;
   if (codexThreadId !== void 0 && args.onStartedThread !== void 0) {
     args.setStartupStage("binding_kandan_thread");
-    startedThreadSession = await args.onStartedThread(
-      args.control,
-      args.cwd,
-      codexThreadId
+    startedThreadSession = await withCodexStartRequestTimeout(
+      "thread/attach",
+      args.onStartedThread(args.control, args.cwd, codexThreadId)
     );
   }
   if (codexThreadId !== void 0 && workDescription !== void 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.97-beta",
+  "version": "0.0.99-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {