@cortexkit/anthropic-auth-core 1.15.0 → 1.16.0

package/dist/dump.d.ts

@@ -13,6 +13,25 @@ export declare function isDumpEnabled(): boolean;
 export declare function setDumpEnabled(enabled: boolean): void;
 export declare function resetDumpState(): void;
 export declare function getDumpDirectory(): string;
+export declare function writeDumpFile(path: string, contents: string): Promise<boolean>;
+/**
+ * Caps completed dump artifacts in the configured directory. A zero-byte cap
+ * disables sweeping. Custom directories may contain unrelated files: only
+ * recognized final artifact names and stale partials are eligible. Symlinks,
+ * fresh partial writes, and files younger than the newness floor remain
+ * protected.
+ */
+export declare function sweepDumpDirectory(options: {
+    dumpDir?: string;
+    maxBytes?: number;
+    protectedPaths?: readonly string[];
+    now?: number;
+    minAgeMs?: number;
+    partialStaleMs?: number;
+}): Promise<{
+    removed: number;
+    freedBytes: number;
+}>;
 export declare function parseDumpCommandAction(argumentsText: string): DumpCommandAction;
 export declare function buildDumpStatusSummary(input?: {
     enabled?: boolean;

package/dist/dump.js

@@ -1,9 +1,9 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { createHash, randomBytes } from 'node:crypto';
+import { lstat, mkdir, readdir, rename, unlink, writeFile, } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { extractBillingHeaderCCH } from "./cch.js";
-import { isSecretKey, relayLog } from "./logger.js";
+import { isSecretKey, logger, relayLog } from "./logger.js";
 export const CLAUDE_DUMP_COMMAND_NAME = 'claude-dump';
 const DUMP_STATUS_TITLE = '## Claude Dump Status';
 const DUMP_ENABLED_TITLE = '## Claude Dump Enabled';
@@ -11,9 +11,21 @@ const DUMP_DISABLED_TITLE = '## Claude Dump Disabled';
 const DUMP_USAGE_TITLE = '## Claude Dump Usage';
 const DUMP_USAGE = 'Usage: `/claude-dump`, `/claude-dump on`, or `/claude-dump off`.';
 const DUMP_DIR_ENV = 'OPENCODE_ANTHROPIC_AUTH_DUMP_DIR';
+const DUMP_MAX_BYTES_ENV = 'OPENCODE_ANTHROPIC_AUTH_DUMP_MAX_BYTES';
 const DEFAULT_DUMP_DIR = join(tmpdir(), 'opencode-anthropic-auth-dumps');
+const DEFAULT_DUMP_MAX_BYTES = 512 * 1024 * 1024;
+const DUMP_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+const DUMP_SWEEP_NEWNESS_FLOOR_MS = 60 * 1000;
+const DUMP_PARTIAL_STALE_MS = 10 * 60 * 1000;
+const DUMP_ARTIFACT_SUFFIX_PATTERN = /\.(body|meta|relay|request)\.json$/;
+// Earlier builds emitted five-digit counters; current counters grow without truncation.
+const DUMP_ARTIFACT_ID_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z-\d{5,}-(.+)$/;
+const DUMP_SEGMENT_PATTERN = '[a-zA-Z0-9._-]';
+const DIRECT_DUMP_PATTERN = new RegExp(`^${DUMP_SEGMENT_PATTERN}{1,80}-direct(?:-${DUMP_SEGMENT_PATTERN}{1,80})?$`);
+const RELAY_DUMP_PATTERN = new RegExp(`^${DUMP_SEGMENT_PATTERN}{1,80}-(?:http|websocket)-p[12]-(?:full_sync|patch)$`);
 let dumpEnabled = false;
 let nextDumpId = 0;
+let lastDumpSweepAt = 0;
 const DIRECT_DUMP_PREVIOUS_BODY_LIMIT = 100;
 const directDumpPreviousBodies = new Map();
 export function isDumpEnabled() {
@@ -25,11 +37,150 @@ export function setDumpEnabled(enabled) {
 export function resetDumpState() {
     dumpEnabled = false;
     nextDumpId = 0;
+    lastDumpSweepAt = 0;
     directDumpPreviousBodies.clear();
 }
 export function getDumpDirectory() {
     return process.env[DUMP_DIR_ENV] || DEFAULT_DUMP_DIR;
 }
+function getDumpMaxBytes() {
+    const configured = Number(process.env[DUMP_MAX_BYTES_ENV]);
+    return Number.isFinite(configured) && configured >= 0
+        ? Math.floor(configured)
+        : DEFAULT_DUMP_MAX_BYTES;
+}
+function isConfiguredDumpDirectory(path) {
+    return resolve(path) === resolve(getDumpDirectory());
+}
+function isDumpArtifactFileName(name) {
+    const stem = name.replace(DUMP_ARTIFACT_SUFFIX_PATTERN, '');
+    if (stem === name)
+        return false;
+    const match = DUMP_ARTIFACT_ID_PATTERN.exec(stem);
+    const requestPath = match?.[1];
+    if (!requestPath)
+        return false;
+    return (DIRECT_DUMP_PATTERN.test(requestPath) ||
+        RELAY_DUMP_PATTERN.test(requestPath));
+}
+function isDumpPartialFileName(name) {
+    if (!name.endsWith('.partial'))
+        return false;
+    const partialStem = name.slice(0, -8);
+    if (isDumpArtifactFileName(partialStem))
+        return true;
+    const separator = partialStem.lastIndexOf('.');
+    if (separator < 0)
+        return false;
+    const nonce = partialStem.slice(separator + 1);
+    return (/^[a-f0-9]{24}$/.test(nonce) &&
+        isDumpArtifactFileName(partialStem.slice(0, separator)));
+}
+export async function writeDumpFile(path, contents) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const nonce = randomBytes(12).toString('hex');
+        const partialPath = `${path}.${nonce}.partial`;
+        let created = false;
+        try {
+            await writeFile(partialPath, contents, { encoding: 'utf8', flag: 'wx' });
+            created = true;
+            await rename(partialPath, path);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                continue;
+            if (created)
+                await unlink(partialPath).catch(() => { });
+            throw error;
+        }
+    }
+    return false;
+}
+/**
+ * Caps completed dump artifacts in the configured directory. A zero-byte cap
+ * disables sweeping. Custom directories may contain unrelated files: only
+ * recognized final artifact names and stale partials are eligible. Symlinks,
+ * fresh partial writes, and files younger than the newness floor remain
+ * protected.
+ */
+export async function sweepDumpDirectory(options) {
+    const dumpDir = options.dumpDir ?? getDumpDirectory();
+    const maxBytes = options.maxBytes ?? getDumpMaxBytes();
+    const now = options.now ?? Date.now();
+    const minAgeMs = options.minAgeMs ?? DUMP_SWEEP_NEWNESS_FLOOR_MS;
+    const partialStaleMs = options.partialStaleMs ?? DUMP_PARTIAL_STALE_MS;
+    const emptyResult = { removed: 0, freedBytes: 0 };
+    if (!isConfiguredDumpDirectory(dumpDir) || maxBytes <= 0)
+        return emptyResult;
+    try {
+        const dumpDirStats = await lstat(dumpDir);
+        if (dumpDirStats.isSymbolicLink())
+            return emptyResult;
+        const protectedPaths = new Set((options.protectedPaths ?? []).map((path) => resolve(path)));
+        const entries = await readdir(dumpDir, { withFileTypes: true });
+        const files = [];
+        await Promise.all(entries.map(async (entry) => {
+            if (!entry.isFile())
+                return;
+            const partial = isDumpPartialFileName(entry.name);
+            if (!partial && !isDumpArtifactFileName(entry.name))
+                return;
+            const path = join(dumpDir, entry.name);
+            try {
+                const stats = await lstat(path);
+                if (!stats.isFile() || stats.isSymbolicLink())
+                    return;
+                files.push({
+                    path,
+                    size: stats.size,
+                    mtimeMs: stats.mtimeMs,
+                    partial,
+                });
+            }
+            catch {
+                // Files can disappear while concurrent dump requests finish.
+            }
+        }));
+        let totalBytes = files.reduce((total, file) => total + file.size, 0);
+        files.sort((left, right) => left.mtimeMs - right.mtimeMs || left.path.localeCompare(right.path));
+        let removed = 0;
+        let freedBytes = 0;
+        for (const file of files) {
+            if (protectedPaths.has(resolve(file.path)))
+                continue;
+            const ageMs = now - file.mtimeMs;
+            const stalePartial = file.partial && ageMs >= partialStaleMs;
+            if (!stalePartial && totalBytes <= maxBytes)
+                continue;
+            if (file.partial ? !stalePartial : ageMs < minAgeMs)
+                continue;
+            try {
+                await unlink(file.path);
+                totalBytes -= file.size;
+                freedBytes += file.size;
+                removed += 1;
+            }
+            catch {
+                // Dump cleanup is best-effort and must not affect request handling.
+            }
+        }
+        if (removed > 0) {
+            logger.debug('dump', 'removed old dump files', { removed, freedBytes });
+        }
+        return { removed, freedBytes };
+    }
+    catch {
+        return emptyResult;
+    }
+}
+function scheduleDumpSweep(dumpDir, protectedPaths) {
+    const now = Date.now();
+    if (now - lastDumpSweepAt < DUMP_SWEEP_INTERVAL_MS)
+        return;
+    lastDumpSweepAt = now;
+    void sweepDumpDirectory({ dumpDir, protectedPaths }).catch(() => { });
+}
 export function parseDumpCommandAction(argumentsText) {
     const normalized = argumentsText.trim().split(/\s+/).filter(Boolean);
     if (normalized.length === 0)
@@ -228,7 +379,7 @@ async function dumpRequest(input) {
         return;
     nextDumpId += 1;
     const affinity = input.affinity?.trim() || 'session-unknown';
-    const id = `${new Date().toISOString().replace(/[:.]/g, '-')}-${String(nextDumpId).padStart(5, '0')}-${dumpFileSessionSegment(affinity)}-${dumpRequestSegment(input)}`;
+    const id = `${new Date().toISOString().replace(/[:.]/g, '-')}-${String(nextDumpId).padStart(6, '0')}-${dumpFileSessionSegment(affinity)}-${dumpRequestSegment(input)}`;
     const dumpDir = getDumpDirectory();
     const prefix = join(dumpDir, id);
     const files = {
@@ -259,19 +410,20 @@ async function dumpRequest(input) {
             files,
         };
         const writes = [
-            writeFile(files.body, input.bodyText, 'utf8'),
-            writeFile(files.metadata, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8'),
+            writeDumpFile(files.body, input.bodyText),
+            writeDumpFile(files.metadata, `${JSON.stringify(metadata, null, 2)}\n`),
         ];
         if (input.payload !== undefined && files.relay) {
-            writes.push(writeFile(files.relay, `${JSON.stringify(redactForDump(input.payload), null, 2)}\n`, 'utf8'));
+            writes.push(writeDumpFile(files.relay, `${JSON.stringify(redactForDump(input.payload), null, 2)}\n`));
         }
         if (input.request !== undefined && files.request) {
-            writes.push(writeFile(files.request, `${JSON.stringify(redactForDump({
+            writes.push(writeDumpFile(files.request, `${JSON.stringify(redactForDump({
                 ...input.request,
                 headers: headersToRecord(input.request.headers),
-            }), null, 2)}\n`, 'utf8'));
+            }), null, 2)}\n`));
         }
         await Promise.all(writes);
+        scheduleDumpSweep(dumpDir, Object.values(files));
         relayLog(`dumped request id=${id} session=${shortAffinity(affinity)} body=${files.body} meta=${files.metadata}`);
     }
     catch (error) {

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './accounts.ts';
 export * from './auth.ts';
 export * from './cache1h.ts';
 export * from './cachekeep.ts';
+export * from './cachekeep-registry.ts';
 export * from './cch.ts';
 export * from './claude-code.ts';
 export * from './commands/account.ts';
@@ -18,3 +19,4 @@ export * from './quota-manager.ts';
 export * from './quotas.ts';
 export * from './relay.ts';
 export * from './routing.ts';
+export * from './sticky-routing.ts';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from "./accounts.js";
 export * from "./auth.js";
 export * from "./cache1h.js";
 export * from "./cachekeep.js";
+export * from "./cachekeep-registry.js";
 export * from "./cch.js";
 export * from "./claude-code.js";
 export * from "./commands/account.js";
@@ -18,3 +19,4 @@ export * from "./quota-manager.js";
 export * from "./quotas.js";
 export * from "./relay.js";
 export * from "./routing.js";
+export * from "./sticky-routing.js";

package/dist/quota-manager.d.ts

@@ -67,14 +67,15 @@ export declare class QuotaManager {
      * Fire-and-forget refresh. Does not await, swallows errors.
      */
     refreshMainInBackground(accessToken: string): void;
-    isMainStale(): boolean;
-    isFallbackStale(accountId: string, accessToken?: string): boolean;
+    private scopedWindowIsStale;
+    isMainStale(modelId?: string): boolean;
+    isFallbackStale(accountId: string, accessToken?: string, modelId?: 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;
+    needsRefresh(requestCount: number, modelId?: string): boolean;
     updateStorage(storage: AccountStorage | null): void;
     /**
      * Seed/update the main quota cache from persisted state. This is deliberately

package/dist/quota-manager.js

@@ -6,7 +6,7 @@
  * Handles deduplication, rate-limiting (429 backoff), and staleness.
  */
 import { createHash } from 'node:crypto';
-import { acquireRefreshFileLock, buildQuotaOperationError, fetchOAuthQuotaSnapshot, getPersistedMainQuota, getQuotaCheckIntervalMs, getQuotaNextRefreshAt, getQuotaRefreshEveryNRequests, isQuotaPolicyAuthError, quotaBackoffActive, } from "./accounts.js";
+import { acquireRefreshFileLock, buildQuotaOperationError, fetchOAuthQuotaSnapshot, getPersistedMainQuota, getQuotaCheckIntervalMs, getQuotaNextRefreshAt, getQuotaRefreshEveryNRequests, getScopedQuotaWindowForModel, isQuotaPolicyAuthError, quotaBackoffActive, } from "./accounts.js";
 // Capture real setTimeout before tests can mock globalThis.setTimeout
 const nativeSetTimeout = globalThis.setTimeout;
 /**
@@ -190,17 +190,24 @@ export class QuotaManager {
     // =========================================================================
     // Staleness queries
     // =========================================================================
-    isMainStale() {
+    scopedWindowIsStale(entry, modelId) {
+        const scoped = getScopedQuotaWindowForModel(entry.quota, modelId);
+        return Boolean(scoped &&
+            this.now() - scoped.checkedAt >= getQuotaCheckIntervalMs(this.storage));
+    }
+    isMainStale(modelId) {
         if (!this.main)
             return true;
-        return this.now() >= this.main.refreshAfter;
+        return (this.now() >= this.main.refreshAfter ||
+            this.scopedWindowIsStale(this.main, modelId));
     }
-    isFallbackStale(accountId, accessToken) {
+    isFallbackStale(accountId, accessToken, modelId) {
         // Token-aware: a credential change invalidates the entry (treated as stale).
         const entry = this.getFallback(accountId, accessToken);
         if (!entry)
             return true;
-        return this.now() >= entry.refreshAfter;
+        return (this.now() >= entry.refreshAfter ||
+            this.scopedWindowIsStale(entry, modelId));
     }
     shouldRefreshOnRequestCount(requestCount) {
         const everyN = getQuotaRefreshEveryNRequests(this.storage);
@@ -212,8 +219,9 @@ export class QuotaManager {
      * Combined check: should a refresh happen right now?
      * True if main is stale by time OR triggered by request count.
      */
-    needsRefresh(requestCount) {
-        return this.isMainStale() || this.shouldRefreshOnRequestCount(requestCount);
+    needsRefresh(requestCount, modelId) {
+        return (this.isMainStale(modelId) ||
+            this.shouldRefreshOnRequestCount(requestCount));
     }
     // =========================================================================
     // Config

package/dist/routing.d.ts

@@ -1,12 +1,14 @@
 import { type AccountStorage, type RoutingMode } from './accounts.ts';
 export declare const CLAUDE_ROUTING_COMMAND_NAME = "claude-routing";
-export declare const ROUTING_MODES: readonly ["main-first", "fallback-first"];
+export declare const ROUTING_MODES: readonly ["main-first", "fallback-first", "sticky-balanced"];
 export declare const DEFAULT_ROUTING_MODE: RoutingMode;
 type RoutingCommandAction = {
     type: 'status';
 } | {
     type: 'mode';
     mode: RoutingMode;
+} | {
+    type: 'reset';
 } | {
     type: 'usage';
 };

package/dist/routing.js

@@ -1,8 +1,12 @@
 import { createEmptyStorage, getAccountStoragePath, loadAccounts, saveAccounts, } from "./accounts.js";
 export const CLAUDE_ROUTING_COMMAND_NAME = 'claude-routing';
-export const ROUTING_MODES = ['main-first', 'fallback-first'];
+export const ROUTING_MODES = [
+    'main-first',
+    'fallback-first',
+    'sticky-balanced',
+];
 export const DEFAULT_ROUTING_MODE = 'main-first';
-const ROUTING_USAGE = 'Usage: `/claude-routing`, `/claude-routing main-first`, or `/claude-routing fallback-first`.';
+const ROUTING_USAGE = 'Usage: `/claude-routing`, `/claude-routing main-first`, `/claude-routing fallback-first`, `/claude-routing sticky-balanced`, or `/claude-routing reset`.';
 function normalizeRoutingMode(value) {
     return typeof value === 'string' &&
         ROUTING_MODES.includes(value)
@@ -25,6 +29,8 @@ export function parseRoutingCommandAction(argumentsText) {
     const tokens = argumentsText.trim().toLowerCase().split(/\s+/).filter(Boolean);
     if (tokens.length === 0)
         return { type: 'status' };
+    if (tokens.length === 1 && tokens[0] === 'reset')
+        return { type: 'reset' };
     if (tokens.length === 1 && ROUTING_MODES.includes(tokens[0])) {
         return { type: 'mode', mode: tokens[0] };
     }
@@ -39,6 +45,9 @@ function routingDescription(mode) {
     if (mode === 'fallback-first') {
         return 'Try usable fallback accounts before the main account. If no fallback succeeds, try the main account.';
     }
+    if (mode === 'sticky-balanced') {
+        return 'Assign each session to a quota-weighted OAuth account, keep it sticky across transient failures, and migrate only for confirmed long-lived exhaustion or permanent account failure.';
+    }
     return 'Try the main account first. Use fallback accounts only when quota policy or fallback errors require it.';
 }
 export function buildRoutingStatusSummary(input) {
@@ -66,6 +75,15 @@ export function executeRoutingCommand(input) {
             ...buildRoutingStatusSummary({ mode: action.mode }).split('\n').slice(2),
         ].join('\n');
     }
+    if (action.type === 'reset') {
+        return [
+            '## Claude Routing Assignment Reset',
+            '',
+            'The current session will be assigned again on its next request.',
+            '',
+            ...buildRoutingStatusSummary({ mode }).split('\n').slice(2),
+        ].join('\n');
+    }
     return [
         '## Claude Routing Usage',
         '',

package/dist/sticky-routing.d.ts

@@ -0,0 +1,86 @@
+import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
+export declare const STICKY_ROUTING_MAIN_ACCOUNT_ID = "main";
+export declare const STICKY_ROUTING_SHORT_RESET_GRACE_MS: number;
+export declare const STICKY_ROUTING_ASSIGNMENT_TTL_MS: number;
+export type StickyRouteFamily = 'fable' | 'opus' | 'general';
+export type StickyRouteCandidate = {
+    accountId: string;
+    quota: OAuthQuotaSnapshot;
+    order: number;
+};
+export type StickyRouteAssignment = {
+    accountId: string;
+    family: StickyRouteFamily;
+    assignedAt: number;
+    lastSeenAt: number;
+    initialInputBytes: number;
+    quotaCheckedAt: number;
+};
+export type StickyRouteResolution = {
+    accountId: string;
+    assignment: StickyRouteAssignment;
+    created: boolean;
+    migrated: boolean;
+};
+export type StickyQuotaFailureDecision = {
+    action: 'retain';
+    reason: 'not-exhausted' | 'unknown';
+} | {
+    action: 'hold';
+    reason: 'five-hour-short-reset';
+    retryAfterSeconds: number;
+} | {
+    action: 'migrate';
+    reason: 'five-hour' | 'seven-day' | 'model-scoped';
+};
+export declare function stickyQuotaSnapshotIsFresh(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, now?: number, modelId?: string): boolean;
+export declare function stickyRouteFamilyForModel(model: unknown): StickyRouteFamily;
+export declare function stickyRouteCandidateWeight(input: {
+    candidate: StickyRouteCandidate;
+    family: StickyRouteFamily;
+    modelId?: string;
+    storage: AccountStorage | null;
+    now?: number;
+}): number;
+export declare function stickyRouteKnownFableExhausted(candidate: StickyRouteCandidate, storage: AccountStorage | null, now?: number): boolean;
+export declare function decideStickyQuotaFailure(input: {
+    quota: OAuthQuotaSnapshot | undefined;
+    modelId?: string;
+    now?: number;
+}): StickyQuotaFailureDecision;
+export declare function getStickyRoutingStatePath(accountStoragePath: string): string;
+export declare function stickyRetryAfterWithJitter(sessionId: string, retryAfterSeconds: number): number;
+export declare class StickySessionRouter {
+    private readonly options;
+    private loaded;
+    private state;
+    private stateMtimeNs;
+    private touchChain;
+    constructor(options: {
+        path: string;
+        now?: () => number;
+        assignmentTtlMs?: number;
+    });
+    private now;
+    private readState;
+    private readStateMtimeNs;
+    private refreshStateIfChanged;
+    private acquireLock;
+    private assignmentIsActive;
+    private prune;
+    private writeState;
+    private scheduleTouch;
+    private selectCandidate;
+    resolve(input: {
+        sessionId: string;
+        family: StickyRouteFamily;
+        modelId?: string;
+        candidates: readonly StickyRouteCandidate[];
+        retainAccountIds: ReadonlySet<string>;
+        storage: AccountStorage | null;
+        inputBytes: number;
+        preferredAccountId?: string;
+        excludeAccountIds?: ReadonlySet<string>;
+    }): Promise<StickyRouteResolution | null>;
+    clear(sessionId: string): Promise<void>;
+}