@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
197 lines (182 loc) • 8.65 kB
text/typescript
import { Database } from "bun:sqlite";
import { lstatSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { sameFileIdentity, statTimeMs, type FileIdentity } from "../../lib/file-identity";
import { ensureLabDirs, labCommunityDir, labRoot } from "../paths";
import { readPrivateRegularFile } from "./file-safety";
import { PublicEvidenceValidationError } from "./validate";
const PUBLIC_EVIDENCE_MUTATION_DB_NAME = "public-evidence-mutation.sqlite";
const LEGACY_MUTATION_LOCK_NAME = ".mutation-lock";
const LEGACY_MUTATION_LOCK_OWNER = "owner.json";
const LEGACY_MUTATION_LOCK_INCOMPLETE_STALE_MS = 24 * 60 * 60 * 1000;
const LEGACY_MUTATION_LOCK_ABSOLUTE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
const DETACHED_MUTATION_LOCK_RE = /^\.mutation-lock-(?:stale|release)-\d+-[0-9a-f-]{36}$/;
const LEGACY_OWNER_FILE_OPTIONS = {
maxBytes: 1024,
errorCode: "community_cache_lock",
errorMessage: "community cache mutation lock metadata is unsafe",
sizeErrorCode: "community_cache_lock",
sizeErrorMessage: "community cache mutation lock metadata exceeds its size bound",
requireMode600: true,
} as const;
type LegacyMutationLockOwner = {
pid: number;
createdAt: number;
};
function mutationLockDatabasePath(configDir?: string): string {
return join(labRoot(configDir), PUBLIC_EVIDENCE_MUTATION_DB_NAME);
}
/** Lock bookkeeping entries an older build may leave in the community cache directory. */
export function isMutationLockEntryName(name: string): boolean {
return name === LEGACY_MUTATION_LOCK_NAME || DETACHED_MUTATION_LOCK_RE.test(name);
}
function legacyMutationLockPath(configDir?: string): string {
return join(labCommunityDir(configDir), LEGACY_MUTATION_LOCK_NAME);
}
function pidDefinitelyDead(pid: number): boolean {
try {
process.kill(pid, 0);
return false;
} catch (error) {
return (error as NodeJS.ErrnoException).code === "ESRCH";
}
}
function readLegacyMutationLockOwner(lockPath: string): LegacyMutationLockOwner | null {
try {
const bytes = readPrivateRegularFile(join(lockPath, LEGACY_MUTATION_LOCK_OWNER), LEGACY_OWNER_FILE_OPTIONS);
const raw = JSON.parse(bytes.toString("utf8")) as Partial<LegacyMutationLockOwner>;
if (
Number.isSafeInteger(raw.pid) && Number(raw.pid) > 0
&& Number.isSafeInteger(raw.createdAt) && Number(raw.createdAt) > 0
) return { pid: Number(raw.pid), createdAt: Number(raw.createdAt) };
} catch {
// Missing or malformed metadata falls back to the directory-age rule below.
}
return null;
}
function assertMutationLockDirectory(lockPath: string) {
const stat = lstatSync(lockPath, { bigint: true });
if (!stat.isDirectory() || stat.isSymbolicLink()) {
throw new PublicEvidenceValidationError(
"community_cache_lock",
"community cache mutation lock is not a directory",
);
}
return stat;
}
/**
* Whether a directory lock left by an older OpenCodex build still has a holder.
*
* Older builds serialized through a `.mutation-lock` directory. This build never creates,
* renames or removes one; it only declines to run beside a holder that still looks alive, using
* the same evidence the older builds used: a live owner PID within the absolute age ceiling, or
* an ownerless directory recent enough to be an acquisition in progress.
*/
function legacyMutationLockBlocks(lockPath: string, nowMs: number): boolean {
let stat: ReturnType<typeof assertMutationLockDirectory>;
try {
stat = assertMutationLockDirectory(lockPath);
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
throw error;
}
const owner = readLegacyMutationLockOwner(lockPath);
if (owner) {
return !pidDefinitelyDead(owner.pid) && nowMs - owner.createdAt <= LEGACY_MUTATION_LOCK_ABSOLUTE_STALE_MS;
}
return nowMs - statTimeMs(stat.mtimeNs) <= LEGACY_MUTATION_LOCK_INCOMPLETE_STALE_MS;
}
function cleanupDetachedMutationLocks(configDir: string | undefined, nowMs: number): void {
const dir = labCommunityDir(configDir);
for (const name of readdirSync(dir)) {
if (!DETACHED_MUTATION_LOCK_RE.test(name)) continue;
const detachedPath = join(dir, name);
// Older builds moved a released or reclaimed lock directory to one of these UUID-scoped
// names before deleting it. One that still records a live owner may belong to a running
// older-build holder, so it is left alone. Removing the rest keeps them from leaking
// storage or being mistaken for community cache objects.
const owner = readLegacyMutationLockOwner(detachedPath);
if (owner && !pidDefinitelyDead(owner.pid) && nowMs - owner.createdAt <= LEGACY_MUTATION_LOCK_ABSOLUTE_STALE_MS) continue;
rmSync(detachedPath, { recursive: true, force: true });
}
}
/** The lock file's identity, after proving it is a single-link regular file. */
function mutationLockFileIdentity(path: string): FileIdentity {
const stat = lstatSync(path, { bigint: true });
if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n) {
throw new PublicEvidenceValidationError("community_cache_lock", "community cache mutation lock is unsafe");
}
return { dev: stat.dev, ino: stat.ino };
}
/**
* Open the lock database on a file this module created as a private regular file.
*
* The Lab root is owner-only, so the processes that can replace this pathname are the user's own,
* the same trust boundary as the config mutation lock. Within it, the file is created exclusively
* with mode 0600 (never chmod-ed through the pathname), and the caller re-proves after locking
* that the pathname still names the file inspected before the open.
*/
function openMutationLockDatabase(path: string): { database: Database; identity: FileIdentity } {
try {
writeFileSync(path, "", { flag: "wx", mode: 0o600 });
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
}
const identity = mutationLockFileIdentity(path);
try {
return { database: new Database(path, { create: false, readwrite: true }), identity };
} catch {
// The SQLite error text can name local paths; the stable code is what callers act on.
throw new PublicEvidenceValidationError("community_cache_lock", "community cache mutation lock is unavailable");
}
}
/**
* Serialize public-evidence mutations across CLI/server processes.
*
* The lock is an OS-held SQLite write transaction on a dedicated database, with
* `busy_timeout=0` so a second holder fails fast as `community_cache_busy`. Closing the handle,
* including at process exit or crash, releases it, so there is no stale-owner recovery and no
* step that renames or deletes another process's lock state. Never return a Promise from `run`.
*/
export function withPublicEvidenceMutationLock<T>(
configDir: string | undefined,
run: () => T,
): T {
ensureLabDirs(configDir);
const path = mutationLockDatabasePath(configDir);
const { database, identity } = openMutationLockDatabase(path);
let transactionOpen = false;
try {
try {
database.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE");
transactionOpen = true;
} catch (cause) {
const code = cause && typeof cause === "object" && "code" in cause ? String((cause as { code?: unknown }).code) : "";
if (code.startsWith("SQLITE_BUSY") || code.startsWith("SQLITE_LOCKED")) {
throw new PublicEvidenceValidationError("community_cache_busy", "community cache is busy");
}
throw new PublicEvidenceValidationError("community_cache_lock", "community cache mutation lock is unavailable");
}
if (!sameFileIdentity(mutationLockFileIdentity(path), identity)) {
throw new PublicEvidenceValidationError("community_cache_lock", "community cache mutation lock changed while opening");
}
const nowMs = Date.now();
if (legacyMutationLockBlocks(legacyMutationLockPath(configDir), nowMs)) {
throw new PublicEvidenceValidationError("community_cache_busy", "community cache is busy");
}
cleanupDetachedMutationLocks(configDir, nowMs);
return run();
} finally {
if (transactionOpen) {
try { database.exec("ROLLBACK"); } catch { /* closing the handle below still releases the OS lock */ }
}
try { database.close(); } catch { /* the OS lock is released with the handle */ }
}
}
/** Test-only seam for the older-build lock policy. This module is not barrel-exported. */
export function publicEvidenceLegacyMutationLockBlocksForTests(
configDir: string | undefined,
nowMs = Date.now(),
): boolean {
return legacyMutationLockBlocks(legacyMutationLockPath(configDir), nowMs);
}