UNPKG

@bitkyc08/opencodex

Version:

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

283 lines (278 loc) • 16.6 kB
import { closeSync, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, writeFileSync } from "node:fs"; import { dirname, join } from "node:path"; import { getConfigDir } from "../config/paths"; import { assertTrustedCodexCliAncestry } from "./cli-update-paths"; import { withWindowsCliRecoveryStore, withWindowsCliRecoveryStoreAsync } from "./cli-update-job-store-windows"; import { windowsCodexCliChildGone } from "./windows-cli-recovery"; export interface CodexCliUpdateNativeChildIdentity { jobName: string; creationTime: string } export interface CodexCliUpdateNativeRecoveryProof { path: string; terminal: string } interface RecoveryRecord { version: 1; token: string; parentPid: number; phase: "armed" | "child" | "terminal"; pgid: number | null; windows?: { jobName: string | null; creationTime: string | null }; } /** ESRCH on the entire owned group is proof; EPERM and PID-only death are not. */ export function codexCliUpdateGroupGone(pgid: number): boolean { if (process.platform === "win32" || !Number.isSafeInteger(pgid) || pgid <= 0) return false; try { process.kill(-pgid, 0); return false; } catch (error) { return (error as NodeJS.ErrnoException).code === "ESRCH"; } } function processGone(pid: number): boolean { try { process.kill(pid, 0); return false; } catch (error) { return (error as NodeJS.ErrnoException).code === "ESRCH"; } } function syncDirectory(dir: string): void { const fd = openSync(dir, constants.O_RDONLY); try { fsyncSync(fd); } finally { closeSync(fd); } } function directory(configDir: string, create: boolean): string { if (process.platform === "win32") return withWindowsCliRecoveryStore(configDir, create, io => io.dir); assertTrustedCodexCliAncestry(configDir); const dir = join(configDir, "codex-cli-update-recovery"); if (create) { try { mkdirSync(dir, { mode: 0o700 }); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; } } const stat = lstatSync(dir); if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.geteuid?.() || (stat.mode & 0o077) !== 0 || realpathSync.native(dir) !== dir) throw new Error("unsafe_recovery_store"); // Persist the store's directory entry too, including a concurrent creator. if (create) syncDirectory(configDir); return dir; } function read(dir: string, token: string, suffix = ".json"): RecoveryRecord { if (!/^[0-9a-f-]{36}$/.test(token)) throw new Error("invalid_recovery_owner"); if (process.platform === "win32") { const record = withWindowsCliRecoveryStore(dirname(dir), false, io => JSON.parse(io.read(token + suffix))) as RecoveryRecord; if (!validRecord(record, token)) throw new Error("invalid_recovery_owner"); return record; } const path = join(dir, token + suffix); const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); try { const stat = fstatSync(fd), lexical = lstatSync(path); if (!stat.isFile() || stat.size > 1024 || stat.nlink !== 1 || stat.uid !== process.geteuid?.() || (stat.mode & 0o077) !== 0 || lexical.isSymbolicLink() || lexical.dev !== stat.dev || lexical.ino !== stat.ino) { throw new Error("unsafe_recovery_store"); } const record = JSON.parse(readFileSync(fd, "utf8")) as RecoveryRecord; if (!validRecord(record, token)) throw new Error("invalid_recovery_owner"); return record; } finally { closeSync(fd); } } function validRecord(record: RecoveryRecord, token: string): boolean { return !!record && record.version === 1 && record.token === token && Number.isSafeInteger(record.parentPid) && record.parentPid > 0 && ["armed", "child", "terminal"].includes(record.phase) && (record.pgid === null || (Number.isSafeInteger(record.pgid) && record.pgid > 0)) && (record.windows === undefined || (!!record.windows && (record.windows.jobName === null || (typeof record.windows.jobName === "string" && /^Global\\ocx-cli-[0-9a-f-]{36}$/.test(record.windows.jobName))) && (record.windows.creationTime === null || (typeof record.windows.creationTime === "string" && /^[1-9][0-9]{0,19}$/.test(record.windows.creationTime))))); } function childGone(record: RecoveryRecord, proof?: (token: string) => RecoveryRecord): boolean { if (record.pgid === null) return false; if (process.platform !== "win32") return codexCliUpdateGroupGone(record.pgid); if (!record.windows?.jobName || !record.windows.creationTime || !proof) return false; const terminal = proof(record.token); return terminal.phase === "terminal" && terminal.pgid === null && terminal.parentPid === record.parentPid && terminal.windows?.jobName === record.windows.jobName && windowsCodexCliChildGone(record.pgid, record.windows.creationTime, record.windows.jobName); } /** Called only after this generation's fence was sealed against another spawn. */ export function closedWindowsCodexCliUpdateChildGone(token: string, configDir = getConfigDir(), expectedPid?: number): boolean { try { const dir = directory(configDir, false), record = read(dir, token); return record.phase === "child" && record.pgid === expectedPid && childGone(record, token => read(dir, token, ".proof")); } catch { return false; } } function pending(path: string): number { const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600); try { const stat = fstatSync(fd), lexical = lstatSync(path); if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.geteuid?.() || (stat.mode & 0o077) !== 0 || lexical.isSymbolicLink() || lexical.dev !== stat.dev || lexical.ino !== stat.ino) throw new Error("unsafe_recovery_store"); ftruncateSync(fd, 0); return fd; } catch (error) { closeSync(fd); throw error; } } function write(dir: string, record: RecoveryRecord): void { if (process.platform === "win32") { withWindowsCliRecoveryStore(dirname(dir), true, io => io.write(record.token + ".json", record.token + ".pending", JSON.stringify(record))); return; } const temp = join(dir, record.token + ".pending"); const fd = pending(temp); try { writeFileSync(fd, JSON.stringify(record)); fsyncSync(fd); } finally { closeSync(fd); } renameSync(temp, join(dir, record.token + ".json")); syncDirectory(dir); } /** Written before COMMITTED; a crash in the spawn/publication gap stays armed. */ export function createCodexCliUpdateRecovery(token: string, configDir = getConfigDir()) { let dir: string | undefined; let record: RecoveryRecord = { version: 1, token, parentPid: process.pid, phase: "armed", pgid: null }; return { arm(jobName?: string): CodexCliUpdateNativeRecoveryProof | undefined { dir ??= directory(configDir, true); try { if (read(dir, token, ".terminal").phase !== "terminal") throw new Error("invalid_recovery_owner"); return; // Parent recovery already ended this exact token. } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; } record = { ...record, phase: "armed", pgid: null, ...(process.platform === "win32" ? { windows: { jobName: jobName ?? null, creationTime: null } } : {}) }; write(dir, record); if (process.platform === "win32" && jobName) { withWindowsCliRecoveryStore(configDir, true, io => io.write(token + ".proof", token + ".proof.pending", JSON.stringify(record))); return { path: join(dir, token + ".proof"), terminal: JSON.stringify({ ...record, phase: "terminal" }) }; } }, child(pgid: number, identity?: CodexCliUpdateNativeChildIdentity) { if (dir) { record = { ...record, phase: "child", pgid, ...(identity ? { windows: identity } : {}) }; write(dir, record); } }, terminal() { if (dir) { record = { ...record, phase: "terminal", pgid: null }; write(dir, record); } }, }; } /** Parent recovery owns this exact run token, never another generation's record. */ export function finishClosedCodexCliUpdateRecovery(token: string, configDir = getConfigDir()): void { const dir = directory(configDir, true); if (process.platform === "win32") { withWindowsCliRecoveryStore(configDir, true, io => io.write(token + ".terminal", token + ".terminal.pending", JSON.stringify({ version: 1, token, parentPid: process.pid, phase: "terminal", pgid: null }))); return; } // An independent terminal marker cannot be overwritten by an interrupted // worker finishing its old armed-record rename after the close notification. const marker = join(dir, token + ".terminal"); const temp = join(dir, token + ".terminal.pending"); const fd = pending(temp); try { writeFileSync(fd, JSON.stringify({ version: 1, token, parentPid: process.pid, phase: "terminal", pgid: null })); fsyncSync(fd); } finally { closeSync(fd); } renameSync(temp, marker); syncDirectory(dir); } /** Proven Windows pending children may publish; ambiguous job receipts stay unchanged. */ export function codexCliUpdateRecoveryBlocksAdmission(configDir = getConfigDir()): boolean { // Ordinary callers can use a home alias without any updater history. Probe // lexically first: a dangling store link is existing, unsafe evidence too. try { lstatSync(join(configDir, "codex-cli-update-recovery")); } catch (error) { return (error as NodeJS.ErrnoException).code !== "ENOENT"; } try { // Resolve only the supported home alias, never a linked recovery store. // Mutation eligibility still requires the original canonical ancestry. const canonical = realpathSync.native(configDir); if (process.platform === "win32") return withWindowsCliRecoveryStore(canonical, false, io => inspectRecoveryFiles(io.names(), (token, suffix = ".json") => { const record = JSON.parse(io.read(token + suffix)) as RecoveryRecord; if (!validRecord(record, token)) throw new Error("invalid_recovery_owner"); return record; }, record => io.write(record.token + ".json", record.token + ".pending", JSON.stringify(record), true)), true); const dir = directory(canonical, false); return inspectRecoveryFiles(readdirSync(dir), (token, suffix) => read(dir, token, suffix)); } catch { return true; } // Existing evidence that disappears/is unreadable stays fenced. } /** Every attempt observes fresh records; this never caches an ACL/admission verdict. */ export async function codexCliUpdateRecoveryBlocksAdmissionAsync(configDir = getConfigDir()): Promise<boolean> { if (process.platform !== "win32") return codexCliUpdateRecoveryBlocksAdmission(configDir); try { lstatSync(join(configDir, "codex-cli-update-recovery")); } catch (error) { return (error as NodeJS.ErrnoException).code !== "ENOENT"; } try { const canonical = realpathSync.native(configDir); return await withWindowsCliRecoveryStoreAsync(canonical, false, async io => { const steps = inspectRecoveryFilesSteps(io.names(), true); let step = steps.next(); while (!step.done) { const effect = step.value; if (effect.kind === "publish") { await io.write(effect.record.token + ".json", effect.record.token + ".pending", JSON.stringify(effect.record), true); step = steps.next(undefined); } else { const record = JSON.parse(await io.read(effect.token + (effect.suffix ?? ".json"))) as RecoveryRecord; if (!validRecord(record, effect.token)) throw new Error("invalid_recovery_owner"); step = steps.next(record); } } return step.value; }, true); } catch { return true; } } type RecoveryInspectionStep = { kind: "read"; token: string; suffix?: string } | { kind: "publish"; record: RecoveryRecord }; type RecoveryInspectionSteps = Generator<RecoveryInspectionStep, boolean, RecoveryRecord | undefined>; function* childGoneSteps(record: RecoveryRecord): RecoveryInspectionSteps { if (process.platform !== "win32") return childGone(record); if (record.pgid === null || !record.windows?.jobName || !record.windows.creationTime) return false; const proof = (yield { kind: "read", token: record.token, suffix: ".proof" })!; return childGone(record, () => proof); } function inspectRecoveryFiles(files: string[], readRecord: (token: string, suffix?: string) => RecoveryRecord, publishChild?: (record: RecoveryRecord) => void): boolean { const steps = inspectRecoveryFilesSteps(files, !!publishChild); let step = steps.next(); while (!step.done) { const effect = step.value; if (effect.kind === "publish") { publishChild!(effect.record); step = steps.next(undefined); } else step = steps.next(readRecord(effect.token, effect.suffix)); } return step.value; } function* inspectRecoveryFilesSteps(files: string[], publishChild: boolean): RecoveryInspectionSteps { if (new Set(files.map(file => file.slice(0, 36))).size > 256) return true; const terminal = new Set<string>(); const active = new Map<string, RecoveryRecord>(); for (const file of files.filter(file => file.endsWith(".terminal"))) { const record = (yield { kind: "read", token: file.slice(0, -9), suffix: ".terminal" })!; if (record.phase !== "terminal") return true; terminal.add(record.token); } for (const file of files.filter(file => file.endsWith(".json"))) { if (terminal.has(file.slice(0, -5))) continue; const record = (yield { kind: "read", token: file.slice(0, -5) })!; if (record.phase === "terminal") { terminal.add(record.token); continue; } active.set(record.token, record); } const reconciled = new Map<string, RecoveryRecord>(); for (const file of files.filter(file => !file.endsWith(".json") && !file.endsWith(".terminal"))) { if (process.platform === "win32" && /^[0-9a-f-]{36}\.proof\.pending$/.test(file)) { if (terminal.has(file.slice(0, 36))) continue; return true; } if (process.platform === "win32" && /^[0-9a-f-]{36}\.proof$/.test(file)) { const token = file.slice(0, 36); if (terminal.has(token) || active.get(token)?.windows?.jobName) continue; return true; } const partial = /^([0-9a-f-]{36})(?:\.(?:terminal|[0-9a-f-]{36}))?\.pending$/.exec(file); if (!partial) return true; const token = partial[1]!; if (terminal.has(token)) continue; // Published terminal authority shadows late writes. const suffix = file.slice(token.length); if (suffix !== ".pending" && suffix !== ".terminal.pending") return true; const record = (yield { kind: "read", token, suffix })!; const previous = active.get(token) ?? reconciled.get(token); if (process.platform === "win32" && suffix === ".pending" && record.phase === "child") { const armed = active.get(token); if (!publishChild || armed?.phase !== "armed" || armed.pgid !== null || armed.parentPid !== record.parentPid || !armed.windows?.jobName || armed.windows.creationTime !== null || armed.windows.jobName !== record.windows?.jobName || record.pgid === null || record.pgid > 0xffffffff || !record.windows?.creationTime || BigInt(record.windows.creationTime) > 0xffffffffffffffffn || !processGone(record.parentPid) || !(yield* childGoneSteps(record)) || !processGone(record.parentPid)) return true; yield { kind: "publish", record }; // Existing protected flush/ACL/rename path; any failure fences. reconciled.set(token, record); continue; } // A complete cleanup write can survive a crash before rename. Recognize // only this owner's terminal evidence, with fresh lifetime proofs. Never // infer completion from an armed/potential verifier publication. if (record.phase !== "terminal" || record.pgid !== null || !processGone(record.parentPid) || (previous && previous.parentPid !== record.parentPid)) return true; if (previous?.phase === "child" && !(yield* childGoneSteps(previous))) return true; if (!processGone(record.parentPid)) return true; reconciled.set(token, record); } for (const record of active.values()) { if (reconciled.has(record.token)) continue; // Re-probe on every admission attempt, including after a restart. A live // or inaccessible group stays fenced until the whole group proves absent. if (record.phase === "child" && record.pgid !== null && processGone(record.parentPid) && (yield* childGoneSteps(record)) && processGone(record.parentPid)) continue; return true; } return false; }