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

package/dist/index.js

@@ -19376,7 +19376,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.93-beta";
+    linzumiCliVersion = "0.0.94-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -19487,6 +19487,82 @@ function assessRunnerLockHolder(record, isPidAlive, now) {
   }
   return { state: "live" };
 }
+function shouldAutoTakeOverForUpdate(existing, myVersion, myLaunchSource, holderState) {
+  if (myLaunchSource !== electronAutoConnectLaunchSource) {
+    return false;
+  }
+  if (existing.launchSource !== electronAutoConnectLaunchSource) {
+    return false;
+  }
+  if (holderState.state !== "live") {
+    return true;
+  }
+  return compareCliVersions(myVersion, existing.cliVersion) > 0;
+}
+function compareCliVersions(a, b) {
+  const pa = parseCliVersion(a);
+  const pb = parseCliVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa.core[i] !== pb.core[i]) {
+      return pa.core[i] > pb.core[i] ? 1 : -1;
+    }
+  }
+  if (pa.prerelease.length === 0 && pb.prerelease.length === 0) {
+    return 0;
+  }
+  if (pa.prerelease.length === 0) {
+    return 1;
+  }
+  if (pb.prerelease.length === 0) {
+    return -1;
+  }
+  return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+function parseCliVersion(value) {
+  const trimmed = value.trim().replace(/^v/i, "").split("+", 1)[0] ?? "";
+  const hyphen = trimmed.indexOf("-");
+  const coreText = hyphen === -1 ? trimmed : trimmed.slice(0, hyphen);
+  const prereleaseText = hyphen === -1 ? "" : trimmed.slice(hyphen + 1);
+  const parts = coreText.split(".");
+  const core = [
+    parseCoreNumber(parts[0]),
+    parseCoreNumber(parts[1]),
+    parseCoreNumber(parts[2])
+  ];
+  const prerelease = prereleaseText === "" ? [] : prereleaseText.split(".").filter((id) => id !== "");
+  return { core, prerelease };
+}
+function parseCoreNumber(value) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+function comparePrerelease(a, b) {
+  const length = Math.max(a.length, b.length);
+  for (let i = 0; i < length; i++) {
+    if (i >= a.length) {
+      return -1;
+    }
+    if (i >= b.length) {
+      return 1;
+    }
+    const idA = a[i];
+    const idB = b[i];
+    const numA = Number.parseInt(idA, 10);
+    const numB = Number.parseInt(idB, 10);
+    const aIsNum = numA.toString() === idA;
+    const bIsNum = numB.toString() === idB;
+    if (aIsNum && bIsNum) {
+      if (numA !== numB) {
+        return numA > numB ? 1 : -1;
+      }
+    } else if (aIsNum !== bIsNum) {
+      return aIsNum ? -1 : 1;
+    } else if (idA !== idB) {
+      return idA > idB ? 1 : -1;
+    }
+  }
+  return 0;
+}
 function takeOverWedgedHolder(lockPath, holder, reason, killPid, onTakeover) {
   try {
     killPid(holder.pid);
@@ -19754,7 +19830,7 @@ function displayLinzumiUrl(linzumiUrl) {
 function isNodeErrorCode2(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-var runnerLockHeartbeatIntervalMs, runnerLockTakeoverAfterMs, runnerLockHeldErrorName, RunnerLockHeldError;
+var runnerLockHeartbeatIntervalMs, runnerLockTakeoverAfterMs, runnerLockHeldErrorName, RunnerLockHeldError, electronAutoConnectLaunchSource;
 var init_runnerLock = __esm({
   "src/runnerLock.ts"() {
     "use strict";
@@ -19775,6 +19851,7 @@ var init_runnerLock = __esm({
         this.heldBy = heldBy;
       }
     };
+    electronAutoConnectLaunchSource = "electron_auto_connect";
   }
 });
 
@@ -25632,6 +25709,43 @@ async function acquireRunnerLockWithConflictResolution(acquire, options, log2) {
       lockPath: error.lockPath
     });
     const lockTakeover = options.lockTakeover;
+    const autoTakeoverDeps = resolveRunnerLockTakeoverDeps(
+      error.lockPath,
+      lockTakeover?.takeover,
+      log2
+    );
+    const holderState = assessRunnerLockHolder(
+      error.heldBy,
+      autoTakeoverDeps.isPidAlive,
+      () => new Date(autoTakeoverDeps.now())
+    );
+    if (shouldAutoTakeOverForUpdate(
+      error.heldBy,
+      linzumiCliVersion,
+      options.launchSource,
+      holderState
+    )) {
+      log2("runner.lock_auto_takeover_for_update", {
+        runnerId: options.runnerId,
+        heldByRunnerId: error.heldBy.runnerId,
+        heldByPid: error.heldBy.pid,
+        lockPath: error.lockPath,
+        fromVersion: error.heldBy.cliVersion,
+        toVersion: linzumiCliVersion,
+        launchSource: electronAutoConnectLaunchSource,
+        holderState: holderState.state
+      });
+      const autoPromptDeps = lockTakeover?.prompt ?? defaultRunnerLockTakeoverPromptDeps(lockTakeover);
+      await resolveRunnerLockConflict({
+        holder: error.heldBy,
+        lockPath: error.lockPath,
+        baseMessage: error.message,
+        takeOverWithoutPrompt: true,
+        prompt: autoPromptDeps,
+        takeover: autoTakeoverDeps
+      });
+      return acquire();
+    }
     if (!shouldResolveRunnerLockConflict(lockTakeover)) {
       throw error;
     }
@@ -25848,6 +25962,32 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     );
   }
 }
+async function applyCodexUnavailableControl(kandan, topic, instanceId, control, log2) {
+  const error = "agent_provider_unavailable:codex";
+  log2("kandan.start_instance_codex_app_server_unavailable", {
+    controlType: control.type,
+    thread_id: controlThreadId(control) ?? null,
+    instanceId
+  });
+  if (control.type === "start_instance" || control.type === "reconnect_thread") {
+    try {
+      await publishStartInstanceMessageState(
+        kandan,
+        topic,
+        control,
+        "failed",
+        error,
+        { instanceId }
+      );
+    } catch (publishError) {
+      log2("kandan.start_instance_unavailable_state_push_failed", {
+        agent_provider: "codex",
+        message: publishError instanceof Error ? publishError.message : String(publishError)
+      });
+    }
+  }
+  throw new Error(error);
+}
 async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, remoteCodexSandboxRunner, activeRemoteCodexExecRequests, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log2, onStartedThread, onThreadProcessStart) {
   if (codex === void 0) {
     switch (control.type) {
@@ -25861,6 +26001,43 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           activeRemoteCodexExecRequests,
           log2
         );
+      // PROD WEDGE (coding jobs down on the shipped CLI beta): a runner whose
+      // cached dependencyStatus.codex.available was `false` at connect (the
+      // `codex --version` probe timed out during the blocking onboarding scan
+      // and was never re-probed) never started its SHARED codex app-server, so
+      // this `codex` is undefined. But a start_instance / reconnect_thread runs
+      // in its OWN thread worker that spawns its OWN codex app-server - it does
+      // NOT need the shared client. The old `default` arm returned
+      // `agent_provider_unavailable:codex` HERE, before delegating, and only as
+      // a bare codex_response: no thread-worker spawn, no
+      // `runner.thread_process_starting` log, no message_state - a SILENT no-op
+      // that left the user's job stuck in `coding` (prod thread 99d5808e,
+      // control_seq 13). When a thread worker IS available (onThreadProcessStart
+      // wired), fall through to the normal switch so the control delegates to
+      // the worker; the worker's own start surfaces any genuine engine failure.
+      // When NO thread worker exists, codex genuinely cannot run the job, so
+      // fail LOUD (log + failed message_state + throw -> codex_error) instead of
+      // leaving it silently stuck. This loud path is SCOPED to start_instance /
+      // reconnect_thread only.
+      case "start_instance":
+      case "reconnect_thread":
+        if (onThreadProcessStart !== void 0) {
+          break;
+        }
+        return await applyCodexUnavailableControl(
+          kandan,
+          topic,
+          instanceId,
+          control,
+          log2
+        );
+      // Every OTHER control type that reaches here is a request/response control
+      // that does NOT need the shared codex app-server to fail gracefully
+      // (browse_directory, create_project, suggest_tasks,
+      // list_claude_code_sessions, interrupt, cancel_turn, ...). Preserve the
+      // original behavior: return a bare `agent_provider_unavailable:codex`
+      // codex_response - NO throw, NO failed message_state, NO start_instance
+      // log - so onboarding/UI features keep working while codex is unavailable.
       default:
         return {
           instanceId,
@@ -68863,7 +69040,7 @@ async function parseStartRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -68968,7 +69145,7 @@ async function parseAgentRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -69143,7 +69320,7 @@ async function parseRunnerArgs(args, deps = {
     cwd,
     codexBin,
     codexUrl: stringValue8(values, "codex-url"),
-    launchSource: electronAutoConnectLaunchSource(),
+    launchSource: electronAutoConnectLaunchSource2(),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
     logFile: stringValue8(values, "log-file"),
@@ -69178,11 +69355,11 @@ function runnerRuntimeDefaultsFromValues(values) {
     allowPortForwardingByDefault: true
   };
 }
-function electronAutoConnectLaunchSource() {
+function electronAutoConnectLaunchSource2() {
   return process.env.LINZUMI_ELECTRON_AUTO_CONNECT_RUNNER === "1" ? "electron_auto_connect" : void 0;
 }
 function connectLaunchSourceTelemetryValue() {
-  return electronAutoConnectLaunchSource() ?? "cli";
+  return electronAutoConnectLaunchSource2() ?? "cli";
 }
 function workspaceTelemetryAttribute(workspace) {
   return workspace === void 0 ? {} : { workspace };

package/package.json

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