@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
153 lines (145 loc) • 6.87 kB
text/typescript
import { readPidFileValue, readRuntimePort } from "../config/process-state";
import { isConnectionRefused, isOpencodexHealthz, probeHostname } from "../server/proxy-liveness";
import { directLocalHttpFetch } from "../server/direct-local-http";
import { isProcessAlive } from "../lib/process-control";
type HealthCheck = {
ok: boolean;
url: string;
message: string;
label: string;
/** True only for a connect-phase refusal: proof that nothing holds the port. */
refused?: boolean;
};
export type ListenTarget = {
port: number;
hostname?: string;
source: "runtime" | "config";
healthUrl: string;
dashboardUrl: string;
};
export function proxyHealthFailureReason(error: unknown, signal: AbortSignal): "timed out" | "unreachable" {
return signal.aborted || (error instanceof Error && error.name === "AbortError")
? "timed out"
: "unreachable";
}
export { isConnectionRefused } from "../server/proxy-liveness";
/**
* A proxy killed by a native trap or SIGKILL never runs the exit cleanup that removes
* `ocx.pid` and `runtime-port.json` (only SIGINT/SIGTERM/SIGHUP and normal exit are
* wired to it), so both records outlive it. That makes "crashed" and "never started"
* distinguishable — and #1419 is what it costs when we discard the distinction: the
* reporter's unsupervised `ocx gui` proxy died and every later command said only
* "not running", never that a previous process had exited or that a service would
* have restarted it.
*
* Two races have to stay closed, because a false "it crashed" is worse than a missing
* hint. `handleStart` binds the port BEFORE it publishes either record, so:
*
* - a start that publishes between two reads is caught by comparing the raw records
* observed before and after the probes (the same snapshot discipline
* `removePidIfValueIs` uses for deletion);
* - a start that has bound but not yet published leaves both snapshots identical, so
* records alone cannot see it. That one is excluded on the port instead: the probe
* must have been REFUSED at connect, which is the only outcome proving nothing holds
* the port. A socket that is accepted and then reset — an in-flight bind — is not a
* refusal, so review caught `unreachable` being too broad for this job.
*
* What this can and cannot prove: the records outliving their process establish that the
* previous run did not complete its cleanup. It does not establish a cause, and it cannot
* fully exclude a clean exit whose `unlinkSync` failed, because cleanup ignores that
* error (`src/cli/index.ts:324-325`) and the records carry no session provenance. The
* wording therefore says the records remain and the run MAY have exited unexpectedly.
*/
export function isUncleanExitEvidence(input: {
live: boolean;
healthOk: boolean;
healthRefused: boolean;
ownerPidAlive: boolean;
pidRecordBefore: number | null;
pidRecordAfter: number | null;
runtimePidBefore: number | null;
runtimePidAfter: number | null;
}): boolean {
if (input.live || input.healthOk) return false;
if (!input.healthRefused) return false;
if (input.ownerPidAlive) return false;
if (input.pidRecordBefore !== input.pidRecordAfter) return false;
if (input.runtimePidBefore !== input.runtimePidAfter) return false;
return input.pidRecordAfter !== null || input.runtimePidAfter !== null;
}
export async function checkProxyHealth(target: ListenTarget): Promise<HealthCheck> {
const url = target.healthUrl;
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 800);
try {
const response = await directLocalHttpFetch(url, { signal: controller.signal });
if (!response.ok) {
const message = `returned HTTP ${response.status}`;
return { ok: false, url, message, label: `${url} ${message}` };
}
const body = await response.json().catch(() => null) as { service?: unknown; status?: unknown; version?: unknown; uptime?: unknown } | null;
if (!isOpencodexHealthz(body)) {
const message = "responded, but not an opencodex proxy";
return { ok: false, url, message, label: `${url} ${message}` };
}
const version = typeof body?.version === "string" ? ` v${body.version}` : "";
const uptime = typeof body?.uptime === "number" ? `, uptime ${Math.round(body.uptime)}s` : "";
const message = `ok${version}${uptime}`;
return { ok: true, url, message, label: `${url} ${message}` };
} catch (error) {
const reason = proxyHealthFailureReason(error, controller.signal);
return { ok: false, url, message: reason, label: `${url} ${reason}`, refused: isConnectionRefused(error) };
} finally {
clearTimeout(timer);
}
}
/**
* The ONE evidence gatherer for stale-process state, shared by `ocx status` and
* `ocx doctor`.
*
* It deliberately probes the port named by the STALE RECORD, not the configured display
* port. Review found the two commands disagreeing precisely here: a proxy that hopped to
* a fallback port, or a config whose port changed after the crash, left status probing
* the configured port while doctor probed the recorded one, so one reported a crash and
* the other did not. The question being asked is "is the process that wrote this record
* gone?", and only that record's own port can answer it.
*
* `live` short-circuits before the probe so a healthy install pays nothing.
*/
export async function probeUncleanExitState(input: {
live: boolean;
port?: number;
hostname?: string | null;
}): Promise<boolean> {
if (input.live) return false;
const pidRecordBefore = readPidFileValue();
const runtimeBefore = readRuntimePort();
const runtimePidBefore = runtimeBefore?.pid ?? null;
if (pidRecordBefore === null && runtimePidBefore === null) return false;
const ownerPid = pidRecordBefore ?? runtimePidBefore;
if (ownerPid !== null && isProcessAlive(ownerPid)) return false;
// The recorded port is the evidence target. Fall back to the configured port only when
// no runtime record exists, which is the pid-file-only case.
const port = runtimeBefore?.port ?? input.port ?? 10100;
const hostname = runtimeBefore?.hostname ?? input.hostname ?? undefined;
const health = await checkProxyHealth({
port,
hostname,
source: runtimeBefore ? "runtime" : "config",
healthUrl: `http://${probeHostname(hostname)}:${port}/healthz`,
dashboardUrl: `http://localhost:${port}/`,
});
const pidRecordAfter = readPidFileValue();
const runtimePidAfter = readRuntimePort()?.pid ?? null;
const ownerPidAfter = pidRecordAfter ?? runtimePidAfter;
return isUncleanExitEvidence({
live: false,
healthOk: health.ok,
healthRefused: health.refused === true,
ownerPidAlive: ownerPidAfter !== null && isProcessAlive(ownerPidAfter),
pidRecordBefore,
pidRecordAfter,
runtimePidBefore,
runtimePidAfter,
});
}