UNPKG

@bitkyc08/opencodex

Version:

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

120 lines (108 loc) • 5.82 kB
/** * The per-alias lock that enrollment and revoke of a Home-initiated link take (structure/remote-link.md, * "Operation journal"). One private SQLite file per alias (lowercased, hashed) under <configDir>/link/locks, held * with BEGIN IMMEDIATE for the whole operation, so a second holder anywhere, this process included, waits. The OS * releases it when the holding process dies, which is what lets a repeat recover an open journal entry. * * Waiting polls with an injected sleep and clock up to a bound; past it the caller answers 409. */ import { Database } from "bun:sqlite"; import { createHash } from "node:crypto"; import { chmodSync, closeSync, lstatSync, mkdirSync, openSync } from "node:fs"; import { dirname, join } from "node:path"; import { assertNotRealHomeUnderTest } from "../lib/test-home-guard"; import { hardenSecretDir, hardenSecretPath } from "../lib/windows-secret-acl"; import { linkDir } from "./paths"; export interface AliasLockDeps { /** Defaults to <configDir>/link/locks. */ lockDir?: string; sleep?: (ms: number) => Promise<void>; now?: () => number; /** How long a second holder waits; defaults to ALIAS_LOCK_WAIT_MS. */ waitMs?: number; pollMs?: number; /** The caller's request: once it aborts (the client went away), the wait ends at the next poll. */ signal?: AbortSignal; } export interface AliasLock { release(): void } /** * Two minutes: a third of the CLI's 360 s enrollment deadline (ENROLLMENT_DEADLINE_MS in src/cli/link-enrollment.ts), * which bounds the wait itself. It does not promise the waiter time to finish: an apply's own worst case can outrun the * deadline, and then the CLI reports the outcome uncertain and a repeat with the same operation id replays it. A waiting * revoke holds its link's Child-operation reservation no longer than this. */ export const ALIAS_LOCK_WAIT_MS = 120_000; const ALIAS_LOCK_POLL_MS = 250; export class AliasLockError extends Error { constructor(readonly code: "link_alias_lock_busy" | "link_alias_lock_failed" | "link_alias_lock_aborted", options?: ErrorOptions) { super(code, options); this.name = "AliasLockError"; } } export function aliasLockPath(alias: string, lockDir: string = join(linkDir(), "locks")): string { return join(lockDir, createHash("sha256").update(alias.toLowerCase()).digest("hex").slice(0, 32) + ".lock"); } function errorCode(error: unknown): unknown { return error !== null && typeof error === "object" && "code" in error ? (error as { code: unknown }).code : undefined; } function assertPrivate(path: string, directory: boolean): void { const stat = lstatSync(path); if (stat.isSymbolicLink() || (directory ? !stat.isDirectory() : !stat.isFile() || stat.nlink !== 1)) throw new AliasLockError("link_alias_lock_failed"); if (process.platform !== "win32" && stat.uid !== process.getuid!()) throw new AliasLockError("link_alias_lock_failed"); } function prepare(path: string, directory: string): void { // <configDir>/link/locks: refuse before any mkdir when a test points it at the real OpenCodex home. assertNotRealHomeUnderTest(dirname(dirname(directory))); mkdirSync(directory, { recursive: true, mode: 0o700 }); assertPrivate(directory, true); if (process.platform !== "win32") chmodSync(directory, 0o700); hardenSecretDir(directory, { required: true }); // Created privately before SQLite opens it; an existing symlink or hard link is refused, never followed. try { closeSync(openSync(path, "wx", 0o600)); } catch (error) { if (errorCode(error) !== "EEXIST") throw error; } assertPrivate(path, false); if (process.platform !== "win32") chmodSync(path, 0o600); hardenSecretPath(path, { required: true }); } function tryAcquire(path: string): Database | null { let database: Database | undefined; try { database = new Database(path, { create: true }); database.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE"); return database; } catch (error) { try { database?.close(); } catch { /* the acquisition failure is what matters */ } const code = errorCode(error); if (code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || (error instanceof Error && /database (?:is|table is) locked/i.test(error.message))) return null; throw new AliasLockError("link_alias_lock_failed", { cause: error }); } } /** Take the alias lock, waiting while another holder has it; AliasLockError link_alias_lock_busy past the bound. */ export async function acquireAliasLock(alias: string, deps: AliasLockDeps = {}): Promise<AliasLock> { const directory = deps.lockDir ?? join(linkDir(), "locks"); const path = aliasLockPath(alias, directory); try { prepare(path, directory); } catch (error) { throw error instanceof AliasLockError ? error : new AliasLockError("link_alias_lock_failed", { cause: error }); } const now = deps.now ?? Date.now, sleep = deps.sleep ?? ((ms: number) => Bun.sleep(ms)); const deadline = now() + (deps.waitMs ?? ALIAS_LOCK_WAIT_MS); for (;;) { if (deps.signal?.aborted) throw new AliasLockError("link_alias_lock_aborted"); const database = tryAcquire(path); if (database) { let held = true; return { release() { if (!held) return; held = false; try { database.exec("ROLLBACK"); } catch { /* close releases the OS lock regardless */ } database.close(); } }; } if (now() >= deadline) throw new AliasLockError("link_alias_lock_busy"); await sleep(deps.pollMs ?? ALIAS_LOCK_POLL_MS); if (deps.signal?.aborted) throw new AliasLockError("link_alias_lock_aborted"); } } export async function withAliasLock<T>(alias: string, deps: AliasLockDeps, action: () => Promise<T>): Promise<T> { const lock = await acquireAliasLock(alias, deps); try { return await action(); } finally { lock.release(); } }