UNPKG

@bitkyc08/opencodex

Version:

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

270 lines (250 loc) • 10.1 kB
import { randomUUID } from "node:crypto"; import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmdirSync, unlinkSync, writeFileSync, type Stats, } from "node:fs"; import { basename, dirname, join } from "node:path"; const SERVICE_STATE_LOCK_WAIT_MS = 2_000; const SERVICE_STATE_LOCK_POLL_MS = 20; const SERVICE_STATE_LOCK_STALE_MS = 30_000; const PROCESS_INSTANCE = randomUUID(); interface ServiceStateLockRecord { readonly version: 1; readonly pid: number; readonly processInstance: string; readonly token: string; readonly createdAt: number; } interface ServiceStateLockSnapshot { readonly record: ServiceStateLockRecord; readonly ownerPath: string; readonly lockIdentity: Pick<Stats, "dev" | "ino">; readonly ownerIdentity: Pick<Stats, "dev" | "ino" | "size">; readonly mtimeMs: number; } export interface ServiceStateLockHooks { readonly now?: () => number; readonly sleep?: (ms: number) => void; readonly processAlive?: (pid: number) => boolean; readonly beforeStaleDelete?: (lockPath: string) => void; readonly beforeRelease?: (lockPath: string) => void; } interface HeldServiceStateLock { depth: number; readonly snapshot: ServiceStateLockSnapshot; } const heldLocks = new Map<string, HeldServiceStateLock>(); function lockPathForStatePath(statePath: string): string { try { return `${realpathSync.native(statePath)}.lock`; } catch { try { return join(realpathSync.native(dirname(statePath)), `${basename(statePath)}.lock`); } catch { return `${statePath}.lock`; } } } function lockOwnerProcessAlive(pid: number): boolean { try { process.kill(pid, 0); return true; } catch (error) { // EPERM means the process exists but this account cannot signal it. Unknown failures // also fail closed: only ESRCH proves the holder is gone. return (error as NodeJS.ErrnoException).code !== "ESRCH"; } } function sameIdentity( left: Pick<Stats, "dev" | "ino">, right: Pick<Stats, "dev" | "ino">, ): boolean { return left.dev === right.dev && left.ino === right.ino; } function ownerFileName(record: ServiceStateLockRecord): string { return `v1-${record.pid}-${record.processInstance}-${record.token}.json`; } function parseOwnerFileName(name: string): { pid: number; pathToken: string } | null { const match = /^v1-([1-9][0-9]*)-([0-9a-f-]+)-([0-9a-f-]+)[.]json$/i.exec(name); if (!match) return null; const pid = Number(match[1]); return Number.isSafeInteger(pid) && pid > 0 ? { pid, pathToken: `${match[2]}-${match[3]}` } : null; } function readLockSnapshot(lockPath: string): ServiceStateLockSnapshot | null { let lockIdentity: Stats; let entries: string[]; try { lockIdentity = lstatSync(lockPath); if (!lockIdentity.isDirectory()) return null; entries = readdirSync(lockPath); } catch { return null; } if (entries.length !== 1 || !parseOwnerFileName(entries[0]!)) return null; const ownerPath = join(lockPath, entries[0]!); try { const ownerIdentity = lstatSync(ownerPath); if (!ownerIdentity.isFile() || ownerIdentity.size > 4096) return null; const value = JSON.parse(readFileSync(ownerPath, "utf8")) as Partial<ServiceStateLockRecord>; if (value.version !== 1 || !Number.isSafeInteger(value.pid) || (value.pid ?? 0) <= 0 || typeof value.processInstance !== "string" || value.processInstance.length === 0 || typeof value.token !== "string" || value.token.length === 0 || typeof value.createdAt !== "number" || !Number.isFinite(value.createdAt)) return null; const record = value as ServiceStateLockRecord; if (entries[0] !== ownerFileName(record)) return null; const currentLock = lstatSync(lockPath); const currentOwner = lstatSync(ownerPath); if (!currentLock.isDirectory() || !sameIdentity(lockIdentity, currentLock) || !currentOwner.isFile() || !sameIdentity(ownerIdentity, currentOwner) || currentOwner.size !== ownerIdentity.size) return null; return { record, ownerPath, lockIdentity, ownerIdentity, mtimeMs: ownerIdentity.mtimeMs }; } catch { return null; } } function sameLock(left: ServiceStateLockSnapshot, right: ServiceStateLockSnapshot): boolean { return left.record.token === right.record.token && left.record.pid === right.record.pid && left.record.processInstance === right.record.processInstance && sameIdentity(left.lockIdentity, right.lockIdentity) && sameIdentity(left.ownerIdentity, right.ownerIdentity) && left.ownerIdentity.size === right.ownerIdentity.size; } function parsedIncompleteOwner(lockPath: string): { ownerPath: string | null; pid: number | null; mtimeMs: number } | null { try { const lock = lstatSync(lockPath); if (!lock.isDirectory()) return null; const entries = readdirSync(lockPath); if (entries.length === 0) return { ownerPath: null, pid: null, mtimeMs: lock.mtimeMs }; if (entries.length !== 1) return null; const parsed = parseOwnerFileName(entries[0]!); if (!parsed) return null; const ownerPath = join(lockPath, entries[0]!); const owner = lstatSync(ownerPath); return owner.isFile() ? { ownerPath, pid: parsed.pid, mtimeMs: owner.mtimeMs } : null; } catch { return null; } } function reclaimStaleLock(lockPath: string, hooks: ServiceStateLockHooks): boolean { const now = hooks.now ?? Date.now; const processAlive = hooks.processAlive ?? lockOwnerProcessAlive; const snapshot = readLockSnapshot(lockPath); const incomplete = snapshot ? null : parsedIncompleteOwner(lockPath); if (!snapshot && !incomplete) return false; const ownerPath = snapshot?.ownerPath ?? incomplete!.ownerPath; const ownerPid = snapshot?.record.pid ?? incomplete!.pid; const createdAt = snapshot ? Math.max(snapshot.record.createdAt, snapshot.mtimeMs) : incomplete!.mtimeMs; if (now() - createdAt <= SERVICE_STATE_LOCK_STALE_MS || (ownerPid !== null && processAlive(ownerPid))) { return false; } if (snapshot) { const current = readLockSnapshot(lockPath); if (!current || !sameLock(snapshot, current)) return false; } hooks.beforeStaleDelete?.(lockPath); try { // The owner filename contains the holder's PID, process-instance nonce and token. A // successor has a different name, so this unlink cannot delete the successor's owner. if (ownerPath) unlinkSync(ownerPath); rmdirSync(lockPath); return true; } catch { return false; } } function acquireOne(lockPath: string, hooks: ServiceStateLockHooks, waitMs: number): ServiceStateLockSnapshot { const held = heldLocks.get(lockPath); if (held) { held.depth += 1; return held.snapshot; } const now = hooks.now ?? Date.now; const sleep = hooks.sleep ?? (ms => Bun.sleepSync(ms)); const deadline = now() + waitMs; if (!existsSync(dirname(lockPath))) mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 }); for (;;) { const record: ServiceStateLockRecord = { version: 1, pid: process.pid, processInstance: PROCESS_INSTANCE, token: randomUUID(), createdAt: now(), }; const ownerPath = join(lockPath, ownerFileName(record)); let createdDirectory = false; let descriptor: number | null = null; try { mkdirSync(lockPath, { mode: 0o700 }); createdDirectory = true; descriptor = openSync(ownerPath, "wx", 0o600); writeFileSync(descriptor, `${JSON.stringify(record)}\n`, "utf8"); fsyncSync(descriptor); closeSync(descriptor); descriptor = null; const snapshot = readLockSnapshot(lockPath); if (!snapshot || snapshot.record.token !== record.token) throw new Error("service state lock ownership could not be verified"); heldLocks.set(lockPath, { depth: 1, snapshot }); return snapshot; } catch (error) { if (descriptor !== null) { try { closeSync(descriptor); } catch { /* best-effort */ } } if (createdDirectory) { try { unlinkSync(ownerPath); } catch { /* incomplete owner may remain for dead-PID recovery */ } try { rmdirSync(lockPath); } catch { /* another entry or uncertain owner remains */ } } const code = (error as NodeJS.ErrnoException).code; if (code !== "EEXIST") throw error; if (reclaimStaleLock(lockPath, hooks)) continue; if (now() >= deadline) { throw new Error(`another process owns the service state lock at ${lockPath}; nothing was written`); } sleep(SERVICE_STATE_LOCK_POLL_MS); } } } function releaseOne(lockPath: string, hooks: ServiceStateLockHooks): void { const held = heldLocks.get(lockPath); if (!held) return; held.depth -= 1; if (held.depth > 0) return; heldLocks.delete(lockPath); hooks.beforeRelease?.(lockPath); try { const current = readLockSnapshot(lockPath); if (!current || !sameLock(held.snapshot, current)) return; unlinkSync(held.snapshot.ownerPath); rmdirSync(lockPath); } catch { /* a verified future holder or stale recovery owns cleanup */ } } export function assertServiceStateLocksOwned(statePaths: readonly string[]): void { for (const path of statePaths) { const lockPath = lockPathForStatePath(path); const held = heldLocks.get(lockPath); const current = readLockSnapshot(lockPath); if (!held || !current || !sameLock(held.snapshot, current)) { throw new Error(`service state lock ownership changed before commit: ${lockPath}`); } } } export function withServiceStateLocks<T>( statePaths: readonly string[], run: () => T, options: { readonly waitMs?: number; readonly hooks?: ServiceStateLockHooks } = {}, ): T { const hooks = options.hooks ?? {}; const lockPaths = [...new Set(statePaths.map(lockPathForStatePath))].sort(); const acquired: string[] = []; try { for (const lockPath of lockPaths) { acquireOne(lockPath, hooks, options.waitMs ?? SERVICE_STATE_LOCK_WAIT_MS); acquired.push(lockPath); } return run(); } finally { for (const lockPath of acquired.reverse()) releaseOne(lockPath, hooks); } }