@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
185 lines (177 loc) • 8.62 kB
text/typescript
import { Agent, request, type IncomingMessage } from "node:http";
import type { Socket } from "node:net";
import { Readable } from "node:stream";
import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
import { serviceApiTokenFingerprint } from "../lib/service-secrets";
import { clearableDeadline } from "../lib/abort";
import {
LINK_RELAY_AUTH_PATH, LINK_RELAY_AUTH_TIMEOUT_MS, LINK_RELAY_AUTH_VERSION,
LINK_RELAY_SESSION_HEADER, linkRelayChallenge, linkRelayProofMatches,
} from "../link/relay-auth";
export interface BoundLinkRelayTarget {
tunnelPort: number;
admissionKey: string;
linkId?: string;
apiKeyId?: string;
}
export class LinkRelayAuthenticationError extends Error {
constructor(readonly unrecognized = false) {
super(unrecognized ? "link relay authentication unavailable; upgrade the Home and Child or re-link"
: "link relay authentication failed");
this.name = "LinkRelayAuthenticationError";
}
}
/** One physical connection, ever. A closed keep-alive socket cannot trigger a silent reconnect. */
class SingleConnectionAgent extends Agent {
socket: Socket | undefined;
private opened = false;
private closeFlight?: Promise<void>;
/** Drain the socket close event before the request reports a terminal outcome. */
close(): Promise<void> {
if (this.closeFlight) return this.closeFlight;
const socket = this.socket;
this.closeFlight = !socket || socket.closed ? Promise.resolve()
: new Promise<void>(resolve => { socket.once("close", () => resolve()); });
this.destroy();
return this.closeFlight;
}
override createConnection(...[options, callback]: Parameters<Agent["createConnection"]>): ReturnType<Agent["createConnection"]> {
if (this.opened) {
if (!callback) throw new LinkRelayAuthenticationError();
callback(new LinkRelayAuthenticationError(), this.socket!);
return undefined;
}
this.opened = true;
this.socket = super.createConnection(options, callback) as Socket;
return this.socket;
}
}
function requestOnConnection(
url: URL, init: RequestInit, agent: SingleConnectionAgent, authenticatedSocket?: Socket,
): Promise<IncomingMessage> {
return new Promise((resolve, reject) => {
const headers = Object.fromEntries(new Headers(init.headers));
// No implicit decompression negotiation; handle an explicitly encoded response below anyway.
headers["accept-encoding"] = "identity";
const outgoing = request(url, {
method: init.method ?? "GET", headers, agent, signal: init.signal ?? undefined,
maxHeaderSize: 64 * 1024,
}, resolve);
outgoing.on("error", reject);
outgoing.on("upgrade", (_response, socket) => { socket.destroy(); reject(new LinkRelayAuthenticationError()); });
outgoing.on("socket", socket => {
if (authenticatedSocket && socket !== authenticatedSocket) outgoing.destroy(new LinkRelayAuthenticationError());
});
void (async () => {
const body = init.body;
if (body instanceof ReadableStream) {
const reader = body.getReader();
const abort = () => { void reader.cancel(init.signal?.reason).catch(() => {}); };
init.signal?.addEventListener("abort", abort, { once: true });
outgoing.once("close", abort);
try {
for (;;) {
init.signal?.throwIfAborted();
const next = await reader.read();
if (next.done) break;
// Await the write callback: upstream backpressure never buffers the whole upload.
await new Promise<void>((done, fail) => outgoing.write(next.value,
error => error ? fail(error) : done()));
}
} finally {
init.signal?.removeEventListener("abort", abort);
outgoing.removeListener("close", abort);
try { await reader.cancel(); } catch { /* preserve the upload outcome */ }
reader.releaseLock();
}
} else if (body != null) {
if (typeof body === "string" || body instanceof Uint8Array) outgoing.write(body);
else throw new TypeError("unsupported link relay body");
}
outgoing.end();
})().catch(error => { outgoing.destroy(error instanceof Error ? error : new Error("link upload failed")); reject(error); });
});
}
function responseHeaders(incoming: IncomingMessage): Headers {
const headers = new Headers();
for (let i = 0; i < incoming.rawHeaders.length; i += 2) {
headers.append(incoming.rawHeaders[i]!, incoming.rawHeaders[i + 1]!);
}
return headers;
}
/** Node HTTP compatibility is confined here; the relay continues to expose a Web Response/stream. */
async function responseOnConnection(incoming: IncomingMessage, agent: SingleConnectionAgent, method: string): Promise<Response> {
const headers = responseHeaders(incoming);
const status = incoming.statusCode ?? 502;
if (method === "HEAD" || status === 204 || status === 205 || status === 304) {
for await (const _chunk of incoming) { /* drain a header-only response */ }
await agent.close();
return new Response(null, { status, headers });
}
let source: Readable = incoming;
const encoding = headers.get("content-encoding")?.trim().toLowerCase();
const decoder = encoding === "gzip" ? createGunzip() : encoding === "deflate" ? createInflate()
: encoding === "br" ? createBrotliDecompress() : undefined;
if (encoding && encoding !== "identity" && !decoder) {
throw new Error("unsupported link response encoding");
}
if (decoder) {
incoming.on("error", error => decoder.destroy(error));
source = incoming.pipe(decoder);
}
const reader = (Readable.toWeb(source) as unknown as ReadableStream<Uint8Array>).getReader();
let finished = false;
const finish = async () => {
if (finished) return agent.close();
finished = true;
if (source !== incoming) source.destroy();
await agent.close();
try { reader.releaseLock(); } catch { /* a cancelled read may still be settling */ }
};
return new Response(new ReadableStream<Uint8Array>({
async pull(controller) {
try {
const next = await reader.read();
if (next.done) { await finish(); controller.close(); }
else controller.enqueue(next.value);
} catch (error) { await finish(); controller.error(error); }
},
async cancel(reason) {
try { await reader.cancel(reason); } finally { await finish(); }
},
}, { highWaterMark: 0 }), { status, headers });
}
/** Authenticate and stream one request on the SAME socket; never fall back to an ordinary fetch. */
export async function fetchBoundLinkRelay(target: BoundLinkRelayTarget, destination: string, init: RequestInit): Promise<Response> {
if (!target.linkId || !target.apiKeyId) throw new LinkRelayAuthenticationError();
const url = new URL(destination);
if (url.origin !== `http://127.0.0.1:${target.tunnelPort}`) throw new LinkRelayAuthenticationError();
const challenge = linkRelayChallenge(serviceApiTokenFingerprint(target.admissionKey), target.apiKeyId, target.linkId);
const probe = new URL(LINK_RELAY_AUTH_PATH, url);
probe.search = new URLSearchParams({ version: LINK_RELAY_AUTH_VERSION, key: target.apiKeyId,
link: target.linkId, nonce: challenge.nonce, proof: challenge.caller }).toString();
const agent = new SingleConnectionAgent({ keepAlive: true, maxSockets: 1, maxFreeSockets: 1 });
const deadline = clearableDeadline(LINK_RELAY_AUTH_TIMEOUT_MS, init.signal ?? undefined);
try {
const response = await requestOnConnection(probe, { method: "GET", signal: deadline.signal }, agent);
const socket = agent.socket;
const proof = response.headers["x-opencodex-link-proof"];
if (response.statusCode !== 204 || typeof proof !== "string" || !linkRelayProofMatches(proof, challenge.expected)) {
throw new LinkRelayAuthenticationError(response.statusCode === 404);
}
// Drain the credential-free response before the Agent can reuse its socket.
for await (const chunk of response) {
if (chunk.length) throw new LinkRelayAuthenticationError();
}
deadline.clear();
init.signal?.throwIfAborted();
if (!socket || socket.destroyed || socket !== agent.socket) throw new LinkRelayAuthenticationError();
const headers = new Headers(init.headers);
headers.set(LINK_RELAY_SESSION_HEADER, challenge.nonce);
const incoming = await requestOnConnection(url, { ...init, headers }, agent, socket);
return await responseOnConnection(incoming, agent, init.method ?? "GET");
} catch (error) {
await agent.close();
throw error;
} finally { deadline.clear(); }
}