@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
196 lines (187 loc) • 9.09 kB
text/typescript
/** Read-only manager-to-proxy binding for consent-bound desktop stops. */
import { execFileSync } from "node:child_process";
import { resolve } from "node:path";
import { verifyPidIdentity } from "../config/process-state";
import { statusWinswRaw } from "../lib/winsw";
import { systemdProperty } from "../service-manager-probe";
import { expectedLaunchdCommand, launchdEvictionTargets, probeLaunchdLoadState, runLaunchctl } from "./launchd";
import { probeSystemdUnitInactive, unitPath } from "./systemd";
import {
inspectWindowsGuardedManager,
observeWindowsGuardedManagerStopped,
type WindowsGuardedManagerDeps,
} from "./windows-guarded-manager";
import { probeWindowsSchedulerTask } from "./windows-scheduler";
import { TASK } from "./state";
export type GuardedManagerTarget =
| { kind: "absent" }
| {
kind: "bound";
pid: number;
managerPid: number;
backend: "launchd" | "systemd" | "scheduler" | "winsw";
/**
* Whether stopping this manager can leave the approved process alive.
* launchd/systemd end their job's whole process tree; Windows Task
* Scheduler's /end does not reliably cascade to the wrapper's child (#764),
* so a bound scheduler or WinSW manager still needs the approved PID
* signalled separately after the manager is stopped.
*/
childNeedsSeparateStop: boolean;
}
| {
/**
* Windows only (#7771): the registered OpenCodex task is not running, but wrappers
* that the checked stop's binding rule ties to the approved PID survive. Provable,
* so it reaches Part A; revalidation compares the bound wrapper set.
*/
kind: "bound-stray";
pid: number;
backend: "scheduler";
wrappers: { pid: number; startTime: number }[];
childNeedsSeparateStop: true;
}
| {
kind: "unknown";
reason: string;
/** The additive ocx-stop/1 serviceStopReason when the binding rule names one. */
stopReason?: "unbound-wrapper" | "evidence-unreadable";
};
export type GuardedManagerStopped = "inactive" | "active" | "unknown";
export function managerOwnsApprovedPid(
managerPid: number,
approvedPid: number,
parentOf: (pid: number) => number | null,
): boolean {
let current = approvedPid;
const seen = new Set<number>();
for (let depth = 0; depth < 16; depth += 1) {
if (current === managerPid) return true;
if (!Number.isSafeInteger(current) || current <= 0 || seen.has(current)) return false;
seen.add(current);
const parent = parentOf(current);
if (parent === null || !Number.isSafeInteger(parent) || parent <= 0) return false;
current = parent;
}
return false;
}
function parentPid(pid: number): number | null {
try {
const raw = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
encoding: "utf8", timeout: 2_000, stdio: ["ignore", "pipe", "pipe"],
}).trim();
const value = Number(raw);
return /^\d+$/.test(raw) && Number.isSafeInteger(value) && value > 0 ? value : null;
} catch { return null; }
}
function positivePid(raw: string | null | undefined): number | null {
if (!raw || !/^\d+$/.test(raw)) return null;
const pid = Number(raw);
return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
}
export interface GuardedManagerDeps {
platform?: NodeJS.Platform;
launchctl?: typeof runLaunchctl;
expectedCommand?: (port: number) => string;
systemdShow?: () => string;
parentOf?: (pid: number) => number | null;
verifyPid?: (pid: number) => number | null;
scheduler?: typeof probeWindowsSchedulerTask;
winsw?: typeof statusWinswRaw;
win?: WindowsGuardedManagerDeps;
}
/** Only one current manager with a verified parent chain may be stopped by name. */
export function inspectGuardedManagerTarget(
approvedPid: number,
approvedPort: number,
deps: GuardedManagerDeps = {},
): GuardedManagerTarget {
const platform = deps.platform ?? process.platform;
if ((deps.verifyPid ?? verifyPidIdentity)(approvedPid) !== approvedPid) {
return { kind: "unknown", reason: "approved process identity could not be verified" };
}
const parentOf = deps.parentOf ?? parentPid;
if (platform === "darwin") {
const run = deps.launchctl ?? runLaunchctl;
let managerPid: number | null = null;
try {
const expected = (deps.expectedCommand ?? expectedLaunchdCommand)(approvedPort);
for (const target of launchdEvictionTargets()) {
const result = run(["print", target]);
if (result.status === 112 || result.status === 113) continue;
if (result.status !== 0) return { kind: "unknown", reason: "launchd state is unreadable" };
if (managerPid !== null) return { kind: "unknown", reason: "multiple launchd jobs are loaded" };
const output = `${result.stdout}\n${result.stderr}`;
if (!output.includes(expected)) return { kind: "unknown", reason: "launchd command differs from registration" };
const pids = [...output.matchAll(/^\s*pid\s*=\s*(\d+)\s*$/gm)];
if (pids.length !== 1) return { kind: "unknown", reason: "launchd PID is ambiguous" };
managerPid = positivePid(pids[0]?.[1]);
if (managerPid === null) return { kind: "unknown", reason: "launchd PID is invalid" };
}
} catch { return { kind: "unknown", reason: "launchd state could not be verified" }; }
if (managerPid === null) return { kind: "absent" };
return managerOwnsApprovedPid(managerPid, approvedPid, parentOf)
? { kind: "bound", pid: approvedPid, managerPid, backend: "launchd", childNeedsSeparateStop: false }
: { kind: "unknown", reason: "launchd job does not own the approved process" };
}
if (platform === "linux") {
try {
const output = (deps.systemdShow ?? (() => execFileSync("systemctl", ["--user", "show", "-p", "LoadState", "-p", "ActiveState", "-p", "MainPID", "-p", "FragmentPath", "-p", "NeedDaemonReload", TASK], {
encoding: "utf8", timeout: 2_000, stdio: ["ignore", "pipe", "pipe"],
})))();
const loaded = systemdProperty(output, "LoadState");
const active = systemdProperty(output, "ActiveState");
const pid = positivePid(systemdProperty(output, "MainPID"));
if (loaded === "not-found" && active === "inactive") return { kind: "absent" };
if (loaded === "loaded" && active === "inactive" && systemdProperty(output, "MainPID") === "0") return { kind: "absent" };
if (loaded !== "loaded" || active !== "active" || pid === null
|| systemdProperty(output, "NeedDaemonReload") !== "no"
|| resolve(systemdProperty(output, "FragmentPath") ?? "") !== resolve(unitPath())) {
return { kind: "unknown", reason: "systemd unit state is not current and active" };
}
return managerOwnsApprovedPid(pid, approvedPid, parentOf)
? { kind: "bound", pid: approvedPid, managerPid: pid, backend: "systemd", childNeedsSeparateStop: false }
: { kind: "unknown", reason: "systemd unit does not own the approved process" };
} catch { return { kind: "unknown", reason: "systemd state could not be verified" }; }
}
if (platform === "win32") {
const scheduler = (deps.scheduler ?? probeWindowsSchedulerTask)();
const native = (deps.winsw ?? statusWinswRaw)();
// A simulated win32 (deps.platform injected) must not run real schtasks or
// process-list queries at the host; the module degrades every unset probe to
// its least-proving answer then, which is exactly the old fail-closed shape.
return inspectWindowsGuardedManager(
approvedPid, scheduler, native, deps.win ?? {}, deps.platform === undefined,
);
}
return { kind: "unknown", reason: "unsupported service manager platform" };
}
/** A guarded success needs manager absence after settlement and once more at publication. */
export async function observeGuardedManagerStopped(
manager: Exclude<GuardedManagerTarget, { kind: "unknown" }>,
deps: Pick<GuardedManagerDeps, "platform" | "scheduler" | "winsw" | "win"> & {
launchd?: typeof probeLaunchdLoadState;
systemd?: typeof probeSystemdUnitInactive;
} = {},
): Promise<GuardedManagerStopped> {
try {
const platform = deps.platform ?? process.platform;
if (platform === "darwin") {
const state = (deps.launchd ?? probeLaunchdLoadState)().state;
return state === "not-loaded" ? "inactive" : state === "unknown" ? "unknown" : "active";
}
if (platform === "linux") return (deps.systemd ?? probeSystemdUnitInactive)();
if (platform === "win32") {
// Registration presence is not the question: schtasks /end leaves the task
// registered forever, so the Windows check is RUNNING state + surviving
// wrapper processes + WinSW status, never mere presence.
return observeWindowsGuardedManagerStopped({
scheduler: deps.scheduler,
winsw: deps.winsw,
...(deps.win ?? {}),
...(manager.kind === "bound" ? { formerManagerPid: manager.managerPid } : {}),
}, deps.platform === undefined);
}
} catch { return "unknown"; }
return "unknown";
}