@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
170 lines (167 loc) • 10.9 kB
text/typescript
import { MessageBudget } from "./budget";
import { authenticatedRemoteSocket, peerEndpoint, remoteControl, type RemoteEndpoint } from "./remote-auth";
import { startRemoteBridge } from "./remote-bridge";
import { exactRecord, RemoteCapacity, REMOTE_LIMITS, remoteError, validPort, type RemotePeer, type RemoteState } from "./remote-contract";
import { remotePortIsLoopback } from "./remote-ports";
import { LocalMessageRpc } from "./rpc";
import type { RemoteMessageStore } from "./remote-store";
import { startRemoteTunnels, type RemoteTunnelPair, type RemoteTunnelDeps } from "./remote-tunnels";
import { isThreadId, LocalMessagingError } from "./types";
interface Route { peer: RemotePeer; port: number; generation: string; expiry: number; ready: boolean; tunnels?: RemoteTunnelPair }
export interface RemoteOwnerDeps extends RemoteTunnelDeps { now?: () => number }
/** Local owner-control capability never leaves this configuration home or enters remote enrollment. */
export function ownerEndpoint(state: RemoteState): RemoteEndpoint {
return { port: state.port, machineId: state.machine.id, transaction: state.generation, key: state.controlKey };
}
/** Discover a route from the live authenticated owner, never a cached loopback port or implicit startup. */
export async function resolveRemoteRoute(store: RemoteMessageStore, selector: string, budget: MessageBudget) {
const state = store.requireEnabled(), peer = store.peer(selector);
const result = exactRecord(await remoteControl(state, ownerEndpoint(state), "message/routes", {}, budget), ["routes"]);
if (!Array.isArray(result.routes) || result.routes.length > REMOTE_LIMITS.peers) throw remoteError("invalid_remote_route", "Messaging owner returned invalid routes.");
const matches = result.routes.filter(route => route && typeof route === "object" && route.machineId === peer.machine.id);
if (matches.length !== 1) throw remoteError("route_unavailable", "No live messaging route exists for this enrolled peer; run the explicit foreground owner.");
const route = exactRecord(matches[0], ["machineId", "transaction", "port", "kind"]);
if (route.transaction !== peer.transaction || !validPort(route.port) || !["initiated", "leased"].includes(String(route.kind))) throw remoteError("invalid_remote_route", "Messaging route does not match the current enrollment.");
store.requireCurrentPeer(state, peer);
return { state, peer, endpoint: peerEndpoint(peer, route.port) };
}
/** Explicit foreground lifetime: one listener, aggregate reservations and bounded owned tunnel teardown. */
export async function startRemoteOwner(store: RemoteMessageStore, home: string, selectors: readonly string[], parent?: AbortSignal,
tunnelDeps: RemoteOwnerDeps = {}) {
const state = store.requireEnabled(), generation = crypto.randomUUID(), controller = new AbortController();
const now = tunnelDeps.now ?? (() => performance.now());
const capacity = new RemoteCapacity(), routes = new Map<string, Route>(), operations = new Set<Promise<unknown>>();
// Availability may retire before cleanup settles; retain every published pair's join and failure.
const ownedTunnels = new Set<RemoteTunnelPair>();
let finish!: () => void, finishError!: (error: Error) => void;
const finished = new Promise<void>((resolve, reject) => { finish = resolve; finishError = reject; });
void finished.catch(() => {});
let stopping = false, closing: Promise<void> | undefined, timer: ReturnType<typeof setInterval> | undefined;
const check = () => {
const current = store.requireEnabled();
if (stopping || current.generation !== state.generation) throw remoteError("owner_retired", "Messaging owner configuration changed; restart this foreground owner explicitly.");
return current;
};
const probe = async (peer: RemotePeer, port: number, budget: MessageBudget) => {
const release = capacity.reserve("connections"); let rpc: LocalMessageRpc | undefined;
try { rpc = await LocalMessageRpc.attach(await authenticatedRemoteSocket(check(), peerEndpoint(peer, port), budget), budget); }
finally { rpc?.close(); release(); }
};
const bridge = startRemoteBridge(store, home, capacity, controller.signal, {
async control(peer, method, params, budget) {
check();
if (method === "message/routes" && !peer) {
exactRecord(params, []);
const current = check();
return { routes: [...routes.values()].filter(route => route.ready && current.peers.some(p => p.transaction === route.peer.transaction)
&& (route.tunnels ? route.tunnels.alive : route.expiry > now())).map(route => ({
machineId: route.peer.machine.id, transaction: route.peer.transaction, port: route.port, kind: route.tunnels ? "initiated" : "leased" })) };
}
if (method !== "message/lease" || !peer) throw new Error();
const lease = exactRecord(params, ["port", "generation"]);
if (!validPort(lease.port) || !isThreadId(lease.generation)) throw new Error();
if (!await remotePortIsLoopback(lease.port, budget, capacity)) throw new Error();
await probe(peer, lease.port, budget);
check(); budget.throwIfEnded(); store.requireCurrentPeer(state, peer);
const existing = routes.get(peer.machine.id);
if (existing?.tunnels) throw new Error();
if (existing && existing.generation !== lease.generation && existing.expiry > now()) {
if (existing.port === lease.port) throw new Error();
// A live generation keeps its lease. Native availability is not owner identity evidence.
const release = capacity.reserve("connections"); let oldBudget: MessageBudget | undefined;
let authenticated = false;
try {
oldBudget = new MessageBudget(budget.remainingMs(1000), budget.signal);
try {
const socket = await authenticatedRemoteSocket(check(), peerEndpoint(existing.peer, existing.port), oldBudget);
socket.terminate(); authenticated = true;
} catch (error) {
if (!(error instanceof LocalMessagingError) || !["remote_auth_failed", "operation_timeout"].includes(error.code)) throw error;
}
} finally { oldBudget?.dispose(); release(); }
check(); budget.throwIfEnded(); store.requireCurrentPeer(state, peer);
if (authenticated || routes.get(peer.machine.id) !== existing) throw new Error();
}
routes.set(peer.machine.id, { peer, port: lease.port, generation: lease.generation, ready: true, expiry: now() + REMOTE_LIMITS.leaseMs });
return { leased: true, generation: lease.generation };
},
});
const register = async (route: Route, budget: MessageBudget) => {
const free = capacity.reserve("connections");
try {
const result = exactRecord(await remoteControl(check(), peerEndpoint(route.peer, route.port), "message/lease",
{ port: route.tunnels!.returnPort, generation }, budget), ["leased", "generation"]);
check(); budget.throwIfEnded(); store.requireCurrentPeer(state, route.peer);
if (routes.get(route.peer.machine.id) !== route) throw new Error();
if (result.leased !== true || result.generation !== generation || !route.tunnels!.alive) throw new Error();
} finally { free(); }
};
const renew = async (budget: MessageBudget) => {
const results = await Promise.allSettled([...routes.values()].filter(route => route.tunnels).map(route => register(route, budget)));
const failure = results.find(result => result.status === "rejected");
if (failure?.status === "rejected") throw failure.reason;
check(); budget.throwIfEnded();
};
const close = (): Promise<void> => closing ??= (async () => {
stopping = true; clearInterval(timer); parent?.removeEventListener("abort", abort); controller.abort();
const results = await Promise.allSettled([bridge.close(), ...[...ownedTunnels].map(tunnels => tunnels.close()), ...operations]);
routes.clear(); ownedTunnels.clear();
if (results.some(result => result.status === "rejected")) {
const error = remoteError("cleanup_incomplete", "Messaging owner cleanup did not complete cleanly.");
finishError(error); throw error;
}
finish();
})();
const abort = () => { void close().catch(() => {}); };
parent?.addEventListener("abort", abort, { once: true });
if (parent?.aborted) abort();
const setup = new MessageBudget(30000, controller.signal);
try {
const unique = new Set(selectors.map(selector => store.peer(selector).machine.id));
if (unique.size !== selectors.length) throw remoteError("duplicate_peer", "Do not initiate the same peer more than once.");
for (const selector of selectors) {
check(); const peer = store.peer(selector);
const tunnels = await startRemoteTunnels(store, peer, setup, capacity, controller.signal, tunnelDeps);
const route: Route = { peer, port: tunnels.localPort, generation, expiry: Infinity, ready: false, tunnels };
try {
check(); setup.throwIfEnded(); ownedTunnels.add(tunnels); routes.set(peer.machine.id, route);
} catch (error) {
// Before publication this local scope, not the routes map, owns the join.
await tunnels.close(); throw error;
}
void tunnels.exited.then(() => {
if (!stopping && routes.get(peer.machine.id) === route) { routes.delete(peer.machine.id); abort(); }
});
// The data connection proves both the peer and native initialization before ready publication.
await probe(peer, route.port, setup); await register(route, setup);
check(); setup.throwIfEnded();
}
// Earlier peers may have spent their lease lifetime waiting for later setup.
const renewal = new MessageBudget(setup.remainingMs(5000), setup.signal);
try { await renew(renewal); for (const route of routes.values()) route.ready = true; }
finally { renewal.dispose(); }
} catch (error) { await close(); throw error; }
finally { setup.dispose(); }
if (stopping) { await close(); throw remoteError("owner_retired", "Messaging owner stopped during setup."); }
let refreshing = false;
timer = setInterval(() => {
if (refreshing || stopping) return;
refreshing = true;
const task = (async () => {
const budget = new MessageBudget(5000, controller.signal);
try {
check();
for (const route of [...routes.values()]) {
if (!store.read()?.peers.some(peer => peer.transaction === route.peer.transaction)) {
routes.delete(route.peer.machine.id); await route.tunnels?.close();
} else if (!route.tunnels && route.expiry <= now()) routes.delete(route.peer.machine.id);
}
await renew(budget);
} catch { abort(); }
finally { budget.dispose(); refreshing = false; }
})();
operations.add(task);
void task.finally(() => operations.delete(task));
}, 10000);
return { port: bridge.port, capacity, close, finished };
}