@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
188 lines (172 loc) • 8.3 kB
text/typescript
import { spawn, spawnSync } from "node:child_process";
import { accessSync, constants, realpathSync, statSync } from "node:fs";
import { dirname, isAbsolute } from "node:path";
/**
* How to launch the dashboard update worker on POSIX.
*
* A worker spawned from the systemd user service stays in that service's cgroup even when
* detached, and the generated unit keeps the default `KillMode=control-group`. The updater then
* stops `opencodex-proxy.service` and systemd kills the worker with it, leaving the proxy offline
* on the old package (#5750). `systemd-run --user --scope` moves the worker into its own
* transient scope first; `--scope` execs the command in place, so the returned PID is still the
* worker's. Outside a systemd-started process (`INVOCATION_ID` unset), or when `systemd-run` is
* missing, the plain detached spawn is unchanged.
*/
export const SYSTEMD_SCOPE_ARGS = ["--user", "--scope", "--quiet", "--collect", "--"] as const;
export interface WorkerLaunchContext {
platform?: NodeJS.Platform;
env?: NodeJS.ProcessEnv;
resolveSystemdRun?: () => string | undefined;
}
// Absolute install paths only — PATH is never consulted, so a caller-controlled entry cannot
// redirect the launch. `/usr/local/bin` is where systemd lands when built or stowed outside the
// distro layout, and `/run/current-system/sw/bin` is the NixOS layout, where the binary lives
// nowhere else even though the user bus works. A candidate only counts when the binary and its
// directory are root-owned and not group/world-writable, so a lower-trust local actor cannot
// plant the launcher the scope probe execs.
const TRUSTED_SYSTEMD_RUN_PATHS = [
"/usr/bin/systemd-run", "/bin/systemd-run", "/usr/local/bin/systemd-run",
"/run/current-system/sw/bin/systemd-run",
] as const;
export interface SystemdRunHooks {
isExecutableFile: (path: string) => boolean;
probeScope: (path: string) => boolean;
/** Async variant of probeScope; resolveSystemdRunAsync prefers it when present. */
probeScopeAsync?: (path: string) => Promise<boolean>;
}
const GROUP_OR_WORLD_WRITE = 0o022;
// stat (follow) rather than lstat: a root-owned symlink to a user-writable directory must fail
// on the target's mode, not pass on the symlink's (mirrors isTrustedSystemPath in
// src/codex/desktop-app/linux.ts).
export interface SystemdRunTrustDeps {
/** Test seam: canonicalizes the candidate before its substitution chain is checked. */
realpathSync?: (path: string) => string;
/** Test seam: stats a resolved path for ownership and mode. */
statSync?: (path: string) => { isFile(): boolean; uid: number; mode: number };
/** Test seam: checks the candidate's executable bit. */
accessSync?: (path: string, mode: number) => void;
}
function rootOnlyWritable(path: string, stat: SystemdRunTrustDeps["statSync"] = statSync): boolean {
try {
const st = stat!(path);
return st.uid === 0 && (st.mode & GROUP_OR_WORLD_WRITE) === 0;
} catch {
return false;
}
}
// "Executable" here includes trust: the binary and its directory must be root-owned and not
// group/world-writable. /usr/local/bin is group-writable on some systems, and a planted or
// replaced systemd-run there would be exec'd by the scope probe under the service account;
// the fallback is the plain detached spawn, so nothing breaks when it is skipped.
// Exported for unit tests.
export function isTrustedSystemdRunFile(path: string, deps: SystemdRunTrustDeps = {}): boolean {
try {
if (!isAbsolute(path)) return false;
(deps.accessSync ?? accessSync)(path, constants.X_OK);
// The lexical path may be a symlink. Checking the link's own parent only proves
// the *entry* is pinned; the file it resolves to — and every ancestor able to
// substitute that resolved file — is what the scope probe will actually exec.
const realpath = deps.realpathSync ?? realpathSync;
const resolved = realpath(path);
const stat = deps.statSync ?? statSync;
const st = stat(resolved);
if (!(st.isFile() && st.uid === 0 && (st.mode & GROUP_OR_WORLD_WRITE) === 0)) {
return false;
}
for (const start of [dirname(path), dirname(resolved)]) {
for (let dir = start, previous = ""; dir !== previous; previous = dir, dir = dirname(dir)) {
if (!rootOnlyWritable(dir, stat)) return false;
}
}
return true;
} catch {
return false;
}
}
/** Scope discovery gets only user-bus identity, never inherited management credentials. */
function scopeProbeEnvironment(): NodeJS.ProcessEnv {
const env: NodeJS.ProcessEnv = { PATH: "/usr/bin:/bin" };
for (const name of ["HOME", "USER", "LOGNAME", "XDG_RUNTIME_DIR", "DBUS_SESSION_BUS_ADDRESS"]) {
if (process.env[name] !== undefined) env[name] = process.env[name];
}
return env;
}
const systemdRunHooks: SystemdRunHooks = {
isExecutableFile: isTrustedSystemdRunFile,
// Run a real scope with the same absolute binary as its harmless version payload.
// Probing only the outer --version would not verify the user bus.
probeScope: path => {
const probe = spawnSync(path, [...SYSTEMD_SCOPE_ARGS, path, "--version"], { stdio: "ignore", timeout: 5_000, env: scopeProbeEnvironment() });
return !probe.error && probe.status === 0;
},
probeScopeAsync: path => new Promise<boolean>(resolve => {
const probe = spawn(path, [...SYSTEMD_SCOPE_ARGS, path, "--version"], { stdio: "ignore", env: scopeProbeEnvironment() });
probe.unref();
const timer = setTimeout(() => {
try { probe.kill("SIGKILL"); } catch { /* failed termination is not a successful probe */ }
resolve(false);
}, 5_000);
timer.unref();
probe.once("error", () => { clearTimeout(timer); resolve(false); });
probe.once("close", code => { clearTimeout(timer); resolve(code === 0); });
}),
};
let systemdRunProbe: string | null | undefined;
let systemdRunProbePending: Promise<string | null> | undefined;
export function resolveSystemdRun(hooks: SystemdRunHooks = systemdRunHooks): string | undefined {
if (systemdRunProbe === undefined) {
systemdRunProbe = null;
for (const command of TRUSTED_SYSTEMD_RUN_PATHS) {
if (!hooks.isExecutableFile(command)) continue;
if (hooks.probeScope(command)) {
systemdRunProbe = command;
break;
}
}
}
return systemdRunProbe ?? undefined;
}
/**
* Management-request path variant. The synchronous resolver blocks the shared
* event loop for up to four sequential five-second scope probes on first use;
* the dashboard update route awaits this instead, so probing overlaps other
* requests. Concurrent first callers share one probe pass.
*/
export async function resolveSystemdRunAsync(hooks: SystemdRunHooks = systemdRunHooks): Promise<string | undefined> {
if (systemdRunProbe !== undefined) return systemdRunProbe ?? undefined;
if (!systemdRunProbePending) {
systemdRunProbePending = (async () => {
const probeScope = hooks.probeScopeAsync ?? (async (path: string) => hooks.probeScope(path));
for (const command of TRUSTED_SYSTEMD_RUN_PATHS) {
if (!hooks.isExecutableFile(command)) continue;
if (await probeScope(command)) {
return command;
}
}
return null;
})();
}
const found = await systemdRunProbePending;
// Honor a cache the sync resolver may have filled while the probe ran — the
// older observation wins so every caller converges on one launcher.
if (systemdRunProbe === undefined) systemdRunProbe = found;
return systemdRunProbe ?? undefined;
}
export function resetSystemdRunProbeForTests(): void {
systemdRunProbe = undefined;
systemdRunProbePending = undefined;
}
export function guiUpdateWorkerCommand(
execPath: string,
args: readonly string[],
context: WorkerLaunchContext = {},
): { command: string; argv: string[] } {
const platform = context.platform ?? process.platform;
const env = context.env ?? process.env;
const underSystemd = platform === "linux" && Boolean(env.INVOCATION_ID);
const systemdRun = underSystemd ? (context.resolveSystemdRun ?? resolveSystemdRun)() : undefined;
if (systemdRun) {
return { command: systemdRun, argv: [...SYSTEMD_SCOPE_ARGS, execPath, ...args] };
}
return { command: execPath, argv: [...args] };
}