UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

123 lines (114 loc) • 5.95 kB
import type { Server } from "bun"; import { formatErrorResponse } from "../bridge"; import { readServiceApiTokenState, type ServiceApiTokenState } from "../lib/service-secrets"; import { linkRouteAllowed } from "../link/routes"; import { isAllowedRequestOrigin, type RequestPolicyView } from "../server/auth-cors"; import { relayLinkDataRequest, type LinkRelayDeps } from "./link-relay"; import type { LinkWebsocketRelay } from "./link-websocket"; /** How often an unavailable link key is looked for again. A valid key is never re-read. */ export const LINK_KEY_RETRY_MS = 1_000; export interface LinkKeySourceDeps { readToken?: () => ServiceApiTokenState; now?: () => number; } /** * The link key for relayed requests, read from the service token file once and then held in * memory, so no data-plane request touches the disk. The file must still hold the key this * connection committed (`tokenFingerprint`); anything else yields null. Only while the key is * unavailable is the file read again, at most once per `LINK_KEY_RETRY_MS`. The key is never * logged, returned in a response, or written anywhere. */ export function createLinkKeySource(expectedFingerprint: string, deps: LinkKeySourceDeps = {}): () => string | null { const readToken = deps.readToken ?? readServiceApiTokenState; const now = deps.now ?? Date.now; let key: string | null = null; let lastRead = 0; const load = (): void => { lastRead = now(); try { const state = readToken(); key = state.kind === "present" && state.fingerprint === expectedFingerprint ? state.token : null; } catch { key = null; } }; load(); return () => { if (key === null && now() - lastRead >= LINK_KEY_RETRY_MS) load(); return key; }; } export interface LinkIngress { tunnelPort: number; linkId?: string; apiKeyId?: string; /** The listener's loopback policy: the standalone Host and Origin anti-rebinding gate. */ policy: RequestPolicyView; linkKey: () => string | null; relay?: LinkRelayDeps; /** * The Responses WebSocket over the link (link-websocket.ts). It is tried only when it wants the * upgrade (the Child's release gate is open, no opt-out, and the Home's last applied answer for the link * did not say off; with no answer yet since start the upgrade tries); otherwise the * upgrade keeps the 426 below, with no network I/O. */ websocket?: Pick<LinkWebsocketRelay, "wanted" | "upgrade">; } const RESPONSES_WEBSOCKET_DISABLED = "Responses WebSocket transport is disabled; use HTTP"; /** The answer codex-rs turns into an HTTP fallback for the rest of its session (C1); every link WebSocket fallback uses it. */ export function upgradeRequiredResponse(): Response { return formatErrorResponse(426, "upgrade_required", RESPONSES_WEBSOCKET_DISABLED); } /** * Lift Bun's per-request idle timer for a relayed request, as the standalone does on its data * routes (`disableResponsesRequestTimeout`). Without it the listener's idle limit cuts a quiet * stretch of a long generation: an SSE gap between events, or a Home that holds a turn after * its headers. The relay bounds the wait itself (header deadline, SSE idle limit, caller abort). * It is a local call rather than the standalone helper's import, which would load the Responses * WebSocket upstream modules into every Child. */ function liftRequestIdleTimer(req: Request, server: Pick<Server<unknown>, "timeout"> | undefined): void { if (!server) return; try { server.timeout(req, 0); } catch { /* the request may already be closed */ } } /** * The link-mode data plane of the client machine listener. It answers only the requests it * owns and returns null for everything else, which the listener handles as before. * * - A `/v1/responses` WebSocket upgrade gets 426, the answer codex-rs turns into an HTTP * fallback, unless the link WebSocket wants it (link-websocket.ts): then it is carried over the link * or, on any failure, answered with the same 426 (or 503 while the tunnel reconnects). * - Every relayed route passes the standalone loopback Host/Origin gate before any upstream * fetch, so a rebinding or cross-site browser page cannot reach the Home through this port. * - Without the committed link key nothing is fetched, and the caller gets * `503 link_credential_unavailable`. * - `/readyz` stays local and is never relayed; the listener answers it from `link-readiness.ts`. * - A relayed request is exempt from the listener's idle limit, like a standalone data route. */ export function handleLinkIngress( req: Request, url: URL, ingress: LinkIngress, server?: Pick<Server<unknown>, "timeout"> & Partial<Pick<Server<unknown>, "upgrade">>, ): Response | Promise<Response> | null { const upgrade = req.headers.get("upgrade"); if (upgrade !== null) { if (url.pathname !== "/v1/responses" || upgrade.trim().toLowerCase() !== "websocket") return null; if (!isAllowedRequestOrigin(req, ingress.policy)) { return formatErrorResponse(403, "origin_rejected", "WebSocket upgrade blocked: non-local Origin"); } if (ingress.websocket && server?.upgrade && ingress.websocket.wanted(ingress.linkId)) { liftRequestIdleTimer(req, server); return ingress.websocket.upgrade(req, server as Server<unknown>, ingress) as Promise<Response>; } return upgradeRequiredResponse(); } if (url.pathname === "/readyz" || !linkRouteAllowed(url, req)) return null; if (!isAllowedRequestOrigin(req, ingress.policy)) { return formatErrorResponse(403, "origin_rejected", "cross-origin data-plane request blocked"); } const admissionKey = ingress.linkKey(); if (!admissionKey) return Response.json({ error: "link_credential_unavailable" }, { status: 503 }); liftRequestIdleTimer(req, server); return relayLinkDataRequest(req, { tunnelPort: ingress.tunnelPort, admissionKey, linkId: ingress.linkId, apiKeyId: ingress.apiKeyId }, ingress.relay); }