@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
156 lines (142 loc) • 7.5 kB
text/typescript
/**
* Ownership predicates for `~/.codex/config.toml`: does opencodex own the routing
* currently written there?
*
* These live in their own leaf module rather than in `inject.ts` because
* `journal.ts` needs them and `inject.ts` already imports `journal.ts`. Keeping
* them here breaks that cycle. `inject.ts` imports them back and re-exports the
* two public predicates, so external callers see no change.
*/
import { parseTomlString } from "./paths";
import { rootAssignmentKey, rootSourceLines, sourceText } from "./toml-source-lines";
export const OCX_SECTION_MARKER = "# Auto-injected by opencodex";
/**
* The marker line actually written above ROUTING keys, carrying the command that undoes them.
*
* #5261: a Windows user whose proxy had stopped was locked out of Codex sign-in, because the
* root `openai_base_url` we write keeps pointing Codex's built-in openai provider at a port
* nothing is listening on. The only surface such a user can still read is `config.toml` itself,
* and it said nothing but "Auto-injected by opencodex" — so the recovery they found was to
* hand-delete lines and the catalog file, which is strictly worse than `ocx restore`.
*
* Root routing predicates and lossless provider table capture/removal accept either exact marker
* line directly above structural routing syntax; they do not claim user comments or opaque value
* lines that merely contain the marker. Keeping the hint on the same
* line lets those transforms remove it together with the routing they own.
*
* Scope is routing only. Prompt layers keep the bare marker: `ocx restore` is not their undo.
*/
export const OCX_ROUTING_MARKER_LINE = `${OCX_SECTION_MARKER} (undo: ocx restore)`;
export function isOcxRoutingMarkerLine(line: string): boolean {
const text = line.trim();
return text === OCX_SECTION_MARKER || text === OCX_ROUTING_MARKER_LINE;
}
export function isRootOpenaiBaseUrlLine(line: string): boolean {
return rootAssignmentKey(line) === "openai_base_url";
}
/**
* codex-rs root key that redirects the realtime sideband WebSocket (WebRTC voice
* join + standalone realtime WS) without touching ordinary provider HTTP. Since
* openai/codex 438c9e98d (#35830) the sideband ignores the provider base URL and
* dials `https://api.openai.com/v1` unless this key is set, so a Pool-routed
* call-create and a directly-joined sideband end up on different accounts (404).
* Injected next to `openai_base_url` with the same value.
*/
export const REALTIME_WS_BASE_URL_KEY = "experimental_realtime_ws_base_url";
export function isRootRealtimeWsBaseUrlLine(line: string): boolean {
return rootAssignmentKey(line) === REALTIME_WS_BASE_URL_KEY;
}
export function tomlStringPattern(key: string): RegExp {
const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const keyToken = `(?:${escaped}|"${escaped}"|'${escaped}')`;
// The quoted value is captured WITH its quotes so callers can decode it as TOML.
// A basic string escapes backslashes, so a Windows path is stored doubled; reading
// the raw bytes back returned a path that matched nothing on disk and made the
// journal's recorded catalog path un-restorable (#1798).
return new RegExp(`^\\s*${keyToken}\\s*=\\s*("(?:\\\\.|[^"\\\\])*"|'[^']*')\\s*(?:#.*)?$`);
}
export function rootTomlString(content: string, key: string): string | null {
const { lines, rootEnd } = rootSourceLines(content);
for (const line of lines.slice(0, rootEnd)) {
if (!line.structural || rootAssignmentKey(line.text) !== key) continue;
try {
const value = (Bun.TOML.parse(line.text) as Record<string, unknown>)[key];
if (typeof value === "string") return value.trim();
} catch { /* Incomplete multiline assignments are not single-line ownership evidence. */ }
}
return null;
}
export function providerTableStart(lines: string[], provider: string): number {
const escapedProvider = provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const providerToken = `(?:${escapedProvider}|"${escapedProvider}"|'${escapedProvider}')`;
const header = new RegExp(`^\\s*\\[\\s*(?:model_providers|"model_providers"|'model_providers')\\s*\\.\\s*${providerToken}\\s*\\]\\s*(?:#.*)?$`);
return lines.findIndex(line => header.test(line));
}
export function providerTableString(content: string, provider: string, key: string): string | null {
const lines = content.split("\n");
const start = providerTableStart(lines, provider);
if (start === -1) return null;
const pattern = tomlStringPattern(key);
for (let index = start + 1; index < lines.length && !/^\s*\[/.test(lines[index]); index += 1) {
const match = pattern.exec(lines[index]);
if (match?.[1]) return parseTomlString(match[1]).trim();
}
return null;
}
/**
* Drop a root `openai_base_url` whose VALUE is the one a recorded injection wrote.
*
* #1798: the marker-adjacency rule below is formatting evidence, and the Codex app
* reserializes the file -- values kept, comments dropped. This rule is value evidence
* instead, so it still recognizes our URL after that rewrite. It is deliberately an
* EXACT value match against what we recorded writing: a user gateway we never wrote
* cannot match, so restore can never delete a URL that was not ours.
*/
export function stripJournaledOpenaiBaseUrl(
content: string,
injectedUrl: string | null,
injectedRealtimeWsUrl: string | null = null,
): string {
if (!injectedUrl && !injectedRealtimeWsUrl) return content;
const { bom, lines, rootEnd } = rootSourceLines(content);
const drop = new Set<number>();
for (let i = 0; i < rootEnd; i++) {
if (!lines[i]!.structural) continue;
const line = lines[i]!.text;
// Each key is matched against ITS OWN recorded value. The realtime override is
// journaled separately so a user-owned override that happens to equal the proxy
// URL is never mistaken for ours.
if (isRootOpenaiBaseUrlLine(line)) {
if (!injectedUrl || rootTomlString(line, "openai_base_url") !== injectedUrl) continue;
} else if (isRootRealtimeWsBaseUrlLine(line)) {
if (!injectedRealtimeWsUrl || rootTomlString(line, REALTIME_WS_BASE_URL_KEY) !== injectedRealtimeWsUrl) continue;
} else {
continue;
}
drop.add(i);
// Take an ownership marker directly above it too, so repeated cycles cannot
// accumulate orphaned comments.
if (i > 0 && lines[i - 1]!.structural && isOcxRoutingMarkerLine(lines[i - 1]!.text)) drop.add(i - 1);
}
if (drop.size === 0) return content;
return bom + sourceText(lines.filter((_, i) => !drop.has(i)));
}
export function hasInjectedOpenaiBaseUrl(content: string): boolean {
const { lines, rootEnd } = rootSourceLines(content);
for (let i = 1; i < rootEnd; i++) {
if (lines[i]!.structural && lines[i - 1]!.structural
&& isRootOpenaiBaseUrlLine(lines[i]!.text) && rootTomlString(lines[i]!.text, "openai_base_url") !== null
&& isOcxRoutingMarkerLine(lines[i - 1]!.text)) return true;
}
return false;
}
/**
* True when the active Codex config is owned by opencodex routing. Covers the
* loopback Design B root override and the legacy/non-loopback provider table.
* A user-owned `openai_base_url` is intentionally not classified as injected.
*/
export function hasInjectedCodexRouting(content: string): boolean {
if (hasInjectedOpenaiBaseUrl(content)) return true;
return rootTomlString(content, "model_provider") === "opencodex"
&& providerTableString(content, "opencodex", "base_url") !== null;
}