UNPKG

@bitkyc08/opencodex

Version:

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

289 lines (267 loc) • 11.7 kB
/** * Durable journal for Anthropic reset-grant claims. * * One dashboard confirmation is one operation. Its UUIDv4 id is also the * upstream `request_id`, so a retry of the same operation is the same claim to * Anthropic. The Claude Code client reuses an unsettled claim's request id for * ten minutes (`b5o = 600000`) and mints a new one afterwards; this journal keeps * the same window. * * Rules (devlog/_plan/260923_claude_reset_grants/010_plan.md, "Ledger contract"): * - Every read-modify-write runs synchronously inside a cross-process * `BEGIN IMMEDIATE` lock on a sibling SQLite file; nothing awaits inside it, * and the upstream claim always runs after the open record is on disk. * - An open record carries a lease; a second attempt inside it is refused. * - Settlement is never inferred. The first terminal settlement wins. * - An unreadable journal refuses the spend instead of starting from empty. */ import { Database } from "bun:sqlite"; import { createHash } from "node:crypto"; import { existsSync, mkdirSync, readFileSync, writeSync } from "node:fs"; import { dirname, join } from "node:path"; import { atomicWriteFileStreamed } from "../config/atomic-write"; import { getConfigDir } from "../config/paths"; export const ANTHROPIC_RESET_LEASE_MS = 90_000; export const ANTHROPIC_RESET_RETRY_WINDOW_MS = 600_000; const RETENTION_MS = 30 * 24 * 60 * 60_000; const MAX_OPERATIONS = 256; export type AnthropicResetLedgerErrorCode = "busy" | "unavailable" | "write_failed"; export class AnthropicResetLedgerError extends Error { constructor(readonly code: AnthropicResetLedgerErrorCode) { super(`Anthropic reset-grant journal ${code}`); this.name = "AnthropicResetLedgerError"; } } interface OperationRecord { accountId: string; grantId: string; orgDigest: string; status: "open" | "settled"; code?: string; resetsLeft?: number | null; attempts: number; leaseUntil: number; createdAt: number; updatedAt: number; } interface Journal { version: 1; operations: Record<string, OperationRecord>; } export interface AnthropicResetOperationIdentity { operationId: string; accountId: string; grantId: string; orgDigest: string; } export type AnthropicResetBegin = | { kind: "execute"; attempt: number } | { kind: "replay"; code: string; resetsLeft: number | null; settledAt: number } | { kind: "identity-mismatch" } | { kind: "in-flight" } | { kind: "expired" } | { kind: "unresolved-prior"; operationId: string } | { kind: "capacity" }; export interface AnthropicResetPendingOperation { operationId: string; grantId: string; createdAt: number; retryableUntil: number; } /** Digest so the journal never stores the raw organization UUID. */ export function anthropicOrgDigest(organizationUuid: string): string { return createHash("sha256").update(`opencodex-anthropic-reset-org\0${organizationUuid.toLowerCase()}`).digest("hex"); } export function anthropicResetJournalPath(customDir?: string): string { return join(customDir ?? getConfigDir(), "anthropic-reset-grant-ledger.json"); } function isRecordShape(value: unknown): value is OperationRecord { if (!value || typeof value !== "object") return false; const record = value as Record<string, unknown>; return typeof record.accountId === "string" && typeof record.grantId === "string" && typeof record.orgDigest === "string" && (record.status === "open" || record.status === "settled") && typeof record.attempts === "number" && typeof record.leaseUntil === "number" && typeof record.createdAt === "number" && typeof record.updatedAt === "number"; } /** Missing file → empty journal. Present but unreadable → throws; never an empty fallback. */ function readJournal(filePath: string): Journal { if (!existsSync(filePath)) return { version: 1, operations: {} }; let parsed: unknown; try { parsed = JSON.parse(readFileSync(filePath, "utf-8")); } catch { throw new AnthropicResetLedgerError("unavailable"); } const journal = parsed as Partial<Journal> | null; if (!journal || journal.version !== 1 || !journal.operations || typeof journal.operations !== "object" || !Object.values(journal.operations).every(isRecordShape)) { throw new AnthropicResetLedgerError("unavailable"); } return journal as Journal; } function writeJournal(filePath: string, journal: Journal, now: number): void { const cutoff = now - RETENTION_MS; journal.operations = Object.fromEntries( Object.entries(journal.operations).filter(([, record]) => record.updatedAt > cutoff), ); const bytes = Buffer.from(JSON.stringify(journal, null, 2)); try { // The streamed form fsyncs the temp file and the parent directory, so an // open record is on disk before the claim that depends on it is sent. atomicWriteFileStreamed(filePath, descriptor => { let offset = 0; while (offset < bytes.length) offset += writeSync(descriptor, bytes, offset, bytes.length - offset); }); } catch { throw new AnthropicResetLedgerError("write_failed"); } } /** * Runs `fn` inside an OS-backed cross-process lock. `busy_timeout = 0` so a * contended request fails immediately instead of blocking the event loop, the * same trade-off src/config/mutation-lock.ts makes. `fn` must be synchronous. */ function withJournalLock<T>(filePath: string, fn: () => T): T { let database: Database | undefined; try { mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 }); database = new Database(`${filePath}.lock.sqlite`, { create: true }); database.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE"); } catch { try { database?.close(); } catch { /* acquisition already failed */ } throw new AnthropicResetLedgerError("busy"); } try { const value = fn(); database.exec("COMMIT"); return value; } catch (error) { try { database.exec("ROLLBACK"); } catch { /* closing releases the lock */ } throw error; } finally { database.close(); } } export interface AnthropicResetLedgerOptions { now?: number; journalPath?: string; } /** True when the operation already has a record. Lock-free read for routing only. */ export function anthropicResetOperationExists(operationId: string, options: AnthropicResetLedgerOptions = {}): boolean { return readJournal(options.journalPath ?? anthropicResetJournalPath()).operations[operationId] !== undefined; } /** * Opens (or re-opens for a same-id retry) one claim attempt. On `execute` the * record is durably open and leased before this returns; the caller may then * send the claim with `operationId` as its request id. */ export function beginAnthropicResetOperation( identity: AnthropicResetOperationIdentity, options: AnthropicResetLedgerOptions = {}, ): AnthropicResetBegin { const now = options.now ?? Date.now(); const filePath = options.journalPath ?? anthropicResetJournalPath(); return withJournalLock(filePath, () => { const journal = readJournal(filePath); const existing = journal.operations[identity.operationId]; if (existing) { if (existing.accountId !== identity.accountId || existing.grantId !== identity.grantId || existing.orgDigest !== identity.orgDigest) { return { kind: "identity-mismatch" }; } if (existing.status === "settled") { return { kind: "replay", code: existing.code ?? "unavailable", resetsLeft: existing.resetsLeft ?? null, settledAt: existing.updatedAt }; } if (existing.leaseUntil > now) return { kind: "in-flight" }; if (now - existing.createdAt >= ANTHROPIC_RESET_RETRY_WINDOW_MS) return { kind: "expired" }; existing.attempts += 1; existing.leaseUntil = now + ANTHROPIC_RESET_LEASE_MS; existing.updatedAt = now; writeJournal(filePath, journal, now); return { kind: "execute", attempt: existing.attempts }; } for (const [operationId, record] of Object.entries(journal.operations)) { if (record.status === "open" && record.accountId === identity.accountId && record.grantId === identity.grantId && record.orgDigest === identity.orgDigest && now - record.createdAt < ANTHROPIC_RESET_RETRY_WINDOW_MS) { return { kind: "unresolved-prior", operationId }; } } if (Object.keys(journal.operations).length >= MAX_OPERATIONS) return { kind: "capacity" }; journal.operations[identity.operationId] = { accountId: identity.accountId, grantId: identity.grantId, orgDigest: identity.orgDigest, status: "open", attempts: 1, leaseUntil: now + ANTHROPIC_RESET_LEASE_MS, createdAt: now, updatedAt: now, }; writeJournal(filePath, journal, now); return { kind: "execute", attempt: 1 }; }); } export interface AnthropicResetSettlement { code: string; resetsLeft: number | null; } /** * Records a terminal answer and returns the settlement the journal now holds. * First settlement wins: a later answer for an already-settled operation gets the * stored one back, so the caller reports what the journal says. A missing record * throws, because an answer with no journal entry cannot be reported as durable. */ export function settleAnthropicResetOperation( settlement: { operationId: string; code: string; resetsLeft: number | null }, options: AnthropicResetLedgerOptions = {}, ): AnthropicResetSettlement { const now = options.now ?? Date.now(); const filePath = options.journalPath ?? anthropicResetJournalPath(); return withJournalLock(filePath, () => { const journal = readJournal(filePath); const existing = journal.operations[settlement.operationId]; if (!existing) throw new AnthropicResetLedgerError("unavailable"); if (existing.status === "settled") return { code: existing.code ?? "unavailable", resetsLeft: existing.resetsLeft ?? null }; existing.status = "settled"; existing.code = settlement.code; existing.resetsLeft = settlement.resetsLeft; existing.leaseUntil = 0; existing.updatedAt = now; writeJournal(filePath, journal, now); return { code: settlement.code, resetsLeft: settlement.resetsLeft }; }); } /** * Ends this process's attempt on an unknown outcome so an explicit same-id retry * does not wait out the whole lease. The record stays open. */ export function releaseAnthropicResetLease(operationId: string, options: AnthropicResetLedgerOptions = {}): void { const now = options.now ?? Date.now(); const filePath = options.journalPath ?? anthropicResetJournalPath(); withJournalLock(filePath, () => { const journal = readJournal(filePath); const existing = journal.operations[operationId]; if (!existing || existing.status !== "open") return; existing.leaseUntil = now; existing.updatedAt = now; writeJournal(filePath, journal, now); }); } /** Open operation for this account still inside its retry window, if any. */ export function pendingAnthropicResetOperation( accountId: string, options: AnthropicResetLedgerOptions = {}, ): AnthropicResetPendingOperation | null { const now = options.now ?? Date.now(); const journal = readJournal(options.journalPath ?? anthropicResetJournalPath()); let pending: AnthropicResetPendingOperation | null = null; for (const [operationId, record] of Object.entries(journal.operations)) { if (record.status !== "open" || record.accountId !== accountId) continue; const retryableUntil = record.createdAt + ANTHROPIC_RESET_RETRY_WINDOW_MS; if (retryableUntil <= now) continue; if (!pending || record.createdAt > pending.createdAt) { pending = { operationId, grantId: record.grantId, createdAt: record.createdAt, retryableUntil }; } } return pending; }