@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
163 lines (156 loc) • 8 kB
text/typescript
import { closeSync, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, openSync, readSync, realpathSync, renameSync, statSync, writeSync, type BigIntStats } from "node:fs";
import { formatWithOptions } from "node:util";
import { basename, dirname, join } from "node:path";
import { ConfigUninstallInProgressError, recordOwnedConfigPath } from "../lib/config-ownership";
export const SERVICE_LOG_MAX_BYTES = 20 * 1024 * 1024;
export const SERVICE_LOG_CHECK_INTERVAL_MS = 60_000;
/** Consecutive failed registrations after which rotation goes ahead unrecorded. */
export const SERVICE_LOG_MAX_REGISTRATION_SKIPS = 3;
function regularLeaf(path: string): BigIntStats | undefined {
try {
const info = lstatSync(path, { bigint: true });
if (!info.isFile() || info.nlink !== 1n || info.ino === 0n) throw new Error("Unsafe service log leaf");
return info;
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
throw error;
}
}
function sameFile(left: BigIntStats | undefined, right: BigIntStats | undefined): boolean {
return left !== undefined && right !== undefined && left.dev === right.dev && left.ino === right.ino;
}
function matchesDescriptor(path: string, fd: number, expected: BigIntStats): boolean {
const info = fstatSync(fd, { bigint: true });
return info.isFile() && info.nlink === 1n && sameFile(expected, info)
&& sameFile(info, regularLeaf(path));
}
/** Preserve the manager's open append descriptor; retain at most two bounded archives. */
export function rotateServiceLog(requestedPath: string, maxBytes = SERVICE_LOG_MAX_BYTES, archiveEnabled = true): boolean {
let source: number | undefined;
let archive: number | undefined;
try {
if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) return false;
// Resolve only the parent: exclusive creation through a Windows junction
// can report EEXIST for a missing leaf. Never resolve away a leaf symlink.
const parent = dirname(requestedPath);
const directory = statSync(parent, { bigint: true });
if (!directory.isDirectory() || directory.ino === 0n) return false;
const canonicalParent = realpathSync(parent);
const path = join(canonicalParent, basename(requestedPath));
const sameDirectory = () => {
const alias = statSync(parent, { bigint: true });
const canonical = statSync(canonicalParent, { bigint: true });
return alias.isDirectory() && canonical.isDirectory()
&& sameFile(directory, alias) && sameFile(directory, canonical);
};
const matches = (suffix: string, fd: number, expected: BigIntStats) => sameDirectory()
&& matchesDescriptor(`${path}${suffix}`, fd, expected)
&& matchesDescriptor(`${requestedPath}${suffix}`, fd, expected);
if (!sameDirectory()) return false;
const original = regularLeaf(requestedPath);
if (!original) return false;
// Windows does not expose O_NOFOLLOW: descriptor/leaf identity checks still
// apply there. Do not reject legitimate junctions in the home path.
const guardedFlags = process.platform === "win32" ? 0 : constants.O_NOFOLLOW | constants.O_NONBLOCK;
source = openSync(path, constants.O_RDWR | guardedFlags);
if (!matches("", source, original)) return false;
const size = Number(fstatSync(source, { bigint: true }).size);
if (!Number.isSafeInteger(size) || size <= maxBytes) return false;
if (!archiveEnabled) {
if (!matches("", source, original)) return false;
ftruncateSync(source, 0);
return true;
}
const previous = regularLeaf(`${path}.1`);
const oldest = regularLeaf(`${path}.2`);
if (!matches("", source, original)) return false;
if (previous) {
if (!sameFile(previous, regularLeaf(`${path}.1`))) return false;
const currentOldest = regularLeaf(`${path}.2`);
if (oldest ? !sameFile(oldest, currentOldest) : currentOldest !== undefined) return false;
if (!sameDirectory()) return false;
renameSync(`${path}.1`, `${path}.2`);
if (!sameFile(previous, regularLeaf(`${path}.2`))) return false;
}
// Never truncate an existing archive, even if another rotation or a path
// replacement wins the gap after rename. Failure leaves the source intact.
if (!sameDirectory()) return false;
archive = openSync(`${path}.1`, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | guardedFlags, 0o600);
const created = fstatSync(archive, { bigint: true });
if (!matches(".1", archive, created)) return false;
// A legacy unbounded file may be huge. Copy only its newest cap-sized tail,
// using fixed memory, before truncating the original inode.
const buffer = Buffer.alloc(Math.min(64 * 1024, maxBytes));
let position = size - maxBytes;
while (position < size) {
const read = readSync(source, buffer, 0, Math.min(buffer.length, size - position), position);
if (read === 0) return false;
let written = 0;
while (written < read) {
if (!matches(".1", archive, created)) return false;
const count = writeSync(archive, buffer, written, read - written);
if (count === 0) return false;
written += count;
}
position += read;
}
fsyncSync(archive);
// Revalidate both names and open objects at the destructive boundary. These
// checks detect observed replacement; they are not an atomic namespace lock.
if (!matches(".1", archive, created)
|| !matches("", source, original)) return false;
ftruncateSync(source, 0);
return true;
} catch {
return false; // Missing files, permissions and disk failures must never stop the service.
} finally {
for (const fd of [archive, source]) {
if (fd !== undefined) try { closeSync(fd); } catch { /* best-effort */ }
}
}
}
/** One sink wrapper covers startup, provider diagnostics and multiline errors. */
export function startServiceLogging(
path: string,
env: NodeJS.ProcessEnv = process.env,
intervalMs = SERVICE_LOG_CHECK_INTERVAL_MS,
): () => void {
if (!env.OCX_SERVICE) return () => {};
const restore: (() => void)[] = [];
for (const method of ["log", "info", "debug", "warn", "error"] as const) {
const original = console[method];
console[method] = (...args: unknown[]) => {
const at = new Date().toISOString();
const line = formatWithOptions({ colors: false }, ...args);
original.call(console, line.split("\n").map(part => `${at} ${part}`).join("\n"));
};
restore.push(() => { console[method] = original; });
}
// Rotation creates the .1/.2 files, so every rotation registers them first. Once recorded this
// is one stat, and it still sees an uninstall tombstone written after logging started. A thrown
// uninstall refusal truncates only the active inode without creating archives. Any other failure (a busy or broken ownership lock)
// skips it and retries next tick, but only a few times in a row: a fault that persists must not
// let the log grow without bound, so rotation then goes ahead unrecorded.
// A `false` result still rotates: a home without ownership metadata has nothing to register, and
// on a full manifest the unrecorded generations are reported by uninstall as residual paths.
let failedRegistrations = 0;
const rotate = () => {
try {
for (const suffix of [".1", ".2"]) recordOwnedConfigPath(dirname(path), `${path}${suffix}`);
failedRegistrations = 0;
} catch (error) {
// Ownership bookkeeping must not break logging.
if (error instanceof ConfigUninstallInProgressError) {
rotateServiceLog(path, SERVICE_LOG_MAX_BYTES, false);
return;
}
failedRegistrations += 1;
if (failedRegistrations < SERVICE_LOG_MAX_REGISTRATION_SKIPS) return;
}
rotateServiceLog(path);
};
rotate();
const timer = setInterval(rotate, intervalMs);
timer.unref();
return () => { clearInterval(timer); for (const reset of restore) reset(); };
}