UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

131 lines (126 loc) • 7.91 kB
import { join } from "node:path"; import { buildExecArgv, buildTunnelArgv, remoteOcxArgv } from "../link/ssh-argv"; import { MessageBudget } from "./budget"; import { exactRecord, RemoteCapacity, remoteError, validPort, type RemotePeer } from "./remote-contract"; import { withRemoteLock, writeRemoteFile } from "./remote-files"; import { reserveRemotePort, remotePortIsLoopback, type RemotePortAllocator, type RemotePortReservation } from "./remote-ports"; import { runRemoteHelper, spawnRemoteHelper, type RemoteHelper } from "./remote-process"; import type { RemoteMessageStore } from "./remote-store"; export interface RemoteTunnelPair { localPort: number; returnPort: number; readonly alive: boolean; readonly exited: Promise<unknown>; close(): Promise<void>; } export interface RemoteTunnelDeps { run?: typeof runRemoteHelper; spawn?: typeof spawnRemoteHelper; allocatePort?: RemotePortAllocator; inspect?: typeof remotePortIsLoopback; } /** Own one -L/-R pair with shared SSH policy and one setup deadline; never adopt/kill existing tunnels. */ export async function startRemoteTunnels(store: RemoteMessageStore, peer: RemotePeer, budget: MessageBudget, capacity: RemoteCapacity, ownerSignal: AbortSignal, deps: RemoteTunnelDeps = {}): Promise<RemoteTunnelPair> { if (!peer.ssh || !peer.hostKey) throw remoteError("return_route_only", "This peer has no initiating SSH enrollment; wait for its return route."); const knownHosts = join(store.directory, `${peer.machine.id}.known_hosts`); withRemoteLock(store.directory, () => writeRemoteFile(knownHosts, peer.hostKey!)); return startRemoteForwardPair({ ssh: peer.ssh, knownHosts, peerPort: peer.port, ownerPort: store.requireEnabled().port }, budget, capacity, ownerSignal, deps); } interface RemoteForwardOptions { ssh: string; knownHosts: string; peerPort: number; ownerPort: number } const FORWARD_SETUP_ATTEMPTS = 3; /** Transport-only setup: no messages or authenticated-ready state are published here. */ export async function startRemoteForwardPair(options: RemoteForwardOptions, budget: MessageBudget, capacity: RemoteCapacity, ownerSignal: AbortSignal, deps: RemoteTunnelDeps = {}): Promise<RemoteTunnelPair> { const localPorts = new Set<number>(), returnPorts = new Set<number>(); for (let attempt = 0; attempt < FORWARD_SETUP_ATTEMPTS; attempt++) { budget.throwIfEnded(); if (ownerSignal.aborted) throw remoteError("cancelled", "Messaging tunnel setup was cancelled."); const result = exactRecord(JSON.parse(await (deps.run ?? runRemoteHelper)(buildExecArgv({ alias: options.ssh, route: null, knownHostsFile: options.knownHosts, argv: remoteOcxArgv(["message", "_port"]) }), budget, capacity)), ["port"]); budget.throwIfEnded(); if (!validPort(result.port)) throw remoteError("remote_incompatible", "Remote node did not offer an unprivileged return port."); if (returnPorts.has(result.port)) continue; returnPorts.add(result.port); const reservation = reserveRemotePort(deps.allocatePort, localPorts); localPorts.add(reservation.port); try { return await startAttempt(options, reservation, result.port, budget, capacity, ownerSignal, deps); } catch (error) { if ((error as { code?: string })?.code !== "forward_port_lost") throw error; } } throw remoteError("forward_port_lost", "Messaging SSH forward ports were lost during bounded setup."); } async function startAttempt(options: RemoteForwardOptions, reservation: RemotePortReservation, returnPort: number, budget: MessageBudget, capacity: RemoteCapacity, ownerSignal: AbortSignal, deps: RemoteTunnelDeps): Promise<RemoteTunnelPair> { const localPort = reservation.port, helpers: RemoteHelper[] = [], exits: Promise<void>[] = []; let lostPort = false; let awaitingReceipts = false; const setupFailure = (fallback: unknown) => { const failures = helpers.flatMap(helper => helper.setupFailure ? [helper.setupFailure] : []); return failures.find(error => (error as { code?: string }).code !== "forward_port_lost") ?? failures[0] ?? fallback; }; let cancelReadiness!: (reason: unknown) => void; const cancelled = new Promise<never>((_, reject) => { cancelReadiness = reject; }); void cancelled.catch(() => {}); let alive = true, closing: Promise<void> | undefined; const close = (): Promise<void> => closing ??= (async () => { alive = false; ownerSignal.removeEventListener("abort", abort); const results = await Promise.allSettled(helpers.map(helper => helper.close())); await Promise.allSettled(helpers.map(helper => helper.output)); reservation.release(); const failure = results.find(result => result.status === "rejected"); if (failure?.status === "rejected") throw failure.reason; })(); const abort = () => { cancelReadiness(remoteError("cancelled", "Messaging tunnel setup was cancelled.")); void close().catch(() => {}); }; ownerSignal.addEventListener("abort", abort, { once: true }); const cancelSetup = () => { cancelReadiness(budget.signal.reason); void close().catch(() => {}); }; budget.signal.addEventListener("abort", cancelSetup, { once: true }); try { budget.throwIfEnded(); if (ownerSignal.aborted) throw remoteError("cancelled", "Messaging tunnel setup was cancelled."); for (const [direction, bindPort, targetPort] of [["L", localPort, options.peerPort], ["R", returnPort, options.ownerPort]] as const) { budget.throwIfEnded(); const argv = buildTunnelArgv({ alias: options.ssh, knownHostsFile: options.knownHosts, direction, bindPort, targetPort, route: null }); if (direction === "L") reservation.handoff(); const helper = (deps.spawn ?? spawnRemoteHelper)(argv, capacity, ownerSignal); helpers.push(helper); const exit = helper.exited.then(async code => { await close(); await helper.output.catch(() => {}); if (code !== 0 && helper.forwardFailed) lostPort = true; }); exits.push(exit); void exit.catch(() => {}); } // A competing loopback listener can exist before SSH even starts. Its socket is not a bind receipt. awaitingReceipts = true; await Promise.race([Promise.all(helpers.map(helper => helper.forwardReady)), cancelled]); awaitingReceipts = false; const checkAlive = async () => { if (alive) return; await Promise.all(exits); throw setupFailure(remoteError(lostPort ? "forward_port_lost" : "ssh_failed", "Messaging SSH forward setup failed.")); }; let ready = false; while (!ready) { budget.throwIfEnded(); await checkAlive(); ready = await (deps.inspect ?? remotePortIsLoopback)(localPort, budget, capacity); await checkAlive(); if (!ready) await new Promise<void>((resolve, reject) => { const timer = setTimeout(() => { budget.signal.removeEventListener("abort", cancel); resolve(); }, budget.remainingMs(100)); const cancel = () => { clearTimeout(timer); budget.signal.removeEventListener("abort", cancel); reject(budget.signal.reason); }; budget.signal.addEventListener("abort", cancel, { once: true }); if (budget.signal.aborted) cancel(); }); } budget.throwIfEnded(); if (ownerSignal.aborted) throw remoteError("cancelled", "Messaging tunnel setup was cancelled."); const exited = Promise.race(helpers.map(helper => helper.exited)); void exited.then(() => close()).catch(() => {}); return { localPort, returnPort, get alive() { return alive; }, exited, close }; } catch (error) { await close(); budget.throwIfEnded(); if (ownerSignal.aborted) throw remoteError("cancelled", "Messaging tunnel setup was cancelled."); // Sibling shutdown can reject first; classify only after every helper's diagnostics and cleanup settle. throw awaitingReceipts ? setupFailure(error) : error; } finally { budget.signal.removeEventListener("abort", cancelSetup); } }