@bitkyc08/opencodex 2.7.43-preview.20260728 → 2.8.0

package/src/server/claude-messages.ts

@@ -9,7 +9,7 @@
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
 import { enforceAnthropicImageLimits } from "../adapters/anthropic-image-guard";
 import { normalizeAnthropicImages } from "../adapters/anthropic-image-normalize";
-import { AnthropicRequestError, anthropicToResponsesTranslation, extractOcxRouteDirective, resolveInboundModel, type ClaudeCacheKeySource } from "../claude/inbound";
+import { AnthropicRequestError, anthropicToResponsesTranslation, extractOcxEffortDirective, extractOcxRouteDirective, resolveInboundModel, type ClaudeCacheKeySource } from "../claude/inbound";
 import { resolveDesktop3pAlias } from "../claude/desktop-3p";
 import { recordDesktopRequest } from "../claude/desktop-health";
 import { stripOneMillionMarker } from "../claude/context-windows";
@@ -523,6 +523,7 @@ export async function handleClaudeMessages(
   let anthropicBody: unknown;
   let internalBody: Rec;
   let cacheKeySource: ClaudeCacheKeySource = null;
+  let effortOverride: ReturnType<typeof extractOcxEffortDirective> = null;
   try {
     anthropicBody = await readAnthropicBody(req);
     // Defensive [1m] strip (devlog 138): clients normally remove the context-variant
@@ -539,6 +540,7 @@ export async function handleClaudeMessages(
       const routeOverride = extractOcxRouteDirective(anthropicBody);
       if (routeOverride && typeof anthropicBody.model === "string") {
         anthropicBody.model = stripOneMillionMarker(routeOverride);
+        effortOverride = extractOcxEffortDirective(anthropicBody);
       }
     }
     // Debug capture (opt-in allowlist scalars) BEFORE the passthrough branch so
@@ -567,6 +569,10 @@ export async function handleClaudeMessages(
     if (isRec(anthropicBody) && wantsNativePassthrough(req, config, anthropicBody.model)) {
       return await anthropicNativePassthrough(req, config, logCtx, logIds, anthropicBody, "/v1/messages");
     }
+    if (isRec(anthropicBody) && effortOverride) {
+      anthropicBody.output_config = { effort: effortOverride };
+      delete anthropicBody.thinking;
+    }
     const translation = anthropicToResponsesTranslation(anthropicBody, config.claudeCode);
     internalBody = translation.body;
     cacheKeySource = translation.cacheKeySource;
@@ -678,6 +684,7 @@ export async function handleClaudeMessages(
   };
   const upstream = await handleResponses(internalReq, buildClaudeReplayConfig(config), logCtx, {
     abortSignal: req.signal,
+    promptCacheKeyIsSharedCohort: cacheKeySource === "system",
     ...(logIds ? { onFirstOutput: () => recordFirstOutput(logCtx, logIds.start) } : {}),
     onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForTerminalStatus(status), { terminalStatus: status, closeReason: "terminal" }),
     onNativePassthroughCancel: () => finalizeNativeLog(499, { closeReason: "client_cancel" }),

package/src/server/gui-static.ts

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { browserSecurityHeaders } from "./auth-cors";
+import type { GuiSessionBootstrap } from "./management-auth";
 
 /** opencodex version, read from the packaged package.json (same source as the server bootstrap). */
 const VERSION = (() => {
@@ -54,8 +56,31 @@ function isFile(path: string): boolean {
   }
 }
 
-export function serveGuiFile(pathname: string): Response | null {
-  const guiDist = findGuiDist();
+function htmlResponse(path: string, session?: GuiSessionBootstrap): Response {
+  let html = readFileSync(path, "utf8");
+  if (session) {
+    const bootstrap = [
+      `<meta name="opencodex-session-token" content="${session.token}">`,
+      `<meta name="opencodex-session-csrf" content="${session.csrfToken}">`,
+      `<meta name="opencodex-session-origin" content="${session.origin}">`,
+    ].join("");
+    html = html.includes("</head>") ? html.replace("</head>", `${bootstrap}</head>`) : `${bootstrap}${html}`;
+  }
+  return new Response(html, {
+    headers: {
+      "Content-Type": "text/html",
+      "Cache-Control": "no-store",
+      Pragma: "no-cache",
+      ...browserSecurityHeaders(),
+    },
+  });
+}
+
+export function serveGuiFile(
+  pathname: string,
+  guiDist = findGuiDist(),
+  session?: GuiSessionBootstrap,
+): Response | null {
   if (!guiDist) return null;
   const filePath = resolveGuiFilePath(guiDist, pathname);
   if (!filePath) return null;
@@ -64,9 +89,7 @@ export function serveGuiFile(pathname: string): Response | null {
     if (!extname(pathname)) {
       const indexPath = join(guiDist, "index.html");
       if (isFile(indexPath)) {
-        return new Response(Bun.file(indexPath), {
-          headers: { "Content-Type": "text/html" },
-        });
+        return htmlResponse(indexPath, session);
       }
     }
     return null;
@@ -74,8 +97,9 @@ export function serveGuiFile(pathname: string): Response | null {
 
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  if (ext === ".html") return htmlResponse(filePath, session);
   return new Response(Bun.file(filePath), {
-    headers: { "Content-Type": contentType },
+    headers: { "Content-Type": contentType, ...browserSecurityHeaders() },
   });
 }
 

package/src/server/images.ts

@@ -25,10 +25,16 @@ import { signalWithTimeout } from "../lib/abort";
 import { sidecarEnter } from "../lib/sidecar-tracker";
 import type { OcxConfig } from "../types";
 import { resolveFirstUsableOpenAiSidecar, selectImagesProvider } from "../providers/openai-sidecar";
+import { getProviderRegistryEntry } from "../providers/registry";
 import { readJsonRequestBody } from "./request-decompress";
 import { ForwardAdmissionCredentialError, validateForwardAdmissionCredential } from "./auth-cors";
 import type { RequestLogContext } from "./request-log";
 import { codexLogAccountId, decodeRequestErrorResponse } from "./responses";
+import { getValidAccessToken, getOAuthCredentialProjectId } from "../oauth/index";
+import { safeAntigravityHttpErrorMessage } from "../adapters/google-errors";
+import { sanitizeUpstreamErrorText } from "../adapters/upstream-http-error";
+import { ANTIGRAVITY_REQUEST_UA } from "../adapters/google-antigravity-wire";
+import { decodeValidatedImageBase64, MAX_ENCODED_BYTES_PER_IMAGE } from "../images/artifacts";
 
 export type ImagesEndpoint = "generations" | "edits";
 
@@ -42,6 +48,276 @@ const IMAGES_UPSTREAM_TIMEOUT_MS = 300_000;
  */
 const IMAGES_RESPONSE_MAX_BYTES = 100 * 1024 * 1024;
 
+const CCA_IMAGE_MODEL = "gemini-3.1-flash-image";
+
+/**
+ * Google Gemini finishReasons that indicate a permanent content/safety block.
+ * When any of these is present, the same prompt will always fail — retrying
+ * wastes paid quota. The response is surfaced as 400 (non-retryable) instead
+ * of 502 (which codex retries up to 5 times).
+ */
+const CCA_BLOCKING_FINISH_REASONS: ReadonlySet<string> = new Set([
+  "SAFETY",
+  "BLOCKLIST",
+  "PROHIBITED_CONTENT",
+  "SPII",
+  "RECITATION",
+]);
+
+/**
+ * Race a promise against an abort signal. If the signal aborts first, reject
+ * immediately — our code stops awaiting the underlying operation even though
+ * the HTTP request behind it may still complete. Used to make the non-cancellable
+ * OAuth refresh chain responsive to client cancellation and deadline expiry.
+ */
+function abortableRace<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+  }
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (val) => { signal.removeEventListener("abort", onAbort); resolve(val); },
+      (err) => { signal.removeEventListener("abort", onAbort); reject(err); },
+    );
+  });
+}
+
+async function tryCcaImageGeneration(
+  body: unknown,
+  config: OcxConfig,
+  logCtx: RequestLogContext,
+  signal: AbortSignal,
+  endpoint: ImagesEndpoint,
+): Promise<Response | undefined> {
+  if (endpoint !== "generations") return undefined;
+  const provider = config.providers?.["google-antigravity"];
+  if (!provider || provider.disabled) return undefined;
+
+  const prompt = (body as { prompt?: unknown })?.prompt;
+  if (typeof prompt !== "string" || !prompt.trim()) {
+    return formatErrorResponse(400, "invalid_request_error", "prompt is required and must not be empty");
+  }
+
+  const nRaw = (body as { n?: unknown })?.n;
+  if (nRaw !== undefined && nRaw !== null) {
+    const n = typeof nRaw === "number" ? nRaw : Number(nRaw);
+    if (!Number.isInteger(n) || n !== 1) {
+      return formatErrorResponse(400, "invalid_request_error", "CCA image generation supports n=1 only");
+    }
+  }
+
+  // Create the deadline before credential resolution so the timeout covers
+  // OAuth token refresh and project discovery, not just the upstream fetch.
+  const timeoutMs = config.images?.timeoutMs ?? IMAGES_UPSTREAM_TIMEOUT_MS;
+  const linkedSignal = signalWithTimeout(timeoutMs, signal);
+  let token: string;
+  try {
+    // Race the OAuth refresh against the deadline signal. getValidAccessToken
+    // chains through 4 layers (resolveAccessSnapshotForAccount →
+    // refreshAndPersistAccessToken → refreshGenericAccountWithLock →
+    // def.refresh()) that do HTTP calls without accepting a signal. Rather than
+    // threading signal through the entire chain, race the whole call against
+    // linkedSignal: when the signal aborts we stop awaiting and surface the
+    // cancellation immediately instead of hanging on the refresh HTTP call.
+    token = await abortableRace(getValidAccessToken("google-antigravity"), linkedSignal.signal);
+  } catch (err) {
+    linkedSignal.cleanup();
+    // abortableRace rejects immediately when the signal fires, so client
+    // cancellation and deadline expiry surface here. Parent abort propagates
+    // into the linked signal, so check parent first (499) before the linked
+    // signal (504).
+    if (signal.aborted) {
+      return formatErrorResponse(499, "client_closed_request", "CCA image request canceled by client");
+    }
+    if (linkedSignal.signal.aborted) {
+      return formatErrorResponse(504, "upstream_error", "CCA image generation timed out during authentication");
+    }
+    // Missing/revoked credential → 401 (re-login required); transient refresh/network → 502.
+    const errName = err instanceof Error ? err.name : "";
+    if (errName === "OAuthLoginRequiredError") {
+      return formatErrorResponse(401, "invalid_request_error", "Google Antigravity login required: run 'ocx login google-antigravity'");
+    }
+    return formatErrorResponse(502, "upstream_error", "CCA image generation failed: OAuth token refresh failed");
+  }
+  const project = getOAuthCredentialProjectId("google-antigravity");
+  if (!project) {
+    linkedSignal.cleanup();
+    return formatErrorResponse(
+      400,
+      "invalid_request_error",
+      "Antigravity requires a discovered Cloud Code Assist project id (re-run `ocx login google-antigravity`).",
+    );
+  }
+
+  logCtx.provider = "google-antigravity";
+  logCtx.model = CCA_IMAGE_MODEL;
+
+  // Pin to the registry endpoint — never use a config-level baseUrl override for OAuth token transmission.
+  const registryEntry = getProviderRegistryEntry("google-antigravity");
+  const baseUrl = registryEntry?.baseUrl ?? "https://daily-cloudcode-pa.googleapis.com";
+  const envelope = {
+    model: CCA_IMAGE_MODEL,
+    userAgent: "antigravity",
+    requestType: "agent",
+    project,
+    requestId: `agent-${crypto.randomUUID()}`,
+    request: {
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+      generationConfig: { responseModalities: ["TEXT", "IMAGE"] },
+      sessionId: `ocx-img-${crypto.randomUUID().slice(0, 8)}`,
+    },
+  };
+  let upstream: Response;
+  try {
+    try {
+      upstream = await fetch(`${baseUrl}/v1internal:generateContent`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`,
+          "User-Agent": ANTIGRAVITY_REQUEST_UA,
+        },
+        body: JSON.stringify(envelope),
+        signal: linkedSignal.signal,
+      });
+    } catch (err) {
+      if (signal.aborted) return formatErrorResponse(499, "client_closed_request", "CCA image request canceled by client");
+      if (err instanceof Error && err.name === "TimeoutError") {
+        return formatErrorResponse(504, "upstream_error", "CCA image generation timed out");
+      }
+      // Network/DNS/runtime errors may embed the request URL or headers verbatim
+      // (e.g. "fetch failed: https://…/v1internal:generateContent"). The token
+      // lives in an Authorization header, not in the URL, but sanitize defensively
+      // so no upstream-rejected credential or query param can reach the client,
+      // and strip the internal base URL host from the surfaced message.
+      const rawMsg = err instanceof Error ? err.message : String(err);
+      const safeMsg = sanitizeUpstreamErrorText(rawMsg).replace(
+        /https?:\/\/[^\s"'<>]+/gi,
+        "[upstream-url]",
+      );
+      return formatErrorResponse(502, "upstream_error", `CCA image generation failed: ${safeMsg}`);
+    }
+
+    // Stream the upstream body with a bounded reader so an oversized or malicious
+    // response is rejected mid-stream rather than after a full arrayBuffer() allocation.
+    let payload: Uint8Array;
+    try {
+      const reader = upstream.body?.getReader();
+      if (!reader) {
+        return formatErrorResponse(502, "upstream_error", "CCA image response had no body");
+      }
+      const chunks: Uint8Array[] = [];
+      let total = 0;
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          total += value.byteLength;
+          if (total > IMAGES_RESPONSE_MAX_BYTES) {
+            await reader.cancel().catch(() => {});
+            return formatErrorResponse(502, "upstream_error", `CCA image response too large (exceeded ${IMAGES_RESPONSE_MAX_BYTES} bytes)`);
+          }
+          chunks.push(value);
+        }
+      } finally {
+        try { await reader.cancel(); } catch { /* ignore */ }
+        reader.releaseLock();
+      }
+      payload = new Uint8Array(total);
+      let offset = 0;
+      for (const chunk of chunks) {
+        payload.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+    } catch (err) {
+      // Body-read timeout/abort: when CCA returns headers then stalls, the linked
+      // signal's timeout aborts reader.read(), which rejects here. The rejection
+      // often surfaces as AbortError (not TimeoutError), so distinguish by signal
+      // state, not error name. Parent abort propagates into the linked signal, so
+      // check the parent first: parent abort → 499 (client cancelled); linked-only
+      // abort → 504 (upstream stall); anything else → 502 body-read failure.
+      if (signal.aborted) {
+        return formatErrorResponse(499, "client_closed_request", "CCA image request canceled by client");
+      }
+      if (linkedSignal.signal.aborted) {
+        return formatErrorResponse(504, "upstream_error", "CCA image response timed out during body read");
+      }
+      const rawMsg = err instanceof Error ? err.message : String(err);
+      const safeMsg = sanitizeUpstreamErrorText(rawMsg).replace(/https?:\/\/[^\s"'<>]+/gi, "[upstream-url]");
+      return formatErrorResponse(502, "upstream_error", `CCA image body read failed: ${safeMsg}`);
+    }
+
+    if (!upstream.ok) {
+      // Preserve auth/rate-limit and other permanent 4xx signals so callers can
+      // distinguish retryable from permanent failures. Remaining 5xx collapse to 502.
+      const text = new TextDecoder().decode(payload);
+      const safeMsg = safeAntigravityHttpErrorMessage(upstream.status, text);
+      if (upstream.status >= 400 && upstream.status < 500) {
+        return formatErrorResponse(upstream.status, "upstream_error", safeMsg);
+      }
+      return formatErrorResponse(502, "upstream_error", safeMsg);
+    }
+
+    let json: Record<string, unknown>;
+    try {
+      json = JSON.parse(new TextDecoder().decode(payload)) as Record<string, unknown>;
+    } catch {
+      return formatErrorResponse(502, "upstream_error", "CCA image response was not valid JSON");
+    }
+    const resp = (json.response ?? json) as {
+      candidates?: { content?: { parts?: { inlineData?: { mimeType?: string; data?: string }; text?: string }[] }; finishReason?: string }[];
+      promptFeedback?: { blockReason?: string };
+    };
+    // Safety blocks are permanent for the same prompt — return 400 (non-retryable)
+    // instead of 502 (which codex retries up to 5 times, wasting paid quota on a
+    // prompt that will never succeed). Two blocking signals exist in the Gemini
+    // API: promptFeedback.blockReason (prompt rejected before generation) and
+    // candidate.finishReason (generation cut off by a content filter).
+    const blockReason = resp.promptFeedback?.blockReason;
+    if (typeof blockReason === "string" && blockReason.trim()) {
+      return formatErrorResponse(400, "invalid_request_error", `CCA image generation blocked by safety filter (promptFeedback.blockReason: ${blockReason})`);
+    }
+    const candidate = resp.candidates?.[0];
+    const finishReason = candidate?.finishReason;
+    if (typeof finishReason === "string" && CCA_BLOCKING_FINISH_REASONS.has(finishReason)) {
+      return formatErrorResponse(400, "invalid_request_error", `CCA image generation blocked by safety filter (finishReason: ${finishReason})`);
+    }
+    const parts = candidate?.content?.parts;
+    if (!Array.isArray(parts)) {
+      return formatErrorResponse(502, "upstream_error", "CCA image response had no valid parts array");
+    }
+    const images: { b64_json: string }[] = [];
+    for (const part of parts) {
+      if (!part || typeof part !== "object") continue;
+      const data = part.inlineData?.data;
+      if (typeof data !== "string" || data.length === 0) continue;
+      if (data.length > MAX_ENCODED_BYTES_PER_IMAGE) {
+        return formatErrorResponse(502, "upstream_error", "CCA image payload exceeds per-image size cap");
+      }
+      try {
+        decodeValidatedImageBase64(data);
+      } catch {
+        return formatErrorResponse(502, "upstream_error", "CCA image payload failed base64/magic validation");
+      }
+      images.push({ b64_json: data });
+    }
+    if (images.length === 0) {
+      return formatErrorResponse(502, "upstream_error", "CCA image model returned no image data");
+    }
+    // Only `{created, data:[{b64_json}]}` is returned — no token, projectId, or
+    // upstream metadata leak through. The Authorization header is consumed by the
+    // fetch above and never copied onto this Response.
+    return new Response(JSON.stringify({ created: Math.floor(Date.now() / 1000), data: images }), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  } finally {
+    linkedSignal.cleanup();
+  }
+}
+
 export async function handleImages(
   req: Request,
   config: OcxConfig,
@@ -53,11 +329,18 @@ export async function handleImages(
     return formatErrorResponse(400, "invalid_request_error", candidates.error);
   }
   const explicitKeyedProvider = config.images?.provider !== undefined && candidates.keyed !== undefined;
+  // Admission bearer is valid proxy auth (requireApiAuth already passed) but must never be
+  // forwarded as OpenAI ChatGPT credentials. When the caller sent it, skip OpenAI forward
+  // and allow CCA / keyed paths instead of rejecting the whole request.
+  let skipOpenAiForwardForAdmissionBearer = false;
   if (!explicitKeyedProvider) {
     try { validateForwardAdmissionCredential(req.headers, config); }
     catch (err) {
-      if (err instanceof ForwardAdmissionCredentialError) return formatErrorResponse(401, "authentication_error", err.message);
-      throw err;
+      if (err instanceof ForwardAdmissionCredentialError) {
+        skipOpenAiForwardForAdmissionBearer = true;
+      } else {
+        throw err;
+      }
     }
   }
   let body: unknown;
@@ -69,15 +352,19 @@ export async function handleImages(
   const model = (body as { model?: unknown } | null)?.model;
   if (typeof model === "string" && model) logCtx.model = model;
 
-  if (candidates.forwardCandidates.length === 0 && !candidates.keyed) {
+  const canUseOpenAiForward = !skipOpenAiForwardForAdmissionBearer && candidates.forwardCandidates.length > 0;
+
+  if (!canUseOpenAiForward && !candidates.keyed) {
+    const ccaResponse = await tryCcaImageGeneration(body, config, logCtx, req.signal, endpoint);
+    if (ccaResponse) return ccaResponse;
     // 400, not 5xx: codex retries every 5xx up to 5 total attempts, and this is a permanent
     // configuration state that must surface on the first attempt.
     return formatErrorResponse(
       400,
       "invalid_request_error",
-      "Built-in image generation needs an OpenAI upstream (ChatGPT login or an OpenAI API-key provider), "
-      + "but none is configured in opencodex. Routed providers cannot serve /v1/images/* — "
-      + "add an OpenAI provider or disable the tool with `codex features disable image_generation`.",
+      "Built-in image generation needs an OpenAI upstream (ChatGPT login or an OpenAI API-key provider) "
+      + "or a logged-in Google Antigravity (Cloud Code Assist) provider, "
+      + "but none is configured in opencodex. Add a provider or disable the tool with `codex features disable image_generation`.",
     );
   }
 
@@ -86,7 +373,7 @@ export async function handleImages(
   // 429 image_gen while api.openai.com sits idle).
   let forward: Awaited<ReturnType<typeof resolveFirstUsableOpenAiSidecar>>;
   let forwardAuthError: Response | undefined;
-  if (candidates.forwardCandidates.length > 0) {
+  if (canUseOpenAiForward) {
     try {
       forward = await resolveFirstUsableOpenAiSidecar(candidates.forwardCandidates, req.headers, config);
       if (forward) logCtx.provider = formatCodexProviderForLog(forward.providerName, codexLogAccountId(forward.authContext), config);
@@ -116,8 +403,12 @@ export async function handleImages(
     // The ChatGPT codex backend takes bare paths (matches the adapter's `${baseUrl}/responses`).
     url = `${provider.baseUrl}/images/${endpoint}`;
   } else if (forwardAuthError) {
-    // A configured OpenAI pool mode owns its authentication failure. Do not hide a
-    // broken/expired pool behind separately billed API-key image generation.
+    // Before surfacing the OpenAI auth failure, try CCA — the user may have a
+    // valid Google Antigravity login even though their OpenAI pool is broken.
+    const ccaResponse = await tryCcaImageGeneration(body, config, logCtx, req.signal, endpoint);
+    if (ccaResponse) return ccaResponse;
+    // No CCA either: a configured OpenAI pool mode owns its authentication failure.
+    // Do not hide a broken/expired pool behind separately billed API-key image generation.
     return forwardAuthError;
   } else if (candidates.keyed) {
     const { provider, apiKey, providerName } = candidates.keyed;
@@ -127,6 +418,9 @@ export async function handleImages(
     // Keyed providers tolerate baseUrl with or without /v1 (mirrors openai-responses.ts).
     url = `${provider.baseUrl.replace(/\/v1\/?$/, "")}/v1/images/${endpoint}`;
   } else {
+    // No usable OpenAI credential — try CCA before giving up.
+    const ccaResponse = await tryCcaImageGeneration(body, config, logCtx, req.signal, endpoint);
+    if (ccaResponse) return ccaResponse;
     return formatErrorResponse(
       401,
       "authentication_error",