@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
142 lines (136 loc) • 7.12 kB
text/typescript
import { publishCredentialSync } from "../local-credentials/generation";
import { osStoreAccounts } from "../local-credentials/references";
import { normalizeAccountAutoPauseRevisions, observeAccountAutoPauseRevisions, snapshotAutoPauseFingerprints } from "./account-auto-pause-revisions";
import { existsSync, readFileSync } from "node:fs";
import { configReasoningPinsConfigError } from "./provider-validation";
import type { OcxConfig } from "../types";
import { withPreservedDiskOnlyProviders } from "../usage/user-cost-overlays";
import { refreshConfigDerivedRegistries } from "./derived-registries";
import { atomicWriteFile, isMissingPathError } from "./atomic-write";
import { getConfigPath } from "./paths";
import { configRebaseDeletionKeys, projectConfigRebaseProvenance } from "./rebase-provenance";
import { clientConnectionSchema } from "./schema/leaf-validators";
import { projectRemovedOpenCodeFreeSnapshot } from "./removed-opencode-free-backup";
/** The requested bytes are current; callers must not roll back only live state. */
export class ConfigWritePublishedError extends Error {
constructor(cause: unknown) {
super("Config was published, but post-publication bookkeeping failed", { cause });
this.name = "ConfigWritePublishedError";
}
}
/** The literal file, with no schema merge or default injection; preserve-only leaves it unprojected. */
export function readRawConfigJson(projectRetired: boolean | "preserve-only" = false): Record<string, unknown> | undefined {
let configPath: string;
let bytes: Buffer;
let parsed: unknown;
try {
configPath = getConfigPath();
if (!existsSync(configPath)) return undefined;
bytes = readFileSync(configPath);
const raw = bytes.toString("utf-8").replace(/^\uFEFF/, "");
parsed = JSON.parse(raw) as unknown;
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
} catch {
// Unreadable or corrupt: behave exactly as before. Never fail a save over protection.
return undefined;
}
if (projectRetired === "preserve-only") {
// Preservation is optional; its failure must not discard the parsed snapshot that the
// client-state guard and OS-store reference accounting depend on.
try {
projectRemovedOpenCodeFreeSnapshot(structuredClone(parsed), { path: configPath, bytes });
} catch {
console.warn("[opencodex] Could not check config.json for retired OpenCode Free entries before saving; no recovery copy was made.");
}
} else if (projectRetired) {
try {
projectRemovedOpenCodeFreeSnapshot(parsed, { path: configPath, bytes });
} catch {
// The in-place projection may be partial; keep the previous unreadable result.
return undefined;
}
}
return parsed as Record<string, unknown>;
}
function failClosedClientPersistenceError(
raw: Record<string, unknown> | undefined,
candidate: OcxConfig,
): string | null {
if (!raw) return null;
const rawHasClient = Object.hasOwn(raw, "client") && raw.client !== undefined;
const rawRole = raw.runtimeRole;
const rawRoleValid = rawRole === undefined
|| rawRole === "standalone"
|| rawRole === "hub"
|| rawRole === "client";
const rawClientValid = !rawHasClient || clientConnectionSchema.safeParse(raw.client).success;
const rawPairValid = rawRoleValid
&& ((rawRole === "client" && rawHasClient && rawClientValid)
|| (rawRole !== "client" && !rawHasClient));
if (rawPairValid) return null;
const candidateValid = candidate.runtimeRole === "client"
&& clientConnectionSchema.safeParse(candidate.client).success;
const deletions = configRebaseDeletionKeys(candidate);
const explicitClear = deletions.has("client") && deletions.has("runtimeRole");
if (candidateValid || explicitClear) return null;
return "config write refused: malformed or mismatched remote client state must be repaired or explicitly cleared";
}
/**
* Atomic config.json write WITHOUT the mutation lock; callers must hold
* `withConfigMutationLockSync`. Returns true when bytes changed. Refreshes the
* cost-overlay registry from the persisted config so runtime estimates follow
* every save path.
*/
export function persistConfigUnlocked(config: OcxConfig): boolean {
const pinError = configReasoningPinsConfigError(config);
if (pinError) throw new Error(pinError);
const configPath = getConfigPath();
// Protect late disk edits from these same bytes, retaining raw rows for guards and credential accounting.
const rawBeforeWrite = readRawConfigJson("preserve-only");
const clientPersistenceError = failClosedClientPersistenceError(rawBeforeWrite, config);
if (clientPersistenceError) throw new Error(clientPersistenceError);
// External editors can add provider rows the live config deliberately does
// not route with yet; merge them at the serialization boundary so an
// unrelated in-process save cannot erase the provider or its overlay.
// Provider preservation reads symbol-keyed live-owner state, which structuredClone
// intentionally drops. Resolve that ownership before projecting JSON provenance.
const provenanceProjection = projectConfigRebaseProvenance(config);
const persisted = withPreservedDiskOnlyProviders(config);
if (provenanceProjection.configRebaseProvenance === undefined) delete persisted.configRebaseProvenance;
else persisted.configRebaseProvenance = provenanceProjection.configRebaseProvenance;
normalizeAccountAutoPauseRevisions(rawBeforeWrite, persisted);
const beforeFingerprints = snapshotAutoPauseFingerprints(rawBeforeWrite ?? {});
const bytes = JSON.stringify(persisted, null, 2) + "\n";
let unchanged = false;
try {
unchanged = readFileSync(configPath, "utf8") === bytes;
} catch (error) {
if (!isMissingPathError(error)) throw error;
}
// Keep the runtime overlay registry in sync with EVERY persist path,
// including byte-identical saves: a cooperating CLI process may have written
// the same bytes (e.g. before a proxy notification), and Logs/Usage must
// adopt the overlay without waiting for a changed save or restart.
let published = unchanged;
let observedPublication = false;
try {
if (!unchanged) {
// Register every OS-store reference on either side before a removal can land.
publishCredentialSync(() => atomicWriteFile(configPath, bytes, undefined, { afterRename: () => { published = true; } }),
{ references: [...new Set([...osStoreAccounts(rawBeforeWrite), ...osStoreAccounts(persisted)])] });
published = true;
}
// Publication, not successful cache refresh, is the rollback boundary. A
// byte-identical save already has the requested state on disk as well.
observeAccountAutoPauseRevisions(persisted, persisted, beforeFingerprints);
observedPublication = true;
refreshConfigDerivedRegistries(persisted);
return !unchanged;
} catch (error) {
if (published) {
if (!observedPublication) observeAccountAutoPauseRevisions(persisted, persisted, beforeFingerprints);
throw new ConfigWritePublishedError(error);
}
throw error;
}
}