@linzumi/cli 0.0.59-beta → 0.0.61-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.59-beta --version
+npx -y @linzumi/cli@0.0.61-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -28294,7 +28294,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.59-beta";
+var linzumiCliVersion = "0.0.61-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28779,7 +28779,335 @@ function normalizeLocalRunnerCache(value) {
   );
 }
 
+// src/threadCodexWorkerIpc.ts
+function bindThreadCodexWorkerIpc(codex) {
+  const pendingServerRequests = /* @__PURE__ */ new Map();
+  const state = { nextServerRequestId: 1 };
+  const send = (message) => {
+    if (process.send === void 0) {
+      throw new Error("thread Codex worker IPC channel closed");
+    }
+    process.send(message);
+  };
+  process.on("message", (message) => {
+    const parsed = threadCodexWorkerParentMessage(message);
+    if (parsed === void 0) {
+      return;
+    }
+    switch (parsed.type) {
+      case "linzumi_thread_codex_worker_request":
+        void codex.request(parsed.method, parsed.params).then(
+          (response) => send({
+            type: "linzumi_thread_codex_worker_response",
+            id: parsed.id,
+            response
+          })
+        ).catch(
+          (error51) => send({
+            type: "linzumi_thread_codex_worker_response",
+            id: parsed.id,
+            error: error51 instanceof Error ? error51.message : String(error51)
+          })
+        );
+        return;
+      case "linzumi_thread_codex_worker_notify":
+        codex.notify(parsed.method, parsed.params);
+        return;
+      case "linzumi_thread_codex_worker_server_request_response": {
+        const pending = pendingServerRequests.get(parsed.id);
+        if (pending === void 0) {
+          return;
+        }
+        pendingServerRequests.delete(parsed.id);
+        if (parsed.error !== void 0) {
+          pending.reject(new Error(parsed.error));
+          return;
+        }
+        pending.resolve(parsed.result);
+        return;
+      }
+    }
+  });
+  codex.onNotification((notification) => {
+    send({
+      type: "linzumi_thread_codex_worker_notification",
+      notification
+    });
+  });
+  codex.onRequest(
+    (request) => new Promise((resolve11, reject) => {
+      const id = state.nextServerRequestId;
+      state.nextServerRequestId += 1;
+      pendingServerRequests.set(id, { resolve: resolve11, reject });
+      send({
+        type: "linzumi_thread_codex_worker_server_request",
+        id,
+        request
+      });
+    })
+  );
+  process.once("disconnect", () => {
+    for (const pending of pendingServerRequests.values()) {
+      pending.reject(new Error("thread Codex worker IPC channel closed"));
+    }
+    pendingServerRequests.clear();
+  });
+}
+function connectThreadCodexWorkerIpc(child) {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const notificationCallbacks = /* @__PURE__ */ new Set();
+  const requestCallbacks = /* @__PURE__ */ new Set();
+  const pendingNotifications = [];
+  const state = { nextRequestId: 1, closed: false };
+  const rejectPendingRequests = (message) => {
+    const error51 = new Error(message);
+    for (const pending of pendingRequests.values()) {
+      pending.reject(error51);
+    }
+    pendingRequests.clear();
+  };
+  const send = (message) => {
+    if (state.closed) {
+      throw new Error("thread Codex worker IPC client is closed");
+    }
+    if (child.send === void 0 || child.connected === false) {
+      throw new Error("thread Codex worker IPC channel closed");
+    }
+    child.send(message);
+  };
+  const onMessage = (message) => {
+    const parsed = threadCodexWorkerChildMessage(message);
+    if (parsed === void 0) {
+      return;
+    }
+    switch (parsed.type) {
+      case "linzumi_thread_codex_worker_response": {
+        const pending = pendingRequests.get(parsed.id);
+        if (pending === void 0) {
+          return;
+        }
+        pendingRequests.delete(parsed.id);
+        if (parsed.error !== void 0) {
+          pending.reject(new Error(parsed.error));
+          return;
+        }
+        if (parsed.response === void 0) {
+          pending.reject(
+            new Error("thread Codex worker response missing body")
+          );
+          return;
+        }
+        pending.resolve(parsed.response);
+        return;
+      }
+      case "linzumi_thread_codex_worker_notification":
+        if (notificationCallbacks.size === 0) {
+          pendingNotifications.push(parsed.notification);
+        } else {
+          for (const callback of notificationCallbacks) {
+            callback(parsed.notification);
+          }
+        }
+        return;
+      case "linzumi_thread_codex_worker_server_request":
+        void respondToThreadCodexWorkerServerRequest(
+          send,
+          parsed.id,
+          parsed.request,
+          requestCallbacks
+        );
+        return;
+    }
+  };
+  const onClosed = () => {
+    state.closed = true;
+    rejectPendingRequests("thread Codex worker IPC channel closed");
+  };
+  child.on("message", onMessage);
+  child.once("exit", onClosed);
+  child.once("disconnect", onClosed);
+  return {
+    request: (method, params) => new Promise((resolve11, reject) => {
+      const id = state.nextRequestId;
+      state.nextRequestId += 1;
+      pendingRequests.set(id, { resolve: resolve11, reject });
+      try {
+        send({
+          type: "linzumi_thread_codex_worker_request",
+          id,
+          method,
+          params
+        });
+      } catch (error51) {
+        pendingRequests.delete(id);
+        reject(error51 instanceof Error ? error51 : new Error(String(error51)));
+      }
+    }),
+    notify: (method, params) => {
+      send({
+        type: "linzumi_thread_codex_worker_notify",
+        method,
+        params
+      });
+    },
+    onNotification: (callback) => {
+      notificationCallbacks.add(callback);
+      pendingNotifications.splice(0).forEach((notification) => {
+        callback(notification);
+      });
+    },
+    onRequest: (callback) => {
+      requestCallbacks.add(callback);
+    },
+    close: () => {
+      state.closed = true;
+      child.off("message", onMessage);
+      child.off("exit", onClosed);
+      child.off("disconnect", onClosed);
+      rejectPendingRequests("thread Codex worker IPC client closed");
+    }
+  };
+}
+async function respondToThreadCodexWorkerServerRequest(send, id, request, callbacks) {
+  try {
+    for (const callback of callbacks) {
+      const result = await callback(request);
+      if (result !== void 0) {
+        send({
+          type: "linzumi_thread_codex_worker_server_request_response",
+          id,
+          result
+        });
+        return;
+      }
+    }
+    send({
+      type: "linzumi_thread_codex_worker_server_request_response",
+      id,
+      error: `unhandled Codex app-server request: ${request.method}`
+    });
+  } catch (error51) {
+    send({
+      type: "linzumi_thread_codex_worker_server_request_response",
+      id,
+      error: error51 instanceof Error ? error51.message : String(error51)
+    });
+  }
+}
+function threadCodexWorkerParentMessage(message) {
+  if (!isJsonObject(message)) {
+    return void 0;
+  }
+  switch (message.type) {
+    case "linzumi_thread_codex_worker_request": {
+      const id = integerValue(message.id);
+      const method = stringValue(message.method);
+      if (id === void 0 || method === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_request",
+        id,
+        method,
+        params: objectValue(message.params)
+      };
+    }
+    case "linzumi_thread_codex_worker_notify": {
+      const method = stringValue(message.method);
+      if (method === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_notify",
+        method,
+        params: objectValue(message.params)
+      };
+    }
+    case "linzumi_thread_codex_worker_server_request_response": {
+      const id = integerValue(message.id);
+      if (id === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_server_request_response",
+        id,
+        result: message.result,
+        error: stringValue(message.error)
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function threadCodexWorkerChildMessage(message) {
+  if (!isJsonObject(message)) {
+    return void 0;
+  }
+  switch (message.type) {
+    case "linzumi_thread_codex_worker_response": {
+      const id = integerValue(message.id);
+      if (id === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_response",
+        id,
+        response: jsonRpcResponseValue(message.response),
+        error: stringValue(message.error)
+      };
+    }
+    case "linzumi_thread_codex_worker_notification": {
+      const notification = jsonRpcNotificationValue(message.notification);
+      if (notification === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_notification",
+        notification
+      };
+    }
+    case "linzumi_thread_codex_worker_server_request": {
+      const id = integerValue(message.id);
+      const request = jsonRpcRequestValue(message.request);
+      if (id === void 0 || request === void 0) {
+        return void 0;
+      }
+      return {
+        type: "linzumi_thread_codex_worker_server_request",
+        id,
+        request
+      };
+    }
+    case "linzumi_thread_codex_worker_ready":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function jsonRpcResponseValue(value) {
+  if (!isJsonObject(value) || !("id" in value)) {
+    return void 0;
+  }
+  if ("result" in value || "error" in value) {
+    return value;
+  }
+  return void 0;
+}
+function jsonRpcNotificationValue(value) {
+  if (!isJsonObject(value) || "id" in value || typeof value.method !== "string") {
+    return void 0;
+  }
+  return value;
+}
+function jsonRpcRequestValue(value) {
+  if (!isJsonObject(value) || !("id" in value) || typeof value.method !== "string") {
+    return void 0;
+  }
+  return value;
+}
+
 // src/runner.ts
+var THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
 async function runLocalCodexRunner(options) {
   const log = makeRunnerLogger(options);
   const cleanup = {
@@ -28817,6 +29145,31 @@ 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 codex = await connectCodexAppServer(started.url);
+  const stop = once(() => {
+    codex.close();
+    started.stop();
+    log.close();
+  });
+  bindThreadCodexWorkerIpc(codex);
+  process.send({
+    type: "linzumi_thread_codex_worker_ready",
+    kandanThreadId: options.threadProcess.kandanThreadId
+  });
+  await waitForThreadCodexWorkerStop(started.process);
+  stop();
+}
 async function openLocalCodexRunner(options, log, cleanup, close) {
   const agentProviders = availableRunnerAgentProviders(options);
   const allowedForwardPorts = options.allowedForwardPorts ?? [];
@@ -29711,7 +30064,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       launchTui: options.launchTui,
       enablePortForwardWatch: true,
       initialForwardPorts: allowedForwardPorts,
-      portForwardWatcher: started?.process.pid === void 0 ? void 0 : { rootPid: started.process.pid },
+      portForwardWatcher: channelSessionPortForwardWatcherOptions({
+        rootPid: started?.process.pid,
+        start: options.portForwardWatcher
+      }),
       suppressedForwardPorts,
       onForwardPortApproved: (port, attribution) => {
         liveForwardPorts.add(port);
@@ -29771,7 +30127,9 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     );
     threadRunnerProcesses.clear();
   });
-  const attachThreadSession = async (control, cwd, codexThreadId) => {
+  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");
@@ -29791,7 +30149,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     const runtimeSettings = startInstanceRuntimeSettings(options, control);
     const session = await attachChannelSession({
       kandan,
-      codex,
+      codex: sessionCodex,
       topic,
       instanceId,
       options: {
@@ -29805,7 +30163,10 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         launchTui: false,
         enablePortForwardWatch: true,
         initialForwardPorts: allowedForwardPorts,
-        portForwardWatcher: started?.process.pid === void 0 ? void 0 : { rootPid: started.process.pid },
+        portForwardWatcher: channelSessionPortForwardWatcherOptions({
+          rootPid: portForwardWatcherRootPid,
+          start: options.portForwardWatcher
+        }),
         suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
           liveForwardPorts.add(port);
@@ -29838,12 +30199,37 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       log
     });
     dynamicChannelSessions.set(kandanThreadId, session);
+    if (sessionCodex !== codex) {
+      sessionCodex.onNotification((notification) => {
+        seq.value += 1;
+        const params = notification.params ?? {};
+        const metadata = extractCodexIds(params);
+        log("codex.notification", {
+          method: notification.method,
+          metadata
+        });
+        session.handleCodexNotification(notification.method, params);
+      });
+    }
     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");
@@ -29863,17 +30249,24 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       };
     }
     const spawnThreadRunner = options.spawnThreadRunner ?? spawnLocalThreadRunnerProcess;
+    const readyTimeoutMs = threadRunnerReadyTimeoutMs(options);
     const startingEntry = {
       kind: "starting",
-      promise: spawnThreadRunner(
-        threadRunnerOptions({
-          options,
-          control,
-          cwd,
-          workspaceSlug,
-          channelSlug,
-          kandanThreadId
-        })
+      promise: withThreadRunnerReadyTimeout(
+        spawnThreadRunner(
+          threadRunnerOptions({
+            options,
+            control,
+            cwd,
+            workspaceSlug,
+            channelSlug,
+            kandanThreadId
+          })
+        ),
+        {
+          kandanThreadId,
+          timeoutMs: readyTimeoutMs
+        }
       )
     };
     threadRunnerProcesses.set(kandanThreadId, startingEntry);
@@ -29886,31 +30279,84 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       }
       throw error51;
     }
-    const runningEntry = {
-      kind: "running",
-      handle
-    };
-    if (threadRunnerProcesses.get(kandanThreadId) === startingEntry) {
-      threadRunnerProcesses.set(kandanThreadId, runningEntry);
-    }
-    handle.onExit?.(() => {
-      if (threadRunnerProcesses.get(kandanThreadId) === runningEntry) {
+    try {
+      const threadCodex = handle.codex;
+      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);
       }
-    });
-    log("runner.thread_process_started", {
-      kandanThreadId,
-      cwd
-    });
-    return {
-      instanceId,
-      controlType: control.type,
-      ok: true,
-      delegated: true,
-      threadProcess: "started",
-      kandanThreadId,
-      cwd
-    };
+      await (entry?.kind === "running" ? entry.handle.close() : handle.close()).catch(() => void 0);
+      throw error51;
+    }
   };
   const heartbeatPayload = () => ({
     instanceId,
@@ -30228,12 +30674,6 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   };
   controlDispatcher.value = handleControl;
   pendingControls.splice(0).forEach(handleControl);
-  if (options.threadProcess?.role === "thread") {
-    const initialControl = options.threadProcess.initialControl;
-    if (initialControl !== void 0) {
-      handleControl(initialControl);
-    }
-  }
   return { instanceId, codexUrl, close };
 }
 function controlTargetsInstance(control, instanceId) {
@@ -32551,6 +32991,15 @@ function startInstanceRuntimeSettings(options, control) {
     allowPortForwardingByDefault: control.allowPortForwardingByDefault ?? defaults.allowPortForwardingByDefault
   };
 }
+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,
@@ -32558,7 +33007,7 @@ function threadRunnerOptions(args) {
   );
   return {
     ...args.options,
-    clientId: `${args.options.clientId ?? args.options.machineId ?? args.options.runnerId}:thread:${args.kandanThreadId}`,
+    clientId: void 0,
     machineId: void 0,
     runnerLockConfigPath: void 0,
     workspaceSlug: args.workspaceSlug,
@@ -32570,10 +33019,10 @@ function threadRunnerOptions(args) {
     editorRuntime: void 0,
     threadProcess: {
       role: "thread",
-      kandanThreadId: args.kandanThreadId,
-      initialControl: args.control
+      kandanThreadId: args.kandanThreadId
     },
     spawnThreadRunner: void 0,
+    threadRunnerReadyTimeoutMs: args.options.threadRunnerReadyTimeoutMs,
     runtimeDefaults: {
       model: runtimeSettings.model,
       reasoningEffort: runtimeSettings.reasoningEffort,
@@ -32601,6 +33050,7 @@ async function closeThreadRunnerEntry(entry) {
 }
 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"
@@ -32610,14 +33060,7 @@ async function spawnLocalThreadRunnerProcess(options) {
   const env = {
     ...process.env,
     LINZUMI_THREAD_RUNNER_ROLE: "thread",
-    LINZUMI_THREAD_RUNNER_TOKEN: options.token,
-    LINZUMI_THREAD_RUNNER_CLIENT_ID: options.clientId ?? `${options.runnerId}:thread`,
-    LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID: options.threadProcess?.kandanThreadId ?? "",
-    ...options.threadProcess?.initialControl === void 0 ? {} : {
-      LINZUMI_THREAD_RUNNER_INITIAL_CONTROL: JSON.stringify(
-        options.threadProcess.initialControl
-      )
-    }
+    LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID: kandanThreadId
   };
   writeCliAuditEvent("process.spawn", {
     command: process.execPath,
@@ -32628,7 +33071,7 @@ async function spawnLocalThreadRunnerProcess(options) {
   const child = spawn6(process.execPath, [scriptPath, ...args], {
     cwd: options.cwd,
     env,
-    stdio: "inherit"
+    stdio: ["inherit", "inherit", "inherit", "ipc"]
   });
   writeCliAuditEvent("process.spawned", {
     command: process.execPath,
@@ -32655,8 +33098,64 @@ async function spawnLocalThreadRunnerProcess(options) {
     }
     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: options.threadProcess?.kandanThreadId ?? "",
+    kandanThreadId: ready2.kandanThreadId,
+    codex: connectThreadCodexWorkerIpc(child),
+    processPid: child.pid,
     onExit: (listener) => {
       if (exitState.exited) {
         queueMicrotask(listener);
@@ -32674,6 +33173,78 @@ async function spawnLocalThreadRunnerProcess(options) {
     })
   };
 }
+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);
+  if (kandanThreadId !== expectedKandanThreadId) {
+    throw new Error("thread Codex worker reported invalid ready payload");
+  }
+  return { kandanThreadId };
+}
+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",
@@ -32722,17 +33293,17 @@ function redactedThreadRunnerCliArgs(args) {
 function optionalCliValue(flag, value) {
   return value === void 0 || value === "" ? [] : [flag, value];
 }
-async function startOwnedCodexAppServer(options) {
+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: mcpCommand.command,
           argsPrefix: mcpCommand.argsPrefix,
@@ -32742,7 +33313,7 @@ async function startOwnedCodexAppServer(options) {
         })
       ]
     });
-    const cleanup = once(mcpAuth.cleanup);
+    const cleanup = once(() => mcpAuth?.cleanup());
     started.process.once("exit", cleanup);
     return {
       ...started,
@@ -32752,7 +33323,7 @@ async function startOwnedCodexAppServer(options) {
       }
     };
   } catch (error51) {
-    mcpAuth.cleanup();
+    mcpAuth?.cleanup();
     throw error51;
   }
 }
@@ -63133,24 +63704,22 @@ async function main(args) {
       return;
     case "agentRunner": {
       const options = await parseAgentRunnerArgs(parsed.args);
-      await runLocalCodexRunner(
-        withLocalMachineId(withThreadRunnerEnv(options))
-      );
+      await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
     case "start": {
       const options = await parseStartRunnerArgs(parsed.args);
       addAllowedCwdForLinzumiUrl(options.cwd, options.kandanUrl);
-      await runLocalCodexRunner(
-        withLocalMachineId(withThreadRunnerEnv(options))
-      );
+      await runLocalCodexRunner(withLocalMachineId(options));
       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(withThreadRunnerEnv(options))
-      );
+      await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
   }
@@ -63779,7 +64348,13 @@ async function parseRunnerArgs(args, deps = {
   ) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue5(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue5(values, "code-server-bin");
-  const explicitToken = stringValue5(values, "token") ?? threadRunnerTokenEnv();
+  const initialDependencyStatus = await deps.buildDependencyStatus({
+    cwd,
+    codexBin,
+    codeServerBin: customCodeServerBin
+  });
+  assertStartDependencies(initialDependencyStatus);
+  const explicitToken = stringValue5(values, "token");
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
@@ -64023,57 +64598,51 @@ function withLocalMachineId(options) {
     machineId: localConfigScopeKey(options.kandanUrl) === localConfigScopeKey(defaultLinzumiWebSocketUrl) ? ensureLocalMachineId() : ensureLocalMachineIdForLinzumiUrl(options.kandanUrl)
   };
 }
-function withThreadRunnerEnv(options) {
-  if (process.env.LINZUMI_THREAD_RUNNER_ROLE !== "thread") {
-    return options;
-  }
-  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"
-    );
-  }
+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 {
-    ...options,
-    clientId: process.env.LINZUMI_THREAD_RUNNER_CLIENT_ID,
+    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,
-      initialControl: initialThreadControlFromEnv()
+      kandanThreadId
     },
     channelSession: void 0
   };
 }
-function threadRunnerTokenEnv() {
-  if (process.env.LINZUMI_THREAD_RUNNER_ROLE !== "thread") {
-    return void 0;
-  }
-  const token = process.env.LINZUMI_THREAD_RUNNER_TOKEN;
-  if (token === void 0 || token.trim() === "") {
-    throw new Error("thread runner is missing LINZUMI_THREAD_RUNNER_TOKEN");
-  }
-  return token;
-}
-function initialThreadControlFromEnv() {
-  const raw = process.env.LINZUMI_THREAD_RUNNER_INITIAL_CONTROL;
-  if (raw === void 0 || raw.trim() === "") {
-    return void 0;
-  }
-  const parsed = JSON.parse(raw);
-  if (parsed === null || typeof parsed !== "object" || !("type" in parsed)) {
-    throw new Error("thread runner initial control is invalid");
-  }
-  switch (parsed.type) {
-    case "start_instance":
-    case "reconnect_thread":
-      return parsed;
-    default:
-      throw new Error("thread runner initial control type is invalid");
+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);

package/package.json

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