UNPKG

@bitkyc08/opencodex

Version:

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

329 lines (311 loc) • 16.5 kB
import { hasHumanDashboardSession } from "./consent-session"; /** * Management API for Anthropic OAuth usage-limit reset grants. * * GET /api/anthropic/reset-grants?accountId=... read one account's grants * POST /api/anthropic/reset-grants/consume spend one grant * * Spending uses the user's own subscription benefit, so the POST requires the * dashboard session principal (AGENTS.md, "User-consent actions"); the admin token * alone is refused. Responses carry fixed codes and fixed messages only: no * upstream body, exception text, token, organization id, or email. Nothing here * logs. Lazy-loaded by `handleAnthropicResetGrantRoutesOnDemand` in * management-api.ts so the core request path never imports it. */ import { jsonResponse } from "../auth-cors"; import type { ManagementContext } from "./context"; import { getValidAccessSnapshotForAccount } from "../../oauth"; import { configuredAnthropicInstance, isAnthropicInstanceId, type AnthropicInstanceId } from "../../providers/anthropic-instance"; import { captureAnthropicPhysicalSendOwnership, anthropicPhysicalSendOwnershipIsCurrent } from "../../oauth/anthropic-send-ownership"; import { anthropicCooldownRecoveryFor } from "../../providers/quota/anthropic-cooldown-recovery"; import { captureProviderAccountQuotaEpoch } from "../../providers/quota/account-cache"; import { captureOAuthAccountSelection, getAccountSet, getAccountCredentialWithStatus, listAccounts } from "../../oauth/store"; import { admitAnthropicAccountAfterReset, type AnthropicResetAdmissionEvidence } from "../../providers/anthropic-reset-admission"; import { ANTHROPIC_RESET_GRANT_ID_RE, AnthropicResetGrantError, AnthropicResetGrantUnknownOutcome, anthropicResetGrantBlocker, claimAnthropicResetGrant, fetchAnthropicOrganizationUuid, fetchAnthropicResetGrantStatus, } from "../../providers/anthropic-reset-grants"; import { AnthropicResetLedgerError, anthropicOrgDigest, anthropicResetOperationExists, anthropicResetJournalPathForInstance, beginAnthropicResetOperation, pendingAnthropicResetOperation, releaseAnthropicResetLease, settleAnthropicResetOperation, } from "../../providers/anthropic-reset-grant-ledger"; const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; const MESSAGES = { method_not_allowed: "Method not allowed", session_required: "Spending a reset requires a dashboard session.", invalid_json: "Request body must be JSON.", invalid_provider: "No matching builtin Anthropic OAuth provider.", invalid_grant_id: "grantId is missing or malformed.", invalid_operation_id: "operationId must be a UUIDv4.", no_account: "No matching Anthropic OAuth account.", auth_failed: "Sign in to this Anthropic account again.", upstream_unavailable: "Anthropic did not return the reset-grant status.", grant_not_usable: "This reset grant cannot be used right now.", operation_identity_mismatch: "This operation belongs to another account or grant.", in_flight: "This reset is still being processed.", unresolved_prior_operation: "An earlier reset attempt on this account is not confirmed yet.", unknown_outcome_expired: "This attempt can no longer be retried; re-read the account.", unknown_outcome: "The reset did not answer; its outcome is unknown.", journal_write_failed: "The reset answered but could not be recorded; its outcome is unknown here.", ledger_busy: "The reset journal is busy. Nothing was used.", ledger_unavailable: "The reset journal is unavailable. Nothing was used.", ledger_capacity: "The reset journal is full. Nothing was used.", } as const; type ErrorCode = keyof typeof MESSAGES; export interface AnthropicResetGrantRouteDeps { provider?: AnthropicInstanceId; isCurrent?: () => boolean; forProvider?: (provider: AnthropicInstanceId) => AnthropicResetGrantRouteDeps; fetchFn?: typeof globalThis.fetch; journalPath?: string; now?: () => number; listAccountIds: () => string[]; activeAccountId: () => string | null; accessTokenFor: (accountId: string) => Promise<string>; /** Lift local admission after a journaled reset, bounded by its journal evidence. Tests omit it. */ admitReset?: (accountId: string, evidence: AnthropicResetAdmissionEvidence) => Promise<void>; } function defaultDepsFor(ctx: ManagementContext, provider: AnthropicInstanceId): AnthropicResetGrantRouteDeps | null { // One source: the live management config. A keeps its legacy reach without a providers row; // B requires its configured builtin row. A fresh file load here would refuse on any drift. const live = ctx.config; const target = live.providers?.[provider]; if (target?.disabled || target && target.authMode !== "oauth" || configuredAnthropicInstance(live, provider) !== provider) return null; const identity = JSON.stringify(target ?? null); let owner: ReturnType<typeof captureAnthropicPhysicalSendOwnership> = null; const targetCurrent = () => configuredAnthropicInstance(live, provider) === provider && JSON.stringify(live.providers?.[provider] ?? null) === identity; return { // Only the journal path: the ledger's numeric `now` option is not the deps clock function. provider, journalPath: anthropicResetJournalPathForInstance(provider), listAccountIds: () => listAccounts(provider).map(account => account.id), activeAccountId: () => captureOAuthAccountSelection(provider)?.accountId ?? null, isCurrent: () => { if (!targetCurrent() || !owner || !anthropicPhysicalSendOwnershipIsCurrent(owner)) return false; const row = getAccountCredentialWithStatus(provider, owner.accountId); return !!row && !row.paused && !row.needsReauth; }, accessTokenFor: async accountId => { const initial = getAccountSet(provider)?.accounts.find(row => row.id === accountId); const recovery = anthropicCooldownRecoveryFor(provider); const incarnation = recovery.reserveAnthropicAccountIncarnation(accountId); const epoch = captureProviderAccountQuotaEpoch(provider); const snapshot = await getValidAccessSnapshotForAccount(provider, accountId, { requireUsableAccount: true }); const current = getAccountSet(provider)?.accounts.find(row => row.id === accountId); if (!initial || !current || initial.loginId !== current.loginId || initial.addedAt !== current.addedAt || recovery.anthropicAccountIncarnation(accountId) !== incarnation || captureProviderAccountQuotaEpoch(provider) !== epoch) throw new Error("reset account replaced"); owner = captureAnthropicPhysicalSendOwnership(snapshot); if (!targetCurrent() || !owner) throw new Error("reset owner changed"); return snapshot.accessToken; }, admitReset: (accountId, evidence) => admitAnthropicAccountAfterReset(provider, accountId, evidence), }; } function selectDeps(ctx: ManagementContext, requested: unknown, deps?: AnthropicResetGrantRouteDeps): AnthropicResetGrantRouteDeps | null { const provider = requested === undefined || requested === null ? "anthropic" : requested; if (!isAnthropicInstanceId(provider)) return null; const selected = deps?.forProvider?.(provider) ?? deps; // Legacy injected dependencies are A-only; B must explicitly bind its own journal. if (selected) return (selected.provider ?? "anthropic") === provider ? { journalPath: anthropicResetJournalPathForInstance(provider), ...selected, provider } : null; return defaultDepsFor(ctx, provider); } function fail(ctx: ManagementContext, status: number, code: ErrorCode, extra: Record<string, unknown> = {}): Response { return jsonResponse({ error: { code, message: MESSAGES[code], ...extra } }, status, ctx.req, ctx.config); } function ledgerFailure(ctx: ManagementContext, error: unknown, extra: Record<string, unknown> = {}): Response { if (error instanceof AnthropicResetLedgerError && error.code === "busy") return fail(ctx, 503, "ledger_busy", extra); return fail(ctx, 503, "ledger_unavailable", extra); } function readFailure(ctx: ManagementContext, error: unknown, extra: Record<string, unknown> = {}): Response { if (error instanceof AnthropicResetGrantError && error.code === "auth") return fail(ctx, 401, "auth_failed", extra); return fail(ctx, 502, "upstream_unavailable", extra); } function resolveAccountId(deps: AnthropicResetGrantRouteDeps, requested: unknown): string | null { const ids = deps.listAccountIds(); if (typeof requested === "string" && requested.trim() !== "") { return ids.includes(requested.trim()) ? requested.trim() : null; } const active = deps.activeAccountId(); return active && ids.includes(active) ? active : ids[0] ?? null; } async function tokenFor(deps: AnthropicResetGrantRouteDeps, accountId: string): Promise<string | null> { try { return await deps.accessTokenFor(accountId); } catch { return null; } } async function handleRead(ctx: ManagementContext, deps: AnthropicResetGrantRouteDeps): Promise<Response> { const receipt = { provider: deps.provider }; const accountId = resolveAccountId(deps, ctx.url.searchParams.get("accountId") ?? undefined); if (!accountId) return fail(ctx, 400, "no_account", receipt); const accessToken = await tokenFor(deps, accountId); if (!accessToken) return fail(ctx, 401, "auth_failed", receipt); if (deps.isCurrent?.() === false) return fail(ctx, 401, "auth_failed", receipt); let status; try { status = await fetchAnthropicResetGrantStatus({ accessToken, fetchFn: deps.fetchFn }); } catch (error) { return readFailure(ctx, error, receipt); } if (deps.isCurrent?.() === false) return fail(ctx, 401, "auth_failed", receipt); let pendingOperation = null; let journalAvailable = true; try { pendingOperation = pendingAnthropicResetOperation(accountId, { journalPath: deps.journalPath, now: deps.now?.() }); } catch { journalAvailable = false; } return jsonResponse({ provider: deps.provider, accountId, ...status, pendingOperation, journalAvailable }, 200, ctx.req, ctx.config); } async function handleConsume(ctx: ManagementContext, injected?: AnthropicResetGrantRouteDeps): Promise<Response> { if (!hasHumanDashboardSession(ctx)) return fail(ctx, 403, "session_required"); let body: Record<string, unknown>; try { const parsed = await ctx.req.json() as unknown; if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fail(ctx, 400, "invalid_json"); body = parsed as Record<string, unknown>; } catch { return fail(ctx, 400, "invalid_json"); } const deps = selectDeps(ctx, body.provider, injected); if (!deps) return fail(ctx, 400, "invalid_provider"); const provider = deps.provider; const operationReceipt = { provider }; const scopedFail = (status: number, code: ErrorCode, extra: Record<string, unknown> = {}) => fail(ctx, status, code, { ...operationReceipt, ...extra }); const { grantId, operationId } = body; if (typeof grantId !== "string" || !ANTHROPIC_RESET_GRANT_ID_RE.test(grantId)) return scopedFail(400, "invalid_grant_id"); if (typeof operationId !== "string" || !UUID_V4_RE.test(operationId)) return scopedFail(400, "invalid_operation_id"); if (typeof body.accountId !== "string") return scopedFail(400, "no_account"); const accountId = resolveAccountId(deps, body.accountId); if (!accountId) return scopedFail(400, "no_account"); const accessToken = await tokenFor(deps, accountId); if (!accessToken || deps.isCurrent?.() === false) return scopedFail(401, "auth_failed"); let organizationUuid: string; try { organizationUuid = await fetchAnthropicOrganizationUuid({ accessToken, fetchFn: deps.fetchFn }); } catch (error) { return readFailure(ctx, error, operationReceipt); } if (deps.isCurrent?.() === false) return scopedFail(401, "auth_failed"); const ledger = { journalPath: deps.journalPath, now: deps.now?.() }; // Retry-after cooldowns survive a usage probe. A journaled reset, including a // replay after the process died before admission, has to lift this account, // but only refusals recorded before the claim was journaled and only for the // windows the journal says were cleared. A failed reread must not turn a // spent grant into an error. const admitJournaledReset = async (code: string, evidence: AnthropicResetAdmissionEvidence): Promise<void> => { if (code !== "reset" || deps.isCurrent?.() === false) return; try { await deps.admitReset?.(accountId, evidence); } catch { /* The grant is already spent. */ } }; // A new operation must pass the spend gate on a fresh read. A same-id retry of // an open record skips it: that attempt was already gated, and upstream // answers a repeated request id for itself. let known: boolean; try { known = anthropicResetOperationExists(operationId, ledger); } catch (error) { return ledgerFailure(ctx, error, operationReceipt); } if (!known) { let status; try { status = await fetchAnthropicResetGrantStatus({ accessToken, fetchFn: deps.fetchFn }); } catch (error) { return readFailure(ctx, error, operationReceipt); } const blocker = anthropicResetGrantBlocker(status, grantId); if (blocker) return scopedFail(409, "grant_not_usable", { reason: blocker }); } let begin; if (deps.isCurrent?.() === false) return scopedFail(401, "auth_failed"); try { begin = beginAnthropicResetOperation( { operationId, accountId, grantId, orgDigest: anthropicOrgDigest(organizationUuid) }, { journalPath: deps.journalPath, now: deps.now?.() }, ); } catch (error) { return ledgerFailure(ctx, error, operationReceipt); } switch (begin.kind) { case "replay": await admitJournaledReset(begin.code, { claimedAt: begin.claimedAt, cleared: begin.cleared }); return jsonResponse( { provider, code: begin.code, replayed: true, resetsLeft: begin.resetsLeft, accountId, grantId, operationId }, 200, ctx.req, ctx.config, ); case "identity-mismatch": return scopedFail(409, "operation_identity_mismatch"); case "in-flight": return scopedFail(409, "in_flight"); case "expired": return scopedFail(409, "unknown_outcome_expired"); case "unresolved-prior": return scopedFail(409, "unresolved_prior_operation", { pendingOperationId: begin.operationId }); case "capacity": return scopedFail(503, "ledger_capacity"); case "execute": break; } let answer; try { answer = await claimAnthropicResetGrant({ accessToken, organizationUuid, grantId, requestId: operationId, fetchFn: deps.fetchFn, }); } catch { try { releaseAnthropicResetLease(operationId, { journalPath: deps.journalPath, now: deps.now?.() }); } catch { /* the lease expires on its own */ } return scopedFail(502, "unknown_outcome", { operationId, grantId, accountId }); } let settled; try { settled = settleAnthropicResetOperation( { operationId, code: answer.code, resetsLeft: answer.resetsLeft, cleared: answer.cleared }, { journalPath: deps.journalPath, now: deps.now?.() }, ); } catch { // Fail closed: the caller must not read this as a durable result. return scopedFail(500, "journal_write_failed", { operationId, grantId, accountId }); } // Report what the journal holds. An overlapping same-id attempt may have // settled first; its answer is the canonical one. const replayed = settled.code !== answer.code || settled.resetsLeft !== answer.resetsLeft; await admitJournaledReset(settled.code, { claimedAt: settled.claimedAt, cleared: settled.cleared }); return jsonResponse( { provider, code: settled.code, replayed, resetsLeft: settled.resetsLeft, cleared: replayed ? [] : answer.cleared, accountId, grantId, operationId, }, 200, ctx.req, ctx.config, ); } export async function handleAnthropicResetGrantRoutes( ctx: ManagementContext, deps?: AnthropicResetGrantRouteDeps, ): Promise<Response | null> { const { pathname } = ctx.url; if (pathname === "/api/anthropic/reset-grants") { if (ctx.req.method !== "GET") return fail(ctx, 405, "method_not_allowed"); const selected = selectDeps(ctx, ctx.url.searchParams.get("provider"), deps); return selected ? handleRead(ctx, selected) : fail(ctx, 400, "invalid_provider"); } if (pathname === "/api/anthropic/reset-grants/consume") { if (ctx.req.method !== "POST") return fail(ctx, 405, "method_not_allowed"); return handleConsume(ctx, deps); } return null; }