@bitkyc08/opencodex 2.8.0 → 2.9.0

package/src/adapters/cursor/framing.ts

@@ -26,6 +26,18 @@ export interface DecodedConnectFrames {
   remainder: Uint8Array;
 }
 
+interface CopyReservation {
+  commitRetained(): void;
+  release(): void;
+}
+
+interface InspectedConnectFrame {
+  flags: number;
+  length: number;
+  payloadStart: number;
+  readBytes: number;
+}
+
 export class ConnectFrameError extends Error {
   constructor(
     public readonly code: ConnectFrameErrorCode,
@@ -65,27 +77,33 @@ export function encodeConnectFrame(
   return frame;
 }
 
-export function tryDecodeConnectFrame(input: Uint8Array, offset = 0): DecodedConnectFrame | null {
+export function tryDecodeConnectFrame(
+  input: Uint8Array,
+  offset = 0,
+  maxPayloadBytes = MAX_CONNECT_FRAME_PAYLOAD_BYTES,
+  reservePayloadCopy?: (bytes: number) => CopyReservation | undefined,
+): DecodedConnectFrame | null {
   assertOffset(input, offset);
-  if (input.length - offset < CONNECT_FRAME_HEADER_BYTES) return null;
-
-  const view = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset);
-  const flags = view.getUint8(0);
-  const length = view.getUint32(1, false);
-  const readBytes = CONNECT_FRAME_HEADER_BYTES + length;
-  if (input.length - offset < readBytes) return null;
-
-  const payloadStart = offset + CONNECT_FRAME_HEADER_BYTES;
-  const payloadEnd = payloadStart + length;
-  const payload = input.slice(payloadStart, payloadEnd);
+  const inspected = inspectConnectFrame(input, offset, maxPayloadBytes);
+  if (!inspected) return null;
+  const payloadEnd = inspected.payloadStart + inspected.length;
+  const reservation = reservePayloadCopy?.(inspected.length);
+  let payload: Uint8Array;
+  try {
+    payload = input.slice(inspected.payloadStart, payloadEnd);
+    reservation?.commitRetained();
+  } catch (error) {
+    reservation?.release();
+    throw error;
+  }
   return {
     frame: {
-      flags,
+      flags: inspected.flags,
       payload,
-      compressed: isConnectFrameCompressed(flags),
-      endStream: isConnectFrameEndStream(flags),
+      compressed: isConnectFrameCompressed(inspected.flags),
+      endStream: isConnectFrameEndStream(inspected.flags),
     },
-    readBytes,
+    readBytes: inspected.readBytes,
   };
 }
 
@@ -108,19 +126,76 @@ export function decodeConnectFrames(input: Uint8Array): ConnectFrame[] {
   return frames;
 }
 
-export function decodeAvailableConnectFrames(input: Uint8Array): DecodedConnectFrames {
-  const frames: ConnectFrame[] = [];
+export function decodeAvailableConnectFrames(
+  input: Uint8Array,
+  maxPayloadBytes = MAX_CONNECT_FRAME_PAYLOAD_BYTES,
+  availableFrameSlots = Number.POSITIVE_INFINITY,
+  reservePayloadCopy?: (bytes: number) => CopyReservation | undefined,
+): DecodedConnectFrames {
+  const planned: Array<InspectedConnectFrame & { reservation?: CopyReservation }> = [];
   let offset = 0;
-  while (offset < input.length) {
-    const decoded = tryDecodeConnectFrame(input, offset);
-    if (!decoded) break;
-    frames.push(decoded.frame);
-    offset += decoded.readBytes;
+  let remainderReservation: CopyReservation | undefined;
+  try {
+    while (offset < input.length && planned.length < availableFrameSlots) {
+      const inspected = inspectConnectFrame(input, offset, maxPayloadBytes);
+      if (!inspected) break;
+      const reservation = reservePayloadCopy?.(inspected.length);
+      planned.push({ ...inspected, reservation });
+      offset += inspected.readBytes;
+    }
+    const remainderBytes = offset === input.length ? 0 : bufferedPayloadBytes(input, offset);
+    remainderReservation = reservePayloadCopy?.(remainderBytes);
+
+    // Keep every reservation transient until every batch allocation succeeds. A later admission
+    // failure can then roll the entire batch back without needing ownership of unreturned frames.
+    const frames = planned.map(({ flags, length, payloadStart }) => {
+      const payload = input.slice(payloadStart, payloadStart + length);
+      return {
+        flags,
+        payload,
+        compressed: isConnectFrameCompressed(flags),
+        endStream: isConnectFrameEndStream(flags),
+      };
+    });
+    const remainder = offset === input.length ? new Uint8Array() : input.slice(offset);
+    for (const entry of planned) entry.reservation?.commitRetained();
+    remainderReservation?.commitRetained();
+    return { frames, remainder };
+  } catch (error) {
+    for (const entry of planned) entry.reservation?.release();
+    remainderReservation?.release();
+    throw error;
   }
-  return {
-    frames,
-    remainder: offset === input.length ? new Uint8Array() : input.slice(offset),
-  };
+}
+
+function inspectConnectFrame(
+  input: Uint8Array,
+  offset: number,
+  maxPayloadBytes: number,
+): InspectedConnectFrame | null {
+  if (input.length - offset < CONNECT_FRAME_HEADER_BYTES) return null;
+  const view = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset);
+  const flags = view.getUint8(0);
+  const length = view.getUint32(1, false);
+  if (length > maxPayloadBytes) {
+    throw new ConnectFrameError("payload_too_large", `Connect frame payload too large: ${length}`);
+  }
+  const readBytes = CONNECT_FRAME_HEADER_BYTES + length;
+  if (input.length - offset < readBytes) return null;
+  return { flags, length, payloadStart: offset + CONNECT_FRAME_HEADER_BYTES, readBytes };
+}
+
+function bufferedPayloadBytes(input: Uint8Array, start: number): number {
+  let offset = start;
+  let payloadBytes = 0;
+  while (input.byteLength - offset >= CONNECT_FRAME_HEADER_BYTES) {
+    const length = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset).getUint32(1, false);
+    const available = Math.min(length, input.byteLength - offset - CONNECT_FRAME_HEADER_BYTES);
+    payloadBytes += available;
+    if (available < length) break;
+    offset += CONNECT_FRAME_HEADER_BYTES + length;
+  }
+  return payloadBytes;
 }
 
 function assertOffset(input: Uint8Array, offset: number): void {

package/src/adapters/cursor/kv-store.ts

@@ -1,3 +1,5 @@
+import type { TranslatorBudget } from "../../lib/translator-budget";
+
 export interface CursorKvStore {
   get(key: string): Uint8Array | undefined;
   set(key: string, value: Uint8Array): void;
@@ -7,19 +9,44 @@ function cloneBytes(value: Uint8Array): Uint8Array {
   return new Uint8Array(value);
 }
 
-export function createCursorKvStore(seed: Record<string, Uint8Array> = {}): CursorKvStore {
+export function createCursorKvStore(
+  seed: Record<string, Uint8Array>,
+  budget: TranslatorBudget,
+): CursorKvStore {
   const values = new Map<string, Uint8Array>();
+  const encoder = new TextEncoder();
+  const sizes = new Map<string, number>();
   for (const [key, value] of Object.entries(seed)) {
+    const bytes = encoder.encode(key).byteLength + value.byteLength;
+    budget.chargeRetained(bytes, { kind: "cursor_kv" });
     values.set(key, cloneBytes(value));
+    sizes.set(key, bytes);
   }
 
   return {
     get(key) {
       const value = values.get(key);
-      return value ? cloneBytes(value) : undefined;
+      if (!value) return undefined;
+      budget.chargeRetained(value.byteLength, { kind: "cursor_kv" });
+      const cloned = cloneBytes(value);
+      queueMicrotask(() => budget.releaseRetained(value.byteLength, { kind: "cursor_kv" }));
+      return cloned;
     },
     set(key, value) {
-      values.set(key, cloneBytes(value));
+      const nextBytes = encoder.encode(key).byteLength + value.byteLength;
+      const previousBytes = sizes.get(key) ?? 0;
+      const reservation = budget.reserveTransient(nextBytes, { kind: "cursor_kv" });
+      let cloned: Uint8Array;
+      try {
+        cloned = cloneBytes(value);
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+      values.set(key, cloned);
+      sizes.set(key, nextBytes);
+      reservation.commitRetained();
+      budget.releaseRetained(previousBytes, { kind: "cursor_kv" });
     },
   };
 }

package/src/adapters/cursor/live-models.ts

@@ -18,6 +18,7 @@ import { GetUsableModelsResponseSchema } from "./gen/agent_pb";
 
 const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 const CURSOR_DISCOVERY_CLIENT_VERSION = "cli-2026.02.13-41ac335";
+const CURSOR_MODEL_DISCOVERY_MAX_BYTES = 4 * 1024 * 1024;
 
 export interface CursorUsableModelsOptions {
   apiKey: string;
@@ -28,7 +29,7 @@ export interface CursorUsableModelsOptions {
 
 export type CursorUsableModelsResult =
   | { ok: true; models: string[] }
-  | { ok: false; error: "auth" | "http" | "transport" | "timeout" | "decode" | "empty"; detail?: string };
+  | { ok: false; error: "auth" | "http" | "transport" | "timeout" | "decode" | "empty" | "too_large"; detail?: string };
 
 const RETRYABLE_DISCOVERY_ERRORS = new Set(["timeout", "transport"]);
 const DISCOVERY_RETRY_TIMEOUT_MS = 3_000;
@@ -97,12 +98,31 @@ async function fetchCursorUsableModelsOnce(opts: CursorUsableModelsOptions): Pro
 
     let status = 0;
     const chunks: Buffer[] = [];
+    let receivedBytes = 0;
+    let bodyRejected = false;
     req.on("response", headers => {
       status = Number(headers[":status"] ?? 0);
+      const contentLength = Number(headers["content-length"] ?? 0);
+      if (Number.isFinite(contentLength) && contentLength > CURSOR_MODEL_DISCOVERY_MAX_BYTES) {
+        bodyRejected = true;
+        req.close(http2.constants.NGHTTP2_CANCEL);
+        close({ ok: false, error: "too_large", detail: "GetUsableModels response exceeds 4 MiB" });
+      }
+    });
+    req.on("data", (chunk: Buffer) => {
+      if (bodyRejected) return;
+      receivedBytes += chunk.byteLength;
+      if (receivedBytes > CURSOR_MODEL_DISCOVERY_MAX_BYTES) {
+        bodyRejected = true;
+        req.close(http2.constants.NGHTTP2_CANCEL);
+        close({ ok: false, error: "too_large", detail: "GetUsableModels response exceeds 4 MiB" });
+        return;
+      }
+      chunks.push(chunk);
     });
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
     req.on("error", () => close({ ok: false, error: "transport", detail: "HTTP/2 request failed" }));
     req.on("end", () => {
+      if (bodyRejected) return;
       if (status === 401 || status === 403) {
         return close({ ok: false, error: "auth", detail: `HTTP ${status}` });
       }