@modelprofile.com/authswitch 3.3.0 → 5.0.0

package/dist_ts/classes.claudecodeharness.js

@@ -1,15 +1,48 @@
 import * as plugins from './plugins.js';
 import { FileHarness } from './classes.fileharness.js';
-import { CredentialStore, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw } from './classes.credentialstore.js';
+import { CredentialStore, credentialHash, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw } from './classes.credentialstore.js';
 import { HarnessProcesses } from './classes.harnessprocesses.js';
 import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { ClaudeCodeLocks } from './classes.claudecodelocks.js';
+import { ClaudeTokenRefresh } from './classes.claudetokenrefresh.js';
+import { CLAUDE_LOGIN_REJECTED, ClaudeLoginRejectedError, ClaudeRateLimitError } from './claudehttp.js';
 import { writeSecretFileAtomically } from './helpers.js';
+/**
+ * How long a read waits for the store and for Claude Code's locks before leaving the saved copy as it found it.
+ *
+ * Reading accounts must stay as quick as it is while a switch, a refresh or a Claude Code session holds a lock. The
+ * saved copy has nothing to finish: whatever the operation holding the lock writes is what the next read mirrors.
+ */
+const MIRROR_WAIT_MS = 1_000;
+/**
+ * A saved login the sign-in service refuses, in terms the user can act on.
+ *
+ * Claude Code rotates the refresh token of the login it is running on (hints.md), and a saved copy keeps the token
+ * it was stashed with. Once such a login has been replaced outside authswitch -- a `claude /login`, a new device
+ * login -- nothing writes the rotation back, and the service was observed refusing the older token the saved copy
+ * still holds (2026-09-18, two saved logins). No retry, no other account and no switch changes that answer; logging
+ * in again and saving that login does, so the message says so.
+ */
+const SAVED_LOGIN_REJECTED = `${CLAUDE_LOGIN_REJECTED} Claude Code rotates a login's refresh token as it uses it, and the service can refuse the older one a saved copy still holds once that login has been replaced outside authswitch; authswitch claude stash --keep saves the new one.`;
 const accountCaches = ['additionalModelOptionsCache', 'additionalModelOptionsAnsweredAt', 'additionalModelCostsCache', 'modelAccessCache', 'orgModelDefaultCache', 'lastSeenOrgDefaultUpdatedAt', 'clientDataCache', 'clientDataCacheSlots', 'autoCompactWindowsCache', 'cachedUsageUtilization'];
-/** File-backed Claude Code subscriber login and its matching global oauthAccount metadata. */
+/**
+ * File-backed Claude Code subscriber login and its matching global oauthAccount metadata.
+ *
+ * A running Claude Code (verified against 2.1.273) re-reads its credential file whenever the file's mtime changes,
+ * before every request, and watches `.claude.json`, so a swap is picked up live without a restart. Every native read
+ * and write therefore runs under Claude Code's own locks instead of asking for it to be stopped.
+ *
+ * Nothing else refreshes a saved login, so its access token expires a few hours after it was saved. Reading such a
+ * login's status refreshes it first, the way Claude Code would; the active login's tokens belong to Claude Code, and
+ * reading the accounts mirrors that login into its own saved copy, so the stash keeps what Claude Code last wrote.
+ */
 export class ClaudeCodeHarness extends FileHarness {
     id = 'claude';
     label = 'Claude Code';
     loginHint = 'Log in using claude auth login, then authswitch claude stash --keep; Claude Code may stay running.';
+    liveSwap = true;
+    autoSwitch = true;
+    renewalUnavailableReason = "renewal dates are not exposed by Claude's account API.";
     store;
     file;
     configFile;
@@ -18,6 +51,8 @@ export class ClaudeCodeHarness extends FileHarness {
     status;
     processes;
     settingsFiles;
+    locks;
+    tokens;
     constructor(options = {}) {
         super();
         this.env = options.env ?? process.env;
@@ -27,10 +62,16 @@ export class ClaudeCodeHarness extends FileHarness {
         this.configFile = options.globalConfigFile ?? plugins.path.join(custom || plugins.os.homedir(), '.claude.json');
         this.store = new CredentialStore(this.id, options.stashRoot);
         this.platform = options.platform ?? process.platform;
-        this.status = new ClaudeAccountStatus(options.fetch);
+        this.status = new ClaudeAccountStatus(options.fetch, options.now);
+        this.tokens = new ClaudeTokenRefresh(options.fetch, options.now);
         this.processes = options.processes ?? new HarnessProcesses('claude', { platform: this.platform });
         this.settingsFiles = options.settingsFiles ?? [plugins.path.join(dir, 'settings.json'),
             plugins.path.join(process.cwd(), '.claude/settings.json'), plugins.path.join(process.cwd(), '.claude/settings.local.json')];
+        this.locks = new ClaudeCodeLocks(dir, this.configFile, { timeoutMs: options.lockTimeoutMs });
+    }
+    /** A login this adapter cannot manage has no Claude Code file to lock; the action itself reports why. */
+    nativeTransaction(actionArg) {
+        return this.unavailableReason() === null ? this.locks.hold(actionArg) : super.nativeTransaction(actionArg);
     }
     /** One record holds the credential and its matching metadata, so both files must be proven stable. */
     nativeSources() { return [readCredentialRaw(this.file), readCredentialRaw(this.configFile)]; }
@@ -44,9 +85,10 @@ export class ClaudeCodeHarness extends FileHarness {
             throw new Error('Claude Code login or its matching account metadata is incomplete. Log in again with Claude Code before saving.');
         return { slotId, identity: JSON.stringify([account.accountUuid, account.organizationUuid]), label: String(account.emailAddress).toLowerCase(), credential };
     }
-    snapshot() {
+    /** Why this installation's login is not a subscriber file login this adapter can manage; null when it is. */
+    unavailableReason() {
         if (this.platform === 'darwin')
-            return { accounts: [], unavailable: 'Claude Code uses the macOS Keychain. This adapter supports file credentials on Linux and Windows; Keychain switching is unavailable.' };
+            return 'Claude Code uses the macOS Keychain. This adapter supports file credentials on Linux and Windows; Keychain switching is unavailable.';
         const overrides = ['CLAUDE_CODE_OAUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_PROFILE', 'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY', 'ANTHROPIC_BASE_URL'];
         const settings = {};
         const environment = { ...this.env };
@@ -56,8 +98,13 @@ export class ClaudeCodeHarness extends FileHarness {
             if (data.env != null)
                 Object.assign(environment, credentialRecord(data.env));
         }
-        if (overrides.some(key => environment[key]) || credentialText(settings.apiKeyHelper))
-            return { accounts: [], unavailable: 'Claude Code has a settings or environment credential/provider override. Remove it before managing subscriber file logins.' };
+        return overrides.some(key => environment[key]) || credentialText(settings.apiKeyHelper)
+            ? 'Claude Code has a settings or environment credential/provider override. Remove it before managing subscriber file logins.' : null;
+    }
+    snapshot() {
+        const unavailable = this.unavailableReason();
+        if (unavailable !== null)
+            return { accounts: [], unavailable };
         const data = readCredentialDocument(this.file).data;
         if (data.claudeAiOauth == null)
             return { accounts: [], unavailable: null };
@@ -92,7 +139,7 @@ export class ClaudeCodeHarness extends FileHarness {
         const raw = JSON.stringify(next, null, 2) + '\n';
         const configRaw = JSON.stringify(nextConfig, null, 2) + '\n';
         if (readCredentialDocument(this.file).raw !== original.raw || readCredentialDocument(this.configFile).raw !== config.raw)
-            throw new Error('Claude Code files changed during the operation; try again after Claude Code exits.');
+            throw new Error('Claude Code files changed during the operation; no credential was replaced. Try again.');
         plugins.fs.mkdirSync(plugins.path.dirname(this.file), { recursive: true, mode: 0o700 });
         plugins.fs.mkdirSync(plugins.path.dirname(this.configFile), { recursive: true, mode: 0o700 });
         try {
@@ -112,14 +159,161 @@ export class ClaudeCodeHarness extends FileHarness {
                     writeSecretFileAtomically(this.configFile, config.raw ?? '{}\n');
             }
             catch {
-                throw new Error('Claude Code switch and rollback were incomplete. Keep Claude Code stopped and restore a verified saved account.');
+                throw new Error('Claude Code switch and rollback were incomplete, so its login and account metadata may not match. Activate a verified saved account with authswitch claude use, then check authswitch claude active.');
             }
-            throw new Error('Claude Code switch failed while updating account metadata. The outgoing login remains saved; check doctor before restarting.');
+            throw new Error('Claude Code switch failed while updating account metadata and was rolled back. The outgoing login remains saved; check authswitch claude doctor.');
+        }
+    }
+    /** The hash that identifies a saved login's refresh token, so a rejected grant is remembered without keeping it. */
+    grantKey(oauthArg) { return credentialHash(credentialText(oauthArg.refreshToken) ?? ''); }
+    /**
+     * The harness's accounts, with the saved copy of the active login brought up to date first.
+     *
+     * Claude Code rotates the refresh token of the login it is running on, and until now only a switch or a save wrote
+     * that back into the stash. A login replaced outside authswitch between two switches therefore left a saved copy
+     * holding the token from before the rotation, which the service was observed refusing -- a saved copy that only
+     * turns out to be unusable when that account's status is next read. Every read of the native login now mirrors it
+     * into its own saved record, so the stash keeps the credential Claude Code last wrote for an account that has one.
+     */
+    async readState() {
+        await this.mirrorActiveLogin();
+        return super.readState();
+    }
+    /**
+     * Writes the active login into its own saved record when the two differ.
+     *
+     * This is the only write a read makes, and it is advisory: a store another operation holds, a lock Claude Code
+     * holds and files that keep changing under it all leave the saved copy as it is, because the next read mirrors
+     * whatever they wrote. The native files are only ever read, and a login without a saved record of its own is
+     * never saved implicitly -- that is what `stash` is for.
+     */
+    async mirrorActiveLogin() {
+        try {
+            if (this.staleSavedCopy(this.snapshot()) === null)
+                return;
+            await this.store.locked(() => this.locks.hold(() => {
+                // Under both locks the decision is taken again, from a snapshot proven not to have been read across a write.
+                const stale = this.staleSavedCopy(this.stableSnapshot());
+                if (stale !== null)
+                    this.store.replaceCredential(stale.id, stale.credential);
+                return [];
+            }, { timeoutMs: MIRROR_WAIT_MS }), { signal: AbortSignal.timeout(MIRROR_WAIT_MS) });
+        }
+        catch { /* A saved copy that could not be brought up to date is no reason to fail a read of the accounts. */ }
+    }
+    /** The active login's saved record when it no longer holds what Claude Code wrote, with the credential to write. */
+    staleSavedCopy(snapshotArg) {
+        // Claude Code runs one login, and an installation this adapter cannot read reports none at all.
+        const [active] = snapshotArg.accounts;
+        if (!active)
+            return null;
+        const id = this.store.id(active.slotId, active.identity);
+        let saved;
+        try {
+            saved = this.store.read(id);
+        }
+        catch {
+            return null;
         }
+        return credentialHash(JSON.stringify(saved.credential)) === credentialHash(JSON.stringify(active.credential))
+            ? null : { id, credential: active.credential };
     }
-    async readAccountStatus(id, optionsArg) {
-        const account = this.readCredential(id);
-        return this.status.read(credentialRecord(account.credential.claudeAiOauth), credentialRecord(account.credential.oauthAccount), optionsArg);
+    /**
+     * What the native files say about this account: its active login, and why they could not be read at all.
+     *
+     * Both answers come from one snapshot, because only their combination proves that a login is *not* the active one.
+     * An installation this adapter cannot read reports no accounts, so the login Claude Code is actually running on
+     * reads as inactive there; anything that would renew a saved login has to refuse instead.
+     */
+    nativeView(idArg) {
+        const snapshot = this.snapshot();
+        return { active: snapshot.accounts.find(account => this.store.id(account.slotId, account.identity) === idArg) ?? null, unavailable: snapshot.unavailable };
+    }
+    /**
+     * The account's status. The active login is read as it is: Claude Code refreshes it. A saved login whose access token
+     * is due is refreshed first; when that fails, the status says why and keeps the stored plan, and the saved login is
+     * left exactly as it was.
+     *
+     * A refresh is only ever sent for a login the native files prove is not the active one (`nativeView`), and a grant
+     * the service already rejected is not sent again while the saved record still holds it.
+     */
+    async readAccountStatus(id, optionsArg = {}) {
+        const read = (accountArg) => this.status.read(credentialRecord(accountArg.credential.claudeAiOauth), credentialRecord(accountArg.credential.oauthAccount), optionsArg);
+        const view = this.nativeView(id);
+        if (view.active)
+            return read(view.active);
+        const saved = this.savedCredential(id);
+        const oauth = credentialRecord(saved.credential.claudeAiOauth);
+        if (!this.tokens.due(oauth))
+            return read(saved);
+        if (view.unavailable !== null) {
+            return this.status.unavailable(oauth, `Login refresh: this saved login's access token has expired and cannot be renewed for this installation. ${view.unavailable}`);
+        }
+        if (this.store.read(id).rejectedGrant === this.grantKey(oauth))
+            return this.status.unavailable(oauth, `Login refresh: ${SAVED_LOGIN_REJECTED}`);
+        let refreshed;
+        try {
+            refreshed = await this.refreshSaved(id, optionsArg.signal);
+        }
+        catch (error) {
+            if (optionsArg.signal?.aborted)
+                throw error;
+            const problem = error instanceof ClaudeLoginRejectedError ? SAVED_LOGIN_REJECTED
+                : error instanceof Error ? error.message : 'the saved login could not be refreshed.';
+            return this.status.unavailable(oauth, `Login refresh: ${problem}`, error instanceof ClaudeRateLimitError ? { retryAt: error.retryAt } : undefined);
+        }
+        return read(refreshed);
+    }
+    /**
+     * A saved login with fresh tokens, refreshed as the only operation on the store: a switch, a save or another refresh
+     * waits for it, so none of them can read or activate a refresh token the service is replacing. Under the lock the
+     * native files are read again, so the decision that this is not the active login is taken where it holds: one that
+     * became active meanwhile belongs to Claude Code and is returned as it is, one in an installation that can no
+     * longer be read is returned unrefreshed, and one another refresh already renewed is not refreshed twice. The new
+     * tokens replace the saved ones only while the record still holds the refresh token that was sent, the
+     * compare-and-swap Claude Code 2.1.273 applies to its own store (`$fn`, @15410824).
+     */
+    refreshSaved(id, signal) {
+        return this.store.locked(async () => {
+            const view = this.nativeView(id);
+            if (view.active)
+                return view.active;
+            const saved = this.savedCredential(id);
+            const oauth = credentialRecord(saved.credential.claudeAiOauth);
+            if (view.unavailable !== null || !this.tokens.due(oauth))
+                return saved;
+            signal?.throwIfAborted();
+            let tokens;
+            try {
+                tokens = await this.tokens.refresh(oauth);
+            }
+            catch (error) {
+                // Only this token was rejected; a login saved again replaces it and is tried like any other.
+                if (error instanceof ClaudeLoginRejectedError)
+                    this.recordRejectedGrant(id, oauth);
+                throw error;
+            }
+            const latest = this.savedCredential(id);
+            const latestOauth = credentialRecord(latest.credential.claudeAiOauth);
+            if (latestOauth.refreshToken !== oauth.refreshToken)
+                return latest;
+            this.store.replaceCredential(id, { ...latest.credential, claudeAiOauth: { ...latestOauth, ...tokens } });
+            return this.savedCredential(id);
+        }, { signal });
+    }
+    /**
+     * Remembers a rejected grant in the saved record, so the next process does not send it again either -- a watch
+     * would otherwise replay a dead login every tick, and every new CLI run once more. It is written only while the
+     * record still holds the token that was sent, and a record that could not be written changes nothing but that:
+     * the refusal the caller reports is the answer, and the grant is simply tried once more.
+     */
+    recordRejectedGrant(id, oauthArg) {
+        try {
+            const latest = credentialRecord(this.savedCredential(id).credential.claudeAiOauth);
+            if (latest.refreshToken === oauthArg.refreshToken)
+                this.store.rememberRejectedGrant(id, this.grantKey(oauthArg));
+        }
+        catch { /* Recording is advisory; the rejection is reported either way. */ }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.claudecodeharness.js","sourceRoot":"","sources":["../ts/classes.claudecodeharness.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.claudecodeharness.js","sourceRoot":"","sources":["../ts/classes.claudecodeharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.claudecodelocks.d.ts

@@ -0,0 +1,38 @@
+export interface IClaudeCodeLocksOptions {
+    /** How long an operation waits for a lock that Claude Code holds. */
+    timeoutMs?: number;
+}
+/**
+ * Claude Code's own locks around its login and global config, taken with its own library and options.
+ *
+ * A running Claude Code picks a swapped credential up on its next request, so a switch no longer waits for it to
+ * stop. What it must not do is interleave with that session's own writes: a token refresh that is in flight when
+ * the credential is swapped leaves the outgoing account's saved copy with a refresh token the server may already
+ * have replaced, and a config save that read `.claude.json` before the swap writes the previous account's
+ * metadata back. Claude Code 2.1.273 serialises those writers with proper-lockfile (see hints.md); this class
+ * takes the same locks, in the order a refresh nests them, waits a bounded time for a held one, and releases them
+ * in reverse order on every path. A lock left behind by a Claude Code that died is stale after its own threshold
+ * and is taken over, exactly as Claude Code itself would.
+ */
+export declare class ClaudeCodeLocks {
+    private readonly configDir;
+    private readonly configFile;
+    private readonly timeoutMs;
+    constructor(configDir: string, configFile: string, optionsArg?: IClaudeCodeLocksOptions);
+    /** The locks of Claude Code 2.1.273, in acquisition order. */
+    private locks;
+    /**
+     * Runs a synchronous read-and-write of the native login while every lock is held.
+     *
+     * A held lock never makes authswitch sit on the others: like Claude Code, it releases what it holds, waits and
+     * starts again, so a live session is never blocked by a switch that is still waiting. A lock that could not be
+     * released afterwards is reported as an outcome line, because the write it guarded has completed and the lock
+     * expires on its own. `timeoutMs` shortens the wait for a caller that must not make a user wait for it -- a read
+     * bringing a saved copy up to date has nothing to finish and can leave it to the next read.
+     */
+    hold(actionArg: () => string[], optionsArg?: {
+        timeoutMs?: number;
+    }): Promise<string[]>;
+    /** Takes the locks in order into `heldArg` and returns the first one another process holds, or null once all are held. */
+    private acquireAll;
+}

package/dist_ts/classes.claudecodelocks.js

@@ -0,0 +1,118 @@
+import * as plugins from './plugins.js';
+import { errorCode } from './helpers.js';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const RETRY_MS = 250;
+/**
+ * Claude Code's own locks around its login and global config, taken with its own library and options.
+ *
+ * A running Claude Code picks a swapped credential up on its next request, so a switch no longer waits for it to
+ * stop. What it must not do is interleave with that session's own writes: a token refresh that is in flight when
+ * the credential is swapped leaves the outgoing account's saved copy with a refresh token the server may already
+ * have replaced, and a config save that read `.claude.json` before the swap writes the previous account's
+ * metadata back. Claude Code 2.1.273 serialises those writers with proper-lockfile (see hints.md); this class
+ * takes the same locks, in the order a refresh nests them, waits a bounded time for a held one, and releases them
+ * in reverse order on every path. A lock left behind by a Claude Code that died is stale after its own threshold
+ * and is taken over, exactly as Claude Code itself would.
+ */
+export class ClaudeCodeLocks {
+    configDir;
+    configFile;
+    timeoutMs;
+    constructor(configDir, configFile, optionsArg = {}) {
+        this.configDir = configDir;
+        this.configFile = configFile;
+        this.timeoutMs = optionsArg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    }
+    /** The locks of Claude Code 2.1.273, in acquisition order. */
+    async locks() {
+        // The OAuth refresh lock's legacy twin is keyed by the resolved directory; Claude Code falls back to the path as given.
+        const resolved = await plugins.fs.promises.realpath(this.configDir).catch(() => this.configDir);
+        const storageWrite = plugins.path.join(this.configDir, '.storage-write');
+        return [
+            { file: this.configDir, lockfilePath: plugins.path.join(this.configDir, '.oauth_refresh.lock'), stale: 60_000, update: 5_000, bestEffort: false },
+            { file: `${resolved}.lock`, lockfilePath: `${resolved}.lock`, stale: 60_000, update: 5_000, bestEffort: true },
+            { file: storageWrite, lockfilePath: `${storageWrite}.lock`, stale: 15_000, bestEffort: false },
+            { file: this.configFile, lockfilePath: `${this.configFile}.lock`, stale: 10_000, bestEffort: false },
+        ];
+    }
+    /**
+     * Runs a synchronous read-and-write of the native login while every lock is held.
+     *
+     * A held lock never makes authswitch sit on the others: like Claude Code, it releases what it holds, waits and
+     * starts again, so a live session is never blocked by a switch that is still waiting. A lock that could not be
+     * released afterwards is reported as an outcome line, because the write it guarded has completed and the lock
+     * expires on its own. `timeoutMs` shortens the wait for a caller that must not make a user wait for it -- a read
+     * bringing a saved copy up to date has nothing to finish and can leave it to the next read.
+     */
+    async hold(actionArg, optionsArg = {}) {
+        const lockfile = await plugins.loadProperLockfile();
+        const deadline = Date.now() + (optionsArg.timeoutMs ?? this.timeoutMs);
+        const held = [];
+        const unreleased = [];
+        const releaseAll = async () => {
+            for (const lock of held.splice(0).reverse()) {
+                // A compromised lock is no longer ours to release; the operation already failed for it.
+                try {
+                    await lock.release();
+                }
+                catch (error) {
+                    if (errorCode(error) !== 'ERELEASED')
+                        unreleased.push(lock.lockfilePath);
+                }
+            }
+        };
+        let outcome;
+        try {
+            for (const directory of new Set([this.configDir, plugins.path.dirname(this.configFile)])) {
+                plugins.fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+            }
+            const locks = await this.locks();
+            for (;;) {
+                // Each attempt owns its flag, so a late report about a lock released in an earlier attempt changes nothing.
+                const attempt = { compromised: false };
+                const busy = await this.acquireAll(lockfile, locks, held, () => { attempt.compromised = true; });
+                if (busy === null) {
+                    if (attempt.compromised)
+                        throw new Error('A Claude Code lock was taken over while authswitch took the others; nothing was changed. Try again.');
+                    break;
+                }
+                await releaseAll();
+                if (Date.now() >= deadline) {
+                    throw new Error(`Claude Code is refreshing or saving its login (${busy.lockfilePath} is held); nothing was changed. Try again in a moment.`);
+                }
+                await new Promise(resolve => { setTimeout(resolve, Math.min(RETRY_MS, Math.max(1, deadline - Date.now()))); });
+            }
+            outcome = { lines: actionArg() };
+        }
+        catch (error) {
+            outcome = { error };
+        }
+        await releaseAll();
+        const note = unreleased.length ? `Claude Code's lock ${unreleased.join(', ')} could not be released; it expires on its own within a minute.` : null;
+        if ('error' in outcome) {
+            if (note === null)
+                throw outcome.error;
+            throw new Error(`${outcome.error instanceof Error ? outcome.error.message : 'Credential operation failed.'} ${note}`);
+        }
+        return note === null ? outcome.lines : [...outcome.lines, note];
+    }
+    /** Takes the locks in order into `heldArg` and returns the first one another process holds, or null once all are held. */
+    async acquireAll(lockfileArg, locksArg, heldArg, onCompromisedArg) {
+        for (const lock of locksArg) {
+            try {
+                const release = await lockfileArg.lock(lock.file, {
+                    lockfilePath: lock.lockfilePath, realpath: false, stale: lock.stale, update: lock.update, onCompromised: onCompromisedArg,
+                });
+                heldArg.push({ lockfilePath: lock.lockfilePath, release });
+            }
+            catch (error) {
+                if (errorCode(error) === 'ELOCKED')
+                    return lock;
+                if (!lock.bestEffort)
+                    throw new Error(`Claude Code's lock ${lock.lockfilePath} could not be taken (${errorCode(error) ?? 'unknown error'}); nothing was changed.`);
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jbGF1ZGVjb2RlbG9ja3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmNsYXVkZWNvZGVsb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBeUJ6QyxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQztBQUNsQyxNQUFNLFFBQVEsR0FBRyxHQUFHLENBQUM7QUFFckI7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUdHO0lBQW9DO0lBRmhELFNBQVMsQ0FBUztJQUVuQyxZQUE2QixTQUFpQixFQUFtQixVQUFrQixFQUFFLGFBQXNDLEVBQUU7UUFBaEcsY0FBUyxHQUFULFNBQVMsQ0FBUTtRQUFtQixlQUFVLEdBQVYsVUFBVSxDQUFRO1FBQ2pGLElBQUksQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLFNBQVMsSUFBSSxrQkFBa0IsQ0FBQztJQUM5RCxDQUFDO0lBRUQsOERBQThEO0lBQ3RELEtBQUssQ0FBQyxLQUFLO1FBQ2pCLHdIQUF3SDtRQUN4SCxNQUFNLFFBQVEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNoRyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLGdCQUFnQixDQUFDLENBQUM7UUFDekUsT0FBTztZQUNMLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsWUFBWSxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUscUJBQXFCLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRTtZQUNqSixFQUFFLElBQUksRUFBRSxHQUFHLFFBQVEsT0FBTyxFQUFFLFlBQVksRUFBRSxHQUFHLFFBQVEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFO1lBQzlHLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsR0FBRyxZQUFZLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUU7WUFDOUYsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLFVBQVUsRUFBRSxZQUFZLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFO1NBQ3JHLENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSSxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQXlCLEVBQUUsYUFBcUMsRUFBRTtRQUNsRixNQUFNLFFBQVEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBQ3BELE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLFVBQVUsQ0FBQyxTQUFTLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3ZFLE1BQU0sSUFBSSxHQUFnQixFQUFFLENBQUM7UUFDN0IsTUFBTSxVQUFVLEdBQWEsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sVUFBVSxHQUFHLEtBQUssSUFBbUIsRUFBRTtZQUMzQyxLQUFLLE1BQU0sSUFBSSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQztnQkFDNUMsd0ZBQXdGO2dCQUN4RixJQUFJLENBQUM7b0JBQUMsTUFBTSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQUMsQ0FBQztnQkFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO29CQUFDLElBQUksU0FBUyxDQUFDLEtBQUssQ0FBQyxLQUFLLFdBQVc7d0JBQUUsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7Z0JBQUMsQ0FBQztZQUMzSCxDQUFDO1FBQ0gsQ0FBQyxDQUFDO1FBQ0YsSUFBSSxPQUFpRCxDQUFDO1FBQ3RELElBQUksQ0FBQztZQUNILEtBQUssTUFBTSxTQUFTLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDekYsT0FBTyxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsU0FBUyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUNwRSxDQUFDO1lBQ0QsTUFBTSxLQUFLLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDakMsU0FBUyxDQUFDO2dCQUNSLDRHQUE0RztnQkFDNUcsTUFBTSxPQUFPLEdBQUcsRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLENBQUM7Z0JBQ3ZDLE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNqRyxJQUFJLElBQUksS0FBSyxJQUFJLEVBQUUsQ0FBQztvQkFDbEIsSUFBSSxPQUFPLENBQUMsV0FBVzt3QkFBRSxNQUFNLElBQUksS0FBSyxDQUFDLHFHQUFxRyxDQUFDLENBQUM7b0JBQ2hKLE1BQU07Z0JBQ1IsQ0FBQztnQkFDRCxNQUFNLFVBQVUsRUFBRSxDQUFDO2dCQUNuQixJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxRQUFRLEVBQUUsQ0FBQztvQkFDM0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxrREFBa0QsSUFBSSxDQUFDLFlBQVksd0RBQXdELENBQUMsQ0FBQztnQkFDL0ksQ0FBQztnQkFDRCxNQUFNLElBQUksT0FBTyxDQUFPLE9BQU8sQ0FBQyxFQUFFLEdBQUcsVUFBVSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxRQUFRLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDdkgsQ0FBQztZQUNELE9BQU8sR0FBRyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsRUFBRSxDQUFDO1FBQ25DLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQUMsT0FBTyxHQUFHLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFBQyxDQUFDO1FBQ3hDLE1BQU0sVUFBVSxFQUFFLENBQUM7UUFDbkIsTUFBTSxJQUFJLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsc0JBQXNCLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGdFQUFnRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7UUFDcEosSUFBSSxPQUFPLElBQUksT0FBTyxFQUFFLENBQUM7WUFDdkIsSUFBSSxJQUFJLEtBQUssSUFBSTtnQkFBRSxNQUFNLE9BQU8sQ0FBQyxLQUFLLENBQUM7WUFDdkMsTUFBTSxJQUFJLEtBQUssQ0FBQyxHQUFHLE9BQU8sQ0FBQyxLQUFLLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsOEJBQThCLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN4SCxDQUFDO1FBQ0QsT0FBTyxJQUFJLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQsMEhBQTBIO0lBQ2xILEtBQUssQ0FBQyxVQUFVLENBQ3RCLFdBQW9DLEVBQ3BDLFFBQW9DLEVBQ3BDLE9BQW9CLEVBQ3BCLGdCQUEyQztRQUUzQyxLQUFLLE1BQU0sSUFBSSxJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQzVCLElBQUksQ0FBQztnQkFDSCxNQUFNLE9BQU8sR0FBRyxNQUFNLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRTtvQkFDaEQsWUFBWSxFQUFFLElBQUksQ0FBQyxZQUFZLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCO2lCQUMxSCxDQUFDLENBQUM7Z0JBQ0gsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDN0QsQ0FBQztZQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7Z0JBQ2YsSUFBSSxTQUFTLENBQUMsS0FBSyxDQUFDLEtBQUssU0FBUztvQkFBRSxPQUFPLElBQUksQ0FBQztnQkFDaEQsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVO29CQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsc0JBQXNCLElBQUksQ0FBQyxZQUFZLHdCQUF3QixTQUFTLENBQUMsS0FBSyxDQUFDLElBQUksZUFBZSx5QkFBeUIsQ0FBQyxDQUFDO1lBQ3JLLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBQ0YifQ==

package/dist_ts/classes.claudestatus.d.ts

@@ -1,8 +1,21 @@
 import type { IHarnessAccountStatus, IHarnessStatusOptions } from './interfaces.harness.js';
-/** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
+/**
+ * Claude Code's read-only OAuth account endpoints: the profile and usage of one login, with the access token it
+ * carries. It never refreshes that token; `ClaudeCodeHarness` refreshes a saved login first, and leaves the active
+ * login's tokens to Claude Code. No inference or browser session is used.
+ */
 export declare class ClaudeAccountStatus {
     private readonly fetcher;
-    constructor(fetcher?: typeof fetch);
+    private readonly now;
+    constructor(fetcher?: typeof fetch, now?: () => number);
     private get;
+    /** The profile, from the session while it is younger than an hour; the session key is a hash of the token, never the token. */
+    private profile;
+    /** A rejected login and an unsupported or foreign profile are answers; a rate limit or a failed request is thrown. */
+    private lookupProfile;
+    /** The plan the login was saved with, the only one known while the service cannot be asked. */
+    private storedSummary;
+    /** A login that could not be made usable for a lookup: its stored plan and why, with the service's retry time for a rate limit. */
+    unavailable(oauth: Record<string, unknown>, problem: string, rateLimit?: IHarnessAccountStatus['rateLimit']): IHarnessAccountStatus;
     read(oauth: Record<string, unknown>, account: Record<string, unknown>, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
 }