@linzumi/cli 0.0.103-beta → 0.0.105-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.103-beta --version
+npx -y @linzumi/cli@0.0.105-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.103-beta";
+    linzumiCliVersion = "0.0.105-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);
@@ -25445,6 +25519,187 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       throw error;
     }
   };
+  const spawnOnMissInFlight = /* @__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) => {
+    if (!shouldUseThreadProcesses(options)) {
+      return "ignored";
+    }
+    const kandanThreadId = event.threadId;
+    if (kandanThreadId === void 0) {
+      return "ignored";
+    }
+    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,
+      ...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";
+      }
+      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,
@@ -25827,6 +26082,32 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       });
     }
     if (control.type === "start_instance") {
+      if (shouldSkipReplayedStartInstanceForKnownSession(
+        control,
+        (kandanThreadId) => threadSessionRegistry.list().some((record) => record.kandanThreadId === kandanThreadId)
+      )) {
+        skippedStaleStartInstances += 1;
+        log2("kandan.start_instance_skipped_known_session", {
+          threadId: controlThreadId(control) ?? null,
+          controlSeq: control.control_seq ?? null,
+          issuedAt: controlIssuedAt(control) ?? null,
+          reason: "thread_already_has_known_session",
+          skippedStaleStartInstances
+        });
+        return kandan.push(topic, "codex_response", {
+          instanceId,
+          controlType: control.type,
+          threadId: controlThreadId(control) ?? null,
+          ok: false,
+          skipped: true,
+          error: "start_instance_thread_already_has_session",
+          issuedAt: controlIssuedAt(control) ?? null
+        }).catch((error) => {
+          log2("kandan.control_response_push_failed", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
       const staleAgeMs = staleStartInstanceAgeMs(control, Date.now());
       if (staleAgeMs !== void 0) {
         skippedStaleStartInstances += 1;
@@ -26003,6 +26284,19 @@ function staleStartInstanceAgeMs(control, nowMs) {
   const ageMs = nowMs - issuedAtMs;
   return ageMs > staleStartInstanceWindowMs ? ageMs : void 0;
 }
+function shouldSkipReplayedStartInstanceForKnownSession(control, hasKnownThreadSession) {
+  if (control.type !== "start_instance") {
+    return false;
+  }
+  if (!controlReplayed(control)) {
+    return false;
+  }
+  const kandanThreadId = controlThreadId(control);
+  if (kandanThreadId === void 0) {
+    return false;
+  }
+  return hasKnownThreadSession(kandanThreadId);
+}
 function shouldSkipReplayedStartTurn(appliedControlSeq, controlSeq) {
   return appliedControlSeq !== void 0 && controlSeq <= appliedControlSeq;
 }
@@ -29657,6 +29951,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":
@@ -31372,7 +31689,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";
@@ -31423,6 +31740,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.103-beta",
+  "version": "0.0.105-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": {