UNPKG

@bitkyc08/opencodex

Version:

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

109 lines (105 loc) • 5.93 kB
import { createHmac, randomBytes, timingSafeEqual } from "node:crypto"; import { isRecord, isThreadId, LocalMessagingError } from "./types"; export const REMOTE_PROTOCOL = "ocx-message-remote/1"; export const REMOTE_LIMITS = Object.freeze({ peers: 4, connections: 16, requests: 32, helpers: 10, unauthenticated: 4, // Authenticated peer sockets together may never use the slots kept for this node's own // control, outgoing probes and lease renewal. ownerReservedConnections: 4, persistentHelpers: 8, transientHelpers: 2, outputBytes: 2 * 1024 * 1024, frameBytes: 1024 * 1024, storeBytes: 128 * 1024, authMs: 5000, leaseMs: 25000, shutdownMs: 3000 }); export interface MessageMachine { id: string; name: string } export interface RemotePeer { alias: string; machine: MessageMachine; transaction: string; incoming: string; outgoing: string; port: number; ssh: string | null; hostKey: string | null; fingerprint: string | null; allowInbound?: boolean; } export interface RemoteState { protocol: typeof REMOTE_PROTOCOL; machine: MessageMachine; enabled: boolean; port: number; controlKey: string; generation: string; peers: RemotePeer[]; } /** Fail closed with authored diagnostics rather than untrusted transport/configuration output. */ export function remoteError(code: string, message: string): LocalMessagingError { return new LocalMessagingError(code, message); } /** Accept an exact bounded object schema, including rejection of unknown fields. */ export function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> { if (!isRecord(value) || Object.keys(value).length !== keys.length || keys.some(key => !Object.hasOwn(value, key))) { throw remoteError("invalid_remote_contract", "Messaging peer returned an invalid protocol object."); } return value; } /** Validate the stable machine identity; names are display metadata, never route authority. */ export function validMachine(value: unknown): value is MessageMachine { return isRecord(value) && Object.keys(value).length === 2 && isThreadId(value.id) && typeof value.name === "string" && value.name.length > 0 && value.name.length <= 128 && !/[\x00-\x1f\x7f-\x9f]/.test(value.name); } /** Permit exact CLI aliases, not names containing shell syntax or fuzzy selectors. */ export function validAlias(value: unknown): value is string { return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(value); } /** Messaging listeners and both forward directions use unprivileged ports only. */ export function validPort(value: unknown): value is number { return Number.isInteger(value) && Number(value) >= 1024 && Number(value) <= 65535; } /** Generate a receiver-issued 256-bit capability; never print it in ordinary CLI output. */ export function capability(): string { return randomBytes(32).toString("hex"); } /** Validate protocol capability/nonces before any keyed proof calculation. */ export function validCapability(value: unknown): value is string { return typeof value === "string" && /^[0-9a-f]{64}$/.test(value); } /** Direction-separated proofs bind both identities, enrollment and fresh nonces on one socket. */ export function peerProof(key: string, direction: "server" | "client", from: string, to: string, transaction: string, clientNonce: string, serverNonce: string): string { return createHmac("sha256", key).update(JSON.stringify([ REMOTE_PROTOCOL, direction, from, to, transaction, clientNonce, serverNonce, ])).digest("hex"); } /** Fixed-size comparison refuses malformed proofs rather than comparing secret strings. */ export function matchesProof(actual: unknown, expected: string): boolean { return validCapability(actual) && timingSafeEqual(Buffer.from(actual, "hex"), Buffer.from(expected, "hex")); } /** One foreground owner's reservations are shared across peers and both tunnel directions. */ export class RemoteCapacity { private used = { connections: 0, requests: 0, helpers: 0, outputBytes: 0 }; private helperSlots = { persistent: 0, transient: 0 }; private peerTotal = 0; /** Enrolled peers share the connections outside the owner's reserved control/probe/renewal slots. */ reservePeerConnection(): () => void { if (this.peerTotal + 1 > REMOTE_LIMITS.connections - REMOTE_LIMITS.ownerReservedConnections) { throw remoteError("remote_capacity", "The enrolled peers' connection share was reached."); } const free = this.reserve("connections"); this.peerTotal++; let released = false; return () => { if (released) return; released = true; this.peerTotal--; free(); }; } /** Keep transient inspectors/control commands available alongside all eight tunnel children. */ reserveHelper(purpose: "persistent" | "transient"): () => void { const limit = purpose === "persistent" ? REMOTE_LIMITS.persistentHelpers : REMOTE_LIMITS.transientHelpers; if (this.helperSlots[purpose] >= limit) { throw remoteError("remote_capacity", "The messaging owner's aggregate helper purpose limit was reached."); } const free = this.reserve("helpers"); this.helperSlots[purpose]++; let released = false; return () => { if (!released) { released = true; this.helperSlots[purpose]--; free(); } }; } /** Reserve before allocating/spawning; overload creates no hidden waiting queue. */ reserve(kind: keyof RemoteCapacity["used"], amount = 1): () => void { if (!Number.isSafeInteger(amount) || amount < 1 || this.used[kind] + amount > REMOTE_LIMITS[kind]) { throw remoteError("remote_capacity", "The messaging owner's aggregate resource limit was reached."); } this.used[kind] += amount; let released = false; return () => { if (!released) { released = true; this.used[kind] -= amount; } }; } /** Safe counters for tests/status: no identities, capabilities or message bodies. */ snapshot() { return { ...this.used }; } }