@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.claudecodeharness.js

@@ -0,0 +1,123 @@
+import * as plugins from './plugins.js';
+import { FileHarness } from './classes.fileharness.js';
+import { CredentialStore, credentialRecord, credentialText, readCredentialDocument, requireHarnessStopped } from './classes.credentialstore.js';
+import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { writeSecretFileAtomically } from './helpers.js';
+const accountCaches = ['additionalModelOptionsCache', 'additionalModelOptionsAnsweredAt', 'additionalModelCostsCache', 'modelAccessCache', 'orgModelDefaultCache', 'lastSeenOrgDefaultUpdatedAt', 'clientDataCache', 'clientDataCacheSlots', 'autoCompactWindowsCache', 'cachedUsageUtilization'];
+/** File-backed Claude Code subscriber login and its matching global oauthAccount metadata. */
+export class ClaudeCodeHarness extends FileHarness {
+    id = 'claude';
+    label = 'Claude Code';
+    loginHint = 'Log in using claude auth login, exit Claude Code, then authswitch claude stash --keep.';
+    store;
+    file;
+    configFile;
+    env;
+    platform;
+    status;
+    checkStopped;
+    settingsFiles;
+    constructor(options = {}) {
+        super();
+        this.env = options.env ?? process.env;
+        const custom = options.configDir ?? this.env.CLAUDE_CONFIG_DIR;
+        const dir = custom || plugins.path.join(plugins.os.homedir(), '.claude');
+        this.file = plugins.path.join(dir, '.credentials.json');
+        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.checkStopped = options.checkStopped ?? (() => requireHarnessStopped('claude'));
+        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')];
+    }
+    beforeMutation() { this.checkStopped(); }
+    inspect(credential, slotId) {
+        if (slotId !== 'anthropic')
+            throw new Error('Unsupported Claude Code credential slot.');
+        const oauth = credentialRecord(credential.claudeAiOauth);
+        const account = credentialRecord(credential.oauthAccount);
+        if (!credentialText(oauth.accessToken) || !Array.isArray(oauth.scopes) || !oauth.scopes.every(scope => typeof scope === 'string')
+            || !credentialText(account.accountUuid) || !credentialText(account.organizationUuid) || !credentialText(account.emailAddress))
+            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() {
+        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.' };
+        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 };
+        for (const file of this.settingsFiles) {
+            const data = readCredentialDocument(file).data;
+            Object.assign(settings, data);
+            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.' };
+        const data = readCredentialDocument(this.file).data;
+        if (data.claudeAiOauth == null)
+            return { accounts: [], unavailable: null };
+        const config = readCredentialDocument(this.configFile).data;
+        try {
+            return { accounts: [this.inspect({ claudeAiOauth: data.claudeAiOauth, oauthAccount: config.oauthAccount }, 'anthropic')], unavailable: null };
+        }
+        catch {
+            return { accounts: [], unavailable: 'Claude Code login or account metadata is incomplete. Log in again with Claude Code; existing files were preserved.' };
+        }
+    }
+    apply(_slotId, previous, target) {
+        const original = readCredentialDocument(this.file);
+        const config = readCredentialDocument(this.configFile);
+        const oldOauth = previous?.credential.claudeAiOauth;
+        const oldAccount = previous?.credential.oauthAccount;
+        if (JSON.stringify(original.data.claudeAiOauth) !== JSON.stringify(oldOauth)
+            || (previous && JSON.stringify(config.data.oauthAccount) !== JSON.stringify(oldAccount)))
+            throw new Error('Claude Code login changed during the operation; no credential was replaced.');
+        const next = { ...original.data };
+        const nextConfig = { ...config.data };
+        if (target) {
+            next.claudeAiOauth = target.credential.claudeAiOauth;
+            nextConfig.oauthAccount = target.credential.oauthAccount;
+        }
+        else {
+            delete next.claudeAiOauth;
+            delete nextConfig.oauthAccount;
+        }
+        for (const key of accountCaches)
+            delete nextConfig[key];
+        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.');
+        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 {
+            writeSecretFileAtomically(this.file, raw);
+            if (readCredentialDocument(this.file).raw !== raw || readCredentialDocument(this.configFile).raw !== config.raw)
+                throw new Error();
+            writeSecretFileAtomically(this.configFile, configRaw);
+            if (readCredentialDocument(this.configFile).raw !== configRaw)
+                throw new Error();
+        }
+        catch {
+            // Roll back only our own writes; a concurrent writer's data must never be overwritten.
+            try {
+                if (readCredentialDocument(this.file).raw === raw)
+                    writeSecretFileAtomically(this.file, original.raw ?? '{}\n');
+                if (readCredentialDocument(this.configFile).raw === configRaw)
+                    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 failed while updating account metadata. The outgoing login remains saved; check doctor before restarting.');
+        }
+    }
+    async readAccountStatus(id) {
+        const account = this.readCredential(id);
+        return this.status.read(credentialRecord(account.credential.claudeAiOauth), credentialRecord(account.credential.oauthAccount));
+    }
+}
+//# 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.claudestatus.d.ts

@@ -0,0 +1,8 @@
+import type { IHarnessAccountStatus } from './interfaces.harness.js';
+/** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
+export declare class ClaudeAccountStatus {
+    private readonly fetcher;
+    constructor(fetcher?: typeof fetch);
+    private get;
+    read(oauth: Record<string, unknown>, account: Record<string, unknown>): Promise<IHarnessAccountStatus>;
+}

package/dist_ts/classes.claudestatus.js

@@ -0,0 +1,139 @@
+import { credentialRecord, credentialText } from './classes.credentialstore.js';
+class ClaudeStatusError extends Error {
+}
+/** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
+export class ClaudeAccountStatus {
+    fetcher;
+    constructor(fetcher = globalThis.fetch) {
+        this.fetcher = fetcher;
+    }
+    async get(route, accessToken) {
+        const signal = AbortSignal.timeout(10_000);
+        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.');
+            }
+        }
+        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.');
+        }
+    }
+    async read(oauth, account) {
+        const result = { facts: [], problems: [] };
+        const storedPlan = credentialText(oauth.subscriptionType);
+        if (storedPlan)
+            result.summary = { subscription: { plan: storedPlan, source: 'stored' } };
+        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;
+        }
+        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)]);
+        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.');
+            }
+        }
+        else
+            result.problems.push(`Profile: ${profile.reason instanceof ClaudeStatusError ? profile.reason.message : 'Lookup failed.'}`);
+        if (usage.status === 'fulfilled') {
+            try {
+                const windows = [];
+                for (const [key, label, durationSeconds, scope] of [
+                    ['five_hour', 'Claude five-hour', 18000, 'account'], ['seven_day', 'Claude weekly', 604800, 'account'],
+                    ['seven_day_oauth_apps', 'OAuth apps weekly', 604800, 'feature'], ['seven_day_opus', 'Opus weekly', 604800, 'feature'], ['seven_day_sonnet', 'Sonnet weekly', 604800, 'feature'],
+                ]) {
+                    if (usage.value[key] == null)
+                        continue;
+                    const window = credentialRecord(usage.value[key]);
+                    if (window.utilization == null)
+                        continue;
+                    if (typeof window.utilization !== 'number' || !Number.isFinite(window.utilization) || window.utilization < 0)
+                        throw new Error();
+                    const resetAt = window.resets_at == null ? null : new Date(String(window.resets_at)).toISOString();
+                    windows.push({ label, durationSeconds, scope, usedPercent: window.utilization, resetAt });
+                }
+                result.summary = { ...result.summary, usageWindows: windows };
+                for (const window of windows)
+                    result.facts.push({ section: 'Usage', summaryKey: 'usageWindows', label: window.label, value: `${window.usedPercent}% used; ${window.resetAt ? 'resets ' + window.resetAt : 'reset not scheduled'}` });
+                if (usage.value.extra_usage != null) {
+                    const extra = credentialRecord(usage.value.extra_usage);
+                    if (typeof extra.is_enabled === 'boolean')
+                        result.facts.push({ section: 'Extra usage', label: 'Enabled', value: extra.is_enabled ? 'yes' : 'no' });
+                    const currency = credentialText(extra.currency);
+                    const amount = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+                    const limit = amount(extra.monthly_limit);
+                    const used = amount(extra.used_credits);
+                    for (const [label, value] of [['Monthly limit', limit], ['Spent', used]]) {
+                        if (value !== undefined)
+                            result.facts.push({ section: 'Extra usage', label, value: currency ? `${(value / 100).toFixed(2)} ${currency}` : `${value} currency minor units (currency not reported)` });
+                    }
+                    if (limit !== undefined && limit > 0 && used !== undefined)
+                        result.facts.push({ section: 'Extra usage', label: 'Monthly budget used', value: `${Math.round(used / limit * 10000) / 100}%` });
+                }
+                if (Array.isArray(usage.value.limits) && usage.value.limits.length)
+                    result.facts.push({ section: 'Availability', label: 'Additional limits', value: 'The service also returned limits without a supported reset-window contract.' });
+            }
+            catch {
+                result.problems.push('Claude usage response is unsupported; missing values were not inferred.');
+            }
+        }
+        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.' });
+        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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"}

package/dist_ts/classes.cli.d.ts

@@ -0,0 +1,31 @@
+import { type TAuthSwitchCoordinator } from './classes.operations.js';
+import type { CodexSwitcher } from './classes.codexswitcher.js';
+import type { IAuthHarness } from './interfaces.harness.js';
+/** Harness-independent command routing and interactive account management. */
+export declare class AuthSwitchCli {
+    private readonly harnesses;
+    private console?;
+    private running;
+    private readonly operations;
+    private get out();
+    constructor(harnessesArg?: IAuthHarness[] | CodexSwitcher, coordinatorArg?: TAuthSwitchCoordinator);
+    private usage;
+    run(argvArg: string[]): Promise<number>;
+    private runTui;
+    private mutate;
+    private commandLogin;
+    private commandPreuse;
+    private selectHarness;
+    private runInteractive;
+    /** Offer a verified save before presenting the switch picker; declining never switches. */
+    private offerToSave;
+    private runHarnessGuide;
+    private printCurrent;
+    private selectActive;
+    private reportOutcome;
+    private commandList;
+    private printAccount;
+    private resolveAccount;
+    private commandUse;
+    private promptForAccount;
+}