@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
212 lines (202 loc) • 12.2 kB
text/typescript
import type { Server } from "bun";
import { loadConfig } from "../config";
import { browserSecurityHeaders, requestPolicyView } from "../server/auth-cors";
import { serveGuiFile, serveSessionBootstrap } from "../server/gui-static";
import {
initializeManagementAuthState,
issueGuiSession,
managementPrincipal,
requireManagementAuth,
type ManagementAuthState,
} from "../server/management-auth";
import { resolveInboundBodyLimitBytes } from "../server/request-decompress";
import type { OcxClientConnectionConfig, OcxConfig } from "../types";
import { disconnectClient, syncConnectedClient } from "./connect";
import { isLinkConnection, readClientConnectionState } from "./state";
import { handleMachineApi, type HubReachability, type MachineApiDeps } from "./machine-api";
import { MACHINE_GUI_ORIGIN_HEADER, requireMachineAuth } from "./machine-auth";
import { HUB_RELAY_REQUEST_BODY_MAX_BYTES, relayHubManagementRequest } from "./hub-relay";
import { createLinkKeySource, handleLinkIngress, type LinkIngress, type LinkKeySourceDeps } from "./link-ingress";
import type { LinkTunnelGate } from "./link-relay";
import { readClientLinkState, type ClientLinkState } from "./link-state";
import { projectClientLinkChild, type ClientLinkSidecarRead } from "./link-status";
import type { ClientLinkSupervisorStatus } from "./link-tunnel";
import { packageVersion } from "../lib/package-version";
import { linkRouteAllowed } from "../link/routes";
const VERSION = packageVersion("0.0.0");
const GUI_SPA_PATHS = new Set([
"/dashboard", "/startup", "/providers", "/models", "/subagents",
"/logs", "/usage", "/storage", "/codex-set", "/integrations",
]);
/** The standalone listener's idle limit: long generations and held turns are never cut. */
const LINK_LISTENER_IDLE_TIMEOUT_SECONDS = 255;
export interface MachineListenerDeps {
state?: OcxClientConnectionConfig;
managementAuthState?: ManagementAuthState;
fetchImpl?: typeof fetch;
machineApi?: Partial<MachineApiDeps>;
/** Link mode: the client tunnel supervisor state for `GET /api/link/status`. */
linkStatus?: () => ClientLinkSupervisorStatus;
/** Link mode: the sidecar read for `GET /api/link/status`. */
readSidecar?: () => ClientLinkState | null;
/** Link mode: how the link key is read; the listener reads it once and caches it. */
linkKey?: LinkKeySourceDeps;
/** Link mode: a key source the runtime already holds (shared with the tunnel supervisor). */
linkKeySource?: () => string | null;
/** Link mode: the tunnel supervisor; relayed requests wait on it while it reconnects. */
linkTunnel?: LinkTunnelGate;
/** Link mode: relay seams (deadline clock and byte cap). */
linkRelay?: LinkIngress["relay"];
serve?: (options: Parameters<typeof Bun.serve>[0]) => Server<unknown>;
}
function json404(req: Request): Response {
const url = new URL(req.url);
return Response.json({ error: "not_found", method: req.method, path: url.pathname }, { status: 404 });
}
function machinePolicyConfig(config: OcxConfig): OcxConfig {
return { ...config, hostname: "127.0.0.1" };
}
export function machineRouteAllowed(url: URL, req: Request, relayEnabled: boolean, linkMode = false): boolean {
if (req.headers.get("upgrade")) return false;
if (linkMode && linkRouteAllowed(url, req)) return true;
const path = url.pathname;
if (req.method === "GET" && (path === "/healthz" || path === "/readyz" || path === "/" || path === "/opencodex-session")) return true;
if ((req.method === "GET" || req.method === "HEAD") && (path === "/api/machine/status" || path === "/api/machine/clients" || path === "/api/machine/shim")) return true;
// The one link route a connected Child serves: its own read-only link status.
if (linkMode && (req.method === "GET" || req.method === "HEAD") && path === "/api/link/status") return true;
if (req.method === "POST" && (path === "/api/machine/sync" || path === "/api/machine/shim" || path === "/api/machine/disconnect")) return true;
if (relayEnabled && path.startsWith("/api/machine/hub-relay/")) return true;
// Known machine endpoints are admitted for every method so an unsupported
// method reaches the authenticated method restriction (403) instead of a
// bare 404 that hides the endpoint entirely.
if (path === "/api/machine/status" || path === "/api/machine/clients" || path === "/api/machine/shim"
|| path === "/api/machine/sync" || path === "/api/machine/disconnect") return true;
if (req.method !== "GET" || path.startsWith("/api/") || path.startsWith("/v1/")) return false;
return GUI_SPA_PATHS.has(path)
|| path.startsWith("/integrations/")
|| /\.(?:css|gif|ico|jpe?g|js|json|map|png|svg|webp|woff2?)$/i.test(path);
}
function readSidecarSafely(read: () => ClientLinkState | null): ClientLinkSidecarRead {
try { return read(); } catch { return "invalid"; }
}
export function startMachineListener(
port?: number,
deps: MachineListenerDeps = {},
): Server<unknown> {
const config = machinePolicyConfig(loadConfig());
const connection = deps.state ?? (() => {
const state = readClientConnectionState();
if (state.kind !== "connected") throw new Error(`machine listener requires connected client state, got ${state.kind}`);
return state.value;
})();
const linkMode = isLinkConnection(connection);
if (linkMode && !connection.link) throw new Error("link machine listener requires link transport metadata");
const managementAuth = deps.managementAuthState ?? initializeManagementAuthState(config);
let hubReachability: HubReachability = "unknown";
const machineApiDeps: MachineApiDeps = {
sync: deps.machineApi?.sync ?? syncConnectedClient,
disconnect: deps.machineApi?.disconnect ?? disconnectClient,
scheduleStandaloneRecycle: deps.machineApi?.scheduleStandaloneRecycle ?? (tokenFingerprint => {
void import("./runtime").then(module => module.scheduleStandaloneRecycle(tokenFingerprint));
}),
hubReachability: deps.machineApi?.hubReachability ?? (() => hubReachability),
setHubReachability: deps.machineApi?.setHubReachability ?? (value => { hubReachability = value; }),
};
const relayEnabled = !linkMode && connection.managementTransport === "relay";
// Link mode only. Everything is resolved once here, so a relayed request reads no file and
// builds no policy: the key is cached, the loopback policy is fixed at bind like the listener.
const inboundBodyLimit = resolveInboundBodyLimitBytes(config.maxInboundBodyBytes);
const linkIngress: LinkIngress | null = linkMode
? {
tunnelPort: connection.link!.tunnelPort,
linkId: connection.link!.linkId,
apiKeyId: connection.apiKeyId,
policy: requestPolicyView(config, "127.0.0.1"),
linkKey: deps.linkKeySource ?? createLinkKeySource(connection.tokenFingerprint, deps.linkKey),
relay: { fetchImpl: deps.fetchImpl, bodyLimitBytes: inboundBodyLimit, tunnel: deps.linkTunnel, ...deps.linkRelay },
}
: null;
const readSidecar = deps.readSidecar ?? (() => readClientLinkState());
return (deps.serve ?? (options => Bun.serve(options)))({
port: port ?? config.port ?? 10100,
hostname: "127.0.0.1",
// A hub client relays only bounded management calls. A link Child carries the Codex data
// plane, so it admits what a standalone listener admits and keeps its idle limit.
maxRequestBodySize: linkMode ? inboundBodyLimit : HUB_RELAY_REQUEST_BODY_MAX_BYTES,
...(linkMode ? { idleTimeout: LINK_LISTENER_IDLE_TIMEOUT_SECONDS } : {}),
async fetch(req: Request, server: Server<unknown>) {
const url = new URL(req.url);
if (linkIngress) {
const handled = handleLinkIngress(req, url, linkIngress, server);
if (handled) return handled;
}
if (!machineRouteAllowed(url, req, relayEnabled, linkMode)) return json404(req);
if (url.pathname === "/healthz" && req.method === "GET") {
return Response.json({ service: "opencodex", version: VERSION, role: "client", uptime: process.uptime(), pid: process.pid, port: server.port });
}
if (url.pathname === "/readyz" && req.method === "GET") {
return Response.json({ service: "opencodex", version: VERSION, role: "client", status: "ready", uptime: process.uptime(), pid: process.pid, port: server.port, protocolVersion: 1 });
}
if (url.pathname.startsWith("/api/machine/hub-relay/")) {
if (!relayEnabled) return json404(req);
const authError = requireMachineAuth(req, managementAuth, config);
if (authError) return authError;
const prefix = "/api/machine/hub-relay";
const suffix = `${url.pathname.slice(prefix.length)}${url.search}`;
const response = await relayHubManagementRequest(req, suffix, {
managementUrl: connection.managementUrl,
browserOrigin: req.headers.get(MACHINE_GUI_ORIGIN_HEADER) ?? req.headers.get("Origin") ?? "",
}, { fetchImpl: deps.fetchImpl });
if (response.status === 401) hubReachability = "unauthorized";
else if (response.status >= 500) hubReachability = "offline";
else hubReachability = "online";
return response;
}
if (url.pathname.startsWith("/api/machine/") || (linkMode && url.pathname === "/api/link/status")) {
const authError = requireManagementAuth(req, managementAuth, config);
if (authError) return authError;
if (managementPrincipal(req, managementAuth, config) !== "gui-session") {
return Response.json({ error: "opencodex machine GUI session required" }, { status: 401 });
}
// A loopback dashboard session proves possession, not user presence: any local
// process can fetch the dashboard bootstrap and replay its token and CSRF value.
// Keep the connected listener useful for status/diagnostics, but never let that
// credentialless bootstrap authorize durable machine changes. Those operations
// remain available through the explicit CLI commands.
if (req.method !== "GET" && req.method !== "HEAD") {
return Response.json({ error: "opencodex machine changes require the local CLI" }, { status: 403 });
}
if (url.pathname === "/api/link/status") {
// A Child never joins again from here, so the dashboard reads `joinAvailable: false`.
const status = projectClientLinkChild(readSidecarSafely(readSidecar), deps.linkStatus?.() ?? { kind: "stopped" }, Date.now());
return Response.json({ ...status, joinAvailable: false }, { headers: { "Cache-Control": "no-store" } });
}
return await handleMachineApi(req, url, connection, machineApiDeps) ?? json404(req);
}
const session = (url.pathname === "/" || url.pathname === "/opencodex-session")
? issueGuiSession(req, config, managementAuth, { trustedTailscaleIngress: false })
: null;
if (url.pathname === "/opencodex-session" && session) return serveSessionBootstrap(session);
// State the role, exactly as the standalone/hub server does (src/server/index.ts).
// The GUI decides whether a machine plane exists from this tag alone
// (gui/src/api-targets.ts `isConnectedRuntime`): without it `discoverApiTargets`
// returns standalone targets and never queries /api/machine/status, so a connected
// client renders as a plain install — no hub usage scope, no "this machine" panel,
// no connected-client list. This listener only ever serves a connected client, so
// the role is a constant here rather than a config read.
const gui = serveGuiFile(url.pathname, undefined, session ?? undefined, "client");
if (gui) return gui;
if (url.pathname === "/") {
return Response.json({
status: "ok",
service: "opencodex",
version: VERSION,
role: "client",
dashboard: { available: false, reason: "GUI build not found" },
endpoints: { health: "/healthz", ready: "/readyz", machine: "/api/machine/*" },
}, { headers: browserSecurityHeaders() });
}
return json404(req);
},
} as Parameters<typeof Bun.serve>[0]);
}