@iislee/opencodex 2.11.0

package/src/server/windows-tcp-drop.ts

@@ -0,0 +1,184 @@
+/**
+ * Soft SIGTERM-before-/F is NOT available on Windows (process.kill is TerminateProcess).
+ * Graceful drain is stopProxyGracefully(); this module only resets leftover TCBs after hard kill.
+ */
+import { dlopen, ptr, type Pointer } from "bun:ffi";
+import { execFileSync } from "node:child_process";
+
+export type TcpQuad = {
+  localAddr: string;
+  localPort: number;
+  remoteAddr: string;
+  remotePort: number;
+  state: string;
+};
+
+/** Parse netstat -ano rows whose local address uses `port`. Exported for tests. */
+export function parseTcpQuadsForLocalPort(output: string, port: number): TcpQuad[] {
+  const rows: TcpQuad[] = [];
+  const portSuffix = `:${port}`;
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!/^TCP\b/i.test(line)) continue;
+    const parts = line.split(/\s+/);
+    if (parts.length < 4) continue;
+    const local = parts[1]!;
+    const remote = parts[2]!;
+    const state = parts[3]!;
+    if (!local.endsWith(portSuffix) && !local.endsWith(`]:${port}`)) continue;
+    const localAddr = stripPort(local, port);
+    const remoteParsed = splitHostPort(remote);
+    if (!localAddr || !remoteParsed) continue;
+    rows.push({
+      localAddr,
+      localPort: port,
+      remoteAddr: remoteParsed.host,
+      remotePort: remoteParsed.port,
+      state,
+    });
+  }
+  return rows;
+}
+
+function stripPort(addr: string, port: number): string | null {
+  const suffix = `:${port}`;
+  if (addr.endsWith(suffix)) return addr.slice(0, -suffix.length).replace(/^\[|\]$/g, "") || "0.0.0.0";
+  return null;
+}
+
+function splitHostPort(addr: string): { host: string; port: number } | null {
+  if (addr === "0.0.0.0:0" || addr === "*:*" || addr === "[::]:0") {
+    return { host: "0.0.0.0", port: 0 };
+  }
+  const m = /^(?:\[([^\]]+)\]|([^:]+)):(\d+)$/.exec(addr);
+  if (!m) return null;
+  return { host: (m[1] ?? m[2] ?? "0.0.0.0").replace(/^::ffff:/i, ""), port: Number(m[3]) };
+}
+
+function ipv4ToWinUint32(addr: string): number | null {
+  const host = addr.replace(/^::ffff:/i, "");
+  // Refuse bare IPv6 — SetTcpEntry is IPv4-only; coercing "::"/"::1" to 0 would
+  // miss the real TCB and can hit an unrelated IPv4 wildcard row.
+  if (isBareIpv6Address(host)) return null;
+  if (host === "0.0.0.0" || host === "*") return 0;
+  const parts = host.split(".").map(Number);
+  if (parts.length !== 4 || parts.some(n => !Number.isInteger(n) || n < 0 || n > 255)) return null;
+  return (parts[0]! | (parts[1]! << 8) | (parts[2]! << 16) | (parts[3]! << 24)) >>> 0;
+}
+
+/** True for bare IPv6 (including :: / ::1), false for dotted IPv4 and IPv4-mapped. */
+export function isBareIpv6Address(addr: string): boolean {
+  const host = String(addr || "").replace(/^\[|\]$/g, "").replace(/^::ffff:/i, "");
+  if (!host) return false;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) return false;
+  return host.includes(":");
+}
+
+export type WindowsTcpDropResult = {
+  /** Successful SetTcpEntry(DELETE_TCB) calls for IPv4 rows. */
+  dropped: number;
+  /** IPv6 (or unparseable) rows skipped — never coerced into IPv4 wildcards. */
+  skippedIpv6: number;
+  /**
+   * SetTcpEntry returned ERROR_ACCESS_DENIED (5) or the UAC-non-elevated code (317).
+   * On a normal (non-admin) update worker this is expected — ghost LISTEN rows must
+   * clear by waiting for the OS, not by SetTcpEntry.
+   */
+  accessDenied: number;
+};
+
+function htons(port: number): number {
+  return (((port & 0xff) << 8) | ((port >> 8) & 0xff)) >>> 0;
+}
+
+type SetTcpEntryFn = (row: Pointer) => number;
+let setTcpEntryFn: SetTcpEntryFn | null | undefined;
+
+function loadSetTcpEntry(): SetTcpEntryFn | null {
+  if (setTcpEntryFn !== undefined) return setTcpEntryFn;
+  if (process.platform !== "win32") {
+    setTcpEntryFn = null;
+    return null;
+  }
+  try {
+    const lib = dlopen("iphlpapi.dll", {
+      SetTcpEntry: { args: ["ptr"], returns: "u32" },
+    });
+    setTcpEntryFn = (row: Pointer) => lib.symbols.SetTcpEntry(row) as number;
+  } catch {
+    setTcpEntryFn = null;
+  }
+  return setTcpEntryFn;
+}
+
+function readNetstatAno(): string {
+  const netstat = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\netstat.exe`;
+  const cmd = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\cmd.exe`;
+  try {
+    return execFileSync(cmd, ["/d", "/c", `chcp 437>nul & "${netstat}" -ano -p tcp`], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+      windowsHide: true,
+    });
+  } catch {
+    return execFileSync(netstat, ["-ano", "-p", "tcp"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 4000,
+      windowsHide: true,
+    });
+  }
+}
+
+/**
+ * Force-delete IPv4 TCP rows bound to `localPort` via SetTcpEntry(DELETE_TCB).
+ * Does not kill foreign processes — only resets sockets so the listen port can bind again.
+ * Bare IPv6 rows (`::1`, `::`, etc.) are skipped (not coerced into IPv4 wildcards);
+ * IPv6 TCB reclamation is unsupported on this path.
+ */
+export function dropWindowsTcpRowsForLocalPort(port: number): WindowsTcpDropResult {
+  if (process.platform !== "win32" || !Number.isFinite(port) || port <= 0) {
+    return { dropped: 0, skippedIpv6: 0, accessDenied: 0 };
+  }
+  const setTcpEntry = loadSetTcpEntry();
+  if (!setTcpEntry) return { dropped: 0, skippedIpv6: 0, accessDenied: 0 };
+
+  let output = "";
+  try {
+    output = readNetstatAno();
+  } catch {
+    return { dropped: 0, skippedIpv6: 0, accessDenied: 0 };
+  }
+
+  const rows = parseTcpQuadsForLocalPort(output, Math.trunc(port));
+  let dropped = 0;
+  let skippedIpv6 = 0;
+  let accessDenied = 0;
+  for (const row of rows) {
+    const localDw = ipv4ToWinUint32(row.localAddr);
+    const remoteDw = ipv4ToWinUint32(row.remoteAddr);
+    if (localDw === null || remoteDw === null) {
+      if (isBareIpv6Address(row.localAddr) || isBareIpv6Address(row.remoteAddr)) {
+        skippedIpv6 += 1;
+      }
+      continue;
+    }
+    const buf = new ArrayBuffer(20);
+    const view = new DataView(buf);
+    view.setUint32(0, 12, true); // MIB_TCP_STATE_DELETE_TCB
+    view.setUint32(4, localDw, true);
+    view.setUint32(8, htons(row.localPort), true);
+    view.setUint32(12, remoteDw, true);
+    view.setUint32(16, htons(row.remotePort), true);
+    try {
+      const rc = setTcpEntry(ptr(buf));
+      if (rc === 0) dropped += 1;
+      // 5 = ERROR_ACCESS_DENIED, 317 = non-elevated SetTcpEntry (MSDN).
+      else if (rc === 5 || rc === 317) accessDenied += 1;
+    } catch {
+      /* keep going */
+    }
+  }
+  return { dropped, skippedIpv6, accessDenied };
+}

package/src/server/windows-tray-control.ts

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { durableBunPath } from "../lib/bun-runtime";
+import type { WindowsTrayStatus } from "../tray/windows";
+
+export type WindowsTrayAction = "install" | "start" | "stop" | "status" | "uninstall";
+
+/** Run blocking registry/PowerShell waits outside the proxy event loop. */
+export function runWindowsTrayAction(action: WindowsTrayAction): Promise<WindowsTrayStatus> {
+  if (action === "status") {
+    return import("../tray/windows").then(({ getWindowsTrayStatusAsync }) => getWindowsTrayStatusAsync());
+  }
+  const bun = durableBunPath();
+  const cli = join(import.meta.dir, "..", "cli", "index.ts");
+  return new Promise((resolve, reject) => {
+    execFile(bun, [cli, "tray", action, "--json"], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 30_000,
+      windowsHide: true,
+      maxBuffer: 256 * 1024,
+    }, (error, stdout, stderr) => {
+      const lines = stdout.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+      for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+          const parsed = JSON.parse(lines[index]) as WindowsTrayStatus | { error?: unknown };
+          if ("supported" in parsed && typeof parsed.supported === "boolean") {
+            resolve(parsed);
+            return;
+          }
+          const failure = parsed as { error?: unknown };
+          if (typeof failure.error === "string") {
+            reject(new Error(failure.error));
+            return;
+          }
+        } catch { /* scan earlier lines */ }
+      }
+      reject(new Error(error?.message || stderr.trim() || "Windows tray action returned no status"));
+    });
+  });
+}

package/src/server/ws-bridge.ts

@@ -0,0 +1,471 @@
+import type { ServerWebSocket } from "bun";
+import { FORWARD_HEADERS } from "../adapters/openai-responses";
+import type { CodexAuthContext } from "../codex/auth-context";
+import { headersForCodexAuthContext } from "../codex/auth-context";
+import type { ResponsesTerminalStatus } from "../bridge";
+import type { DataPlaneAdmission } from "./auth-cors";
+import type { AdmissionReservation } from "../lib/admission";
+
+const OPEN = 1;
+type ResponsesTerminalReporter = (status: ResponsesTerminalStatus) => void;
+type ResponsesPayloadObserver = (payload: string) => void;
+const SAFE_RESPONSE_HEADER_EXACT = new Set([
+  "retry-after",
+  "x-request-id",
+  "openai-request-id",
+  "x-codex-turn-state",
+  "openai-model",
+  "x-models-etag",
+  "x-reasoning-included",
+]);
+
+export interface WsData {
+  headers?: Headers; // base inbound forward headers only; per-turn auth refresh injects current pool tokens
+  /**
+   * Resolved once at the handshake. Auth is handshake-time only on this path, so
+   * the per-frame log contexts have no request headers left to re-resolve from.
+   * Optional like every other member here: a socket object can exist before the
+   * handshake fills it, and an unattributed frame is preferable to a fabricated
+   * attribution.
+   */
+  admission?: DataPlaneAdmission;
+  authContext?: CodexAuthContext; // last resolved account decision for observability/registry cleanup
+  cancel?: () => void; // cancels the in-flight stream reader/fetch
+  turnId?: number; // monotonically increasing per socket; prevents stale frames after replacement turns
+  /** Discriminator: Responses reframing vs transparent live/realtime sideband relay. */
+  kind?: "responses" | "live-sideband";
+  liveUpstream?: WebSocket;
+  liveUpstreamUrl?: string;
+  liveUpstreamHeaders?: Record<string, string>;
+  livePending?: Array<string | Buffer>;
+  liveOpened?: boolean;
+  admissionLease?: AdmissionReservation<ServerWebSocket<WsData>>;
+}
+
+/**
+ * Build the Responses WebSocket upgrade payload.
+ *
+ * Extracted so the handshake's contract is testable: `server.upgrade` hands its
+ * `data` straight to the socket, and a client has no way to read `ws.data` back.
+ * A test that only asserts "the socket opened" would still pass if the admission
+ * were dropped from the payload, so the payload itself is what gets asserted.
+ */
+export function buildResponsesWsData(headers: Headers, admission: DataPlaneAdmission, admissionLease?: AdmissionReservation<ServerWebSocket<WsData>>): WsData {
+  // Auth is handshake-time only on this path: the per-frame contexts have no
+  // request headers left to re-resolve from, so the decision rides along here.
+  return { headers, admission, ...(admissionLease ? { admissionLease } : {}) };
+}
+
+export class WsSendDroppedError extends Error {
+  constructor() {
+    super("websocket send dropped the message");
+  }
+}
+
+export function selectForwardHeaders(
+  headers: Headers,
+  codexOverride?: { accessToken: string; chatgptAccountId: string },
+): Headers {
+  const selected = new Headers();
+  for (const name of FORWARD_HEADERS) {
+    const value = headers.get(name);
+    if (value) selected.set(name, value);
+  }
+  if (codexOverride) {
+    selected.set("authorization", `Bearer ${codexOverride.accessToken}`);
+    selected.set("chatgpt-account-id", codexOverride.chatgptAccountId);
+  }
+  return selected;
+}
+
+export function selectForwardHeadersForAuthContext(headers: Headers, ctx: CodexAuthContext): Headers {
+  return headersForCodexAuthContext(headers, ctx);
+}
+
+export function safeResponseHeaders(headers: Headers): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [name, value] of headers) {
+    const lower = name.toLowerCase();
+    if (
+      SAFE_RESPONSE_HEADER_EXACT.has(lower) ||
+      lower.startsWith("x-ratelimit-") ||
+      /^x-codex(?:-[a-z0-9-]+)?-(primary|secondary|tertiary)-(used-percent|window-minutes|reset-at)$/.test(lower) ||
+      /^x-codex(?:-[a-z0-9-]+)?-limit-name$/.test(lower)
+    ) {
+      out[lower] = value;
+    }
+  }
+  return out;
+}
+
+export function buildWarmupCompletionFrames(frame: Record<string, unknown>): string[] {
+  const createdAt = Math.floor(Date.now() / 1000);
+  const baseResponse: Record<string, unknown> = {
+    id: "",
+    object: "response",
+    created_at: createdAt,
+    model: typeof frame.model === "string" ? frame.model : undefined,
+    output: [],
+  };
+  return [
+    JSON.stringify({
+      type: "response.created",
+      sequence_number: 0,
+      response: { ...baseResponse, status: "in_progress" },
+    }),
+    JSON.stringify({
+      type: "response.completed",
+      sequence_number: 1,
+      response: { ...baseResponse, status: "completed" },
+    }),
+  ];
+}
+
+export function sendTextFrame(ws: ServerWebSocket<WsData>, payload: string): void {
+  if (ws.readyState !== OPEN) throw new WsSendDroppedError();
+  const result = ws.send(payload);
+  if (result === 0) throw new WsSendDroppedError();
+  // Bun returns -1 when queued with backpressure. That is accepted; a later 0 is the hard failure.
+}
+
+export function sendJsonFrame(ws: ServerWebSocket<WsData>, payload: Record<string, unknown>): void {
+  sendTextFrame(ws, JSON.stringify(payload));
+}
+
+export function buildWsErrorFrame(
+  status: number,
+  error: Record<string, unknown>,
+  headers?: Headers,
+): Record<string, unknown> {
+  return {
+    type: "error",
+    status,
+    error,
+    headers: headers ? safeResponseHeaders(headers) : {},
+  };
+}
+
+function parseSseBlock(block: string): string | null {
+  const data: string[] = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith("data:")) {
+      const value = line.slice(5);
+      data.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+  }
+  return data.length > 0 ? data.join("\n") : null;
+}
+
+function nextSseBlock(buffer: string): { block: string; rest: string } | null {
+  const match = buffer.match(/\r?\n\r?\n/);
+  if (!match || match.index === undefined) return null;
+  return {
+    block: buffer.slice(0, match.index),
+    rest: buffer.slice(match.index + match[0].length),
+  };
+}
+
+function payloadType(payload: string): string | null {
+  try {
+    const json = JSON.parse(payload) as { type?: unknown };
+    return typeof json.type === "string" ? json.type : null;
+  } catch {
+    return null;
+  }
+}
+
+function terminalStatusFromType(type: string): ResponsesTerminalStatus | null {
+  switch (type) {
+    case "response.completed":
+      return "completed";
+    case "response.failed":
+      return "failed";
+    case "response.incomplete":
+      return "incomplete";
+    default:
+      return null;
+  }
+}
+
+function protocolError(message: string): Record<string, unknown> {
+  return {
+    type: "protocol_error",
+    code: "websocket_protocol_error",
+    message,
+  };
+}
+
+function sendProtocolError(ws: ServerWebSocket<WsData>, status: number, message: string): void {
+  sendJsonFrame(ws, buildWsErrorFrame(status, protocolError(message)));
+}
+
+export async function pumpResponsesSseToWebSocket(
+  ws: ServerWebSocket<WsData>,
+  sseStream: ReadableStream<Uint8Array>,
+  options: {
+    isCurrent?: () => boolean;
+    onTerminal?: ResponsesTerminalReporter;
+    onSsePayload?: ResponsesPayloadObserver;
+  } = {},
+): Promise<void> {
+  const reader = sseStream.getReader();
+  const isCurrent = options.isCurrent ?? (() => true);
+  let clientCancelled = false;
+  let terminalReported = false;
+  const reportTerminal = (status: ResponsesTerminalStatus) => {
+    if (terminalReported || clientCancelled || !isCurrent()) return;
+    terminalReported = true;
+    options.onTerminal?.(status);
+  };
+  const cancel = () => {
+    clientCancelled = true;
+    void reader.cancel().catch(() => {});
+  };
+  ws.data.cancel = cancel;
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let terminalSeen = false;
+
+  const handlePayload = (payload: string): boolean => {
+    if (!isCurrent()) return true;
+    if (payload === "[DONE]") return false;
+    try {
+      options.onSsePayload?.(payload);
+    } catch {
+      /* payload observation must not affect WebSocket delivery */
+    }
+    const type = payloadType(payload);
+    if (!type) {
+      reportTerminal("incomplete");
+      sendProtocolError(ws, 502, "Invalid JSON payload in upstream SSE frame");
+      terminalSeen = true;
+      void reader.cancel().catch(() => {});
+      return true;
+    }
+    if (terminalSeen) return true;
+    sendTextFrame(ws, payload);
+    const terminalStatus = terminalStatusFromType(type);
+    if (terminalStatus) {
+      reportTerminal(terminalStatus);
+      terminalSeen = true;
+      void reader.cancel().catch(() => {});
+      return true;
+    }
+    return false;
+  };
+
+  try {
+    while (!terminalSeen) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let next: { block: string; rest: string } | null;
+      while ((next = nextSseBlock(buffer))) {
+        buffer = next.rest;
+        const payload = parseSseBlock(next.block);
+        if (payload && handlePayload(payload)) break;
+      }
+    }
+    buffer += decoder.decode();
+    if (!terminalSeen && buffer.trim()) {
+      const payload = parseSseBlock(buffer);
+      if (payload) handlePayload(payload);
+    }
+    if (!terminalSeen && isCurrent() && !clientCancelled) {
+      reportTerminal("incomplete");
+      sendProtocolError(ws, 502, "Upstream stream ended before response terminal event");
+    }
+  } catch (err) {
+    if (!terminalSeen && isCurrent() && ws.readyState === OPEN) {
+      if (!(err instanceof WsSendDroppedError)) reportTerminal("incomplete");
+      sendProtocolError(ws, 502, err instanceof Error ? err.message : String(err));
+    }
+  } finally {
+    if (ws.data.cancel === cancel) ws.data.cancel = undefined;
+  }
+}
+
+export function sendResponsesJsonAsEvents(
+  ws: ServerWebSocket<WsData>,
+  response: Record<string, unknown>,
+  onTerminal?: ResponsesTerminalReporter,
+  onPayload?: ResponsesPayloadObserver,
+): void {
+  const sendObservedFrame = (payload: Record<string, unknown>) => {
+    const text = JSON.stringify(payload);
+    try {
+      onPayload?.(text);
+    } catch {
+      /* payload observation must not affect WebSocket delivery */
+    }
+    sendTextFrame(ws, text);
+  };
+  const output = Array.isArray(response.output) ? response.output : [];
+  sendObservedFrame({
+    type: "response.created",
+    response: { ...response, status: "in_progress", output: [] },
+  });
+  output.forEach((item, outputIndex) => {
+    sendObservedFrame({
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item,
+    });
+  });
+  const finalStatus = response.status === "failed" || response.status === "incomplete"
+    ? response.status
+    : "completed";
+  sendObservedFrame({
+    type: `response.${finalStatus}` as "response.completed" | "response.failed" | "response.incomplete",
+    response: { ...response, status: finalStatus },
+  });
+  onTerminal?.(finalStatus);
+}
+
+function errorPayloadFromText(text: string): Record<string, unknown> {
+  try {
+    const json = JSON.parse(text) as { error?: unknown };
+    if (json.error && typeof json.error === "object" && !Array.isArray(json.error)) {
+      return json.error as Record<string, unknown>;
+    }
+  } catch {
+    /* fall through */
+  }
+  return {
+    type: "upstream_error",
+    message: text ? text.slice(0, 500) : "Upstream request failed",
+  };
+}
+
+export async function sendResponseToWebSocket(
+  ws: ServerWebSocket<WsData>,
+  response: Response,
+  isCurrent: () => boolean,
+  options: {
+    onTerminal?: ResponsesTerminalReporter;
+    onSsePayload?: ResponsesPayloadObserver;
+  } = {},
+): Promise<void> {
+  if (!isCurrent()) {
+    await response.body?.cancel().catch(() => {});
+    return;
+  }
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    if (!isCurrent()) return;
+    sendJsonFrame(ws, buildWsErrorFrame(response.status, errorPayloadFromText(text), response.headers));
+    return;
+  }
+
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  if (!response.body) {
+    options.onTerminal?.("incomplete");
+    sendJsonFrame(ws, buildWsErrorFrame(502, {
+      type: "protocol_error",
+      code: "websocket_protocol_error",
+      message: `Unexpected successful upstream response without a body (${response.status})`,
+    }, response.headers));
+    return;
+  }
+
+  if (contentType.includes("text/event-stream")) {
+    await pumpResponsesSseToWebSocket(ws, response.body, {
+      isCurrent,
+      onTerminal: options.onTerminal,
+      onSsePayload: options.onSsePayload,
+    });
+    return;
+  }
+
+  if (contentType.includes("application/json")) {
+    const text = await response.text();
+    if (!isCurrent()) return;
+    const json = JSON.parse(text) as Record<string, unknown>;
+    sendResponsesJsonAsEvents(ws, json, options.onTerminal, options.onSsePayload);
+    return;
+  }
+
+  const { prefix, stream } = await readBoundedPrefix(response.body);
+  if (!isCurrent()) {
+    await stream.cancel().catch(() => {});
+    return;
+  }
+  if (looksLikeSse(prefix)) {
+    await pumpResponsesSseToWebSocket(ws, stream, {
+      isCurrent,
+      onTerminal: options.onTerminal,
+      onSsePayload: options.onSsePayload,
+    });
+    return;
+  }
+
+  const text = await new Response(stream).text();
+  if (!isCurrent()) return;
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) {
+    const json = JSON.parse(trimmed) as Record<string, unknown>;
+    sendResponsesJsonAsEvents(ws, json, options.onTerminal, options.onSsePayload);
+    return;
+  }
+
+  options.onTerminal?.("incomplete");
+  sendJsonFrame(ws, buildWsErrorFrame(502, {
+    type: "protocol_error",
+    code: "websocket_protocol_error",
+    message: `Unexpected successful non-SSE upstream response (${contentType || "missing content-type"})`,
+  }, response.headers));
+}
+
+export async function readBoundedPrefix(
+  body: ReadableStream<Uint8Array>,
+  maxBytes = 4096,
+): Promise<{ prefix: Uint8Array; stream: ReadableStream<Uint8Array> }> {
+  const reader = body.getReader();
+  const chunks: Uint8Array[] = [];
+  let remainder: Uint8Array | undefined;
+  let total = 0;
+  while (total < maxBytes) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const take = Math.min(value.byteLength, maxBytes - total);
+    if (take > 0) {
+      chunks.push(value.slice(0, take));
+      total += take;
+    }
+    if (take < value.byteLength) {
+      remainder = value.slice(take);
+      break;
+    }
+  }
+  const prefix = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    prefix.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      if (prefix.byteLength > 0) controller.enqueue(prefix);
+      if (remainder && remainder.byteLength > 0) controller.enqueue(remainder);
+    },
+    async pull(controller) {
+      const { done, value } = await reader.read();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+  return { prefix, stream };
+}
+
+export function looksLikeSse(prefix: Uint8Array): boolean {
+  const text = new TextDecoder().decode(prefix);
+  return /^\s*(event:|data:)/.test(text);
+}