@modelprofile.com/authswitch 3.2.0 → 4.0.0

package/dist_ts/classes.claudecodelocks.d.ts

@@ -0,0 +1,35 @@
+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.
+     */
+    hold(actionArg: () => string[]): 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,117 @@
+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.
+     */
+    async hold(actionArg) {
+        const lockfile = await plugins.loadProperLockfile();
+        const deadline = Date.now() + 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,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

package/dist_ts/classes.claudestatus.d.ts

@@ -1,8 +1,21 @@
-import type { IHarnessAccountStatus } from './interfaces.harness.js';
-/** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
+import type { IHarnessAccountStatus, IHarnessStatusOptions } from './interfaces.harness.js';
+/**
+ * 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;
-    read(oauth: Record<string, unknown>, account: Record<string, unknown>): Promise<IHarnessAccountStatus>;
+    /** 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>;
 }

package/dist_ts/classes.claudestatus.js

@@ -1,7 +1,7 @@
-import { credentialRecord, credentialText } from './classes.credentialstore.js';
+import { credentialHash, credentialRecord, credentialText } from './classes.credentialstore.js';
+import { claudeRequest, ClaudeLoginRejectedError, ClaudeRateLimitError, ClaudeRequestError } from './claudehttp.js';
+import { latestRetryAt } from './ratelimit.js';
 import { plainText } from './formatting.js';
-class ClaudeStatusError extends Error {
-}
 /** Reset times are normalised to ISO 8601 UTC; an unparsable one rejects the whole usage response. */
 const resetTimestamp = (value) => value == null ? null : new Date(String(value)).toISOString();
 const SERVER_NAME_LENGTH = 64;
@@ -91,65 +91,82 @@ const claudeUsageWindows = (usage) => {
         throw new Error('Unsupported Claude usage limits.');
     return Array.isArray(limits) && limits.length ? limitWindows(limits) : { windows: keyedWindows(usage), unsupported: [] };
 };
-/** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
+/**
+ * How long a session reuses an account's profile. The watch polls every few minutes, and the profile (plan,
+ * organization, billing type) changes far more rarely, so it is read at most hourly there.
+ */
+const PROFILE_REUSE_MS = 3_600_000;
+const REQUEST_TIMEOUT_MS = 10_000;
+const MISMATCH = 'Claude returned a different account or organization; no account data was displayed.';
+/**
+ * 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 class ClaudeAccountStatus {
     fetcher;
-    constructor(fetcher = globalThis.fetch) {
+    now;
+    constructor(fetcher = globalThis.fetch, now = Date.now) {
         this.fetcher = fetcher;
+        this.now = now;
+    }
+    async get(route, accessToken, signal) {
+        const { status, body } = await claudeRequest(this.fetcher, {
+            url: `https://api.anthropic.com/api/oauth/${route}`, method: 'GET', subject: 'Claude account', timeoutMs: REQUEST_TIMEOUT_MS, signal, now: this.now,
+            headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json',
+                ...(route === 'usage' ? { 'anthropic-beta': 'oauth-2025-04-20' } : { 'Cache-Control': 'no-cache' }) },
+        });
+        if (status === 401)
+            throw new ClaudeLoginRejectedError();
+        if (status < 200 || status > 299)
+            throw new ClaudeRequestError(`Claude account service returned HTTP ${status}.`);
+        if (body === null)
+            throw new ClaudeRequestError('The Claude account service returned invalid data.');
+        return body;
     }
-    async get(route, accessToken) {
-        const signal = AbortSignal.timeout(10_000);
+    /** The profile, from the session while it is younger than an hour; the session key is a hash of the token, never the token. */
+    profile(token, account, optionsArg) {
+        const lookup = () => this.lookupProfile(token, account, optionsArg.signal);
+        return optionsArg.session ? optionsArg.session.reuse(`claude:profile:${credentialHash(token)}`, PROFILE_REUSE_MS, lookup) : lookup();
+    }
+    /** A rejected login and an unsupported or foreign profile are answers; a rate limit or a failed request is thrown. */
+    async lookupProfile(token, account, signal) {
+        let body;
         try {
-            const response = await this.fetcher(`https://api.anthropic.com/api/oauth/${route}`, {
-                method: 'GET', redirect: 'error', signal,
-                headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json',
-                    ...(route === 'usage' ? { 'anthropic-beta': 'oauth-2025-04-20' } : { 'Cache-Control': 'no-cache' }) },
-            });
-            if (!response.ok) {
-                await response.body?.cancel();
-                throw new ClaudeStatusError(response.status === 401 ? 'Login expired or was rejected. Log in again with Claude Code and save it.' : `Claude account service returned HTTP ${response.status}.`);
-            }
-            const reader = response.body?.getReader();
-            if (!reader)
-                throw new ClaudeStatusError('The Claude account service returned an empty response.');
-            const chunks = [];
-            let size = 0;
-            try {
-                while (true) {
-                    const part = await reader.read();
-                    if (part.done)
-                        break;
-                    size += part.value.byteLength;
-                    if (size > 1024 * 1024) {
-                        await reader.cancel();
-                        throw new ClaudeStatusError('The Claude account response is too large.');
-                    }
-                    chunks.push(part.value);
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            try {
-                return credentialRecord(JSON.parse(Buffer.concat(chunks).toString('utf8')));
-            }
-            catch {
-                throw new ClaudeStatusError('The Claude account service returned invalid data.');
-            }
+            body = await this.get('profile', token, signal);
         }
         catch (error) {
-            if (signal.aborted)
-                throw new ClaudeStatusError('The Claude account request timed out.');
-            if (error instanceof ClaudeStatusError)
-                throw error;
-            throw new ClaudeStatusError('The Claude account service could not be reached.');
+            if (error instanceof ClaudeLoginRejectedError)
+                return { kind: 'unavailable', problem: `Profile: ${error.message}` };
+            throw error;
+        }
+        try {
+            const user = credentialRecord(body.account);
+            const organization = credentialRecord(body.organization);
+            if (user.uuid !== account.accountUuid || organization.uuid !== account.organizationUuid)
+                return { kind: 'mismatch' };
+            const facts = [];
+            for (const [label, value] of [['Email', user.email], ['Organization', organization.name], ['Billing type', organization.billing_type], ['Seat tier', organization.seat_tier]]) {
+                if (credentialText(value))
+                    facts.push({ section: 'Account', label: String(label), value: String(value) });
+            }
+            return { kind: 'found', plan: credentialText(organization.organization_type)?.replace(/^claude_/, ''), facts };
         }
+        catch {
+            return { kind: 'unavailable', problem: 'Claude profile response is unsupported; no profile values were inferred.' };
+        }
+    }
+    /** The plan the login was saved with, the only one known while the service cannot be asked. */
+    storedSummary(oauth) {
+        const plan = credentialText(oauth.subscriptionType);
+        return plan ? { summary: { subscription: { plan, source: 'stored' } } } : {};
     }
-    async read(oauth, account) {
-        const result = { facts: [], problems: [] };
-        const storedPlan = credentialText(oauth.subscriptionType);
-        if (storedPlan)
-            result.summary = { subscription: { plan: storedPlan, source: 'stored' } };
+    /** 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, problem, rateLimit) {
+        return { facts: [], problems: [problem], ...this.storedSummary(oauth), ...(rateLimit ? { rateLimit } : {}) };
+    }
+    async read(oauth, account, optionsArg = {}) {
+        const result = { facts: [], problems: [], ...this.storedSummary(oauth) };
         if (!Array.isArray(oauth.scopes) || !oauth.scopes.includes('user:profile')) {
             result.facts.push({ section: 'Availability', label: 'Live account status', value: 'This login lacks the user:profile scope. Log in through Claude Code to obtain subscriber status.' });
             return result;
@@ -157,27 +174,22 @@ export class ClaudeAccountStatus {
         const token = credentialText(oauth.accessToken);
         if (!token)
             return { facts: [], problems: ['No usable Claude Code access token is available.'] };
-        const [profile, usage] = await Promise.allSettled([this.get('profile', token), this.get('usage', token)]);
+        const [profile, usage] = await Promise.allSettled([this.profile(token, account, optionsArg), this.get('usage', token, optionsArg.signal)]);
+        const failure = (reason) => reason instanceof ClaudeRequestError ? reason.message : 'Lookup failed.';
         if (profile.status === 'fulfilled') {
-            try {
-                const user = credentialRecord(profile.value.account);
-                const organization = credentialRecord(profile.value.organization);
-                if (user.uuid !== account.accountUuid || organization.uuid !== account.organizationUuid)
-                    return { facts: [], problems: ['Claude returned a different account or organization; no account data was displayed.'] };
-                const plan = credentialText(organization.organization_type)?.replace(/^claude_/, '');
-                if (plan)
-                    result.summary = { ...result.summary, subscription: { plan, source: 'live' } };
-                for (const [label, value] of [['Email', user.email], ['Organization', organization.name], ['Billing type', organization.billing_type], ['Seat tier', organization.seat_tier]]) {
-                    if (credentialText(value))
-                        result.facts.push({ section: 'Account', label: String(label), value: String(value) });
-                }
-            }
-            catch {
-                result.problems.push('Claude profile response is unsupported; no profile values were inferred.');
+            const found = profile.value;
+            if (found.kind === 'mismatch')
+                return { facts: [], problems: [MISMATCH] };
+            if (found.kind === 'unavailable')
+                result.problems.push(found.problem);
+            else {
+                if (found.plan)
+                    result.summary = { ...result.summary, subscription: { plan: found.plan, source: 'live' } };
+                result.facts.push(...found.facts.map(fact => ({ ...fact })));
             }
         }
         else
-            result.problems.push(`Profile: ${profile.reason instanceof ClaudeStatusError ? profile.reason.message : 'Lookup failed.'}`);
+            result.problems.push(`Profile: ${failure(profile.reason)}`);
         if (usage.status === 'fulfilled') {
             try {
                 const { windows, unsupported } = claudeUsageWindows(usage.value);
@@ -207,9 +219,13 @@ export class ClaudeAccountStatus {
             }
         }
         else
-            result.problems.push(`Usage: ${usage.reason instanceof ClaudeStatusError ? usage.reason.message : 'Lookup failed.'}`);
-        result.facts.push({ section: 'Availability', label: 'Billing dates and earned resets', value: 'Renewal dates, cancellation dates and earned reset credits are not exposed by these Claude Code endpoints.' });
+            result.problems.push(`Usage: ${failure(usage.reason)}`);
+        const limited = [profile, usage].flatMap(item => item.status === 'rejected' && item.reason instanceof ClaudeRateLimitError ? [item.reason] : []);
+        if (limited.length)
+            result.rateLimit = { retryAt: latestRetryAt(limited.map(error => error.retryAt)) };
+        // The missing renewal dates are the harness's `renewalUnavailableReason`, stated once by the views that show them.
+        result.facts.push({ section: 'Availability', label: 'Earned resets', value: 'authswitch does not read earned reset credits for Claude Code logins.' });
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.claudestatus.js","sourceRoot":"","sources":["../ts/classes.claudestatus.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.claudestatus.js","sourceRoot":"","sources":["../ts/classes.claudestatus.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.claudetokenrefresh.d.ts

@@ -0,0 +1,32 @@
+/** Claude Code 2.1.273's public OAuth client (`CLIENT_ID`, @12733057), used when a login does not name its own. */
+export declare const CLAUDE_CODE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+/** The token fields a refresh replaces in a stored `claudeAiOauth`; every other field is kept. */
+export interface IClaudeTokens {
+    accessToken: string;
+    refreshToken: string;
+    /** Milliseconds since the epoch, as Claude Code stores them. */
+    expiresAt: number;
+    refreshTokenExpiresAt?: number;
+    scopes?: string[];
+}
+/**
+ * Refreshes a saved Claude Code login with the refresh-token grant Claude Code 2.1.273 uses (`RQ`, @15355055).
+ *
+ * It only talks to the token endpoint; which login is refreshed, and how the result is stored, belongs to the harness.
+ */
+export declare class ClaudeTokenRefresh {
+    private readonly fetcher;
+    private readonly now;
+    constructor(fetcher?: typeof fetch, now?: () => number);
+    /**
+     * Whether Claude Code would refresh this login before using it: its access token expires within five minutes. A
+     * login without a numeric expiry or without a refresh token is used as it is, exactly as Claude Code does.
+     */
+    due(oauthArg: Record<string, unknown>): boolean;
+    /**
+     * New tokens for the login. A response without a refresh token keeps the one sent, and one without a scope keeps the
+     * stored scopes, as Claude Code merges them. Throws `ClaudeRequestError` with a fixed diagnostic; a grant the service
+     * rejects is `ClaudeLoginRejectedError`, and a rate limit is `ClaudeRateLimitError`.
+     */
+    refresh(oauthArg: Record<string, unknown>): Promise<IClaudeTokens>;
+}

package/dist_ts/classes.claudetokenrefresh.js

@@ -0,0 +1,77 @@
+import { credentialText } from './classes.credentialstore.js';
+import { claudeRequest, ClaudeLoginRejectedError, ClaudeRequestError } from './claudehttp.js';
+/** Claude Code 2.1.273's token endpoint (`TOKEN_URL`, bundle offset @12733057; see hints.md). */
+const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
+/** Claude Code 2.1.273's public OAuth client (`CLIENT_ID`, @12733057), used when a login does not name its own. */
+export const CLAUDE_CODE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+/** Claude Code 2.1.273 refreshes an access token that expires within five minutes (`cF`, @15359182). */
+const REFRESH_MARGIN_MS = 300_000;
+/**
+ * Claude Code 2.1.273 allows a refresh 30 seconds. A refresh is never cut shorter than that, nor cancelled once sent:
+ * the service may already have replaced the refresh token the request carries.
+ */
+const REFRESH_TIMEOUT_MS = 30_000;
+const seconds = (valueArg) => typeof valueArg === 'number' && Number.isFinite(valueArg) && valueArg >= 0 ? valueArg : undefined;
+/**
+ * Refreshes a saved Claude Code login with the refresh-token grant Claude Code 2.1.273 uses (`RQ`, @15355055).
+ *
+ * It only talks to the token endpoint; which login is refreshed, and how the result is stored, belongs to the harness.
+ */
+export class ClaudeTokenRefresh {
+    fetcher;
+    now;
+    constructor(fetcher = globalThis.fetch, now = Date.now) {
+        this.fetcher = fetcher;
+        this.now = now;
+    }
+    /**
+     * Whether Claude Code would refresh this login before using it: its access token expires within five minutes. A
+     * login without a numeric expiry or without a refresh token is used as it is, exactly as Claude Code does.
+     */
+    due(oauthArg) {
+        const expiresAt = oauthArg.expiresAt;
+        return typeof expiresAt === 'number' && Number.isFinite(expiresAt) && credentialText(oauthArg.refreshToken) !== undefined
+            && this.now() + REFRESH_MARGIN_MS >= expiresAt;
+    }
+    /**
+     * New tokens for the login. A response without a refresh token keeps the one sent, and one without a scope keeps the
+     * stored scopes, as Claude Code merges them. Throws `ClaudeRequestError` with a fixed diagnostic; a grant the service
+     * rejects is `ClaudeLoginRejectedError`, and a rate limit is `ClaudeRateLimitError`.
+     */
+    async refresh(oauthArg) {
+        const refreshToken = credentialText(oauthArg.refreshToken);
+        const scopes = oauthArg.scopes;
+        if (!refreshToken || !Array.isArray(scopes) || !scopes.every(scope => typeof scope === 'string')) {
+            throw new ClaudeRequestError('This saved login has no refresh token or scopes to refresh with. Log in again with Claude Code and save it.');
+        }
+        const { status, body } = await claudeRequest(this.fetcher, {
+            url: TOKEN_URL, method: 'POST', headers: { 'Content-Type': 'application/json' }, subject: 'Claude sign-in',
+            body: JSON.stringify({
+                grant_type: 'refresh_token', refresh_token: refreshToken,
+                client_id: credentialText(oauthArg.clientId) ?? CLAUDE_CODE_CLIENT_ID, scope: scopes.join(' '),
+            }),
+            timeoutMs: REFRESH_TIMEOUT_MS, readErrorBody: true, now: this.now,
+        });
+        if ((status === 400 || status === 401) && body?.error === 'invalid_grant')
+            throw new ClaudeLoginRejectedError();
+        if (status < 200 || status > 299)
+            throw new ClaudeRequestError(`The Claude sign-in service returned HTTP ${status}.`);
+        const receivedAt = this.now();
+        const accessToken = credentialText(body?.access_token);
+        const tokenType = body?.token_type;
+        const expiresIn = seconds(body?.expires_in);
+        const refreshExpiresIn = body?.refresh_token_expires_in == null ? null : seconds(body.refresh_token_expires_in);
+        const rotated = body?.refresh_token == null ? null : credentialText(body.refresh_token);
+        const scope = body?.scope == null ? null : typeof body.scope === 'string' ? body.scope.split(/\s+/).filter(Boolean) : undefined;
+        if (!accessToken || (tokenType != null && (typeof tokenType !== 'string' || tokenType.toLowerCase() !== 'bearer'))
+            || expiresIn === undefined || refreshExpiresIn === undefined || rotated === undefined || scope === undefined) {
+            throw new ClaudeRequestError('The Claude sign-in service returned an unsupported token response; the saved login was not changed.');
+        }
+        return {
+            accessToken, refreshToken: rotated ?? refreshToken, expiresAt: receivedAt + expiresIn * 1000,
+            ...(refreshExpiresIn === null ? {} : { refreshTokenExpiresAt: receivedAt + refreshExpiresIn * 1000 }),
+            ...(scope === null || !scope.length ? {} : { scopes: scope }),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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