@iislee/opencodex 2.11.0

package/src/server/request-decompress.ts

@@ -0,0 +1,132 @@
+import { gunzipSync, inflateRawSync, inflateSync, zstdDecompressSync } from "node:zlib";
+import type { TranslatorBudget } from "../lib/translator-budget";
+
+/**
+ * Request-body decompression for the /v1/responses data plane.
+ *
+ * Codex CLI compresses Responses HTTP bodies with zstd when its
+ * `enable_request_compression` feature fires (default ON): auth is the codex
+ * backend AND the provider is the built-in `openai` id (codex-rs client.rs
+ * responses_request_compression). Under Design B injection the provider id IS
+ * `openai`, so the HTTP fallback path (WebSocket unavailable) delivers
+ * `content-encoding: zstd` bodies that `req.json()` cannot parse.
+ */
+
+/**
+ * Cap decompressed request bodies (a compressed bomb must not inflate unbounded). Codex compresses
+ * EVERY responses request with zstd (no size threshold), and image-heavy histories inflate fast:
+ * ~12 full-res screenshots as base64 already cross 64MB decompressed. The proxy is fed by the user's
+ * own local Codex over loopback, so the bomb threat is weak; this cap is really an OOM guard. Keep it
+ * generous enough that ordinary multi-image sessions decode, while still bounding a runaway body.
+ */
+export const MAX_DECOMPRESSED_BODY_BYTES = 256 * 1024 * 1024;
+
+export class UnsupportedContentEncodingError extends Error {
+  constructor(readonly encoding: string) {
+    super(`Unsupported content-encoding: ${encoding}`);
+  }
+}
+
+export class DecompressedBodyTooLargeError extends Error {
+  constructor(readonly bytes: number, limit: number = MAX_DECOMPRESSED_BODY_BYTES) {
+    super(`Decompressed request body exceeds ${limit} bytes`);
+  }
+}
+
+function assertBodySizeWithinLimit(body: Uint8Array, maxBytes: number): Uint8Array {
+  if (body.byteLength > maxBytes) throw new DecompressedBodyTooLargeError(body.byteLength, maxBytes);
+  return body;
+}
+
+function declaredBodyLength(req: Request): number | null {
+  const raw = req.headers.get("content-length");
+  if (raw === null || raw.trim() === "") return null;
+  const length = Number(raw);
+  return Number.isFinite(length) && length >= 0 ? length : null;
+}
+
+function inflateDeflateBody(compressed: Uint8Array<ArrayBuffer>, opts: { maxOutputLength: number }): Uint8Array {
+  // HTTP "deflate" appears both zlib-wrapped and raw in the wild (Bun.deflateSync emits raw,
+  // which the previous Bun.inflateSync accepted). Try zlib-wrapped first, fall back to raw —
+  // but never swallow the size-cap abort.
+  try {
+    return inflateSync(compressed, opts);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException | null)?.code === "ERR_BUFFER_TOO_LARGE") throw err;
+    return inflateRawSync(compressed, opts);
+  }
+}
+
+export function decodeRequestBody(
+  raw: Uint8Array,
+  contentEncoding: string | null,
+  maxBytes: number = MAX_DECOMPRESSED_BODY_BYTES,
+): Uint8Array {
+  const encoding = (contentEncoding ?? "").trim().toLowerCase();
+  if (encoding === "" || encoding === "identity") return assertBodySizeWithinLimit(raw, maxBytes);
+  const compressed = raw as Uint8Array<ArrayBuffer>;
+  // `maxOutputLength` makes zlib abort DURING inflation (ERR_BUFFER_TOO_LARGE), so a
+  // decompression bomb never allocates beyond the cap — checking after the fact would
+  // already have paid the full allocation (review finding, PR #96).
+  const opts = { maxOutputLength: maxBytes };
+  let decoded: Uint8Array;
+  try {
+    if (encoding === "zstd") decoded = zstdDecompressSync(compressed, opts);
+    else if (encoding === "gzip" || encoding === "x-gzip") decoded = gunzipSync(compressed, opts);
+    else if (encoding === "deflate") decoded = inflateDeflateBody(compressed, opts);
+    // Multi-codings ("zstd, gzip") and unknown tokens are rejected rather than guessed.
+    else throw new UnsupportedContentEncodingError(encoding);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException | null)?.code === "ERR_BUFFER_TOO_LARGE") {
+      throw new DecompressedBodyTooLargeError(maxBytes + 1, maxBytes);
+    }
+    throw err;
+  }
+  return assertBodySizeWithinLimit(decoded, maxBytes);
+}
+
+/** Parse a bounded JSON request body, transparently decoding compressed payloads. */
+export async function readBoundedJsonRequestBody(
+  req: Request,
+  maxBytes: number,
+  budget?: TranslatorBudget,
+): Promise<unknown> {
+  const encoding = req.headers.get("content-encoding");
+  const declaredLength = declaredBodyLength(req);
+  // Reject an honest oversized declaration before req.arrayBuffer() can allocate it.
+  // Missing, malformed, or dishonest declarations remain covered by decodeRequestBody's
+  // post-read cap below.
+  if (declaredLength !== null && declaredLength > maxBytes) {
+    throw new DecompressedBodyTooLargeError(declaredLength, maxBytes);
+  }
+  const releaseReservation = budget && declaredLength !== null && declaredLength > 0
+    ? budget.observeAcceptedRequestCopy(declaredLength)
+    : undefined;
+  let raw: Uint8Array;
+  try {
+    raw = new Uint8Array(await req.arrayBuffer());
+  } finally {
+    releaseReservation?.();
+  }
+  const releaseRaw = budget?.observeAcceptedRequestCopy(raw.byteLength);
+  let releaseDecoded: (() => void) | undefined;
+  let releaseText: (() => void) | undefined;
+  try {
+    const decoded = decodeRequestBody(raw, encoding, maxBytes);
+    releaseDecoded = decoded === raw ? undefined : budget?.observeAcceptedRequestCopy(decoded.byteLength);
+    const text = new TextDecoder().decode(decoded);
+    releaseText = budget?.observeAcceptedRequestCopy(new TextEncoder().encode(text).byteLength);
+    const parsed = JSON.parse(text);
+    budget?.observeAcceptedRequestCopy(new TextEncoder().encode(JSON.stringify(parsed)).byteLength);
+    return parsed;
+  } finally {
+    releaseText?.();
+    releaseDecoded?.();
+    releaseRaw?.();
+  }
+}
+
+/** Parse a JSON data-plane body using the shared 256 MiB admission cap. */
+export function readJsonRequestBody(req: Request, budget?: TranslatorBudget): Promise<unknown> {
+  return readBoundedJsonRequestBody(req, MAX_DECOMPRESSED_BODY_BYTES, budget);
+}

package/src/server/request-log-conversation.ts

@@ -0,0 +1,168 @@
+/**
+ * Best-effort chat/session correlation for Logs / usage.jsonl (#330).
+ * Opaque ids only — never persist raw emails or Claude Desktop system-hash fallbacks.
+ */
+import { createHash } from "node:crypto";
+
+/** Reject absurdly long client strings before hashing (DoS / JSONL bloat). */
+export const LOG_CONVERSATION_ID_INPUT_MAX = 4096;
+/** Persisted / filterable form is always a 32-char hex digest. */
+export const LOG_CONVERSATION_ID_LEN = 32;
+
+function hasControlChars(value: string): boolean {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+function sanitizeConversationIdInput(raw: string | undefined | null): string | undefined {
+  if (typeof raw !== "string") return undefined;
+  const trimmed = raw.trim();
+  if (!trimmed) return undefined;
+  // Reject control characters that would break JSONL / UI paste.
+  if (hasControlChars(trimmed)) return undefined;
+  if (trimmed.length > LOG_CONVERSATION_ID_INPUT_MAX) return undefined;
+  return trimmed;
+}
+
+/**
+ * Cap / sanitize a correlation id for persistence.
+ * Always hashes so client-controlled headers cannot land emails or short secrets in usage.jsonl.
+ */
+export function normalizeLogConversationId(raw: string | undefined | null): string | undefined {
+  const trimmed = sanitizeConversationIdInput(raw);
+  if (!trimmed) return undefined;
+  return createHash("sha256").update(trimmed).digest("hex").slice(0, LOG_CONVERSATION_ID_LEN);
+}
+
+/**
+ * Filter match: accept either the persisted digest or the original preimage
+ * (so pasting from Logs detail or the client-facing session id both work).
+ */
+export function matchesLogConversationId(
+  stored: string | undefined,
+  query: string | undefined | null,
+): boolean {
+  if (!stored) return false;
+  const trimmed = typeof query === "string" ? query.trim() : "";
+  if (!trimmed) return false;
+  if (stored === trimmed) return true;
+  const hashed = normalizeLogConversationId(trimmed);
+  return hashed !== undefined && stored === hashed;
+}
+
+/**
+ * Codex/Claude/Cursor priority for Responses-shaped requests:
+ * parent thread header > session_id / session-id > thread-id > cursor conversation id.
+ */
+export function sessionIdHeaderFromRequest(headers: Headers): string | null {
+  return headers.get("session_id") ?? headers.get("session-id");
+}
+
+export function conversationIdFromResponsesRequest(input: {
+  clientThreadId?: string;
+  sessionIdHeader?: string | null;
+  threadIdHeader?: string | null;
+  cursorConversationId?: string;
+}): string | undefined {
+  return normalizeLogConversationId(
+    input.clientThreadId
+      ?? input.sessionIdHeader
+      ?? input.threadIdHeader
+      ?? input.cursorConversationId,
+  );
+}
+
+/**
+ * Claude Code metadata.user_id only — never the system-hash Desktop fallback.
+ * Hashes the raw user_id once (same opacity goal as inbound prompt_cache_key).
+ */
+export function conversationIdFromClaudeMetadata(
+  metadata: { user_id?: unknown } | null | undefined,
+): string | undefined {
+  if (!metadata || typeof metadata.user_id !== "string") return undefined;
+  return normalizeLogConversationId(metadata.user_id);
+}
+
+/** @deprecated Prefer conversationIdFromClaudeMetadata; kept for call-site clarity. */
+export function conversationIdFromClaudeCacheKey(
+  cacheKeySource: "metadata" | "system" | null | undefined,
+  promptCacheKey: string | undefined,
+): string | undefined {
+  if (cacheKeySource !== "metadata") return undefined;
+  // prompt_cache_key is already sha256(user_id)[:32] from inbound — persist as-is
+  // (do not re-hash) so native and translated paths stay aligned when callers pass
+  // the preimage via conversationIdFromClaudeMetadata instead.
+  const trimmed = sanitizeConversationIdInput(promptCacheKey);
+  if (!trimmed) return undefined;
+  if (trimmed.length === LOG_CONVERSATION_ID_LEN && /^[0-9a-f]+$/i.test(trimmed)) return trimmed.toLowerCase();
+  return normalizeLogConversationId(trimmed);
+}
+
+export interface ConversationLogTotals {
+  requests: number;
+  totalTokens: number;
+  estimatedCostUsd: number;
+  pricedRequests: number;
+  unpricedRequests: number;
+  unmeteredRequests: number;
+}
+
+type TotalsSource = {
+  totalTokens?: number;
+  usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  usageStatus?: string;
+  displayMetrics?: {
+    cost?:
+      | { kind: "value"; estimate: { cost: { total: number } } }
+      | { kind: "unavailable"; reason: string };
+  };
+};
+
+function rowTokenTotal(entry: TotalsSource): number | undefined {
+  if (typeof entry.totalTokens === "number" && Number.isFinite(entry.totalTokens) && entry.totalTokens >= 0) {
+    return entry.totalTokens;
+  }
+  const usageTotal = entry.usage?.totalTokens;
+  if (typeof usageTotal === "number" && Number.isFinite(usageTotal) && usageTotal >= 0) return usageTotal;
+  const input = entry.usage?.inputTokens;
+  const output = entry.usage?.outputTokens;
+  if (typeof input === "number" && typeof output === "number" && Number.isFinite(input) && Number.isFinite(output)) {
+    return Math.max(0, input) + Math.max(0, output);
+  }
+  return undefined;
+}
+
+/** Sum tokens/cost for the currently loaded log slice matching a conversation filter. */
+export function summarizeConversationLogs(entries: readonly TotalsSource[]): ConversationLogTotals {
+  let totalTokens = 0;
+  let estimatedCostUsd = 0;
+  let pricedRequests = 0;
+  let unpricedRequests = 0;
+  let unmeteredRequests = 0;
+  for (const entry of entries) {
+    const tokens = rowTokenTotal(entry);
+    if (tokens !== undefined) totalTokens += tokens;
+    if (entry.usageStatus === "unsupported") {
+      unmeteredRequests += 1;
+      continue;
+    }
+    const cost = entry.displayMetrics?.cost;
+    if (cost?.kind === "value" && Number.isFinite(cost.estimate.cost.total) && cost.estimate.cost.total >= 0) {
+      estimatedCostUsd += cost.estimate.cost.total;
+      pricedRequests += 1;
+      continue;
+    }
+    unpricedRequests += 1;
+  }
+  return {
+    requests: entries.length,
+    totalTokens,
+    estimatedCostUsd,
+    pricedRequests,
+    unpricedRequests,
+    unmeteredRequests,
+  };
+}