conductor-oss 0.18.2 → 0.18.4

package/web/.next/standalone/packages/web/src/components/sessions/sessionTerminalUtils.test.ts

@@ -2,24 +2,13 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { TERMINAL_FONT_FAMILY } from "@/components/terminal/xtermTheme";
 import {
-  buildTerminalSnapshotPayload,
   calculateMobileTerminalViewportMetrics,
-  decodeTerminalBase64Payload,
   detectCompactTerminalChrome,
   detectMobileTerminalInputRail,
   getSessionTerminalViewportOptions,
-  normalizeTerminalSnapshot,
-  parseTerminalBinaryFrame,
-  prependTerminalModes,
   sanitizeRemoteTerminalSnapshot,
-  stripBrowserTerminalResponses,
 } from "./sessionTerminalUtils";
 
-test("decodeTerminalBase64Payload decodes terminal stream payload bytes", () => {
-  const bytes = decodeTerminalBase64Payload("aGVsbG8=");
-  assert.deepEqual(Array.from(bytes), [104, 101, 108, 108, 111]);
-});
-
 test("detectMobileTerminalInputRail only enables compact touch layouts on narrow viewports", () => {
   assert.equal(detectMobileTerminalInputRail(390, true, 1), true);
   assert.equal(detectMobileTerminalInputRail(390, false, 1), true);
@@ -42,122 +31,11 @@ test("detectCompactTerminalChrome activates immersive mode below lg breakpoint (
   assert.equal(detectCompactTerminalChrome(844, 390, false, 1), true);
 });
 
-test("stripBrowserTerminalResponses removes browser-generated device status chatter", () => {
-  const raw = "\u001b[Ihello\u001b[12;34R\u001b[?1;2cworld\u001b]11;rgb:0000/0000/0000\u0007";
-  assert.equal(stripBrowserTerminalResponses(raw), "helloworld");
-});
-
 test("sanitizeRemoteTerminalSnapshot strips ANSI control sequences and normalizes newlines", () => {
   const raw = "\u001b[31merror\u001b[0m\r\nnext\rline\u0000";
   assert.equal(sanitizeRemoteTerminalSnapshot(raw), "error\nnext\nline");
 });
 
-test("normalizeTerminalSnapshot converts LF-only snapshots to CRLF for xterm replay", () => {
-  assert.equal(normalizeTerminalSnapshot("one\ntwo"), "one\r\ntwo");
-  assert.equal(normalizeTerminalSnapshot("one\r\ntwo"), "one\r\ntwo");
-});
-
-test("buildTerminalSnapshotPayload prefixes mobile/web restore modes before the snapshot bytes", () => {
-  const payload = buildTerminalSnapshotPayload("prompt> ", {
-    alternateScreen: true,
-    applicationKeypad: true,
-    applicationCursor: true,
-    hideCursor: true,
-    bracketedPaste: true,
-    mouseProtocolMode: "AnyMotion",
-    mouseProtocolEncoding: "Sgr",
-  });
-  const text = new TextDecoder().decode(payload);
-
-  assert.match(text, /\u001b\[\?1049h/);
-  assert.match(text, /\u001b\[\?2004h/);
-  assert.match(text, /\u001b\[\?1003h/);
-  assert.match(text, /\u001b\[\?1006h/);
-  assert.ok(text.endsWith("prompt> "));
-});
-
-test("prependTerminalModes keeps stream payload untouched when no modes are available", () => {
-  const payload = new TextEncoder().encode("plain");
-  assert.deepEqual(prependTerminalModes(payload), payload);
-});
-
-test("parseTerminalBinaryFrame decodes restore frames with explicit mode metadata", () => {
-  const payload = new TextEncoder().encode("prompt> ");
-  const frame = new Uint8Array(24 + payload.length);
-  frame.set([0x43, 0x54, 0x50, 0x32, 2, 1], 0);
-  const view = new DataView(frame.buffer);
-  view.setBigUint64(6, 42n, false);
-  view.setUint8(14, 1);
-  view.setUint8(15, 2);
-  view.setUint16(16, 120, false);
-  view.setUint16(18, 32, false);
-  view.setUint8(20, 0b0001_1101);
-  view.setUint8(21, 4);
-  view.setUint8(22, 2);
-  frame.set(payload, 24);
-
-  const parsed = parseTerminalBinaryFrame(frame.buffer);
-  assert.deepEqual(parsed, {
-    kind: "restore",
-    sequence: 42,
-    snapshotVersion: 1,
-    reason: "lagged",
-    cols: 120,
-    rows: 32,
-    modes: {
-      alternateScreen: true,
-      applicationKeypad: false,
-      applicationCursor: true,
-      hideCursor: true,
-      bracketedPaste: true,
-      mouseProtocolMode: "AnyMotion",
-      mouseProtocolEncoding: "Sgr",
-    },
-    payload,
-  });
-});
-
-test("parseTerminalBinaryFrame still accepts legacy restore frames", () => {
-  const payload = new TextEncoder().encode("prompt> ");
-  const frame = new Uint8Array(20 + payload.length);
-  frame.set([0x43, 0x54, 0x50, 0x32, 1, 1], 0);
-  const view = new DataView(frame.buffer);
-  view.setBigUint64(6, 42n, false);
-  view.setUint8(14, 1);
-  view.setUint8(15, 2);
-  view.setUint16(16, 120, false);
-  view.setUint16(18, 32, false);
-  frame.set(payload, 20);
-
-  const parsed = parseTerminalBinaryFrame(frame.buffer);
-  assert.deepEqual(parsed, {
-    kind: "restore",
-    sequence: 42,
-    snapshotVersion: 1,
-    reason: "lagged",
-    cols: 120,
-    rows: 32,
-    modes: undefined,
-    payload,
-  });
-});
-
-test("parseTerminalBinaryFrame decodes stream frames", () => {
-  const payload = new TextEncoder().encode("line\r\n");
-  const frame = new Uint8Array(14 + payload.length);
-  frame.set([0x43, 0x54, 0x50, 0x32, 2, 2], 0);
-  const view = new DataView(frame.buffer);
-  view.setBigUint64(6, 7n, false);
-  frame.set(payload, 14);
-
-  const parsed = parseTerminalBinaryFrame(frame.buffer);
-  assert.deepEqual(parsed, {
-    kind: "stream",
-    sequence: 7,
-    payload,
-  });
-});
-
 test("getSessionTerminalViewportOptions keeps compact fonts for phones and larger fonts for desktop", () => {
   assert.deepEqual(getSessionTerminalViewportOptions(390), {
     fontFamily: "'SF Mono', Menlo, Monaco, monospace",

package/web/.next/standalone/packages/web/src/components/sessions/sessionTerminalUtils.ts

@@ -25,228 +25,8 @@ export type TerminalModeState = {
 const MOBILE_TERMINAL_INPUT_MAX_WIDTH_PX = 1024;
 /** Must match the Tailwind `lg:` breakpoint (1024px) used in SessionTerminal / SessionDetail. */
 const COMPACT_TERMINAL_CHROME_MAX_WIDTH_PX = 1024;
-const TERMINAL_FRAME_MAGIC = [0x43, 0x54, 0x50, 0x32] as const;
-const TERMINAL_FRAME_PROTOCOL_VERSION = 2;
-const TERMINAL_FRAME_KIND_RESTORE = 1;
-const TERMINAL_FRAME_KIND_STREAM = 2;
-const TERMINAL_STREAM_FRAME_HEADER_BYTES = 14;
-const TERMINAL_RESTORE_FRAME_HEADER_BYTES_V1 = 20;
-const TERMINAL_RESTORE_FRAME_HEADER_BYTES_V2 = 24;
-const BROWSER_TERMINAL_RESPONSE_PATTERNS = [
-  /\x1b\[(?:I|O)/g,
-  /\x1b\[\d+;\d+R/g,
-  /\x1b\[(?:[?>])[\d;]*c/g,
-  /\x1b\](?:10|11|12|4;\d+);[\s\S]*?(?:\x07|\x1b\\)/g,
-];
 const ANSI_ESCAPE_PATTERN = /\u001b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][\s\S]*?(?:\u0007|\u001b\\))/g;
 
-export type TerminalBinaryFrame =
-  | {
-      kind: "restore";
-      sequence: number;
-      snapshotVersion: number;
-      reason: "attach" | "lagged" | "unknown";
-      cols: number;
-      rows: number;
-      modes?: TerminalModeState;
-      payload: Uint8Array;
-    }
-  | {
-      kind: "stream";
-      sequence: number;
-      payload: Uint8Array;
-    };
-
-function decodeTerminalRestoreReason(code: number): "attach" | "lagged" | "unknown" {
-  if (code === 1) {
-    return "attach";
-  }
-  if (code === 2) {
-    return "lagged";
-  }
-  return "unknown";
-}
-
-function decodeTerminalMouseProtocolMode(code: number): string {
-  if (code === 1) return "Press";
-  if (code === 2) return "PressRelease";
-  if (code === 3) return "ButtonMotion";
-  if (code === 4) return "AnyMotion";
-  return "None";
-}
-
-function decodeTerminalMouseProtocolEncoding(code: number): string {
-  if (code === 1) return "Utf8";
-  if (code === 2) return "Sgr";
-  if (code === 3) return "Urxvt";
-  return "Default";
-}
-
-function decodeTerminalModes(flags: number, mouseModeCode: number, mouseEncodingCode: number): TerminalModeState {
-  return {
-    alternateScreen: (flags & (1 << 0)) !== 0,
-    applicationKeypad: (flags & (1 << 1)) !== 0,
-    applicationCursor: (flags & (1 << 2)) !== 0,
-    hideCursor: (flags & (1 << 3)) !== 0,
-    bracketedPaste: (flags & (1 << 4)) !== 0,
-    mouseProtocolMode: decodeTerminalMouseProtocolMode(mouseModeCode),
-    mouseProtocolEncoding: decodeTerminalMouseProtocolEncoding(mouseEncodingCode),
-  };
-}
-
-function concatTerminalPayload(prefix: Uint8Array, payload: Uint8Array): Uint8Array {
-  if (prefix.byteLength === 0) {
-    return payload;
-  }
-
-  if (payload.byteLength === 0) {
-    return prefix;
-  }
-
-  const merged = new Uint8Array(prefix.byteLength + payload.byteLength);
-  merged.set(prefix, 0);
-  merged.set(payload, prefix.byteLength);
-  return merged;
-}
-
-export function encodeTerminalModesPrefix(modes?: TerminalModeState | null): Uint8Array {
-  if (!modes) {
-    return new Uint8Array(0);
-  }
-
-  const sequences = [
-    modes.alternateScreen ? "\u001b[?1049h" : "\u001b[?1049l",
-    modes.applicationCursor ? "\u001b[?1h" : "\u001b[?1l",
-    modes.applicationKeypad ? "\u001b=" : "\u001b>",
-    modes.hideCursor ? "\u001b[?25l" : "\u001b[?25h",
-    modes.bracketedPaste ? "\u001b[?2004h" : "\u001b[?2004l",
-    "\u001b[?1000l\u001b[?1002l\u001b[?1003l\u001b[?1005l\u001b[?1006l\u001b[?1015l",
-  ];
-
-  if (modes.mouseProtocolMode === "Press") {
-    sequences.push("\u001b[?1000h");
-  } else if (modes.mouseProtocolMode === "ButtonMotion") {
-    sequences.push("\u001b[?1002h");
-  } else if (modes.mouseProtocolMode === "AnyMotion") {
-    sequences.push("\u001b[?1003h");
-  } else if (modes.mouseProtocolMode === "PressRelease") {
-    sequences.push("\u001b[?1000h");
-  }
-
-  if (modes.mouseProtocolEncoding === "Utf8") {
-    sequences.push("\u001b[?1005h");
-  } else if (modes.mouseProtocolEncoding === "Sgr") {
-    sequences.push("\u001b[?1006h");
-  } else if (modes.mouseProtocolEncoding === "Urxvt") {
-    sequences.push("\u001b[?1015h");
-  }
-
-  return new TextEncoder().encode(sequences.join(""));
-}
-
-export function prependTerminalModes(
-  payload: Uint8Array,
-  modes?: TerminalModeState | null,
-): Uint8Array {
-  return concatTerminalPayload(encodeTerminalModesPrefix(modes), payload);
-}
-
-export function buildTerminalSnapshotPayload(
-  snapshot: string,
-  modes?: TerminalModeState | null,
-): Uint8Array {
-  return prependTerminalModes(new TextEncoder().encode(normalizeTerminalSnapshot(snapshot)), modes);
-}
-
-export function decodeTerminalBase64Payload(value: string): Uint8Array {
-  const normalized = value.trim();
-  if (normalized.length === 0) {
-    return new Uint8Array(0);
-  }
-
-  if (typeof atob === "function") {
-    const decoded = atob(normalized);
-    const bytes = new Uint8Array(decoded.length);
-    for (let index = 0; index < decoded.length; index += 1) {
-      bytes[index] = decoded.charCodeAt(index);
-    }
-    return bytes;
-  }
-
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(normalized, "base64"));
-  }
-
-  throw new Error("A base64 decoder is not available in this environment");
-}
-
-export function parseTerminalBinaryFrame(buffer: ArrayBuffer): TerminalBinaryFrame {
-  const bytes = new Uint8Array(buffer);
-  if (bytes.byteLength < TERMINAL_STREAM_FRAME_HEADER_BYTES) {
-    throw new Error("Terminal frame was shorter than the stream header");
-  }
-
-  for (let index = 0; index < TERMINAL_FRAME_MAGIC.length; index += 1) {
-    if (bytes[index] !== TERMINAL_FRAME_MAGIC[index]) {
-      throw new Error("Terminal frame magic did not match the frame protocol");
-    }
-  }
-
-  const view = new DataView(buffer);
-  const version = view.getUint8(4);
-  if (version !== 1 && version !== TERMINAL_FRAME_PROTOCOL_VERSION) {
-    throw new Error(`Unsupported terminal frame protocol version: ${version}`);
-  }
-
-  const kind = view.getUint8(5);
-  const sequence = Number(view.getBigUint64(6, false));
-  if (!Number.isSafeInteger(sequence)) {
-    throw new Error("Terminal frame sequence exceeded the safe integer range");
-  }
-
-  if (kind === TERMINAL_FRAME_KIND_RESTORE) {
-    const headerBytes = version >= 2 ? TERMINAL_RESTORE_FRAME_HEADER_BYTES_V2 : TERMINAL_RESTORE_FRAME_HEADER_BYTES_V1;
-    if (bytes.byteLength < headerBytes) {
-      throw new Error("Terminal restore frame was shorter than the restore header");
-    }
-
-    return {
-      kind: "restore",
-      sequence,
-      snapshotVersion: view.getUint8(14),
-      reason: decodeTerminalRestoreReason(view.getUint8(15)),
-      cols: view.getUint16(16, false),
-      rows: view.getUint16(18, false),
-      modes: version >= 2
-        ? decodeTerminalModes(view.getUint8(20), view.getUint8(21), view.getUint8(22))
-        : undefined,
-      payload: bytes.slice(headerBytes),
-    };
-  }
-
-  if (kind === TERMINAL_FRAME_KIND_STREAM) {
-    return {
-      kind: "stream",
-      sequence,
-      payload: bytes.slice(TERMINAL_STREAM_FRAME_HEADER_BYTES),
-    };
-  }
-
-  throw new Error(`Unsupported terminal frame kind: ${kind}`);
-}
-
-export function normalizeTerminalSnapshot(snapshot: string): string {
-  return snapshot.replace(/\r?\n/g, "\r\n");
-}
-
-export function stripBrowserTerminalResponses(data: string): string {
-  let sanitized = data;
-  for (const pattern of BROWSER_TERMINAL_RESPONSE_PATTERNS) {
-    sanitized = sanitized.replace(pattern, "");
-  }
-  return sanitized;
-}
-
 export function sanitizeRemoteTerminalSnapshot(snapshot: string): string {
   return snapshot
     .replace(ANSI_ESCAPE_PATTERN, "")

package/web/.next/standalone/packages/web/src/components/sessions/terminal/terminalApi.ts

@@ -1,109 +1,111 @@
 /**
- * Fetch/API wrappers for terminal operations:
- * connection info and snapshot fetch. All I/O goes through TTyD WebSocket.
+ * Terminal API utilities.
+ * Connection resolution is client-side for the WS URL — the browser builds
+ * the ttyd endpoint directly. Authentication still uses a lightweight
+ * Next.js proxy to obtain a short-lived terminal token.
  */
 
-import {
-  readCachedTerminalConnection,
-  storeCachedTerminalConnection,
-} from "./terminalCache";
-import type {
-  TerminalConnectionInfo,
-  TerminalSnapshot,
-} from "./terminalTypes";
-import type { TerminalModeState } from "../sessionTerminalUtils";
-
-export function parseTerminalModes(value: unknown): TerminalModeState | undefined {
-  if (!value || typeof value !== "object") {
-    return undefined;
-  }
+import type { TerminalConnectionInfo } from "./terminalTypes";
 
-  const candidate = value as Record<string, unknown>;
-  const mouseProtocolMode = typeof candidate["mouseProtocolMode"] === "string"
-    ? candidate["mouseProtocolMode"]
-    : "None";
-  const mouseProtocolEncoding = typeof candidate["mouseProtocolEncoding"] === "string"
-    ? candidate["mouseProtocolEncoding"]
-    : "Default";
+// ---------------------------------------------------------------------------
+// Direct backend URL resolution — no server round-trip
+// ---------------------------------------------------------------------------
 
-  return {
-    alternateScreen: candidate["alternateScreen"] === true,
-    applicationKeypad: candidate["applicationKeypad"] === true,
-    applicationCursor: candidate["applicationCursor"] === true,
-    hideCursor: candidate["hideCursor"] === true,
-    bracketedPaste: candidate["bracketedPaste"] === true,
-    mouseProtocolMode,
-    mouseProtocolEncoding,
-  };
-}
+/**
+ * Resolve the Rust backend origin from the browser.
+ *
+ * Priority:
+ *  1. `NEXT_PUBLIC_CONDUCTOR_BACKEND_URL` (build-time env var)
+ *  2. Dev mode heuristic: if the page is served from port 3000 the backend
+ *     lives on the same hostname at port 4749.
+ *  3. Same origin (production: Rust backend serves the dashboard).
+ */
+function resolveBackendOrigin(): string {
+  // Build-time env var (NEXT_PUBLIC_ prefix exposes it to the client bundle)
+  const envUrl = process.env.NEXT_PUBLIC_CONDUCTOR_BACKEND_URL?.trim();
+  if (envUrl) return envUrl;
 
-export async function fetchTerminalConnection(sessionId: string): Promise<TerminalConnectionInfo> {
-  const cached = readCachedTerminalConnection(sessionId);
-  if (cached) {
-    return cached;
-  }
+  if (typeof window === "undefined") return "http://127.0.0.1:4749";
 
-  const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/terminal/connection`, {
-    cache: "no-store",
-  });
-  const data = (await response.json().catch(() => null)) as
-    | {
-        ptyWsUrl?: string | null;
-        interactive?: boolean;
-        error?: string;
-      }
-    | null;
-  if (!response.ok) {
-    throw new Error(data?.error ?? `Failed to resolve terminal connection: ${response.status}`);
+  const { protocol, hostname, port } = window.location;
+
+  // Dev mode: Next.js dev server on :3000, Rust backend on :4749
+  if (port === "3000") {
+    return `${protocol}//${hostname}:4749`;
   }
 
-  const connection: TerminalConnectionInfo = {
-    ptyWsUrl:
-      typeof data?.ptyWsUrl === "string" && data.ptyWsUrl.trim().length > 0
-        ? data.ptyWsUrl.trim()
-        : null,
-    interactive: data?.interactive === true,
-  };
-  storeCachedTerminalConnection(sessionId, connection);
-  return connection;
+  // Production / standalone: backend serves dashboard at the same origin
+  return window.location.origin;
 }
 
-export async function fetchTerminalSnapshot(sessionId: string, lines: number): Promise<TerminalSnapshot> {
-  const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/terminal/snapshot?lines=${lines}`, {
+/**
+ * Fetch a terminal token via the Next.js proxy (which handles auth).
+ * The token is required by the Rust backend WebSocket endpoint.
+ * Fail closed on proxy or backend errors so the browser does not attempt an
+ * unauthenticated ttyd websocket with a missing or stale token.
+ */
+type TerminalTokenResult =
+  | { interactive: true; token: string | null }
+  | { interactive: false; token: null };
+
+async function fetchTerminalToken(sessionId: string): Promise<TerminalTokenResult> {
+  const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/terminal/token`, {
     cache: "no-store",
   });
-  const data = (await response.json().catch(() => null)) as
-    | { snapshot?: string; transcript?: string; source?: string; live?: boolean; restored?: boolean; sequence?: number; modes?: unknown; error?: string }
+  const data = (await res.json().catch(() => null)) as
+    | { token?: string; required?: boolean; error?: string }
     | null;
-  if (!response.ok) {
-    throw new Error(data?.error ?? `Failed to resolve terminal snapshot: ${response.status}`);
+
+  if (res.status === 401 || res.status === 403) {
+    return {
+      interactive: false,
+      token: null,
+    };
+  }
+
+  if (!res.ok) {
+    throw new Error(data?.error ?? `Failed to resolve terminal token: ${res.status}`);
   }
-  const rawSnapshot = typeof data?.snapshot === "string" ? data.snapshot : "";
-  const transcript = typeof data?.transcript === "string" ? data.transcript : "";
-  const compactedSnapshot = transcript.trim().length > 0 ? transcript : rawSnapshot;
+
+  if (data?.required !== true) {
+    return {
+      interactive: true,
+      token: null,
+    };
+  }
+
+  const token = typeof data?.token === "string" ? data.token.trim() : "";
+  if (token.length === 0) {
+    throw new Error("Terminal token response did not include a ttyd token");
+  }
+
   return {
-    snapshot: compactedSnapshot,
-    transcript: "",
-    source: typeof data?.source === "string" ? data.source : "empty",
-    live: data?.live === true,
-    restored: data?.restored === true,
-    sequence: typeof data?.sequence === "number" && Number.isSafeInteger(data.sequence)
-      ? data.sequence
-      : null,
-    modes: parseTerminalModes(data?.modes),
+    interactive: true,
+    token,
   };
 }
 
-export async function fetchSessionStatus(sessionId: string): Promise<string | null> {
-  const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}`, {
-    cache: "no-store",
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to load session: ${response.status}`);
+/**
+ * Build the direct ttyd WebSocket URL for a session.
+ *
+ * 1. Fetch a short-lived token via Next.js proxy (one HTTP call, handles auth).
+ * 2. Construct the WebSocket URL pointing directly at the Rust backend.
+ *
+ * The WebSocket stream itself is direct — no middleware in the data path.
+ */
+export async function resolveTerminalConnection(sessionId: string): Promise<TerminalConnectionInfo> {
+  const origin = resolveBackendOrigin();
+  const wsProtocol = origin.startsWith("https") ? "wss:" : "ws:";
+  const url = new URL(origin);
+  const auth = await fetchTerminalToken(sessionId);
+  if (!auth.interactive) {
+    return {
+      ptyWsUrl: null,
+      interactive: false,
+    };
   }
+  const tokenParam = auth.token ? `&token=${encodeURIComponent(auth.token)}` : "";
+  const ptyWsUrl = `${wsProtocol}//${url.host}/api/sessions/${encodeURIComponent(sessionId)}/terminal/ws?protocol=ttyd${tokenParam}`;
 
-  const data = (await response.json().catch(() => null)) as { status?: unknown } | null;
-  return typeof data?.status === "string" && data.status.trim().length > 0
-    ? data.status.trim()
-    : null;
+  return { ptyWsUrl, interactive: true };
 }

package/web/.next/standalone/packages/web/src/components/sessions/terminal/terminalCache.ts

@@ -1,26 +1,13 @@
 /**
- * Module-level Map caches and TTL logic for terminal connections,
- * snapshots, and UI state.
+ * Module-level cache and TTL logic for terminal UI state.
  */
 
 import {
-  TERMINAL_CONNECTION_CACHE_MAX_TTL_MS,
-  TERMINAL_CONNECTION_CACHE_MAX_ENTRIES,
-  TERMINAL_SNAPSHOT_CACHE_MAX_ENTRIES,
   TERMINAL_UI_STATE_CACHE_MAX_ENTRIES,
-  TERMINAL_SNAPSHOT_CACHE_MAX_AGE_MS,
   TERMINAL_UI_STATE_CACHE_MAX_AGE_MS,
 } from "./terminalConstants";
-import type {
-  TerminalConnectionInfo,
-  TerminalSnapshot,
-  CachedTerminalConnection,
-  CachedTerminalSnapshot,
-  CachedTerminalUiState,
-} from "./terminalTypes";
+import type { CachedTerminalUiState } from "./terminalTypes";
 
-export const terminalConnectionCache = new Map<string, CachedTerminalConnection>();
-export const terminalSnapshotCache = new Map<string, CachedTerminalSnapshot>();
 export const terminalUiStateCache = new Map<string, CachedTerminalUiState>();
 
 export function trimTerminalCache(cache: Map<string, unknown>, maxEntries: number): void {
@@ -33,64 +20,6 @@ export function trimTerminalCache(cache: Map<string, unknown>, maxEntries: numbe
   }
 }
 
-export function readCachedTerminalConnection(sessionId: string): TerminalConnectionInfo | null {
-  const cached = terminalConnectionCache.get(sessionId);
-  if (!cached) {
-    return null;
-  }
-  if (cached.expiresAt <= Date.now()) {
-    terminalConnectionCache.delete(sessionId);
-    return null;
-  }
-  return cached.value;
-}
-
-export function storeCachedTerminalConnection(sessionId: string, value: TerminalConnectionInfo): void {
-  terminalConnectionCache.delete(sessionId);
-  terminalConnectionCache.set(sessionId, {
-    value,
-    expiresAt: Date.now() + TERMINAL_CONNECTION_CACHE_MAX_TTL_MS,
-  });
-  trimTerminalCache(terminalConnectionCache, TERMINAL_CONNECTION_CACHE_MAX_ENTRIES);
-}
-
-export function clearCachedTerminalConnection(sessionId: string): void {
-  terminalConnectionCache.delete(sessionId);
-}
-
-export function readCachedTerminalSnapshot(sessionId: string): TerminalSnapshot | null {
-  const cached = terminalSnapshotCache.get(sessionId);
-  if (!cached) {
-    return null;
-  }
-  if (Date.now() - cached.updatedAt > TERMINAL_SNAPSHOT_CACHE_MAX_AGE_MS) {
-    terminalSnapshotCache.delete(sessionId);
-    return null;
-  }
-  return {
-    snapshot: cached.snapshot,
-    transcript: cached.transcript,
-    source: cached.source,
-    live: cached.live,
-    restored: cached.restored,
-    sequence: cached.sequence,
-    modes: cached.modes,
-  };
-}
-
-export function storeCachedTerminalSnapshot(sessionId: string, snapshot: TerminalSnapshot): void {
-  terminalSnapshotCache.delete(sessionId);
-  terminalSnapshotCache.set(sessionId, {
-    ...snapshot,
-    updatedAt: Date.now(),
-  });
-  trimTerminalCache(terminalSnapshotCache, TERMINAL_SNAPSHOT_CACHE_MAX_ENTRIES);
-}
-
-export function clearCachedTerminalSnapshot(sessionId: string): void {
-  terminalSnapshotCache.delete(sessionId);
-}
-
 export function readCachedTerminalUiState(sessionId: string): CachedTerminalUiState | null {
   const cached = terminalUiStateCache.get(sessionId);
   if (!cached) {