@linzumi/cli 0.0.19-beta → 0.0.22-beta

package/src/phoenix.ts

@@ -1,359 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-plan.md
-  Relationship: Implements the spec's runner-to-Kandan Phoenix websocket
-  transport for structured runner events and server control pushes.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-thread-binding-spec.md
-  Relationship: Exposes server-pushed chat events to the channel-bound runner
-  so Kandan thread replies can drive the local Codex session.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Treats the Kandan websocket as a reconnectable transport so
-  server restarts do not terminate the durable local Codex session.
-
-- Date: 2026-04-26
-  Spec: plans/2026_04_26_linzumi_cli_review_followups_note.md
-  Relationship: Treats non-ok Phoenix replies for runner pushes as transport
-  failures so failed Kandan writes cannot be mistaken for synchronized state.
-*/
-import {
-  type JsonObject,
-  type JsonValue,
-  type KandanControl,
-  type PhoenixFrame,
-  isJsonObject
-} from "./protocol";
-
-type PendingPush = {
-  readonly event: string;
-  readonly resolve: (payload: JsonValue) => void;
-  readonly reject: (error: Error) => void;
-};
-
-type JoinRegistration = {
-  readonly payload: () => JsonObject;
-};
-
-export type PhoenixClient = {
-  readonly join: (
-    topic: string,
-    payload: JsonObject,
-    options?: { readonly rejoinPayload?: (() => JsonObject) | undefined }
-  ) => Promise<JsonObject>;
-  readonly push: (topic: string, event: string, payload: JsonObject) => Promise<JsonValue>;
-  readonly onControl: (callback: (control: KandanControl) => void) => void;
-  readonly onEvent: (
-    callback: (topic: string, event: string, payload: JsonValue) => void
-  ) => void;
-  readonly onReconnect: (callback: () => void | Promise<void>) => void;
-  readonly close: () => void;
-};
-
-export function phoenixWebsocketUrl(baseUrl: string, token: string): string {
-  const parsed = new URL(baseUrl);
-  switch (parsed.protocol) {
-    case "http:":
-      parsed.protocol = "ws:";
-      break;
-    case "https:":
-      parsed.protocol = "wss:";
-      break;
-  }
-  parsed.pathname = parsed.pathname.replace(/\/$/, "") + "/socket/websocket";
-  parsed.searchParams.set("token", token);
-  parsed.searchParams.set("vsn", "2.0.0");
-  return parsed.toString();
-}
-
-export async function connectPhoenixClient(
-  baseUrl: string,
-  token: string,
-  socketFactory: (url: string) => WebSocket = url => new WebSocket(url)
-): Promise<PhoenixClient> {
-  const pending = new Map<string, PendingPush>();
-  const joins = new Map<string, JoinRegistration>();
-  const controlCallbacks = new Set<(control: KandanControl) => void>();
-  const eventCallbacks = new Set<(topic: string, event: string, payload: JsonValue) => void>();
-  const reconnectCallbacks = new Set<() => void | Promise<void>>();
-  const state: {
-    nextRef: number;
-    websocket: WebSocket | undefined;
-    closed: boolean;
-    connected: boolean;
-    hasEverConnected: boolean;
-    connectionGeneration: number;
-    ready: Promise<void>;
-    resolveReady: (() => void) | undefined;
-    rejectReady: ((error: Error) => void) | undefined;
-    reconnectTimer: ReturnType<typeof setTimeout> | undefined;
-  } = {
-    nextRef: 1,
-    websocket: undefined,
-    closed: false,
-    connected: false,
-    hasEverConnected: false,
-    connectionGeneration: 0,
-    ready: Promise.resolve(),
-    resolveReady: undefined,
-    rejectReady: undefined,
-    reconnectTimer: undefined,
-  };
-  const rejectPending = (message: string) => {
-    const error = new Error(message);
-    pending.forEach(pendingPush => pendingPush.reject(error));
-    pending.clear();
-  };
-
-  const resetReady = () => {
-    state.ready = new Promise((resolve, reject) => {
-      state.resolveReady = resolve;
-      state.rejectReady = reject;
-    });
-  };
-
-  const handleMessage = (event: MessageEvent) => {
-    const frame = decodeFrame(String(event.data));
-    const [, ref, topic, name, payload] = frame;
-
-    if (ref !== null && (name === "phx_reply" || name === "phx_error")) {
-      const pendingPush = pending.get(ref);
-
-      if (pendingPush !== undefined) {
-        pending.delete(ref);
-
-        if (name === "phx_error") {
-          pendingPush.reject(new Error("phoenix push failed"));
-        } else if (isNonOkPushReply(payload) && pendingPush.event !== "phx_join") {
-          pendingPush.reject(new Error(`phoenix push failed: ${replyErrorMessage(payload)}`));
-        } else {
-          pendingPush.resolve(payload);
-        }
-      }
-    }
-
-    if (topic.startsWith("local_runner:") && name === "control" && isKandanControl(payload)) {
-      controlCallbacks.forEach(callback => callback(payload));
-    }
-
-    if (ref === null && name !== "phx_reply" && name !== "phx_error") {
-      eventCallbacks.forEach(callback => callback(topic, name, payload));
-    }
-  };
-
-  const pushOnOpenSocket = (
-    topic: string,
-    event: string,
-    payload: JsonObject
-  ): Promise<JsonValue> => {
-    const websocket = state.websocket;
-
-    if (websocket === undefined || websocket.readyState !== WebSocket.OPEN) {
-      return Promise.reject(new Error("phoenix websocket is not open"));
-    }
-
-    const ref = String(state.nextRef);
-    state.nextRef += 1;
-    const frame: PhoenixFrame = [null, ref, topic, event, payload];
-
-    return new Promise((resolve, reject) => {
-      pending.set(ref, { event, resolve, reject });
-      websocket.send(JSON.stringify(frame));
-    });
-  };
-
-  const replayJoins = async () => {
-    for (const [topic, registration] of joins) {
-      const reply = await pushOnOpenSocket(topic, "phx_join", registration.payload());
-
-      if (!isJoinReply(reply)) {
-        throw new Error(`phoenix rejoin failed for ${topic}`);
-      }
-    }
-  };
-
-  const scheduleReconnect = () => {
-    if (state.closed || state.reconnectTimer !== undefined) {
-      return;
-    }
-
-    resetReady();
-    state.reconnectTimer = setTimeout(() => {
-      state.reconnectTimer = undefined;
-      void openSocket();
-    }, 250);
-  };
-
-  const handleDisconnect = (message: string) => {
-    state.connected = false;
-    rejectPending(message);
-    scheduleReconnect();
-  };
-
-  const openSocket = async (): Promise<void> => {
-    if (state.closed) {
-      return;
-    }
-
-    const websocket = socketFactory(phoenixWebsocketUrl(baseUrl, token));
-    state.websocket = websocket;
-    websocket.addEventListener("message", handleMessage);
-    websocket.addEventListener(
-      "close",
-      () => {
-        if (state.websocket === websocket) {
-          handleDisconnect("phoenix websocket closed");
-        }
-      },
-      { once: true },
-    );
-    websocket.addEventListener(
-      "error",
-      () => {
-        if (state.websocket === websocket) {
-          handleDisconnect("phoenix websocket error");
-        }
-      },
-      { once: true },
-    );
-
-    try {
-      await waitForOpen(websocket);
-      state.connectionGeneration += 1;
-      await replayJoins();
-      state.connected = true;
-      state.hasEverConnected = true;
-      state.resolveReady?.();
-
-      if (state.connectionGeneration > 1) {
-        reconnectCallbacks.forEach(callback => {
-          void Promise.resolve(callback()).catch(() => undefined);
-        });
-      }
-    } catch (error) {
-      if (!state.closed) {
-        if (!state.hasEverConnected) {
-          state.rejectReady?.(error instanceof Error ? error : new Error(String(error)));
-        }
-        handleDisconnect("phoenix websocket reconnect failed");
-      }
-    }
-  };
-
-  resetReady();
-  void openSocket();
-  await state.ready;
-
-  const push = async (
-    topic: string,
-    event: string,
-    payload: JsonObject
-  ): Promise<JsonValue> => {
-    await state.ready;
-    return pushOnOpenSocket(topic, event, payload);
-  };
-
-  return {
-    join: async (topic, payload, options) => {
-      const reply = await push(topic, "phx_join", payload);
-
-      if (isJoinReply(reply)) {
-        joins.set(topic, { payload: options?.rejoinPayload ?? (() => payload) });
-        return reply.response;
-      }
-
-      throw new Error(`phoenix join failed: ${joinErrorMessage(reply)}`);
-    },
-    push,
-    onControl: callback => {
-      controlCallbacks.add(callback);
-    },
-    onEvent: callback => {
-      eventCallbacks.add(callback);
-    },
-    onReconnect: callback => {
-      reconnectCallbacks.add(callback);
-    },
-    close: () => {
-      state.closed = true;
-      if (state.reconnectTimer !== undefined) {
-        clearTimeout(state.reconnectTimer);
-      }
-      state.websocket?.close();
-      rejectPending("phoenix websocket closed");
-    }
-  };
-}
-
-export function encodeFrame(frame: PhoenixFrame): string {
-  return JSON.stringify(frame);
-}
-
-export function decodeFrame(text: string): PhoenixFrame {
-  const parsed = JSON.parse(text);
-
-  if (
-    Array.isArray(parsed) &&
-    parsed.length === 5 &&
-    (parsed[0] === null || typeof parsed[0] === "string") &&
-    (parsed[1] === null || typeof parsed[1] === "string") &&
-    typeof parsed[2] === "string" &&
-    typeof parsed[3] === "string"
-  ) {
-    return parsed as unknown as PhoenixFrame;
-  }
-
-  throw new Error("invalid Phoenix frame");
-}
-
-function isJoinReply(value: JsonValue): value is {
-  readonly status: "ok";
-  readonly response: JsonObject;
-} {
-  return (
-    isJsonObject(value) &&
-    value.status === "ok" &&
-    isJsonObject(value.response)
-  );
-}
-
-function joinErrorMessage(value: JsonValue): string {
-  return replyErrorMessage(value);
-}
-
-function replyErrorMessage(value: JsonValue): string {
-  if (!isJsonObject(value)) {
-    return "invalid reply";
-  }
-
-  const response = value.response;
-
-  if (isJsonObject(response) && typeof response.error === "string") {
-    return response.error;
-  }
-
-  if (typeof value.error === "string") {
-    return value.error;
-  }
-
-  return "unknown";
-}
-
-function isNonOkPushReply(value: JsonValue): boolean {
-  return isJsonObject(value) && value.status !== "ok";
-}
-
-function isKandanControl(value: JsonValue): value is KandanControl {
-  return isJsonObject(value) && typeof value.type === "string";
-}
-
-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
-    });
-  });
-}

package/src/portForwardApproval.ts

@@ -1,181 +0,0 @@
-/*
-- Date: 2026-04-27
-  Spec: plans/2026-04-26-local-runner-subdomain-forwarding-epr.md
-  Relationship: Keeps local runner port-forward approval and revocation policy
-  pure so security decisions are tested directly instead of hiding inside the
-  channel-session orchestration module.
-*/
-import { type JsonObject } from "./protocol";
-import {
-  commandLabel,
-  sameForwardCandidate,
-  type PortForwardCandidate,
-} from "./portForwardWatcher";
-
-export type PendingPortForwardRequest = {
-  readonly requestId: string;
-  readonly port: number;
-  readonly pid: number;
-  readonly command: string;
-  readonly cwd?: string | undefined;
-  readonly sourceSeq: number;
-};
-
-export type PortForwardCandidateReview =
-  | {
-      readonly type: "skip";
-      readonly reason:
-        | "thread_not_bound"
-        | "suppressed_port"
-        | "already_pending"
-        | "already_approved"
-        | "recently_dismissed";
-    }
-  | { readonly type: "remember_approved_target"; readonly target: PortForwardCandidate }
-  | {
-      readonly type: "revoke_and_prompt";
-      readonly revoked: PortForwardCandidate;
-      readonly candidate: PortForwardCandidate;
-      readonly reason: "listener_changed";
-    }
-  | { readonly type: "prompt"; readonly candidate: PortForwardCandidate };
-
-export function reviewPortForwardCandidate(options: {
-  readonly candidate: PortForwardCandidate;
-  readonly threadBound: boolean;
-  readonly suppressedPorts?: ReadonlySet<number> | undefined;
-  readonly approvedPorts: ReadonlySet<number>;
-  readonly approvedTargets: ReadonlyMap<number, PortForwardCandidate>;
-  readonly dismissedTargets?: ReadonlyMap<number, PortForwardCandidate> | undefined;
-  readonly pendingRequests: readonly PendingPortForwardRequest[];
-}): PortForwardCandidateReview {
-  if (!options.threadBound) {
-    return { type: "skip", reason: "thread_not_bound" };
-  }
-
-  if (options.suppressedPorts?.has(options.candidate.port) === true) {
-    return { type: "skip", reason: "suppressed_port" };
-  }
-
-  const dismissedTarget = options.dismissedTargets?.get(options.candidate.port);
-
-  if (
-    dismissedTarget !== undefined &&
-    sameDismissedPortForwardTarget(dismissedTarget, options.candidate)
-  ) {
-    return { type: "skip", reason: "recently_dismissed" };
-  }
-
-  if (options.approvedPorts.has(options.candidate.port)) {
-    const approvedTarget = options.approvedTargets.get(options.candidate.port);
-
-    if (approvedTarget === undefined) {
-      return { type: "remember_approved_target", target: options.candidate };
-    }
-
-    if (sameForwardCandidate(approvedTarget, options.candidate)) {
-      return { type: "skip", reason: "already_approved" };
-    }
-
-    return {
-      type: "revoke_and_prompt",
-      revoked: approvedTarget,
-      candidate: options.candidate,
-      reason: "listener_changed",
-    };
-  }
-
-  if (options.pendingRequests.some(request => request.port === options.candidate.port)) {
-    return { type: "skip", reason: "already_pending" };
-  }
-
-  return { type: "prompt", candidate: options.candidate };
-}
-
-export function pendingRequestFromCandidate(options: {
-  readonly requestId: string;
-  readonly sourceSeq: number;
-  readonly candidate: PortForwardCandidate;
-}): PendingPortForwardRequest {
-  return {
-    requestId: options.requestId,
-    port: options.candidate.port,
-    pid: options.candidate.pid,
-    command: options.candidate.command,
-    ...(options.candidate.cwd === undefined ? {} : { cwd: options.candidate.cwd }),
-    sourceSeq: options.sourceSeq,
-  };
-}
-
-export function approvedTargetFromRequest(
-  request: PendingPortForwardRequest,
-): PortForwardCandidate {
-  return {
-    port: request.port,
-    pid: request.pid,
-    command: request.command,
-    ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
-  };
-}
-
-export function portForwardPromptLabel(candidate: PortForwardCandidate): string {
-  return commandLabel(candidate.command);
-}
-
-export function portForwardPromptBody(
-  candidate: PortForwardCandidate,
-  requestId: string,
-): string {
-  const label = portForwardPromptLabel(candidate);
-  const cwdLine = candidate.cwd === undefined ? undefined : `Working directory: ${candidate.cwd}`;
-
-  return [
-    `Detected ${label} listening from a descendant process.`,
-    `Port: ${candidate.port}`,
-    `PID: ${candidate.pid}`,
-    `Command: ${candidate.command}`,
-    ...(cwdLine === undefined ? [] : [cwdLine]),
-    "Kandan can open this as an authenticated HTTP, HTTPS, or WebSocket preview. It does not expose arbitrary TCP or UDP protocols.",
-    "Open this preview in Kandan?",
-    "",
-    `Fallback commands: ${portForwardDecisionCommand("approve", requestId)} or ${portForwardDecisionCommand("deny", requestId)}`,
-  ].join("\n");
-}
-
-export function portForwardPromptReason(candidate: PortForwardCandidate): string {
-  return [
-    `Port ${candidate.port}`,
-    `PID ${candidate.pid}`,
-    `command: ${candidate.command}`,
-    ...(candidate.cwd === undefined ? [] : [`cwd: ${candidate.cwd}`]),
-    "preview protocols: HTTP, HTTPS, WebSocket",
-  ].join(" / ");
-}
-
-export function portForwardDecisionCommand(
-  decision: "approve" | "deny",
-  requestId: string,
-): string {
-  return `/kandan ${decision}-port-forward ${requestId}`;
-}
-
-export function forwardPreviewPath(runnerId: string, port: number): string {
-  return `/local-codex-runners/${encodeURIComponent(runnerId)}/forwards/${port}/preview`;
-}
-
-export function revocationCapabilities(
-  capabilities: JsonObject | undefined,
-  port: number,
-): JsonObject {
-  return {
-    ...(capabilities ?? {}),
-    revokedPorts: [port],
-  };
-}
-
-function sameDismissedPortForwardTarget(
-  left: PortForwardCandidate,
-  right: PortForwardCandidate,
-): boolean {
-  return left.port === right.port && left.command === right.command && left.cwd === right.cwd;
-}