UNPKG

@bitkyc08/opencodex

Version:

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

245 lines (225 loc) • 11 kB
import { readFileSync } from "node:fs"; import { execFileSync, execSync } from "node:child_process"; import { existsSync, mkdirSync, unlinkSync } from "node:fs"; import { homedir } from "node:os"; import { join } from "node:path"; import { getConfigDir } from "../config"; import { BUN_RUNTIME_PATH_ENV, BUN_RUNTIME_SOURCE_ENV, durableBunRuntime, type DurableBunRuntime } from "../lib/bun-runtime"; import { recordOwnedConfigPath } from "../lib/config-ownership"; import { systemdProperty } from "../service-manager-probe"; import { writeServiceApiTokenFile, sh } from "./guards"; import { shellQuote, buildServiceShellCommand, buildServiceLauncherShellCommand, resolvedProxyEnv } from "./health"; import type { ServiceInstallCleanupOps } from "./orchestration"; import { SERVICE_MANAGED_ENV, TASK, cliEntry, filterTransientServicePath, stableLauncherEntry, logPath, serviceStatePath, currentCodexSqliteHomeAbsolute, writeServiceInstallState } from "./state"; import { writeServiceDefinitionFile } from "./windows-ops"; /** The `--port <n>` baked into the installed systemd user unit. Linux only. */ export function systemdListenPort(deps: { readUnit?: () => string } = {}): number | null { try { const text = (deps.readUnit ?? (() => readFileSync(unitPath(), "utf8")))(); const last = [...text.matchAll(/start --port (\d{1,5})(?:\s|"|$)/gm)].at(-1); if (!last) return null; const n = Number(last[1]); return n > 0 && n <= 65535 ? n : null; } catch { return null; } } function systemdQuote(value: string): string { return `"${value .replace(/\\/g, "\\\\") .replace(/"/g, "\\\"") .replace(/%/g, "%%") .replace(/\n/g, "\\n")}"`; } function systemdEnvironmentAssignment(name: string, value: string | undefined): string | null { if (!value) return null; return `Environment=${systemdQuote(`${name}=${value}`)}`; } // ── Linux (systemd user unit) ── function unitDir(): string { return join(homedir(), ".config", "systemd", "user"); } export function unitPath(): string { return join(unitDir(), `${TASK}.service`); } export function buildUnit( proxyEnv: { name: string; value: string }[] = resolvedProxyEnv(), deps: { launcher?: string | null; runtime?: DurableBunRuntime } = {}, ): string { const runtime = deps.runtime ?? durableBunRuntime(); const { bun, bunRuntimeSource, cli } = cliEntry(runtime); // Discovery belongs to installSystemd(), which resolves once and passes the same value to // both the unit and install state. Keeping this builder explicit makes tests and diagnostics // independent of the host PATH. const launcher = deps.launcher ?? null; const log = logPath(); const path = filterTransientServicePath(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", ":", "linux"); const codexHome = systemdEnvironmentAssignment("CODEX_HOME", process.env.CODEX_HOME?.trim()); const codexSqliteHome = systemdEnvironmentAssignment("CODEX_SQLITE_HOME", currentCodexSqliteHomeAbsolute()); const opencodexHome = systemdEnvironmentAssignment("OPENCODEX_HOME", process.env.OPENCODEX_HOME?.trim()); const envLines = [ systemdEnvironmentAssignment("OCX_SERVICE", "1"), systemdEnvironmentAssignment(SERVICE_MANAGED_ENV, "1"), ...(launcher ? [] : [ systemdEnvironmentAssignment(BUN_RUNTIME_SOURCE_ENV, bunRuntimeSource), systemdEnvironmentAssignment(BUN_RUNTIME_PATH_ENV, bun), ]), // A launcher normally resolves the current package's bundled Bun after every upgrade. // Preserve only a proof-bound shell override; otherwise writing a package-local path here // would recreate the version-manager pin that the launcher mode exists to remove. launcher && runtime.source === "override" ? systemdEnvironmentAssignment(runtime.overrideEnv, runtime.path) : null, systemdEnvironmentAssignment("PATH", path), codexHome, codexSqliteHome, opencodexHome, ...proxyEnv.map(({ name, value }) => systemdEnvironmentAssignment(name, value)), ].filter((line): line is string => Boolean(line)).join("\n"); const command = `${launcher ? buildServiceLauncherShellCommand(launcher) : buildServiceShellCommand(bun, cli)} >> ${shellQuote(log)} 2>&1`; return `[Unit] Description=OpenCodex Proxy Server After=network-online.target Wants=network-online.target [Service] Type=simple ExecStart=${systemdQuote("/bin/sh")} -lc ${systemdQuote(command)} Restart=on-failure RestartSec=5 ${envLines} [Install] WantedBy=default.target `; } /** The per-user runtime dir systemd creates (holds the user-bus socket), or null. */ function userRuntimeDir(): string | null { const fromEnv = process.env.XDG_RUNTIME_DIR; if (fromEnv && existsSync(fromEnv)) return fromEnv; if (typeof process.getuid === "function") { const candidate = `/run/user/${process.getuid()}`; if (existsSync(candidate)) return candidate; } return null; } /** * SSH sessions frequently start without `XDG_RUNTIME_DIR`/`DBUS_SESSION_BUS_ADDRESS`, so * `systemctl --user` can't find the user bus even when systemd is running. Point `XDG_RUNTIME_DIR` * at the per-user runtime dir when it exists so the `--user` probe and install commands reach the * bus. No-op when already set or when no runtime dir exists (e.g. genuinely non-systemd hosts). */ function ensureUserBusEnv(): void { if (process.env.XDG_RUNTIME_DIR) return; const dir = userRuntimeDir(); if (dir) process.env.XDG_RUNTIME_DIR = dir; } export function isSystemd(): boolean { try { execSync("systemctl --version", { stdio: "pipe" }); } catch { return false; } ensureUserBusEnv(); // Prefer the user-bus probe; but an SSH session without a user D-Bus fails it even when systemd // is present (F9). Fall back to the per-user runtime dir existing — a strong signal the user // systemd instance is available — so a first-time `ocx service install` isn't wrongly refused. try { execSync("systemctl --user show-environment", { stdio: "pipe" }); return true; } catch { /* no user bus in this session */ } return userRuntimeDir() !== null; } export function installSystemd(): void { ensureUserBusEnv(); // reach the user bus over a bare SSH session (F9) const dir = unitDir(); if (!existsSync(dir)) mkdirSync(dir, { recursive: true }); recordOwnedConfigPath(getConfigDir(), serviceStatePath()); if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true }); writeServiceApiTokenFile(); // Resolve ONCE and reuse: the unit and the install state must agree about what is // launched, or the staleness check would validate a path the unit does not run. const launcher = stableLauncherEntry(); writeServiceDefinitionFile(unitPath(), buildUnit(resolvedProxyEnv(), { launcher }), "utf8"); sh("systemctl --user daemon-reload"); sh(`systemctl --user enable ${TASK}`); sh(`systemctl --user restart ${TASK}`); writeServiceInstallState("scheduler", launcher); } /** * Whether systemd's in-memory unit differs from the file on disk. * * The systemd analogue of launchd's stale-plist case: writing * `~/.config/systemd/user/<unit>` does not change the definition systemd has loaded * until `daemon-reload`, so a plain `systemctl start` would run the PREVIOUS * ExecStart. `NeedDaemonReload` is a per-unit property emitted as a bare * `NeedDaemonReload=yes|no` line; pass the unit name or `show` reports the manager's * own property instead, which answers a different question. * * Fail-open: if the query cannot run (no user bus, unit absent) we must not block a * start that would otherwise work. */ export function systemdNeedsDaemonReload(deps: { show?: () => string } = {}): boolean { try { const out = (deps.show ?? (() => sh(`systemctl --user show -p NeedDaemonReload ${TASK}`)))(); return /NeedDaemonReload\s*=\s*yes/i.test(out); } catch { return false; } } export function startSystemd(): void { ensureUserBusEnv(); if (!existsSync(unitPath())) { console.error(`opencodex service is not installed: ${unitPath()}`); console.error("Run `ocx service install` first to create and enable the systemd user unit."); process.exit(1); } // The unit on disk may be newer than what systemd loaded; starting now would run // the previous definition. // // `start` alone is not enough after a reload: it is a no-op on an already-active // unit, so the stale process would keep running the old ExecStart. NeedDaemonReload // compares disk against loaded, never loaded against running, so the only way to // make the running process match the file is to restart it. if (systemdNeedsDaemonReload()) { console.log("ℹ️ unit file changed on disk; reloading systemd and restarting the service."); sh("systemctl --user daemon-reload"); sh(`systemctl --user restart ${TASK}`); return; } sh(`systemctl --user start ${TASK}`); } export function stopSystemd(): void { try { sh(`systemctl --user stop ${TASK}`); } catch { /* not running */ } } export function statusSystemd(): string { try { return sh(`systemctl --user status ${TASK}`); } catch { return ""; } } /** Strict user-unit inactivity proof for guarded desktop takeover. */ export function probeSystemdUnitInactive(deps: { show?: () => string } = {}): "inactive" | "active" | "unknown" { try { const output = (deps.show ?? (() => execFileSync("systemctl", ["--user", "show", "-p", "ActiveState", "-p", "MainPID", TASK], { encoding: "utf8", timeout: 2_000, stdio: ["ignore", "pipe", "pipe"], })))(); const active = systemdProperty(output, "ActiveState")?.toLowerCase(); const pid = systemdProperty(output, "MainPID"); if (active === "inactive" && pid === "0") return "inactive"; if (["active", "activating", "deactivating", "reloading"].includes(active ?? "") || (pid !== null && /^\d+$/.test(pid) && Number(pid) > 0)) return "active"; return "unknown"; } catch { return "unknown"; } } export function uninstallSystemd(deps: { run?: (command: string) => string; unitExists?: () => boolean; removeUnit?: () => void; } = {}): void { const run = deps.run ?? sh; try { run(`systemctl --user stop ${TASK}`); } catch { /* not running */ } try { run(`systemctl --user disable ${TASK}`); } catch { /* absent */ } if ((deps.unitExists ?? (() => existsSync(unitPath())))()) { (deps.removeUnit ?? (() => unlinkSync(unitPath())))(); } try { run("systemctl --user daemon-reload"); } catch { /* best-effort */ } } export function systemdServiceInstallCleanupOps(deps: { run?: (command: string) => string; } = {}): ServiceInstallCleanupOps { const run = deps.run ?? sh; return { status: () => { const output = run(`systemctl --user show -p LoadState ${TASK}`); const loadState = systemdProperty(output, "LoadState")?.toLowerCase(); if (!loadState) throw new Error("systemd service status could not be verified."); return loadState === "not-found" ? null : loadState; }, stop: () => { run(`systemctl --user stop ${TASK}`); }, }; }