@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
257 lines (235 loc) • 8.17 kB
text/typescript
import { randomUUID } from "node:crypto";
import {
closeSync,
existsSync,
fsyncSync,
linkSync,
openSync,
readFileSync,
unlinkSync,
writeFileSync,
} from "node:fs";
import { dirname, join } from "node:path";
import { renameAtomicFile } from "../../lib/windows-atomic-replace";
import {
ensureLabDirs,
labAutomationPolicyPath,
} from "../paths";
import { normalizeLabAutomationPolicyV1 } from "./policy";
import {
loadLabAutomationPolicy,
loadLabAutomationRoutes,
normalizeLabAutomationRoutesV1,
} from "./persistence";
import type { LabAutomationPolicyV1, LabAutomationRoutesV1 } from "./types";
import { LabAutomationError } from "./types";
const CONFIG_SCHEMA_VERSION = 1 as const;
const CONFIG_KEYS = new Set(["schemaVersion", "policy", "routes"]);
const CONFIG_LOCK_WAIT_MS = 5_000;
const LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
interface ConfigLockMeta {
pid: number;
token: string;
}
export interface LabAutomationConfigV1 {
schemaVersion: typeof CONFIG_SCHEMA_VERSION;
policy: LabAutomationPolicyV1;
routes: LabAutomationRoutesV1;
}
type ConfigCommitFault = "before_publish" | null;
let configCommitFaultForTests: ConfigCommitFault = null;
function configPath(configDir?: string): string {
return join(dirname(labAutomationPolicyPath(configDir)), "automation-config.json");
}
function configLockPath(configDir?: string): string {
return `${configPath(configDir)}.lock`;
}
function sleepLockRetry(): void {
Atomics.wait(LOCK_SLEEP, 0, 0, 10);
}
function readLockMeta(lockPath: string): ConfigLockMeta | null {
try {
const parsed = JSON.parse(readFileSync(lockPath, "utf8")) as unknown;
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
const row = parsed as Record<string, unknown>;
if (!Number.isSafeInteger(row.pid) || (row.pid as number) <= 0) return null;
if (typeof row.token !== "string" || row.token.length < 16 || row.token.length > 128) return null;
return { pid: row.pid as number, token: row.token };
} catch {
return null;
}
}
function pidDefinitelyDead(pid: number): boolean {
try {
process.kill(pid, 0);
return false;
} catch (error) {
const code = error && typeof error === "object" && "code" in error
? String((error as { code?: unknown }).code)
: undefined;
return code === "ESRCH";
}
}
function cleanupFile(path: string): void {
try {
unlinkSync(path);
} catch {
// Absent or already cleaned.
}
}
function releaseLock(lockPath: string, token: string): void {
try {
if (readLockMeta(lockPath)?.token === token) unlinkSync(lockPath);
} catch {
// Already released or replaced.
}
}
function reclaimDeadLock(lockPath: string): boolean {
const observed = readLockMeta(lockPath);
if (!observed || !pidDefinitelyDead(observed.pid)) return false;
const current = readLockMeta(lockPath);
if (!current || current.pid !== observed.pid || current.token !== observed.token) return false;
try {
unlinkSync(lockPath);
return true;
} catch {
return false;
}
}
function acquireConfigLock(configDir?: string): () => void {
ensureLabDirs(configDir);
const lockPath = configLockPath(configDir);
const deadline = Date.now() + CONFIG_LOCK_WAIT_MS;
while (true) {
const token = randomUUID();
const privatePath = `${lockPath}.${process.pid}.${token}.tmp`;
let publicationAttempted = false;
try {
const fd = openSync(privatePath, "wx", 0o600);
try {
writeFileSync(fd, JSON.stringify({ pid: process.pid, token }), { encoding: "utf8" });
fsyncSync(fd);
} finally {
closeSync(fd);
}
publicationAttempted = true;
linkSync(privatePath, lockPath);
cleanupFile(privatePath);
return () => releaseLock(lockPath, token);
} catch (error) {
cleanupFile(privatePath);
const code = error && typeof error === "object" && "code" in error
? String((error as { code?: unknown }).code)
: undefined;
if (code === "EEXIST" && !publicationAttempted) continue;
if (code !== "EEXIST") {
throw new LabAutomationError("automation config lock failed", "state_lock_failed");
}
if (reclaimDeadLock(lockPath)) continue;
if (Date.now() >= deadline) {
throw new LabAutomationError("automation config is busy", "state_lock_busy");
}
sleepLockRetry();
}
}
}
function withConfigLock<T>(configDir: string | undefined, action: () => T): T {
const release = acquireConfigLock(configDir);
try {
return action();
} finally {
release();
}
}
function normalizeConfig(raw: unknown): LabAutomationConfigV1 {
if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
throw new LabAutomationError("automation config must be an object", "invalid_state");
}
const row = raw as Record<string, unknown>;
for (const key of Object.keys(row)) {
if (!CONFIG_KEYS.has(key)) {
throw new LabAutomationError(`unknown automation config field ${key}`, "invalid_state");
}
}
if (row.schemaVersion !== CONFIG_SCHEMA_VERSION) {
throw new LabAutomationError("unsupported automation config schemaVersion", "invalid_state");
}
return Object.freeze({
schemaVersion: CONFIG_SCHEMA_VERSION,
policy: normalizeLabAutomationPolicyV1(row.policy),
routes: normalizeLabAutomationRoutesV1(row.routes),
});
}
function loadConfigUnlocked(configDir?: string): LabAutomationConfigV1 {
ensureLabDirs(configDir);
const path = configPath(configDir);
if (!existsSync(path)) {
return Object.freeze({
schemaVersion: CONFIG_SCHEMA_VERSION,
policy: loadLabAutomationPolicy(configDir),
routes: loadLabAutomationRoutes(configDir),
});
}
try {
return normalizeConfig(JSON.parse(readFileSync(path, "utf8")) as unknown);
} catch (error) {
if (error instanceof LabAutomationError) throw error;
throw new LabAutomationError("invalid automation config JSON", "invalid_state");
}
}
function writeConfigUnlocked(
policy: LabAutomationPolicyV1,
routes: LabAutomationRoutesV1,
configDir?: string,
): LabAutomationConfigV1 {
ensureLabDirs(configDir);
const normalized = Object.freeze({
schemaVersion: CONFIG_SCHEMA_VERSION,
policy: normalizeLabAutomationPolicyV1(policy),
routes: normalizeLabAutomationRoutesV1(routes),
});
const path = configPath(configDir);
const tmp = join(dirname(path), `.automation-config.${process.pid}.${randomUUID()}.tmp`);
let fd: number | null = null;
try {
fd = openSync(tmp, "wx", 0o600);
writeFileSync(fd, JSON.stringify(normalized), { encoding: "utf8" });
fsyncSync(fd);
closeSync(fd);
fd = null;
if (configCommitFaultForTests === "before_publish") {
throw new LabAutomationError("synthetic automation config commit failure", "invalid_state");
}
renameAtomicFile(tmp, path, undefined, "lab-automation");
return normalized;
} finally {
if (fd !== null) closeSync(fd);
cleanupFile(tmp);
}
}
/** Load one coherent policy/routes generation. */
export function loadLabAutomationConfig(configDir?: string): LabAutomationConfigV1 {
return withConfigLock(configDir, () => loadConfigUnlocked(configDir));
}
/** Atomically publish one coherent policy/routes generation. */
export function saveLabAutomationConfig(
policy: LabAutomationPolicyV1,
routes: LabAutomationRoutesV1,
configDir?: string,
): LabAutomationConfigV1 {
return withConfigLock(configDir, () => writeConfigUnlocked(policy, routes, configDir));
}
/** Update only policy while preserving routes from the same committed generation. */
export function saveLabAutomationPolicyConfig(
policy: LabAutomationPolicyV1,
configDir?: string,
): LabAutomationConfigV1 {
return withConfigLock(configDir, () => {
const current = loadConfigUnlocked(configDir);
return writeConfigUnlocked(policy, current.routes, configDir);
});
}
/** Test-only fault injection before the atomic rename publication point. */
export function setLabAutomationConfigCommitFaultForTests(fault: ConfigCommitFault): void {
configCommitFaultForTests = fault;
}