@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
229 lines (217 loc) • 12 kB
text/typescript
import { randomUUID } from "node:crypto";
import { lstatSync, unlinkSync } from "node:fs";
import { join, resolve } from "node:path";
import { atomicWriteFile, getConfigDir, getConfigPath, mutatePersistedConfig, readConfigDiagnostics, withConfigMutationLockSync } from "../config";
import { readAlivePid, readRuntimePort } from "../config/process-state";
import { getCodexHome } from "./paths";
import { advanceCodexCredentialMutationEpoch } from "./credential-mutation-epoch";
import { readNativeMainAuthBytes } from "./native-main-auth-file";
import { assertPlainLocalPath, ORCA_ACCOUNT_DIRECTORY, parseOrcaAuth, readBoundedLocalFile, readOrcaAuthSource, sameLocalPath } from "./orca-auth-source";
export class OrcaImportError extends Error {
constructor(message: string) { super(message); this.name = "OrcaImportError"; }
}
export interface OrcaImportResult {
mode: "preview" | "apply";
discovered: number;
eligible: number;
imported: number;
duplicates: number;
invalid: number;
invalidReasons: Partial<Record<OrcaImportInvalidReason, number>>;
}
export type OrcaImportInvalidReason = "unsupported_entry" | "home_mismatch" | "source_invalid";
class OrcaImportEntryError extends Error {
constructor(readonly reason: OrcaImportInvalidReason) { super(reason); }
}
function noteInvalid(result: OrcaImportResult, error: unknown): void {
const reason = error instanceof OrcaImportEntryError ? error.reason : "source_invalid";
result.invalid++;
result.invalidReasons[reason] = (result.invalidReasons[reason] ?? 0) + 1;
}
function optionalFile(path: string): string | undefined {
try { return readBoundedLocalFile(path, 4 * 1024 * 1024); }
catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
throw new OrcaImportError("A target or main credential file is unreadable; import refused.");
}
}
function object(value: unknown): Record<string, unknown> {
if (!value || typeof value !== "object" || Array.isArray(value)) throw new OrcaImportError("Invalid existing account state; import refused.");
return value as Record<string, unknown>;
}
function assertStopped(): void {
let running = readAlivePid() !== null;
const runtime = readRuntimePort();
if (runtime) {
try { process.kill(runtime.pid, 0); running = true; }
catch (error) { if ((error as NodeJS.ErrnoException).code !== "ESRCH") running = true; }
}
if (running) throw new OrcaImportError("Stop the opencodex proxy before applying an Orca import.");
}
function prepare(sourceDir: string, registryPath: string) {
const configRaw = optionalFile(getConfigPath());
if (!configRaw || readConfigDiagnostics().source !== "file") {
throw new OrcaImportError("Initialize a valid opencodex configuration before importing.");
}
const config = object(JSON.parse(configRaw));
const accounts = config.codexAccounts ?? [];
if (!Array.isArray(accounts)) throw new OrcaImportError("Invalid existing account configuration.");
const identities = new Set<string>();
const configuredIds = new Set<string>();
for (const entry of accounts) {
const row = object(entry);
if (typeof row.id === "string") configuredIds.add(row.id);
if (row.chatgptAccountId !== undefined && typeof row.chatgptAccountId !== "string") throw new OrcaImportError("Invalid existing account identity.");
if (typeof row.chatgptAccountId === "string" && row.chatgptAccountId) identities.add(row.chatgptAccountId);
}
const reservedIdentities = new Set(identities);
const storedIdentityCounts = new Map<string, number>();
const recoverable = new Map<string, { id: string; credential: Record<string, unknown> }>();
const storePath = join(getConfigDir(), "codex-accounts.json");
const storeRaw = optionalFile(storePath);
const store = storeRaw === undefined ? {} : object(JSON.parse(storeRaw));
for (const [id, entry] of Object.entries(store)) {
const record = object(entry);
// Retain orphan and tombstoned records; a credential is still evidence of identity.
if (record.credential === undefined && typeof record.generation === "number") continue;
const credential = object(record.credential ?? record);
if (typeof credential.chatgptAccountId !== "string" || !credential.chatgptAccountId
|| typeof credential.accessToken !== "string" || typeof credential.refreshToken !== "string"
|| typeof credential.expiresAt !== "number") throw new OrcaImportError("Invalid existing credential store.");
identities.add(credential.chatgptAccountId);
storedIdentityCounts.set(credential.chatgptAccountId, (storedIdentityCounts.get(credential.chatgptAccountId) ?? 0) + 1);
// A process can die after the credential rename but before config registration. Only
// the untouched initial record emitted by this importer may finish that registration.
// Older, validated, replaced, tombstoned, or independently owned orphans remain blockers.
if (id.startsWith("orca-") && ORCA_ACCOUNT_DIRECTORY.test(id.slice(5)) && !configuredIds.has(id)
&& record.generation === 1 && record.codexValidationPending === true
&& record.deletedAt === undefined && record.replacedAt === undefined
&& record.lastCodexValidatedAt === undefined && record.lastCodexValidationStatus === undefined
&& record.lastCodexValidationError === undefined && record.lastCodexValidationTerminal === undefined
&& credential.refreshToken === "" && typeof credential.sourceAuthPath === "string"
&& typeof credential.sourceSubject === "string" && credential.sourceSubject) {
recoverable.set(credential.chatgptAccountId, { id, credential });
}
}
let mainRaw: string | undefined;
const mainAuthPath = join(getCodexHome(), "auth.json");
try {
mainRaw = readNativeMainAuthBytes(mainAuthPath, "local-bounded", 4 * 1024 * 1024).toString("utf8");
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
throw new OrcaImportError("A target or main credential file is unreadable; import refused.");
}
}
if (mainRaw !== undefined) {
const main = object(JSON.parse(mainRaw));
if (main.tokens !== undefined) {
const identity = parseOrcaAuth(mainRaw, false).chatgptAccountId;
identities.add(identity);
reservedIdentities.add(identity);
}
else if (typeof main.OPENAI_API_KEY !== "string") throw new OrcaImportError("Main Codex identity is unknown; import refused.");
}
const root = assertPlainLocalPath(resolve(sourceDir));
const directory = assertPlainLocalPath(join(root, "codex-accounts"));
if (!lstatSync(directory).isDirectory()) throw new OrcaImportError("Invalid Orca data directory.");
const registryRaw = readBoundedLocalFile(resolve(registryPath), 32 * 1024 * 1024);
const registry = object(JSON.parse(registryRaw));
const registered = object(registry.settings).codexManagedAccounts;
if (!Array.isArray(registered) || registered.length > 1024) {
throw new OrcaImportError("Invalid Orca account registry or account limit exceeded.");
}
const result: OrcaImportResult = {
mode: "preview", discovered: registered.length, eligible: 0, imported: 0,
duplicates: 0, invalid: 0, invalidReasons: {},
};
const candidates: { credential: ReturnType<typeof readOrcaAuthSource>; recoverId?: string }[] = [];
const sourceIds = new Set<string>();
for (const entry of registered) {
try {
const row = object(entry);
if (typeof row.id !== "string" || !ORCA_ACCOUNT_DIRECTORY.test(row.id)
|| typeof row.managedHomePath !== "string"
|| (row.managedHomeRuntime !== undefined && row.managedHomeRuntime !== "host")) {
throw new OrcaImportEntryError("unsupported_entry");
}
const home = join(directory, row.id, "home");
if (!sameLocalPath(assertPlainLocalPath(row.managedHomePath), assertPlainLocalPath(home))) {
throw new OrcaImportEntryError("home_mismatch");
}
if (sourceIds.has(row.id)) { result.duplicates++; continue; }
sourceIds.add(row.id);
const credential = readOrcaAuthSource(join(home, "auth.json"));
let recoverId: string | undefined;
if (identities.has(credential.chatgptAccountId)) {
const orphan = recoverable.get(credential.chatgptAccountId);
if (orphan && !reservedIdentities.has(credential.chatgptAccountId)
&& storedIdentityCounts.get(credential.chatgptAccountId) === 1
&& sameLocalPath(orphan.credential.sourceAuthPath as string, credential.sourceAuthPath)
&& orphan.credential.sourceSubject === credential.sourceSubject) {
recoverId = orphan.id;
recoverable.delete(credential.chatgptAccountId);
} else { result.duplicates++; continue; }
}
identities.add(credential.chatgptAccountId);
candidates.push({ credential, recoverId });
result.eligible++;
} catch (error) { noteInvalid(result, error); }
}
return { configRaw, registryRaw, storeRaw, storePath, store, candidates, result };
}
/** Offline, explicit-source import. The returned report deliberately contains no identities or paths. */
export function importOrcaAccounts(options: { sourceDir: string; registryPath: string; apply?: boolean }): OrcaImportResult {
try {
if (!options.apply) return prepare(options.sourceDir, options.registryPath).result;
assertStopped();
return withConfigMutationLockSync(() => {
assertStopped();
const state = prepare(options.sourceDir, options.registryPath);
state.result.mode = "apply";
if (!state.candidates.length) return state.result;
const writesCredentials = state.candidates.some(candidate => candidate.recoverId === undefined);
const additions = state.candidates.map(({ credential, recoverId }) => {
let id = recoverId;
if (id === undefined) {
do { id = `orca-${randomUUID()}`; } while (state.store[id]);
state.store[id] = { credential, generation: 1, codexValidationPending: true };
}
return { id, email: "", alias: "Orca account", isMain: false, chatgptAccountId: credential.chatgptAccountId };
});
// Re-read registry and sources immediately before publishing either target file.
if (readBoundedLocalFile(resolve(options.registryPath), 32 * 1024 * 1024) !== state.registryRaw) {
throw new OrcaImportError("Orca registry changed during import; retry.");
}
for (const { credential } of state.candidates) {
if (JSON.stringify(readOrcaAuthSource(credential.sourceAuthPath)) !== JSON.stringify(credential)) {
throw new OrcaImportError("Orca credentials changed during import; retry.");
}
}
assertStopped();
if (optionalFile(getConfigPath()) !== state.configRaw || optionalFile(state.storePath) !== state.storeRaw) {
throw new OrcaImportError("Target accounts changed during import; retry.");
}
if (writesCredentials) atomicWriteFile(state.storePath, JSON.stringify(state.store, null, 2) + "\n");
try {
const outcome = mutatePersistedConfig(config => {
if (optionalFile(getConfigPath()) !== state.configRaw) throw new OrcaImportError("Target configuration changed; retry.");
config.codexAccounts = [...(config.codexAccounts ?? []), ...additions];
return { changed: true, value: undefined };
});
if (outcome.status !== "committed") throw new OrcaImportError("Target configuration could not be committed.");
} catch (error) {
if (writesCredentials) {
if (state.storeRaw === undefined) unlinkSync(state.storePath);
else atomicWriteFile(state.storePath, state.storeRaw);
}
throw error;
}
advanceCodexCredentialMutationEpoch();
state.result.imported = additions.length;
return state.result;
});
} catch (error) {
if (error instanceof OrcaImportError) throw error;
throw new OrcaImportError("Orca import could not complete; verify source and target local account files.");
}
}