@linzumi/cli 0.0.19-beta → 0.0.22-beta

package/src/channelSessionSupport.ts

@@ -1,308 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-quality-pass-spec.md
-  Relationship: Owns pure channel-session policy so the stateful runner can
-  stay focused on websocket lifecycle and Codex turn orchestration.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Keeps local Codex version discovery bounded so channel
-  availability is not blocked indefinitely by a bad executable.
-
-- Date: 2026-05-02
-  Spec: plans/2026-05-02-agent-first-zero-to-codex-launch-plan.md
-  Relationship: Keeps the npm CLI runner in parity with the legacy local
-  runner by carrying Kandan attachment metadata into queued Codex input.
-*/
-import { spawnSync } from "node:child_process";
-import { hostname } from "node:os";
-import { arrayValue, integerValue, objectValue, stringValue } from "./json";
-import { type JsonObject, type JsonValue, isJsonObject } from "./protocol";
-
-export type KandanChatAttachment = {
-  readonly id: string | undefined;
-  readonly kind: string | undefined;
-  readonly fileName: string | undefined;
-  readonly contentType: string | undefined;
-  readonly sizeBytes: number | undefined;
-  readonly url: string | undefined;
-};
-
-export type KandanChatEvent = {
-  readonly seq: number;
-  readonly type: string;
-  readonly actorKind: string | undefined;
-  readonly actorSlug: string | undefined;
-  readonly actorUserId: number | undefined;
-  readonly threadId: string | undefined;
-  readonly replyToSeq: number | undefined;
-  readonly localRunnerEventType: string | undefined;
-  readonly body: string;
-  readonly attachments: readonly KandanChatAttachment[];
-};
-
-export type RunnerIdentity = {
-  readonly actorUserId: number | undefined;
-  readonly actorUsername: string | undefined;
-};
-
-export type RunnerPayloadContext = {
-  readonly runnerIdentity: RunnerIdentity;
-  readonly codexVersion: string | undefined;
-};
-
-export type ChannelSessionSupportOptions = {
-  readonly runnerId: string;
-  readonly cwd: string;
-  readonly fast?: boolean | undefined;
-  readonly channelSession:
-    | {
-        readonly model?: string | undefined;
-        readonly reasoningEffort?: string | undefined;
-        readonly sandbox?: string | undefined;
-        readonly approvalPolicy?: string | undefined;
-      }
-    | undefined;
-};
-
-export function availabilityMessage(
-  options: ChannelSessionSupportOptions,
-  codexVersion: string | undefined,
-  codexThreadId: string,
-): string {
-  const session = options.channelSession;
-
-  return [
-    "Codex is ready.",
-    "",
-    "| Stat | Value |",
-    "| --- | --- |",
-    `| Host | ${markdownTableCell(hostname())} |`,
-    `| Directory | ${markdownTableCell(options.cwd)} |`,
-    `| Codex thread | ${markdownTableCell(codexThreadId)} |`,
-    `| Codex | ${markdownTableCell(codexVersion ?? "unknown")} |`,
-    `| Model | ${markdownTableCell(session?.model ?? "default")} |`,
-    `| Reasoning effort | ${markdownTableCell(session?.reasoningEffort ?? "default")} |`,
-    `| Fast mode | ${options.fast ? "yes" : "no"} |`,
-    `| Sandbox | ${markdownTableCell(session?.sandbox ?? "default")} |`,
-    `| Approval policy | ${markdownTableCell(session?.approvalPolicy ?? "default")} |`,
-    "",
-    "Reply in this thread to send a message to the local Codex session.",
-  ].join("\n");
-}
-
-function markdownTableCell(value: string): string {
-  return value
-    .replaceAll("\\", "\\\\")
-    .replaceAll("|", "\\|")
-    .replaceAll("\n", " ");
-}
-
-export function parseKandanChatEvent(
-  value: JsonValue,
-): KandanChatEvent | undefined {
-  if (!isJsonObject(value)) {
-    return undefined;
-  }
-
-  const payload = objectValue(value.payload) ?? {};
-  const actor = objectValue(value.actor);
-  const seq = integerValue(value.seq);
-  const type = stringValue(value.type);
-
-  if (seq === undefined || type === undefined) {
-    return undefined;
-  }
-
-  return {
-    seq,
-    type,
-    actorKind: stringValue(actor?.kind),
-    actorSlug: stringValue(actor?.slug),
-    actorUserId: integerValue(value.actor_user_id),
-    threadId: stringValue(payload.thread_id),
-    replyToSeq: integerValue(payload.reply_to_seq),
-    localRunnerEventType: localRunnerEventType(payload),
-    body:
-      stringValue(value.body) ??
-      stringValue(value.text) ??
-      stringValue(payload.body) ??
-      stringValue(payload.text) ??
-      "",
-    attachments: parseKandanChatAttachments(
-      arrayValue(payload.attachments) ?? arrayValue(value.attachments) ?? [],
-    ),
-  };
-}
-
-function parseKandanChatAttachments(
-  attachments: readonly JsonValue[],
-): readonly KandanChatAttachment[] {
-  return attachments.flatMap(attachment => {
-    const value = objectValue(attachment);
-
-    if (value === undefined) {
-      return [];
-    }
-
-    return [
-      {
-        id: stringValue(value.id),
-        kind: stringValue(value.kind),
-        fileName:
-          stringValue(value.file_name) ??
-          stringValue(value.fileName) ??
-          stringValue(value.name),
-        contentType:
-          stringValue(value.content_type) ??
-          stringValue(value.contentType) ??
-          stringValue(value.mime_type) ??
-          stringValue(value.mimeType),
-        sizeBytes:
-          integerValue(value.size_bytes) ??
-          integerValue(value.sizeBytes) ??
-          integerValue(value.size),
-        url: stringValue(value.url),
-      },
-    ];
-  });
-}
-
-export function isCodexAuthoredEvent(
-  event: Pick<
-    KandanChatEvent,
-    "actorKind" | "actorSlug" | "localRunnerEventType"
-  >,
-): boolean {
-  if (event.localRunnerEventType !== undefined) {
-    return true;
-  }
-
-  if (event.actorKind === "service" && event.actorSlug === "codex") {
-    return true;
-  }
-
-  return event.actorSlug === "codex";
-}
-
-export function senderAllowed(
-  listenUser: string,
-  event: Pick<KandanChatEvent, "actorSlug" | "actorUserId">,
-  runnerIdentity: RunnerIdentity,
-): boolean {
-  const normalized = listenUser.trim().toLocaleLowerCase();
-
-  if (normalized === "all") {
-    return true;
-  }
-
-  if (event.actorSlug !== undefined && event.actorSlug.toLocaleLowerCase() === normalized) {
-    return true;
-  }
-
-  return (
-    runnerIdentity.actorUsername?.toLocaleLowerCase() === normalized &&
-    runnerIdentity.actorUserId !== undefined &&
-    event.actorUserId === runnerIdentity.actorUserId
-  );
-}
-
-export function identityFromAccessToken(token: string): RunnerIdentity {
-  const [, payload] = token.split(".");
-
-  if (payload === undefined) {
-    return { actorUserId: undefined, actorUsername: undefined };
-  }
-
-  try {
-    const decoded = JSON.parse(
-      Buffer.from(base64UrlToBase64(payload), "base64").toString("utf8"),
-    );
-    const actorUserId =
-      integerValue(decoded.actor_id) ?? integerValue(decoded.sub);
-
-    return {
-      actorUserId,
-      actorUsername: stringValue(decoded.actor_username),
-    };
-  } catch (_error) {
-    return { actorUserId: undefined, actorUsername: undefined };
-  }
-}
-
-export function detectCodexVersion(
-  codexBin: string,
-  cwd: string,
-): string | undefined {
-  const result = spawnSync(codexBin, ["--version"], {
-    cwd,
-    encoding: "utf8",
-    timeout: 1_000,
-  });
-
-  if (result.error !== undefined || result.status !== 0) {
-    return undefined;
-  }
-
-  const version = stringValue(result.stdout) ?? stringValue(result.stderr);
-  const trimmed = version?.trim();
-
-  return trimmed === "" ? undefined : trimmed;
-}
-
-export function localRunnerPayload(
-  options: ChannelSessionSupportOptions,
-  instanceId: string,
-  eventType: string,
-  codexThreadId: string,
-  context: RunnerPayloadContext,
-  sourceMessageSeq?: number | undefined,
-  extraLocalRunnerMetadata?: JsonObject | undefined,
-): JsonObject {
-  return {
-    metadata: {
-      local_codex_runner: {
-        ...(extraLocalRunnerMetadata ?? {}),
-        runner_id: options.runnerId,
-        instance_id: instanceId,
-        event_type: eventType,
-        codex_thread_id: codexThreadId,
-        hostname: hostname(),
-        cwd: options.cwd,
-        codex_version: context.codexVersion ?? null,
-        model: options.channelSession?.model ?? null,
-        reasoning_effort: options.channelSession?.reasoningEffort ?? null,
-        fast: options.fast ?? false,
-        sandbox: options.channelSession?.sandbox ?? null,
-        approval_policy: options.channelSession?.approvalPolicy ?? null,
-        user_id: context.runnerIdentity.actorUserId ?? null,
-        ...(sourceMessageSeq === undefined
-          ? {}
-          : { source_message_seq: sourceMessageSeq }),
-      },
-    },
-  };
-}
-
-export function localRunnerEventType(payload: JsonObject): string | undefined {
-  const metadata = objectValue(payload.metadata);
-  const localRunner = objectValue(metadata?.local_codex_runner);
-
-  return stringValue(localRunner?.event_type);
-}
-
-function base64UrlToBase64(value: string): string {
-  const normalized = value.replaceAll("-", "+").replaceAll("_", "/");
-  const padding = normalized.length % 4;
-
-  switch (padding) {
-    case 0:
-      return normalized;
-    case 2:
-      return `${normalized}==`;
-    case 3:
-      return `${normalized}=`;
-    default:
-      return normalized;
-  }
-}

package/src/codexAppServer.ts

@@ -1,380 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-plan.md
-  Relationship: Implements the spec's local Codex app-server process/client
-  seam, including loopback binding and readiness before runner attachment.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Implements the spec requirement that the local runner is a
-  complete app-server JSON-RPC client: server-initiated requests must receive
-  a response instead of hanging active Codex turns indefinitely.
-*/
-import { spawn, type ChildProcess } from "node:child_process";
-import { createServer } from "node:net";
-import {
-  type JsonObject,
-  type JsonValue,
-  type JsonRpcId,
-  type JsonRpcMessage,
-  type JsonRpcNotification,
-  type JsonRpcRequest,
-  type JsonRpcResponse,
-  isJsonObject
-} from "./protocol";
-
-type PendingRequest = {
-  readonly resolve: (value: JsonRpcResponse) => void;
-  readonly reject: (error: Error) => void;
-};
-
-export type CodexAppServerClient = {
-  readonly request: (method: string, params?: JsonObject) => Promise<JsonRpcResponse>;
-  readonly notify: (method: string, params?: JsonObject) => void;
-  readonly onNotification: (callback: (message: JsonRpcNotification) => void) => void;
-  readonly onRequest?: (callback: (message: JsonRpcRequest) => JsonValue | Promise<JsonValue>) => void;
-  readonly close: () => void;
-};
-
-export type StartedCodexAppServer = {
-  readonly url: string;
-  readonly process: ChildProcess;
-};
-
-export type StartCodexAppServerOptions = {
-  readonly model?: string | undefined;
-  readonly reasoningEffort?: string | undefined;
-  readonly fast?: boolean | undefined;
-};
-
-export async function chooseLoopbackPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = createServer();
-
-    server.on("error", error => reject(error));
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-
-      if (typeof address === "object" && address !== null) {
-        const port = address.port;
-        server.close(error => {
-          if (error !== undefined) {
-            reject(error);
-          } else {
-            resolve(port);
-          }
-        });
-      } else {
-        server.close();
-        reject(new Error("failed to allocate loopback port"));
-      }
-    });
-  });
-}
-
-export async function startCodexAppServer(
-  codexBin: string,
-  cwd: string,
-  options: StartCodexAppServerOptions = {},
-): Promise<StartedCodexAppServer> {
-  const port = await chooseLoopbackPort();
-  const url = `ws://127.0.0.1:${port}`;
-  const child = spawn(codexBin, codexAppServerArgs(url, options), {
-    cwd,
-    env: process.env,
-    stdio: ["ignore", "inherit", "inherit"]
-  });
-
-  child.once("exit", code => {
-    if (code !== 0) {
-      process.stderr.write(`codex app-server exited with code ${code ?? "signal"}\n`);
-    }
-  });
-
-  try {
-    await waitForReadyz(url, child);
-  } catch (error) {
-    child.kill("SIGINT");
-    throw error;
-  }
-
-  return { url, process: child };
-}
-
-export function codexAppServerArgs(
-  listenUrl: string,
-  options: StartCodexAppServerOptions = {},
-): string[] {
-  return [
-    "app-server",
-    ...codexConfigArgs(options),
-    "--listen",
-    listenUrl,
-  ];
-}
-
-function codexConfigArgs(options: StartCodexAppServerOptions): string[] {
-  return [
-    ...(options.model === undefined ? [] : [
-      "-c",
-      `model=${JSON.stringify(options.model)}`,
-    ]),
-    ...(options.reasoningEffort === undefined ? [] : [
-      "-c",
-      `model_reasoning_effort=${JSON.stringify(options.reasoningEffort)}`,
-    ]),
-    ...(options.fast === true ? [
-      "-c",
-      `service_tier=${JSON.stringify("fast")}`,
-    ] : []),
-  ];
-}
-
-export async function connectCodexAppServer(
-  websocketUrl: string,
-  socketFactory: (url: string) => WebSocket = url => new WebSocket(url)
-): Promise<CodexAppServerClient> {
-  const websocket = socketFactory(websocketUrl);
-  const pending = new Map<JsonRpcId, PendingRequest>();
-  const notificationCallbacks = new Set<(message: JsonRpcNotification) => void>();
-  const requestCallbacks = new Set<(message: JsonRpcRequest) => JsonValue | Promise<JsonValue>>();
-  const pendingNotifications: JsonRpcNotification[] = [];
-  const state = { nextId: 1 };
-  const rejectPending = (message: string) => {
-    const error = new Error(message);
-    pending.forEach(pendingRequest => pendingRequest.reject(error));
-    pending.clear();
-  };
-
-  websocket.addEventListener("close", () => rejectPending("codex app-server websocket closed"));
-  websocket.addEventListener("error", () => rejectPending("codex app-server websocket error"));
-
-  websocket.addEventListener("message", event => {
-    const parsed = JSON.parse(String(event.data));
-
-    if (!isJsonObject(parsed)) {
-      throw new Error("codex app-server sent non-object JSON-RPC message");
-    }
-
-    const message = parsed as JsonRpcMessage;
-
-    if ("id" in message && ("result" in message || "error" in message)) {
-      const pendingRequest = pending.get(message.id);
-
-      if (pendingRequest !== undefined) {
-        pending.delete(message.id);
-        pendingRequest.resolve(message);
-      }
-      return;
-    }
-
-    if ("id" in message && typeof message.method === "string") {
-      void respondToServerRequest(websocket, message as JsonRpcRequest, requestCallbacks);
-      return;
-    }
-
-    if (!("id" in message) && typeof message.method === "string") {
-      const notification = message as JsonRpcNotification;
-
-      if (notificationCallbacks.size === 0) {
-        pendingNotifications.push(notification);
-      } else {
-        notificationCallbacks.forEach(callback => callback(notification));
-      }
-    }
-  });
-
-  await waitForOpen(websocket);
-  await initialize(websocket, pending);
-
-  const request = (method: string, params?: JsonObject): Promise<JsonRpcResponse> => {
-    const id = state.nextId;
-    state.nextId += 1;
-    const message: JsonRpcRequest =
-      params === undefined
-        ? { jsonrpc: "2.0", id, method }
-        : { jsonrpc: "2.0", id, method, params };
-
-    return sendRequest(websocket, pending, message);
-  };
-
-  return {
-    request,
-    notify: (method, params) => {
-      const message =
-        params === undefined
-          ? { jsonrpc: "2.0", method }
-          : { jsonrpc: "2.0", method, params };
-      websocket.send(JSON.stringify(message));
-    },
-    onNotification: callback => {
-      notificationCallbacks.add(callback);
-      pendingNotifications.splice(0).forEach(notification => callback(notification));
-    },
-    onRequest: callback => {
-      requestCallbacks.add(callback);
-    },
-    close: () => websocket.close()
-  };
-}
-
-async function respondToServerRequest(
-  websocket: WebSocket,
-  request: JsonRpcRequest,
-  callbacks: Set<(message: JsonRpcRequest) => JsonValue | Promise<JsonValue>>,
-): Promise<void> {
-  try {
-    if (callbacks.size === 0) {
-      websocket.send(JSON.stringify({
-        jsonrpc: "2.0",
-        id: request.id,
-        error: {
-          code: -32601,
-          message: `unhandled Codex app-server request: ${request.method}`,
-        },
-      }));
-      return;
-    }
-
-    const callback = Array.from(callbacks)[0];
-
-    if (callback === undefined) {
-      throw new Error(`unhandled Codex app-server request: ${request.method}`);
-    }
-
-    const result = await callback(request);
-    websocket.send(JSON.stringify({ jsonrpc: "2.0", id: request.id, result }));
-  } catch (error) {
-    websocket.send(JSON.stringify({
-      jsonrpc: "2.0",
-      id: request.id,
-      error: {
-        code: -32000,
-        message: error instanceof Error ? error.message : String(error),
-      },
-    }));
-  }
-}
-
-async function initialize(
-  websocket: WebSocket,
-  pending: Map<JsonRpcId, PendingRequest>
-): Promise<void> {
-  const response = await sendRequest(websocket, pending, {
-    jsonrpc: "2.0",
-    id: "initialize",
-    method: "initialize",
-    params: {
-      clientInfo: {
-        name: "kandan-local-codex-runner",
-        version: "0.0.1"
-      },
-      capabilities: {
-        experimentalApi: true
-      }
-    }
-  });
-
-  if ("error" in response) {
-    throw new Error(`codex initialize failed: ${response.error.message}`);
-  }
-
-  websocket.send(JSON.stringify({ jsonrpc: "2.0", method: "initialized" }));
-}
-
-function sendRequest(
-  websocket: WebSocket,
-  pending: Map<JsonRpcId, PendingRequest>,
-  message: JsonRpcRequest
-): Promise<JsonRpcResponse> {
-  if (websocket.readyState !== WebSocket.OPEN) {
-    return Promise.reject(new Error("codex app-server websocket is not open"));
-  }
-
-  return new Promise((resolve, reject) => {
-    pending.set(message.id, { resolve, reject });
-    websocket.send(JSON.stringify(message));
-  });
-}
-
-function waitForOpen(websocket: WebSocket): Promise<void> {
-  return new Promise((resolve, reject) => {
-    websocket.addEventListener("open", () => resolve(), { once: true });
-    websocket.addEventListener("error", () => reject(new Error("websocket open failed")), {
-      once: true
-    });
-  });
-}
-
-function waitForReadyz(
-  websocketUrl: string,
-  child: ChildProcess,
-  timeoutMs = 10_000
-): Promise<void> {
-  const readyzUrl = readyzUrlForWebsocket(websocketUrl);
-  const deadline = Date.now() + timeoutMs;
-
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-
-    const finish = (result: "ready" | Error) => {
-      if (settled) {
-        return;
-      }
-
-      settled = true;
-
-      if (timer !== undefined) {
-        clearTimeout(timer);
-      }
-
-      child.off("exit", onExit);
-
-      if (result === "ready") {
-        resolve();
-      } else {
-        reject(result);
-      }
-    };
-
-    const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
-      finish(new Error(`codex app-server exited before readyz: ${code ?? signal ?? "unknown"}`));
-    };
-
-    const scheduleCheck = () => {
-      timer = setTimeout(checkReadyz, 50);
-    };
-
-    const checkReadyz = async () => {
-      if (Date.now() > deadline) {
-        finish(new Error("timed out waiting for codex app-server readyz"));
-        return;
-      }
-
-      try {
-        const response = await fetch(readyzUrl);
-
-        if (response.ok) {
-          finish("ready");
-        } else {
-          scheduleCheck();
-        }
-      } catch (_error) {
-        scheduleCheck();
-      }
-    };
-
-    child.once("exit", onExit);
-    void checkReadyz();
-  });
-}
-
-function readyzUrlForWebsocket(websocketUrl: string): string {
-  const parsed = new URL(websocketUrl);
-  parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
-  parsed.pathname = "/readyz";
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString();
-}