@linzumi/cli 0.0.58-beta → 0.0.60-beta

package/README.md

@@ -62,7 +62,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.58-beta --version
+npx -y @linzumi/cli@0.0.60-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -20847,7 +20847,7 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
       request.port,
       approvedTargetFromRequest(request)
     );
-    await publishForwardPortResolvedEvent(args, request, {
+    await publishForwardPortResolvedEvent(args, state, request, {
       decision: "deny"
     });
     await publishMessageStateForPortForwardResult(
@@ -20874,7 +20874,7 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
 async function expirePendingPortForwardRequest(args, state, request, reason) {
   const failedReason = reason === "listener_exited" ? "port_forward_listener_exited" : "port_forward_listener_changed";
   state.pendingPortForwardRequests.delete(request.requestId);
-  await publishForwardPortResolvedEvent(args, request, {
+  await publishForwardPortResolvedEvent(args, state, request, {
     decision: "expired",
     reason
   });
@@ -20906,7 +20906,7 @@ async function approvePortForwardRequest(args, state, request, options) {
     processName: processIdentity?.appName ?? null,
     processIconKey: processIdentity?.iconKey ?? null
   });
-  await publishForwardPortResolvedEvent(args, request, {
+  await publishForwardPortResolvedEvent(args, state, request, {
     decision: "approve",
     capabilities
   });
@@ -21224,7 +21224,7 @@ async function publishForwardPortRequestedEvent(args, state, request, processIde
     args.log
   );
 }
-async function publishForwardPortResolvedEvent(args, request, result) {
+async function publishForwardPortResolvedEvent(args, state, request, result) {
   await pushOptional(
     args.kandan,
     args.topic,
@@ -21235,6 +21235,9 @@ async function publishForwardPortResolvedEvent(args, request, result) {
       port: request.port,
       pid: request.pid,
       command: request.command,
+      codexThreadId: state.codexThreadId ?? null,
+      kandanThreadId: state.kandanThreadId ?? null,
+      channelSlug: args.options.channelSession.channelSlug ?? null,
       ...request.cwd === void 0 ? {} : { cwd: request.cwd },
       sourceSeq: request.sourceSeq,
       decision: result.decision,
@@ -24718,6 +24721,7 @@ function linzumiMcpServerConfig(options) {
     name: "linzumi",
     command: options.command ?? "linzumi",
     args: [
+      ...options.argsPrefix ?? [],
       "mcp",
       "server",
       "--api-url",
@@ -24738,6 +24742,23 @@ function codexMcpConfigArgs(config2) {
     `mcp_servers.${config2.name}.args=${tomlStringArray(config2.args)}`
   ];
 }
+function linzumiMcpCommandForProcess(processExecPath, scriptPath) {
+  const trimmedScriptPath = scriptPath?.trim() ?? "";
+  switch (trimmedScriptPath === "") {
+    case true:
+      return { command: "linzumi", argsPrefix: [] };
+    case false:
+      switch (trimmedScriptPath.endsWith(".ts") || trimmedScriptPath.endsWith(".js")) {
+        case true:
+          return {
+            command: processExecPath,
+            argsPrefix: [trimmedScriptPath]
+          };
+        case false:
+          return { command: trimmedScriptPath, argsPrefix: [] };
+      }
+  }
+}
 function claudeCodeMcpConfigJson(config2) {
   return `${JSON.stringify(
     {
@@ -28273,7 +28294,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.58-beta";
+var linzumiCliVersion = "0.0.60-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28759,6 +28780,7 @@ function normalizeLocalRunnerCache(value) {
 }
 
 // src/runner.ts
+var THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
 async function runLocalCodexRunner(options) {
   const log = makeRunnerLogger(options);
   const cleanup = {
@@ -28796,6 +28818,29 @@ async function runLocalCodexRunner(options) {
     throw error51;
   }
 }
+async function runThreadCodexWorker(options) {
+  if (options.threadProcess?.role !== "thread") {
+    throw new Error("thread Codex worker requires thread process options");
+  }
+  if (process.send === void 0) {
+    throw new Error("thread Codex worker requires an IPC channel");
+  }
+  const log = makeRunnerLogger(options);
+  const started = await startOwnedCodexAppServer(options, {
+    linzumiMcp: false
+  });
+  const stop = once(() => {
+    started.stop();
+    log.close();
+  });
+  process.send({
+    type: "linzumi_thread_codex_worker_ready",
+    kandanThreadId: options.threadProcess.kandanThreadId,
+    codexUrl: started.url
+  });
+  await waitForThreadCodexWorkerStop(started.process);
+  stop();
+}
 async function openLocalCodexRunner(options, log, cleanup, close) {
   const agentProviders = availableRunnerAgentProviders(options);
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
@@ -28908,7 +28953,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   );
   cleanup.actions.push(() => kandan.close());
   const topic = `local_runner:${options.runnerId}`;
-  const clientId = options.machineId ?? options.runnerId;
+  const clientId = options.clientId ?? options.machineId ?? options.runnerId;
   const runnerHost = hostname2();
   const joinPayload = () => ({
     clientName: "kandan-local-codex-runner",
@@ -29690,6 +29735,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       launchTui: options.launchTui,
       enablePortForwardWatch: true,
       initialForwardPorts: allowedForwardPorts,
+      portForwardWatcher: channelSessionPortForwardWatcherOptions({
+        rootPid: started?.process.pid,
+        start: options.portForwardWatcher
+      }),
       suppressedForwardPorts,
       onForwardPortApproved: (port, attribution) => {
         liveForwardPorts.add(port);
@@ -29742,7 +29791,16 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       )
     );
   });
-  const attachThreadSession = async (control, cwd, codexThreadId) => {
+  const threadRunnerProcesses = /* @__PURE__ */ new Map();
+  cleanup.actions.push(async () => {
+    await Promise.all(
+      Array.from(threadRunnerProcesses.values(), closeThreadRunnerEntry)
+    );
+    threadRunnerProcesses.clear();
+  });
+  const attachThreadSessionWithCodex = async (args) => {
+    const { control, cwd, codexThreadId, sessionCodex } = args;
+    const portForwardWatcherRootPid = args.portForwardWatcherRootPid;
     const workspaceSlug = optionalThreadControlField(control, "workspace");
     const channelSlug = optionalThreadControlField(control, "channel");
     const kandanThreadId = optionalThreadControlField(control, "threadId");
@@ -29762,7 +29820,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     const runtimeSettings = startInstanceRuntimeSettings(options, control);
     const session = await attachChannelSession({
       kandan,
-      codex,
+      codex: sessionCodex,
       topic,
       instanceId,
       options: {
@@ -29776,6 +29834,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         launchTui: false,
         enablePortForwardWatch: true,
         initialForwardPorts: allowedForwardPorts,
+        portForwardWatcher: channelSessionPortForwardWatcherOptions({
+          rootPid: portForwardWatcherRootPid,
+          start: options.portForwardWatcher
+        }),
         suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
           liveForwardPorts.add(port);
@@ -29810,6 +29872,151 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     dynamicChannelSessions.set(kandanThreadId, session);
     return session;
   };
+  const attachThreadSession = async (control, cwd, codexThreadId) => {
+    return await attachThreadSessionWithCodex({
+      control,
+      cwd,
+      codexThreadId,
+      sessionCodex: codex,
+      portForwardWatcherRootPid: started?.process.pid
+    });
+  };
+  const startThreadRunnerProcess = async (control, cwd) => {
+    if (options.threadProcess?.role === "thread") {
+      return void 0;
+    }
+    const agentProviderResult = startInstanceAgentProvider(control);
+    if (agentProviderResult.type !== "ok" || agentProviderResult.provider !== "codex") {
+      return void 0;
+    }
+    const workspaceSlug = optionalThreadControlField(control, "workspace");
+    const channelSlug = optionalThreadControlField(control, "channel");
+    const kandanThreadId = optionalThreadControlField(control, "threadId");
+    if (workspaceSlug === void 0 || channelSlug === void 0 || kandanThreadId === void 0) {
+      return void 0;
+    }
+    const existing = threadRunnerProcesses.get(kandanThreadId);
+    if (existing !== void 0) {
+      return {
+        instanceId,
+        controlType: control.type,
+        ok: true,
+        delegated: true,
+        threadProcess: "already_started",
+        kandanThreadId,
+        cwd
+      };
+    }
+    const spawnThreadRunner = options.spawnThreadRunner ?? spawnLocalThreadRunnerProcess;
+    const readyTimeoutMs = threadRunnerReadyTimeoutMs(options);
+    const startingEntry = {
+      kind: "starting",
+      promise: withThreadRunnerReadyTimeout(
+        spawnThreadRunner(
+          threadRunnerOptions({
+            options,
+            control,
+            cwd,
+            workspaceSlug,
+            channelSlug,
+            kandanThreadId
+          })
+        ),
+        {
+          kandanThreadId,
+          timeoutMs: readyTimeoutMs
+        }
+      )
+    };
+    threadRunnerProcesses.set(kandanThreadId, startingEntry);
+    let handle;
+    try {
+      handle = await startingEntry.promise;
+    } catch (error51) {
+      if (threadRunnerProcesses.get(kandanThreadId) === startingEntry) {
+        threadRunnerProcesses.delete(kandanThreadId);
+      }
+      throw error51;
+    }
+    try {
+      const threadCodex = await connectCodexAppServer(handle.codexUrl);
+      const closeThreadCodex = once(() => threadCodex.close());
+      handle.onExit?.(closeThreadCodex);
+      const runtimeHandle = {
+        ...handle,
+        close: async () => {
+          closeThreadCodex();
+          await handle.close();
+        }
+      };
+      const runningEntry = {
+        kind: "running",
+        handle: runtimeHandle
+      };
+      if (threadRunnerProcesses.get(kandanThreadId) === startingEntry) {
+        threadRunnerProcesses.set(kandanThreadId, runningEntry);
+      }
+      handle.onExit?.(() => {
+        if (threadRunnerProcesses.get(kandanThreadId) === runningEntry) {
+          threadRunnerProcesses.delete(kandanThreadId);
+        }
+      });
+      log("runner.thread_process_started", {
+        kandanThreadId,
+        cwd
+      });
+      const onStartedThread = (startedControl, startedCwd, codexThreadId) => attachThreadSessionWithCodex({
+        control: startedControl,
+        cwd: startedCwd,
+        codexThreadId,
+        sessionCodex: threadCodex,
+        portForwardWatcherRootPid: handle.processPid
+      });
+      switch (control.type) {
+        case "start_instance": {
+          const result = await startCodexProviderInstance({
+            codex: threadCodex,
+            kandan,
+            topic,
+            control,
+            options,
+            instanceId,
+            cwd,
+            matchedRoot: cwd,
+            onStartedThread,
+            setStartupStage: () => void 0,
+            setStartedCodexThreadId: () => void 0
+          });
+          return result.controlResponse;
+        }
+        case "reconnect_thread":
+          return await applyControl(
+            threadCodex,
+            kandan,
+            topic,
+            instanceId,
+            options,
+            agentProviders,
+            allowedCwds.value,
+            activeClaudeCodeSessions,
+            pendingClaudeCodeApprovals,
+            ensureClaudeCodeForwardPortSession,
+            disposeClaudeCodeForwardPortSession,
+            control,
+            log,
+            onStartedThread,
+            void 0
+          );
+      }
+    } catch (error51) {
+      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);
+      throw error51;
+    }
+  };
   const heartbeatPayload = () => ({
     instanceId,
     clientId,
@@ -29890,6 +30097,15 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   });
   const handleControl = (control) => {
     log("kandan.control", { control });
+    if (!threadProcessOwnsControl(options, control)) {
+      log("kandan.control_ignored", {
+        reason: "thread_process_mismatch",
+        controlType: control.type,
+        controlThreadId: controlThreadId(control) ?? null,
+        threadProcessId: options.threadProcess?.kandanThreadId ?? null
+      });
+      return;
+    }
     if (control.type === "replace_runner") {
       log("runner.replaced", {
         runnerId: options.runnerId,
@@ -30099,7 +30315,8 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         disposeClaudeCodeForwardPortSession,
         control,
         log,
-        attachThreadSession
+        attachThreadSession,
+        shouldUseThreadProcesses(options) ? startThreadRunnerProcess : void 0
       );
     }).then((response) => {
       return kandan.push(topic, "codex_response", response);
@@ -30129,6 +30346,60 @@ function controlTargetsInstance(control, instanceId) {
 function controlInstanceId(control) {
   return "instanceId" in control ? control.instanceId : void 0;
 }
+function shouldUseThreadProcesses(options) {
+  if (options.threadProcess?.role === "thread") {
+    return false;
+  }
+  return options.spawnThreadRunner !== void 0 || options.codexUrl === void 0;
+}
+function threadProcessOwnsControl(options, control) {
+  const threadProcess = options.threadProcess;
+  const threadId = controlThreadId(control);
+  if (threadProcess?.role !== "thread") {
+    if (shouldUseThreadProcesses(options) && threadId !== void 0 && threadChildOnlyControl(control)) {
+      return false;
+    }
+    return true;
+  }
+  if (threadId !== void 0) {
+    return threadId === threadProcess.kandanThreadId;
+  }
+  if ("instanceId" in control && control.instanceId !== void 0 && control.instanceId !== "") {
+    return true;
+  }
+  switch (control.type) {
+    case "replace_runner":
+      return true;
+    default:
+      return false;
+  }
+}
+function threadChildOnlyControl(control) {
+  switch (control.type) {
+    case "forward_http_request":
+    case "forward_tcp_open":
+    case "forward_tcp_send":
+    case "forward_tcp_close":
+      return true;
+    default:
+      return false;
+  }
+}
+function controlThreadId(control) {
+  switch (control.type) {
+    case "start_instance":
+    case "reconnect_thread":
+    case "forward_http_request":
+    case "forward_tcp_open":
+    case "forward_tcp_send":
+    case "forward_tcp_close": {
+      const threadId = stringValue(control.threadId)?.trim();
+      return threadId === void 0 || threadId === "" ? void 0 : threadId;
+    }
+    default:
+      return void 0;
+  }
+}
 async function resolveSessionControl(channelSession, dynamicChannelSessions, control) {
   const primaryHandled = await (channelSession?.handleControl(control) ?? Promise.resolve(void 0));
   if (primaryHandled !== void 0) {
@@ -30349,7 +30620,7 @@ async function resumeCodexThreadForReconnect(codex, codexThreadId, resumeOverrid
     );
   }
 }
-async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log, onStartedThread) {
+async function applyControl(codex, kandan, topic, instanceId, options, agentProviders, allowedCwds, activeClaudeCodeSessions, pendingClaudeCodeApprovals, ensureClaudeCodeForwardPortSession, disposeClaudeCodeForwardPortSession, control, log, onStartedThread, onThreadProcessStart) {
   switch (control.type) {
     case "start_instance": {
       const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -30427,6 +30698,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
         });
       }
       try {
+        const delegated = await onThreadProcessStart?.(control, cwd.cwd);
+        if (delegated !== void 0) {
+          return delegated;
+        }
         if (agentProvider === "claude-code") {
           startupStage = "starting_claude_code_session";
           const result2 = await startClaudeCodeProviderInstance({
@@ -30564,6 +30839,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       const workDescription = normalizedWorkDescription(
         control.workDescription
       );
+      const delegated = await onThreadProcessStart?.(control, cwd.cwd);
+      if (delegated !== void 0) {
+        return delegated;
+      }
       if (agentProvider === "claude-code") {
         const activeSession = activeClaudeCodeSessions.get(codexThreadId);
         if (activeSession !== void 0 && workDescription !== void 0) {
@@ -32371,25 +32650,330 @@ function startInstanceRuntimeSettings(options, control) {
     allowPortForwardingByDefault: control.allowPortForwardingByDefault ?? defaults.allowPortForwardingByDefault
   };
 }
-async function startOwnedCodexAppServer(options) {
+function channelSessionPortForwardWatcherOptions(args) {
+  if (args.rootPid === void 0 && args.start === void 0) {
+    return void 0;
+  }
+  return {
+    ...args.rootPid === void 0 ? {} : { rootPid: args.rootPid },
+    ...args.start === void 0 ? {} : { start: args.start }
+  };
+}
+function threadRunnerOptions(args) {
+  const runtimeSettings = startInstanceRuntimeSettings(
+    args.options,
+    args.control
+  );
+  return {
+    ...args.options,
+    clientId: void 0,
+    machineId: void 0,
+    runnerLockConfigPath: void 0,
+    workspaceSlug: args.workspaceSlug,
+    cwd: args.cwd,
+    codexUrl: void 0,
+    launchTui: false,
+    allowedCwds: Array.from(/* @__PURE__ */ new Set([args.cwd, ...args.options.allowedCwds])),
+    codeServerBin: args.options.editorRuntime?.mode === "server_managed" ? void 0 : args.options.codeServerBin,
+    editorRuntime: void 0,
+    threadProcess: {
+      role: "thread",
+      kandanThreadId: args.kandanThreadId
+    },
+    spawnThreadRunner: void 0,
+    threadRunnerReadyTimeoutMs: args.options.threadRunnerReadyTimeoutMs,
+    runtimeDefaults: {
+      model: runtimeSettings.model,
+      reasoningEffort: runtimeSettings.reasoningEffort,
+      sandbox: runtimeSettings.sandbox,
+      approvalPolicy: runtimeSettings.approvalPolicy,
+      allowPortForwardingByDefault: runtimeSettings.allowPortForwardingByDefault
+    },
+    channelSession: void 0
+  };
+}
+async function closeThreadRunnerEntry(entry) {
+  switch (entry.kind) {
+    case "running":
+      await entry.handle.close();
+      return;
+    case "starting":
+      try {
+        const handle = await entry.promise;
+        await handle.close();
+      } catch (_error) {
+        return;
+      }
+      return;
+  }
+}
+async function spawnLocalThreadRunnerProcess(options) {
+  const scriptPath = process.argv[1];
+  const kandanThreadId = options.threadProcess?.kandanThreadId ?? "";
+  if (scriptPath === void 0 || scriptPath.trim() === "") {
+    throw new Error(
+      "cannot fork thread runner without current CLI script path"
+    );
+  }
+  const args = ["run", ...threadRunnerCliArgs(options)];
+  const env = {
+    ...process.env,
+    LINZUMI_THREAD_RUNNER_ROLE: "thread",
+    LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID: kandanThreadId
+  };
+  writeCliAuditEvent("process.spawn", {
+    command: process.execPath,
+    args: [scriptPath, ...redactedThreadRunnerCliArgs(args)],
+    cwd: options.cwd,
+    purpose: "linzumi.thread_runner"
+  });
+  const child = spawn6(process.execPath, [scriptPath, ...args], {
+    cwd: options.cwd,
+    env,
+    stdio: ["inherit", "inherit", "inherit", "ipc"]
+  });
+  writeCliAuditEvent("process.spawned", {
+    command: process.execPath,
+    args: [scriptPath, ...redactedThreadRunnerCliArgs(args)],
+    cwd: options.cwd,
+    pid: child.pid,
+    purpose: "linzumi.thread_runner"
+  });
+  const exitListeners = /* @__PURE__ */ new Set();
+  const exitState = { exited: false };
+  child.once("exit", (code, signal) => {
+    writeCliAuditEvent("process.exit", {
+      command: process.execPath,
+      args: [scriptPath, ...redactedThreadRunnerCliArgs(args)],
+      cwd: options.cwd,
+      pid: child.pid,
+      code,
+      signal,
+      purpose: "linzumi.thread_runner"
+    });
+    exitState.exited = true;
+    for (const listener of exitListeners) {
+      listener();
+    }
+    exitListeners.clear();
+  });
+  const ready2 = await new Promise((resolve11, reject) => {
+    let settled = false;
+    let timeout;
+    const cleanupReadyListeners = () => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      child.off("message", onMessage);
+      child.off("exit", onExitBeforeReady);
+    };
+    const settle = (action) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanupReadyListeners();
+      action();
+    };
+    const onMessage = (message) => {
+      const parsed = (() => {
+        try {
+          return threadRunnerReadyMessage(message, kandanThreadId);
+        } catch (error51) {
+          settle(
+            () => reject(error51 instanceof Error ? error51 : new Error(String(error51)))
+          );
+          return void 0;
+        }
+      })();
+      if (parsed === void 0) {
+        return;
+      }
+      settle(() => resolve11(parsed));
+    };
+    const onExitBeforeReady = (code, signal) => {
+      settle(
+        () => reject(
+          new Error(
+            `thread Codex worker exited before ready: code=${code ?? "null"} signal=${signal ?? "null"}`
+          )
+        )
+      );
+    };
+    const onReadyTimeout = () => {
+      settle(() => {
+        child.kill("SIGINT");
+        reject(threadRunnerReadyTimeoutError(kandanThreadId, readyTimeoutMs));
+      });
+    };
+    child.on("message", onMessage);
+    child.once("exit", onExitBeforeReady);
+    const readyTimeoutMs = threadRunnerReadyTimeoutMs(options);
+    timeout = setTimeout(onReadyTimeout, readyTimeoutMs);
+  });
+  return {
+    kandanThreadId: ready2.kandanThreadId,
+    codexUrl: ready2.codexUrl,
+    processPid: child.pid,
+    onExit: (listener) => {
+      if (exitState.exited) {
+        queueMicrotask(listener);
+        return;
+      }
+      exitListeners.add(listener);
+    },
+    close: () => new Promise((resolveClose) => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        resolveClose();
+        return;
+      }
+      child.once("exit", () => resolveClose());
+      child.kill("SIGINT");
+    })
+  };
+}
+function threadRunnerReadyMessage(message, expectedKandanThreadId) {
+  if (!isJsonObject(message)) {
+    return void 0;
+  }
+  if (message.type !== "linzumi_thread_codex_worker_ready") {
+    return void 0;
+  }
+  const kandanThreadId = stringValue(message.kandanThreadId);
+  const codexUrl = stringValue(message.codexUrl);
+  if (kandanThreadId !== expectedKandanThreadId || codexUrl === void 0) {
+    throw new Error("thread Codex worker reported invalid ready payload");
+  }
+  return { kandanThreadId, codexUrl };
+}
+function waitForThreadCodexWorkerStop(codexProcess) {
+  return new Promise((resolve11) => {
+    const stop = once(() => {
+      process.off("disconnect", stop);
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      codexProcess.off("exit", stop);
+      resolve11();
+    });
+    process.once("disconnect", stop);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    codexProcess.once("exit", stop);
+  });
+}
+function withThreadRunnerReadyTimeout(promise2, args) {
+  return new Promise((resolve11, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(
+        threadRunnerReadyTimeoutError(args.kandanThreadId, args.timeoutMs)
+      );
+    }, args.timeoutMs);
+    promise2.then(
+      (handle) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeout);
+        resolve11(handle);
+      },
+      (error51) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeout);
+        reject(error51);
+      }
+    );
+  });
+}
+function threadRunnerReadyTimeoutError(kandanThreadId, timeoutMs) {
+  return new Error(
+    `thread Codex worker did not report ready within ${timeoutMs}ms for Kandan thread ${kandanThreadId}`
+  );
+}
+function threadRunnerReadyTimeoutMs(options) {
+  const timeoutMs = options.threadRunnerReadyTimeoutMs ?? THREAD_RUNNER_READY_TIMEOUT_MS;
+  if (Number.isFinite(timeoutMs) && timeoutMs >= 0) {
+    return timeoutMs;
+  }
+  throw new Error("thread runner ready timeout must be a non-negative number");
+}
+function threadRunnerCliArgs(options) {
+  return [
+    "--api-url",
+    options.kandanUrl,
+    "--cwd",
+    options.cwd,
+    "--codex-bin",
+    options.codexBin,
+    ...optionalCliValue("--workspace", options.workspaceSlug),
+    ...optionalCliValue("--log-file", options.logFile),
+    ...options.fast === true ? ["--fast"] : [],
+    ...optionalCliValue("--allowed-cwd", options.allowedCwds.join(",")),
+    ...optionalCliValue(
+      "--forward-port",
+      (options.allowedForwardPorts ?? []).join(",")
+    ),
+    ...optionalCliValue("--code-server-bin", options.codeServerBin),
+    ...optionalCliValue("--model", options.runtimeDefaults?.model),
+    ...optionalCliValue(
+      "--reasoning-effort",
+      options.runtimeDefaults?.reasoningEffort
+    ),
+    ...optionalCliValue("--sandbox", options.runtimeDefaults?.sandbox),
+    ...optionalCliValue(
+      "--approval-policy",
+      options.runtimeDefaults?.approvalPolicy
+    ),
+    ...options.runtimeDefaults?.allowPortForwardingByDefault === true ? ["--allow-port-forwarding-by-default"] : []
+  ];
+}
+function redactedThreadRunnerCliArgs(args) {
+  const redacted = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--token") {
+      redacted.push(arg, "<redacted>");
+      index += 1;
+      continue;
+    }
+    if (arg !== void 0) {
+      redacted.push(arg);
+    }
+  }
+  return redacted;
+}
+function optionalCliValue(flag, value) {
+  return value === void 0 || value === "" ? [] : [flag, value];
+}
+async function startOwnedCodexAppServer(options, args = { linzumiMcp: true }) {
   ensureCodexProjectTrusted(options.cwd);
   const defaults = runnerRuntimeDefaults(options);
-  const mcpAuth = writeEphemeralMcpAuthFile(options);
+  const mcpAuth = args.linzumiMcp === true ? writeEphemeralMcpAuthFile(options) : void 0;
+  const mcpCommand = currentLinzumiCommand();
   try {
     const started = await startCodexAppServer(options.codexBin, options.cwd, {
       model: defaults.model,
       reasoningEffort: defaults.reasoningEffort,
       fast: options.fast,
-      mcpServers: [
+      mcpServers: mcpAuth === void 0 ? [] : [
         linzumiMcpServerConfig({
-          command: currentLinzumiCommand(),
+          command: mcpCommand.command,
+          argsPrefix: mcpCommand.argsPrefix,
           kandanUrl: options.kandanUrl,
           authFilePath: mcpAuth.path,
           ownerUsername: mcpOwnerUsername(options)
         })
       ]
     });
-    const cleanup = once(mcpAuth.cleanup);
+    const cleanup = once(() => mcpAuth?.cleanup());
     started.process.once("exit", cleanup);
     return {
       ...started,
@@ -32399,7 +32983,7 @@ async function startOwnedCodexAppServer(options) {
       }
     };
   } catch (error51) {
-    mcpAuth.cleanup();
+    mcpAuth?.cleanup();
     throw error51;
   }
 }
@@ -32435,8 +33019,7 @@ function once(action) {
   };
 }
 function currentLinzumiCommand() {
-  const scriptPath = process.argv[1];
-  return scriptPath === void 0 || scriptPath.trim() === "" ? "linzumi" : scriptPath;
+  return linzumiMcpCommandForProcess(process.execPath, process.argv[1]);
 }
 function runnerWorkspaceSlug(options) {
   return options.channelSession?.workspaceSlug ?? options.workspaceSlug;
@@ -62791,6 +63374,10 @@ async function main(args) {
       return;
     }
     case "run": {
+      if (process.env.LINZUMI_THREAD_RUNNER_ROLE === "thread") {
+        await runThreadCodexWorker(parseThreadCodexWorkerArgs(parsed.args));
+        return;
+      }
       const options = await parseRunnerArgs(parsed.args);
       await runLocalCodexRunner(withLocalMachineId(options));
       return;
@@ -63421,6 +64008,12 @@ async function parseRunnerArgs(args, deps = {
   ) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue5(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue5(values, "code-server-bin");
+  const initialDependencyStatus = await deps.buildDependencyStatus({
+    cwd,
+    codexBin,
+    codeServerBin: customCodeServerBin
+  });
+  assertStartDependencies(initialDependencyStatus);
   const explicitToken = stringValue5(values, "token");
   const token = await deps.resolveToken({
     kandanUrl,
@@ -63657,11 +64250,60 @@ function parseChannelPath(channel) {
   };
 }
 function withLocalMachineId(options) {
+  if (options.threadProcess?.role === "thread") {
+    return options;
+  }
   return {
     ...options,
     machineId: localConfigScopeKey(options.kandanUrl) === localConfigScopeKey(defaultLinzumiWebSocketUrl) ? ensureLocalMachineId() : ensureLocalMachineIdForLinzumiUrl(options.kandanUrl)
   };
 }
+function parseThreadCodexWorkerArgs(args) {
+  const values = strictFlagValues2(args);
+  const kandanUrl = kandanUrlValue(values) ?? defaultLinzumiWebSocketUrl;
+  const cwd = stringValue5(values, "cwd") ?? process.cwd();
+  const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
+    parseAllowedCwdList(stringValue5(values, "allowed-cwd"))
+  ) : assertConfiguredAllowedCwds([cwd]);
+  const kandanThreadId = requiredThreadRunnerKandanThreadId();
+  return {
+    kandanUrl,
+    token: "",
+    runnerId: `thread-codex-worker:${kandanThreadId}`,
+    machineId: void 0,
+    runnerLockConfigPath: void 0,
+    workspaceSlug: stringValue5(values, "workspace"),
+    cwd,
+    codexBin: stringValue5(values, "codex-bin") ?? "codex",
+    codexUrl: void 0,
+    launchTui: false,
+    fast: values.get("fast") === true ? true : void 0,
+    logFile: stringValue5(values, "log-file"),
+    allowedCwds: configuredAllowedCwds2.allowedCwds,
+    missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
+    allowedForwardPorts: parseAllowedPortList(
+      stringValue5(values, "forward-port")
+    ),
+    codeServerBin: void 0,
+    editorRuntime: void 0,
+    socketFactory: void 0,
+    runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
+    threadProcess: {
+      role: "thread",
+      kandanThreadId
+    },
+    channelSession: void 0
+  };
+}
+function requiredThreadRunnerKandanThreadId() {
+  const kandanThreadId = process.env.LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID;
+  if (kandanThreadId === void 0 || kandanThreadId.trim() === "") {
+    throw new Error(
+      "thread runner is missing LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID"
+    );
+  }
+  return kandanThreadId;
+}
 function required3(values, key) {
   const value = stringValue5(values, key);
   if (value === void 0) {

package/package.json

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