@linzumi/cli 0.0.105-beta → 0.0.107-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.105-beta --version
+npx -y @linzumi/cli@0.0.107-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -15076,6 +15076,15 @@ import { createServer } from "node:net";
 import { homedir as homedir8 } from "node:os";
 import { join as join10 } from "node:path";
 import { WebSocket as NodeWebSocket } from "ws";
+function pingWebSocketIfSupported(websocket) {
+  const candidate = websocket;
+  if (typeof candidate.ping === "function" && candidate.readyState === WebSocket.OPEN) {
+    try {
+      candidate.ping();
+    } catch {
+    }
+  }
+}
 async function chooseLoopbackPort() {
   return new Promise((resolve12, reject) => {
     const server = createServer();
@@ -15363,7 +15372,13 @@ async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new
     pending.forEach((pendingRequest) => pendingRequest.reject(error));
     pending.clear();
   };
+  const keepalive = setInterval(
+    () => pingWebSocketIfSupported(websocket),
+    codexAppServerKeepaliveIntervalMs
+  );
+  keepalive.unref?.();
   const handleConnectionClosed = (message) => {
+    clearInterval(keepalive);
     rejectPending(message);
     if (state.closeError !== void 0) {
       return;
@@ -15443,7 +15458,10 @@ async function connectCodexAppServer(websocketUrl, socketFactory = (url) => new
       }
       closeCallbacks.add(callback);
     },
-    close: () => websocket.close()
+    close: () => {
+      clearInterval(keepalive);
+      websocket.close();
+    }
   };
 }
 function parseCodexAppServerFrame(data) {
@@ -15653,7 +15671,7 @@ function readyzUrlForWebsocket(websocketUrl) {
   parsed.hash = "";
   return parsed.toString();
 }
-var codexAppServerWatchdogPollMs, blockedCodexAppServerEnvKeys, codexDisableAppsConfigArgs;
+var codexAppServerWatchdogPollMs, codexAppServerKeepaliveIntervalMs, blockedCodexAppServerEnvKeys, codexDisableAppsConfigArgs;
 var init_codexAppServer = __esm({
   "src/codexAppServer.ts"() {
     "use strict";
@@ -15663,6 +15681,14 @@ var init_codexAppServer = __esm({
     init_engineChildReaper();
     init_engineParentDeathWatchdog();
     codexAppServerWatchdogPollMs = 2e3;
+    codexAppServerKeepaliveIntervalMs = (() => {
+      const raw = process.env.LINZUMI_CODEX_WS_KEEPALIVE_MS;
+      if (raw === void 0) {
+        return 2e4;
+      }
+      const parsed = Number.parseInt(raw, 10);
+      return Number.isInteger(parsed) && parsed > 0 ? parsed : 2e4;
+    })();
     blockedCodexAppServerEnvKeys = [
       "LINZUMI_MCP_ACCESS_TOKEN",
       "LINZUMI_MCP_OWNER_USERNAME"
@@ -19972,7 +19998,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.105-beta";
+    linzumiCliVersion = "0.0.107-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -22702,6 +22728,9 @@ var init_authCache = __esm({
 });
 
 // src/threadCodexWorkerIpc.ts
+function isThreadCodexWorkerSessionClosedMessage(message) {
+  return isJsonObject(message) && message.type === "linzumi_thread_codex_worker_session_closed";
+}
 function bindThreadCodexWorkerIpc(codex, ipc = process) {
   const pendingServerRequests = /* @__PURE__ */ new Map();
   const state = { nextServerRequestId: 1, sendDropLogged: false };
@@ -23654,15 +23683,33 @@ async function runThreadCodexWorker(options) {
   const log2 = makeRunnerLogger(options);
   const started = await startOwnedCodexAppServer(options);
   const codex = await connectCodexAppServer(started.url);
+  const kandanThreadId = options.threadProcess.kandanThreadId;
   const stop = once(() => {
     codex.close();
     started.stop();
     log2.close();
   });
   bindThreadCodexWorkerIpc(codex);
+  codex.onClose?.((error) => {
+    log2("runner.thread_codex_worker_session_closed", {
+      kandanThreadId,
+      reason: error.message
+    });
+    if (process.send !== void 0 && process.connected !== false) {
+      try {
+        process.send({
+          type: "linzumi_thread_codex_worker_session_closed",
+          kandanThreadId,
+          reason: error.message
+        });
+      } catch {
+      }
+    }
+    stop();
+  });
   process.send({
     type: "linzumi_thread_codex_worker_ready",
-    kandanThreadId: options.threadProcess.kandanThreadId,
+    kandanThreadId,
     commanderManagedPorts: commanderManagedPortsForStartedCodex(started)
   });
   await waitForThreadCodexWorkerStop(started.process);
@@ -25472,6 +25519,17 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
           (port) => port.port
         )
       });
+      const evictOnFailedResult = async (result) => {
+        if (result !== void 0 && result.ok !== false) {
+          return result;
+        }
+        const entry = threadRunnerProcesses.get(kandanThreadId);
+        if (entry === startingEntry || entry?.kind === "running") {
+          threadRunnerProcesses.delete(kandanThreadId);
+        }
+        await (entry?.kind === "running" ? entry.handle.close() : handle.close()).catch(() => void 0);
+        return result;
+      };
       switch (control.type) {
         case "start_instance": {
           const result = await startCodexProviderInstance({
@@ -25487,27 +25545,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
             setStartupStage: () => void 0,
             setStartedCodexThreadId: () => void 0
           });
-          return result.controlResponse;
+          return await evictOnFailedResult(result.controlResponse);
         }
         case "reconnect_thread":
-          return await applyControl(
-            threadCodex,
-            kandan,
-            topic,
-            instanceId,
-            options,
-            agentProviders,
-            allowedCwds,
-            remoteCodexSandboxRunner,
-            activeRemoteCodexExecRequests,
-            activeClaudeCodeSessions,
-            pendingClaudeCodeApprovals,
-            ensureClaudeCodeForwardPortSession,
-            disposeClaudeCodeForwardPortSession,
-            control,
-            log2,
-            onStartedThread,
-            void 0
+          return await evictOnFailedResult(
+            await applyControl(
+              threadCodex,
+              kandan,
+              topic,
+              instanceId,
+              options,
+              agentProviders,
+              allowedCwds,
+              remoteCodexSandboxRunner,
+              activeRemoteCodexExecRequests,
+              activeClaudeCodeSessions,
+              pendingClaudeCodeApprovals,
+              ensureClaudeCodeForwardPortSession,
+              disposeClaudeCodeForwardPortSession,
+              control,
+              log2,
+              onStartedThread,
+              void 0
+            )
           );
       }
     } catch (error) {
@@ -25520,6 +25580,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
   };
   const spawnOnMissInFlight = /* @__PURE__ */ new Map();
+  const spawnOnMissHandledMessages = /* @__PURE__ */ new Map();
   const replaySpawnOnMissMessageOnLiveSession = async (event, record, reconnectControl) => {
     try {
       log2("runner.spawn_on_miss_replay_on_sibling", {
@@ -25564,13 +25625,24 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
   };
   const handleUnroutedThreadMessage = async (event) => {
-    if (!shouldUseThreadProcesses(options)) {
-      return "ignored";
-    }
     const kandanThreadId = event.threadId;
-    if (kandanThreadId === void 0) {
+    if (!shouldUseThreadProcesses(options) || kandanThreadId === void 0) {
       return "ignored";
     }
+    const messageKey = `${kandanThreadId}:${event.seq}`;
+    const inFlightMessage = spawnOnMissHandledMessages.get(messageKey);
+    if (inFlightMessage !== void 0) {
+      return await inFlightMessage;
+    }
+    const run = handleUnroutedThreadMessageOnce(event, kandanThreadId);
+    spawnOnMissHandledMessages.set(messageKey, run);
+    try {
+      return await run;
+    } finally {
+      spawnOnMissHandledMessages.delete(messageKey);
+    }
+  };
+  const handleUnroutedThreadMessageOnce = async (event, kandanThreadId) => {
     const existing = threadRunnerProcesses.get(kandanThreadId);
     const existingLiveness = existing === void 0 ? void 0 : threadRunnerEntryLiveness(existing);
     if (existingLiveness === "live") {
@@ -25586,6 +25658,12 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       ...baseControl,
       sourceSeq: event.seq,
       workDescription: event.body,
+      // Carry the user's attachments on the reconstructed control (Codex P2) so
+      // the FIRST spawn-on-miss message - the one that owns the respawn and runs
+      // its turn inside startThreadRunnerProcess, not via the replay helper -
+      // still resumes with its files/images. Re-serialized to the wire shape the
+      // resume turn parses (parseKandanChatAttachments).
+      ...event.attachments.length === 0 ? {} : { attachments: kandanChatAttachmentsToWire(event.attachments) },
       ...providerBinding?.modelProvider === void 0 ? {} : { modelProvider: providerBinding.modelProvider },
       ...providerBinding?.llmProxy === void 0 ? {} : { llmProxy: providerBinding.llmProxy }
     };
@@ -25658,6 +25736,23 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         );
         return "spawned";
       }
+      if (startResult === void 0 || startResult.ok === false) {
+        spawnSettle("no_session");
+        const startError = startResult !== void 0 && typeof startResult.error === "string" ? startResult.error : "the thread could not be resumed (no resumable codex session)";
+        log2("runner.spawn_on_miss_failed", {
+          kandanThreadId,
+          codex_thread_id: record.codexThreadId,
+          seq: event.seq,
+          message: startError
+        });
+        await publishSpawnOnMissMessageState(
+          reconnectControl,
+          "failed",
+          `could not resume the thread's coding session: ${startError}`,
+          record.codexThreadId
+        );
+        return "spawned";
+      }
       spawnSettle("spawned");
       return "spawned";
     } catch (error) {
@@ -27717,11 +27812,15 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           })
         );
         const identity = identityFromAccessToken(options.token);
+        const reconnectAttachments = parseKandanChatAttachments(
+          arrayValue(control.attachments) ?? []
+        );
         await startedThreadSession.startThreadMessageTurn({
           seq: sourceSeq,
           body: workDescription,
           actorSlug: identity.actorUsername,
           actorUserId: identity.actorUserId,
+          attachments: reconnectAttachments,
           boundStartTimeout: true
         });
       }
@@ -28396,6 +28495,9 @@ async function startCodexProviderInstance(args) {
     args.setStartupStage("starting_first_turn");
     const rootSeq = integerValue(args.control.rootSeq);
     const sourceSeq = integerValue(args.control.sourceSeq) ?? rootSeq;
+    const firstTurnAttachments = parseKandanChatAttachments(
+      arrayValue(args.control.attachments) ?? []
+    );
     if (startedThreadSession !== void 0 && sourceSeq !== void 0) {
       const identity = identityFromAccessToken(args.options.token);
       await startedThreadSession.startThreadMessageTurn({
@@ -28403,6 +28505,7 @@ async function startCodexProviderInstance(args) {
         body: workDescription,
         actorSlug: identity.actorUsername,
         actorUserId: identity.actorUserId,
+        attachments: firstTurnAttachments,
         boundStartTimeout: true
       });
     } else {
@@ -29761,6 +29864,16 @@ function rehydrationControlSnapshot(args) {
     ...runtimeSettings.fast === void 0 ? {} : { fast: runtimeSettings.fast }
   };
 }
+function kandanChatAttachmentsToWire(attachments) {
+  return attachments.map((attachment) => ({
+    ...attachment.id === void 0 ? {} : { id: attachment.id },
+    ...attachment.kind === void 0 ? {} : { kind: attachment.kind },
+    ...attachment.fileName === void 0 ? {} : { file_name: attachment.fileName },
+    ...attachment.contentType === void 0 ? {} : { content_type: attachment.contentType },
+    ...attachment.sizeBytes === void 0 ? {} : { size_bytes: attachment.sizeBytes },
+    ...attachment.url === void 0 ? {} : { url: attachment.url }
+  }));
+}
 function rehydrationReconnectControl(record) {
   const snapshot = record.control;
   const rootSeq = integerValue(snapshot.rootSeq);
@@ -29972,6 +30085,9 @@ function threadRunnerEntryLiveness(entry) {
   if (ipcClosed) {
     return "dead";
   }
+  if (handle.sessionClosed?.() === true) {
+    return "dead";
+  }
   return processIsAlive2(handle.processPid) ? "live" : "dead";
 }
 async function closeThreadRunnerEntry(entry) {
@@ -30029,6 +30145,18 @@ async function spawnLocalThreadRunnerProcess(options) {
   });
   const exitListeners = /* @__PURE__ */ new Set();
   const exitState = { exited: false };
+  const sessionState = { closed: false };
+  child.on("message", (message) => {
+    if (isThreadCodexWorkerSessionClosedMessage(message)) {
+      sessionState.closed = true;
+      writeCliAuditEvent("runner.thread_runner_session_detached", {
+        purpose: "linzumi.thread_runner",
+        kandanThreadId: message.kandanThreadId,
+        reason: message.reason,
+        pid: child.pid
+      });
+    }
+  });
   child.once("exit", (code, signal) => {
     writeCliAuditEvent("process.exit", {
       command: process.execPath,
@@ -30104,6 +30232,7 @@ async function spawnLocalThreadRunnerProcess(options) {
     codex: connectThreadCodexWorkerIpc(child),
     processPid: child.pid,
     commanderManagedPorts: ready2.commanderManagedPorts,
+    sessionClosed: () => sessionState.closed,
     onExit: (listener) => {
       if (exitState.exited) {
         queueMicrotask(listener);

package/package.json

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