@yansigit/opencodex 2.31.0

package/src/lib/server-resource-ownership.ts

@@ -0,0 +1,71 @@
+type Cleanup = () => void;
+
+type ServerResourceOwner = {
+  token: symbol;
+  cleanups: Set<Cleanup>;
+};
+
+export type ServerResourceOwnerLease = {
+  release(): void;
+};
+
+const owners: ServerResourceOwner[] = [];
+
+function currentOwner(): ServerResourceOwner | undefined {
+  return owners.at(-1);
+}
+
+/** Acquire ownership for resources created while one server instance starts. */
+export function acquireServerResourceOwner(): ServerResourceOwnerLease {
+  const owner: ServerResourceOwner = {
+    token: Symbol("server-resource-owner"),
+    cleanups: new Set(),
+  };
+  owners.push(owner);
+
+  let released = false;
+  return {
+    release() {
+      if (released) return;
+      released = true;
+      const index = owners.findIndex(candidate => candidate.token === owner.token);
+      if (index !== -1) owners.splice(index, 1);
+      for (const cleanup of [...owner.cleanups]) {
+        try {
+          cleanup();
+        } catch {
+          // Resource cleanup is best-effort and one failed hook must not retain siblings.
+        }
+      }
+      owner.cleanups.clear();
+    },
+  };
+}
+
+/** Attach cleanup to the server instance currently being started. */
+export function registerCurrentServerResourceCleanup(cleanup: Cleanup): () => void {
+  const owner = currentOwner();
+  if (!owner) return () => {};
+  owner.cleanups.add(cleanup);
+  let attached = true;
+  return () => {
+    if (!attached) return;
+    attached = false;
+    owner.cleanups.delete(cleanup);
+  };
+}
+
+/** Test-only reset for isolated lifecycle tests. */
+export function resetServerResourceOwnershipForTests(): void {
+  for (const owner of [...owners].reverse()) {
+    for (const cleanup of [...owner.cleanups]) {
+      try {
+        cleanup();
+      } catch {
+        // Test reset must leave no retained owner even when a synthetic cleanup throws.
+      }
+    }
+    owner.cleanups.clear();
+  }
+  owners.length = 0;
+}

package/src/lib/service-secrets.ts

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { getConfigDir } from "../config";
+
+export function serviceApiTokenFilePath(): string {
+  return join(getConfigDir(), "service-api-token");
+}
+
+/**
+ * App-side service token loading (WinSW native mode has no batch wrapper to read the
+ * token file into the environment). Pure: returns the token or null — the CALLER
+ * assigns it to process.env.OPENCODEX_API_AUTH_TOKEN. Loads only when the env token
+ * is empty and OCX_API_TOKEN_FILE names a readable file.
+ */
+export function loadServiceTokenFromFile(env: Record<string, string | undefined>): string | null {
+  if (env.OPENCODEX_API_AUTH_TOKEN?.trim()) return null;
+  const file = env.OCX_API_TOKEN_FILE?.trim();
+  if (!file) return null;
+  try {
+    const token = readFileSync(file, "utf8").trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/shadow-call.ts

@@ -0,0 +1,61 @@
+/**
+ * Shadow-call intercept source models.
+ *
+ * Codex 0.145.0+ uses `gpt-5.6-luna` for helper calls. Older clients through
+ * 0.144.x used `gpt-5.4-mini`; operators supporting them can restore that
+ * prefix with the `sourceModels` override. Every surface that names the
+ * intercepted model (management API, GUI badges/tooltips, CLI) reads it from
+ * here instead of hard-coding a slug that goes stale on the next client bump.
+ */
+export const DEFAULT_SHADOW_SOURCE_MODELS = ["gpt-5.6-luna"] as const;
+
+/** Normalize a persisted `sourceModels` override; falls back to the defaults. */
+export function shadowSourceModels(configured?: unknown): string[] {
+  const configuredStrings = Array.isArray(configured)
+    ? configured
+      .filter((v): v is string => typeof v === "string" && v.trim() !== "")
+      .map(v => v.trim())
+    : [];
+  return configuredStrings.length > 0 ? configuredStrings : [...DEFAULT_SHADOW_SOURCE_MODELS];
+}
+
+/**
+ * True when `modelId` is one of Codex's helper/shadow source models.
+ * Routed ids (`provider/model`) are hard-excluded: a shadow call is always a
+ * bare native slug, and an explicit routed selection must never be hijacked.
+ */
+export function isShadowSourceModel(modelId: string, configured?: unknown): boolean {
+  if (modelId.includes("/")) return false;
+  return shadowSourceModels(configured).some(prefix => modelId.startsWith(prefix));
+}
+
+/**
+ * The configured source prefix this model matched, or undefined.
+ *
+ * Callers that RECORD the intercepted model must record this rather than the caller's raw
+ * `modelId`. Matching is by prefix, so `gpt-5.6-luna` plus arbitrary trailing text still
+ * intercepts — and the raw string is caller-controlled, reaches `usage.jsonl` and `/api/logs`,
+ * and only passes a pattern-based redactor on the way. A credential family that redactor does
+ * not recognize survives verbatim. Returning the operator-configured prefix keeps the log
+ * field inside a set the operator chose, so no caller string is ever persisted.
+ */
+export function shadowSourceModelPrefix(modelId: string, configured?: unknown): string | undefined {
+  if (modelId.includes("/")) return undefined;
+  return shadowSourceModels(configured).find(prefix => modelId.startsWith(prefix));
+}
+
+/**
+ * Decide whether a matching source model should use the opt-in intercept.
+ *
+ * Before Codex 0.147.0 this checked x-codex-turn-metadata and exempted
+ * request_kind "turn". Codex 0.147.0 can label background helper calls as
+ * "turn", causing them to bypass the intercept (#1684). The fix is to
+ * intercept every configured shadow source model unconditionally — the model
+ * slug alone is a sufficient signal.
+ */
+export function shouldInterceptShadowCall(
+  modelId: string,
+  configured: unknown,
+): boolean {
+  return isShadowSourceModel(modelId, configured);
+}

package/src/lib/sidecar-tracker.ts

@@ -0,0 +1,52 @@
+/**
+ * Lightweight in-flight breadcrumb for sidecar work (web-search / vision), read by crash-guard.
+ *
+ * The proxy's unhandled rejections arrive with a native-only stack, so the throw site is invisible.
+ * To confirm or rule out the strong correlation with sidecar activity (the gpt-mini web-search /
+ * vision passes that run an EXTRA upstream fetch alongside the main turn), each sidecar call brackets
+ * itself with enter()/exit(). crash-guard then records whether any sidecar was in flight when a
+ * rejection fired — turning a guess into evidence without a debugger.
+ */
+let inFlight = 0;
+let lastLabel = "";
+let lastEnterAt = 0;
+
+export function sidecarEnter(label: string): () => void {
+  inFlight++;
+  lastLabel = truncateRetainedUtf8(label, MAX_DIAGNOSTIC_VALUE_BYTES);
+  lastEnterAt = Date.now();
+  let exited = false;
+  return () => {
+    if (exited) return;
+    exited = true;
+    if (inFlight > 0) inFlight--;
+  };
+}
+
+export function sidecarBreadcrumb(): { inFlight: number; lastLabel: string; sinceMs: number } {
+  return {
+    inFlight,
+    lastLabel,
+    sinceMs: lastEnterAt ? Date.now() - lastEnterAt : 0,
+  };
+}
+
+/**
+ * Generic last-activity breadcrumb (any code path, not just sidecars). The proxy's native-only
+ * rejections carry no source location, so we record the most recent meaningful activity —
+ * request path + a short note — to correlate the next fault with what the daemon was doing.
+ */
+let lastActivity = "";
+let lastActivityAt = 0;
+
+export function markActivity(note: string): void {
+  lastActivity = truncateRetainedUtf8(note, MAX_DIAGNOSTIC_VALUE_BYTES);
+  lastActivityAt = Date.now();
+}
+
+export function activityBreadcrumb(): { note: string; sinceMs: number } {
+  return { note: lastActivity, sinceMs: lastActivityAt ? Date.now() - lastActivityAt : 0 };
+}
+import { truncateRetainedUtf8 } from "./admission";
+
+const MAX_DIAGNOSTIC_VALUE_BYTES = 8 * 1024;

package/src/lib/sse-decoder.ts

@@ -0,0 +1,364 @@
+import {
+  TRANSLATOR_MAX_SSE_EVENT_BYTES,
+  TranslatorBudgetExceededError,
+  type TranslatorBudget,
+} from "./translator-budget";
+
+export interface ServerSentEvent {
+  event?: string;
+  data: string;
+}
+
+export type SseRecord =
+  | { kind: "event"; event?: string; data: string }
+  | { kind: "comment"; comment: string };
+
+/**
+ * Extract one SSE field value from a single line, or null when the line is a different field.
+ *
+ * The space after the colon is OPTIONAL in text/event-stream: `data:{"a":1}` is as valid as
+ * `data: {"a":1}`. Parsers that hardcoded `startsWith("data: ")` silently dropped every frame
+ * from a producer that omits it, which surfaced as a completed turn with no content (#1170).
+ *
+ * Strips at most ONE leading space — the same rule `decodeServerSentEvents` applies below — so a
+ * payload that legitimately begins with whitespace keeps the rest of it. Does not trim the value:
+ * callers own that choice, and some of them intentionally keep trailing bytes.
+ */
+export function sseFieldValue(line: string, field: string): string | null {
+  if (!line.startsWith(field)) return null;
+  const rest = line.slice(field.length);
+  // A colonless field line is the field with an empty value per the SSE rules, and
+  // `decodeServerSentEvents` below treats it that way (`colon < 0` -> valueStart = line.length).
+  // These helpers must not disagree with the decoder they mirror.
+  if (rest.length === 0) return "";
+  if (!rest.startsWith(":")) return null;
+  return rest.startsWith(": ") ? rest.slice(2) : rest.slice(1);
+}
+
+/**
+ * Offset-only variant of {@link sseFieldValue} for parsers that index into a larger buffer.
+ *
+ * Returns the index where the field's value begins within `text`, or -1 when the line at
+ * `[lineStart, lineEnd)` is a different field. Slicing nothing matters for the live Claude relay,
+ * whose translator-budget accounting reserves bytes by offset — materializing the line first would
+ * allocate the very string the budget exists to bound.
+ */
+export function sseFieldOffset(text: string, lineStart: number, lineEnd: number, field: string): number {
+  if (!text.startsWith(field, lineStart)) return -1;
+  let valueStart = lineStart + field.length;
+  // Colonless field line: empty value, positioned at end-of-line (matches the decoder).
+  if (valueStart >= lineEnd) return lineEnd;
+  if (text[valueStart] !== ":") return -1;
+  valueStart += 1;
+  if (valueStart < lineEnd && text[valueStart] === " ") valueStart += 1;
+  return valueStart;
+}
+
+/**
+ * Decode text/event-stream records across arbitrary fetch chunk boundaries.
+ *
+ * The final record is dispatched at EOF even when the upstream omits the trailing blank line or
+ * final newline. That matters for compatible APIs that place a terminal event in the last bytes of
+ * the body: dropping that record turns a successful response into an adapter_eof failure.
+ */
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments: true; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<SseRecord>;
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: false; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent>;
+export async function* decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: boolean; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent | SseRecord> {
+  const translatorBudget = options.translatorBudget;
+  const reader = source.getReader();
+  const decoder = new TextDecoder();
+  let lineBuffer = "";
+  let lineRawBytes = 0;
+  let lineRetainedBytes = 0;
+  let event: string | undefined;
+  let eventBytes = 0;
+  let dataLines: string[] = [];
+  let dataLinesBytes = 0;
+  const scope = { kind: "live_transient" as const };
+
+  const utf8SliceBytes = (value: string, start: number, end: number): number => {
+    let bytes = 0;
+    for (let index = start; index < end; index++) {
+      const codePoint = value.codePointAt(index)!;
+      if (codePoint <= 0x7f) bytes += 1;
+      else if (codePoint <= 0x7ff) bytes += 2;
+      else if (codePoint <= 0xffff) bytes += 3;
+      else {
+        bytes += 4;
+        index += 1;
+      }
+    }
+    return bytes;
+  };
+
+  const linePrefixAfter = (sourceValue: string, start: number, end: number): string => {
+    if (lineBuffer.length >= 6) return lineBuffer.slice(0, 6);
+    return (lineBuffer + sourceValue.slice(start, Math.min(end, start + 6 - lineBuffer.length))).slice(0, 6);
+  };
+
+  const accountedLineBytes = (rawBytes: number, prefix: string): number => {
+    if (prefix.length < 5 && "data:".startsWith(prefix)) return 0;
+    if (!prefix.startsWith("data:")) return rawBytes;
+    return Math.max(0, rawBytes - (prefix[5] === " " ? 6 : 5));
+  };
+
+  const appendLine = (sourceValue: string, start: number, end: number): void => {
+    if (start >= end) return;
+    const nextRawBytes = lineRawBytes + utf8SliceBytes(sourceValue, start, end);
+    const prefix = linePrefixAfter(sourceValue, start, end);
+    const nextRetainedBytes = accountedLineBytes(nextRawBytes, prefix);
+    if (prefix.startsWith("data:")) {
+      const logicalEventBytes = dataLinesBytes + dataLines.length + nextRetainedBytes;
+      if (logicalEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+        throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+      }
+    }
+    const reservation = translatorBudget.reserveTransient(nextRawBytes, scope);
+    try {
+      const fragment = sourceValue.slice(start, end);
+      lineBuffer += fragment;
+      reservation.commitRetained();
+      translatorBudget.releaseRetained(lineRetainedBytes, scope);
+      lineRawBytes = nextRawBytes;
+      lineRetainedBytes = nextRawBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  // Prompt cancellation channel: an abort cancels the underlying reader directly, which
+  // settles any in-flight read() so a consumer's iterator.return() cannot hang behind an
+  // idle upstream (a plain generator return waits for the pending await first).
+  const signal = options?.signal;
+  const onAbort = () => { reader.cancel(signal?.reason).catch(() => { /* already closed */ }); };
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+
+  const includeComments = options?.includeComments === true;
+
+  const dispatch = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    if (dataLines.length === 0) {
+      translatorBudget.releaseRetained(eventBytes, scope);
+      event = undefined;
+      eventBytes = 0;
+      return undefined;
+    }
+    const payloadBytes = dataLinesBytes + Math.max(0, dataLines.length - 1);
+    if (payloadBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+      throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+    }
+    let data: string;
+    if (dataLines.length === 1) {
+      data = dataLines[0]!;
+    } else {
+      const reservation = translatorBudget.reserveTransient(payloadBytes, scope);
+      try {
+        data = dataLines.join("\n");
+        reservation.commitRetained();
+        translatorBudget.releaseRetained(dataLinesBytes, scope);
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+    }
+    const record = { ...(event ? { event } : {}), data };
+    const retainedRecordBytes = payloadBytes + eventBytes;
+    event = undefined;
+    eventBytes = 0;
+    dataLines = [];
+    dataLinesBytes = 0;
+    return {
+      record: includeComments ? { kind: "event", ...record } : record,
+      bytes: retainedRecordBytes,
+    };
+  };
+
+  const acceptLine = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    let line = lineBuffer;
+    let retainedLineBytes = lineRetainedBytes;
+    let lineOwned = true;
+    const releaseLine = (): void => {
+      if (!lineOwned) return;
+      lineOwned = false;
+      translatorBudget.releaseRetained(retainedLineBytes, scope);
+    };
+    lineBuffer = "";
+    lineRawBytes = 0;
+    lineRetainedBytes = 0;
+    try {
+      if (line.endsWith("\r")) {
+        const nextLineBytes = retainedLineBytes - 1;
+        const reservation = translatorBudget.reserveTransient(nextLineBytes, scope);
+        try {
+          const nextLine = line.slice(0, -1);
+          reservation.commitRetained();
+          translatorBudget.releaseRetained(retainedLineBytes, scope);
+          line = nextLine;
+          retainedLineBytes = nextLineBytes;
+        } catch (error) {
+          reservation.release();
+          throw error;
+        }
+      }
+      if (line === "") {
+        releaseLine();
+        return dispatch();
+      }
+      if (line.startsWith(":")) {
+        if (!includeComments) {
+          releaseLine();
+          return undefined;
+        }
+        const commentStart = line[1] === " " ? 2 : 1;
+        const commentBytes = utf8SliceBytes(line, commentStart, line.length);
+        translatorBudget.chargeRetained(commentBytes, scope);
+        try {
+          const comment = line.slice(commentStart);
+          releaseLine();
+          return { record: { kind: "comment", comment }, bytes: commentBytes };
+        } catch (error) {
+          translatorBudget.releaseRetained(commentBytes, scope);
+          throw error;
+        }
+      }
+
+      const colon = line.indexOf(":");
+      const fieldEnd = colon < 0 ? line.length : colon;
+      const fieldBytes = utf8SliceBytes(line, 0, fieldEnd);
+      const fieldReservation = translatorBudget.reserveTransient(fieldBytes, scope);
+      let field = "";
+      try {
+        field = line.slice(0, fieldEnd);
+        fieldReservation.commitRetained();
+      } catch (error) {
+        fieldReservation.release();
+        throw error;
+      }
+      try {
+        let valueStart = colon < 0 ? line.length : colon + 1;
+        if (line[valueStart] === " ") valueStart += 1;
+        const valueBytes = utf8SliceBytes(line, valueStart, line.length);
+
+        if (field === "event") {
+          const reservation = translatorBudget.reserveTransient(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            reservation.commitRetained();
+            translatorBudget.releaseRetained(eventBytes, scope);
+            event = value;
+            eventBytes = valueBytes;
+            releaseLine();
+          } catch (error) {
+            reservation.release();
+            throw error;
+          }
+        }
+        else if (field === "data") {
+          const nextEventBytes = dataLinesBytes + valueBytes + dataLines.length;
+          if (nextEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+            throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+          }
+          // The extracted value is a distinct retained allocation while the source line is still
+          // live. Admit that insertion before slicing/pushing, then release the source owner.
+          translatorBudget.chargeRetained(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            dataLines.push(value);
+            dataLinesBytes += valueBytes;
+            releaseLine();
+          } catch (error) {
+            translatorBudget.releaseRetained(valueBytes, scope);
+            throw error;
+          }
+        } else {
+          releaseLine();
+        }
+      } finally {
+        translatorBudget.releaseRetained(fieldBytes, scope);
+      }
+      return undefined;
+    } catch (error) {
+      releaseLine();
+      throw error;
+    }
+  };
+
+  const consumeDecoded = async function* (
+    decoded: string,
+  ): AsyncGenerator<ServerSentEvent | SseRecord> {
+    let offset = 0;
+    while (offset < decoded.length) {
+      const newline = decoded.indexOf("\n", offset);
+      if (newline < 0) {
+        appendLine(decoded, offset, decoded.length);
+        return;
+      }
+      appendLine(decoded, offset, newline);
+      const accepted = acceptLine();
+      if (accepted) {
+        try {
+          yield accepted.record;
+        } finally {
+          translatorBudget.releaseRetained(accepted.bytes, scope);
+        }
+      }
+      offset = newline + 1;
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (value) {
+        const sourceBytes = value.byteLength;
+        const sourceReservation = translatorBudget.reserveTransient(sourceBytes, scope);
+        let sourceCommitted = false;
+        try {
+          const decoded = decoder.decode(value, { stream: !done });
+          sourceReservation.commitRetained();
+          sourceCommitted = true;
+          yield* consumeDecoded(decoded);
+        } finally {
+          if (sourceCommitted) translatorBudget.releaseRetained(sourceBytes, scope);
+          else sourceReservation.release();
+        }
+      }
+      if (!done) continue;
+      const finalDecoded = decoder.decode();
+      yield* consumeDecoded(finalDecoded);
+      if (lineBuffer.length > 0) {
+        const accepted = acceptLine();
+        if (accepted) {
+          try {
+            yield accepted.record;
+          } finally {
+            translatorBudget.releaseRetained(accepted.bytes, scope);
+          }
+        }
+      }
+      const finalRecord = dispatch();
+      if (finalRecord) {
+        try {
+          yield finalRecord.record;
+        } finally {
+          translatorBudget.releaseRetained(finalRecord.bytes, scope);
+        }
+      }
+      break;
+    }
+  } finally {
+    translatorBudget.releaseRetained(lineRetainedBytes + dataLinesBytes + eventBytes, scope);
+    signal?.removeEventListener("abort", onAbort);
+    try { await reader.cancel(); } catch { /* already closed/errored */ }
+    try { reader.releaseLock(); } catch { /* already released */ }
+  }
+}