@linzumi/cli 0.0.99-beta → 0.0.101-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.99-beta --version
+npx -y @linzumi/cli@0.0.101-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -3361,7 +3361,8 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     resolveReady: void 0,
     rejectReady: void 0,
     reconnectTimer: void 0,
-    reconnectAttempts: 0
+    reconnectAttempts: 0,
+    heartbeatTimer: void 0
   };
   const pushTimeoutMs = options.pushTimeoutMs ?? defaultPushTimeoutMs;
   const controlCursorStore = options.controlCursorStore;
@@ -3751,6 +3752,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
     state.connected = false;
     const websocket = state.websocket;
     state.websocket = void 0;
+    stopHeartbeat();
     if (websocket !== void 0 && (websocket.readyState === WebSocket.CONNECTING || websocket.readyState === WebSocket.OPEN)) {
       try {
         websocket.close();
@@ -3768,6 +3770,29 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
       });
     }
   };
+  const HEARTBEAT_INTERVAL_MS = 3e4;
+  const stopHeartbeat = () => {
+    if (state.heartbeatTimer !== void 0) {
+      clearInterval(state.heartbeatTimer);
+      state.heartbeatTimer = void 0;
+    }
+  };
+  const startHeartbeat = () => {
+    stopHeartbeat();
+    state.heartbeatTimer = setInterval(() => {
+      const websocket = state.websocket;
+      if (websocket === void 0 || websocket.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      const ref = String(state.nextRef);
+      state.nextRef += 1;
+      try {
+        websocket.send(JSON.stringify([null, ref, "phoenix", "heartbeat", {}]));
+      } catch {
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+    state.heartbeatTimer.unref?.();
+  };
   const openSocket = async () => {
     if (state.closed) {
       return;
@@ -3803,6 +3828,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url, protoc
       state.connected = true;
       state.hasEverConnected = true;
       state.reconnectAttempts = 0;
+      startHeartbeat();
       markReady();
       if (state.connectionGeneration > 1) {
         reconnectCallbacks.forEach((callback) => {
@@ -19803,7 +19829,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.99-beta";
+    linzumiCliVersion = "0.0.101-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -22098,6 +22124,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";
@@ -24699,6 +24756,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);
@@ -24778,81 +24836,96 @@ 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 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 (rebuilt) {
-              await replayOntoLiveSession({ waitForSiblingSpawn: false });
-            } else {
-              const startResult = await startThreadRunnerProcess(
-                reconnectControl,
-                cwd
+      const rebuildOnDeadCodexWorker = shouldUseThreadProcesses(options) ? async (rebuildArgs) => threadRebuildSerializer.run(
+        rebuildArgs.kandanThreadId,
+        async () => {
+          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 replayOntoLiveSession = async (options2) => {
+              const liveSession = await withCodexStartRequestTimeout(
+                "thread/attach",
+                resolveLiveDynamicChannelSession(
+                  rebuildArgs.codexThreadId,
+                  {
+                    waitForSiblingSpawn: options2.waitForSiblingSpawn
+                  }
+                )
               );
-              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
+              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 (rebuilt) {
+                await replayOntoLiveSession({
+                  waitForSiblingSpawn: false
                 });
-                await replayOntoLiveSession({ waitForSiblingSpawn: true });
+              } 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,
@@ -31192,6 +31265,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.99-beta",
+  "version": "0.0.101-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": {