@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
165 lines (153 loc) • 6.94 kB
text/typescript
import { createHash } from "node:crypto";
import { isAbsolute } from "node:path";
import { parseStrictSemver } from "../lib/strict-semver";
import type {
ServiceInstallState,
ServiceOwnershipSubject,
} from "./state";
import {
SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
SERVICE_OWNERSHIP_PROTOCOL_VERSION,
} from "./install-state-contract.mjs";
export type ManagingCliRole = "service-registration" | "path";
export type ManagingCliObservation =
| { readonly status: "absent" }
| { readonly status: "unknown"; readonly reason: string }
| { readonly status: "observed"; readonly version: string; readonly identity: string };
export type RegisteredManagingCliInvocation =
| { readonly status: "absent" }
| { readonly status: "unknown"; readonly reason: string }
| { readonly status: "resolved"; readonly executable: string; readonly args: readonly string[] };
/** Resolve the exact command baked into the preserved service registration. */
export function registeredManagingCliInvocation(
state: ServiceInstallState | null,
): RegisteredManagingCliInvocation {
if (!state) return { status: "absent" };
if (state.launcherPath) {
return isAbsolute(state.launcherPath)
? { status: "resolved", executable: state.launcherPath, args: [] }
: { status: "unknown", reason: "the recorded service launcher is not absolute" };
}
if (!state.bunPath || !isAbsolute(state.bunPath)) {
return { status: "unknown", reason: "the registered service executable is missing or not absolute" };
}
if (state.cliPath === null) return { status: "resolved", executable: state.bunPath, args: [] };
if (typeof state.cliPath === "string" && isAbsolute(state.cliPath)) {
return { status: "resolved", executable: state.bunPath, args: [state.cliPath] };
}
return { status: "unknown", reason: "the registered service CLI path is missing or not absolute" };
}
export interface ServiceTakeoverCompatibilityInput {
readonly state: ServiceInstallState | null;
readonly subject: ServiceOwnershipSubject;
readonly managers: Readonly<Record<ManagingCliRole, ManagingCliObservation>>;
}
export type ServiceTakeoverCompatibility =
| {
readonly kind: "supported";
readonly protocolVersion: typeof SERVICE_OWNERSHIP_PROTOCOL_VERSION;
readonly minimumCliVersion: typeof SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION;
/** Opaque binding over the approved subject and both managing-CLI observations. */
readonly token: string;
}
| {
readonly kind: "blocked";
readonly reason:
| "managing-cli-unknown"
| "managing-cli-unsupported"
| "managing-cli-unobserved"
| "service-protocol-unsupported";
readonly detail: string;
readonly minimumCliVersion: typeof SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION;
};
function comparePrerelease(left: readonly (bigint | string)[], right: readonly (bigint | string)[]): number {
if (left.length === 0 || right.length === 0) return left.length === right.length ? 0 : left.length === 0 ? 1 : -1;
for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
const a = left[index];
const b = right[index];
if (a === undefined || b === undefined) return a === b ? 0 : a === undefined ? -1 : 1;
if (a === b) continue;
if (typeof a === "bigint" && typeof b === "bigint") return a < b ? -1 : 1;
if (typeof a === "bigint") return -1;
if (typeof b === "bigint") return 1;
return a < b ? -1 : 1;
}
return 0;
}
function versionSupportsOwnership(value: string): boolean {
const actual = parseStrictSemver(value);
const minimum = parseStrictSemver(SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION);
if (!actual || !minimum) return false;
for (let index = 0; index < actual.core.length; index += 1) {
if (actual.core[index] !== minimum.core[index]) return actual.core[index]! > minimum.core[index]!;
}
return comparePrerelease(actual.prerelease, minimum.prerelease) >= 0;
}
function compatibilityToken(input: ServiceTakeoverCompatibilityInput): string {
return createHash("sha256").update(JSON.stringify({
subject: input.subject,
protocolVersion: input.state?.ownershipProtocolVersion ?? null,
managers: {
"service-registration": input.managers["service-registration"],
path: input.managers.path,
},
})).digest("hex");
}
/**
* Decide whether permanent desktop ownership can be offered.
*
* Both managing surfaces are mandatory observations. `absent` is a trustworthy answer;
* `unknown` is not. An observed service registration additionally needs the protocol marker
* written by a CLI whose start/repair/update paths honor the ownership claim. This is what
* keeps the preserved registration from starting an older runtime at the next login.
*/
export function assessServiceTakeoverCompatibility(
input: ServiceTakeoverCompatibilityInput,
): ServiceTakeoverCompatibility {
const observed = Object.entries(input.managers) as Array<[ManagingCliRole, ManagingCliObservation]>;
const unknown = observed.find(([, manager]) => manager.status === "unknown");
if (unknown) return {
kind: "blocked",
reason: "managing-cli-unknown",
detail: `${unknown[0]} compatibility could not be determined`,
minimumCliVersion: SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
};
const present = observed.filter(([, manager]) => manager.status === "observed") as Array<[
ManagingCliRole,
Extract<ManagingCliObservation, { status: "observed" }>,
]>;
if (present.length === 0) return {
kind: "blocked",
reason: "managing-cli-unobserved",
detail: "no managing OpenCodex CLI installation was observed",
minimumCliVersion: SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
};
const unsupported = present.find(([, manager]) => !versionSupportsOwnership(manager.version));
if (unsupported) return {
kind: "blocked",
reason: "managing-cli-unsupported",
detail: `${unsupported[0]} uses OpenCodex ${unsupported[1].version}; ${SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION} or later is required`,
minimumCliVersion: SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
};
if (input.managers["service-registration"].status === "observed"
&& input.state?.ownershipProtocolVersion !== SERVICE_OWNERSHIP_PROTOCOL_VERSION) {
return {
kind: "blocked",
reason: "service-protocol-unsupported",
detail: "the preserved service registration was not written by an ownership-aware CLI",
minimumCliVersion: SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
};
}
return {
kind: "supported",
protocolVersion: SERVICE_OWNERSHIP_PROTOCOL_VERSION,
minimumCliVersion: SERVICE_OWNERSHIP_MINIMUM_CLI_VERSION,
token: compatibilityToken(input),
};
}
export function sameServiceTakeoverCompatibility(
left: ServiceTakeoverCompatibility,
right: ServiceTakeoverCompatibility,
): boolean {
return left.kind === "supported" && right.kind === "supported" && left.token === right.token;
}