@linzumi/cli 0.0.59-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.59-beta --version
+npx -y @linzumi/cli@0.0.60-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.60-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28780,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 = {
@@ -28817,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 ?? [];
@@ -29711,7 +29735,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 +29798,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 +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: {
@@ -29805,7 +29834,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);
@@ -29840,10 +29872,23 @@ 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");
@@ -29863,17 +29908,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 +29938,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 = 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);
       }
-    });
-    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 +30333,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 +32650,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 +32666,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 +32678,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 +32709,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 +32719,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 +32730,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 +32757,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,
+    codexUrl: ready2.codexUrl,
+    processPid: child.pid,
     onExit: (listener) => {
       if (exitState.exited) {
         queueMicrotask(listener);
@@ -32674,6 +32832,79 @@ 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);
+  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",
@@ -32722,17 +32953,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 +32973,7 @@ async function startOwnedCodexAppServer(options) {
         })
       ]
     });
-    const cleanup = once(mcpAuth.cleanup);
+    const cleanup = once(() => mcpAuth?.cleanup());
     started.process.once("exit", cleanup);
     return {
       ...started,
@@ -32752,7 +32983,7 @@ async function startOwnedCodexAppServer(options) {
       }
     };
   } catch (error51) {
-    mcpAuth.cleanup();
+    mcpAuth?.cleanup();
     throw error51;
   }
 }
@@ -63133,24 +63364,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 +64008,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 +64258,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.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": {