@linzumi/cli 0.0.20-beta → 0.0.23-beta

package/src/runner.ts

@@ -1,943 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-plan.md
-  Relationship: Bridges the spec's desired local instance lifecycle between
-  Kandan controls, Codex app-server JSON-RPC, and optional remote TUI launch.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Hosts the process lifecycle used by the channel-bound local
-  Codex product flow while delegating session behavior to `channelSession.ts`.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-quality-pass-spec.md
-  Relationship: Keeps the runner focused on transport lifecycle and Codex
-  process orchestration instead of embedding pure channel-session policy.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-session-module-spec.md
-  Relationship: Delegates channel-bound Kandan/Codex session orchestration to
-  the dedicated channel session module.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Owns channel-mode startup cost and process-level cleanup
-  requirements for the deep quality pass, including cleanup of partially
-  opened resources when startup fails.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Leaves channel-scoped approval controls to `channelSession.ts`
-  so the process runner remains lifecycle-only while Kandan safely resolves
-  Codex app-server approval requests from the thread UI.
-
-- Date: 2026-04-26
-  Spec: plans/2026_04_26_linzumi_cli_review_followups_note.md
-  Relationship: Rejects stale Kandan controls for previous local runner
-  instances before they can mutate the current Codex app-server session.
-
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Enforces local machine cwd capabilities for Kandan-requested
-  Codex session starts and advertises cwd plus local preview-port capabilities
-  to the server on the runner join payload.
-
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-runner-forwarding-and-editor-plan.md
-  Relationship: Routes Kandan-authenticated local preview forwarding controls
-  to the local loopback HTTP fetcher after verifying the control targets this
-  runner instance.
-
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-runner-port-forward-approval.md
-  Relationship: Lets channel-session approval add descendant listener ports to
-  the runner's live forwarding capability before forwarding requests use them.
-*/
-import { spawn, type ChildProcess } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { hostname } from "node:os";
-import { join } from "node:path";
-import { attachChannelSession } from "./channelSession";
-import { connectCodexAppServer, startCodexAppServer } from "./codexAppServer";
-import { arrayValue, integerValue, objectValue, stringValue } from "./json";
-import { resolveAllowedCwd } from "./localCapabilities";
-import {
-  createForwardWebSocketManager,
-  handleForwardHttpRequest,
-  isForwardHttpRequestControl,
-  isForwardWebSocketControl,
-} from "./localForwarding";
-import {
-  isStartLocalEditorControl,
-  localEditorCapabilities,
-  startLocalEditor,
-  type LocalEditorState,
-} from "./localEditor";
-import type { InstalledEditorRuntime } from "./localEditorRuntime";
-import {
-  dependencyStatusPayload,
-  type RunnerDependencyStatus,
-} from "./dependencyStatus";
-import { connectPhoenixClient } from "./phoenix";
-import {
-  type JsonObject,
-  type JsonRpcResponse,
-  type JsonValue,
-  type KandanChannelSessionOptions,
-  type KandanControl,
-  extractCodexIds,
-  isJsonObject,
-} from "./protocol";
-import { createRunnerLogger, type RunnerLogger } from "./runnerLogger";
-import { reportRunnerConsoleEvent } from "./runnerConsoleReporter";
-
-export type RunnerOptions = {
-  readonly kandanUrl: string;
-  readonly token: string;
-  readonly runnerId: string;
-  readonly cwd: string;
-  readonly codexBin: string;
-  readonly codexUrl: string | undefined;
-  readonly launchTui: boolean;
-  readonly fast?: boolean | undefined;
-  readonly logFile?: string | undefined;
-  readonly allowedCwds: readonly string[];
-  readonly allowedForwardPorts?: readonly number[] | undefined;
-  readonly codeServerBin?: string | undefined;
-  readonly editorRuntime?: InstalledEditorRuntime | undefined;
-  readonly dependencyStatus?: RunnerDependencyStatus | undefined;
-  readonly socketFactory?: ((url: string) => WebSocket) | undefined;
-  readonly channelSession: KandanChannelSessionOptions | undefined;
-};
-
-export type LocalCodexRunnerHandle = {
-  readonly instanceId: string;
-  readonly codexUrl: string;
-  readonly close: () => Promise<void>;
-};
-
-type CleanupAction = () => void | Promise<void>;
-
-type CleanupStack = {
-  readonly actions: CleanupAction[];
-  closePromise: Promise<void> | undefined;
-  removeHandlers: (() => void) | undefined;
-};
-
-export async function runLocalCodexRunner(
-  options: RunnerOptions,
-): Promise<LocalCodexRunnerHandle> {
-  const log = makeRunnerLogger(options);
-  const cleanup: CleanupStack = {
-    actions: [() => log.close()],
-    closePromise: undefined,
-    removeHandlers: undefined,
-  };
-  const close = () => closeCleanupStack(cleanup);
-  cleanup.removeHandlers = installCleanupHandlers(close);
-
-  log("runner.starting", {
-    runnerId: options.runnerId,
-    cwd: options.cwd,
-    kandanUrl: options.kandanUrl,
-  });
-
-  try {
-    return await openLocalCodexRunner(options, log, cleanup, close);
-  } catch (error) {
-    await close().catch(() => undefined);
-    throw error;
-  }
-}
-
-async function openLocalCodexRunner(
-  options: RunnerOptions,
-  log: RunnerLogger,
-  cleanup: CleanupStack,
-  close: () => Promise<void>,
-): Promise<LocalCodexRunnerHandle> {
-  const allowedForwardPorts = options.allowedForwardPorts ?? [];
-  const liveForwardPorts = new Set<number>(allowedForwardPorts);
-  const managedForwardPorts = new Set<number>();
-  const allowedCwds = { value: [...options.allowedCwds] };
-  const localEditorState: { value: LocalEditorState } = {
-    value: { status: "disabled" },
-  };
-  const localEditorGeneration = { value: 0 };
-  cleanup.actions.push(() => {
-    if (localEditorState.value.status === "running") {
-      localEditorState.value.process.kill("SIGINT");
-      localEditorState.value.collaboration?.process.kill("SIGINT");
-    }
-  });
-  const capabilitiesPayload = (): JsonObject => ({
-    codexAppServer: true,
-    codexRemoteTui: true,
-    startInstance: allowedCwds.value.length > 0,
-    allowedCwds: allowedCwds.value,
-    allowedCwdSuggestions: allowedCwdSuggestions(
-      options.cwd,
-      allowedCwds.value,
-    ),
-    portForwarding: liveForwardPorts.size > 0,
-    allowedPorts: Array.from(liveForwardPorts).sort(
-      (left, right) => left - right,
-    ),
-    toolStatus:
-      options.dependencyStatus === undefined
-        ? null
-        : dependencyStatusPayload(options.dependencyStatus),
-    editorRuntime:
-      options.dependencyStatus?.editorRuntime === undefined
-        ? null
-        : dependencyStatusPayload(options.dependencyStatus).editorRuntime,
-    ...localEditorCapabilities(
-      options.editorRuntime,
-      allowedCwds.value,
-      localEditorState.value,
-    ),
-  });
-  const kandan = await connectPhoenixClient(
-    options.kandanUrl,
-    options.token,
-    options.socketFactory,
-  );
-  cleanup.actions.push(() => kandan.close());
-  const topic = `local_runner:${options.runnerId}`;
-  const joinPayload = (): JsonObject => ({
-    clientName: "kandan-local-codex-runner",
-    version: "0.0.1",
-    workspace: options.channelSession?.workspaceSlug ?? null,
-    channel: options.channelSession?.channelSlug ?? null,
-    capabilities: capabilitiesPayload(),
-  });
-
-  const pendingControls: KandanControl[] = [];
-  const controlDispatcher: {
-    value: ((control: KandanControl) => void) | undefined;
-  } = { value: undefined };
-  kandan.onControl((control) => {
-    const dispatcher = controlDispatcher.value;
-    if (dispatcher === undefined) {
-      pendingControls.push(control);
-      return;
-    }
-
-    dispatcher(control);
-  });
-
-  await kandan.join(topic, joinPayload(), { rejoinPayload: joinPayload });
-
-  const started =
-    options.codexUrl === undefined
-      ? await startCodexAppServer(options.codexBin, options.cwd, {
-          model: options.channelSession?.model,
-          reasoningEffort: options.channelSession?.reasoningEffort,
-          fast: options.fast,
-        })
-      : undefined;
-
-  if (started !== undefined) {
-    cleanup.actions.push(() => {
-      started.process.kill("SIGINT");
-    });
-  }
-
-  const codexUrl = options.codexUrl ?? started?.url;
-
-  if (codexUrl === undefined) {
-    throw new Error("missing codex app-server websocket URL");
-  }
-
-  const instanceId = `codex-${randomUUID()}`;
-  const publishLocalEditorStatus = (payload: JsonObject): void => {
-    void kandan.push(topic, "local_editor_status", payload).catch((error) => {
-      log("kandan.local_editor_status_push_failed", {
-        message: error instanceof Error ? error.message : String(error),
-      });
-    });
-  };
-  const watchLocalEditorExit = (
-    state: Extract<LocalEditorState, { status: "running" }>,
-    generation: number,
-    initialStatusPushed: Promise<unknown>,
-  ): void => {
-    const handleExit = () => {
-      if (
-        localEditorGeneration.value !== generation ||
-        localEditorState.value.status !== "running" ||
-        localEditorState.value.process !== state.process
-      ) {
-        return;
-      }
-
-      localEditorState.value = { status: "disabled" };
-      liveForwardPorts.delete(state.port);
-      managedForwardPorts.delete(state.port);
-      if (state.collaboration !== undefined) {
-        liveForwardPorts.delete(state.collaboration.serverPort);
-        managedForwardPorts.delete(state.collaboration.serverPort);
-      }
-      publishLocalEditorStatus({
-        instanceId,
-        ok: true,
-        cwd: state.cwd,
-        capabilities: {
-          ...capabilitiesPayload(),
-          revokedPorts:
-            state.collaboration === undefined
-              ? [state.port]
-              : [state.port, state.collaboration.serverPort],
-        },
-      });
-    };
-
-    const handleExitAfterInitialStatus = () => {
-      void initialStatusPushed.then(handleExit).catch((error) => {
-        log("kandan.local_editor_initial_status_failed", {
-          message: error instanceof Error ? error.message : String(error),
-        });
-      });
-    };
-
-    void state.exited.then(handleExitAfterInitialStatus);
-  };
-  const codex = await connectCodexAppServer(codexUrl);
-  cleanup.actions.push(() => codex.close());
-
-  const seq = { value: 0 };
-  const codexThreads =
-    options.channelSession === undefined
-      ? await discoverCodexThreads(codex, options.cwd)
-      : [];
-
-  const runnerHost = hostname();
-  const instancePayload = {
-    instanceId,
-    codexUrl,
-    tuiLaunched: options.launchTui,
-    cwd: options.cwd,
-    hostname: runnerHost,
-    codexThreads,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
-    fast: options.fast ?? false,
-  };
-
-  await kandan.push(topic, "instance_started", instancePayload);
-  log("runner.instance_started", { instanceId, codexUrl });
-
-  const channelSession =
-    options.channelSession === undefined
-      ? undefined
-      : await attachChannelSession({
-          kandan,
-          codex,
-          topic,
-          instanceId,
-          options: {
-            token: options.token,
-            runnerId: options.runnerId,
-            cwd: options.cwd,
-            codexBin: options.codexBin,
-            fast: options.fast,
-            launchTui: options.launchTui,
-            enablePortForwardWatch: true,
-            initialForwardPorts: allowedForwardPorts,
-            suppressedForwardPorts: () => Array.from(managedForwardPorts),
-            onForwardPortApproved: (port) => {
-              liveForwardPorts.add(port);
-              return capabilitiesPayload();
-            },
-            onForwardPortRevoked: (port) => {
-              liveForwardPorts.delete(port);
-              return capabilitiesPayload();
-            },
-            channelSession: options.channelSession,
-          },
-          log,
-        });
-
-  if (channelSession !== undefined) {
-    cleanup.actions.push(() => channelSession.close());
-    kandan.onReconnect(() => channelSession.handleKandanReconnect());
-  }
-
-  const heartbeatPayload = (): JsonObject => ({
-    instanceId,
-    codexUrl,
-    cwd: options.cwd,
-    hostname: runnerHost,
-    workspace: options.channelSession?.workspaceSlug ?? null,
-    channel: options.channelSession?.channelSlug ?? null,
-    threadId: channelSession?.currentKandanThreadId() ?? null,
-    codexThreadId: channelSession?.currentCodexThreadId() ?? null,
-    model: options.channelSession?.model ?? null,
-    reasoningEffort: options.channelSession?.reasoningEffort ?? null,
-    fast: options.fast ?? false,
-    capabilities: capabilitiesPayload(),
-  });
-  const pushHeartbeat = () =>
-    kandan.push(topic, "heartbeat", heartbeatPayload()).catch((error) => {
-      log("kandan.heartbeat_push_failed", {
-        message: error instanceof Error ? error.message : String(error),
-      });
-    });
-  const heartbeatInterval = setInterval(() => {
-    void pushHeartbeat();
-  }, 15_000);
-  cleanup.actions.push(() => clearInterval(heartbeatInterval));
-  kandan.onReconnect(() => pushHeartbeat().then(() => undefined));
-  void pushHeartbeat();
-
-  const forwardWebSockets = createForwardWebSocketManager(kandan, topic, () =>
-    Array.from(liveForwardPorts),
-  );
-  cleanup.actions.push(() => forwardWebSockets.close());
-
-  const channelCodexThreadId = channelSession?.currentCodexThreadId();
-  if (options.launchTui && channelCodexThreadId !== undefined) {
-    await prepareCodexThreadForTuiResume(codex, channelCodexThreadId);
-  }
-
-  const tui = options.launchTui
-    ? launchCodexTui(
-        options.codexBin,
-        codexUrl,
-        options.cwd,
-        channelCodexThreadId,
-        options.channelSession,
-        options.fast,
-      )
-    : undefined;
-
-  if (tui !== undefined) {
-    cleanup.actions.push(() => {
-      tui.kill("SIGINT");
-    });
-  }
-
-  codex.onNotification((notification) => {
-    seq.value += 1;
-    const params = (notification.params ?? {}) as JsonObject;
-    const metadata = extractCodexIds(params);
-
-    if (channelSession === undefined) {
-      void kandan
-        .push(topic, "codex_notification", {
-          instanceId,
-          seq: seq.value,
-          method: notification.method,
-          params,
-          metadata,
-          receivedAt: new Date().toISOString(),
-        })
-        .catch((error) => {
-          log("kandan.codex_notification_push_failed", {
-            message: error instanceof Error ? error.message : String(error),
-          });
-        });
-    }
-
-    log("codex.notification", {
-      method: notification.method,
-      metadata,
-    });
-    channelSession?.handleCodexNotification(notification.method, params);
-  });
-
-  const handleControl = (control: KandanControl) => {
-    log("kandan.control", { control });
-    if (!controlTargetsInstance(control, instanceId)) {
-      log("kandan.control_ignored", {
-        reason: "instance_id_mismatch",
-        instanceId,
-        controlInstanceId: control.instanceId,
-        controlType: control.type,
-      });
-      return;
-    }
-
-    if (isForwardHttpRequestControl(control)) {
-      void handleForwardHttpRequest(control, Array.from(liveForwardPorts))
-        .then((response) =>
-          kandan.push(topic, "forward:http_response", response),
-        )
-        .catch((error) =>
-          kandan.push(topic, "forward:http_response", {
-            requestId: control.requestId,
-            ok: false,
-            error: error instanceof Error ? error.message : String(error),
-          }),
-        )
-        .catch((error) => {
-          log("kandan.forward_response_push_failed", {
-            message: error instanceof Error ? error.message : String(error),
-          });
-        });
-      return;
-    }
-
-    if (isForwardWebSocketControl(control)) {
-      forwardWebSockets.handle(control);
-      return;
-    }
-
-    if (isStartLocalEditorControl(control)) {
-      void startLocalEditor(control, {
-        codeServerBin: options.codeServerBin,
-        editorRuntime: options.editorRuntime,
-        allowedCwds: allowedCwds.value,
-        currentState: localEditorState.value,
-        browserBaseUrl:
-          control.browserBaseUrl ?? process.env.KANDAN_LOCAL_RUNNER_PUBLIC_BASE_URL,
-        runnerId: options.runnerId,
-      })
-        .then((result) => {
-          if (result.ok) {
-            localEditorGeneration.value += 1;
-            const editorGeneration = localEditorGeneration.value;
-            if (localEditorState.value.status === "running") {
-              liveForwardPorts.delete(localEditorState.value.port);
-              managedForwardPorts.delete(localEditorState.value.port);
-              if (localEditorState.value.collaboration !== undefined) {
-                liveForwardPorts.delete(
-                  localEditorState.value.collaboration.serverPort,
-                );
-                managedForwardPorts.delete(
-                  localEditorState.value.collaboration.serverPort,
-                );
-              }
-            }
-            localEditorState.value = result.state;
-            liveForwardPorts.add(result.event.port);
-            managedForwardPorts.add(result.event.port);
-            if (result.event.collaboration !== undefined) {
-              liveForwardPorts.add(result.event.collaboration.serverPort);
-              managedForwardPorts.add(result.event.collaboration.serverPort);
-            }
-            const initialStatusPushed = kandan.push(
-              topic,
-              "local_editor_status",
-              {
-                instanceId,
-                requestId: control.requestId,
-                ok: true,
-                capabilities: capabilitiesPayload(),
-                ...result.event,
-              },
-            );
-
-            if (result.state.status === "running") {
-              watchLocalEditorExit(
-                result.state,
-                editorGeneration,
-                initialStatusPushed,
-              );
-            }
-
-            return initialStatusPushed;
-          }
-
-          localEditorState.value = result.state;
-          return kandan.push(topic, "local_editor_status", {
-            instanceId,
-            requestId: control.requestId,
-            ok: false,
-            reason: result.reason,
-            capabilities: capabilitiesPayload(),
-          });
-        })
-        .catch((error) =>
-          kandan.push(topic, "local_editor_status", {
-            instanceId,
-            requestId: control.requestId,
-            ok: false,
-            reason: error instanceof Error ? error.message : String(error),
-            capabilities: capabilitiesPayload(),
-          }),
-        )
-        .catch((error) => {
-          log("kandan.local_editor_status_push_failed", {
-            message: error instanceof Error ? error.message : String(error),
-          });
-        });
-      return;
-    }
-
-    if (isUpdateRunnerConfigControl(control)) {
-      allowedCwds.value = normalizeAllowedCwds(control.allowedCwds);
-      void pushHeartbeat();
-      return;
-    }
-
-    void (channelSession?.handleControl(control) ?? Promise.resolve(undefined))
-      .then((handled) => {
-        if (handled !== undefined) {
-          return handled;
-        }
-
-        return applyControl(
-          codex,
-          instanceId,
-          options,
-          allowedCwds.value,
-          control,
-        );
-      })
-      .then((response) => {
-        return kandan.push(topic, "codex_response", response);
-      })
-      .catch((error) => {
-        return kandan.push(topic, "codex_error", {
-          instanceId,
-          message: error instanceof Error ? error.message : String(error),
-        });
-      })
-      .catch((error) => {
-        log("kandan.control_response_push_failed", {
-          message: error instanceof Error ? error.message : String(error),
-        });
-      });
-  };
-
-  controlDispatcher.value = handleControl;
-  pendingControls.splice(0).forEach(handleControl);
-
-  return { instanceId, codexUrl, close };
-}
-
-function controlTargetsInstance(
-  control: KandanControl,
-  instanceId: string,
-): boolean {
-  return control.instanceId === undefined || control.instanceId === instanceId;
-}
-
-async function closeCleanupStack(cleanup: CleanupStack): Promise<void> {
-  if (cleanup.closePromise !== undefined) {
-    return cleanup.closePromise;
-  }
-
-  cleanup.closePromise = (async () => {
-    const errors: Error[] = [];
-    cleanup.removeHandlers?.();
-    cleanup.removeHandlers = undefined;
-
-    for (const action of [...cleanup.actions].reverse()) {
-      try {
-        await action();
-      } catch (error) {
-        errors.push(error instanceof Error ? error : new Error(String(error)));
-      }
-    }
-
-    cleanup.actions.splice(0);
-
-    if (errors[0] !== undefined) {
-      throw errors[0];
-    }
-  })();
-
-  return cleanup.closePromise;
-}
-
-async function discoverCodexThreads(
-  codex: Awaited<ReturnType<typeof connectCodexAppServer>>,
-  cwd: string,
-): Promise<JsonValue[]> {
-  const response = await codex.request("thread/list", { cwd });
-
-  if ("error" in response) {
-    return [];
-  }
-
-  const result = objectValue(response.result);
-  const data = arrayValue(result?.data);
-
-  return data === undefined
-    ? []
-    : data
-        .filter(isJsonObject)
-        .map((thread) => ({
-          id: stringValue(thread.id) ?? "",
-          preview: stringValue(thread.preview) ?? "",
-          cwd: stringValue(thread.cwd) ?? "",
-          source: stringValue(thread.source) ?? "",
-          updatedAt: integerValue(thread.updatedAt) ?? null,
-          status: objectValue(thread.status) ?? null,
-        }))
-        .filter((thread) => thread.id !== "");
-}
-
-function extractStartedThreadId(response: JsonRpcResponse): string | undefined {
-  if ("error" in response) {
-    return undefined;
-  }
-
-  return stringValue(objectValue(objectValue(response.result)?.thread)?.id);
-}
-
-function normalizedWorkDescription(value: string | undefined): string | undefined {
-  const normalized = value?.trim();
-
-  return normalized === undefined || normalized === ""
-    ? undefined
-    : normalized;
-}
-
-function makeRunnerLogger(options: RunnerOptions): RunnerLogger {
-  return createRunnerLogger(
-    options.logFile ?? join(options.cwd, ".linzumi-runner.log"),
-    options.launchTui ? undefined : reportRunnerConsoleEvent,
-  );
-}
-
-function installCleanupHandlers(close: () => Promise<void>): () => void {
-  const closeAndExit = () => {
-    void close()
-      .catch(() => undefined)
-      .finally(() => process.exit(0));
-  };
-  const closeOnExit = () => {
-    void close().catch(() => undefined);
-  };
-
-  process.once("SIGINT", closeAndExit);
-  process.once("SIGTERM", closeAndExit);
-  process.once("SIGHUP", closeAndExit);
-  process.once("exit", closeOnExit);
-
-  return () => {
-    process.off("SIGINT", closeAndExit);
-    process.off("SIGTERM", closeAndExit);
-    process.off("SIGHUP", closeAndExit);
-    process.off("exit", closeOnExit);
-  };
-}
-
-function launchCodexTui(
-  codexBin: string,
-  codexUrl: string,
-  cwd: string,
-  codexThreadId: string | undefined,
-  session: KandanChannelSessionOptions | undefined,
-  fast: boolean | undefined,
-): ChildProcess {
-  return spawn(codexBin, codexTuiArgs(codexUrl, codexThreadId, session, fast), {
-    cwd,
-    env: process.env,
-    stdio: "inherit",
-  });
-}
-
-export function codexTuiArgs(
-  codexUrl: string,
-  codexThreadId: string | undefined,
-  session?: KandanChannelSessionOptions | undefined,
-  fast?: boolean | undefined,
-): string[] {
-  const overrides = codexTuiConfigArgs(session, fast);
-
-  return codexThreadId === undefined
-    ? ["--remote", codexUrl, ...overrides]
-    : ["resume", "--remote", codexUrl, ...overrides, codexThreadId];
-}
-
-function codexTuiConfigArgs(
-  session: KandanChannelSessionOptions | undefined,
-  fast: boolean | undefined,
-): string[] {
-  const modelArgs =
-    session?.model === undefined ? [] : ["--model", session.model];
-  const reasoningArgs =
-    session?.reasoningEffort === undefined
-      ? []
-      : ["-c", `model_reasoning_effort="${session.reasoningEffort}"`];
-  const tierArgs = fast === true ? ["-c", 'service_tier="fast"'] : [];
-
-  return [...modelArgs, ...reasoningArgs, ...tierArgs];
-}
-
-export async function prepareCodexThreadForTuiResume(
-  codex: Pick<Awaited<ReturnType<typeof connectCodexAppServer>>, "request">,
-  codexThreadId: string,
-): Promise<void> {
-  const resume = await codex.request("thread/resume", {
-    threadId: codexThreadId,
-  });
-
-  if (!("error" in resume)) {
-    return;
-  }
-
-  if (!resume.error.message.includes("no rollout found")) {
-    throw new Error(
-      `failed to prepare Codex TUI resume: ${resume.error.message}`,
-    );
-  }
-
-  const injected = await codex.request("thread/inject_items", {
-    threadId: codexThreadId,
-    items: [{ type: "agentMessage", text: "" }],
-  });
-
-  if ("error" in injected) {
-    throw new Error(
-      `failed to prepare Codex TUI resume: ${injected.error.message}`,
-    );
-  }
-
-  const verified = await codex.request("thread/resume", {
-    threadId: codexThreadId,
-  });
-
-  if ("error" in verified) {
-    throw new Error(
-      `failed to verify Codex TUI resume: ${verified.error.message}`,
-    );
-  }
-}
-
-async function applyControl(
-  codex: Awaited<ReturnType<typeof connectCodexAppServer>>,
-  instanceId: string,
-  options: RunnerOptions,
-  allowedCwds: readonly string[],
-  control: KandanControl,
-): Promise<JsonObject> {
-  switch (control.type) {
-    case "start_instance": {
-      const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
-
-      if (!cwd.ok) {
-        return {
-          instanceId,
-          controlType: control.type,
-          ok: false,
-          error: cwd.reason,
-        };
-      }
-
-      const response = await codex.request("thread/start", {
-        cwd: cwd.cwd,
-        serviceName: "kandan-local-runner",
-        personality: "pragmatic",
-        ...(control.model === undefined ? {} : { model: control.model }),
-        ...(control.reasoningEffort === undefined
-          ? {}
-          : { reasoningEffort: control.reasoningEffort }),
-        ...(control.approvalPolicy === undefined
-          ? {}
-          : { approvalPolicy: control.approvalPolicy }),
-        ...(control.sandbox === undefined ? {} : { sandbox: control.sandbox }),
-        ...(control.fast === true ? { serviceTier: "fast" } : {}),
-      });
-      const codexThreadId = extractStartedThreadId(response);
-      const workDescription = normalizedWorkDescription(control.workDescription);
-
-      if (codexThreadId !== undefined && workDescription !== undefined) {
-        await codex.request("turn/start", {
-          threadId: codexThreadId,
-          input: [{ type: "text", text: workDescription }],
-        });
-      }
-
-      return {
-        instanceId,
-        controlType: control.type,
-        cwd: cwd.cwd,
-        matchedRoot: cwd.matchedRoot,
-        response: response as JsonObject,
-      };
-    }
-
-    case "start_turn": {
-      const response = await codex.request("turn/start", {
-        threadId: control.threadId,
-        input: control.input,
-      });
-      return {
-        instanceId,
-        controlType: control.type,
-        response: response as JsonObject,
-      };
-    }
-
-    case "steer_turn": {
-      const response = await codex.request("turn/steer", {
-        threadId: control.threadId,
-        turnId: control.turnId,
-        input: control.input,
-      });
-      return {
-        instanceId,
-        controlType: control.type,
-        response: response as JsonObject,
-      };
-    }
-
-    case "interrupt_turn": {
-      const response = await codex.request("turn/interrupt", {
-        threadId: control.threadId,
-        turnId: control.turnId ?? null,
-      });
-      return {
-        instanceId,
-        controlType: control.type,
-        response: response as JsonObject,
-      };
-    }
-
-    case "read_thread": {
-      const response = await codex.request("thread/read", {
-        threadId: control.threadId,
-        includeTurns: control.includeTurns ?? true,
-      });
-      return {
-        instanceId,
-        controlType: control.type,
-        response: response as JsonObject,
-      };
-    }
-
-    case "stop_instance":
-    case "kill_instance":
-    case "interrupt_queued_messages":
-    case "resolve_codex_approval_request":
-    case "forward_http_request":
-    case "forward_websocket_open":
-    case "forward_websocket_send":
-    case "forward_websocket_close":
-    case "start_local_editor":
-    case "update_runner_config":
-      return { instanceId, controlType: control.type, skipped: true };
-  }
-}
-
-function isUpdateRunnerConfigControl(
-  control: KandanControl,
-): control is Extract<
-  KandanControl,
-  { readonly type: "update_runner_config" }
-> {
-  return control.type === "update_runner_config";
-}
-
-function normalizeAllowedCwds(values: readonly string[]): string[] {
-  return Array.from(
-    new Set(
-      values.flatMap((value) => {
-        const normalized = value.trim();
-        return normalized === "" ? [] : [normalized];
-      }),
-    ),
-  );
-}
-
-function allowedCwdSuggestions(
-  cwd: string,
-  allowedCwds: readonly string[],
-): string[] {
-  return normalizeAllowedCwds([cwd, ...allowedCwds]);
-}