@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
141 lines (138 loc) • 7.96 kB
text/typescript
import { constants, closeSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync,
realpathSync, renameSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
import { spawnSync } from "node:child_process";
import { dirname, isAbsolute, join } from "node:path";
import { assertNotRealHomeUnderTest } from "../lib/test-home-guard";
import { remoteError, REMOTE_LIMITS } from "./remote-contract";
/** macOS reports access ACLs separately from otherwise-private POSIX mode bits. */
export function macAclOutputIsPrivate(output: string): boolean {
const lines = output.trimEnd().split("\n");
return lines.length === 1 && /^[d-][rwxStTs-]{9}[.@]?\s/.test(lines[0]!);
}
function checkMacAcl(path: string): void {
if (process.platform !== "darwin") return;
const result = spawnSync("/bin/ls", ["-lde", path], {
encoding: "utf8", timeout: 1_000, shell: false, windowsHide: true,
env: { ...process.env, LC_ALL: "C" },
});
if (result.error || result.status !== 0 || result.stderr || !macAclOutputIsPrivate(result.stdout)) throw new Error();
}
/** Check the entire path ancestry before using the private messaging subtree. */
export function checkRemoteDirectory(path: string): void {
checkDirectory(path, true);
}
/** The configuration home needs trusted ancestry; only messaging's own leaf must be private. */
function checkDirectory(path: string, privateLeaf: boolean): void {
if (!["linux", "darwin"].includes(process.platform) || !isAbsolute(path)) {
throw remoteError("unsupported_platform", "Remote messaging requires a private Linux or macOS configuration home.");
}
try {
const final = lstatSync(path);
if (!final.isDirectory() || final.isSymbolicLink()
|| (privateLeaf && (final.uid !== process.getuid!() || (final.mode & 0o077)))) throw new Error();
if (privateLeaf) checkMacAcl(path);
// Root-controlled OS aliases (/tmp and /var on macOS) are not user-controlled redirects.
for (let entry = path; ; entry = dirname(entry)) {
const stat = lstatSync(entry);
if (stat.isSymbolicLink()) { if (stat.uid !== 0) throw new Error(); }
else if (!stat.isDirectory() || (stat.uid !== process.getuid!() && stat.uid !== 0)
|| ((stat.mode & 0o022) !== 0 && !(stat.uid === 0 && (stat.mode & 0o1000) !== 0))
|| (privateLeaf && entry === path && (stat.uid !== process.getuid!() || (stat.mode & 0o077) !== 0))) throw new Error();
if (entry === "/") break;
}
for (let entry = realpathSync(path); ; entry = dirname(entry)) {
const stat = lstatSync(entry);
if (!stat.isDirectory() || (stat.uid !== process.getuid!() && stat.uid !== 0)
|| ((stat.mode & 0o022) && !(stat.uid === 0 && (stat.mode & 0o1000)))) throw new Error();
if (entry === "/") break;
}
} catch { throw remoteError("unsafe_remote_storage", "Messaging storage requires private owned directories and trusted ancestors."); }
}
/** ENOENT alone means absent; permission failures and redirects are not empty state. */
export function remotePathExists(path: string): boolean {
try { lstatSync(path); return true; }
catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return false; throw error; }
}
/** A published directory entry must reach storage before dependent remote work starts. */
function syncRemoteDirectory(path: string, sync = fsyncSync): void {
let fd: number | undefined;
try {
fd = openSync(realpathSync(path), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
sync(fd);
} catch { throw remoteError("remote_storage_unknown", "Messaging storage changed, but its crash durability could not be confirmed; inspect state before explicit recovery."); }
finally { if (fd !== undefined) closeSync(fd); }
}
/** Remove a validated private file durably; shared journals require the caller's mutation lock. */
export function removeRemoteFile(path: string, remove = unlinkSync, sync = fsyncSync): void {
assertNotRealHomeUnderTest(path); readRemoteFile(path);
remove(path); syncRemoteDirectory(dirname(path), sync);
}
/** Create only explicitly requested state, refusing an unsafe existing configuration home. */
export function createRemoteDirectory(path: string): void {
assertNotRealHomeUnderTest(path);
const parent = dirname(path);
if (!remotePathExists(parent)) {
if (!remotePathExists(dirname(parent))) throw remoteError("unsafe_remote_storage", "Messaging configuration parent must already exist.");
checkDirectory(dirname(parent), false);
mkdirSync(parent, { mode: 0o700 });
syncRemoteDirectory(dirname(parent));
}
checkDirectory(parent, false);
if (!remotePathExists(path)) { mkdirSync(path, { mode: 0o700 }); syncRemoteDirectory(parent); }
checkRemoteDirectory(path);
}
/** Bounded, fatal-UTF-8, no-follow regular file reads never open SQLite or create absent state. */
export function readRemoteFile(path: string): string | null {
if (!remotePathExists(dirname(path))) return null;
checkRemoteDirectory(dirname(path));
let fd: number;
try { fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
throw remoteError("unsafe_remote_storage", "Cannot safely read messaging state.");
}
try {
const stat = fstatSync(fd);
if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid!() || (stat.mode & 0o077)
|| stat.size > REMOTE_LIMITS.storeBytes) throw new Error();
checkMacAcl(path);
const bytes = Buffer.alloc(REMOTE_LIMITS.storeBytes + 1);
let size = 0;
while (size < bytes.length) { const count = readSync(fd, bytes, size, bytes.length - size, size); if (!count) break; size += count; }
if (size > REMOTE_LIMITS.storeBytes) throw new Error();
return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size));
} catch { throw remoteError("unsafe_remote_storage", "Messaging state is unsafe, oversized or malformed."); }
finally { closeSync(fd); }
}
/** Publish a private file atomically; this primitive is called while its store lock is owned. */
export function writeRemoteFile(path: string, text: string, sync = fsyncSync): void {
assertNotRealHomeUnderTest(path);
checkRemoteDirectory(dirname(path));
if (Buffer.byteLength(text) > REMOTE_LIMITS.storeBytes) throw remoteError("remote_capacity", "Messaging state exceeds its byte limit.");
readRemoteFile(path);
const temporary = join(dirname(path), `.write-${crypto.randomUUID()}`);
const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
try {
try {
try { checkMacAcl(temporary); }
catch { throw remoteError("unsafe_remote_storage", "Cannot safely publish messaging state: temporary file ACL privacy could not be confirmed."); }
writeFileSync(fd, text, "utf8"); sync(fd);
} finally { closeSync(fd); }
renameSync(temporary, path);
try { checkMacAcl(path); }
catch { throw remoteError("remote_storage_unknown", "Messaging state was replaced, but its ACL privacy and crash durability could not be confirmed; inspect state and permissions before explicit recovery."); }
syncRemoteDirectory(dirname(path), sync);
} finally { if (remotePathExists(temporary)) unlinkSync(temporary); }
}
/** Serialize cooperating mutations. Crash residue fails closed; it is never reaped by age. */
export function withRemoteLock<T>(directory: string, action: () => T): T {
const lock = join(directory, "mutation.lock");
try { mkdirSync(lock, { mode: 0o700 }); }
catch { throw remoteError("remote_state_busy", "Messaging state is locked; finish or recover its owning mutation first."); }
const identity = lstatSync(lock);
try { return action(); }
finally {
const current = lstatSync(lock);
if (current.dev === identity.dev && current.ino === identity.ino) rmdirSync(lock);
}
}