UNPKG

@bitkyc08/opencodex

Version:

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

244 lines (241 loc) • 17.4 kB
import { randomUUID } from "node:crypto"; import { join } from "node:path"; import { getConfigDir } from "../../config/paths"; import { issueServerLeaf } from "../../claude/intercept/local-ca"; import { startConnectProxy, type ConnectProxyHandle } from "../../claude/intercept/connect-proxy"; import { didRunOptionalShutdownHooks, registerOptionalShutdownHook } from "../../lib/optional-shutdown-hooks"; import { isTestHomeGuardArmed } from "../../lib/test-home-guard"; import { desktopOutboundFetch, desktopProxyFor } from "../../lib/desktop-proxy-route"; import { inspectDesktopCompatibilityAuthority, loadDesktopCompatibilityAuthority, type StoredDesktopAuthority } from "./certificate-store"; import { inspectWindowsCertificateTrust } from "./windows-certificate-trust"; import { createNativeIdentityReader } from "./native-identity"; import { UsageRelayController, type UsageIdentity } from "./usage-controller"; import { createUsageControlledFetch } from "./usage-controlled-fetch"; import { startDesktopRelay } from "./relay-listener"; import { launchWindowsCodexCompatibilityAsync } from "./windows-package-launch"; import { acquireDesktopCompatibilityRuntime, bindDesktopCompatibilityLaunch } from "./runtime-ownership"; import { createDesktopConnectionStore, type DesktopConnectionStore } from "./connection-store"; import { createNativeRoutingVerifier } from "./routing-preflight"; import { createInstalledBuildProbe, type DesktopBuildAssessment } from "./installed-build"; export { DESKTOP_COMPATIBILITY_ASSESSED_VERSION, isAssessedDesktopInstalled } from "./installed-build"; export interface DesktopRuntimeIo { platform?: string; loadAuthority?: () => Promise<StoredDesktopAuthority>; trust?: (authority: StoredDesktopAuthority) => Promise<"trusted" | "not-trusted" | "unknown">; identity?: ReturnType<typeof createNativeIdentityReader>; buildSupported?: () => boolean | Promise<boolean>; /** Internal fixture probe factory; requires testOnly and all sandbox identity/CA seams. */ testOnlyBuildProbe?: () => ReturnType<typeof createInstalledBuildProbe>; upstreamFetch?: typeof fetch; connectionStore?: DesktopConnectionStore; routingSupported?: () => boolean; /** Synthetic-test execution is admitted only with explicit fixture identity and CA seams. */ testOnly?: boolean; } /** Optional runtime. Import/construction/status do not start listeners or touch credentials. */ export function createDesktopCompatibilityRuntime(io: DesktopRuntimeIo = {}) { const platform = io.platform ?? process.platform; let buildProbe: ReturnType<typeof createInstalledBuildProbe> | undefined; let previousBuildAssessment: DesktopBuildAssessment | null = null; let boundBuild: { probe: ReturnType<typeof createInstalledBuildProbe>; revision: number } | null = null; let invalidateTrial: (() => void) | undefined; let contextEpoch = 0; const buildSupported = io.buildSupported ?? (() => buildProbe?.check() ?? Promise.resolve(false)); let routingSupported = io.routingSupported ?? (() => false); let contextFailure: "build_unverified" | "native_routing_unverified" | null = null; const checkContext = async () => { const epoch = contextEpoch, probe = buildProbe; let binding: ReturnType<NonNullable<typeof probe>["binding"]> | null = null; try { if (!routingSupported()) { contextFailure = "native_routing_unverified"; invalidateTrial?.(); return null; } const supported = await buildSupported(); // An old probe completion must not invalidate a replacement runtime's consent. if (epoch !== contextEpoch || probe !== buildProbe) return null; if (!io.buildSupported && probe) { binding = probe.binding(); const changed = boundBuild?.probe === probe && boundBuild.revision !== binding.revision; boundBuild = { probe, revision: binding.revision }; if (!supported || !binding.identity || changed) { contextFailure = "build_unverified"; invalidateTrial?.(); return null; } } contextFailure = !routingSupported() ? "native_routing_unverified" : !supported ? "build_unverified" : null; } catch { if (epoch !== contextEpoch || probe !== buildProbe) return null; contextFailure = "build_unverified"; } if (contextFailure) invalidateTrial?.(); return contextFailure === null ? { binding } : null; }; const contextValid = async () => (await checkContext()) !== null; let phase: "off" | "starting" | "running" | "stopping" | "cleanup-required" = "off"; type OwnedRuntime = { controller: UsageRelayController; close(): Promise<void>; pacUrl: string; fingerprint: string; deadline: number }; let owned: OwnedRuntime | null = null; let closing: Promise<void> | null = null; let pendingCleanup: (() => Promise<void>) | null = null; let releaseOwner: (() => void) | null = null; let pendingLaunch: { owner: OwnedRuntime; abort: AbortController; revision: number | null; result: ReturnType<typeof launchWindowsCodexCompatibilityAsync> } | null = null; const status = () => ({ phase, supported: platform === "win32", running: owned !== null, contextFailure, ...(buildProbe ? { buildAssessment: buildProbe.lastResult() ?? (previousBuildAssessment ? { ...previousBuildAssessment } : null) } : {}), ...(owned ? { fingerprint: owned.fingerprint, safetyDeadline: owned.deadline, usage: owned.controller.snapshot() } : {}) }); async function stop(): Promise<ReturnType<typeof status>> { if (phase === "starting") throw new Error("desktop_compatibility_busy"); if (closing) { await closing; return status(); } if (!pendingCleanup) return status(); contextEpoch++; invalidateTrial?.(); phase = "stopping"; closing = pendingCleanup().then(() => { owned = null; pendingCleanup = null; invalidateTrial = undefined; boundBuild = null; phase = "off"; releaseOwner?.(); releaseOwner = null; }) .catch(error => { phase = "cleanup-required"; throw error; }).finally(() => { closing = null; }); await closing; return status(); } async function start() { if (phase !== "off") throw new Error("desktop_compatibility_busy"); if (platform !== "win32") throw new Error("desktop_compatibility_unsupported"); contextEpoch++; boundBuild = null; invalidateTrial = undefined; if (io.testOnlyBuildProbe && (!io.testOnly || io.buildSupported)) throw new Error("desktop_compatibility_test_environment"); if ((isTestHomeGuardArmed() || io.testOnlyBuildProbe) && !(io.testOnly && io.identity && io.loadAuthority && io.trust && (io.buildSupported || io.testOnlyBuildProbe) && io.connectionStore && io.routingSupported)) throw new Error("desktop_compatibility_test_environment"); if (didRunOptionalShutdownHooks()) throw new Error("desktop_compatibility_stopping"); try { desktopProxyFor(new URL("https://chatgpt.com")); } catch { throw new Error("desktop_compatibility_egress_proxy_invalid"); } releaseOwner = acquireDesktopCompatibilityRuntime(); phase = "starting"; let relay: Awaited<ReturnType<typeof startDesktopRelay>> | undefined, proxy: ConnectProxyHandle | undefined; let pac: ReturnType<typeof Bun.serve> | undefined, timer: ReturnType<typeof setInterval> | undefined; let detach: (() => void) | undefined, unbindLaunch: (() => void) | undefined, controller: UsageRelayController | undefined; const cleanup = async () => { const launch = pendingLaunch; launch?.abort.abort(); unbindLaunch?.(); if (timer) clearInterval(timer); detach?.(); // Abort transport before awaiting stream refresh so a stuck reader cannot retain sockets. const results = await Promise.allSettled([pac?.stop(true), proxy?.close(), relay?.close(), controller?.observeOnly(), buildProbe?.close(), launch?.result]); if (results.some(result => result.status === "rejected")) throw new Error("desktop_compatibility_cleanup_incomplete"); }; pendingCleanup = cleanup; try { if (!io.buildSupported) { // A fresh probe owns this start; diagnostics retain the last completed observation. previousBuildAssessment = buildProbe?.lastResult() ?? previousBuildAssessment; buildProbe = io.testOnlyBuildProbe ? io.testOnlyBuildProbe() : createInstalledBuildProbe(); } if (!io.routingSupported) routingSupported = createNativeRoutingVerifier((await import("../paths")).getCodexHome()); if (!await contextValid()) throw new Error(`desktop_compatibility_${contextFailure}`); const directory = join(getConfigDir(), "codex-desktop-compatibility"); if (!io.loadAuthority) { const saved = inspectDesktopCompatibilityAuthority(directory); if (saved.status === "missing") throw new Error("desktop_compatibility_certificate_not_prepared"); if (saved.status === "invalid") throw new Error("desktop_compatibility_certificate_invalid"); if (saved.status === "expired") throw new Error("desktop_compatibility_certificate_expired"); } const authority = await (io.loadAuthority?.() ?? loadDesktopCompatibilityAuthority({ directory })); const trust = await (io.trust?.(authority) ?? inspectWindowsCertificateTrust(authority.authority.certPem, authority.fingerprint)); if (trust !== "trusted") throw new Error("desktop_compatibility_trust_required"); const connections = io.connectionStore ?? createDesktopConnectionStore(directory); const previousConnection = connections.read(); const deadline = authority.expiresAt - 300_000; if (deadline <= Date.now()) throw new Error("desktop_compatibility_certificate_expiring"); const identity = io.identity ?? createNativeIdentityReader(join((await import("../paths")).getCodexHome(), "auth.json"), desktopOutboundFetch as typeof fetch); const account: UsageIdentity | null = await identity.verifyFreshIdentity(); if (!account) throw new Error("desktop_compatibility_native_identity_unverified"); if (didRunOptionalShutdownHooks()) throw new Error("desktop_compatibility_stopping"); controller = new UsageRelayController(account, identity.readCurrentIdentity, identity.verifyFreshIdentity, Date.now, deadline, 180000, contextValid); const trialController = controller; invalidateTrial = () => trialController.invalidateContext(); relay = await startDesktopRelay({ leaf: issueServerLeaf(authority.authority, authority.commonName, ["chatgpt.com"]), fetchImpl: createUsageControlledFetch(controller, io.upstreamFetch ?? desktopOutboundFetch as typeof fetch) }); try { proxy = await startConnectProxy(previousConnection?.connectPort ?? 0, { interceptPort: relay.port, interceptHosts: ["chatgpt.com"], allowedTargets: ["chatgpt.com:443"] }); } catch { throw new Error("desktop_compatibility_connection_unavailable"); } const runId = previousConnection?.id ?? randomUUID(), proxyPort = proxy.port; try { pac = Bun.serve({ hostname: "127.0.0.1", port: previousConnection?.pacPort ?? 0, fetch(req) { const url = new URL(req.url); if (req.method !== "GET" || req.headers.has("origin") || url.origin !== `http://127.0.0.1:${pac!.port}` || url.pathname !== `/${runId}/proxy.pac`) return new Response(null, { status: 404 }); return new Response(`function FindProxyForURL(url, host) { return Date.now() < ${deadline} && host.toLowerCase() === "chatgpt.com" && url.indexOf("https:") === 0 ? "PROXY 127.0.0.1:${proxyPort}; DIRECT" : "DIRECT"; }`, { headers: { "content-type": "application/x-ns-proxy-autoconfig", "cache-control": "no-store" } }); } }); } catch { throw new Error("desktop_compatibility_connection_unavailable"); } const connection = await connections.publish({ version: 1, id: runId, connectPort: proxyPort, pacPort: pac.port! }); if (connection.id !== runId || connection.connectPort !== proxyPort || connection.pacPort !== pac.port) throw new Error("desktop_compatibility_connection_changed"); if (didRunOptionalShutdownHooks()) throw new Error("desktop_compatibility_stopping"); const active = controller; let ticking = false, deadlineHandled = false, lastContextCheck = Date.now(); timer = setInterval(() => { if (ticking) return; ticking = true; const expired = Date.now() >= deadline; const work = (async () => { const contextCadence = active.snapshot().mode === "apply" ? 10000 : 60000; if (!expired && Date.now() - lastContextCheck >= contextCadence) { lastContextCheck = Date.now(); if (!await contextValid() && active.snapshot().mode === "apply") { await active.observeOnly(); return; } } await (expired && !deadlineHandled ? (deadlineHandled = true, active.observeOnly()) : active.expireIfNeeded()); })(); void work.catch(() => {}).finally(() => { ticking = false; }); }, 1000); timer.unref(); owned = { controller, close: cleanup, fingerprint: authority.fingerprint, deadline, pacUrl: `http://127.0.0.1:${pac.port}/${runId}/proxy.pac` }; phase = "running"; const launchedBy = owned; unbindLaunch = bindDesktopCompatibilityLaunch(owned.pacUrl, () => { if (owned !== launchedBy || phase !== "running" || Date.now() >= deadline || contextFailure) return null; const binding = buildProbe?.binding(); return binding && binding.revision === boundBuild?.revision ? binding : null; }, () => { if (owned !== launchedBy || phase !== "running") return; // The restart adapter is synchronous. stop() revokes the trial and begins closing // listeners and sockets before yielding; failed cleanup stays visible on status. void stop().catch(() => {}); }); detach = registerOptionalShutdownHook("codex-desktop-compatibility", () => { void stop().catch(() => {}); }); return status(); } catch (error) { try { await cleanup(); pendingCleanup = null; invalidateTrial = undefined; boundBuild = null; phase = "off"; releaseOwner?.(); releaseOwner = null; } catch { phase = "cleanup-required"; throw new Error("desktop_compatibility_cleanup_incomplete"); } throw error; } } async function apply(accountWideConsent: boolean) { const current = owned; if (!current || phase !== "running") throw new Error("desktop_compatibility_not_running"); const generation = current.controller.snapshot().generation, valid = await contextValid(); if (owned !== current || phase !== "running") throw new Error("desktop_compatibility_not_running"); if (!valid) { await current.controller.observeOnly(); throw new Error(`desktop_compatibility_${contextFailure}`); } if (generation !== current.controller.snapshot().generation) return { accepted: false, reason: "superseded", ...current.controller.snapshot() }; const result = await current.controller.activate({ scope: "account-ui-compatibility", accountWideConsent }); if (owned !== current || phase !== "running") { await current.controller.observeOnly(); return { ...result, accepted: false, reason: "runtime-stopped" }; } return result; } return { status, start, stop, apply, async observe() { if (owned) await owned.controller.observeOnly(); return status(); }, async launch() { if (!owned || phase !== "running") throw new Error("desktop_compatibility_not_running"); const current = owned; const verified = await checkContext(); if (!verified) throw new Error(`desktop_compatibility_${contextFailure}`); if (owned !== current || phase !== "running") throw new Error("desktop_compatibility_not_running"); const revision = verified.binding?.revision ?? null; if (revision !== null && buildProbe?.binding().revision !== revision) { throw new Error("desktop_compatibility_build_unverified"); } if (!pendingLaunch || pendingLaunch.owner !== current) { const abort = new AbortController(); pendingLaunch = { owner: current, abort, revision, result: launchWindowsCodexCompatibilityAsync(current.pacUrl, verified.binding?.build ?? null, { signal: abort.signal }) }; } const launch = pendingLaunch; let result: Awaited<typeof launch.result>; try { result = await launch.result; } finally { if (pendingLaunch === launch) pendingLaunch = null; } // An old child cannot report success or stop a runtime that replaced its owner. if (owned !== current || phase !== "running") throw new Error("desktop_compatibility_not_running"); // Success binds to the revision the child launched, which every joined caller must share. const stale = launch.revision !== revision || (revision !== null && buildProbe?.binding().revision !== revision); // A failed or indeterminate activation may have left a process on the managed connection, // so its still-current runtime is fenced even when the build revision moved meanwhile. if (result.status === "refused" && result.reason === "activation_failed") await stop(); if (stale) throw new Error("desktop_compatibility_build_unverified"); return result; }, /** Internal native launch context; management status never returns the control endpoint. */ getPacUrl: () => owned?.pacUrl ?? null, }; } export type DesktopCompatibilityRuntime = ReturnType<typeof createDesktopCompatibilityRuntime>;