@cortexkit/anthropic-auth-core 1.15.1 → 1.17.0

package/dist/cachekeep-registry.d.ts

@@ -0,0 +1,21 @@
+export declare const CACHE_KEEP_REGISTRY_LEASE_MS: number;
+export type CacheKeepTrackedSession = {
+    id: string;
+    cacheExpiresAt: number;
+    nextPrewarmAt: number;
+};
+export declare function getDefaultCacheKeepRegistryDirectory(scope: 'opencode' | 'pi'): string;
+export declare class CacheKeepSessionRegistry {
+    private readonly options;
+    private readonly filePath;
+    private writeChain;
+    constructor(options: {
+        directory: string;
+        now?: () => number;
+        leaseMs?: number;
+        instanceId?: string;
+    });
+    publish(sessions: readonly CacheKeepTrackedSession[]): Promise<void>;
+    list(localSessions?: readonly CacheKeepTrackedSession[]): Promise<CacheKeepTrackedSession[]>;
+    dispose(): Promise<void>;
+}

package/dist/cachekeep-registry.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const CACHE_KEEP_REGISTRY_LEASE_MS = 3 * 60_000;
+function normalizeSession(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const record = value;
+    if (typeof record.id !== 'string' ||
+        record.id.length === 0 ||
+        typeof record.cacheExpiresAt !== 'number' ||
+        !Number.isFinite(record.cacheExpiresAt) ||
+        typeof record.nextPrewarmAt !== 'number' ||
+        !Number.isFinite(record.nextPrewarmAt)) {
+        return;
+    }
+    return {
+        id: record.id,
+        cacheExpiresAt: record.cacheExpiresAt,
+        nextPrewarmAt: record.nextPrewarmAt,
+    };
+}
+function normalizeRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const record = value;
+    if (record.version !== 1 ||
+        typeof record.updatedAt !== 'number' ||
+        !Number.isFinite(record.updatedAt) ||
+        !Array.isArray(record.sessions)) {
+        return;
+    }
+    return {
+        version: 1,
+        updatedAt: record.updatedAt,
+        sessions: record.sessions.flatMap((session) => {
+            const normalized = normalizeSession(session);
+            return normalized ? [normalized] : [];
+        }),
+    };
+}
+export function getDefaultCacheKeepRegistryDirectory(scope) {
+    return join(tmpdir(), 'opencode-anthropic-auth', 'cachekeep-sessions', scope);
+}
+export class CacheKeepSessionRegistry {
+    options;
+    filePath;
+    writeChain = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        const instanceId = options.instanceId ?? `${process.pid}-${randomUUID()}`;
+        this.filePath = join(options.directory, `${instanceId}.json`);
+    }
+    publish(sessions) {
+        const snapshot = sessions.map((session) => ({ ...session }));
+        this.writeChain = this.writeChain
+            .catch(() => { })
+            .then(async () => {
+            if (snapshot.length === 0) {
+                await rm(this.filePath, { force: true });
+                return;
+            }
+            await mkdir(this.options.directory, { recursive: true, mode: 0o700 });
+            const tempPath = `${this.filePath}.${randomUUID()}.tmp`;
+            const record = {
+                version: 1,
+                updatedAt: this.options.now?.() ?? Date.now(),
+                sessions: snapshot,
+            };
+            await writeFile(tempPath, `${JSON.stringify(record)}\n`, {
+                mode: 0o600,
+            });
+            await rename(tempPath, this.filePath);
+        });
+        return this.writeChain;
+    }
+    async list(localSessions = []) {
+        await this.writeChain.catch(() => { });
+        const now = this.options.now?.() ?? Date.now();
+        const leaseMs = this.options.leaseMs ?? CACHE_KEEP_REGISTRY_LEASE_MS;
+        let names;
+        try {
+            names = (await readdir(this.options.directory)).filter((name) => name.endsWith('.json'));
+        }
+        catch {
+            names = [];
+        }
+        const records = await Promise.all(names.map(async (name) => {
+            try {
+                const raw = await readFile(join(this.options.directory, name), 'utf8');
+                return normalizeRecord(JSON.parse(raw));
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        const sessions = new Map();
+        for (const record of records) {
+            if (!record ||
+                now - record.updatedAt > leaseMs ||
+                record.updatedAt > now) {
+                continue;
+            }
+            for (const session of record.sessions) {
+                const existing = sessions.get(session.id);
+                if (!existing || session.cacheExpiresAt > existing.cacheExpiresAt) {
+                    sessions.set(session.id, session);
+                }
+            }
+        }
+        for (const session of localSessions) {
+            const existing = sessions.get(session.id);
+            if (!existing || session.cacheExpiresAt > existing.cacheExpiresAt) {
+                sessions.set(session.id, { ...session });
+            }
+        }
+        return [...sessions.values()].sort((left, right) => left.id.localeCompare(right.id));
+    }
+    async dispose() {
+        await this.writeChain.catch(() => { });
+        await rm(this.filePath, { force: true });
+    }
+}

package/dist/cachekeep.d.ts

@@ -1,4 +1,5 @@
 import type { AccountStorage } from './accounts.ts';
+import type { CacheKeepTrackedSession } from './cachekeep-registry.ts';
 export declare const CLAUDE_CACHE_KEEP_COMMAND_NAME = "claude-cachekeep";
 export declare const CACHE_KEEP_TTL_MS: number;
 export declare const CACHE_KEEP_PREWARM_LEAD_MS: number;
@@ -16,6 +17,8 @@ export type CacheKeepCommandAction = {
     type: 'status';
 } | {
     type: 'disable';
+} | {
+    type: 'always';
 } | {
     type: 'window';
     startHour: number;
@@ -28,23 +31,29 @@ export type CacheKeepCommandAction = {
 };
 export type CacheKeepStatus = {
     enabled: boolean;
+    always?: boolean;
     window?: CacheKeepWindow;
     trackedSessions?: number;
+    trackedSessionDetails?: CacheKeepTrackedSession[];
     nextPrewarmAt?: number;
     hybridActive?: boolean;
 };
 export declare function parseCacheKeepCommandAction(input: string): CacheKeepCommandAction;
 export declare function getCacheKeepWindow(storage: AccountStorage | null): CacheKeepWindow | undefined;
+export declare function isCacheKeepAlways(storage: AccountStorage | null): boolean;
 export declare function isCacheKeepPersistentlyEnabled(storage: AccountStorage | null): boolean;
 export declare function isCacheKeepHybridActive(storage: AccountStorage | null): boolean;
 export declare function isWithinCacheKeepWindow(window: CacheKeepWindow | undefined, now?: Date): boolean;
+export declare function isCacheKeepActiveNow(storage: AccountStorage | null, now?: Date): boolean;
 export declare function localDayKey(now?: Date): string;
 export declare function buildCacheKeepStatusSummary(status: CacheKeepStatus): string;
 export declare function executeCacheKeepCommand(input: {
     argumentsText: string;
     enabled?: boolean;
+    always?: boolean;
     window?: CacheKeepWindow;
     trackedSessions?: number;
+    trackedSessionDetails?: CacheKeepTrackedSession[];
     nextPrewarmAt?: number;
     hybridActive?: boolean;
 }): string;
@@ -86,14 +95,20 @@ export declare class CacheKeepManager {
         now?: () => number;
         prewarmTimeoutMs?: number;
         prepareHeaders?: (headers: Headers, target: CacheKeepTarget) => Promise<Headers> | Headers;
+        onTrackedSessionsChanged?: (sessions: readonly CacheKeepTrackedSession[]) => Promise<void> | void;
     });
     start(): void;
     stop(): void;
-    stats(window?: CacheKeepWindow, now?: number): {
+    stats(window?: CacheKeepWindow, now?: number, always?: boolean): {
         trackedSessions: number;
         nextPrewarmAt: number | undefined;
     };
+    trackedSessions(): CacheKeepTrackedSession[];
+    trackedOAuthRoute(sessionId: string): {
+        oauthAccountId?: string;
+    } | undefined;
     trackedCount(): number;
+    private publishTrackedSessions;
     private totalBodyBytes;
     private evictOldestTarget;
     private pruneTargets;

package/dist/cachekeep.js

@@ -14,7 +14,7 @@ const STATUS_TITLE = '## Claude Cache Keep Status';
 const ENABLED_TITLE = '## Claude Cache Keep Enabled';
 const DISABLED_TITLE = '## Claude Cache Keep Disabled';
 const USAGE_TITLE = '## Claude Cache Keep Usage';
-const USAGE = 'Usage: `/claude-cachekeep`, `/claude-cachekeep off`, or `/claude-cachekeep HH-HH`.';
+const USAGE = 'Usage: `/claude-cachekeep`, `/claude-cachekeep always`, `/claude-cachekeep off`, or `/claude-cachekeep HH-HH`.';
 function padHour(hour) {
     return String(hour).padStart(2, '0');
 }
@@ -24,6 +24,8 @@ export function parseCacheKeepCommandAction(input) {
         return { type: 'status' };
     if (trimmed === 'off')
         return { type: 'disable' };
+    if (trimmed === 'always')
+        return { type: 'always' };
     if (trimmed === 'subagents on')
         return { type: 'subagents', enabled: true };
     if (trimmed === 'subagents off')
@@ -58,8 +60,12 @@ export function getCacheKeepWindow(storage) {
     }
     return { startHour, endHour };
 }
+export function isCacheKeepAlways(storage) {
+    return (storage?.cacheKeep?.enabled === true && storage.cacheKeep.always === true);
+}
 export function isCacheKeepPersistentlyEnabled(storage) {
-    return storage?.cacheKeep?.enabled === true && !!getCacheKeepWindow(storage);
+    return (storage?.cacheKeep?.enabled === true &&
+        (isCacheKeepAlways(storage) || !!getCacheKeepWindow(storage)));
 }
 export function isCacheKeepHybridActive(storage) {
     return (isCacheKeepPersistentlyEnabled(storage) &&
@@ -75,6 +81,12 @@ export function isWithinCacheKeepWindow(window, now = new Date()) {
     }
     return hour >= window.startHour || hour < window.endHour;
 }
+export function isCacheKeepActiveNow(storage, now = new Date()) {
+    if (storage?.cacheKeep?.enabled !== true)
+        return false;
+    return (isCacheKeepAlways(storage) ||
+        isWithinCacheKeepWindow(getCacheKeepWindow(storage), now));
+}
 export function localDayKey(now = new Date()) {
     return `${now.getFullYear()}-${padHour(now.getMonth() + 1)}-${padHour(now.getDate())}`;
 }
@@ -88,13 +100,18 @@ function localWindowKey(window, now = new Date()) {
     }
     return localDayKey(now);
 }
+function cacheKeepPeriodKey(storage, window, now = new Date()) {
+    return isCacheKeepAlways(storage) ? 'always' : localWindowKey(window, now);
+}
 export function buildCacheKeepStatusSummary(status) {
-    const window = status.window
-        ? `${padHour(status.window.startHour)}-${padHour(status.window.endHour)}`
-        : 'not configured';
+    const schedule = status.always
+        ? 'always (while this process is running)'
+        : status.window
+            ? `${padHour(status.window.startHour)}-${padHour(status.window.endHour)}`
+            : 'not configured';
     const lines = [
         `Cache keep: ${status.enabled ? 'enabled' : 'disabled'}`,
-        `Window: ${window}`,
+        `Schedule: ${schedule}`,
         'Mode requirement: `/claude-cache mode hybrid` must be active.',
     ];
     if (typeof status.hybridActive === 'boolean') {
@@ -103,6 +120,12 @@ export function buildCacheKeepStatusSummary(status) {
     if (typeof status.trackedSessions === 'number') {
         lines.push(`Tracked sessions: ${status.trackedSessions}`);
     }
+    if (status.trackedSessionDetails?.length) {
+        lines.push('Sessions:');
+        for (const session of status.trackedSessionDetails) {
+            lines.push(`- ${session.id}`);
+        }
+    }
     if (status.nextPrewarmAt) {
         lines.push(`Next prewarm: ${new Date(status.nextPrewarmAt).toLocaleString()}`);
     }
@@ -112,8 +135,10 @@ export function executeCacheKeepCommand(input) {
     const action = parseCacheKeepCommandAction(input.argumentsText);
     const status = {
         enabled: input.enabled ?? false,
+        always: input.always,
         window: input.window,
         trackedSessions: input.trackedSessions,
+        trackedSessionDetails: input.trackedSessionDetails,
         nextPrewarmAt: input.nextPrewarmAt,
         hybridActive: input.hybridActive,
     };
@@ -127,6 +152,18 @@ export function executeCacheKeepCommand(input) {
             buildCacheKeepStatusSummary({ ...status, enabled: false }),
         ].join('\n');
     }
+    if (action.type === 'always') {
+        return [
+            ENABLED_TITLE,
+            '',
+            buildCacheKeepStatusSummary({
+                ...status,
+                enabled: true,
+                always: true,
+                window: undefined,
+            }),
+        ].join('\n');
+    }
     if (action.type === 'window') {
         return [
             ENABLED_TITLE,
@@ -134,6 +171,7 @@ export function executeCacheKeepCommand(input) {
             buildCacheKeepStatusSummary({
                 ...status,
                 enabled: true,
+                always: false,
                 window: { startHour: action.startHour, endHour: action.endHour },
             }),
         ].join('\n');
@@ -218,17 +256,47 @@ export class CacheKeepManager {
         clearInterval(this.timer);
         this.timer = null;
     }
-    stats(window, now = this.options.now?.() ?? Date.now()) {
-        const today = localWindowKey(window, new Date(now));
+    stats(window, now = this.options.now?.() ?? Date.now(), always = false) {
+        const today = always ? 'always' : localWindowKey(window, new Date(now));
         const targets = [...this.targets.values()].filter((target) => target.dayKey === today);
         const nextPrewarmAt = targets.length
             ? Math.min(...targets.map((target) => target.cacheExpiresAt - CACHE_KEEP_PREWARM_LEAD_MS))
             : undefined;
         return { trackedSessions: targets.length, nextPrewarmAt };
     }
+    trackedSessions() {
+        return [...this.targets.values()]
+            .map((target) => ({
+            id: target.id,
+            cacheExpiresAt: target.cacheExpiresAt,
+            nextPrewarmAt: target.cacheExpiresAt - CACHE_KEEP_PREWARM_LEAD_MS,
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    trackedOAuthRoute(sessionId) {
+        const target = this.targets.get(sessionId);
+        return target ? { oauthAccountId: target.oauthAccountId } : undefined;
+    }
     trackedCount() {
         return this.targets.size;
     }
+    publishTrackedSessions() {
+        const callback = this.options.onTrackedSessionsChanged;
+        if (!callback)
+            return;
+        try {
+            void Promise.resolve(callback(this.trackedSessions())).catch((error) => {
+                logger.warn('cachekeep', 'failed to publish tracked sessions', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        catch (error) {
+            logger.warn('cachekeep', 'failed to publish tracked sessions', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     totalBodyBytes() {
         return [...this.targets.values()].reduce((sum, target) => sum + target.bodyText.length, 0);
     }
@@ -270,10 +338,10 @@ export class CacheKeepManager {
         }
         const now = this.options.now?.() ?? Date.now();
         const window = getCacheKeepWindow(input.storage);
-        if (!isWithinCacheKeepWindow(window, new Date(now))) {
-            return { tracked: false, reason: 'outside configured window' };
+        if (!isCacheKeepActiveNow(input.storage, new Date(now))) {
+            return { tracked: false, reason: 'outside configured schedule' };
         }
-        const today = localWindowKey(window, new Date(now));
+        const today = cacheKeepPeriodKey(input.storage, window, new Date(now));
         this.pruneTargets(now, today);
         if (this.targets.has(input.sessionId))
             this.targets.delete(input.sessionId);
@@ -291,6 +359,7 @@ export class CacheKeepManager {
             oauthAccountId: input.oauthAccountId,
         });
         this.pruneTargets(now, today);
+        this.publishTrackedSessions();
         this.start();
         return { tracked: true };
     }
@@ -314,16 +383,25 @@ export class CacheKeepManager {
         const storage = await this.options.loadStorage();
         const window = getCacheKeepWindow(storage);
         const now = this.options.now?.() ?? Date.now();
-        const today = localWindowKey(window, new Date(now));
+        const today = cacheKeepPeriodKey(storage, window, new Date(now));
+        if (isCacheKeepAlways(storage)) {
+            for (const target of this.targets.values())
+                target.dayKey = 'always';
+        }
         this.pruneTargets(now, today);
         if (!this.targets.size) {
+            this.publishTrackedSessions();
             this.stop();
             return;
         }
-        if (!isCacheKeepHybridActive(storage))
+        if (!isCacheKeepHybridActive(storage)) {
+            this.publishTrackedSessions();
             return;
-        if (!isWithinCacheKeepWindow(window, new Date(now)))
+        }
+        if (!isCacheKeepActiveNow(storage, new Date(now))) {
+            this.publishTrackedSessions();
             return;
+        }
         logger.debug('cachekeep', 'fired', { targets: this.targets.size });
         const dueAt = now + CACHE_KEEP_PREWARM_LEAD_MS;
         for (const target of this.targets.values()) {
@@ -331,6 +409,7 @@ export class CacheKeepManager {
                 continue;
             await this.prewarm(target, now);
         }
+        this.publishTrackedSessions();
     }
     async sendPrewarm(target) {
         const prewarm = await buildCacheKeepPrewarmBody(target.bodyText);

package/dist/commands/account.d.ts

@@ -39,6 +39,7 @@ export interface AccountListItem {
     role: 'main' | 'fallback';
     enabled: boolean;
     quotaPercent: number | null;
+    tierLabel?: string;
 }
 export declare function buildAccountList(storage: AccountStorage): AccountListItem[];
 export declare function executeAccountCommand(input: {

package/dist/commands/account.js

@@ -1,3 +1,4 @@
+import { formatOAuthAccountTier } from "../oauth-profile.js";
 export const CLAUDE_ACCOUNT_COMMAND_NAME = 'claude-account';
 export function parseAccountCommandAction(argumentsText) {
     const parts = argumentsText.trim().split(/\s+/).filter(Boolean);
@@ -89,6 +90,7 @@ export function buildAccountList(storage) {
         role: 'main',
         enabled: true,
         quotaPercent: fiveHour?.usedPercent ?? null,
+        tierLabel: formatOAuthAccountTier(storage.main?.profile),
     });
     for (const account of storage.accounts) {
         const fiveHourQuota = account.quota?.five_hour;
@@ -98,6 +100,9 @@ export function buildAccountList(storage) {
             role: 'fallback',
             enabled: account.enabled !== false,
             quotaPercent: fiveHourQuota?.usedPercent ?? null,
+            tierLabel: account.type === 'oauth'
+                ? formatOAuthAccountTier(account.profile)
+                : undefined,
         });
     }
     return list;
@@ -124,7 +129,8 @@ export function executeAccountCommand(input) {
         for (const a of list) {
             const pct = a.quotaPercent != null ? ` ${Math.round(a.quotaPercent)}%` : '';
             const status = !a.enabled ? ' (disabled)' : '';
-            lines.push(`- **${a.label}** [${a.role}]${status}${pct}`);
+            const tier = a.tierLabel ? ` · ${a.tierLabel}` : '';
+            lines.push(`- **${a.label}** [${a.role}]${tier}${status}${pct}`);
         }
         lines.push('', USAGE_TEXT);
         return { text: lines.join('\n') };

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;