UNPKG

@bitkyc08/opencodex

Version:

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

310 lines (293 loc) • 16.2 kB
import { configureSocks5Fetch, socks5ProxyFromEnv } from "../lib/proxy-env"; import { redactUrlForLog } from "../lib/redact"; import { join } from "node:path"; import { DEFAULT_SUBAGENT_MODELS, SUBAGENT_MODELS_VERSION } from "./subagent-models"; import { MULTI_AGENT_SURFACE_ADVISORY_VERSION } from "./multi-agent-surface"; import { DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES } from "../lib/app-owned-memory"; import { describeProxyForLog, readWindowsSystemProxy, type WindowsProxyRegistryReader } from "../lib/windows-system-proxy"; import { readMacOSSystemProxy, type MacOSProxyReader } from "./macos-system-proxy"; import { OPENAI_PROVIDER_TIER_VERSION, type OcxConfig } from "../types"; import type { OcxRuntimeRole } from "../types/config"; export function codexAutoStartEnabled(config: Pick<OcxConfig, "codexAutoStart">): boolean { return config.codexAutoStart !== false; } export const CODEX_SHIM_AUTO_RESTORE_ENV = "OPENCODEX_CODEX_SHIM_AUTO_RESTORE"; export function codexShimAutoRestoreEnabled( config: Pick<OcxConfig, "codexShimAutoRestore">, env: NodeJS.ProcessEnv = process.env, ): boolean { return config.codexShimAutoRestore !== false && env[CODEX_SHIM_AUTO_RESTORE_ENV] !== "0"; } export function multiAgentGuidanceEnabled( config: Pick<OcxConfig, "multiAgentGuidanceEnabled">, ): boolean { return config.multiAgentGuidanceEnabled !== false; } export function runtimeRole(config: Pick<OcxConfig, "runtimeRole">): OcxRuntimeRole { return config.runtimeRole ?? "standalone"; } export function getDefaultConfig(): OcxConfig { // Fresh-install default: works out of the box with Codex's ChatGPT OAuth (no API key). // gpt-* requests forward the caller's incoming OAuth headers to the ChatGPT backend. // Adding extra providers (e.g. opencode-go) and switching defaultProvider is a user/runtime choice. return { port: 10100, emptyCompletionRetry: false, dropCodexSafetyBuffering: false, fastRows: true, managementUsageMaxReadBytes: 64 * 1024 * 1024, appOwnedMemoryBudgetMb: DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES / (1024 * 1024), // Fresh/re-initialized configs are already written in the current three-tier // OpenAI shape. Mark them as such so startup does not mistake them for a // legacy config and collide with an immutable backup from an earlier setup. openaiProviderTierVersion: OPENAI_PROVIDER_TIER_VERSION, providers: { openai: { adapter: "openai-responses", baseUrl: "https://chatgpt.com/backend-api/codex", authMode: "forward", codexAccountMode: "pool", }, }, defaultProvider: "openai", subagentModels: [...DEFAULT_SUBAGENT_MODELS], subagentModelsVersion: SUBAGENT_MODELS_VERSION, // v1 is the shipped surface while a v2 native-to-routed task is undeliverable // ciphertext. Written explicitly rather than left absent, because an absent key // means base everywhere else. A fresh install starts already acknowledged: there is // nothing to advise an operator who is on the recommended surface. multiAgentMode: "v1", multiAgentSurfaceAdvisoryVersion: MULTI_AGENT_SURFACE_ADVISORY_VERSION, multiAgentGuidanceEnabled: true, websockets: false, codexAutoStart: true, codexShimAutoRestore: true, }; } export function resolveEnvValue(value: string | undefined): string | undefined { if (!value) return undefined; const match = value.match(/^\$\{(\w+)\}$/); if (match) return process.env[match[1]]; if (value.startsWith("$")) return process.env[value.slice(1)]; return value; } const warnedProxyConfigDiscards = new Set<"proxy" | "noProxy" | "noProxyElements">(); function warnProxyConfigDiscardOnce(kind: "proxy" | "noProxy" | "noProxyElements"): void { if (warnedProxyConfigDiscards.has(kind)) return; warnedProxyConfigDiscards.add(kind); if (kind === "proxy") { console.warn( "⚠️ config.json proxy was discarded because it is not a non-empty resolved string — configured proxy routing is disabled; existing proxy environment variables remain authoritative, otherwise outbound requests use direct egress", ); } else if (kind === "noProxy") { console.warn( "⚠️ config.json noProxy was discarded because it is not a string, string array, or resolved environment reference — existing NO_PROXY and loopback bypasses remain", ); } else { console.warn( "⚠️ config.json noProxy contains invalid elements — invalid elements were ignored; valid entries, existing NO_PROXY, and loopback bypasses remain", ); } } const LOOPBACK_NO_PROXY = ["localhost", "127.0.0.1", "::1", "[::1]"] as const; const LOOPBACK_ADDRESS_NO_PROXY = ["127.0.0.1", "::1", "[::1]"] as const; // With no config.proxy, which loopback bypasses are written depends on who reads them. The // installed SOCKS fetch wrapper (src/lib/proxy-env.ts configuredOutboundFetch) matches these // entries as exact hosts. Bun applies an inherited HTTP(S) proxy itself and matches NO_PROXY // entries as domain suffixes, so a bare "localhost" there would also send any *.localhost name // direct, including from a fetch that never passes the wrapper. The full list is therefore // written only when an inherited SOCKS proxy is the only one. Whenever Bun applies an inherited // HTTP(S) proxy, only the loopback addresses are added: they cannot widen that way (a URL host // ending in a numeric label parses as IPv4) and keep local health and management calls to // 127.0.0.1 off the proxy. A proxy-free process is left untouched: writing NO_PROXY into it is // itself a proxy-env mutation callers observe (the lab sandbox rejects these keys). function inheritedLoopbackBypass(): readonly string[] | undefined { const schemeProxy = ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy"].some(key => process.env[key]?.trim()); const httpAllProxy = ["ALL_PROXY", "all_proxy"].some(key => { const value = process.env[key]?.trim(); if (!value) return false; try { return ["http:", "https:"].includes(new URL(value).protocol); } catch { return false; } }); if (schemeProxy || httpAllProxy) return LOOPBACK_ADDRESS_NO_PROXY; return socks5ProxyFromEnv() !== undefined ? LOOPBACK_NO_PROXY : undefined; } function withNoProxyEntries(existing: string, configured: readonly string[], loopback: readonly string[]): string { const entries = existing.split(",").map(s => s.trim()).filter(Boolean); const seen = new Set(entries.map(entry => entry.toLowerCase())); for (const host of [...configured, ...loopback]) { const key = host.toLowerCase(); if (!seen.has(key)) { entries.push(host); seen.add(key); } } return entries.join(","); } function mergeNoProxyEntries(configured: readonly string[] = [], loopback: readonly string[] = LOOPBACK_NO_PROXY): void { process.env.NO_PROXY = withNoProxyEntries(process.env.NO_PROXY ?? process.env.no_proxy ?? "", configured, loopback); // Bun's native fetch reads a non-empty lowercase no_proxy before NO_PROXY // (src/codex/catalog/remote.ts), so an inherited one would shadow the loopback entries above. // Only the loopback addresses join it: Bun matches entries as domain suffixes, and any name // (a bare "localhost", or a configured noProxy entry the inherited value always shadowed) // would send its subdomains past a proxy the inherited value kept them on. const inherited = process.env.no_proxy; if (inherited !== undefined && inherited.trim() !== "") { process.env.no_proxy = withNoProxyEntries(inherited, [], loopback.filter(host => host !== "localhost")); } } function configuredNoProxyEntries(config: OcxConfig): string[] { const raw = config.noProxy; let entries: string[]; if (Array.isArray(raw)) { if (raw.some(entry => typeof entry !== "string")) warnProxyConfigDiscardOnce("noProxyElements"); entries = raw.filter((entry): entry is string => typeof entry === "string"); } else if (typeof raw === "string") { const resolved = resolveEnvValue(raw); if (raw && resolved === undefined) warnProxyConfigDiscardOnce("noProxy"); entries = (resolved ?? "").split(","); } else { if (raw !== undefined) warnProxyConfigDiscardOnce("noProxy"); entries = []; } return entries.map(entry => entry.trim()).filter(Boolean); } /** * Mirror `config.proxy` into HTTP(S)_PROXY env vars. Bun fetch consumes them natively; transports * such as the ChatGPT upstream WebSocket select the same environment explicitly. User-set HTTP(S)_PROXY * variables win; config fills missing scheme proxies, which take precedence over ALL_PROXY for WS. * localhost/127.0.0.1 are appended to NO_PROXY so the CLI's own health checks and * running-proxy API calls stay direct. Call once per process entry that makes outbound provider * requests (server start, catalog sync). `announce` prints the one-line startup banner naming * the outbound proxy actually in effect; only server start passes it, because on catalog sync * that line is noise. The URL is redacted because a proxy URL can carry credentials. */ export function applyProxyEnv(config: OcxConfig, announce = false): void { applyProxyEnvWith(config); if (!announce) return; const outbound = process.env.ALL_PROXY?.trim() || process.env.HTTPS_PROXY?.trim() || process.env.HTTP_PROXY?.trim(); if (outbound) console.log(` outbound proxy: ${redactUrlForLog(outbound)}`); } /** Test seam for `proxy: "auto"`: the registry reader and platform are injectable. */ export function applyProxyEnvWith( config: OcxConfig, auto: { reader?: WindowsProxyRegistryReader; macOSReader?: MacOSProxyReader; platform?: NodeJS.Platform } = {}, ): void { // `proxy` and `noProxy` are not declared in the top-level schema, which ends in // `.passthrough()`, so whatever is on disk arrives here verbatim. A non-string value // reached string-only methods and threw out of this function, and it runs once per // process entry point — the failure was a startup crash, not a degraded proxy. Ignore // malformed values with a privacy-safe warning instead: they cannot express a routing // intent, and refusing to start is a worse answer than starting without them. const rawProxy = config.proxy; let proxy = typeof rawProxy === "string" ? resolveEnvValue(rawProxy) : undefined; if (!proxy) { if (rawProxy !== undefined) warnProxyConfigDiscardOnce("proxy"); // Inherited-SOCKS path: only loopback bypasses are appended. A configured noProxy is // deliberately NOT merged here — with no config.proxy the operator's bypass list has // no declared proxy to apply against, and merging it would silently widen direct // egress beyond the loopback fix this branch exists for. const loopback = inheritedLoopbackBypass(); if (loopback) mergeNoProxyEntries([], loopback); configureSocks5Fetch(); return; } if (proxy.trim().toLowerCase() === "auto") { if ((auto.platform ?? process.platform) === "darwin") { // An inherited scheme or ALL_PROXY route owns both its proxy and bypass // variables. Combining it with system exceptions would change that route. if (["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"] .some(key => process.env[key]?.trim())) { console.log('[opencodex] proxy "auto": existing proxy environment wins; macOS system proxy not consulted'); configureSocks5Fetch(); return; } const found = readMacOSSystemProxy(auto.macOSReader); if (found.kind !== "proxy") { const reason = found.kind === "unsafe-exceptions" ? "macOS exceptions cannot be safely translated; discovery refused" : found.kind === "disabled" ? "macOS system proxy is disabled" : "macOS proxy settings could not be read"; console.log(`[opencodex] proxy "auto": ${reason}; proxy environment unchanged`); return; } const configured = configuredNoProxyEntries(config); const inheritedLowercase = process.env.no_proxy?.trim(); if (inheritedLowercase && configured.some(host => /^localhost\.?$/i.test(host))) { console.log('[opencodex] proxy "auto": configured noProxy "localhost" cannot be represented exactly for Bun while an inherited no_proxy is set; discovery refused'); return; } const origins = [ found.httpUrl && `HTTP ${describeProxyForLog(found.httpUrl)}`, found.httpsUrl && `HTTPS ${describeProxyForLog(found.httpsUrl)}`, ].filter(Boolean).join(", "); console.log(`[opencodex] proxy "auto": using macOS system proxy ${origins}`); if (found.droppedLinkLocal) { console.log('[opencodex] proxy "auto": link-local IP literals use the proxy; macOS link-local range exceptions are not expressible'); } if (found.httpUrl) process.env.HTTP_PROXY = found.httpUrl; if (found.httpsUrl) process.env.HTTPS_PROXY = found.httpsUrl; // Bun gives non-empty lowercase no_proxy priority over NO_PROXY. Before // discovery there was no proxy, so an ordinary configured name and its // subdomains can stay direct in both paths. Bare localhost is refused // above when lowercase is inherited: Bun cannot match it exactly there. mergeNoProxyEntries([...configured, ...found.exceptions], LOOPBACK_ADDRESS_NO_PROXY); if (process.env.no_proxy?.trim()) { process.env.no_proxy = withNoProxyEntries(process.env.no_proxy, [...configured, ...found.exceptions], LOOPBACK_ADDRESS_NO_PROXY); } configureSocks5Fetch(); return; } // #1525 slice 1: one startup read of the Windows static proxy. Never copy the literal // "auto" into HTTP_PROXY; every non-proxy outcome leaves outbound routing as it was. if (process.env.HTTP_PROXY?.trim() || process.env.http_proxy?.trim() || process.env.HTTPS_PROXY?.trim() || process.env.https_proxy?.trim()) { console.log("[opencodex] proxy \"auto\": existing HTTP_PROXY/HTTPS_PROXY environment wins; system proxy not consulted"); proxy = undefined; } else { const found = readWindowsSystemProxy(auto.reader, auto.platform); if (found.kind === "proxy") { const origins = [ found.httpUrl && `HTTP ${describeProxyForLog(found.httpUrl)}`, found.httpsUrl && `HTTPS ${describeProxyForLog(found.httpsUrl)}`, ].filter(Boolean).join(", "); console.log(`[opencodex] proxy "auto": using Windows system proxy ${origins}`); if (found.httpUrl) process.env.HTTP_PROXY = found.httpUrl; if (found.httpsUrl) process.env.HTTPS_PROXY = found.httpsUrl; proxy = undefined; } else { const reason = found.kind === "unsupported" ? "only Windows and macOS system proxy discovery is supported; using direct egress on this OS" : found.kind === "disabled" ? "Windows system proxy is disabled; using direct egress" : found.kind === "socks-only" ? "Windows system proxy is SOCKS-only, which HTTP_PROXY cannot express; using direct egress" : "Windows proxy settings could not be read; using direct egress"; console.log(`[opencodex] proxy "auto": ${reason}`); proxy = undefined; } } } if (proxy) { if (/^socks/i.test(proxy.trim()) && !/^socks5h?:\/\//i.test(proxy.trim())) { throw new Error("Only SOCKS5 proxy URLs are supported; use socks5://host:port"); } if (/^socks5h?:\/\//i.test(proxy.trim())) { for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"] as const) { delete process.env[key]; } process.env.ALL_PROXY = proxy; } else { if (!process.env.HTTP_PROXY?.trim() && !process.env.http_proxy?.trim()) process.env.HTTP_PROXY = proxy; if (!process.env.HTTPS_PROXY?.trim() && !process.env.https_proxy?.trim()) process.env.HTTPS_PROXY = proxy; } } // Configured entries first, then loopback: loopback is unconditional, so appending it last // keeps it present even when the operator lists a loopback host themselves. mergeNoProxyEntries(configuredNoProxyEntries(config)); configureSocks5Fetch(); }