@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
101 lines (92 loc) • 4.79 kB
text/typescript
import { realpathSync } from "node:fs";
import { dirname, isAbsolute, join } from "node:path";
import {
observePackageManifestAt,
packageManifestPathIn,
runningPackageRoot,
} from "../lib/package-tree-integrity";
import type { LauncherTarget, ResolveLauncherTarget } from "../lib/package-tree-retarget";
import { readServiceInstallState, SERVICE_MANAGED_ENV } from "../service/state";
import { detectInstallOwnershipFromPath, type InstallOwnership } from "./install-detection.mjs";
const PACKAGE_DIR = join("@bitkyc08", "opencodex");
/**
* The package launcher mise's npm backend creates in `<toolRoot>/<selector>/node_modules/.bin`,
* beside the package it starts. This is the layout `detectInstallOwnershipFromPath` verifies as
* mise-owned; a launcher in any other layout is not followed.
*/
const LAUNCHER_BIN = join("node_modules", ".bin");
const LAUNCHER_PACKAGE_DIR = join("node_modules", PACKAGE_DIR);
export interface MiseLauncherTargetDeps {
platform?: NodeJS.Platform;
env?: NodeJS.ProcessEnv;
ownership?: () => InstallOwnership;
launcherPath?: () => string | undefined;
runningRoot?: () => string;
realpath?: (path: string) => string;
}
export interface MiseLauncherTargetWatchPlan {
runningRoot: string;
resolveTarget: ResolveLauncherTarget;
}
function canonical(path: string, realpath: (path: string) => string): string | null {
try {
return realpath(path);
} catch {
return null;
}
}
/**
* Map a recorded service launcher to the package directory it starts, when it is one of mise's
* own package launchers for this tool. A mise shim (`<data>/shims/ocx`) resolves to the mise
* binary and names no package, and anything outside `<toolRoot>/<selector>/` is not a launcher
* this install owns, so both are unsupported and return null.
*/
function launcherPackageEntry(launcherPath: string, toolRoot: string, realpath: (path: string) => string): string | null {
if (!isAbsolute(launcherPath)) return null;
const binDir = dirname(launcherPath);
const canonicalToolRoot = canonical(toolRoot, realpath);
if (canonicalToolRoot === null) return null;
if (!binDir.endsWith(`/${LAUNCHER_BIN}`)) return null;
const selectorDir = binDir.slice(0, binDir.length - LAUNCHER_BIN.length - 1);
if (canonical(dirname(selectorDir), realpath) !== canonicalToolRoot) return null;
return join(selectorDir, LAUNCHER_PACKAGE_DIR);
}
/**
* Decide whether this process should watch its service launcher for a mise upgrade, and build the
* resolver when it should.
*
* Eligible only when every one of these holds:
* - Linux. launchd services always run pinned package paths (see the stable-launcher contract),
* and Windows services have no launcher, so neither can follow a moved `latest` link.
* - The process is the managed service job itself (`OCX_SERVICE_MANAGED=1`). `OCX_SERVICE=1`
* alone is also set on proxies `ocx claude`/`ocx opencode` spawn, and a foreground proxy must
* never restart itself because a service record exists.
* - The running package has a verified mise owner, and the recorded launcher is one of that
* tool's package launchers.
* - At boot, the launcher resolves to exactly the running package. That proves the supervisor
* started this process through it, so a restart through it converges instead of looping.
*/
export function planMiseLauncherTargetWatch(deps: MiseLauncherTargetDeps = {}): MiseLauncherTargetWatchPlan | null {
if ((deps.platform ?? process.platform) !== "linux") return null;
if ((deps.env ?? process.env)[SERVICE_MANAGED_ENV] !== "1") return null;
const realpath = deps.realpath ?? realpathSync;
const runningRoot = canonical((deps.runningRoot ?? runningPackageRoot)(), realpath);
if (runningRoot === null) return null;
const ownership = (deps.ownership ?? (() => detectInstallOwnershipFromPath(runningRoot)))();
if (ownership.installer !== "mise" || !ownership.owner) return null;
const owner = ownership.owner;
const launcherPath = (deps.launcherPath ?? (() => readServiceInstallState()?.launcherPath))();
if (!launcherPath) return null;
const entry = launcherPackageEntry(launcherPath, owner.toolRoot, realpath);
const toolRoot = canonical(owner.toolRoot, realpath);
if (entry === null || toolRoot === null) return null;
const resolveTarget = (): LauncherTarget | null => {
const root = canonical(entry, realpath);
// A floating link repointed outside this tool's installs is not a mise upgrade of it.
if (root === null || !root.startsWith(`${toolRoot}/`)) return null;
const manifest = observePackageManifestAt(packageManifestPathIn(root));
return manifest === null ? null : { root, manifest };
};
if (resolveTarget()?.root !== runningRoot) return null;
return { runningRoot, resolveTarget };
}