@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
74 lines (71 loc) • 3.84 kB
text/typescript
import { restoreNativeCodexAsync } from "../codex/inject";
import type { RetainedCodexProviderTable } from "../codex/inject/restore";
import { stripGrokConfig } from "../grok/inject";
/**
* Restore shared client state after a stop.
*
* Returns the two failure kinds separately. `historyOnly` means teardown succeeded and
* only Codex history metadata could not be finalized: the proxy is down, the service is
* stopped, and a manifest is waiting for review. `other` means something that actually
* removes state a client depends on.
*
* The distinction exists because `ocx update` must proceed for the first and abort for the
* second, and it can only see an exit code (#3008).
*
* `historyDeferred` is the third kind (#4718). The Codex history preflight refuses BEFORE
* the config half runs, so nothing was restored at all: config, catalog, history and
* provenance are untouched and the client is still routed at the proxy that just stopped.
* Like `historyOnly` the proxy is genuinely down, so an update may replace package files.
* Unlike `historyOnly` the obligation was not performed, so the receipt must survive.
*/
export async function restoreSharedClientStateAfterStop(
reportRetainedCodexProviderTable: (retained: RetainedCodexProviderTable) => void,
): Promise<{ historyOnly: boolean; historyDeferred: boolean; other: boolean }> {
let historyOnly = false;
let historyDeferred = false;
let other = false;
try {
const result = await restoreNativeCodexAsync();
if (result.success) {
console.log(`↩️ ${result.message}`);
if (result.retainedCodexProviderTable) {
reportRetainedCodexProviderTable(result.retainedCodexProviderTable);
}
}
else {
// Codex history is the one restore whose failure leaves the runtime consistent: the
// manifest is retained and the routed metadata is untouched. Config and catalog are
// not — a client reads those, so their failure is a real teardown failure.
const artifacts = result.artifacts;
const configOrCatalogFailed = artifacts.config.state === "failed" || artifacts.catalog.state === "failed";
// A preflight refusal reports every artifact as `skipped` because none of them were
// attempted. Reading the states alone cannot tell that apart from an ownership
// refusal, so the structured reason carries it and the states are still required to
// agree — a refusal that somehow reports a failed artifact is not this case.
// A degraded restore has no refusal reason and reports config as partial, so it cannot
// enter this branch: its config obligation was discharged and the stop receipt must be
// released rather than preserved.
const preflightRefused = result.historyPreflightRefusal !== undefined
&& artifacts.config.state === "skipped"
&& artifacts.catalog.state === "skipped"
&& artifacts.history.state === "skipped";
if (preflightRefused) historyDeferred = true;
else if (!configOrCatalogFailed && artifacts.history.state === "failed") historyOnly = true;
else other = true;
console.error(`⚠️ ${result.message}`);
}
} catch (error) {
other = true;
console.error(`⚠️ Native Codex restore failed: ${error instanceof Error ? error.message : String(error)}`);
}
// A refused or thrown Grok strip is actionable because it would point Grok at a dead proxy.
try {
const grok = stripGrokConfig();
if (grok.changed) console.log(`↩️ ${grok.message}`);
else if (!grok.ok) { other = true; console.error(`⚠️ ${grok.message}`); }
} catch (error) {
other = true;
console.error(`⚠️ Grok config restore failed: ${error instanceof Error ? error.message : String(error)}`);
}
return { historyOnly, historyDeferred, other };
}