UNPKG

@bitkyc08/opencodex

Version:

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

122 lines (116 loc) • 5.16 kB
/** Linux pidfd ownership for the opt-in sentinel. Loaded only on Linux. */ import { dlopen, FFIType, read } from "bun:ffi"; import type { TerminateResult } from "./health-sentinel-main"; const ESRCH = 3; const ENOSYS = 38; // Syscalls from 424 onward share one number on every Linux architecture. Binding is limited to // x64/arm64 because the FFI signature below assumes their LP64 integer-register calling convention. const SYS_PIDFD_OPEN = 434; const SYS_PIDFD_SEND_SIGNAL = 424; type CallResult = { value: number; errno: number }; export type PidfdSyscalls = { open(pid: number): CallResult; signal(fd: number, signal: number): CallResult; close(fd: number): void; dispose(): void; }; export type ParentPidfd = { terminate(signal?: 15 | 9): TerminateResult; close(): void }; export type ParentPidfdResult = | { kind: "bound"; handle: ParentPidfd } | { kind: "unsupported"; reason: string } | { kind: "refused"; reason: string }; function nativeSyscalls(): PidfdSyscalls { const symbols = { // syscall is variadic, but these syscalls use integer/pointer arguments only. All supplied // slots are machine-word integers (including zero for siginfo and flags), on these LP64 ABIs. syscall: { args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64], returns: FFIType.i64 }, __errno_location: { args: [], returns: FFIType.ptr }, close: { args: [FFIType.i32], returns: FFIType.i32 }, } as const; const load = (path: string) => dlopen(path, symbols); let libc: ReturnType<typeof load>; try { libc = load("libc.so.6"); } catch { // musl exports libc symbols through its loader; it has no glibc soname or pidfd wrappers. libc = load(`/lib/ld-musl-${process.arch === "x64" ? "x86_64" : "aarch64"}.so.1`); } const call = (nr: number, a: number, b: number, c = 0, d = 0): CallResult => { const value = Number(libc.symbols.syscall(nr, a, b, c, d)); return { value, errno: value === -1 ? read.i32(libc.symbols.__errno_location()!) : 0 }; }; return { open: pid => call(SYS_PIDFD_OPEN, pid, 0), signal: (fd, signal) => call(SYS_PIDFD_SEND_SIGNAL, fd, signal), // Never retry close on Linux: even an EINTR has released the descriptor. close: fd => { libc.symbols.close(fd); }, dispose: () => libc.close(), }; } /** Acquire before arming; reparenting during acquisition invalidates even a successfully opened fd. */ export function openParentPidfd( pid: number, isParent: () => boolean, options: { arch?: string; load?: () => PidfdSyscalls } = {}, ): ParentPidfdResult { return openVerifiedPidfd(pid, isParent, options); } /** The verifier confirms the same PID ownership on both sides of pidfd acquisition. */ export function openVerifiedPidfd( pid: number, verify: () => boolean, options: { arch?: string; load?: () => PidfdSyscalls } = {}, ): ParentPidfdResult { if (!verify()) return { kind: "refused", reason: "PID ownership could not be verified" }; const arch = options.arch ?? process.arch; if (arch !== "x64" && arch !== "arm64") return { kind: "unsupported", reason: `pidfd syscall ABI is unsupported on ${arch}` }; let api: PidfdSyscalls; try { api = (options.load ?? nativeSyscalls)(); } catch { return { kind: "refused", reason: "Linux pidfd libc binding is unavailable" }; } let fd: number | null = null; let closed = false; let signalled = false; const close = () => { if (closed) return; closed = true; try { if (fd !== null) api.close(fd); } finally { api.dispose(); } }; const refuse = (reason: string): ParentPidfdResult => { close(); return { kind: "refused", reason }; }; try { const opened = api.open(pid); if (opened.value < 0) { close(); return opened.errno === ENOSYS ? { kind: "unsupported", reason: "pidfd_open is unsupported by this kernel" } : { kind: "refused", reason: `pidfd_open failed (errno ${opened.errno})` }; } fd = opened.value; if (!verify()) return refuse("PID ownership changed during pidfd acquisition"); // Check both syscall support and permission before arming, without sending a signal. const probe = api.signal(fd, 0); if (probe.value < 0) { close(); return probe.errno === ENOSYS ? { kind: "unsupported", reason: "pidfd_send_signal is unsupported by this kernel" } : { kind: "refused", reason: `pidfd signal check failed (errno ${probe.errno})` }; } if (!verify()) return refuse("PID ownership changed during pidfd verification"); return { kind: "bound", handle: { close, terminate: (signal = 9) => { if (closed || signalled) return "not_target"; // A throwing binding must settle the recorded intent as "failed", like process.kill does. let sent: CallResult; try { sent = api.signal(fd!, signal); } catch { return "failed"; } if (sent.value < 0) return sent.errno === ESRCH ? "not_target" : "failed"; if (signal === 9) signalled = true; return "terminated"; }, }, }; } catch { return refuse("Linux pidfd binding failed"); } }