@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
178 lines (165 loc) • 9.68 kB
text/typescript
import { request, type IncomingMessage } from "node:http";
import type { Socket } from "node:net";
import { createHash, randomBytes } from "node:crypto";
import { clearableDeadline } from "../lib/abort";
import { LINK_RELAY_SESSION_HEADER, linkRelayProofMatches } from "../link/relay-auth";
import {
noteHomeConnection, relayChallenge, requestOnConnection, SingleConnectionAgent, type BoundLinkRelayTarget,
} from "./link-relay-transport";
import { LINK_CHILD_WS_LIMITS, linkWebsocketChildReady } from "./link-websocket-limits";
/**
* The Home leg of a link WebSocket, design T4 3.2 steps 6 to 9: one relay-auth preflight and the
* upgrade, on one physical connection, never a second.
*
* - The preflight is the same credential-free challenge every relayed request starts with. Its own
* verified answer decides: a Home that does not name the WebSocket as on (no state pair, a pair whose
* proof does not verify, or off) gets no upgrade, and its answer still updates the cached state under
* the ordering rule.
* - The upgrade carries the session nonce and the link key as a Bearer on that same socket, with a fresh
* Sec-WebSocket-Key and without Origin, Sec-WebSocket-Extensions or Sec-WebSocket-Protocol.
* - The 101 must be on the authenticated socket and complete: Upgrade websocket, Connection upgrade, the
* right Sec-WebSocket-Accept, no extension and no subprotocol. Anything else destroys the socket.
*
* Every failure is a closed word the caller maps to 426; nothing here retries or writes a frame.
*/
export type LinkWebsocketSetupFailure = "disabled" | "credential" | "preflight" | "not_advertised" | "home_refused" | "handshake" | "timeout" | "aborted";
export type LinkWebsocketSetup =
| { ok: true; socket: Socket; head: Buffer }
| { ok: false; reason: LinkWebsocketSetupFailure; status?: number };
const WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
/** Headers of the caller's request that never travel on the Home leg's upgrade. */
const UPGRADE_OMITTED = ["origin", "sec-websocket-extensions", "sec-websocket-protocol", "sec-websocket-key", "sec-websocket-version",
"connection", "upgrade", "host", "content-length", "transfer-encoding", LINK_RELAY_SESSION_HEADER];
export function websocketAcceptFor(key: string): string {
return createHash("sha1").update(key + WEBSOCKET_GUID).digest("base64");
}
function single(value: string | string[] | undefined): string | null {
return typeof value === "string" ? value : null;
}
/** A 101 that completes this upgrade and nothing more (design 3.2 step 8). */
export function validLinkUpgradeAnswer(response: Pick<IncomingMessage, "statusCode" | "headers">, key: string): boolean {
const headers = response.headers;
if (response.statusCode !== 101) return false;
if (single(headers.upgrade)?.trim().toLowerCase() !== "websocket") return false;
if (!(single(headers.connection) ?? "").toLowerCase().split(",").some(token => token.trim() === "upgrade")) return false;
if (single(headers["sec-websocket-accept"]) !== websocketAcceptFor(key)) return false;
return headers["sec-websocket-extensions"] === undefined && headers["sec-websocket-protocol"] === undefined;
}
function upgradeOnConnection(
url: URL, headers: Headers, agent: SingleConnectionAgent, socket: Socket, key: string, signal: AbortSignal,
): Promise<LinkWebsocketSetup> {
return new Promise(resolve => {
let settled = false;
// The signal is watched here, never handed to the request: once the socket is ours, nothing may destroy it.
const onAbort = () => { if (!settled) outgoing.destroy(); };
const settle = (result: LinkWebsocketSetup): void => {
if (settled) return;
settled = true;
signal.removeEventListener("abort", onAbort);
resolve(result);
};
const failed = (): LinkWebsocketSetup => ({ ok: false, reason: signal.aborted ? "aborted" : "handshake" });
const outgoing = request(url, { method: "GET", headers: Object.fromEntries(headers), agent });
signal.addEventListener("abort", onAbort, { once: true });
outgoing.on("socket", assigned => { if (assigned !== socket) outgoing.destroy(); });
outgoing.on("upgrade", (response: IncomingMessage, upgraded: Socket, head: Buffer) => {
if (settled || signal.aborted || upgraded !== socket || !validLinkUpgradeAnswer(response, key)) {
upgraded.destroy();
settle(failed());
return;
}
settle({ ok: true, socket: upgraded, head: Buffer.from(head) });
});
outgoing.on("response", (response: IncomingMessage) => {
response.resume();
// A 101 that the HTTP parser did not take as an upgrade (no Upgrade header) is a broken handshake, not a refusal.
if (response.statusCode === 101) { socket.destroy(); settle(failed()); return; }
settle({ ok: false, reason: signal.aborted ? "aborted" : "home_refused", status: response.statusCode });
});
outgoing.on("error", () => settle(failed()));
outgoing.on("close", () => settle(failed()));
if (signal.aborted) onAbort();
outgoing.end();
});
}
export interface LinkWebsocketSetupTimers {
setTimeout(callback: () => void, ms: number): unknown;
clearTimeout(handle: unknown): void;
}
const realTimers: LinkWebsocketSetupTimers = {
setTimeout(callback, ms) { const handle = setTimeout(callback, ms); (handle as { unref?: () => void }).unref?.(); return handle; },
clearTimeout(handle) { clearTimeout(handle as ReturnType<typeof setTimeout>); },
};
/**
* Open the Home leg. `headers` are the caller's forwarded headers with the link key already set as
* the Bearer (the relay builds them); `signal` is the caller's abort. The Child's release gate is
* checked here, before any I/O, and the upgrade has its own bound (the setup budget), so neither
* depends on the caller.
*/
export async function openLinkWebsocket(
target: BoundLinkRelayTarget, headers: Headers,
options: { signal: AbortSignal; preflightMs?: number; upgradeMs?: number; timers?: LinkWebsocketSetupTimers; ready?: () => boolean },
): Promise<LinkWebsocketSetup> {
const { signal } = options;
if (!(options.ready ?? linkWebsocketChildReady)()) return { ok: false, reason: "disabled" };
if (!target.linkId || !target.apiKeyId) return { ok: false, reason: "credential" };
const origin = new URL("http://127.0.0.1:" + target.tunnelPort);
let challenge: ReturnType<typeof relayChallenge>;
try { challenge = relayChallenge(target, origin); } catch { return { ok: false, reason: "credential" }; }
const agent = new SingleConnectionAgent({ keepAlive: true, maxSockets: 1, maxFreeSockets: 1 });
const deadline = clearableDeadline(options.preflightMs ?? LINK_CHILD_WS_LIMITS.preflightMs, signal);
let handedOff = false;
try {
let answer: IncomingMessage;
try {
answer = await requestOnConnection(challenge.probe, { method: "GET", signal: deadline.signal, headers: challenge.headers }, agent);
} catch {
return { ok: false, reason: signal.aborted ? "aborted" : "preflight" };
}
const proof = answer.headers["x-opencodex-link-proof"];
if (answer.statusCode !== 204 || typeof proof !== "string" || !linkRelayProofMatches(proof, challenge.challenge.expected)) {
return { ok: false, reason: "preflight", status: answer.statusCode };
}
const { websocket } = noteHomeConnection(target, challenge.challenge.nonce, answer.headers, challenge.preflight);
try {
for await (const chunk of answer) if ((chunk as Buffer).length) return { ok: false, reason: "preflight" };
} catch {
return { ok: false, reason: signal.aborted ? "aborted" : "preflight" };
}
deadline.clear();
if (websocket !== "on") return { ok: false, reason: "not_advertised" };
if (signal.aborted) return { ok: false, reason: "aborted" };
const socket = agent.socket;
if (!socket || socket.destroyed) return { ok: false, reason: "preflight" };
const key = randomBytes(16).toString("base64");
const upgradeHeaders = new Headers(headers);
for (const name of UPGRADE_OMITTED) upgradeHeaders.delete(name);
upgradeHeaders.set("connection", "Upgrade");
upgradeHeaders.set("upgrade", "websocket");
upgradeHeaders.set("sec-websocket-version", "13");
upgradeHeaders.set("sec-websocket-key", key);
upgradeHeaders.set(LINK_RELAY_SESSION_HEADER, challenge.challenge.nonce);
// The upgrade's own bound: a Home that proved itself and then never answers cannot hold the connection.
const timers = options.timers ?? realTimers;
const upgradeDeadline = new AbortController();
const timer = timers.setTimeout(() => upgradeDeadline.abort(new DOMException("link websocket upgrade deadline", "TimeoutError")),
options.upgradeMs ?? LINK_CHILD_WS_LIMITS.setupBudgetMs);
let result: LinkWebsocketSetup;
try {
result = await upgradeOnConnection(new URL("/v1/responses", origin), upgradeHeaders, agent, socket, key, AbortSignal.any([signal, upgradeDeadline.signal]));
} finally { timers.clearTimeout(timer); }
if (!result.ok && result.reason === "aborted" && !signal.aborted && upgradeDeadline.signal.aborted) result = { ok: false, reason: "timeout" };
if (result.ok) {
handedOff = true;
// Node drops its own error listener on upgrade: until the caller adds one, an error is recorded, never unhandled.
const upgraded = result.socket as Socket & { linkError?: unknown };
upgraded.on("error", error => { upgraded.linkError ??= error; });
result.socket.setTimeout(0);
result.socket.setNoDelay(true);
}
return result;
} finally {
deadline.clear();
if (!handedOff) await agent.close();
}
}