@cortexkit/opencode-openai-auth 0.7.2 → 0.8.0

package/dist/index.d.ts

@@ -1,48 +1,393 @@
-import type { Hooks, Plugin, PluginInput } from '@opencode-ai/plugin';
-import { type ResetTargetIdentity } from './commands';
-import { type AccountStorage, type FallbackAccount, loadAccounts, type OAuthAccount, type OAuthQuotaSnapshot } from './core/accounts';
-import { QuotaManager } from './core/quota-manager';
-import { type SidebarMachineState, type SidebarState } from './sidebar-state';
+import { SidebarMachineState, SidebarState } from "./sidebar-state.js";
+import { Hooks, Plugin, PluginInput } from "@opencode-ai/plugin";
+//#region ../core/dist/provider.d.ts
+type QuotaWindowName = string;
+type ProviderQuotaFn = (input: {
+  accessToken: string;
+  fetchImpl: typeof fetch;
+  now: () => number;
+}) => Promise<OAuthQuotaSnapshot>;
+//#endregion
+//#region ../core/dist/quota-manager.d.ts
+type QuotaEntry = {
+  quota: OAuthQuotaSnapshot;
+  refreshAfter: number;
+  checkedAt: number;
+  accountId?: string;
+};
+type QuotaManagerOptions = {
+  storage: AccountStorage | null;
+  fetchImpl?: typeof fetch;
+  /**
+   * Account config file this manager's cross-process refresh locks are named
+   * after. Host-resolved and required, so two hosts pointing at different
+   * stores never contend on one another's lock.
+   */
+  configPath: string;
+  now?: () => number;
+  /** Injected quota-fetch function — replaces the hard-imported Anthropic fetchOAuthQuotaSnapshot */
+  fetchQuotaFn?: ProviderQuotaFn;
+  onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, fingerprint: string, fetchStartedAt: number) => void;
+  onApiError?: (error: AccountOperationError) => void;
+};
+declare class QuotaManager {
+  private main;
+  private mainTokenFp;
+  private mainQuotaAccountId;
+  private fallbacks;
+  private fallbackTokenFps;
+  private inflightMain;
+  private inflightMainFp;
+  private inflightFallbacks;
+  private mainLastApiError;
+  private fallbackApiErrors;
+  private fallbackErrorTokenFps;
+  private rateLimitedUntilMap;
+  private apiGate;
+  private lastApiCallAt;
+  private storage;
+  private readonly fetchImpl;
+  private readonly now;
+  private readonly fetchQuotaFn;
+  private readonly onMainQuotaFetched;
+  private readonly onApiError;
+  private readonly configPath;
+  constructor(opts: QuotaManagerOptions);
+  /**
+   * Cached main quota entry. Pass the live access token to enforce token
+   * binding: if the cached entry was produced by a different token (main
+   * account switched), it is dropped and null is returned so the caller
+   * refetches for the current account. Called without a token (e.g. for
+   * display) it returns whatever is cached.
+   */
+  getMain(accessToken?: string): QuotaEntry | null;
+  /**
+   * Cached fallback quota entry. Pass the live access token to enforce token
+   * binding: if the entry was produced by a different token (account re-login),
+   * it is dropped and null is returned so the caller refetches.
+   */
+  getFallback(accountId: string, accessToken?: string): QuotaEntry | null;
+  getAllFallbacks(): Map<string, QuotaEntry>;
+  setMain(accessToken: string, entry: QuotaEntry, accountId?: string, completeSnapshot?: boolean): void;
+  /**
+   * Non-invalidating read of the cached main quota for POLICY decisions
+   * (killswitch). Unlike getMain(token), a token mismatch does NOT drop the
+   * cache — an access-token refresh is a same-account event and must not turn a
+   * known-exhausted account into "unknown" (which would fail open and spend).
+   *
+   * Pass the live ChatGPT accountId to still drop on a genuine account SWITCH:
+   * if the cached entry's account identity is known and differs, return null so
+   * the killswitch treats it as unknown rather than judging account A by account
+   * B's quota. When identity is unknown on either side, the cached snapshot is
+   * returned (best-effort) — the same fail-open-on-unknown stance as elsewhere.
+   */
+  peekMainForPolicy(accountId?: string): QuotaEntry | null;
+  /**
+   * Non-invalidating read of a cached fallback quota for POLICY decisions
+   * (killswitch, admission). Keyed by the stable internal account id, so a
+   * token refresh for the same account does not drop it (getFallback(id, token)
+   * would).
+   *
+   * Pass the live ChatGPT identity to still drop on a genuine re-login: if the
+   * cached entry's identity is known and differs, return null so the previous
+   * identity's (possibly exhausted) quota is never judged against its
+   * replacement. Unknown on either side fails open, matching peekMainForPolicy.
+   */
+  peekFallbackForPolicy(accountId: string, identity?: string): QuotaEntry | null;
+  setFallback(accountId: string, entry: QuotaEntry, accessToken?: string, completeSnapshot?: boolean, identity?: string): void;
+  /**
+   * Mark accountId ('main' or a fallback id) rate-limited until resetAtMs.
+   * Keeps the LATER reset: skips only when an existing mark is strictly
+   * later than resetAtMs, so an equal-reset re-mark still applies (idempotent)
+   * instead of being silently dropped by a stale `>=` comparison.
+   */
+  markRateLimited(accountId: string, resetAtMs: number): void;
+  /** True iff accountId has a mark whose reset has not yet passed. */
+  isRateLimited(accountId: string): boolean;
+  /**
+   * Raw stored reset for accountId's mark, or undefined if none. Unlike
+   * isRateLimited, this does NOT apply read-time expiry — callers on the
+   * block path already know the mark is live (isRateLimited just returned
+   * true) and want its exact reset estimate for a Retry-After computation.
+   */
+  rateLimitedUntil(accountId: string): number | undefined;
+  /** Explicit early clear — read-time expiry in isRateLimited is primary. */
+  clearRateLimited(accountId: string): void;
+  refreshMain(accessToken: string): Promise<OAuthQuotaSnapshot>;
+  refreshFallback(accountId: string, accessToken: string): Promise<OAuthQuotaSnapshot>;
+  refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
+  /**
+   * Fire-and-forget refresh. Does not await, swallows errors.
+   */
+  refreshMainInBackground(accessToken: string): void;
+  isMainStale(): boolean;
+  isFallbackStale(accountId: string, accessToken?: string): boolean;
+  shouldRefreshOnRequestCount(requestCount: number): boolean;
+  /**
+   * Combined check: should a refresh happen right now?
+   * True if main is stale by time OR triggered by request count.
+   */
+  needsRefresh(requestCount: number): boolean;
+  updateStorage(storage: AccountStorage | null): void;
+  /**
+   * Seed/update the main quota cache from persisted state. This is deliberately
+   * callable after every disk load so another plugin process's fresh quota write
+   * can stop this process from showing "checking…" or making a redundant quota
+   * API call.
+   */
+  seedMainFromStorage(storage: AccountStorage | null, accessToken?: string): void;
+  private seedMainBackoffFromStorage;
+  /**
+   * Seed fallback cache entries from persisted account.quota data.
+   * Updates older in-memory entries so a fresh quota write from another plugin
+   * process prevents redundant checks and stale sidebar writes.
+   */
+  seedFallbacksFromAccounts(accounts: OAuthAccount[]): void;
+  /**
+   * Whether the MAIN quota API is currently in backoff. Scoped to the main
+   * account — a fallback account's 429 never reports here.
+   */
+  isBackedOff(): boolean;
+  /**
+   * Whether a specific fallback account's quota API is in backoff.
+   */
+  isFallbackBackedOff(accountId: string, accessToken?: string): boolean;
+  getLastApiError(): AccountOperationError | undefined;
+  /** Minimum gap between consecutive quota API calls (ms). */
+  private static readonly API_CALL_GAP_MS;
+  private static fallbackInflightKey;
+  private static quotaLockName;
+  /**
+   * Serialize API calls through a shared gate so only one
+   * quota API request runs at a time, with a minimum gap
+   * between calls. Prevents concurrent and rapid-fire calls
+   * from triggering rate limits.
+   */
+  private _enqueueApiFetch;
+  private _fetchMain;
+  private _fetchFallback;
+  /** Route through injected fetchQuotaFn, or throw if unset. */
+  private _fetchQuota;
+  private static isAuthError;
+  /** Main quota failure: arms main-only backoff and persists via onApiError. */
+  private _handleMainFetchError;
+  /**
+   * Fallback quota failure: arms backoff for THIS account only. Never touches
+   * main backoff state and never calls onApiError (which persists the main
+   * quota error) — the per-account error is recorded by the caller via the
+   * account's lastQuotaRefreshError.
+   */
+  private _handleFallbackFetchError;
+}
+//#endregion
+//#region ../core/dist/paths.d.ts
+/**
+ * The config file and the runtime-state file a store operation reads and writes.
+ *
+ * Both are required. A store function never derives one from the other, because
+ * a host may point its state file somewhere the derivation would not reach and
+ * a silently derived path would lock one file while writing another.
+ */
+interface AccountPaths {
+  configPath: string;
+  statePath: string;
+}
+//#endregion
+//#region ../core/dist/accounts.d.ts
+type AccountQuotaWindow = {
+  usedPercent: number;
+  remainingPercent: number;
+  resetsAt?: string;
+  checkedAt: number;
+  windowMinutes?: number;
+};
+interface OAuthQuotaSnapshot {
+  primary?: AccountQuotaWindow;
+  secondary?: AccountQuotaWindow;
+  resetCreditsAvailable?: number;
+  resetCreditsApplicable?: number;
+}
+type AccountBase = {
+  id: string;
+  label?: string;
+  enabled?: boolean;
+  addedAt?: number;
+  lastUsed?: number;
+  /** Stable ChatGPT account identifier extracted from the OAuth token claims. */
+  accountId?: string;
+};
+type AccountOperationError = {
+  message: string;
+  checkedAt: number;
+  nextRetryAt?: number;
+  retryCount?: number;
+  tokenHash?: string;
+};
+type OAuthAccount = AccountBase & {
+  type: 'oauth';
+  access?: string;
+  refresh: string;
+  expires?: number;
+  lastRefreshedAt?: number;
+  lastRefreshError?: AccountOperationError;
+  lastQuotaRefreshError?: AccountOperationError;
+  quota?: OAuthQuotaSnapshot;
+};
+type ApiKeyAccount = AccountBase & {
+  type: 'api';
+  apiKey?: string;
+  baseURL: string;
+  authHeader?: 'authorization-bearer' | 'x-api-key';
+};
+type FallbackAccount = OAuthAccount | ApiKeyAccount;
+type RoutingMode = 'main-first' | 'fallback-first' | 'sticky-balanced';
+type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w', number>>;
+type KillswitchConfig = {
+  enabled?: boolean;
+  main?: KillswitchThresholds;
+  accounts?: Record<string, KillswitchThresholds>;
+};
+interface ResetInFlight {
+  redeemRequestId: string;
+  creditId: string;
+  startedAt: number;
+}
+interface ResetLastOutcome {
+  code: string;
+  at: number;
+  previousOutcome?: {
+    code: string;
+    at: number;
+  };
+}
+interface ResetAccountState {
+  inFlight?: ResetInFlight | Record<string, unknown>;
+  lastOutcome?: ResetLastOutcome;
+  cooldownUntil?: number;
+}
+type ResetStateByAccount = Record<string, ResetAccountState>;
+type AccountStorage = {
+  version: 1;
+  main?: {
+    type: 'opencode';
+    provider: 'openai';
+  };
+  routing?: {
+    mode?: RoutingMode;
+  };
+  fallbackOn?: number[];
+  refresh?: {
+    enabled?: boolean;
+    intervalMinutes?: number;
+    refreshBeforeExpiryMinutes?: number;
+    mainLastRefreshError?: AccountOperationError;
+    mainRefreshLeaseId?: string;
+    mainRefreshLeaseUntil?: number;
+    mainRefreshLeaseTokenHash?: string;
+  };
+  quota?: {
+    enabled?: boolean;
+    checkIntervalMinutes?: number;
+    refreshEveryNRequests?: number;
+    minimumRemaining?: Partial<Record<QuotaWindowName | '5h' | '1w', number>>;
+    failClosedOnUnknownQuota?: boolean;
+    showToasts?: boolean;
+    mainQuota?: OAuthQuotaSnapshot;
+    mainQuotaCheckedAt?: number;
+    mainQuotaToken?: string;
+    mainLastQuotaApiError?: AccountOperationError;
+  };
+  reset?: ResetStateByAccount;
+  dump?: {
+    enabled?: boolean;
+  };
+  costZeroing?: {
+    enabled?: boolean;
+  };
+  killswitch?: KillswitchConfig;
+  logging?: {
+    level?: string;
+  };
+  cachekeep?: {
+    enabled?: boolean;
+    subagents?: boolean;
+    sustain?: boolean;
+    /** Clock-hour window start (0-23, inclusive) — keeps cachekeep idle warming
+     *  inside `[startHour, endHour)` local hours. Omit to warm unconditionally. */
+    startHour?: number;
+    /** Clock-hour window end (0-23, exclusive) — must differ from startHour
+     *  to be honored; an unset or equal hour falls back to "always warm". */
+    endHour?: number;
+  };
+  /** Stable ChatGPT account identifier of the main account (extracted from OAuth token). */
+  mainAccountId?: string;
+  accounts: FallbackAccount[];
+};
+declare function loadAccounts(paths: AccountPaths): Promise<AccountStorage | null>;
+//#endregion
+//#region ../core/dist/oauth.d.ts
+interface IdTokenClaims {
+  chatgpt_account_id?: string;
+  email?: string;
+  organizations?: Array<{
+    id: string;
+  }>;
+  'https://api.openai.com/auth'?: {
+    chatgpt_account_id?: string;
+  };
+}
+export declare function parseJwtClaims(token: string): IdTokenClaims | undefined;
+export declare function extractAccountIdFromClaims(claims: IdTokenClaims): string | undefined;
+//#endregion
+//#region ../core/dist/commands.d.ts
+interface ResetTargetIdentity {
+  accountKey: string;
+  label: string;
+  accessToken: string;
+  chatgptAccountId?: string;
+}
+//#endregion
+//#region src/index.d.ts
 export declare const MAIN_REFRESH_LOCK_TTL_MS: number;
 export declare const MAIN_REFRESH_LEASE_TTL_MS = 90000;
 export declare class AuthPersistError extends Error {
-    readonly code = "OPENAI_AUTH_PERSIST_FAILED";
-    constructor(cause: unknown);
+  readonly code = "OPENAI_AUTH_PERSIST_FAILED";
+  constructor(cause: unknown);
 }
 export type ResetTargetResolutionErrorKind = 'unknown_account' | 'disabled_account' | 'non_oauth_account' | 'token_unavailable';
 export declare class ResetTargetResolutionError extends Error {
-    readonly code: ResetTargetResolutionErrorKind;
-    constructor(code: ResetTargetResolutionErrorKind, message: string);
+  readonly code: ResetTargetResolutionErrorKind;
+  constructor(code: ResetTargetResolutionErrorKind, message: string);
 }
 interface ResetTargetResolverDeps {
-    getAuth: () => Promise<{
-        type: string;
-        access?: string;
-        refresh?: string;
-        expires?: number;
-    }>;
-    refreshMainWithLease: () => Promise<{
-        access: string;
-        refresh: string;
-        expires: number;
-    }>;
-    refreshFallbackAccount: (account: OAuthAccount, storage: AccountStorage) => Promise<OAuthAccount>;
-    loadAccounts: typeof loadAccounts;
-    accountStoragePath: string;
-    now: () => number;
+  getAuth: () => Promise<{
+    type: string;
+    access?: string;
+    refresh?: string;
+    expires?: number;
+  }>;
+  refreshMainWithLease: () => Promise<{
+    access: string;
+    refresh: string;
+    expires: number;
+  }>;
+  refreshFallbackAccount: (account: OAuthAccount, storage: AccountStorage) => Promise<OAuthAccount>;
+  loadAccounts: typeof loadAccounts;
+  accountStoragePath: string;
+  accountStatePath: string;
+  now: () => number;
 }
 export declare function createResetTargetResolver(deps: ResetTargetResolverDeps): (accountKey: string) => Promise<ResetTargetIdentity>;
 export declare function buildResetRedemptionDeps(): {
-    fetchImpl: typeof fetch;
-    now: () => number;
-    randomUUID: () => `${string}-${string}-${string}-${string}-${string}`;
+  fetchImpl: typeof fetch;
+  now: () => number;
+  randomUUID: () => `${string}-${string}-${string}-${string}-${string}`;
 };
-export { extractAccountIdFromClaims, type IdTokenClaims, parseJwtClaims, } from './core/oauth';
 interface CodexAuthPluginOptions {
-    issuer?: string;
-    codexApiEndpoint?: string;
-    experimentalWebSockets?: boolean;
-    responsesLite?: boolean;
+  issuer?: string;
+  codexApiEndpoint?: string;
+  experimentalWebSockets?: boolean;
+  responsesLite?: boolean;
 }
 export declare function findCachekeepFallbackAccount(accounts: FallbackAccount[], accountId: string): OAuthAccount | undefined;
 export declare function mergePushedQuotaMetadata(incoming: OAuthQuotaSnapshot, previous: OAuthQuotaSnapshot | undefined): OAuthQuotaSnapshot;
@@ -52,7 +397,8 @@ export declare function resolveSidebarSessionId(headers: Headers): string | unde
 export declare function CodexAuthPlugin(input: PluginInput, options?: CodexAuthPluginOptions): Promise<Hooks>;
 export declare const OpenAIAuthPlugin: Plugin;
 declare const _default: {
-    id: string;
-    server: Plugin;
+  id: string;
+  server: Plugin;
 };
-export default _default;
+//#endregion
+export { type IdTokenClaims, _default as default };