@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
279 lines (247 loc) • 13 kB
text/typescript
import { createHash } from "node:crypto";
import {
closeSync, existsSync, fchmodSync, fsyncSync, lstatSync, mkdirSync, openSync, realpathSync,
rmSync, rmdirSync, statSync, unlinkSync, writeFileSync,
} from "node:fs";
import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
import {
atomicWriteFileNoFollowStreamed, isMissingPathError, nextAtomicTempSequence, syncParentDirectory,
} from "../../config/atomic-write";
import { withConfigMutationLockSync } from "../../config/mutation-lock";
import { readBoundedRegularFileSync } from "../../lib/bounded-file-read";
import { parseJsonc } from "../../lib/jsonc";
import { assertNotRealCodexHomeUnderTest, assertNotRealHomeUnderTest } from "../../lib/test-home-guard";
import { renameAtomicFile } from "../../lib/windows-atomic-replace";
import type { GatewayClientContext, GatewayClientResult, GatewayOverride } from "./types";
export const GATEWAY_PLACEHOLDER_KEY = "opencodex-local";
const MAX_CLIENT_BYTES = 4 * 1024 * 1024;
// Restore records include base64 copies of up to three profiles or both settings and parsed prior values.
const MAX_STASH_BYTES = 32 * 1024 * 1024;
export const sha256 = (bytes: Uint8Array): string => createHash("sha256").update(bytes).digest("hex");
export interface ClientFile {
target: string;
bytes: Buffer;
hash: string;
}
/** Resolve the existing prefix even when a new client file or directory is needed. */
function resolveClientPath(path: string): string {
try { return realpathSync(path); }
catch (error) {
const parent = dirname(path);
if (!isMissingPathError(error) || parent === path) throw error;
if (lstatSync(path, { throwIfNoEntry: false })?.isSymbolicLink()) {
throw new Error(`Refusing an unresolvable gateway client symlink: ${path}`);
}
return join(resolveClientPath(parent), basename(path));
}
}
function underCanonicalHome(ctx: GatewayClientContext, path: string): string {
const subpath = relative(ctx.home, path);
if (subpath === ".." || subpath.startsWith(`..${sep}`) || isAbsolute(subpath)) {
throw new Error(`Gateway client path is outside the home directory: ${path}`);
}
return join(realpathSync(ctx.home), subpath);
}
/** Compare the resolved file against the fixed names under the canonical home. */
function clientDestination(ctx: GatewayClientContext, path: string, allowedPaths: readonly string[]): string {
const parent = dirname(path);
if (relative(underCanonicalHome(ctx, parent), resolveClientPath(parent)) !== "") {
throw new Error(`Gateway client file resolves outside the allowed client directory: ${path}`);
}
const target = resolveClientPath(path);
// Following links in the allowlist would let a redirected profile authorize its own destination.
if (!allowedPaths.some(allowed => relative(underCanonicalHome(ctx, allowed), target) === "")) {
throw new Error(`Gateway client file resolves outside the allowed client paths: ${path}`);
}
return target;
}
function readClientDestination(target: string): ClientFile | null {
try {
const bytes = readBoundedRegularFileSync(target, MAX_CLIENT_BYTES);
return { target, bytes, hash: sha256(bytes) };
} catch (error) {
if (isMissingPathError(error)) return null;
throw error;
}
}
export function readClientFile(ctx: GatewayClientContext, path: string, allowedPaths: readonly string[] = [path]): ClientFile | null {
return readClientDestination(clientDestination(ctx, path, allowedPaths));
}
/** Inspect a candidate without failing status or recovery when it cannot be resolved or read. */
export function inspectClientFile(ctx: GatewayClientContext, path: string, allowedPaths: readonly string[] = [path]): ClientFile | null | undefined {
try { return readClientFile(ctx, path, allowedPaths); } catch { return undefined; }
}
export function assertClientSize(bytes: Uint8Array): void {
if (bytes.length > MAX_CLIENT_BYTES) throw new Error("Gateway client file would exceed the 4 MiB limit");
}
export function checkedClientDestination(ctx: GatewayClientContext, path: string, original: ClientFile | null, allowedPaths: readonly string[] = [path], destination = original?.target): string {
const target = clientDestination(ctx, path, allowedPaths);
const current = readClientDestination(target);
if (original?.hash !== current?.hash || (destination !== undefined && destination !== target)) {
throw new Error(`Gateway client file changed before update: ${path}`);
}
return target;
}
/** Replace the resolved client file using the directory's inherited Windows ACL. */
export function writeClientFile(ctx: GatewayClientContext, path: string, original: ClientFile | null, bytes: Uint8Array, allowedPaths: readonly string[] = [path]): void {
assertClientSize(bytes);
const target = checkedClientDestination(ctx, path, original, allowedPaths);
const dir = dirname(target);
assertNotRealHomeUnderTest(dir);
assertNotRealCodexHomeUnderTest(dir);
const mode = original && process.platform !== "win32" ? statSync(target).mode & 0o777 : 0o644;
const temp = join(dir, `.${basename(target)}.ocx-${process.pid}-${nextAtomicTempSequence()}.tmp`);
const fd = openSync(temp, "wx", 0o600);
try {
try {
writeFileSync(fd, bytes);
if (process.platform !== "win32") fchmodSync(fd, mode);
fsyncSync(fd);
} finally { closeSync(fd); }
renameAtomicFile(temp, target, undefined, "config", {
validateBeforeRename: destination => { checkedClientDestination(ctx, path, original, allowedPaths, destination); },
});
} catch (error) {
try { unlinkSync(temp); } catch (cleanup) {
if (!isMissingPathError(cleanup)) throw new AggregateError([error, cleanup], "Could not update the gateway client or remove its temporary file");
}
throw error;
}
syncParentDirectory(target);
}
export function removeCreatedClientFile(ctx: GatewayClientContext, path: string, original: ClientFile, allowedPaths: readonly string[] = [path]): void {
if (lstatSync(path).isSymbolicLink()) throw new Error(`Refusing to remove a symlinked gateway client file: ${path}`);
checkedClientDestination(ctx, path, original, allowedPaths);
assertNotRealHomeUnderTest(dirname(original.target));
assertNotRealCodexHomeUnderTest(dirname(original.target));
unlinkSync(original.target);
syncParentDirectory(original.target);
}
export function clientRefusal(message: string, code: GatewayClientResult["code"] = "io-error", changedFiles: string[] = []): GatewayClientResult {
return { ok: false, code, message, changed: changedFiles.length > 0, changedFiles, notes: [] };
}
export function mutateClient(ctx: GatewayClientContext, work: () => GatewayClientResult): GatewayClientResult {
try { return withConfigMutationLockSync(work, ctx.stateDir); }
catch (error) { return clientRefusal((error as Error).message); }
}
/** Create `dir` (and parents); returns the directories that did not exist before, outermost first. */
export function mkdirTracked(dir: string): string[] {
const created: string[] = [];
for (let cur = dir; !existsSync(cur); cur = dirname(cur)) created.unshift(cur);
mkdirSync(dir, { recursive: true });
return created;
}
/** Remove the directories this connector created, deepest first, only while empty. */
export function rmdirsIfEmpty(ctx: GatewayClientContext, dirs: readonly string[]): void {
for (const dir of [...dirs].reverse()) {
try {
const allowed = underCanonicalHome(ctx, dir);
if (relative(allowed, realpathSync(dir)) === "") rmdirSync(allowed);
} catch { /* gone or not empty */ }
}
}
function stashDirectory(ctx: GatewayClientContext): string {
return join(ctx.stateDir, "gateway-clients");
}
export function stashPath(ctx: GatewayClientContext, id: string): string {
return join(stashDirectory(ctx), `${id}.json`);
}
function assertStashDirectory(path: string): void {
if (!lstatSync(dirname(path)).isDirectory()) throw new Error("Gateway restore record directory is not a regular directory");
}
export function hasStash(ctx: GatewayClientContext, id: string): boolean {
const path = stashPath(ctx, id);
try {
assertStashDirectory(path);
lstatSync(path);
return true;
} catch (error) {
if (isMissingPathError(error)) return false;
throw error;
}
}
export function readStash<T>(ctx: GatewayClientContext, id: string): T | null {
const path = stashPath(ctx, id);
try {
assertStashDirectory(path);
const bytes = readBoundedRegularFileSync(path, MAX_STASH_BYTES);
const value = JSON.parse(bytes.toString("utf8")) as { version?: number } & T;
if (value?.version !== 1) throw new Error("Unknown gateway restore record version");
return value;
} catch (error) {
if (isMissingPathError(error)) return null;
throw error;
}
}
export function inspectStashPresence(ctx: GatewayClientContext, id: string): boolean {
try { return hasStash(ctx, id); } catch { return true; }
}
export function writeStash(ctx: GatewayClientContext, id: string, value: object): void {
const path = stashPath(ctx, id);
const bytes = Buffer.from(`${JSON.stringify(value)}\n`);
if (bytes.length > MAX_STASH_BYTES) throw new Error("Gateway restore record would exceed its size limit");
mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
assertStashDirectory(path);
atomicWriteFileNoFollowStreamed(path, fd => writeFileSync(fd, bytes));
}
export function dropStash(ctx: GatewayClientContext, id: string): void {
const path = stashPath(ctx, id);
assertStashDirectory(path);
rmSync(path, { force: true });
removeEmptyStashDirectory(ctx);
}
export function removeEmptyStashDirectory(ctx: GatewayClientContext): void {
const dir = stashDirectory(ctx);
try {
if (lstatSync(dir).isDirectory()) rmdirSync(dir);
} catch (error) {
const code = (error as NodeJS.ErrnoException).code;
if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") throw error;
}
}
export function isRestoreFile(home: string, path: string, record: {
originalBytes: unknown; createdDirs: unknown; resolvedPath?: unknown;
}): boolean {
const allowedDirs: string[] = [];
for (let dir = dirname(path); relative(home, dir) !== "" && dir !== dirname(dir); dir = dirname(dir)) allowedDirs.push(dir);
return (record.originalBytes === null || typeof record.originalBytes === "string")
&& (record.resolvedPath === undefined || typeof record.resolvedPath === "string")
&& Array.isArray(record.createdDirs) && record.createdDirs.every(dir => allowedDirs.includes(dir));
}
export const normalizeUrl = (url: unknown): string => typeof url === "string" ? url.trim().replace(/\/+$/, "") : "";
/** Where an organisation's admin_settings.json lives (Google's enterprise gateway docs). */
export function adminSettingsPath(ctx: GatewayClientContext): string | undefined {
if (ctx.adminSettingsPath) return ctx.adminSettingsPath;
if (ctx.platform === "win32") {
const base = ctx.env.ProgramData;
return base ? join(base, "Antigravity", "admin_settings.json") : undefined;
}
return ctx.platform === "darwin"
? "/Library/Application Support/Antigravity/admin_settings.json"
: "/etc/antigravity/admin_settings.json";
}
/** What admin_settings.json sets under `gateway`, or null when nothing. */
export function adminGatewayOverride(ctx: GatewayClientContext): GatewayOverride | null {
const path = adminSettingsPath(ctx);
if (!path) return null;
let gateway: unknown;
try {
// A missing file is no override; EACCES or a parse failure is an unknown one, never a thrown status.
const bytes = readBoundedRegularFileSync(resolveClientPath(path), MAX_CLIENT_BYTES);
gateway = (parseJsonc(bytes.toString("utf8")) as { gateway?: unknown } | null)?.gateway;
} catch (error) {
if (isMissingPathError(error)) return null;
return { source: "admin_settings", code: "admin-unreadable", detail: "admin_settings.json exists but could not be read, so its gateway settings are unknown" };
}
if (!gateway || typeof gateway !== "object" || Object.keys(gateway).length === 0) return null;
return { source: "admin_settings", code: "admin-gateway", detail: "organization admin_settings.json sets the gateway and wins over the user settings and AGY_LLM_GATEWAY_* variables" };
}
/** The env override, or null. Only the environment of the process OpenCodex runs in is visible. */
export function envGatewayOverride(ctx: GatewayClientContext, targetUrl?: string): GatewayOverride | null {
const raw = ctx.env.AGY_LLM_GATEWAY_URL?.trim();
if (!raw) return null;
if (targetUrl && normalizeUrl(raw) === normalizeUrl(targetUrl)) return null;
let shown = "an unparseable value";
try { shown = new URL(raw).origin; } catch { /* keep generic */ }
return { source: "env", code: "env-gateway", detail: `AGY_LLM_GATEWAY_URL is set to ${shown} in the environment OpenCodex sees (other shells are not checked) and wins over ~/.antigravity/settings.json` };
}