@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.codexstatus.js

@@ -0,0 +1,304 @@
+import { commitinfo } from './00_commitinfo_data.js';
+// Verified Chromium-compatible billing request profile, independent of any locally installed browser.
+const billingUserAgent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36';
+const record = (valueArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        throw new Error('Unexpected status response.');
+    return valueArg;
+};
+const numeric = (valueArg) => {
+    if (typeof valueArg !== 'number' || !Number.isFinite(valueArg) || valueArg < 0)
+        throw new Error('Unexpected numeric status field.');
+    return valueArg;
+};
+const text = (valueArg) => {
+    if (typeof valueArg !== 'string' || !valueArg.trim())
+        throw new Error('Unexpected text status field.');
+    return valueArg;
+};
+const boolean = (valueArg) => {
+    if (typeof valueArg !== 'boolean')
+        throw new Error('Unexpected boolean status field.');
+    return valueArg;
+};
+const timestamp = (secondsArg) => new Date(numeric(secondsArg) * 1000).toISOString();
+const count = (valueArg) => {
+    const value = numeric(valueArg);
+    if (!Number.isSafeInteger(value))
+        throw new Error('Invalid status count.');
+    return value;
+};
+/** Only fixed, local diagnostics may cross the HTTP error boundary. */
+class StatusRequestError extends Error {
+}
+/**
+ * Read-only ChatGPT status contract verified against Codex 0.154.0.
+ * These source-defined backend routes are isolated here. No token refresh,
+ * credential writes, app-server lifecycle changes or reset consumption occur.
+ */
+export class CodexAccountStatus {
+    fetcher;
+    constructor(fetcher = globalThis.fetch) {
+        this.fetcher = fetcher;
+    }
+    async read(rawArg, identityArg) {
+        if (identityArg.kind !== 'chatgpt')
+            return {
+                facts: [{ label: 'Authentication', value: 'API key' }, { label: 'Subscription and usage', value: 'Not exposed by Codex for API-key logins' }], problems: [],
+            };
+        let accessToken;
+        try {
+            accessToken = text(record(record(JSON.parse(rawArg)).tokens).access_token);
+        }
+        catch {
+            return { facts: [], problems: ['The login has no usable access token. Log in again with Codex, then save the account.'] };
+        }
+        if (!identityArg.accountId)
+            return { facts: [], problems: ['The login has no account ID for a status lookup.'] };
+        return this.readCredential(accessToken, identityArg.accountId, identityArg.planType);
+    }
+    /** Read the ChatGPT account directly, independent of a harness's on-disk format. */
+    async readCredential(accessToken, accountId, planType) {
+        const result = { facts: [], problems: [] };
+        const identityArg = { accountId, planType };
+        const sections = await Promise.allSettled([
+            this.get('wham/usage', accessToken, identityArg.accountId),
+            this.get('wham/rate-limit-reset-credits', accessToken, identityArg.accountId),
+            this.get('wham/profiles/me', accessToken, identityArg.accountId),
+            this.get('accounts/check/v4-2023-04-27', accessToken, identityArg.accountId),
+        ]);
+        const usage = sections[0];
+        if (usage.status === 'fulfilled' && usage.value.account_id != null && usage.value.account_id !== identityArg.accountId) {
+            return { facts: [], problems: ['The status service returned a different account ID; no account data was displayed.'] };
+        }
+        const parsers = [
+            (bodyArg) => this.limits(bodyArg, identityArg.accountId),
+            (bodyArg) => this.resets(bodyArg),
+            (bodyArg) => ({ facts: this.activity(bodyArg), summary: undefined }),
+            (bodyArg) => this.billing(bodyArg, identityArg.accountId),
+        ];
+        const labels = ['Subscription and limits', 'Earned reset details', 'Token usage', 'Billing'];
+        for (let index = 0; index < sections.length; index++) {
+            const section = sections[index];
+            if (section.status === 'rejected') {
+                result.problems.push(`${labels[index]}: ${section.reason instanceof Error ? section.reason.message : 'Request failed.'}`);
+                continue;
+            }
+            try {
+                // Each parser validates its whole section before returning any facts or summary.
+                const parsed = parsers[index](section.value);
+                result.facts.push(...parsed.facts);
+                if (parsed.summary)
+                    result.summary = { ...result.summary, ...parsed.summary };
+            }
+            catch {
+                result.problems.push(`${labels[index]}: the service returned an unsupported response; no values were inferred.`);
+            }
+        }
+        if (!result.summary?.subscription && identityArg.planType) {
+            result.facts.unshift({ section: 'Subscription', summaryKey: 'subscription', label: 'Last known plan', value: `${identityArg.planType} (from stored login; not verified live)` });
+            result.summary = { ...result.summary, subscription: { plan: identityArg.planType, source: 'stored' } };
+        }
+        return result;
+    }
+    async get(pathArg, tokenArg, accountIdArg) {
+        const signal = AbortSignal.timeout(10_000);
+        try {
+            const response = await this.fetcher(`https://chatgpt.com/backend-api/${pathArg}`, {
+                method: 'GET', redirect: 'error', signal,
+                headers: { Authorization: `Bearer ${tokenArg}`, 'ChatGPT-Account-ID': accountIdArg,
+                    'User-Agent': `authswitch/${commitinfo.version}`, Accept: 'application/json',
+                    ...(pathArg === 'accounts/check/v4-2023-04-27' ? { originator: 'Codex Desktop', 'OAI-Language': 'en', 'User-Agent': billingUserAgent } : {}) },
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                if (response.headers.get('cf-mitigated') === 'challenge')
+                    throw new StatusRequestError('Blocked by a service verification challenge (Cloudflare); this lookup is unavailable to the current HTTP client.');
+                if (response.status === 401)
+                    throw new StatusRequestError('Login expired or was rejected. Log in again with the account’s harness, then save the account.');
+                if (response.status === 403)
+                    throw new StatusRequestError('Access denied by the service (HTTP 403).');
+                throw new StatusRequestError(`Service returned HTTP ${response.status}.`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new StatusRequestError('The 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 StatusRequestError('The status response is too large.');
+                    }
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            try {
+                return record(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            }
+            catch {
+                throw new StatusRequestError('The service returned invalid status data.');
+            }
+        }
+        catch (errorArg) {
+            // Never surface remote bodies, request headers, token strings or arbitrary fetch errors.
+            if (signal.aborted)
+                throw new Error('The status request timed out.');
+            if (errorArg instanceof StatusRequestError)
+                throw errorArg;
+            throw new Error('The status service could not be reached.');
+        }
+    }
+    /** Desktop 26.908.40834 account-check contract; select the credential's exact account. */
+    billing(bodyArg, accountIdArg) {
+        const accounts = record(bodyArg.accounts);
+        const match = (valueArg) => {
+            const value = record(valueArg);
+            return record(value.account).account_id === accountIdArg;
+        };
+        // A default workspace must never supply another account's billing information.
+        const selected = Object.hasOwn(accounts, accountIdArg) ? accounts[accountIdArg]
+            : Object.values(accounts).find(value => match(value));
+        if (selected === undefined || !match(selected))
+            throw new Error('No matching billing account.');
+        const account = record(selected);
+        const entitlement = record(account.entitlement);
+        const subscription = record(account.last_active_subscription);
+        const billing = {};
+        if (entitlement.has_active_subscription != null)
+            billing.hasActiveSubscription = boolean(entitlement.has_active_subscription);
+        if (subscription.will_renew != null)
+            billing.autoRenew = boolean(subscription.will_renew) && entitlement.cancels_at == null;
+        for (const [field, key] of [['renews_at', 'renewsAt'], ['cancels_at', 'cancelsAt'], ['expires_at', 'expiresAt']]) {
+            if (entitlement[field] != null)
+                billing[key] = new Date(text(entitlement[field])).toISOString();
+        }
+        if (!Object.keys(billing).length)
+            throw new Error('No billing fields returned.');
+        const facts = [];
+        const append = (label, value) => facts.push({ section: 'Billing', summaryKey: 'billing', label, value });
+        if (billing.hasActiveSubscription !== undefined)
+            append('Active subscription', billing.hasActiveSubscription ? 'yes' : 'no');
+        if (billing.autoRenew !== undefined)
+            append('Automatic renewal', billing.autoRenew ? 'on' : 'off');
+        if (billing.renewsAt)
+            append('Renewal date (UTC)', billing.renewsAt);
+        if (billing.cancelsAt)
+            append('Cancellation date (UTC)', billing.cancelsAt);
+        if (billing.expiresAt)
+            append('Subscription expiry (UTC)', billing.expiresAt);
+        return { facts, summary: { billing } };
+    }
+    limits(bodyArg, accountIdArg) {
+        if (bodyArg.account_id != null && bodyArg.account_id !== accountIdArg)
+            throw new Error('Account mismatch.');
+        const plan = text(bodyArg.plan_type);
+        const facts = [{ section: 'Subscription', summaryKey: 'subscription', label: 'Subscription plan', value: `${plan} (live)` }];
+        const usageWindows = [];
+        const summary = { subscription: { plan, source: 'live' }, usageWindows };
+        const appendLimit = (nameArg, valueArg, scopeArg) => {
+            if (valueArg == null)
+                return;
+            const limit = record(valueArg);
+            facts.push({ section: 'Limits & credits', label: `${nameArg} usage allowed`, value: boolean(limit.allowed) ? 'yes' : 'no' });
+            facts.push({ section: 'Limits & credits', label: `${nameArg} limit reached`, value: boolean(limit.limit_reached) ? 'yes' : 'no' });
+            for (const [key, name] of [['primary_window', 'primary'], ['secondary_window', 'secondary']]) {
+                if (limit[key] == null)
+                    continue;
+                const window = record(limit[key]);
+                const used = numeric(window.used_percent);
+                const durationSeconds = numeric(window.limit_window_seconds);
+                const minutes = durationSeconds / 60;
+                const duration = minutes % 1440 === 0 ? `${minutes / 1440}d` : minutes % 60 === 0 ? `${minutes / 60}h` : `${minutes}m`;
+                const resetAt = timestamp(window.reset_at);
+                usageWindows.push({ label: `${nameArg} ${name}`, scope: scopeArg, durationSeconds, usedPercent: used, resetAt });
+                facts.push({ section: 'Usage', summaryKey: 'usageWindows', label: `${nameArg} ${name} (${duration})`, value: `${used}% used, ${Math.max(0, 100 - used)}% remaining; resets ${resetAt}` });
+            }
+        };
+        appendLimit('Codex', bodyArg.rate_limit, 'account');
+        if (bodyArg.additional_rate_limits != null) {
+            if (!Array.isArray(bodyArg.additional_rate_limits))
+                throw new Error('Invalid additional limits.');
+            for (const value of bodyArg.additional_rate_limits) {
+                const limit = record(value);
+                appendLimit(text(limit.limit_name), limit.rate_limit, 'feature');
+            }
+        }
+        if (bodyArg.credits != null) {
+            const credits = record(bodyArg.credits);
+            const unlimited = boolean(credits.unlimited);
+            const hasCredits = boolean(credits.has_credits);
+            facts.push({ section: 'Limits & credits', label: 'Credits', value: unlimited ? 'unlimited' : credits.balance != null ? text(credits.balance) : hasCredits ? 'available (balance not returned)' : 'none available' });
+        }
+        if (bodyArg.spend_control != null) {
+            const spend = record(bodyArg.spend_control);
+            facts.push({ section: 'Limits & credits', label: 'Spend limit reached', value: boolean(spend.reached) ? 'yes' : 'no' });
+            if (spend.individual_limit != null) {
+                const limit = record(spend.individual_limit);
+                facts.push({ section: 'Limits & credits', label: 'Individual spend', value: `${text(limit.used)} used of ${text(limit.limit)}; ${text(limit.remaining)} remaining; resets ${timestamp(limit.reset_at)}` });
+            }
+        }
+        if (bodyArg.rate_limit_reached_type != null)
+            facts.push({ section: 'Limits & credits', label: 'Limit state', value: text(record(bodyArg.rate_limit_reached_type).type) });
+        if (bodyArg.rate_limit_reset_credits != null) {
+            summary.resets = { available: count(record(bodyArg.rate_limit_reset_credits).available_count) };
+            facts.push({ section: 'Earned resets', summaryKey: 'resets', label: 'Available earned resets', value: String(summary.resets.available) });
+        }
+        else
+            facts.push({ section: 'Earned resets', summaryKey: 'resets', label: 'Available earned resets', value: 'Not returned by the limits service' });
+        return { facts, summary };
+    }
+    resets(bodyArg) {
+        const availableCount = count(bodyArg.available_count);
+        if (!Array.isArray(bodyArg.credits))
+            throw new Error('Invalid reset details.');
+        const facts = [{ section: 'Earned resets', summaryKey: 'resets', label: 'Earned resets (detail lookup)', value: `${availableCount} available` }];
+        const details = [];
+        for (const raw of bodyArg.credits) {
+            const credit = record(raw);
+            const expiresAt = credit.expires_at == null ? null : new Date(text(credit.expires_at)).toISOString();
+            const status = text(credit.status);
+            const kind = text(credit.reset_type);
+            details.push({ status, kind, expiresAt });
+            facts.push({ section: 'Earned resets', summaryKey: 'resetDetails', label: 'Earned reset', value: `${status}; ${kind}; ${expiresAt === null ? 'no expiry reported' : 'expires ' + expiresAt}` });
+        }
+        if (bodyArg.credits.length < availableCount)
+            facts.push({ section: 'Earned resets', label: 'Reset details', value: `${bodyArg.credits.length} shown; the available count includes all credits` });
+        // A successful detail lookup supersedes the count from the limits response.
+        return { facts, summary: { resets: { available: availableCount, details } } };
+    }
+    activity(bodyArg) {
+        const stats = record(bodyArg.stats);
+        const facts = [];
+        for (const [key, label] of [
+            ['lifetime_tokens', 'Lifetime tokens'], ['peak_daily_tokens', 'Peak daily tokens'],
+            ['longest_running_turn_sec', 'Longest turn (seconds)'], ['current_streak_days', 'Current streak (days)'], ['longest_streak_days', 'Longest streak (days)'],
+        ])
+            facts.push({ section: 'Activity', label, value: stats[key] == null ? 'Not returned' : numeric(stats[key]).toLocaleString('en-US') });
+        if (stats.daily_usage_buckets != null) {
+            if (!Array.isArray(stats.daily_usage_buckets))
+                throw new Error('Invalid daily usage.');
+            const days = stats.daily_usage_buckets.map((valueArg) => {
+                const day = record(valueArg);
+                const date = text(day.start_date);
+                if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+                    throw new Error('Invalid daily date.');
+                return { date, tokens: numeric(day.tokens) };
+            }).sort((leftArg, rightArg) => rightArg.date.localeCompare(leftArg.date));
+            for (const day of days.slice(0, 7))
+                facts.push({ section: 'Daily tokens', label: `Tokens ${day.date}`, value: day.tokens.toLocaleString('en-US') });
+            if (days.length > 7)
+                facts.push({ section: 'Daily tokens', label: 'Daily activity', value: `Showing the latest 7 of ${days.length} reported days` });
+        }
+        return facts;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexstatus.js","sourceRoot":"","sources":["../ts/classes.codexstatus.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.codexswitcher.d.ts

@@ -0,0 +1,61 @@
+import type { IActiveAuth, ICodexSwitcherOptions, IStashResult, IStashListing, ISwitchResult } from './interfaces.js';
+import { CodexAuth } from './classes.codexauth.js';
+import { CodexDaemon } from './classes.codexdaemon.js';
+import { CodexHome } from './classes.codexhome.js';
+import { RemoteControlStore } from './classes.remotecontrol.js';
+import { StashStore } from './classes.stashstore.js';
+/**
+ * Orchestrates stashing and restoring Codex credentials.
+ *
+ * Two invariants this class defends:
+ *
+ * 1. A credential is never destroyed or overwritten until a copy has been
+ *    written to the stash *and read back*.
+ * 2. Every operation that stops the app-server starts it again, including when
+ *    the operation fails partway. Leaving remote control down would turn a
+ *    failed switch into a broken machine.
+ *
+ * Both stash and use quiesce the app-server first. It refreshes tokens on its
+ * own schedule, so reading or writing `auth.json` while it runs races that
+ * refresh: the copy taken could be a token the daemon has already rotated away,
+ * and a credential the daemon wrote after the copy would be destroyed unstashed.
+ */
+export declare class CodexSwitcher {
+    readonly home: CodexHome;
+    readonly auth: CodexAuth;
+    readonly remoteControl: RemoteControlStore;
+    readonly stashes: StashStore;
+    readonly daemon: CodexDaemon;
+    constructor(optionsArg?: ICodexSwitcherOptions);
+    readActive(): IActiveAuth;
+    /**
+     * Saves the active credential under its account email, together with the
+     * remote-control enrollments belonging to that account, then clears the active
+     * slot so a different account can be logged in.
+     *
+     * `keepActive` saves without clearing, for taking a checkpoint.
+     */
+    stash(optionsArg?: {
+        keepActive?: boolean;
+    }): IStashResult;
+    /** Every stash, annotated with whether it is the account currently in use. */
+    list(): IStashListing[];
+    /**
+     * Makes a stashed account the active one.
+     *
+     * Re-running it for the account that is already active is not a no-op: it
+     * restores that account's enrollments, which is the repair path when remote
+     * control has stopped working for the current login.
+     */
+    use(emailArg: string): ISwitchResult;
+    drop(emailArg: string): boolean;
+    private assertNotKeyring;
+    /**
+     * Stops the app-server if it is up. Returns whether it was running, which is
+     * also the signal for whether to start it again afterwards -- a daemon that
+     * was down before a command stays down after it.
+     */
+    private quiesceDaemon;
+    /** Brings the app-server back, on the success path and the failure path alike. */
+    private resumeDaemon;
+}

package/dist_ts/classes.codexswitcher.js

@@ -0,0 +1,226 @@
+import { CodexAuth } from './classes.codexauth.js';
+import { CodexDaemon } from './classes.codexdaemon.js';
+import { CodexHome } from './classes.codexhome.js';
+import { RemoteControlStore } from './classes.remotecontrol.js';
+import { StashStore } from './classes.stashstore.js';
+import { countPaired } from './helpers.js';
+const KEYRING_MESSAGE = 'the active Codex credential is held in an OS keyring, which authswitch cannot move.\n' +
+    'Set `auth_credentials_store_mode` to file storage in ~/.codex/config.toml and log in again to use authswitch.';
+/**
+ * Orchestrates stashing and restoring Codex credentials.
+ *
+ * Two invariants this class defends:
+ *
+ * 1. A credential is never destroyed or overwritten until a copy has been
+ *    written to the stash *and read back*.
+ * 2. Every operation that stops the app-server starts it again, including when
+ *    the operation fails partway. Leaving remote control down would turn a
+ *    failed switch into a broken machine.
+ *
+ * Both stash and use quiesce the app-server first. It refreshes tokens on its
+ * own schedule, so reading or writing `auth.json` while it runs races that
+ * refresh: the copy taken could be a token the daemon has already rotated away,
+ * and a credential the daemon wrote after the copy would be destroyed unstashed.
+ */
+export class CodexSwitcher {
+    home;
+    auth;
+    remoteControl;
+    stashes;
+    daemon;
+    constructor(optionsArg = {}) {
+        this.home = new CodexHome(optionsArg.codexHome);
+        this.auth = new CodexAuth(this.home);
+        this.remoteControl = new RemoteControlStore(this.home);
+        this.stashes = new StashStore('codex', optionsArg.stashRoot);
+        this.daemon = new CodexDaemon(this.home, optionsArg.codexBinary);
+    }
+    readActive() {
+        return this.auth.readActive();
+    }
+    /**
+     * Saves the active credential under its account email, together with the
+     * remote-control enrollments belonging to that account, then clears the active
+     * slot so a different account can be logged in.
+     *
+     * `keepActive` saves without clearing, for taking a checkpoint.
+     */
+    stash(optionsArg = {}) {
+        const notes = [];
+        const problems = [];
+        const before = this.auth.readActive();
+        this.assertNotKeyring(before);
+        if (before.source === 'none') {
+            // Nothing on disk means nothing to save, and a daemon holding no
+            // credential cannot produce one. Fail here rather than bouncing the
+            // app-server -- and remote control with it -- to learn the same thing.
+            throw new Error(`no active Codex credential found at ${before.authFilePath}; run \`codex login\` first`);
+        }
+        const daemonWasRunning = this.quiesceDaemon(notes);
+        let daemonRestarted = false;
+        let entry;
+        try {
+            // Re-read only now that the daemon is down: whatever it may have refreshed
+            // between the check above and the stop is the credential we must save.
+            const active = this.auth.readActive();
+            this.assertNotKeyring(active);
+            if (!active.raw) {
+                throw new Error(`no active Codex credential found at ${active.authFilePath}`);
+            }
+            if (!active.identity) {
+                throw new Error(`could not identify the account behind ${active.authFilePath}; refusing to stash an unlabelled credential`);
+            }
+            const enrollments = this.remoteControl.read(active.identity.accountId);
+            entry = this.stashes.write(active.identity, active.raw, enrollments, this.home.dir);
+            if (!this.stashes.readBack(entry.email, active.raw)) {
+                throw new Error(`the stash for ${entry.email} could not be read back from ${this.stashes.entryDir(entry.email)}; leaving the active credential in place`);
+            }
+            if (!optionsArg.keepActive) {
+                this.auth.clearActive();
+            }
+            if (enrollments.length === 0) {
+                notes.push('no remote-control enrollment found for this account');
+            }
+        }
+        finally {
+            daemonRestarted = this.resumeDaemon(daemonWasRunning, notes, problems);
+        }
+        return {
+            entry,
+            daemonRestarted,
+            complete: problems.length === 0,
+            notes,
+            problems,
+        };
+    }
+    /** Every stash, annotated with whether it is the account currently in use. */
+    list() {
+        const active = this.auth.readActive();
+        return this.stashes.list().map((entryArg) => {
+            const paired = countPaired(entryArg.enrollments);
+            return {
+                ...entryArg,
+                slug: this.stashes.slugFor(entryArg.email),
+                isActive: active.identity !== null && active.identity.email === entryArg.email && active.identity.accountId === entryArg.accountId && active.identity.kind === entryArg.kind,
+                enrollmentsTotal: entryArg.enrollments.length,
+                enrollmentsPaired: paired,
+                hasRemoteControl: paired > 0,
+            };
+        });
+    }
+    /**
+     * Makes a stashed account the active one.
+     *
+     * Re-running it for the account that is already active is not a no-op: it
+     * restores that account's enrollments, which is the repair path when remote
+     * control has stopped working for the current login.
+     */
+    use(emailArg) {
+        const target = this.stashes.readMeta(emailArg);
+        let targetAuth = this.stashes.readAuth(emailArg);
+        if (!target || targetAuth === null) {
+            throw new Error(`no stash for "${emailArg}"`);
+        }
+        const targetIdentity = this.auth.identityFromRaw(targetAuth);
+        if (!targetIdentity || targetIdentity.email !== target.email || targetIdentity.accountId !== target.accountId || targetIdentity.kind !== target.kind) {
+            throw new Error('the saved Codex credential does not match its metadata; refusing to switch');
+        }
+        const notes = [];
+        const problems = [];
+        this.assertNotKeyring(this.auth.readActive());
+        const daemonWasRunning = this.quiesceDaemon(notes);
+        let enrollmentsRestored = 0;
+        let fromEmail = null;
+        let daemonRestarted = false;
+        try {
+            // Everything below reads the credential state only after the daemon is
+            // down, so nothing it refreshed mid-command is missed or overwritten.
+            const active = this.auth.readActive();
+            this.assertNotKeyring(active);
+            fromEmail = active.identity?.email ?? null;
+            if (fromEmail !== null && fromEmail !== target.email) {
+                // Never drop a credential on the floor: check the outgoing one into the
+                // stash, and prove it landed, before the incoming one overwrites it.
+                const outgoingEnrollments = this.remoteControl.read(active.identity.accountId);
+                this.stashes.write(active.identity, active.raw, outgoingEnrollments, this.home.dir);
+                if (!this.stashes.readBack(fromEmail, active.raw)) {
+                    throw new Error(`could not save the outgoing credential for ${fromEmail}; aborting before it would be overwritten`);
+                }
+                notes.push(`stashed the outgoing credential for ${fromEmail}`);
+            }
+            else if (fromEmail === null && active.raw) {
+                throw new Error(`refusing to overwrite the unidentifiable credential at ${active.authFilePath}; move it aside manually first`);
+            }
+            if (fromEmail === target.email) {
+                if (active.identity.accountId !== target.accountId || active.identity.kind !== target.kind) {
+                    throw new Error('the active and saved Codex accounts share an email but have different identities; refusing to overwrite either credential');
+                }
+                // A daemon refresh may have made the saved tokens obsolete. Keep the current
+                // login while restoring the saved pairing, and verify its updated stash.
+                targetAuth = active.raw;
+                this.stashes.write(active.identity, targetAuth, target.enrollments, this.home.dir);
+                if (!this.stashes.readBack(target.email, targetAuth))
+                    throw new Error('could not verify the current credential in its stash; refusing to overwrite it');
+                notes.push(`${target.email} was already active; refreshing its remote-control enrollments`);
+            }
+            this.auth.writeActive(targetAuth);
+            if (target.enrollments.length > 0) {
+                enrollmentsRestored = this.remoteControl.restore(target.enrollments);
+                notes.push(`restored ${enrollmentsRestored} remote-control enrollment(s)`);
+            }
+            else {
+                notes.push('no remote-control enrollment was stashed for this account');
+            }
+        }
+        finally {
+            daemonRestarted = this.resumeDaemon(daemonWasRunning, notes, problems);
+        }
+        return {
+            from: fromEmail,
+            to: target.email,
+            enrollmentsRestored,
+            daemonRestarted,
+            complete: problems.length === 0,
+            notes,
+            problems,
+        };
+    }
+    drop(emailArg) {
+        return this.stashes.remove(emailArg);
+    }
+    assertNotKeyring(activeArg) {
+        if (activeArg.source === 'keyring') {
+            throw new Error(KEYRING_MESSAGE);
+        }
+    }
+    /**
+     * Stops the app-server if it is up. Returns whether it was running, which is
+     * also the signal for whether to start it again afterwards -- a daemon that
+     * was down before a command stays down after it.
+     */
+    quiesceDaemon(notesArg) {
+        if (!this.daemon.isDaemonRunning()) {
+            notesArg.push('app-server was not running');
+            return false;
+        }
+        const stopResult = this.daemon.stop();
+        if (!stopResult.ok) {
+            throw new Error(`could not stop the Codex app-server, refusing to touch credentials underneath it: ${this.daemon.describeFailure(stopResult)}`);
+        }
+        return true;
+    }
+    /** Brings the app-server back, on the success path and the failure path alike. */
+    resumeDaemon(wasRunningArg, notesArg, problemsArg) {
+        if (!wasRunningArg) {
+            return false;
+        }
+        const startResult = this.daemon.start();
+        if (!startResult.ok) {
+            problemsArg.push(`the app-server did not come back up (${this.daemon.describeFailure(startResult)}); remote control is down until you run \`codex app-server daemon start\``);
+            return false;
+        }
+        notesArg.push('app-server restarted');
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexswitcher.js","sourceRoot":"","sources":["../ts/classes.codexswitcher.ts"],"names":[],"mappings":"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"}