UNPKG

@bitkyc08/opencodex

Version:

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

73 lines (71 loc) • 4.56 kB
import { connect as tcpConnect, type Socket } from "node:net"; import { connect as tlsConnect, type TLSSocket } from "node:tls"; import { desktopProxyFor } from "./desktop-proxy-route"; import { dialTunnel, type OpaqueProxyRoute } from "./opaque-proxy-tunnel"; // The shared opaque dialer owns proxy framing; this caller owns fixed-target // TLS and bounds the entire connection, including the target TLS handshake. export interface DesktopTunnelOptions { proxy?: string | false; signal?: AbortSignal; timeoutMs?: number; /** Isolated test peers; production always uses verified TLS to chatgpt.com:443. */ target?: { host: string; port: number }; ca?: string; proxyCa?: string; } const fail = () => new Error("desktop_upstream_connection_failed"); function waitConnected(socket: Socket, event: "connect" | "secureConnect", signal: AbortSignal): Promise<void> { return new Promise((resolve, reject) => { const dispose = () => { socket.off(event, done); socket.off("error", failure); socket.off("close", failure); signal.removeEventListener("abort", failure); }; const done = () => { dispose(); resolve(); }; const failure = () => { dispose(); reject(fail()); }; socket.once(event, done); socket.once("error", failure); socket.once("close", failure); signal.addEventListener("abort", failure, { once: true }); if (signal.aborted) failure(); }); } /** Fixed-destination TLS dial for native desktop upgraded sockets. No logs or direct fallback. */ export async function dialDesktopUpstream(options: DesktopTunnelOptions = {}): Promise<TLSSocket> { const timeout = options.timeoutMs ?? 10000; if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 30000) throw fail(); const cancel = new AbortController(), timer = setTimeout(() => cancel.abort(), timeout); const signal = options.signal ? AbortSignal.any([options.signal, cancel.signal]) : cancel.signal; const sockets = new Set<Socket>(); const own = <T extends Socket>(socket: T): T => { sockets.add(socket); socket.on("error", () => {}); return socket; }; const destroy = () => { for (const socket of sockets) socket.destroy(); }; signal.addEventListener("abort", destroy, { once: true }); try { if (signal.aborted) throw fail(); const proxy = options.proxy === undefined ? desktopProxyFor(new URL("https://chatgpt.com")) : options.proxy; const target = options.target ?? { host: "chatgpt.com", port: 443 }; let raw: Socket; if (proxy === false) { raw = own(tcpConnect(target)); await waitConnected(raw, "connect", signal); } else { const url = new URL(proxy), protocol = url.protocol; if (!["http:", "https:", "socks5:", "socks5h:"].includes(protocol) || !url.hostname || url.search || url.hash || url.pathname !== "" && url.pathname !== "/") throw fail(); const host = url.hostname.replace(/^\[|\]$/g, ""), port = Number(url.port) || (protocol === "https:" ? 443 : protocol.startsWith("socks") ? 1080 : 80); const credentials = url.username || url.password ? { username: decodeURIComponent(url.username), password: decodeURIComponent(url.password) } : {}; const endpoint = { host, port, ...credentials }; const route: OpaqueProxyRoute = protocol === "https:" ? { ...endpoint, kind: "https", proxyCa: options.proxyCa } : { ...endpoint, kind: protocol.slice(0, -1) as "http" | "socks5" | "socks5h" }; const authority = `${target.host.includes(":") ? `[${target.host}]` : target.host}:${target.port}`; // The route resolver remains authoritative; a failed proxy never becomes DIRECT. raw = own(await dialTunnel(authority, route, { signal, timeoutMs: timeout, maxHeaderBytes: 65536 })); } if (signal.aborted || raw.destroyed) throw fail(); // This consumer historically closes its writable side after peer EOF. The // shared opaque transport preserves half-closes for callers that need them. raw.allowHalfOpen = false; const secured = own(tlsConnect({ socket: raw, servername: "chatgpt.com", ca: options.ca, rejectUnauthorized: true, ALPNProtocols: ["http/1.1"] })); // The CONNECT reader paused its stream before handing buffered bytes back. Bun's // TLS-over-TLS path needs the outer TLS stream explicitly resumed for the new handshake. raw.resume(); await waitConnected(secured, "secureConnect", signal); if (signal.aborted) throw fail(); return secured; } catch { destroy(); throw fail(); } finally { clearTimeout(timer); signal.removeEventListener("abort", destroy); } }