@cortexkit/anthropic-auth-core 1.1.0 → 1.1.1

package/dist/accounts.d.ts

@@ -20,6 +20,9 @@ export type OAuthAccount = {
 export type AccountOperationError = {
     message: string;
     checkedAt: number;
+    nextRetryAt?: number;
+    retryCount?: number;
+    tokenHash?: string;
 };
 export type AccountQuotaWindow = {
     usedPercent: number;
@@ -38,6 +41,10 @@ export type AccountStorage = {
         enabled?: boolean;
         intervalMinutes?: number;
         refreshBeforeExpiryMinutes?: number;
+        mainLastRefreshError?: AccountOperationError;
+        mainRefreshLeaseId?: string;
+        mainRefreshLeaseUntil?: number;
+        mainRefreshLeaseTokenHash?: string;
     };
     quota?: {
         enabled?: boolean;
@@ -86,6 +93,16 @@ export declare function setDumpPersistentEnabled(enabled: boolean, path?: string
 export declare function isFastModePersistentlyEnabled(storage: AccountStorage | null): boolean;
 export declare function setFastModePersistentEnabled(enabled: boolean, path?: string): Promise<AccountStorage>;
 export declare function shouldFallbackStatus(status: number, storage: AccountStorage | null): boolean;
+export declare function getRefreshIntervalMs(storage: AccountStorage | null): number;
+export declare function hashRefreshToken(refreshToken: string): string;
+export declare function buildRefreshOperationError(input: {
+    error: unknown;
+    now: number;
+    refreshToken: string;
+    previous?: AccountOperationError;
+}): AccountOperationError;
+export declare function refreshBackoffActive(error: AccountOperationError | undefined, refreshToken: string | undefined, now: number): boolean;
+export declare function formatRefreshBackoffMessage(error: AccountOperationError, now: number): string;
 export declare function getQuotaCheckIntervalMs(storage: AccountStorage | null): number;
 export declare function quotaSnapshotPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null): boolean;
 export declare function getQuotaNextRefreshAt(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, now: number): number;

package/dist/accounts.js

@@ -1,13 +1,17 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { refreshClaudeOAuthToken } from "./auth.js";
+import { ClaudeOAuthRefreshError, refreshClaudeOAuthToken } from "./auth.js";
 import { CACHE_1H_MODES, CLAUDE_CODE_VERSION, DEFAULT_CACHE_1H_MODE, } from "./constants.js";
 export const ACCOUNT_FILE_NAME = 'anthropic-auth.json';
 export const QUOTA_URL = 'https://api.anthropic.com/api/oauth/usage';
 const DEFAULT_FALLBACK_ON = [401, 403, 429];
 const DEFAULT_REFRESH_BEFORE_EXPIRY_MINUTES = 30;
+const DEFAULT_REFRESH_INTERVAL_MINUTES = 10;
+const MIN_REFRESH_RETRY_DELAY_MS = 5 * 60_000;
+const MAX_REFRESH_RETRY_DELAY_MS = 60 * 60_000;
+const NON_TRANSIENT_REFRESH_RETRY_DELAY_MS = 24 * 60 * 60_000;
 const DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES = 5;
 const DEFAULT_MINIMUM_REMAINING = {
     five_hour: 0,
@@ -63,7 +67,15 @@ function normalizeOperationError(value) {
     const checkedAt = Number(value.checkedAt);
     if (!Number.isFinite(checkedAt))
         return undefined;
-    return { message: value.message, checkedAt };
+    const nextRetryAt = Number(value.nextRetryAt);
+    const retryCount = Number(value.retryCount);
+    return {
+        message: value.message,
+        checkedAt,
+        nextRetryAt: Number.isFinite(nextRetryAt) ? nextRetryAt : undefined,
+        retryCount: Number.isFinite(retryCount) ? retryCount : undefined,
+        tokenHash: typeof value.tokenHash === 'string' ? value.tokenHash : undefined,
+    };
 }
 function normalizeQuota(value) {
     if (!isRecord(value))
@@ -245,6 +257,50 @@ function refreshBeforeExpiryMs(storage) {
         DEFAULT_REFRESH_BEFORE_EXPIRY_MINUTES;
     return Math.max(0, minutes) * 60_000;
 }
+export function getRefreshIntervalMs(storage) {
+    const minutes = storage?.refresh?.intervalMinutes ?? DEFAULT_REFRESH_INTERVAL_MINUTES;
+    return Math.max(1, minutes) * 60_000;
+}
+export function hashRefreshToken(refreshToken) {
+    return createHash('sha256').update(refreshToken).digest('hex');
+}
+function isTransientRefreshError(error) {
+    if (error instanceof ClaudeOAuthRefreshError) {
+        return error.status === 429 || error.status >= 500;
+    }
+    if (!(error instanceof Error))
+        return false;
+    return (error.message.includes('fetch failed') ||
+        ('code' in error &&
+            (error.code === 'ECONNRESET' ||
+                error.code === 'ECONNREFUSED' ||
+                error.code === 'ETIMEDOUT' ||
+                error.code === 'UND_ERR_CONNECT_TIMEOUT')));
+}
+export function buildRefreshOperationError(input) {
+    const retryCount = (input.previous?.retryCount ?? 0) + 1;
+    const delay = isTransientRefreshError(input.error)
+        ? Math.min(MAX_REFRESH_RETRY_DELAY_MS, MIN_REFRESH_RETRY_DELAY_MS * 2 ** Math.min(retryCount - 1, 6))
+        : NON_TRANSIENT_REFRESH_RETRY_DELAY_MS;
+    return {
+        message: formatErrorMessage(input.error),
+        checkedAt: input.now,
+        nextRetryAt: input.now + delay,
+        retryCount,
+        tokenHash: hashRefreshToken(input.refreshToken),
+    };
+}
+export function refreshBackoffActive(error, refreshToken, now) {
+    if (!error?.nextRetryAt || error.nextRetryAt <= now)
+        return false;
+    if (!refreshToken)
+        return true;
+    return error.tokenHash === hashRefreshToken(refreshToken);
+}
+export function formatRefreshBackoffMessage(error, now) {
+    const seconds = Math.max(1, Math.ceil(((error.nextRetryAt ?? now) - now) / 1000));
+    return `Claude OAuth refresh is backed off for ${seconds}s after: ${error.message}`;
+}
 export function getQuotaCheckIntervalMs(storage) {
     const minutes = storage?.quota?.checkIntervalMinutes ?? DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES;
     return Math.max(1, minutes) * 60_000;
@@ -353,16 +409,21 @@ function formatErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function recordRefreshError(account, error, now) {
-    account.lastRefreshError = {
-        message: formatErrorMessage(error),
-        checkedAt: now,
-    };
+    account.lastRefreshError = buildRefreshOperationError({
+        error,
+        now,
+        refreshToken: account.refresh,
+        previous: account.lastRefreshError,
+    });
 }
 function recordQuotaRefreshError(account, error, now) {
     account.lastQuotaRefreshError = {
         message: formatErrorMessage(error),
         checkedAt: now,
     };
+    if (error instanceof ClaudeOAuthRefreshError) {
+        recordRefreshError(account, error, now);
+    }
 }
 export class FallbackAccountManager {
     now;
@@ -383,22 +444,18 @@ export class FallbackAccountManager {
         await saveAccounts(storage, this.configPath);
     }
     startBackgroundRefresh() {
-        void this.refreshDueAccounts().catch(() => { });
-        void this.refreshQuotaForDueAccounts().catch(() => { });
+        const run = async () => {
+            await this.refreshDueAccounts();
+            await this.refreshQuotaForDueAccounts();
+        };
+        void run().catch(() => { });
         if (!this.refreshTimer) {
             this.refreshTimer = setInterval(() => {
-                void this.refreshDueAccounts().catch(() => { });
+                void run().catch(() => { });
             }, BACKGROUND_TICK_MS);
             if ('unref' in this.refreshTimer)
                 this.refreshTimer.unref();
         }
-        if (!this.quotaTimer) {
-            this.quotaTimer = setInterval(() => {
-                void this.refreshQuotaForDueAccounts().catch(() => { });
-            }, BACKGROUND_TICK_MS);
-            if ('unref' in this.quotaTimer)
-                this.quotaTimer.unref();
-        }
     }
     stopBackgroundRefresh() {
         if (this.refreshTimer)
@@ -420,6 +477,11 @@ export class FallbackAccountManager {
             try {
                 let next = account;
                 if (tokenNeedsRefresh(next, storage, this.now())) {
+                    const refreshError = next.lastRefreshError;
+                    if (refreshError &&
+                        refreshBackoffActive(refreshError, next.refresh, this.now())) {
+                        throw new Error(formatRefreshBackoffMessage(refreshError, this.now()));
+                    }
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }
@@ -462,6 +524,9 @@ export class FallbackAccountManager {
                 continue;
             if (!tokenNeedsRefresh(account, storage, this.now()))
                 continue;
+            if (refreshBackoffActive(account.lastRefreshError, account.refresh, this.now())) {
+                continue;
+            }
             try {
                 await this.refreshAccount(account, storage);
                 changed = true;
@@ -487,6 +552,9 @@ export class FallbackAccountManager {
             let next = account;
             try {
                 if (tokenNeedsRefresh(next, storage, this.now())) {
+                    if (refreshBackoffActive(next.lastRefreshError, next.refresh, this.now())) {
+                        continue;
+                    }
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }
@@ -517,6 +585,11 @@ export class FallbackAccountManager {
             let next = account;
             try {
                 if (tokenNeedsRefresh(next, storage, this.now())) {
+                    const refreshError = next.lastRefreshError;
+                    if (refreshError &&
+                        refreshBackoffActive(refreshError, next.refresh, this.now())) {
+                        throw new Error(formatRefreshBackoffMessage(refreshError, this.now()));
+                    }
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "repository": {
     "type": "git",