UNPKG

@bitkyc08/opencodex

Version:

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

219 lines (200 loc) • 8.56 kB
/** * Process and workspace lifetime for one `agy acp` turn. * * Each turn gets a fresh directory outside the OpenCodex home. It has mode 0700 on POSIX and a * private NTFS ACL on Windows, with its own temp directory. The CLI's request-review permission * engine scopes file access to this workspace, which serves as both the spawn and session cwd. * POSIX signals the child's group and waits for leader exit and group disappearance. Windows * requires a successful System32 taskkill /T /F while the leader is alive and leader closure. */ import { execFile, spawn, type ChildProcess } from "node:child_process"; import { chmod, mkdir, mkdtemp, realpath, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { isAbsolute, join, relative, sep } from "node:path"; import { forgetEphemeralSecretDir, hardenSecretDirAsync, windowsSecretAclApplies } from "../../lib/windows-secret-acl"; export interface TurnWorkspace { dir: string; tmp: string; remove(): Promise<void> } export class AgyAcpCleanupError extends Error {} export class AgyAcpWorkspaceCleanupError extends AgyAcpCleanupError { constructor() { super("Antigravity ACP could not remove its private workspace."); } } function isInside(child: string, parent: string): boolean { const rel = relative(parent, child); return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel); } /** A fresh private workspace outside `home`; throws when the temp root resolves inside it. */ export async function createTurnWorkspace(home: string, tempRoot = tmpdir()): Promise<TurnWorkspace> { const root = await realpath(tempRoot); let homeReal = home; try { homeReal = await realpath(home); } catch { /* a missing home cannot contain the workspace */ } if (isInside(root, homeReal)) throw new Error("agy acp workspace would be inside the OpenCodex home"); const created = await mkdtemp(join(root, "ocx-agy-acp-")); let aclDir: string | undefined; const remove = async (): Promise<void> => { try { await rm(created, { recursive: true, force: true, maxRetries: 2 }); } catch { const error = new AgyAcpWorkspaceCleanupError(); console.warn(error.message); throw error; } if (aclDir) forgetEphemeralSecretDir(aclDir); }; try { const dir = await realpath(created); if (isInside(dir, homeReal)) throw new Error("agy acp workspace would be inside the OpenCodex home"); if (windowsSecretAclApplies()) { aclDir = dir; const acl = await hardenSecretDirAsync(dir, { required: true }); if (!acl.ok) throw new Error("agy acp could not harden the workspace ACL"); } else { await chmod(dir, 0o700); } const tmp = join(dir, ".tmp"); await mkdir(tmp, { mode: 0o700 }); return { dir, tmp, remove }; } catch (error) { // Rollback reports its own fixed warning. The caller still receives the original setup error. await remove().catch(() => {}); throw error; } } export type AgyAcpChild = Pick<ChildProcess, "stdin" | "stdout" | "stderr" | "pid" | "exitCode" | "signalCode" | "kill" | "on" | "once">; export type AgyAcpSpawn = (binary: string, args: string[], options: { cwd: string; env: Record<string, string> }) => AgyAcpChild; const NO_PROCESS_SPAWN_ERRORS = new Set(["ENOENT", "EACCES", "EPERM", "ENOEXEC", "EMFILE", "ENFILE", "EAGAIN", "ENOMEM"]); /** A failed spawn with no assigned PID has no owned process to reap. */ export function agySpawnCreatedNoProcess(child: AgyAcpChild, error: NodeJS.ErrnoException): boolean { return child.pid === undefined && error.code !== undefined && NO_PROCESS_SPAWN_ERRORS.has(error.code); } export const defaultAgyAcpSpawn: AgyAcpSpawn = (binary, args, options) => spawn(binary, args, { ...options, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, shell: false, detached: process.platform !== "win32", }); export interface ReapOptions { graceMs: number; reapTimeoutMs: number; platform?: NodeJS.Platform; signalGroup?: (pid: number, signal: NodeJS.Signals | 0) => void; killWindowsTree?: (pid: number, completed: (ok: boolean) => void) => void; warnTreeFailure?: () => void; setTimeout?: typeof setTimeout; clearTimeout?: typeof clearTimeout; } function defaultKillWindowsTree(pid: number, completed: (ok: boolean) => void): void { const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`; execFile(taskkill, ["/PID", String(pid), "/T", "/F"], { windowsHide: true, timeout: 5_000 }, error => completed(!error)); } const GROUP_POLL_MS = 25; export class AgyAcpTreeCleanupError extends AgyAcpCleanupError { constructor(readonly platform = process.platform) { super(platform === "win32" ? "Antigravity ACP could not confirm Windows process tree cleanup." : "Antigravity ACP could not confirm POSIX process tree cleanup."); } } /** Reject unless the owned process tree is confirmed gone within the deadline. */ export function reapProcessTree(child: AgyAcpChild, options: ReapOptions): Promise<void> { const set = options.setTimeout ?? setTimeout; const clear = options.clearTimeout ?? clearTimeout; const platform = options.platform ?? process.platform; const pid = child.pid; const signalGroup = options.signalGroup ?? ((target: number, signal: NodeJS.Signals | 0) => process.kill(-target, signal)); const signalLeader = (sig: NodeJS.Signals): void => { if (child.exitCode !== null || child.signalCode !== null) return; try { child.kill(sig); } catch { /* best effort only */ } }; const unconfirmed = (): AgyAcpTreeCleanupError => { const error = new AgyAcpTreeCleanupError(platform); if (options.warnTreeFailure) options.warnTreeFailure(); else console.warn(error.message); return error; }; const leaderGone = child.exitCode !== null || child.signalCode !== null; if (pid === undefined) return Promise.reject(unconfirmed()); if (platform === "win32") { if (leaderGone) return Promise.reject(unconfirmed()); return new Promise<void>((resolve, reject) => { let treeKilled = false; let leaderClosed = false; let settled = false; const finish = (confirmed: boolean): void => { if (settled) return; settled = true; clear(deadline); if (confirmed) { resolve(); return; } const error = unconfirmed(); if (!leaderClosed) signalLeader("SIGKILL"); reject(error); }; const deadline = set(() => finish(false), options.reapTimeoutMs); child.once("close", () => { leaderClosed = true; if (treeKilled) finish(true); }); try { (options.killWindowsTree ?? defaultKillWindowsTree)(pid, ok => { if (!ok) return finish(false); treeKilled = true; if (leaderClosed) finish(true); }); } catch { finish(false); } }); } const noSuchGroup = (error: unknown): boolean => (error as NodeJS.ErrnoException | undefined)?.code === "ESRCH"; return new Promise<void>((resolve, reject) => { let leaderExited = leaderGone; let groupSignalled = false; let settled = false; let pollTimer: ReturnType<typeof setTimeout> | undefined; const finish = (confirmed: boolean): void => { if (settled) return; settled = true; clear(grace); clear(deadline); if (pollTimer !== undefined) clear(pollTimer); if (confirmed) { resolve(); } else { if (!leaderExited) signalLeader("SIGKILL"); reject(unconfirmed()); } }; const pollGroup = (): void => { try { signalGroup(pid, 0); } catch (error) { return finish(noSuchGroup(error)); } pollTimer = set(pollGroup, GROUP_POLL_MS); }; const killGroup = (): void => { if (settled) return; if (!groupSignalled) { try { signalGroup(pid, "SIGKILL"); } catch (error) { if (!noSuchGroup(error)) return finish(false); } groupSignalled = true; } if (leaderExited) pollGroup(); }; const onExit = (): void => { if (leaderExited) return; leaderExited = true; clear(grace); killGroup(); }; const grace = set(killGroup, options.graceMs); const deadline = set(() => finish(false), options.reapTimeoutMs); if (leaderExited) { clear(grace); killGroup(); } else { child.once("exit", onExit); child.once("close", onExit); try { signalGroup(pid, "SIGTERM"); } catch { signalLeader("SIGTERM"); } } }); }