@jaralabs/codex-bridge 0.2.0 → 0.4.0

package/lib/auth.mjs

@@ -0,0 +1,79 @@
+// auth.mjs: load, cache, and refresh the ChatGPT account tokens that
+// live in ~/.codex/auth.json. The bridge never writes the password
+// back to the file; only the refreshed tokens. The cache TTL is short
+// (30s) so an external `codex login` is picked up without a bridge
+// restart, and refresh is triggered by 401 from the upstream API.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
+const AUTH_PATH = join(CODEX_HOME, "auth.json");
+const AUTH_TTL_MS = 30_000;
+
+const OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+
+let _authCache = null;
+let _authLoadedAt = 0;
+
+export function loadAuth() {
+  if (!existsSync(AUTH_PATH)) {
+    throw new Error(`auth.json not found at ${AUTH_PATH}; run \`codex login\` first`);
+  }
+  if (_authCache && Date.now() - _authLoadedAt < AUTH_TTL_MS) return _authCache;
+  const raw = readFileSync(AUTH_PATH, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.auth_mode !== "chatgpt") {
+    throw new Error(`auth.json auth_mode=${parsed.auth_mode}; only chatgpt supported`);
+  }
+  _authCache = parsed.tokens;
+  _authLoadedAt = Date.now();
+  return _authCache;
+}
+
+export async function refreshAccessToken(refreshToken) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: OAUTH_CLIENT_ID,
+    scope: "openid profile email offline-access",
+  });
+  const res = await fetch(OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString(),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`oauth refresh failed ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const json = await res.json();
+  const current = _authCache || loadAuth();
+  const updated = {
+    ...current,
+    access_token: json.access_token,
+    refresh_token: json.refresh_token || current.refresh_token,
+    id_token: json.id_token || current.id_token,
+  };
+  try {
+    const raw = readFileSync(AUTH_PATH, "utf8");
+    const file = JSON.parse(raw);
+    file.tokens = updated;
+    writeFileSync(AUTH_PATH, JSON.stringify(file, null, 2));
+  } catch {
+    // best-effort; next refresh will try again
+  }
+  _authCache = updated;
+  _authLoadedAt = Date.now();
+  return updated;
+}
+
+export async function getAuth() {
+  const a = loadAuth();
+  if (!a.access_token && a.refresh_token) {
+    return refreshAccessToken(a.refresh_token);
+  }
+  return a;
+}

package/lib/capabilities.mjs

@@ -0,0 +1,183 @@
+// capabilities.mjs: probe the upstream ChatGPT Responses API at boot
+// and persist a small capability record to ~/.codex/bridge_capabilities.json.
+//
+// The probe sends a minimal request (one user message, no tools) and
+// records:
+//
+//   * which request fields the API accepted (or rejected) so we can
+//     detect a wire-shape drift the next time the bridge starts;
+//   * the round-trip latency;
+//   * the resolved model id (so we know if the model slug was renamed
+//     or routed to a different one);
+//   * the response shape: did we get an event stream? Did the
+//     response.completed event arrive?
+//
+// The next boot compares the new probe against the previous record.
+// If the shape changes in a way we did not anticipate, we log a
+// warn and (optionally) refuse to start.
+//
+// The probe is best-effort. If it fails, the bridge still starts:
+// the real chat handler will surface a clearer error on the first
+// request and the operator can see what changed.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAuth } from "./auth.mjs";
+
+const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
+const CAPS_PATH = join(CODEX_HOME, "bridge_capabilities.json");
+const CHATGPT_BASE = "https://chatgpt.com/backend-api/codex";
+
+const PROBE_MODEL = process.env.CODEX_BRIDGE_PROBE_MODEL || "gpt-6-luna";
+
+// The list of body fields we send on every request. The probe
+// checks which of these the API still accepts. If a previously
+// accepted field is now rejected, we log a strong warn.
+const PROBE_FIELDS = [
+  "model",
+  "store",
+  "stream",
+  "instructions",
+  "input",
+  "tool_choice",
+  "parallel_tool_calls",
+  "prompt_cache_key",
+];
+
+export async function probeCapabilities({ log = console.log.bind(console) } = {}) {
+  const start = Date.now();
+  let result;
+  try {
+    const auth = await getAuth();
+    const body = {
+      model: PROBE_MODEL,
+      store: false,
+      stream: true,
+      input: [
+        {
+          type: "message",
+          role: "user",
+          content: [{ type: "input_text", text: "ping" }],
+        },
+      ],
+      prompt_cache_key: `bridge-probe-${Date.now()}`,
+    };
+    const res = await fetch(`${CHATGPT_BASE}/responses`, {
+      method: "POST",
+      signal: AbortSignal.timeout(15_000),
+      headers: {
+        authorization: `Bearer ${auth.access_token}`,
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        "OpenAI-Beta": "responses=experimental",
+        "chatgpt-account-id": auth.account_id || "",
+      },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      result = { ok: false, status: res.status, error: text.slice(0, 400), latencyMs: Date.now() - start };
+    } else {
+      // Read the SSE stream until the first response.completed or
+      // error event, then bail. We do not need the full response.
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder("utf8");
+      let buf = "";
+      let completed = false;
+      let resolvedModel = null;
+      let firstEvent = null;
+      const events = new Set();
+      while (!completed) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf("\n\n")) !== -1) {
+          const block = buf.slice(0, idx);
+          buf = buf.slice(idx + 2);
+          let data = "";
+          for (const line of block.split("\n")) {
+            if (line.startsWith("data:")) data += line.slice(5).trim();
+          }
+          if (!data || data === "[DONE]") continue;
+          let json;
+          try { json = JSON.parse(data); } catch { continue; }
+          events.add(json.type);
+          if (!firstEvent) firstEvent = json.type;
+          if (json.type === "response.completed") {
+            completed = true;
+            resolvedModel = json.response?.model || null;
+            break;
+          }
+          if (json.type === "error" || json.type === "response.failed") {
+            completed = true;
+            result = { ok: false, status: res.status, error: json.message || json.error || "unknown", events: Array.from(events) };
+            try { await reader.cancel(); } catch {}
+            break;
+          }
+        }
+      }
+      if (!result) {
+        result = {
+          ok: true,
+          status: res.status,
+          latencyMs: Date.now() - start,
+          resolvedModel,
+          firstEvent,
+          events: Array.from(events),
+        };
+      }
+    }
+  } catch (e) {
+    result = { ok: false, error: e?.message || String(e), latencyMs: Date.now() - start };
+  }
+
+  // Compare against the previous record.
+  const previous = readPrevious();
+  const record = {
+    probedAt: new Date().toISOString(),
+    probeModel: PROBE_MODEL,
+    probeFields: PROBE_FIELDS,
+    ...result,
+  };
+  if (previous) {
+    const drift = detectDrift(previous, record);
+    if (drift.length > 0) {
+      log("warn", "capabilities.drift", { drift });
+    }
+  }
+  try {
+    mkdirSync(CODEX_HOME, { recursive: true });
+    writeFileSync(CAPS_PATH, JSON.stringify(record, null, 2));
+  } catch (e) {
+    // best-effort: do not block startup on disk write failure
+  }
+  return record;
+}
+
+function readPrevious() {
+  if (!existsSync(CAPS_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CAPS_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function detectDrift(prev, next) {
+  const out = [];
+  if (prev.ok !== next.ok) {
+    out.push({ kind: "ok", before: prev.ok, after: next.ok });
+  }
+  if (prev.resolvedModel && next.resolvedModel && prev.resolvedModel !== next.resolvedModel) {
+    out.push({ kind: "resolvedModel", before: prev.resolvedModel, after: next.resolvedModel });
+  }
+  if (Array.isArray(prev.events) && Array.isArray(next.events)) {
+    const lost = prev.events.filter((e) => !next.events.includes(e));
+    const gained = next.events.filter((e) => !prev.events.includes(e));
+    if (lost.length > 0) out.push({ kind: "eventsLost", events: lost });
+    if (gained.length > 0) out.push({ kind: "eventsGained", events: gained });
+  }
+  return out;
+}

package/lib/plugin.ts

@@ -1,28 +1,63 @@
-// codex-bridge OpenCode plugin template.
+// codex-bridge OpenCode plugin.
 //
-// Install: copy this file to ~/.config/opencode/plugins/codex-bridge-models.ts
-//   or run `codex-bridge install-plugin` (TODO).
+// Goals:
+//   1. Register the chatgpt provider pointing at the local bridge
+//      (http://127.0.0.1:11434/v1), pulling the live model list from
+//      ~/.codex/models_cache.json.
+//   2. Register MCP servers (Doop, codegraph, etc.) so they show up in
+//      OpenCode's tool list when the user picks a ChatGPT model.
+//   3. Inject a permission policy (V2 schema) that mirrors ChatGPT Plus:
+//      every MCP tool is `ask`, read-only built-in tools are `allow`.
 //
-// Why a plugin: opencode 2.x doesn't hot-reload provider models when opencode.jsonc
-// changes on disk for short-lived CLI invocations like `opencode run`. In a
-// long-lived TUI server, opencode does reload, and the plugin on `session.created`
-// is purely belt-and-suspenders.
-//
-// The plugin reads ~/.codex/models_cache.json and writes the resulting model list
-// into cfg.provider.chatgpt.models. On TUI restart the change will already be
-// present in opencode.jsonc thanks to lib/sync-cache.mjs running from
-// `codex-bridge start`, so this hook is mostly a no-op.
+// Install: copy this file to ~/.config/opencode/plugins/codex-bridge.ts
+// (or symlink). The bridge does NOT auto-install; that is the user's call.
 
-import { spawnSync } from "node:child_process"
 import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
 
 const CODEX_HOME = process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex")
 const CACHE = join(CODEX_HOME, "models_cache.json")
 const PROVIDER_ID = "chatgpt"
+const BRIDGE_BASE = process.env.CODEX_BRIDGE_BASE || "http://127.0.0.1:11434/v1"
 
 const VISIBLE = new Set(["list", "default", null, undefined])
 
+// MCP servers we always want available, even if the user has not added
+// them via `opencode mcp add`. The user can disable any of these by
+// setting the matching env var to "1":
+//   CODEX_BRIDGE_DISABLE_DOOP=1
+//   CODEX_BRIDGE_DISABLE_CODEGRAPH=1
+//   CODEX_BRIDGE_DISABLE_CODEGRAPH_FE=1
+//   CODEX_BRIDGE_DISABLE_ANGECOM=1
+function defaultMcpServers(): Record<string, any> {
+  const out: Record<string, any> = {}
+  if (process.env.CODEX_BRIDGE_DISABLE_DOOP !== "1") {
+    const cmd = process.env.DOOP_MCP_COMMAND || "npx"
+    const args = (process.env.DOOP_MCP_ARGS || "-y @arqora/doop-mcp").split(" ")
+    out["doop"] = { type: "local", command: [cmd, ...args] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_CODEGRAPH !== "1") {
+    out["codegraph"] = { type: "local", command: ["codegraph", "mcp"] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_CODEGRAPH_FE !== "1") {
+    out["codegraph-fe"] = { type: "local", command: ["codegraph-fe", "mcp"] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_ANGECOM !== "1") {
+    // The angecom MCP lives outside this repo; only register it if the
+    // user has it on disk. This keeps the plugin usable from any cwd.
+    const home = process.env.HOME || "/tmp"
+    const candidate = join(home, "workspace/angecom/angecom-mcp/dist/index.js")
+    if (existsSync(candidate)) {
+      out["angecom"] = {
+        type: "local",
+        command: ["node", candidate],
+        cwd: join(home, "workspace/angecom/angecom-mcp"),
+      }
+    }
+  }
+  return out
+}
+
 function readCache(): string[] {
   if (!existsSync(CACHE)) return []
   try {
@@ -63,33 +98,97 @@ function mergeModels(provider: any, slugs: string[]): void {
   if (!same) provider.models = desired
 }
 
-const CodexBridgeModelsPlugin = {
-  id: "codex-bridge-models",
+// V2 permission schema: an array of { action, resource, effect } rules.
+// Order matters: the last matching rule wins, so we put broad allow
+// rules first, then explicit ask rules for state-changing tools, and
+// finally a global "ask" catch-all so anything not listed still prompts.
+//
+// Read-only tools are allow-listed (Plus UX: reads run silently).
+// Anything that mutates state or hits the network prompts the user.
+function basePermissionRules(): any[] {
+  return [
+    // --- Read-only allow rules (built-in) ---
+    { action: "read", resource: "*", effect: "allow" },
+    { action: "glob", resource: "*", effect: "allow" },
+    { action: "grep", resource: "*", effect: "allow" },
+    { action: "list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "read_mcp_resource", resource: "*", effect: "allow" },
+
+    // --- MCP read-only tools (Doop and codegraph both expose several
+    //     of these; the <server>_<tool> action pattern matches them). ---
+    // We list them explicitly so the saved-approval flow can record
+    // each tool separately instead of one broad rule.
+    { action: "doop_list_canvases", resource: "*", effect: "allow" },
+    { action: "doop_get_guidelines", resource: "*", effect: "allow" },
+    { action: "doop_get_reference", resource: "*", effect: "allow" },
+    { action: "doop_get_comments", resource: "*", effect: "allow" },
+    { action: "doop_get_frame", resource: "*", effect: "allow" },
+    { action: "doop_get_frame_screenshot", resource: "*", effect: "allow" },
+    { action: "doop_get_linear_issue", resource: "*", effect: "allow" },
+    { action: "codegraph_codegraph_explore", resource: "*", effect: "allow" },
+    { action: "codegraph-fe_codegraph_explore", resource: "*", effect: "allow" },
+    { action: "angecom_confluence_list_folder", resource: "*", effect: "allow" },
+    { action: "angecom_jira_get_issue", resource: "*", effect: "allow" },
+    { action: "angecom_jira_get_transitions", resource: "*", effect: "allow" },
+    { action: "angecom_jira_list_attachments", resource: "*", effect: "allow" },
+    { action: "angecom_list_workspaces", resource: "*", effect: "allow" },
+    { action: "angecom_list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "opencode_list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "opencode_read_mcp_resource", resource: "*", effect: "allow" },
+
+    // --- Anything state-changing defaults to ask (Plus behavior). ---
+    { action: "*", resource: "*", effect: "ask" },
+  ]
+}
+
+function mergePermissions(current: any): any[] {
+  const base = basePermissionRules()
+  if (!Array.isArray(current)) return base
+  // User-defined rules win. We keep the base array as a fallback and
+  // append the user rules, so the user's specific "allow" overrides
+  // our "ask" catch-all at the bottom.
+  return [...base, ...current]
+}
+
+const CodexBridgePlugin = {
+  id: "codex-bridge",
   async setup(_ctx: unknown) {
     return {
       config: async (cfg: any) => {
-        const slugs = readCache()
-        if (slugs.length === 0) return
+        // --- Provider ---
         if (!cfg.provider) cfg.provider = {}
         if (!cfg.provider[PROVIDER_ID]) {
           cfg.provider[PROVIDER_ID] = {
             npm: "@ai-sdk/openai-compatible",
             name: "ChatGPT Business (codex-bridge)",
-            options: { baseURL: "http://127.0.0.1:11434/v1" },
+            options: { baseURL: BRIDGE_BASE },
             models: {},
           }
         }
-        mergeModels(cfg.provider[PROVIDER_ID], slugs)
+        const slugs = readCache()
+        if (slugs.length > 0) {
+          mergeModels(cfg.provider[PROVIDER_ID], slugs)
+        }
+
+        // --- MCP servers ---
+        if (!cfg.mcp) cfg.mcp = {}
+        if (!cfg.mcp.servers) cfg.mcp.servers = {}
+        const defaults = defaultMcpServers()
+        for (const [name, def] of Object.entries(defaults)) {
+          if (!cfg.mcp.servers[name]) cfg.mcp.servers[name] = def
+        }
+
+        // --- Permission policy (V2 schema) ---
+        cfg.permissions = mergePermissions(cfg.permissions)
       },
       event: async ({ event }: { event: { type?: string } }) => {
         if (event?.type === "session.created") {
-          // Optional: re-sync at session start. The on-disk JSON file is already
-          // kept up to date by lib/sync-cache.mjs when codex-bridge start runs.
+          // No-op: on-disk config is already kept fresh by lib/sync-cache.mjs.
         }
       },
     }
   },
 }
 
-export default CodexBridgeModelsPlugin
-export { CodexBridgeModelsPlugin }
+export default CodexBridgePlugin
+export { CodexBridgePlugin }

package/lib/resilience.mjs

@@ -0,0 +1,182 @@
+// resilience.mjs: backoff retry, circuit breaker, and in-memory metrics
+// for the upstream ChatGPT Responses API.
+//
+// Goals:
+//   * Survive transient 429/5xx without surfacing the error to the
+//     client when a quick retry would have worked.
+//   * Stop hammering the API when it is clearly down (circuit
+//     breaker) so the bridge does not amplify an outage.
+//   * Surface a small set of counters at /v1/health so an operator
+//     can see whether the bridge is healthy without log scraping.
+//
+// This module is in-memory and process-local. State resets on
+// restart, which is fine for a single-process bridge.
+
+import { appendFileSync } from "node:fs";
+
+const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+const DEFAULT_MAX_RETRIES = 4;
+const DEFAULT_BASE_MS = 400;
+const DEFAULT_MAX_MS = 8_000;
+const CIRCUIT_FAIL_THRESHOLD = 5;        // consecutive failures to open
+const CIRCUIT_WINDOW_MS = 30_000;        // failures older than this drop off
+const CIRCUIT_COOLDOWN_MS = 15_000;      // how long we stay open before half-open
+
+const state = {
+  // metrics
+  requests: 0,
+  successes: 0,
+  failures: 0,
+  retries: 0,
+  lastError: null,
+  lastSuccessAt: 0,
+  lastFailureAt: 0,
+  // circuit breaker
+  failureTimes: [],   // timestamps of recent failures
+  circuitOpenedAt: 0, // 0 = closed; >0 = open since this timestamp
+  halfOpenProbe: null, // one in-flight probe during half-open
+};
+
+export function recordSuccess() {
+  state.requests += 1;
+  state.successes += 1;
+  state.lastSuccessAt = Date.now();
+  state.lastError = null;
+  // A success closes the circuit if we are in half-open.
+  if (state.circuitOpenedAt) {
+    state.circuitOpenedAt = 0;
+    state.halfOpenProbe = null;
+    log("info", "circuit.closed");
+  }
+}
+
+export function recordFailure(err) {
+  state.requests += 1;
+  state.failures += 1;
+  state.lastFailureAt = Date.now();
+  state.lastError = err?.message || String(err);
+  const now = Date.now();
+  state.failureTimes = state.failureTimes.filter((t) => now - t < CIRCUIT_WINDOW_MS);
+  state.failureTimes.push(now);
+  if (
+    state.circuitOpenedAt === 0 &&
+    state.failureTimes.length >= CIRCUIT_FAIL_THRESHOLD
+  ) {
+    state.circuitOpenedAt = now;
+    log("warn", "circuit.opened", { failures: state.failureTimes.length, windowMs: CIRCUIT_WINDOW_MS });
+  }
+}
+
+// Returns true if the breaker permits a request right now. If the
+// breaker is open but the cooldown has elapsed, returns true once
+// (half-open probe); the caller must call recordSuccess or
+// recordFailure to close or re-open the circuit.
+export function circuitPermits() {
+  if (state.circuitOpenedAt === 0) return true;
+  const now = Date.now();
+  const openFor = now - state.circuitOpenedAt;
+  if (openFor < CIRCUIT_COOLDOWN_MS) return false;
+  if (state.halfOpenProbe) return false;
+  state.halfOpenProbe = "in-flight";
+  log("info", "circuit.half_open", { openForMs: openFor });
+  return true;
+}
+
+export function circuitStatus() {
+  if (state.circuitOpenedAt === 0) return "closed";
+  const openFor = Date.now() - state.circuitOpenedAt;
+  if (openFor < CIRCUIT_COOLDOWN_MS) return "open";
+  return "half_open";
+}
+
+// Compute the backoff delay before the next attempt. attempt is
+// 0-indexed: 0 means the first retry, etc.
+export function backoffMs(attempt) {
+  const exp = Math.min(DEFAULT_MAX_MS, DEFAULT_BASE_MS * 2 ** attempt);
+  // Full jitter: random in [0, exp].
+  return Math.floor(Math.random() * exp);
+}
+
+export function isRetryableStatus(status) {
+  return RETRYABLE_STATUS.has(status);
+}
+
+export const retryConfig = {
+  maxRetries: DEFAULT_MAX_RETRIES,
+  baseMs: DEFAULT_BASE_MS,
+  maxMs: DEFAULT_MAX_MS,
+};
+
+export function metrics() {
+  return {
+    requests: state.requests,
+    successes: state.successes,
+    failures: state.failures,
+    retries: state.retries,
+    lastError: state.lastError,
+    lastSuccessAt: state.lastSuccessAt,
+    lastFailureAt: state.lastFailureAt,
+    circuit: circuitStatus(),
+    circuitFailuresInWindow: state.failureTimes.length,
+  };
+}
+
+// Wrap an async function with retry + circuit breaker semantics.
+// fn() must throw an Error with .status attached when the response
+// is a retryable HTTP error. onRetry(attempt, delayMs, err) is
+// called before sleeping between attempts.
+export async function withResilience(label, fn, { onRetry, signal } = {}) {
+  if (!circuitPermits()) {
+    const err = new Error(`circuit open: ${label}`);
+    err.status = 503;
+    err.code = "circuit_open";
+    throw err;
+  }
+  let lastErr;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    if (signal?.aborted) {
+      const e = new Error("aborted");
+      e.code = "aborted";
+      throw e;
+    }
+    try {
+      const result = await fn(attempt);
+      recordSuccess();
+      return result;
+    } catch (err) {
+      lastErr = err;
+      const status = err?.status;
+      const retryable = isRetryableStatus(status) || err?.code === "fetch_failed";
+      if (!retryable || attempt === retryConfig.maxRetries) {
+        recordFailure(err);
+        throw err;
+      }
+      state.retries += 1;
+      const delay = backoffMs(attempt);
+      if (onRetry) onRetry(attempt, delay, err);
+      log("warn", "retry", { label, attempt: attempt + 1, status, delayMs: delay, err: err?.message });
+      if (signal) {
+        await new Promise((resolve, reject) => {
+          const t = setTimeout(resolve, delay);
+          signal.addEventListener("abort", () => {
+            clearTimeout(t);
+            reject(Object.assign(new Error("aborted"), { code: "aborted" }));
+          }, { once: true });
+        });
+      } else {
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  recordFailure(lastErr);
+  throw lastErr;
+}
+
+function log(level, msg, extra) {
+  try {
+    const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...(extra || {}) });
+    appendFileSync(process.env.CODEX_BRIDGE_LOG || "/tmp/codex-bridge.log", line + "\n");
+  } catch {
+    // best-effort logging; never throw from the resilience layer
+  }
+}