@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
175 lines (160 loc) • 10.3 kB
text/typescript
import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { z } from "zod";
import { loadConfig } from "../config";
import { shouldSyncCodexOnStart } from "./desired-state";
import { atomicWriteFile } from "../config/atomic-write";
import { withConfigMutationLockSync } from "../config/mutation-lock";
import { getConfigDir } from "../config/paths";
import { assertCodexHomeOwner } from "./codex-home-owner";
import { ConfigWriteLockRefusal, publishConfigWriteTarget, watchConfigWriteTargets, withConfigWriteLockHeld, type LockHandle } from "./config-write-lock";
import { providerTableStart } from "./injected-marker";
import { CODEX_CONFIG_PATH, getCodexHome, tomlString } from "./paths";
import { rootSourceLines, sourceAssignment, sourceText } from "./toml-source-lines";
import { JOURNAL_PATH, removeJournal } from "./journal";
import { externalCodexModelProvider } from "./inject/config-toml";
import { readBoundedCodexConfig } from "./inject/bounded-config-reader";
import { isLoopbackHostname } from "./loopback-target";
import { validateCodexRoutingTarget, type CodexRoutingTarget } from "./inject/routing-target";
const approval = z.object({ original: z.string(), originalUrl: z.string().url(), managedUrls: z.array(z.string().url()).max(2) }).strict();
const recordSchema = z.object({ version: z.literal(1), codexHome: z.string(), providers: z.record(z.string(), approval) }).strict();
type RoutingRecord = z.infer<typeof recordSchema>;
type Approval = z.infer<typeof approval>;
let beforePublishForTests: (() => void) | undefined;
export function setBeforeProviderRoutingPublishForTests(hook: typeof beforePublishForTests): void { beforePublishForTests = hook; }
function recordPath(): string {
const homeId = createHash("sha256").update(getCodexHome()).digest("hex");
return join(getConfigDir(), `codex-provider-routing-${homeId}.json`);
}
function readRecord(): RoutingRecord {
const content = readBoundedCodexConfig(recordPath());
if (content === null) return { version: 1, codexHome: getCodexHome(), providers: {} };
const record = recordSchema.parse(JSON.parse(content));
if (record.codexHome !== getCodexHome()) throw new Error("Codex provider routing consent belongs to another home.");
for (const saved of Object.values(record.providers)) {
const parsed = Bun.TOML.parse(saved.original) as Record<string, unknown>;
if (Object.keys(parsed).length !== 1 || parsed.base_url !== saved.originalUrl
|| saved.managedUrls.some(url => !isLoopbackHostname(new URL(url).hostname))) {
throw new Error("Codex provider routing recovery evidence is invalid; existing files were preserved.");
}
}
return record;
}
/** Only regular Responses provider tables with no separate credential transport are eligible. */
function providerUrl(content: string, id: string, checkCredentials = true) {
if (!/^[A-Za-z0-9_-]{1,128}$/.test(id) || ["__proto__", "constructor", "prototype", "openai", "opencodex", "ollama", "lmstudio"].includes(id)) {
throw new Error("Select a custom provider ID using letters, digits, hyphens or underscores.");
}
const parsed = Bun.TOML.parse(content) as Record<string, unknown>;
const table = (parsed.model_providers as Record<string, Record<string, unknown>> | undefined)?.[id];
if (!table || checkCredentials && ((table.wire_api !== undefined && table.wire_api !== "responses")
|| table.requires_openai_auth !== true
|| ["env_key", "experimental_bearer_token", "auth", "http_headers", "env_http_headers"].some(key => Object.hasOwn(table, key)))) {
throw new Error("Routing consent requires a Responses provider using OpenAI authentication without custom credentials or headers.");
}
const { bom, lines } = rootSourceLines(content);
const start = providerTableStart(lines.map(line => line.structural ? line.text : ""), id);
if (start < 0) throw new Error("Routing consent requires an explicit provider table.");
let end = start + 1;
while (end < lines.length && !(lines[end]!.structural && /^\s*\[/.test(lines[end]!.text))) end++;
for (let i = start + 1; i < end; i++) {
const field = sourceAssignment(lines, i, end);
if (field?.key !== "base_url") continue;
if (typeof field.value !== "string") break;
const url = new URL(field.value);
if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) break;
return { url: field.value, assignment: field.text, replace: (text: string) =>
bom + sourceText(lines.slice(0, field.start)) + text + lines[field.end - 1]!.eol + sourceText(lines.slice(field.end)) };
}
throw new Error("Routing consent requires a credential-free HTTP(S) base_url assignment.");
}
function inWriteSection<T>(run: (held: LockHandle, content: string, record: RoutingRecord) => T): T {
assertCodexHomeOwner(getCodexHome());
const result = withConfigWriteLockHeld(CODEX_CONFIG_PATH, undefined, held => {
watchConfigWriteTargets(held, [CODEX_CONFIG_PATH, recordPath(), JOURNAL_PATH]);
const content = readFileSync(CODEX_CONFIG_PATH, "utf8");
return run(held, content, readRecord());
});
if (!result.ok) throw new ConfigWriteLockRefusal(result);
return result.value;
}
function publish(path: string, content: string, held: LockHandle): void {
publishConfigWriteTarget(CODEX_CONFIG_PATH, held, path, (destination, hooks) => atomicWriteFile(destination, content, undefined, hooks));
}
function save(record: RoutingRecord, held: LockHandle): void {
publish(recordPath(), JSON.stringify(record, null, 2) + "\n", held);
}
/** Read-only ownership evidence: consent alone never claims a URL we did not publish. */
export function isApprovedCodexProviderUrl(id: string, url: string): boolean {
const record = readRecord();
return Object.hasOwn(record.providers, id) && record.providers[id]!.managedUrls.includes(url);
}
export function approvedCodexProviders(): string[] {
return Object.keys(readRecord().providers);
}
/** Capture the exact source before asking; commit refuses a changed provider after the prompt. */
export function previewCodexProviderConsent(id: string): string {
return providerUrl(readFileSync(CODEX_CONFIG_PATH, "utf8"), id).assignment;
}
export function allowCodexProviderRouting(id: string, expected: string): void {
inWriteSection((held, content, record) => {
const field = providerUrl(content, id);
if (field.assignment !== expected) throw new Error("Provider changed after confirmation; review it and retry.");
if (Object.hasOwn(record.providers, id)) throw new Error("Provider is already approved; revoke it before granting new consent.");
record.providers[id] = { original: field.assignment, originalUrl: field.url, managedUrls: [] };
save(record, held);
});
}
function accepts(fieldUrl: string, saved: Approval): boolean {
return fieldUrl === saved.originalUrl || saved.managedUrls.includes(fieldUrl);
}
/** Called by start/sync, never prompts and never broadens the approved provider set. */
export function injectApprovedCodexProvider(id: string, target: CodexRoutingTarget, beforeWrite?: () => void, validateOnly = false): false | { configChanged: boolean } {
return inWriteSection((held, content, record) => {
if (!Object.hasOwn(record.providers, id)) return false;
const apply = () => {
target = validateCodexRoutingTarget(target);
if (target.requiresAdmissionToken || target.desktopAuthless || target.clientCompaction || !isLoopbackHostname(new URL(target.baseUrl).hostname)) {
throw new Error("Approved custom providers support only authenticated Codex on a local loopback proxy without client compaction.");
}
if (externalCodexModelProvider(content) !== id) throw new Error("Active provider changed; routing was not applied.");
const field = providerUrl(content, id), saved = record.providers[id]!;
if (!accepts(field.url, saved)) throw new Error("Approved provider base_url changed outside OpenCodex; revoke and approve it again.");
if (validateOnly) return { configChanged: false };
beforeWrite?.();
if (!shouldSyncCodexOnStart(loadConfig())) return false;
if (readFileSync(CODEX_CONFIG_PATH, "utf8") !== content) throw new Error("Codex config changed before publication; retry sync.");
publishConfigWriteTarget(CODEX_CONFIG_PATH, held, JOURNAL_PATH, (_destination, hooks) => removeJournal(hooks));
if (field.url === target.baseUrl) return { configChanged: false };
// Write recovery evidence first. Both the previous and candidate URL remain restorable
// if publication fails or the process exits between these two atomic renames.
saved.managedUrls = [...new Set([field.url, target.baseUrl])].filter(url => url !== saved.originalUrl);
save(record, held);
beforePublishForTests?.();
publish(CODEX_CONFIG_PATH, field.replace(`base_url = ${tomlString(target.baseUrl)}`), held);
return { configChanged: true };
};
return validateOnly ? apply() : withConfigMutationLockSync(apply);
});
}
/** Restore only our URLs; unrelated edits and provider IDs/history are never rewritten. */
export function restoreApprovedCodexProviders(revokeId?: string): boolean {
const ids = approvedCodexProviders();
if (revokeId !== undefined && !ids.includes(revokeId)) throw new Error("Provider has no routing consent to revoke.");
if (!ids.length) return false;
return inWriteSection((held, content, record) => {
let next = content;
for (const id of revokeId === undefined ? Object.keys(record.providers) : [revokeId]) {
const saved = record.providers[id]!;
const parsed = Bun.TOML.parse(next) as Record<string, unknown>;
const table = (parsed.model_providers as Record<string, Record<string, unknown>> | undefined)?.[id];
if (!table || !saved.managedUrls.includes(table.base_url as string)) continue;
const field = providerUrl(next, id, false);
if (saved.managedUrls.includes(field.url)) next = field.replace(saved.original);
}
if (next !== content) publish(CODEX_CONFIG_PATH, next, held);
if (revokeId !== undefined) { delete record.providers[revokeId]; save(record, held); }
return next !== content;
});
}