@linzumi/cli 0.0.94-beta → 0.0.96-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.94-beta --version
+npx -y @linzumi/cli@0.0.96-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -112,6 +112,14 @@ import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+function projectScanBudgetMs() {
+  const raw = process.env.LINZUMI_ONBOARDING_PROJECT_SCAN_BUDGET_MS?.trim();
+  if (raw === void 0 || raw === "") {
+    return defaultProjectScanBudgetMs;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultProjectScanBudgetMs;
+}
 function discoverCurrentGitProject(args) {
   const startedAtMs = args.nowMs ?? Date.now();
   const responsiveness = args.placeResponsiveness;
@@ -136,7 +144,19 @@ function discoverCurrentGitProject(args) {
   });
   const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots(args.cwd);
   let placesSearched = 1;
+  const scanBudgetMs = projectScanBudgetMs();
   for (const sourceRoot of sourceRoots) {
+    if (Date.now() - startedAtMs >= scanBudgetMs) {
+      searchStats.push({
+        place: sourceRoot,
+        source: "git",
+        duration_ms: 0,
+        result_count: 0,
+        skipped_scan_budget_exceeded: true
+      });
+      placesSearched += 1;
+      continue;
+    }
     const sourceRootStartedAtMs = Date.now();
     const rootResponsive = isPlaceResponsive(sourceRoot, responsiveness);
     if (!rootResponsive) {
@@ -296,6 +316,9 @@ function isGitWorktreeRoot(path2) {
   return existsSync(join(path2, ".git"));
 }
 function defaultLocalProjectSourceRoots(cwd) {
+  if (cwd === dirname(cwd)) {
+    return [];
+  }
   return uniqueStrings([
     ...ancestorSourceRoots(cwd),
     ...homeSourceRoots(),
@@ -409,13 +432,14 @@ function compactJsonObject(value) {
     })
   );
 }
-var worktreePathSampleLimit, gitSpawnTimeoutMs;
+var worktreePathSampleLimit, gitSpawnTimeoutMs, defaultProjectScanBudgetMs;
 var init_onboardingProjectDiscovery = __esm({
   "src/onboardingProjectDiscovery.ts"() {
     "use strict";
     init_onboardingPlaceResponsiveness();
     worktreePathSampleLimit = 25;
     gitSpawnTimeoutMs = 4e3;
+    defaultProjectScanBudgetMs = 2e4;
   }
 });
 
@@ -8437,6 +8461,38 @@ var init_userFacingErrors = __esm({
 
 // src/channelSession.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
+function codexStartRequestTimeoutMs() {
+  const raw = process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS?.trim();
+  if (raw === void 0 || raw === "") {
+    return CODEX_START_REQUEST_TIMEOUT_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : CODEX_START_REQUEST_TIMEOUT_MS;
+}
+function isCodexStartRequestTimeoutError(error) {
+  return error instanceof CodexStartRequestTimeoutError;
+}
+function withCodexStartRequestTimeout(method, request, timeoutMs = codexStartRequestTimeoutMs()) {
+  if (!(timeoutMs > 0)) {
+    return request;
+  }
+  return new Promise((resolve12, reject) => {
+    const timer = setTimeout(() => {
+      reject(new CodexStartRequestTimeoutError(method, timeoutMs));
+    }, timeoutMs);
+    timer.unref?.();
+    request.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve12(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
 async function attachChannelSession(args) {
   const session = args.options.channelSession;
   const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
@@ -8941,6 +8997,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     failedSeqs: /* @__PURE__ */ new Map(),
     drainInFlight: false,
     drainRequested: false,
+    boundStartTimeout: false,
     fusedQueuedSeqs: /* @__PURE__ */ new Map(),
     reconnectRetryTimer: void 0,
     reconnectRetryAttempts: 0,
@@ -10295,6 +10352,9 @@ async function startThreadMessageTurn(args, state, payloadContext, message) {
   if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     throw new Error("cannot start a local Codex turn before thread binding");
   }
+  if (message.boundStartTimeout === true) {
+    state.boundStartTimeout = true;
+  }
   const queued = {
     seq: message.seq,
     actorSlug: message.actorSlug,
@@ -10558,7 +10618,9 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
     if (state.kandanThreadId !== void 0) {
       startCodexTypingHeartbeat(args, state, state.kandanThreadId);
     }
-    const started = await args.codex.request("turn/start", {
+    const boundStartTimeout = state.boundStartTimeout;
+    state.boundStartTimeout = false;
+    const turnStartRequest = args.codex.request("turn/start", {
       threadId: codexThreadId,
       input: await codexInputItemsForQueuedKandanMessage(
         args,
@@ -10569,6 +10631,7 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
         runtimeOptionsForSettings(args.options, state.runtimeSettings)
       )
     });
+    const started = boundStartTimeout ? await withCodexStartRequestTimeout("turn/start", turnStartRequest) : await turnStartRequest;
     const turnId = extractTurnIdFromResponse(started);
     state.pendingReconnectContextInjection = void 0;
     const interruptAfterStart = state.turn.status === "starting" && state.turn.interruptAfterStart;
@@ -10641,6 +10704,9 @@ async function drainKandanMessageQueueOnce(args, state, payloadContext) {
       queued_seq: next.seq,
       message: error instanceof Error ? error.message : String(error)
     });
+    if (isCodexStartRequestTimeoutError(error)) {
+      throw error;
+    }
   }
 }
 function drainKandanMessageQueueBlocked(args, state) {
@@ -11654,7 +11720,7 @@ async function pushOptional(kandan, topic, event, payload, log2) {
     });
   }
 }
-var codexTypingHeartbeatMs, maxTrackedFailedChatEventSeqs, maxChatEventFailureAttempts, maxForwardedTurnIds, maxClaimedKandanMessageKeys, claimedKandanMessageKeys, nextChatJoinRegistrationSerial, defaultReconnectHandlingRetryDelaysMs, defaultTuiInputMirrorRetryDelaysMs, pipelineCloseTimeoutMs;
+var codexTypingHeartbeatMs, CODEX_START_REQUEST_TIMEOUT_MS, CodexStartRequestTimeoutError, maxTrackedFailedChatEventSeqs, maxChatEventFailureAttempts, maxForwardedTurnIds, maxClaimedKandanMessageKeys, claimedKandanMessageKeys, nextChatJoinRegistrationSerial, defaultReconnectHandlingRetryDelaysMs, defaultTuiInputMirrorRetryDelaysMs, pipelineCloseTimeoutMs;
 var init_channelSession = __esm({
   "src/channelSession.ts"() {
     "use strict";
@@ -11679,6 +11745,15 @@ var init_channelSession = __esm({
     init_processNameCatalog();
     init_userFacingErrors();
     codexTypingHeartbeatMs = 5e3;
+    CODEX_START_REQUEST_TIMEOUT_MS = 12e4;
+    CodexStartRequestTimeoutError = class extends Error {
+      constructor(method, timeoutMs) {
+        super(
+          `Codex ${method} did not reply within ${timeoutMs}ms (start request timed out)`
+        );
+        this.name = "CodexStartRequestTimeoutError";
+      }
+    };
     maxTrackedFailedChatEventSeqs = 256;
     maxChatEventFailureAttempts = 5;
     maxForwardedTurnIds = 64;
@@ -19376,7 +19451,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.94-beta";
+    linzumiCliVersion = "0.0.96-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -22265,6 +22340,11 @@ function connectThreadCodexWorkerIpc(child) {
     onRequest: (callback) => {
       requestCallbacks.add(callback);
     },
+    // The worker child exited/disconnected (onClosed) or close() was called.
+    // A reconnect uses this to detect a DEAD cached client and respawn a fresh
+    // worker instead of send()-ing on a closed channel (which throws "thread
+    // Codex worker IPC client is closed" and strands the resume).
+    isClosed: () => state.closed || child.connected === false,
     close: () => {
       state.closed = true;
       child.off("message", onMessage);
@@ -23035,6 +23115,34 @@ async function runThreadCodexWorker(options) {
 async function openLocalCodexRunner(options, log2, cleanup, close) {
   const agentProviders = availableRunnerAgentProviders(options);
   const localCodexAppServerAvailable = hasLocalCodexAppServerCapability(options);
+  const dependencyStatusRef = {
+    value: options.dependencyStatus
+  };
+  const refreshDependencyStatus = async () => {
+    if (dependencyStatusRef.value === void 0) {
+      return;
+    }
+    try {
+      const refreshed = await buildRunnerDependencyStatus({
+        cwd: options.cwd,
+        codexBin: options.codexBin,
+        codeServerBin: options.codeServerBin,
+        editorRuntime: dependencyStatusRef.value?.editorRuntime
+      });
+      const previousCodexAvailable = dependencyStatusRef.value?.codex.available;
+      dependencyStatusRef.value = refreshed;
+      log2("runner.dependency_status_reprobed", {
+        runnerId: options.runnerId,
+        codex_available: refreshed.codex.available,
+        codex_available_changed: previousCodexAvailable !== refreshed.codex.available
+      });
+    } catch (error) {
+      log2("runner.dependency_status_reprobe_failed", {
+        runnerId: options.runnerId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
   const liveForwardPorts = new Set(allowedForwardPorts);
   const managedForwardPorts = /* @__PURE__ */ new Set();
@@ -23207,8 +23315,8 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     ),
     forwardedPortAttributions: buildForwardPortAttributionPayload(),
     pendingEditorForwardPortRequests: pendingEditorForwardPortRequests(),
-    toolStatus: options.dependencyStatus === void 0 ? null : dependencyStatusPayload(options.dependencyStatus),
-    editorRuntime: options.dependencyStatus?.editorRuntime === void 0 ? null : dependencyStatusPayload(options.dependencyStatus).editorRuntime,
+    toolStatus: dependencyStatusRef.value === void 0 ? null : dependencyStatusPayload(dependencyStatusRef.value),
+    editorRuntime: dependencyStatusRef.value?.editorRuntime === void 0 ? null : dependencyStatusPayload(dependencyStatusRef.value).editorRuntime,
     ...localEditorCapabilities(
       options.editorRuntime,
       allowedCwds.value,
@@ -24221,6 +24329,35 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     threadRunnerProcesses.clear();
   });
+  const evictStaleDynamicChannelSession = async (codexThreadId, expectClient) => {
+    const session = dynamicChannelSessions.get(codexThreadId);
+    const boundClient = dynamicChannelSessionCodexClients.get(codexThreadId);
+    if (session === void 0) {
+      return false;
+    }
+    if (expectClient !== void 0 && boundClient !== expectClient) {
+      return false;
+    }
+    if (boundClient?.isClosed?.() !== true) {
+      return false;
+    }
+    dynamicChannelSessions.delete(codexThreadId);
+    dynamicChannelSessionCodexClients.delete(codexThreadId);
+    dynamicChannelSessionAttachInFlight.delete(codexThreadId);
+    log2("runner.thread_session_evicted_dead_worker", {
+      codex_thread_id: codexThreadId,
+      kandan_thread_id: session.currentKandanThreadId() ?? null
+    });
+    try {
+      await session.close();
+    } catch (error) {
+      log2("runner.thread_session_evict_close_failed", {
+        codex_thread_id: codexThreadId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return true;
+  };
   const attachThreadSessionWithCodex = async (args) => {
     const { control, cwd, codexThreadId, sessionCodex } = args;
     const portForwardWatcherRootPid = args.portForwardWatcherRootPid;
@@ -24232,7 +24369,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
     const existingSession = dynamicChannelSessions.get(codexThreadId);
     if (existingSession !== void 0) {
-      return existingSession;
+      const evicted = await evictStaleDynamicChannelSession(codexThreadId);
+      if (!evicted) {
+        return existingSession;
+      }
     }
     const alreadyAttaching = dynamicChannelSessionAttachInFlight.get(codexThreadId);
     if (alreadyAttaching !== void 0) {
@@ -24538,6 +24678,18 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
           threadRunnerProcesses.delete(kandanThreadId);
         }
       });
+      handle.onExit?.(() => {
+        if (cleanup.closePromise !== void 0) {
+          return;
+        }
+        for (const [codexThreadId, client] of Array.from(
+          dynamicChannelSessionCodexClients.entries()
+        )) {
+          if (client === threadCodex) {
+            void evictStaleDynamicChannelSession(codexThreadId, threadCodex);
+          }
+        }
+      });
       log2("runner.thread_process_started", {
         kandanThreadId,
         cwd
@@ -25071,14 +25223,15 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     log2,
     pendingControls,
     controlDispatcher,
-    dispatchControl
+    dispatchControl,
+    refreshDependencyStatus
   );
   return { instanceId, codexUrl, close };
 }
-function finishRunnerStartup(options, log2, pendingControls, controlDispatcher, dispatchControl) {
+function finishRunnerStartup(options, log2, pendingControls, controlDispatcher, dispatchControl, onOnboardingDiscoveryComplete) {
   controlDispatcher.value = dispatchControl;
   pendingControls.splice(0).forEach(({ control, ack }) => dispatchControl(control, ack));
-  startOnboardingDiscoveryAgents(options, log2);
+  startOnboardingDiscoveryAgents(options, log2, onOnboardingDiscoveryComplete);
 }
 function commanderOutboxPersistDir() {
   const override = process.env.LINZUMI_COMMANDER_OUTBOX_DIR?.trim();
@@ -27175,22 +27328,25 @@ async function startCodexProviderInstance(args) {
     args.options,
     args.control
   );
-  const response = await args.codex.request("thread/start", {
-    cwd: args.cwd,
-    serviceName: "kandan-local-runner",
-    personality: "pragmatic",
-    developerInstructions: commanderDeveloperInstructions({
+  const response = await withCodexStartRequestTimeout(
+    "thread/start",
+    args.codex.request("thread/start", {
       cwd: args.cwd,
-      planTool: "linzumi-mcp",
-      developerPrompt,
-      linzumiContext
-    }),
-    ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
-    ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
-    ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
-    ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
-    ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
-  });
+      serviceName: "kandan-local-runner",
+      personality: "pragmatic",
+      developerInstructions: commanderDeveloperInstructions({
+        cwd: args.cwd,
+        planTool: "linzumi-mcp",
+        developerPrompt,
+        linzumiContext
+      }),
+      ...runtimeSettings.model === void 0 ? {} : { model: runtimeSettings.model },
+      ...runtimeSettings.reasoningEffort === void 0 ? {} : { reasoningEffort: runtimeSettings.reasoningEffort },
+      ...runtimeSettings.approvalPolicy === void 0 ? {} : { approvalPolicy: runtimeSettings.approvalPolicy },
+      ...runtimeSettings.sandbox === void 0 ? {} : { sandbox: runtimeSettings.sandbox },
+      ...runtimeSettings.fast === true ? { serviceTier: "fast" } : {}
+    })
+  );
   const codexThreadId = extractStartedThreadId(response);
   args.setStartedCodexThreadId(codexThreadId);
   const workDescription = normalizedWorkDescription(
@@ -27224,13 +27380,17 @@ async function startCodexProviderInstance(args) {
         seq: sourceSeq,
         body: workDescription,
         actorSlug: identity.actorUsername,
-        actorUserId: identity.actorUserId
+        actorUserId: identity.actorUserId,
+        boundStartTimeout: true
       });
     } else {
-      await args.codex.request("turn/start", {
-        threadId: codexThreadId,
-        input: [{ type: "text", text: workDescription }]
-      });
+      await withCodexStartRequestTimeout(
+        "turn/start",
+        args.codex.request("turn/start", {
+          threadId: codexThreadId,
+          input: [{ type: "text", text: workDescription }]
+        })
+      );
     }
   }
   return {
@@ -29130,9 +29290,10 @@ function redactedThreadRunnerCliArgs(args) {
 function optionalCliValue(flag, value) {
   return value === void 0 || value === "" ? [] : [flag, value];
 }
-function startOnboardingDiscoveryAgents(options, log2) {
+function startOnboardingDiscoveryAgents(options, log2, onOnboardingDiscoveryComplete) {
   const workspaceSlug = runnerWorkspaceSlug(options);
   if (!shouldStartOnboardingDiscoveryAgents(options, workspaceSlug)) {
+    void onOnboardingDiscoveryComplete?.();
     return;
   }
   const startKey = onboardingDiscoveryAgentStartKey(options, workspaceSlug);
@@ -29190,6 +29351,7 @@ function startOnboardingDiscoveryAgents(options, log2) {
       workers_completed: 2,
       successful_write_count: successfulWriteCount
     });
+    await onOnboardingDiscoveryComplete?.();
   });
 }
 function withSuccessfulWriteCount(report, successfulPostStartWriteCount) {

package/package.json

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