@linzumi/cli 0.0.98-beta → 0.0.100-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.98-beta --version
+npx -y @linzumi/cli@0.0.100-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -19803,7 +19803,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.98-beta";
+    linzumiCliVersion = "0.0.100-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -22098,6 +22098,37 @@ var init_runnerConsoleReporter = __esm({
   }
 });
 
+// src/threadRebuildSerializer.ts
+function createThreadRebuildSerializer() {
+  const chains = /* @__PURE__ */ new Map();
+  return {
+    async run(key, fn) {
+      const prior = chains.get(key) ?? Promise.resolve();
+      const run = prior.then(fn, fn);
+      const tail = run.then(
+        () => void 0,
+        () => void 0
+      );
+      chains.set(key, tail);
+      try {
+        return await run;
+      } finally {
+        if (chains.get(key) === tail) {
+          chains.delete(key);
+        }
+      }
+    },
+    activeKeyCount() {
+      return chains.size;
+    }
+  };
+}
+var init_threadRebuildSerializer = __esm({
+  "src/threadRebuildSerializer.ts"() {
+    "use strict";
+  }
+});
+
 // src/telemetry.ts
 import { mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "node:fs";
 import { dirname as dirname11, basename as basename7, join as join18 } from "node:path";
@@ -24579,6 +24610,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 = [];
@@ -24640,6 +24682,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     dynamicChannelSessions.clear();
     dynamicChannelSessionCodexClients.clear();
+    dynamicChannelSessionAttachWaiters.clear();
     const claudeSessions = [...activeClaudeCodeSessions.values()];
     for (const session of claudeSessions) {
       try {
@@ -24687,6 +24730,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     threadRunnerProcesses.clear();
   });
+  const threadRebuildSerializer = createThreadRebuildSerializer();
   const evictStaleDynamicChannelSession = async (codexThreadId, expectClient) => {
     const session = dynamicChannelSessions.get(codexThreadId);
     const boundClient = dynamicChannelSessionCodexClients.get(codexThreadId);
@@ -24716,6 +24760,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;
@@ -24744,36 +24810,50 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         );
       }
       const runtimeSettings = startInstanceRuntimeSettings(options, control);
-      const rebuildOnDeadCodexWorker = shouldUseThreadProcesses(options) ? async (rebuildArgs) => {
-        await evictStaleDynamicChannelSession(rebuildArgs.codexThreadId);
-        let rebuilt = false;
-        for (const message of rebuildArgs.pendingMessages) {
-          const reconnectControl = {
-            type: "reconnect_thread",
-            workspace: workspaceSlug,
-            channel: channelSlug,
-            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,
-            ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
-            ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
-            ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
-            ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
-            ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
-          };
-          const liveSession = dynamicChannelSessions.get(
+      const rebuildOnDeadCodexWorker = shouldUseThreadProcesses(options) ? async (rebuildArgs) => threadRebuildSerializer.run(
+        rebuildArgs.kandanThreadId,
+        async () => {
+          await evictStaleDynamicChannelSession(
             rebuildArgs.codexThreadId
           );
-          try {
-            if (liveSession !== void 0 && rebuilt) {
+          let rebuilt = false;
+          for (const message of rebuildArgs.pendingMessages) {
+            const reconnectControl = {
+              type: "reconnect_thread",
+              workspace: workspaceSlug,
+              channel: channelSlug,
+              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,
+              ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
+              ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+              ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
+              ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+              ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
+            };
+            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,
@@ -24781,22 +24861,45 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
                 actorUserId: message.actorUserId,
                 boundStartTimeout: true
               });
-            } else {
-              await startThreadRunnerProcess(reconnectControl, cwd);
+            };
+            try {
+              if (rebuilt) {
+                await replayOntoLiveSession({
+                  waitForSiblingSpawn: false
+                });
+              } else {
+                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) {
+              log2("runner.thread_dead_worker_rebuild_failed", {
+                codex_thread_id: rebuildArgs.codexThreadId,
+                kandan_thread_id: rebuildArgs.kandanThreadId,
+                seq: message.seq,
+                message: error instanceof Error ? error.message : String(error)
+              });
+              return false;
             }
-            rebuilt = true;
-          } catch (error) {
-            log2("runner.thread_dead_worker_rebuild_failed", {
-              codex_thread_id: rebuildArgs.codexThreadId,
-              kandan_thread_id: rebuildArgs.kandanThreadId,
-              seq: message.seq,
-              message: error instanceof Error ? error.message : String(error)
-            });
-            return false;
           }
+          return rebuilt;
         }
-        return rebuilt;
-      } : void 0;
+      ) : void 0;
       const session = await attachChannelSession({
         kandan,
         codex: sessionCodex,
@@ -24854,6 +24957,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,
@@ -25973,6 +26077,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;
@@ -27119,7 +27226,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;
@@ -27811,10 +27921,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) {
@@ -31130,6 +31239,7 @@ var init_runner = __esm({
     init_runnerLockTakeover();
     init_runnerConsoleReporter();
     init_version();
+    init_threadRebuildSerializer();
     init_telemetry();
     init_mcpConfig();
     init_linzumiApiClient();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.98-beta",
+  "version": "0.0.100-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": {