@linzumi/cli 0.0.104-beta → 0.0.106-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.104-beta --version
+npx -y @linzumi/cli@0.0.106-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -10637,6 +10637,28 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
   }
   startPortForwardWatchIfEnabled(args, state, payloadContext);
   if (event.threadId !== state.kandanThreadId) {
+    if (args.options.onUnroutedThreadMessage !== void 0) {
+      try {
+        const outcome = await args.options.onUnroutedThreadMessage(event);
+        if (outcome === "spawned") {
+          args.log("kandan.message_spawn_on_miss", {
+            seq: event.seq,
+            actor_slug: event.actorSlug ?? null,
+            actor_user_id: event.actorUserId ?? null,
+            thread_id: event.threadId ?? null,
+            bound_thread_id: state.kandanThreadId ?? null,
+            body_preview: runnerConsoleBodyPreview(event.body)
+          });
+          return;
+        }
+      } catch (error) {
+        args.log("kandan.message_spawn_on_miss_failed", {
+          seq: event.seq,
+          thread_id: event.threadId ?? null,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
     args.log("kandan.message_ignored", {
       seq: event.seq,
       actor_slug: event.actorSlug ?? null,
@@ -10750,7 +10772,9 @@ async function startThreadMessageTurn(args, state, payloadContext, message) {
     actorSlug: message.actorSlug,
     actorUserId: message.actorUserId,
     body: message.body,
-    attachments: [],
+    // Forward the user's attachments (files/images) just like the normal routed
+    // path; a replayed follow-up with files must not lose them.
+    attachments: message.attachments ?? [],
     receivedAtMs: Date.now()
   };
   enqueuePendingKandanMessage(state.queue, queued);
@@ -19948,7 +19972,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.104-beta";
+    linzumiCliVersion = "0.0.106-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -24749,6 +24773,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         clearForwardPortAttribution(port);
         return capabilitiesPayload();
       },
+      // Catch unrouted thread.message events even when no dynamic worker
+      // session is attached (the durable thread's worker fully died). Late-
+      // bound to dodge the const's temporal dead zone (defined below).
+      onUnroutedThreadMessage: (event) => handleUnroutedThreadMessage(event),
       channelSession: options.channelSession
     },
     log: log2
@@ -24879,6 +24907,34 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     threadRunnerProcesses.clear();
   });
+  const reapStaleThreadRunnerProcesses = () => {
+    for (const [kandanThreadId, entry] of Array.from(
+      threadRunnerProcesses.entries()
+    )) {
+      if (threadRunnerEntryLiveness(entry) !== "dead") {
+        continue;
+      }
+      if (threadRunnerProcesses.get(kandanThreadId) !== entry) {
+        continue;
+      }
+      threadRunnerProcesses.delete(kandanThreadId);
+      log2("runner.thread_process_stale_entry_reaped", {
+        kandanThreadId,
+        pid: entry.kind === "running" ? entry.handle.processPid ?? null : null,
+        prior_kind: entry.kind
+      });
+      void closeThreadRunnerEntry(entry).catch(() => void 0);
+    }
+  };
+  if (shouldUseThreadProcesses(options)) {
+    const reaperIntervalMs = options.threadRunnerReaperIntervalMs ?? THREAD_RUNNER_REAPER_INTERVAL_MS;
+    const reaperInterval = setInterval(
+      reapStaleThreadRunnerProcesses,
+      reaperIntervalMs
+    );
+    reaperInterval.unref?.();
+    cleanup.actions.push(() => clearInterval(reaperInterval));
+  }
   const threadModelProviderBindings = /* @__PURE__ */ new Map();
   const threadRebuildSerializer = createThreadRebuildSerializer();
   const evictStaleDynamicChannelSession = async (codexThreadId, expectClient) => {
@@ -25081,6 +25137,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
           fast: control.fast ?? options.fast,
           launchTui: false,
           rebuildOnDeadCodexWorker,
+          // Late-bound (defined after startThreadRunnerProcess); the arrow keeps
+          // it out of the const's temporal dead zone while still resolving the
+          // live handler when an unrouted chat event actually arrives.
+          onUnroutedThreadMessage: (event) => handleUnroutedThreadMessage(event),
           pipelinePersistDir: commanderOutboxPersistDir(),
           enablePortForwardWatch: true,
           initialForwardPorts: allowedForwardPorts,
@@ -25277,15 +25337,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
     const existing = threadRunnerProcesses.get(kandanThreadId);
     if (existing !== void 0) {
-      return {
-        instanceId,
-        controlType: control.type,
-        ok: true,
-        delegated: true,
-        threadProcess: "already_started",
+      const liveness = threadRunnerEntryLiveness(existing);
+      if (liveness !== "dead") {
+        return {
+          instanceId,
+          controlType: control.type,
+          ok: true,
+          delegated: true,
+          threadProcess: "already_started",
+          kandanThreadId,
+          cwd
+        };
+      }
+      log2("runner.thread_process_stale_entry_evicted", {
         kandanThreadId,
-        cwd
-      };
+        codex_thread_id: control.type === "reconnect_thread" ? stringValue(control.codexThreadId) ?? null : null,
+        prior_kind: existing.kind,
+        pid: existing.kind === "running" ? existing.handle.processPid ?? null : null,
+        control_type: control.type
+      });
+      if (threadRunnerProcesses.get(kandanThreadId) === existing) {
+        threadRunnerProcesses.delete(kandanThreadId);
+      }
+      void closeThreadRunnerEntry(existing).catch(() => void 0);
     }
     const spawnThreadRunner = options.spawnThreadRunner ?? spawnLocalThreadRunnerProcess;
     const readyTimeoutMs = threadRunnerReadyTimeoutMs(options);
@@ -25398,6 +25472,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({
@@ -25413,27 +25498,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) {
@@ -25445,6 +25532,222 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       throw error;
     }
   };
+  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", {
+        kandanThreadId: event.threadId ?? null,
+        codex_thread_id: record.codexThreadId,
+        seq: event.seq
+      });
+      const liveSession = await withCodexStartRequestTimeout(
+        "thread/attach",
+        resolveLiveDynamicChannelSession(record.codexThreadId, {
+          waitForSiblingSpawn: true
+        })
+      );
+      if (liveSession === void 0) {
+        throw new Error(
+          `spawn-on-miss could not resolve a live session for codex thread ${record.codexThreadId}`
+        );
+      }
+      await liveSession.startThreadMessageTurn({
+        seq: event.seq,
+        body: event.body,
+        actorSlug: event.actorSlug,
+        actorUserId: event.actorUserId,
+        // Forward the user's attachments; a replayed follow-up with files/images
+        // must not be processed as if they were never sent.
+        attachments: event.attachments,
+        boundStartTimeout: true
+      });
+    } catch (error) {
+      log2("runner.spawn_on_miss_failed", {
+        kandanThreadId: event.threadId ?? null,
+        codex_thread_id: record.codexThreadId,
+        seq: event.seq,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      await publishSpawnOnMissMessageState(
+        reconnectControl,
+        "failed",
+        `could not resume the thread's coding session: ${error instanceof Error ? error.message : String(error)}`,
+        record.codexThreadId
+      );
+    }
+  };
+  const handleUnroutedThreadMessage = async (event) => {
+    const kandanThreadId = event.threadId;
+    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") {
+      return "ignored";
+    }
+    const record = threadSessionRegistry.list().find((entry) => entry.kandanThreadId === kandanThreadId);
+    if (record === void 0) {
+      return "ignored";
+    }
+    const baseControl = rehydrationReconnectControl(record);
+    const providerBinding = threadModelProviderBindings.get(kandanThreadId);
+    const reconnectControl = {
+      ...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 }
+    };
+    const cwd = resolveAllowedCwd(record.cwd, allowedCwds.value);
+    if (!cwd.ok) {
+      log2("runner.spawn_on_miss_cwd_rejected", {
+        kandanThreadId,
+        cwd: record.cwd,
+        reason: cwd.reason,
+        seq: event.seq
+      });
+      await publishSpawnOnMissMessageState(
+        reconnectControl,
+        "failed",
+        `could not resume the thread's coding session: working directory ${record.cwd} is not an allowed root (${cwd.reason})`,
+        record.codexThreadId
+      );
+      return "spawned";
+    }
+    const resolvedCwd = cwd.cwd;
+    const inFlightSpawn = spawnOnMissInFlight.get(kandanThreadId);
+    if (inFlightSpawn !== void 0) {
+      log2("runner.spawn_on_miss_resuming", {
+        kandanThreadId,
+        codex_thread_id: record.codexThreadId,
+        provider_session_key: record.codexThreadId,
+        seq: event.seq,
+        decision: "await_in_flight_spawn"
+      });
+      const outcome = await inFlightSpawn;
+      if (outcome === "no_session") {
+        await publishSpawnOnMissMessageState(
+          reconnectControl,
+          "failed",
+          `could not resume the thread's coding session: no live session after spawn`,
+          record.codexThreadId
+        );
+        return "spawned";
+      }
+      await replaySpawnOnMissMessageOnLiveSession(
+        event,
+        record,
+        reconnectControl
+      );
+      return "spawned";
+    }
+    log2("runner.spawn_on_miss_resuming", {
+      kandanThreadId,
+      codex_thread_id: record.codexThreadId,
+      provider_session_key: record.codexThreadId,
+      seq: event.seq,
+      decision: "spawned_resume"
+    });
+    let spawnSettle = () => void 0;
+    const spawnPromise = new Promise((resolve12) => {
+      spawnSettle = resolve12;
+    });
+    spawnOnMissInFlight.set(kandanThreadId, spawnPromise);
+    try {
+      const startResult = await startThreadRunnerProcess(
+        reconnectControl,
+        resolvedCwd
+      );
+      if (threadStartDelegatedToSibling(startResult)) {
+        spawnSettle("spawned");
+        await replaySpawnOnMissMessageOnLiveSession(
+          event,
+          record,
+          reconnectControl
+        );
+        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) {
+      spawnSettle("no_session");
+      log2("runner.spawn_on_miss_failed", {
+        kandanThreadId,
+        codex_thread_id: record.codexThreadId,
+        seq: event.seq,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      await publishSpawnOnMissMessageState(
+        reconnectControl,
+        "failed",
+        `could not resume the thread's coding session: ${error instanceof Error ? error.message : String(error)}`,
+        record.codexThreadId
+      );
+      return "spawned";
+    } finally {
+      spawnSettle("spawned");
+      if (spawnOnMissInFlight.get(kandanThreadId) === spawnPromise) {
+        spawnOnMissInFlight.delete(kandanThreadId);
+      }
+    }
+  };
+  const publishSpawnOnMissMessageState = async (control, status, reason, codexThreadId) => {
+    const payload = startInstanceMessageStatePayload(control, status, reason, {
+      instanceId,
+      codexThreadId
+    });
+    if (payload === void 0) {
+      return;
+    }
+    try {
+      await kandan.push(topic, "message_state", payload);
+    } catch (error) {
+      log2("runner.spawn_on_miss_state_push_failed", {
+        thread_id: optionalThreadControlField(control, "threadId") ?? null,
+        status,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const heartbeatPayload = () => ({
     instanceId,
     clientId,
@@ -27462,11 +27765,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
         });
       }
@@ -28141,6 +28448,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({
@@ -28148,6 +28458,7 @@ async function startCodexProviderInstance(args) {
         body: workDescription,
         actorSlug: identity.actorUsername,
         actorUserId: identity.actorUserId,
+        attachments: firstTurnAttachments,
         boundStartTimeout: true
       });
     } else {
@@ -29506,6 +29817,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);
@@ -29696,6 +30017,29 @@ function threadRunnerOptions(args) {
     channelSession: void 0
   };
 }
+function processIsAlive2(pid) {
+  if (pid === void 0 || !Number.isInteger(pid) || pid <= 0) {
+    return true;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error?.code;
+    return code === "EPERM";
+  }
+}
+function threadRunnerEntryLiveness(entry) {
+  if (entry.kind === "starting") {
+    return "starting";
+  }
+  const handle = entry.handle;
+  const ipcClosed = handle.codex.isClosed?.() === true;
+  if (ipcClosed) {
+    return "dead";
+  }
+  return processIsAlive2(handle.processPid) ? "live" : "dead";
+}
 async function closeThreadRunnerEntry(entry) {
   switch (entry.kind) {
     case "running":
@@ -31411,7 +31755,7 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
     };
   }
 }
-var THREAD_RUNNER_READY_TIMEOUT_MS, onboardingDiscoveryAgentStartKeys, onboardingConversationImportKeys, onboardingConversationDiscoveryReportLimit, staleStartInstanceWindowMs, connectionStaleThresholdMs, connectionUnrecoverableAfterMs, controlCursorWriteDebounceMs, controlCursorEpochKey, codexTurnTerminalNotificationMethods, claudeSessionStoreSequenceHighWater, claudeCodeLlmProxySessionHeader, onboardingConversationTitleFirstMessages, onboardingConversationTitleLastMessages, onboardingConversationTitleBodyMaxLength, onboardingConversationImportMessageMaxLength, onboardingConversationImportCandidateLimit, onboardingConversationImportProgressInterval;
+var THREAD_RUNNER_READY_TIMEOUT_MS, THREAD_RUNNER_REAPER_INTERVAL_MS, onboardingDiscoveryAgentStartKeys, onboardingConversationImportKeys, onboardingConversationDiscoveryReportLimit, staleStartInstanceWindowMs, connectionStaleThresholdMs, connectionUnrecoverableAfterMs, controlCursorWriteDebounceMs, controlCursorEpochKey, codexTurnTerminalNotificationMethods, claudeSessionStoreSequenceHighWater, claudeCodeLlmProxySessionHeader, onboardingConversationTitleFirstMessages, onboardingConversationTitleLastMessages, onboardingConversationTitleBodyMaxLength, onboardingConversationImportMessageMaxLength, onboardingConversationImportCandidateLimit, onboardingConversationImportProgressInterval;
 var init_runner = __esm({
   "src/runner.ts"() {
     "use strict";
@@ -31462,6 +31806,7 @@ var init_runner = __esm({
     init_userFacingErrors();
     init_remoteCodexSandboxRunner();
     THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
+    THREAD_RUNNER_REAPER_INTERVAL_MS = 3e4;
     onboardingDiscoveryAgentStartKeys = /* @__PURE__ */ new Set();
     onboardingConversationImportKeys = /* @__PURE__ */ new Set();
     onboardingConversationDiscoveryReportLimit = 100;

package/package.json

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