UNPKG

@bitkyc08/opencodex

Version:

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

145 lines (143 loc) • 8.46 kB
import { linkSync, mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs"; import { dirname, join } from "node:path"; import { ownEvidence, ownerState, safeNamespace, safeNamespaceStat, type OwnerDeps, type OwnerEvidence } from "./prompt-lock-owner"; import { ChangedLock as ChangedClaim, checkEntry, checkIdentity, guarded, type Entry, type Namespace } from "./prompt-lock-evidence"; import { LockFileBusy, lockFileOperation } from "./prompt-lock-io"; export interface ClaimRecord extends OwnerEvidence { ticket: number; token?: string } export class UnsafeLockNamespace extends Error { constructor(readonly path: string) { super(`Unsafe lock state at ${path}; deliberate removal is required.`); } } interface AbandonedClaim { token: string; parents: Namespace[]; entry: Entry } // Only a completed invocation may enter this map; live/reentrant reservations never do. const abandoned = new Map<string, AbandonedClaim>(); function recoverAbandoned(directory: string, deps: OwnerDeps): void { for (const [path, claim] of abandoned) { if (dirname(path) !== directory) continue; // The token is bound to the captured bytes and unique name, never to PID alone. const record = JSON.parse(claim.entry.body) as ClaimRecord; if (record.pid !== process.pid || record.token !== claim.token) throw new ChangedClaim("Unknown local claim"); try { guarded(claim.parents, [claim.entry], deps, () => unlinkSync(path)); } catch (error) { if (!(error instanceof ChangedClaim) && (error as NodeJS.ErrnoException).code !== "ENOENT") throw error; // A replacement is not ours; forget custody without deleting it. } abandoned.delete(path); } } /** Publish owner evidence together with choosing=0; an empty reservation is never published. */ export function withLockClaim<T>( path: string, token: string, deps: OwnerDeps, run: () => T, initialized?: () => void, ): { ok: true; value: T } | { ok: false } { const io = <R>(operation: () => R): R => lockFileOperation(operation, deps.platform); const directory = `${path}.claims`; try { recoverAbandoned(directory, deps); } catch (error) { if (error instanceof LockFileBusy) return { ok: false }; throw error; } if (!safeNamespace(dirname(path), "directory", deps)) throw new UnsafeLockNamespace(dirname(path)); const root: Namespace = { path: dirname(path), stat: io(() => deps.lstat(dirname(path))) }; try { guarded([root], [], deps, () => mkdirSync(directory, { mode: 0o700 })); } catch (error) { if (error instanceof LockFileBusy) return { ok: false }; if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; } // A peer's cleanup removes the empty claims directory, so it can vanish between our mkdir and // this read. That is contention, not an unsafe namespace and not a crash: report it as busy. // One observation is both validated and kept as the parent witness, so a replacement that // appears after a missing read can never be trusted without its own ownership check. let directoryStat: ReturnType<OwnerDeps["lstat"]>; try { directoryStat = io(() => deps.lstat(directory)); } catch (error) { if (error instanceof LockFileBusy || (error as NodeJS.ErrnoException).code === "ENOENT") return { ok: false }; throw error; } if (!safeNamespaceStat(directoryStat, "directory", deps)) throw new UnsafeLockNamespace(directory); const parents = [root, { path: directory, stat: directoryStat }]; const claimDirectoryGone = (): boolean => { try { const now = deps.lstat(directory); return now.dev !== parents[1].stat.dev || now.ino !== parents[1].stat.ino; } catch { return true; } }; const ownName = `${process.pid}-${token}.claim`, ownPath = join(directory, ownName); const temporary = `${path}.claim-init-${token}`; let ownEntry: Entry | undefined, temporaryEntry: Entry | undefined; const evidence = { ...ownEvidence(deps), token }; const capture = (entryPath: string, expectedBody?: string): Entry => guarded(parents, [], deps, () => { if (!safeNamespace(entryPath, "file", deps, true)) throw new UnsafeLockNamespace(entryPath); const entry = { path: entryPath, stat: deps.lstat(entryPath), body: readFileSync(entryPath, "utf8") }; checkEntry(entry, deps); if (expectedBody !== undefined && entry.body !== expectedBody) throw new ChangedClaim("Local claim evidence changed"); return entry; }); const peers = (): Array<{ name: string; ticket: number }> => { const result: Array<{ name: string; ticket: number }> = []; for (const name of guarded(parents, [], deps, () => readdirSync(directory))) { if (name === ownName) continue; const peerPath = join(directory, name); if (!/^([1-9][0-9]*)-[0-9a-f]{16}\.claim$/.test(name) || !safeNamespace(peerPath, "file", deps, true)) throw new UnsafeLockNamespace(peerPath); let entry: Entry, peer: ClaimRecord | null; try { entry = capture(peerPath); peer = JSON.parse(entry.body); } catch (error) { if (error instanceof LockFileBusy || error instanceof UnsafeLockNamespace) throw error; if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; throw new UnsafeLockNamespace(peerPath); } const state = ownerState(peer, deps); if (state === "unsafe") throw new UnsafeLockNamespace(peerPath); if (state === "dead") { try { guarded(parents, [entry], deps, () => { if (ownerState(peer, deps) !== "dead") throw new ChangedClaim("Peer is no longer dead"); checkEntry(entry, deps); for (const parent of parents) checkIdentity(parent, deps); unlinkSync(peerPath); }); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; } continue; } const ticket = peer?.ticket; if (typeof ticket !== "number" || !Number.isSafeInteger(ticket) || ticket < 0) throw new UnsafeLockNamespace(peerPath); result.push({ name, ticket }); } return result; }; try { const choosingBody = JSON.stringify({ ...evidence, ticket: 0 }); guarded(parents, [], deps, () => writeFileSync(temporary, choosingBody, { mode: 0o600, flag: "wx" })); temporaryEntry = capture(temporary, choosingBody); guarded(parents, [temporaryEntry], deps, () => linkSync(temporary, ownPath)); ownEntry = { ...temporaryEntry, path: ownPath }; guarded(parents, [temporaryEntry], deps, () => unlinkSync(temporary)); temporaryEntry = undefined; initialized?.(); let ticket = 1; for (const peer of peers()) ticket = Math.max(ticket, peer.ticket + 1); if (!Number.isSafeInteger(ticket)) return { ok: false }; const ticketBody = JSON.stringify({ ...evidence, ticket }); guarded(parents, [], deps, () => writeFileSync(temporary, ticketBody, { mode: 0o600, flag: "wx" })); temporaryEntry = capture(temporary, ticketBody); guarded(parents, [temporaryEntry, ownEntry], deps, () => renameSync(temporary, ownPath)); ownEntry = { ...temporaryEntry, path: ownPath }; temporaryEntry = undefined; for (const peer of peers()) { if (peer.ticket === 0 || peer.ticket < ticket || (peer.ticket === ticket && peer.name < ownName)) return { ok: false }; } if (!safeNamespace(path, "file", deps, true)) throw new UnsafeLockNamespace(path); return { ok: true, value: run() }; } catch (error) { const code = (error as NodeJS.ErrnoException).code; // A peer's final rmdir can remove the claims directory between our identity check and the // link/rename into it; platforms report that as ENOENT or (macOS link) EINVAL. Either is contention. if (error instanceof LockFileBusy || code === "ENOENT" || (code === "EINVAL" && claimDirectoryGone())) return { ok: false }; throw error; } finally { if (temporaryEntry) { try { guarded(parents, [temporaryEntry], deps, () => unlinkSync(temporary)); } catch { /* Preserve changed or busy entries. */ } } if (ownEntry) { try { guarded(parents, [ownEntry], deps, () => unlinkSync(ownPath)); } catch (error) { if (!(error instanceof ChangedClaim) && (error as NodeJS.ErrnoException).code !== "ENOENT") { abandoned.set(ownPath, { token, parents, entry: ownEntry }); } } try { guarded(parents, [], deps, () => rmdirSync(directory)); } catch { /* A peer or replacement still owns the directory. */ } } } }