@linzumi/cli 0.0.19-beta → 0.0.22-beta

package/src/json.ts

@@ -1,49 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Provides small JSON readers used by the local runner's
-  channel binding and Codex transcript normalization without ad hoc casts.
-*/
-import { type JsonObject, type JsonValue, isJsonObject } from "./protocol";
-
-export function objectValue(value: JsonValue | undefined): JsonObject | undefined {
-  return value !== undefined && isJsonObject(value) ? value : undefined;
-}
-
-export function arrayValue(
-  value: JsonValue | undefined,
-): readonly JsonValue[] | undefined {
-  return Array.isArray(value) ? value : undefined;
-}
-
-export function stringValue(value: JsonValue | undefined): string | undefined {
-  return typeof value === "string" && value.trim() !== ""
-    ? value.trim()
-    : undefined;
-}
-
-export function integerValue(value: JsonValue | undefined): number | undefined {
-  return typeof value === "number" && Number.isInteger(value)
-    ? value
-    : undefined;
-}
-
-export function stringListValue(value: JsonValue | undefined): string[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-
-  return value.flatMap((entry) => {
-    const normalized = stringValue(entry);
-    return normalized === undefined ? [] : [normalized];
-  });
-}
-
-export function parseJsonObjectOrUndefined(text: string): JsonObject | undefined {
-  try {
-    const parsed: unknown = JSON.parse(text);
-    return isJsonObject(parsed) ? parsed : undefined;
-  } catch (_error) {
-    return undefined;
-  }
-}

package/src/kandanQueue.ts

@@ -1,113 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Owns deterministic queue formatting and interrupt fusion for
-  Kandan thread replies before they are sent into local Codex.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Carries selected queued message seqs through interrupt fusion
-  so the UI can show which pending replies were accepted by the interrupt.
-
-- Date: 2026-05-02
-  Spec: plans/2026-05-02-agent-first-zero-to-codex-launch-plan.md
-  Relationship: Carries Kandan attachment metadata through npm CLI runner queue
-  fusion so attachment-backed replies stay intact before Codex sees them.
-*/
-import { type KandanChatAttachment } from "./channelSessionSupport";
-
-export type QueuedKandanAttachment = KandanChatAttachment;
-
-export type QueuedKandanMessage = {
-  readonly seq: number;
-  readonly actorSlug: string | undefined;
-  readonly actorUserId: number | undefined;
-  readonly body: string;
-  readonly attachments: readonly QueuedKandanAttachment[];
-};
-
-export type QueueInterruptResult =
-  | {
-      readonly ok: true;
-      readonly queue: QueuedKandanMessage[];
-      readonly selectedCount: number;
-      readonly selectedSeqs: number[];
-      readonly remainingCount: number;
-    }
-  | {
-      readonly ok: false;
-      readonly reason: "queue_empty";
-    };
-
-export function formatQueuedKandanMessage(message: QueuedKandanMessage): string {
-  const sender =
-    message.actorSlug === undefined || message.actorSlug.trim() === ""
-      ? "unknown"
-      : message.actorSlug.trim();
-  const userId =
-    message.actorUserId === undefined
-      ? "unknown"
-      : message.actorUserId.toString();
-
-  return [
-    `Kandan message seq=${message.seq} from ${sender} (user_id=${userId}):`,
-    "",
-    message.body,
-  ].join("\n");
-}
-
-export function codexInputForQueuedKandanMessage(message: QueuedKandanMessage): string {
-  const command = message.body.trimStart();
-
-  return command.startsWith("!") ? command : formatQueuedKandanMessage(message);
-}
-
-export function interruptQueuedMessages(
-  queue: readonly QueuedKandanMessage[],
-  throughSeq: number | undefined,
-): QueueInterruptResult {
-  const selected =
-    throughSeq === undefined
-      ? Array.from(queue)
-      : queue.filter((message) => message.seq <= throughSeq);
-  const remaining =
-    throughSeq === undefined
-      ? []
-      : queue.filter((message) => message.seq > throughSeq);
-
-  if (selected.length === 0) {
-    return { ok: false, reason: "queue_empty" };
-  }
-
-  const fused = fuseQueuedMessages(selected);
-
-  if (fused === undefined) {
-    return { ok: false, reason: "queue_empty" };
-  }
-
-  return {
-    ok: true,
-    queue: [fused, ...remaining],
-    selectedCount: selected.length,
-    selectedSeqs: selected.map(message => message.seq),
-    remainingCount: remaining.length,
-  };
-}
-
-function fuseQueuedMessages(
-  selected: readonly QueuedKandanMessage[],
-): QueuedKandanMessage | undefined {
-  const last = selected[selected.length - 1];
-
-  if (last === undefined) {
-    return undefined;
-  }
-
-  return {
-    seq: last.seq,
-    actorSlug: "kandan",
-    actorUserId: undefined,
-    body: selected.map(codexInputForQueuedKandanMessage).join("\n\n---\n\n"),
-    attachments: selected.flatMap(message => message.attachments),
-  };
-}

package/src/kandanTls.ts

@@ -1,86 +0,0 @@
-/*
-- Date: 2026-04-29
-  Spec: kandan/server_v2/plans/2026-04-29-local-runner-editor-runtime-distribution-note.md
-  Relationship: Lets local proof and development runners trust a specific
-  Kandan CA certificate without disabling TLS verification globally.
-*/
-import { existsSync } from "node:fs";
-
-type BunRuntime = {
-  readonly file: (path: string) => unknown;
-};
-
-type TlsFetchInit = RequestInit & {
-  readonly tls?: {
-    readonly ca: unknown;
-  };
-};
-
-type TlsWebSocketOptions = {
-  readonly tls?: {
-    readonly ca: unknown;
-  };
-};
-
-export type KandanTlsTrust = {
-  readonly caFile: string;
-  readonly ca: unknown;
-};
-
-export function kandanTlsTrustFromEnv(): KandanTlsTrust | undefined {
-  return kandanTlsTrustFromCaFile(process.env.KANDAN_TLS_CA_FILE);
-}
-
-export function kandanTlsTrustFromCaFile(caFile: string | undefined): KandanTlsTrust | undefined {
-  if (caFile === undefined || caFile.trim() === "") {
-    return undefined;
-  }
-
-  const trimmed = caFile.trim();
-  if (!existsSync(trimmed)) {
-    throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
-  }
-
-  const bun = (globalThis as unknown as { readonly Bun?: BunRuntime }).Bun;
-  if (bun === undefined) {
-    throw new Error("KANDAN_TLS_CA_FILE requires the Bun runtime");
-  }
-
-  return {
-    caFile: trimmed,
-    ca: bun.file(trimmed),
-  };
-}
-
-export function trustedFetch(
-  trust: KandanTlsTrust | undefined,
-): typeof fetch {
-  if (trust === undefined) {
-    return fetch;
-  }
-
-  return ((input: URL | RequestInfo, init?: RequestInit) => {
-    const request = {
-      ...(init ?? {}),
-      tls: {
-        ca: trust.ca,
-      },
-    } satisfies TlsFetchInit;
-    return fetch(input, request);
-  }) as typeof fetch;
-}
-
-export function trustedWebSocketFactory(
-  trust: KandanTlsTrust | undefined,
-): ((url: string) => WebSocket) | undefined {
-  if (trust === undefined) {
-    return undefined;
-  }
-
-  return (url) =>
-    new WebSocket(url, {
-      tls: {
-        ca: trust.ca,
-      },
-    } as TlsWebSocketOptions);
-}

package/src/localCapabilities.ts

@@ -1,143 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Defines the local machine capability boundary for Kandan-
-  requested Codex session starts and future preview forwarding. Remote starts
-  are allowed only inside explicitly configured local cwd roots, and preview
-  forwarding is advertised only for explicitly configured local ports.
-*/
-import { realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, relative, resolve } from "node:path";
-
-export type CwdCapabilityDecision =
-  | {
-      readonly ok: true;
-      readonly cwd: string;
-      readonly matchedRoot: string;
-    }
-  | {
-      readonly ok: false;
-      readonly reason:
-        | "missing_cwd"
-        | "no_allowed_cwd"
-        | "cwd_not_allowed"
-        | "cwd_not_found";
-    };
-
-export function parseAllowedCwdList(value: string | undefined): string[] {
-  if (value === undefined) {
-    return [];
-  }
-
-  return value
-    .split(",")
-    .map((part) => part.trim())
-    .filter((part) => part !== "");
-}
-
-export function parseAllowedPortList(value: string | undefined): number[] {
-  if (value === undefined) {
-    return [];
-  }
-
-  const ports = new Set<number>();
-
-  for (const part of value.split(",")) {
-    const trimmed = part.trim();
-
-    if (trimmed === "") {
-      continue;
-    }
-
-    const port = Number(trimmed);
-
-    if (!Number.isInteger(port) || port < 1 || port > 65_535) {
-      throw new Error(`invalid --forward-port: ${trimmed} is not a TCP port`);
-    }
-
-    ports.add(port);
-  }
-
-  return [...ports].sort((left, right) => left - right);
-}
-
-export function assertConfiguredAllowedCwds(
-  paths: readonly string[],
-): string[] {
-  return paths.map((path) => {
-    try {
-      return realpathSync(resolve(expandUserPath(path)));
-    } catch (_error) {
-      throw new Error(`invalid --allowed-cwd: ${path} does not exist`);
-    }
-  });
-}
-
-export function expandUserPath(pathValue: string): string {
-  if (pathValue === "~") {
-    return homedir();
-  }
-
-  if (pathValue.startsWith("~/")) {
-    return resolve(homedir(), pathValue.slice(2));
-  }
-
-  return pathValue;
-}
-
-export function resolveAllowedCwd(
-  requestedCwd: string | undefined,
-  allowedRoots: readonly string[],
-): CwdCapabilityDecision {
-  if (requestedCwd === undefined || requestedCwd.trim() === "") {
-    return { ok: false, reason: "missing_cwd" };
-  }
-
-  if (allowedRoots.length === 0) {
-    return { ok: false, reason: "no_allowed_cwd" };
-  }
-
-  let cwd: string;
-
-  try {
-    cwd = realpathSync(resolve(requestedCwd));
-  } catch (_error) {
-    return { ok: false, reason: "cwd_not_found" };
-  }
-
-  const matchedRoot = allowedRoots.find((root) =>
-    cwdIsInsideNormalizedRoot(cwd, root),
-  );
-
-  return matchedRoot === undefined
-    ? { ok: false, reason: "cwd_not_allowed" }
-    : { ok: true, cwd, matchedRoot };
-}
-
-function cwdIsInsideNormalizedRoot(
-  cwd: string,
-  normalizedRoot: string,
-): boolean {
-  return relativePathIsInsideRoot(relative(normalizedRoot, cwd));
-}
-
-export function relativePathIsInsideRoot(pathRelativeToRoot: string): boolean {
-  return (
-    pathRelativeToRoot === "" ||
-    (!pathLooksAbsolute(pathRelativeToRoot) &&
-      pathRelativeToRoot !== ".." &&
-      !pathRelativeToRoot.startsWith("../") &&
-      !pathRelativeToRoot.startsWith("..\\") &&
-      !pathRelativeToRoot.includes("/../") &&
-      !pathRelativeToRoot.includes("\\..\\"))
-  );
-}
-
-function pathLooksAbsolute(pathValue: string): boolean {
-  return (
-    isAbsolute(pathValue) ||
-    /^[A-Za-z]:[\\/]/.test(pathValue) ||
-    pathValue.startsWith("\\\\")
-  );
-}

package/src/localCodexMessageState.ts

@@ -1,135 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Defines the user-visible local Codex message state model and
-  the Codex notification-to-state mapping used by Kandan to show queued,
-  processing, approval, failed, ignored, and processed states consistently.
-
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-runner-port-forward-approval.md
-  Relationship: Allows local runner approval states to carry explicit
-  UI choices so descendant port-forward prompts can reuse the existing
-  Kandan approval bottom bar.
-*/
-import { objectValue, stringValue } from "./json";
-import type { JsonObject, JsonRpcRequest } from "./protocol";
-
-export type LocalCodexProcessingReason =
-  | "starting turn"
-  | "streaming response"
-  | "running terminal command"
-  | "interrupt requested"
-  | "awaiting approval";
-
-export type CodexApprovalMessageState = {
-  readonly requestId: string;
-  readonly kind: string;
-  readonly summary: string;
-  readonly reason?: string | undefined;
-  readonly choices?: readonly ApprovalChoice[] | undefined;
-  readonly allowedActorSlug?: string | undefined;
-  readonly allowedActorUserId?: number | undefined;
-};
-
-export type ApprovalChoice = {
-  readonly decision: string;
-  readonly label: string;
-  readonly description?: string | undefined;
-};
-
-export type ActiveProcessingState =
-  | {
-      readonly seq: number;
-      readonly reason: Exclude<LocalCodexProcessingReason, "awaiting approval">;
-    }
-  | {
-      readonly seq: number;
-      readonly reason: "awaiting approval";
-      readonly approval: CodexApprovalMessageState;
-    };
-
-export type LocalCodexMessageState =
-  | { readonly status: "queued" }
-  | { readonly status: "processed" }
-  | {
-      readonly status: "processing";
-      readonly reason: LocalCodexProcessingReason;
-      readonly approval?: CodexApprovalMessageState | undefined;
-    }
-  | { readonly status: "ignored"; readonly reason: string }
-  | { readonly status: "failed"; readonly reason: string };
-
-export function codexApprovalMessageState(
-  request: JsonRpcRequest,
-): CodexApprovalMessageState {
-  const params = objectValue(request.params) ?? {};
-  const command = stringValue(params.command) ?? stringValue(params.cmd);
-  const filePath =
-    stringValue(params.path) ??
-    stringValue(params.filePath) ??
-    stringValue(params.file);
-  const summary =
-    command ??
-    filePath ??
-    stringValue(params.reason) ??
-    stringValue(params.summary) ??
-    request.method;
-
-  return {
-    requestId: String(request.id),
-    kind: request.method,
-    summary,
-  };
-}
-
-export function approvalRequestKey(requestId: string, sourceSeq: number): string {
-  return `${sourceSeq}:${requestId}`;
-}
-
-export function processingReasonForCodexNotification(
-  method: string,
-  params: JsonObject,
-): Exclude<LocalCodexProcessingReason, "awaiting approval"> | undefined {
-  if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta") {
-    return "streaming response";
-  }
-
-  if (
-    method.startsWith("item/commandExecution/") ||
-    method === "command/exec/outputDelta"
-  ) {
-    return "running terminal command";
-  }
-
-  const item = objectValue(params.item) ?? params;
-  const itemType = stringValue(item.type);
-
-  switch (itemType) {
-    case "commandExecution":
-    case "terminalInput":
-      return "running terminal command";
-    case "agentMessage":
-    case "reasoning":
-    case "fileChange":
-    case "web_search_call":
-    case "webSearchCall":
-    case "webSearch":
-      return "streaming response";
-    default:
-      return undefined;
-  }
-}
-
-export function processingMessageStateFromActive(
-  state: ActiveProcessingState,
-): Extract<LocalCodexMessageState, { readonly status: "processing" }> {
-  switch (state.reason) {
-    case "awaiting approval":
-      return { status: "processing", reason: state.reason, approval: state.approval };
-    case "starting turn":
-    case "streaming response":
-    case "running terminal command":
-    case "interrupt requested":
-      return { status: "processing", reason: state.reason };
-  }
-}

package/src/localCodexTurnState.ts

@@ -1,108 +0,0 @@
-/*
-- Date: 2026-04-26
-  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
-  Relationship: Defines the pure local Codex turn lifecycle helpers used by
-  the channel-session orchestrator for interruption, active-turn lookup,
-  completion, failure cleanup, and forwarding eligibility.
-*/
-
-export type TurnState =
-  | { readonly status: "idle" }
-  | {
-      readonly status: "starting";
-      readonly queuedSeq: number;
-      readonly interruptAfterStart: boolean;
-    }
-  | { readonly status: "active"; readonly turnId: string; readonly queuedSeq: number }
-  | { readonly status: "completing"; readonly turnId: string; readonly queuedSeq: number };
-
-export function activeTurnId(turn: TurnState): string | undefined {
-  switch (turn.status) {
-    case "active":
-    case "completing":
-      return turn.turnId;
-    case "idle":
-    case "starting":
-      return undefined;
-  }
-}
-
-export function activeQueuedSeqForTurn(
-  turn: TurnState,
-  turnId: string,
-): number | undefined {
-  switch (turn.status) {
-    case "active":
-    case "completing":
-      return turn.turnId === turnId ? turn.queuedSeq : undefined;
-    case "idle":
-    case "starting":
-      return undefined;
-  }
-}
-
-export function interruptibleQueuedSeq(turn: TurnState): number | undefined {
-  switch (turn.status) {
-    case "active":
-    case "starting":
-      return turn.queuedSeq;
-    case "idle":
-    case "completing":
-      return undefined;
-  }
-}
-
-export function markInterruptAfterStart(turn: TurnState): TurnState {
-  switch (turn.status) {
-    case "starting":
-      return {
-        status: "starting",
-        queuedSeq: turn.queuedSeq,
-        interruptAfterStart: true,
-      };
-    case "idle":
-    case "active":
-    case "completing":
-      return turn;
-  }
-}
-
-export function turnCanForwardByState(turn: TurnState, turnId: string): boolean {
-  switch (turn.status) {
-    case "active":
-    case "completing":
-      return turn.turnId === turnId;
-    case "idle":
-    case "starting":
-      return false;
-  }
-}
-
-export function completingQueuedSeqForTurn(
-  turn: TurnState,
-  turnId: string,
-): number | undefined {
-  switch (turn.status) {
-    case "active":
-      return turn.turnId === turnId ? turn.queuedSeq : undefined;
-    case "idle":
-    case "starting":
-    case "completing":
-      return undefined;
-  }
-}
-
-export function shouldClearTurnAfterFailure(
-  turn: TurnState,
-  turnId: string,
-): boolean {
-  switch (turn.status) {
-    case "starting":
-      return true;
-    case "active":
-    case "completing":
-      return turn.turnId === turnId;
-    case "idle":
-      return false;
-  }
-}