@linzumi/cli 0.0.58-beta → 0.0.59-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.59-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.59-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28908,7 +28929,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 +29711,7 @@ 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 },
       suppressedForwardPorts,
       onForwardPortApproved: (port, attribution) => {
         liveForwardPorts.add(port);
@@ -29742,6 +29764,13 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       )
     );
   });
+  const threadRunnerProcesses = /* @__PURE__ */ new Map();
+  cleanup.actions.push(async () => {
+    await Promise.all(
+      Array.from(threadRunnerProcesses.values(), closeThreadRunnerEntry)
+    );
+    threadRunnerProcesses.clear();
+  });
   const attachThreadSession = async (control, cwd, codexThreadId) => {
     const workspaceSlug = optionalThreadControlField(control, "workspace");
     const channelSlug = optionalThreadControlField(control, "channel");
@@ -29776,6 +29805,7 @@ 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 },
         suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
           liveForwardPorts.add(port);
@@ -29810,6 +29840,78 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     dynamicChannelSessions.set(kandanThreadId, session);
     return session;
   };
+  const startThreadRunnerProcess = async (control, cwd) => {
+    if (options.threadProcess?.role === "thread") {
+      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 startingEntry = {
+      kind: "starting",
+      promise: spawnThreadRunner(
+        threadRunnerOptions({
+          options,
+          control,
+          cwd,
+          workspaceSlug,
+          channelSlug,
+          kandanThreadId
+        })
+      )
+    };
+    threadRunnerProcesses.set(kandanThreadId, startingEntry);
+    let handle;
+    try {
+      handle = await startingEntry.promise;
+    } catch (error51) {
+      if (threadRunnerProcesses.get(kandanThreadId) === startingEntry) {
+        threadRunnerProcesses.delete(kandanThreadId);
+      }
+      throw error51;
+    }
+    const runningEntry = {
+      kind: "running",
+      handle
+    };
+    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
+    });
+    return {
+      instanceId,
+      controlType: control.type,
+      ok: true,
+      delegated: true,
+      threadProcess: "started",
+      kandanThreadId,
+      cwd
+    };
+  };
   const heartbeatPayload = () => ({
     instanceId,
     clientId,
@@ -29890,6 +29992,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 +30210,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);
@@ -30116,6 +30228,12 @@ 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) {
@@ -30129,6 +30247,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 +30521,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 +30599,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 +30740,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,10 +32551,182 @@ function startInstanceRuntimeSettings(options, control) {
     allowPortForwardingByDefault: control.allowPortForwardingByDefault ?? defaults.allowPortForwardingByDefault
   };
 }
+function threadRunnerOptions(args) {
+  const runtimeSettings = startInstanceRuntimeSettings(
+    args.options,
+    args.control
+  );
+  return {
+    ...args.options,
+    clientId: `${args.options.clientId ?? args.options.machineId ?? args.options.runnerId}:thread:${args.kandanThreadId}`,
+    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,
+      initialControl: args.control
+    },
+    spawnThreadRunner: void 0,
+    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];
+  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_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
+      )
+    }
+  };
+  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"
+  });
+  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();
+  });
+  return {
+    kandanThreadId: options.threadProcess?.kandanThreadId ?? "",
+    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 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) {
   ensureCodexProjectTrusted(options.cwd);
   const defaults = runnerRuntimeDefaults(options);
   const mcpAuth = writeEphemeralMcpAuthFile(options);
+  const mcpCommand = currentLinzumiCommand();
   try {
     const started = await startCodexAppServer(options.codexBin, options.cwd, {
       model: defaults.model,
@@ -32382,7 +32734,8 @@ async function startOwnedCodexAppServer(options) {
       fast: options.fast,
       mcpServers: [
         linzumiMcpServerConfig({
-          command: currentLinzumiCommand(),
+          command: mcpCommand.command,
+          argsPrefix: mcpCommand.argsPrefix,
           kandanUrl: options.kandanUrl,
           authFilePath: mcpAuth.path,
           ownerUsername: mcpOwnerUsername(options)
@@ -32435,8 +32788,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;
@@ -62781,18 +63133,24 @@ async function main(args) {
       return;
     case "agentRunner": {
       const options = await parseAgentRunnerArgs(parsed.args);
-      await runLocalCodexRunner(withLocalMachineId(options));
+      await runLocalCodexRunner(
+        withLocalMachineId(withThreadRunnerEnv(options))
+      );
       return;
     }
     case "start": {
       const options = await parseStartRunnerArgs(parsed.args);
       addAllowedCwdForLinzumiUrl(options.cwd, options.kandanUrl);
-      await runLocalCodexRunner(withLocalMachineId(options));
+      await runLocalCodexRunner(
+        withLocalMachineId(withThreadRunnerEnv(options))
+      );
       return;
     }
     case "run": {
       const options = await parseRunnerArgs(parsed.args);
-      await runLocalCodexRunner(withLocalMachineId(options));
+      await runLocalCodexRunner(
+        withLocalMachineId(withThreadRunnerEnv(options))
+      );
       return;
     }
   }
@@ -63421,7 +63779,7 @@ 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");
+  const explicitToken = stringValue5(values, "token") ?? threadRunnerTokenEnv();
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
@@ -63657,11 +64015,66 @@ 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 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"
+    );
+  }
+  return {
+    ...options,
+    clientId: process.env.LINZUMI_THREAD_RUNNER_CLIENT_ID,
+    machineId: void 0,
+    runnerLockConfigPath: void 0,
+    codexUrl: void 0,
+    launchTui: false,
+    threadProcess: {
+      role: "thread",
+      kandanThreadId,
+      initialControl: initialThreadControlFromEnv()
+    },
+    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 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.59-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": {