@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
271 lines (269 loc) • 13.5 kB
text/typescript
import type { ServerWebSocket } from "bun";
import { MessageBudget } from "./budget";
import { LocalMessageRpc } from "./rpc";
import { localDaemonEndpoint } from "./socket";
import { isRecord, isThreadId } from "./types";
import { capability, exactRecord, matchesProof, peerProof, RemoteCapacity, REMOTE_LIMITS,
REMOTE_PROTOCOL, validCapability, type RemotePeer } from "./remote-contract";
import { admitRemoteRpc } from "./remote-rpc-admission";
import { receiveRemoteEnvelope } from "./remote-envelope";
import { RemoteReplyGrants } from "./remote-replies";
import type { RemoteMessageStore } from "./remote-store";
interface Connection {
stage: "hello" | "proof" | "authorized";
budget: MessageBudget;
release: () => void;
peer?: RemotePeer;
key?: string;
from?: string;
transaction?: string;
nonce?: string;
serverNonce?: string;
ws?: ServerWebSocket<Connection>;
rpc?: LocalMessageRpc;
pending: number;
lastId: number;
queue: boolean;
initialized: boolean;
initializing: boolean;
closed: boolean;
authTimer?: ReturnType<typeof setTimeout>;
loadedIds: Set<string>;
}
export interface RemoteBridgeHooks {
control(peer: RemotePeer | null, method: string, params: unknown, budget: MessageBudget): Promise<unknown>;
}
/** A foreground-owned loopback gateway authenticates before touching the existing native daemon. */
export function startRemoteBridge(store: RemoteMessageStore, codexHome: string, capacity: RemoteCapacity,
signal: AbortSignal, hooks: RemoteBridgeHooks) {
const initial = store.requireEnabled();
const connections = new Set<Connection>();
const tasks = new Set<Promise<void>>();
const replies = new RemoteReplyGrants(store);
let stopping = false;
let closePromise: Promise<void> | undefined;
const validConnection = (data: Connection): boolean => {
const state = store.requireEnabled();
if (state.generation !== initial.generation) return false;
if (!data.peer) return data.key === state.controlKey;
return state.peers.some(peer => peer.machine.id === data.from
&& peer.transaction === data.transaction && peer.incoming === data.key);
};
const retire = (data: Connection) => {
if (data.closed) return;
data.closed = true;
clearTimeout(data.authTimer);
connections.delete(data);
data.budget.dispose();
data.rpc?.close();
data.ws?.terminate();
data.release();
};
const send = (data: Connection, value: unknown) => {
const frame = JSON.stringify(value);
const free = capacity.reserve("outputBytes", Buffer.byteLength(frame));
try {
if (!data.ws || data.ws.send(frame) <= 0) retire(data);
} finally {
free();
}
};
const authenticate = (data: Connection, raw: unknown) => {
const state = store.requireEnabled();
if (state.generation !== initial.generation) throw new Error("Messaging owner generation changed.");
if (data.stage === "hello") {
const hello = exactRecord(raw, ["type", "protocol", "from", "to", "transaction", "nonce"]);
if (hello.type !== "hello" || hello.protocol !== REMOTE_PROTOCOL || !isThreadId(hello.from)
|| hello.to !== state.machine.id || !isThreadId(hello.transaction) || !validCapability(hello.nonce)) {
throw new Error("Invalid messaging authentication hello.");
}
const peer = state.peers.find(item => item.machine.id === hello.from && item.transaction === hello.transaction);
const isLocalControl = hello.from === state.machine.id && hello.transaction === state.generation;
const key = isLocalControl ? state.controlKey : peer?.incoming;
if (!key) throw new Error("Messaging enrollment is unavailable.");
Object.assign(data, { peer, key, from: hello.from, transaction: hello.transaction, nonce: hello.nonce, serverNonce: capability() });
data.stage = "proof";
send(data, { type: "challenge", nonce: data.serverNonce, proof: peerProof(key, "server", data.from!, state.machine.id,
data.transaction!, data.nonce!, data.serverNonce!) });
} else {
const proof = exactRecord(raw, ["type", "proof"]);
if (proof.type !== "authorize" || !validConnection(data) || !matchesProof(proof.proof,
peerProof(data.key!, "client", data.from!, state.machine.id, data.transaction!, data.nonce!, data.serverNonce!))) {
throw new Error("Messaging authentication proof was refused.");
}
// Unverified sockets never consume outgoing/control capacity. Promote only after proof verification.
// Peer sockets share the connections outside the owner's reserved control/probe/renewal slots.
const release = data.peer ? capacity.reservePeerConnection() : capacity.reserve("connections");
data.release();
data.release = release;
data.stage = "authorized";
clearTimeout(data.authTimer);
send(data, { type: "authorized", protocol: REMOTE_PROTOCOL });
}
};
const execute = async (data: Connection, frame: Record<string, unknown>) => {
const id = frame.id;
const method = frame.method as string;
data.budget.throwIfEnded();
if (!validConnection(data)) throw new Error("Messaging enrollment changed.");
if (method.startsWith("message/")) {
if (data.rpc || data.pending !== 1) throw new Error("Control and native RPC cannot share a connection.");
const result = method === "message/reply-route" && !data.peer
? replies.control(frame.params)
: await hooks.control(data.peer ?? null, method, frame.params, data.budget);
if (!data.closed && validConnection(data)) send(data, { id, result });
return;
}
const params = admitRemoteRpc(method, frame.params);
let result: unknown;
if (method === "initialize") {
if (data.rpc || data.initializing || data.initialized) throw new Error("Messaging connection was already initialized.");
data.initializing = true;
data.rpc = await LocalMessageRpc.connect(localDaemonEndpoint(codexHome).url, data.budget);
data.initializing = false;
result = { userAgent: REMOTE_PROTOCOL };
} else if (method === "initialized") {
if (id !== undefined || !data.rpc || data.initialized) throw new Error("Invalid messaging initialization acknowledgement.");
data.initialized = true;
return;
} else {
if (!data.rpc || !data.initialized) throw new Error("Initialize the messaging connection before native RPC.");
if (method === "thread/loaded/list") {
const page = await data.rpc.loadedPage(params.cursor as string | undefined);
const visible = page.data.filter(id => !data.peer || replies.visible(data.peer, id));
for (const id of visible) data.loadedIds.add(id);
if (data.loadedIds.size > 1000) throw new Error("Loaded session limit exceeded.");
result = { ...page, data: visible };
}
else if (method === "thread/read") {
if (!data.loadedIds.has(params.threadId as string)
|| (data.peer && !replies.visible(data.peer, params.threadId as string))) {
throw new Error("Session is outside this peer's reply routes.");
}
const thread = await data.rpc.readThread(params.threadId as string);
if (data.peer && !replies.visible(data.peer, thread.id)) throw new Error("Session permission changed during lookup.");
result = { thread: { id: thread.id, name: thread.name, status: { type: thread.status } } };
} else {
if (data.queue || !data.peer) throw new Error("Only one peer message may be queued per connection.");
data.queue = true;
const envelope = receiveRemoteEnvelope((params.input as { text: string }[])[0]!.text,
params.clientUserMessageId as string, data.peer);
if (!data.loadedIds.has(params.threadId as string)) {
send(data, { id, error: { code: -32000, message: "Recipient was not discovered loaded on this connection." } });
return;
}
const fresh = await data.rpc.readThread(params.threadId as string);
if (fresh.status === "notLoaded") {
send(data, { id, error: { code: -32000, message: "Recipient unloaded before queue submission." } });
return;
}
if (!validConnection(data)) throw new Error("Messaging enrollment changed before submission.");
data.budget.throwIfEnded();
const settleReply = replies.begin(data.peer, envelope.header, params.threadId as string);
let submissionId: string | undefined;
// An exception or uncertain receipt must spend the one-shot route, not authorize a replay.
let submitted = true;
let receipt;
try {
receipt = await data.rpc.queueMessage(params.threadId as string,
envelope.text, params.clientUserMessageId as string, value => { submissionId = value; });
submitted = receipt.status !== "not_sent";
} finally {
settleReply(submitted);
}
if (receipt.status === "unknown") {
retire(data);
return;
}
if (receipt.status === "not_sent") {
send(data, { id, error: { code: receipt.error?.code === "unsupported_queue" ? -32601 : -32000,
message: "Messaging queue request was rejected." } });
return;
}
result = { queuedSubmission: { id: submissionId, input: params.input, clientUserMessageId: params.clientUserMessageId } };
}
}
if (!data.closed && validConnection(data)) {
send(data, { id, result });
} else {
retire(data);
}
};
const server = Bun.serve<Connection>({ hostname: "127.0.0.1", port: initial.port, development: false,
maxRequestBodySize: 4096, idleTimeout: 30,
fetch(req, runtime) {
try {
const url = new URL(req.url);
if (stopping || signal.aborted || !store.requireEnabled() || url.pathname !== "/message" || url.search
|| req.method !== "GET" || req.headers.has("origin") || req.headers.has("authorization")) return new Response(null, { status: 403 });
const unauthenticated = [...connections].filter(data => data.stage !== "authorized");
// Reclaim the oldest idle admission instead of letting four silent clients block all fresh proofs.
if (unauthenticated.length >= REMOTE_LIMITS.unauthenticated) retire(unauthenticated[0]!);
const release = () => {};
const budget = new MessageBudget(30000, signal);
const data: Connection = { stage: "hello", budget, release, pending: 0, lastId: 0, queue: false,
initialized: false, initializing: false, closed: false, loadedIds: new Set() };
connections.add(data);
budget.signal.addEventListener("abort", () => retire(data), { once: true });
data.authTimer = setTimeout(() => retire(data), REMOTE_LIMITS.authMs);
if (runtime.upgrade(req, { data })) return;
retire(data);
return new Response(null, { status: 400 });
} catch { return new Response(null, { status: 503 }); }
},
websocket: { maxPayloadLength: REMOTE_LIMITS.frameBytes, backpressureLimit: 1,
closeOnBackpressureLimit: true,
open(ws) { ws.data.ws = ws; },
close(ws) { retire(ws.data); },
message(ws, message) {
const data = ws.data;
try {
if (stopping || data.closed || typeof message !== "string"
|| Buffer.byteLength(message) > (data.stage === "authorized" ? REMOTE_LIMITS.frameBytes : 4096)) {
throw new Error("Messaging connection is closed or its frame is invalid.");
}
const raw: unknown = JSON.parse(message);
if (data.stage !== "authorized") {
authenticate(data, raw);
return;
}
if (!isRecord(raw) || typeof raw.method !== "string" || Object.keys(raw).some(key => !["id", "method", "params"].includes(key))) {
throw new Error("Invalid messaging RPC frame.");
}
if (raw.method !== "initialized") {
if (!Number.isSafeInteger(raw.id) || Number(raw.id) <= data.lastId) throw new Error("Messaging RPC IDs must strictly increase.");
data.lastId = Number(raw.id);
} else if (raw.id !== undefined) throw new Error("The initialized notification must not have a request ID.");
if (data.pending >= 4) throw new Error("Messaging RPC concurrency limit exceeded.");
const free = capacity.reserve("requests");
let freeBytes: () => void;
try {
freeBytes = capacity.reserve("outputBytes", Buffer.byteLength(message));
} catch (error) {
free();
throw error;
}
data.pending++;
const task = execute(data, raw).catch(() => retire(data)).finally(() => {
data.pending--;
free();
freeBytes();
tasks.delete(task);
});
tasks.add(task);
} catch { retire(data); }
},
}, error() { return new Response(null, { status: 503 }); },
});
const close = (): Promise<void> => closePromise ??= (async () => {
stopping = true;
signal.removeEventListener("abort", abort);
for (const data of [...connections]) retire(data);
await server.stop(true);
await Promise.allSettled([...tasks]);
})();
const abort = () => { void close(); };
signal.addEventListener("abort", abort, { once: true });
if (signal.aborted) abort();
return { port: server.port!, close };
}