UNPKG

@bitkyc08/opencodex

Version:

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

136 lines (129 loc) • 6.03 kB
import { resolveServiceOwnership } from "../service"; import type { ServiceOwnershipResolution } from "../service"; import { serviceStatePaths } from "../service/state"; import { acquireOwnershipMutationLease, OWNERSHIP_MUTATION_LEASE_TOKEN_ENV, } from "../service/ownership-mutation-lease.mjs"; import { planUpdateRuntimeHandling } from "./runtime-ownership.mjs"; import { createSupervisionLatch, inspectDesktopSupervision } from "../service/desktop-supervision.mjs"; type SupervisionInspector = typeof inspectDesktopSupervision; export type { ServiceOwnershipResolution }; /** * Why a dashboard update must not restart a runtime it did not stop. * * The worker defaults to restarting. When the package updater it just ran left a * foreign-owned runtime alone — which is the correct behaviour under a desktop takeover — * the sidecar's unchanged pid fails the worker's restart evidence, so it reclaims the port, * runs the repair that now refuses, and falls through to a direct start. The app's runtime * ends up replaced by an npm proxy immediately after the update declined to touch it. * * Returns the line to report, or null when the restart may proceed. It lives beside the * worker rather than inside it because `src/update/job.ts` is one line under the repository * size cap. */ export function updateRestartVeto( resolve: () => ServiceOwnershipResolution = resolveServiceOwnership, inspect: SupervisionInspector = inspectDesktopSupervision, latch = createSupervisionLatch(), ): string | null { const owner = resolve(); const plan = planUpdateRuntimeHandling({ ownership: owner.kind === "owned" ? owner.ownership : null, ownershipUnknown: owner.kind === "unknown", // The restart decision does not refresh the service; only the stop veto is read here. serviceInstalled: false, supervision: latch.observe(inspect()), }); if (plan.mayStopRuntime) return null; return plan.notice ?? "The background runtime is owned elsewhere; it was left running."; } /** * The lease boundary inside a running restart, handed to `restart`. * * `ocx service repair` re-activates the OS service manager — Task Scheduler, launchd * or systemd — and that `ocx start` child is not a descendant of this process: it runs * with the stored registration environment, carries no delegated token, and can never * join the lease held here. Held through the repair's serving wait, the lease keeps * that child from ever starting (#5760; the npm lane releases at this boundary). The * veto is the decision the lease must cover — the reclaim and kills it authorizes — * so the fallthrough takes the lease back before re-running it: anything between the * service refresh and the direct start would otherwise mutate the port unleased. */ export interface UpdateRestartLeaseControl { /** Free the lease before a service-manager-mediated start that cannot join it. Idempotent. */ releaseForServiceManager(): void; /** * Take the lease back before the fallthrough mutates the port, then re-run the veto * under it. A lease that stays claimed (a live claimant mid-mutation) fails closed: * the returned notice stops the restart before any kill or start, and `failed` marks * the job failed — the refresh just before this did not produce a serving proxy, so * nothing is known to be running. An ownership veto is not a failure. */ reacquireForDirectStart(): UpdateRestartStop | null; /** Re-run the recorded-owner veto; a non-null notice must stop the restart there. */ vetoAgain(): string | null; } /** Why the direct-start fallthrough stopped; `failed` means no proxy is known to be serving. */ export interface UpdateRestartStop { readonly notice: string; readonly failed: boolean; } /** * Long enough to outlast one service-wrapper respawn cycle (5 s) of the managed child the * refresh just started, which briefly holds the lease while it binds and publishes. */ const REACQUIRE_WAIT_MS = 10_000; export async function runUpdateRestartWithOwnershipLease<T>( resolve: (() => ServiceOwnershipResolution) | undefined, restart: (lease: UpdateRestartLeaseControl) => Promise<T>, inspect: SupervisionInspector = inspectDesktopSupervision, ): Promise<{ readonly kind: "veto"; readonly notice: string } | { readonly kind: "ran"; readonly value: T }> { const latch = createSupervisionLatch(); let lease = acquireOwnershipMutationLease(serviceStatePaths()); const previous = process.env[OWNERSHIP_MUTATION_LEASE_TOKEN_ENV]; process.env[OWNERSHIP_MUTATION_LEASE_TOKEN_ENV] = lease.token; let heldNow = true; const restoreEnv = () => { if (previous === undefined) delete process.env[OWNERSHIP_MUTATION_LEASE_TOKEN_ENV]; else process.env[OWNERSHIP_MUTATION_LEASE_TOKEN_ENV] = previous; }; const release = () => { if (!heldNow) return; heldNow = false; restoreEnv(); lease.release(); }; const reacquireForDirectStart = (): UpdateRestartStop | null => { if (!heldNow) { try { lease = acquireOwnershipMutationLease(serviceStatePaths(), { waitMs: REACQUIRE_WAIT_MS }); } catch { return { failed: true, notice: "Update installed, but another process kept the runtime ownership lease claimed, so no proxy was started. " + "Run 'ocx service status', then 'ocx service repair' or 'ocx start'.", }; } heldNow = true; process.env[OWNERSHIP_MUTATION_LEASE_TOKEN_ENV] = lease.token; } const veto = updateRestartVeto(resolve, inspect, latch); return veto ? { notice: veto, failed: false } : null; }; try { const veto = updateRestartVeto(resolve, inspect, latch); return veto ? { kind: "veto", notice: veto } : { kind: "ran", value: await restart({ releaseForServiceManager: release, reacquireForDirectStart, vetoAgain: () => updateRestartVeto(resolve, inspect, latch), }), }; } finally { release(); } }