@linzumi/cli 0.0.20-beta → 0.0.23-beta

package/src/codexRuntimeOptions.ts

@@ -1,80 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Defines the pure local Codex app-server runtime option mapping
-  for model, reasoning effort, fast tier, approval policy, and sandbox mode so
-  session settings are testable outside the channel-session orchestrator.
-*/
-import type { JsonObject } from "./protocol";
-
-export type CodexRuntimeOptions = {
-  readonly cwd: string;
-  readonly fast?: boolean | undefined;
-  readonly channelSession: {
-    readonly model?: string | undefined;
-    readonly reasoningEffort?: string | undefined;
-    readonly approvalPolicy?: string | undefined;
-    readonly sandbox?: string | undefined;
-  };
-};
-
-export function codexThreadRuntimeOverrides(
-  options: CodexRuntimeOptions,
-): JsonObject {
-  const session = options.channelSession;
-
-  return {
-    ...(session.model === undefined ? {} : { model: session.model }),
-    ...(session.reasoningEffort === undefined
-      ? {}
-      : { reasoningEffort: session.reasoningEffort }),
-    ...(options.fast === true ? { serviceTier: "fast" } : {}),
-    ...(session.approvalPolicy === undefined
-      ? {}
-      : { approvalPolicy: session.approvalPolicy }),
-    ...(session.sandbox === undefined ? {} : { sandbox: session.sandbox }),
-  };
-}
-
-export function codexTurnRuntimeOverrides(options: CodexRuntimeOptions): JsonObject {
-  const session = options.channelSession;
-
-  return {
-    cwd: options.cwd,
-    ...(session.model === undefined ? {} : { model: session.model }),
-    ...(session.reasoningEffort === undefined
-      ? {}
-      : { effort: session.reasoningEffort }),
-    ...(options.fast === true ? { serviceTier: "fast" } : {}),
-    ...(session.approvalPolicy === undefined
-      ? {}
-      : { approvalPolicy: session.approvalPolicy }),
-    ...(session.sandbox === undefined
-      ? {}
-      : { sandboxPolicy: codexSandboxPolicy(session.sandbox, options.cwd) }),
-  };
-}
-
-function codexSandboxPolicy(sandbox: string, cwd: string): JsonObject {
-  switch (sandbox) {
-    case "danger-full-access":
-      return { type: "dangerFullAccess" };
-    case "read-only":
-      return {
-        type: "readOnly",
-        access: { type: "fullAccess" },
-        networkAccess: false,
-      };
-    case "workspace-write":
-      return {
-        type: "workspaceWrite",
-        writableRoots: [cwd],
-        readOnlyAccess: { type: "fullAccess" },
-        networkAccess: false,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-      };
-    default:
-      throw new Error(`unsupported Codex sandbox mode: ${sandbox}`);
-  }
-}

package/src/dependencyStatus.ts

@@ -1,198 +0,0 @@
-/*
-- Date: 2026-04-28
-  Spec: plans/2026-04-28-npm-first-local-runner-onboarding.md
-  Relationship: Probes local runner dependencies before first-run onboarding
-  claims that Codex sessions and editor previews are ready from Kandan.
-*/
-import { spawn } from "node:child_process";
-import {
-  editorRuntimeStatusPayload,
-  type EditorRuntimeStatus,
-} from "./localEditorRuntime";
-import { type JsonObject } from "./protocol";
-
-export type ToolDependencyStatus = {
-  readonly command: string;
-  readonly available: boolean;
-  readonly version?: string | undefined;
-  readonly reason?:
-    | "not_configured"
-    | "editor_runtime_unavailable"
-    | "custom_runtime"
-    | undefined;
-};
-
-export type RunnerDependencyStatus = {
-  readonly bun: ToolDependencyStatus;
-  readonly codex: ToolDependencyStatus;
-  readonly codeServer: ToolDependencyStatus;
-  readonly editorRuntime?: EditorRuntimeStatus | undefined;
-};
-
-export function probeTool(command: string, cwd: string): Promise<ToolDependencyStatus> {
-  return new Promise((resolve) => {
-    const child = spawn(command, ["--version"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    let resolved = false;
-
-    const finish = (status: ToolDependencyStatus): void => {
-      if (resolved) {
-        return;
-      }
-
-      resolved = true;
-      clearTimeout(timeout);
-      resolve(status);
-    };
-
-    const timeout = setTimeout(() => {
-      child.kill("SIGKILL");
-      finish({ command, available: false });
-    }, 1_000);
-
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", () => {
-      finish({ command, available: false });
-    });
-    child.on("exit", (code) => {
-      if (code !== 0) {
-        finish({ command, available: false });
-        return;
-      }
-
-      const version = firstNonBlank(stdout, stderr);
-
-      finish(
-        version === undefined
-          ? { command, available: true }
-          : { command, available: true, version },
-      );
-    });
-  });
-}
-
-export async function buildRunnerDependencyStatus(args: {
-  readonly cwd: string;
-  readonly codexBin: string;
-  readonly codeServerBin?: string | undefined;
-  readonly editorRuntime?: EditorRuntimeStatus | undefined;
-}): Promise<RunnerDependencyStatus> {
-  const [bun, codex, codeServer] = await Promise.all([
-    probeTool(process.execPath, args.cwd),
-    probeTool(args.codexBin, args.cwd),
-    codeServerDependencyStatus(args),
-  ]);
-
-  return {
-    bun,
-    codex,
-    codeServer,
-    editorRuntime: args.editorRuntime,
-  };
-}
-
-function codeServerDependencyStatus(args: {
-  readonly cwd: string;
-  readonly codeServerBin?: string | undefined;
-  readonly editorRuntime?: EditorRuntimeStatus | undefined;
-}): Promise<ToolDependencyStatus> {
-  switch (args.editorRuntime?.status) {
-    case "ready":
-      return Promise.resolve({
-        command: args.codeServerBin ?? args.editorRuntime.codeServerBin,
-        available: true,
-        version: args.editorRuntime.codeServerVersion,
-      });
-    case "unavailable":
-      return Promise.resolve({
-        command: args.codeServerBin ?? "code-server",
-        available: false,
-        reason: "editor_runtime_unavailable",
-      });
-    case "custom":
-    case undefined:
-      break;
-  }
-
-  return args.codeServerBin === undefined
-    ? Promise.resolve({
-        command: "code-server",
-        available: false,
-        reason: "not_configured" as const,
-      })
-    : probeTool(args.codeServerBin, args.cwd);
-}
-
-export function assertStartDependencies(status: RunnerDependencyStatus): void {
-  if (!status.bun.available) {
-    throw new Error("Bun is not available. Install Bun, then rerun linzumi start.");
-  }
-
-  if (!status.codex.available) {
-    throw new Error(
-      `Codex is not available at ${status.codex.command}. Install Codex or pass --codex-bin <path>.`,
-    );
-  }
-
-  if (
-    status.editorRuntime?.status === "unavailable" ||
-    (status.codeServer?.available === false && status.codeServer.reason !== "not_configured")
-  ) {
-    throw new Error(
-      "The Kandan editor runtime is not available. Reconnect when the runtime update finishes or pass --code-server-bin <path> for a custom development runtime.",
-    );
-  }
-}
-
-export function dependencyStatusPayload(status: RunnerDependencyStatus): JsonObject {
-  const codeServer = status.codeServer ?? disabledCodeServerStatus();
-
-  return {
-    bun: toolPayload(status.bun),
-    codex: toolPayload(status.codex),
-    codeServer: toolPayload(codeServer),
-    editorRuntime:
-      status.editorRuntime === undefined
-        ? null
-        : editorRuntimeStatusPayload(status.editorRuntime),
-  };
-}
-
-function disabledCodeServerStatus(): ToolDependencyStatus {
-  return {
-    command: "code-server",
-    available: false,
-    reason: "not_configured",
-  };
-}
-
-function toolPayload(status: ToolDependencyStatus): JsonObject {
-  return {
-    command: status.command,
-    available: status.available,
-    version: status.version ?? null,
-    reason: status.reason ?? null,
-  };
-}
-
-function firstNonBlank(...values: readonly (string | undefined)[]): string | undefined {
-  for (const value of values) {
-    const trimmed = value?.trim();
-
-    if (trimmed !== undefined && trimmed !== "") {
-      return trimmed;
-    }
-  }
-
-  return undefined;
-}