@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.cli.js

@@ -0,0 +1,584 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { CodexHarness } from './classes.codexharness.js';
+import { OpenCodeHarness } from './classes.opencodeharness.js';
+import { ClaudeCodeHarness } from './classes.claudecodeharness.js';
+import { AuthSwitchTui } from './classes.tui.js';
+import { AglAuthSwitchCoordinator, AuthSwitchOperations } from './classes.operations.js';
+import { AccountListRenderer, readAccountList } from './classes.accountlist.js';
+import { duration, orderedUsageWindows, until } from './accounts.js';
+import { defaultPreusePrompt, PreuseError, validatePreuseOptions } from './preuse.js';
+import { bold, dim, green, orange, plainText, red } from './formatting.js';
+const canPrompt = () => process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI;
+const COMMANDS = ['login', 'stash', 'list', 'ls', 'use', 'preuse', 'current', 'drop', 'rm', 'doctor'];
+/** Harness-independent command routing and interactive account management. */
+export class AuthSwitchCli {
+    harnesses = new Map();
+    console;
+    running = false;
+    operations;
+    get out() { return this.console ??= new plugins.smartconsole.SmartConsole(); }
+    constructor(harnessesArg, coordinatorArg) {
+        const coordinator = new AglAuthSwitchCoordinator();
+        this.operations = new AuthSwitchOperations(coordinatorArg ?? (harnessesArg === undefined ? request => coordinator.coordinate(request) : undefined));
+        harnessesArg ??= [new CodexHarness(), new OpenCodeHarness(), new ClaudeCodeHarness()];
+        // Preserve the published single-Codex constructor at the composition boundary.
+        const harnesses = Array.isArray(harnessesArg) ? harnessesArg : [new CodexHarness(harnessesArg)];
+        for (const harness of harnesses) {
+            if (!/^[a-z][a-z0-9-]*$/.test(harness.id) || COMMANDS.includes(harness.id) || harness.id === 'help') {
+                throw new Error(`invalid harness name "${plainText(harness.id)}"`);
+            }
+            if (this.harnesses.has(harness.id))
+                throw new Error(`duplicate harness "${harness.id}"`);
+            this.harnesses.set(harness.id, harness);
+        }
+    }
+    usage() {
+        return `${bold('authswitch')} ${dim(`v${commitinfo.version}`)}
+Manage saved accounts across harnesses.
+
+${bold('Usage')}
+  authswitch                         open the interactive guide
+  authswitch list                    list all accounts with live subscription, usage and resets
+  authswitch <harness> list           list accounts for one harness
+  authswitch list --json             print all account information as JSON
+  authswitch <harness> preuse <account> [--prompt <text>] [--model <id>]
+                                    send one prompt through that account without switching
+  authswitch <harness> stash [account/provider] [--keep]
+                                    save one active login; --keep leaves it active
+  authswitch <harness> use [account]   activate a saved account; prompts when omitted
+  authswitch <harness> current        show the active account
+  authswitch <harness> login [provider]
+                                    sign in and save a new account without switching
+  authswitch <harness> drop <account>  remove a saved account
+  authswitch <harness> doctor         diagnose the harness
+
+${bold('Harnesses')}
+  ${[...this.harnesses.values()].map((harnessArg) => `${harnessArg.id} (${harnessArg.label})`).join(', ') || 'none registered'}
+  Unqualified commands use the sole harness, or ask you to choose one.
+
+${bold('Options')}
+  -h, --help                         show this help
+  -v, --version                      show the version
+  -i, --interactive                  open the guided account manager
+  --tui                             open the terminal management dashboard
+  --json                            JSON output for list / ls only
+
+Preuse consumes the selected account's quota. Its default prompt is:
+  "${defaultPreusePrompt}"
+
+${bold('Environment')}
+  AUTHSWITCH_HOME   root directory for saved accounts (default ~/.authswitch)
+  NO_COLOR          disable coloured output
+  Other credential locations and executables are configured by each harness.
+`;
+    }
+    async run(argvArg) {
+        if (this.running)
+            throw new Error('This CLI is already running.');
+        this.running = true;
+        const args = [...argvArg];
+        try {
+            // Parse command values before global flags: a prompt may itself contain a flag.
+            if (args[0] === 'preuse' || (this.harnesses.has(args[0]) && args[1] === 'preuse')) {
+                const qualified = args[0] !== 'preuse';
+                return await this.commandPreuse(qualified ? this.harnesses.get(args[0]) : undefined, args.slice(qualified ? 2 : 1));
+            }
+            const jsonFlags = args.filter(value => value === '--json');
+            const json = jsonFlags.length === 1;
+            if (jsonFlags.length > 1) {
+                process.stderr.write('Use --json only once.\n');
+                return 2;
+            }
+            if (json) {
+                args.splice(args.indexOf('--json'), 1);
+                const route = [...args];
+                if (this.harnesses.has(route[0]))
+                    route.shift();
+                if (route.length !== 1 || !['list', 'ls'].includes(route[0])) {
+                    process.stderr.write('--json requires list or ls, optionally qualified by a harness.\n');
+                    return 2;
+                }
+            }
+            if (['-h', '--help', 'help'].includes(args[0]) || (args.length === 0 && !canPrompt())) {
+                process.stdout.write(`${this.usage()}\n`);
+                return 0;
+            }
+            if (['-v', '--version'].includes(args[0])) {
+                process.stdout.write(`${commitinfo.version}\n`);
+                return 0;
+            }
+            const modes = args.filter(value => ['-i', '--interactive', '--tui'].includes(value));
+            if (modes.length) {
+                const rest = args.filter(value => !['-i', '--interactive', '--tui'].includes(value));
+                if (modes.length !== 1 || rest.length > 1 || (rest.length === 1 && !this.harnesses.has(rest[0]))) {
+                    process.stderr.write('Choose one interactive mode, optionally qualified by a harness; do not combine it with a command.\n');
+                    return 2;
+                }
+                if (!canPrompt()) {
+                    process.stderr.write('Interactive mode requires a terminal outside CI.\n');
+                    return 2;
+                }
+                const harness = rest.length ? this.harnesses.get(rest[0]) : undefined;
+                if (modes[0] === '--tui')
+                    return await this.runTui(harness);
+                return await this.runInteractive(harness);
+            }
+            if (args.length === 0)
+                return await this.runInteractive();
+            const first = args.shift();
+            let harness = this.harnesses.get(first);
+            const command = harness ? args.shift() ?? 'list' : first;
+            if (!harness && !COMMANDS.includes(command)) {
+                process.stderr.write(`${red('unknown harness or command')} "${plainText(first)}"\n\n${this.usage()}\n`);
+                return 2;
+            }
+            if (['list', 'ls'].includes(command)) {
+                if (args.length) {
+                    process.stderr.write('list accepts only --json; optionally put a harness before list.\n');
+                    return 2;
+                }
+                return await this.commandList(harness ? [harness] : [...this.harnesses.values()], json);
+            }
+            if (!harness) {
+                harness = await this.selectHarness();
+                if (!harness)
+                    return canPrompt() ? 0 : 2;
+            }
+            switch (command) {
+                case 'login':
+                    if (args.length > 1 || args[0]?.startsWith('-')) {
+                        process.stderr.write('login accepts an optional provider ID.\n');
+                        return 2;
+                    }
+                    return await this.commandLogin(harness, args[0]);
+                case 'stash': {
+                    const references = args.filter(value => value !== '--keep');
+                    if (references.length > 1 || references.some(value => value.startsWith('-'))) {
+                        process.stderr.write('stash accepts one active account or provider and --keep.\n');
+                        return 2;
+                    }
+                    const account = await this.selectActive(harness, references[0]);
+                    return account ? this.reportOutcome(await this.mutate(harness, { harnessId: harness.id, action: 'save', keepActive: args.includes('--keep'), accountId: account.id })) : 1;
+                }
+                case 'use': return await this.commandUse(harness, args[0]);
+                case 'current':
+                    this.printCurrent(harness, await harness.readState());
+                    return 0;
+                case 'drop':
+                case 'rm': {
+                    if (!args[0]) {
+                        process.stderr.write(`${red('drop needs an account')}: authswitch ${harness.id} drop <account>\n`);
+                        return 2;
+                    }
+                    const id = await this.resolveAccount(harness, args[0]);
+                    return id === null ? 1 : this.reportOutcome(await harness.removeAccount(id));
+                }
+                case 'doctor': return this.reportOutcome(await harness.diagnose());
+                default:
+                    process.stderr.write(`${red('unknown command')} "${plainText(command)}"\n\n${this.usage()}\n`);
+                    return 2;
+            }
+        }
+        catch (errorArg) {
+            process.stderr.write(`${red('error')} ${errorArg instanceof Error ? errorArg.message : String(errorArg)}\n`);
+            return 1;
+        }
+        finally {
+            const console = this.console;
+            this.console = undefined;
+            try {
+                await console?.dispose();
+            }
+            finally {
+                this.running = false;
+            }
+        }
+    }
+    async runTui(harnessArg) {
+        return new AuthSwitchTui([...this.harnesses.values()], this.out, this.operations).run(harnessArg);
+    }
+    mutate(harness, mutation) {
+        return this.operations.run(harness, mutation, canPrompt() ? async (message) => await this.out.prompts.ask({
+            name: 'waitForIdle', type: 'confirm', message, default: false,
+        }) === true : undefined);
+    }
+    async commandLogin(harness, providerId) {
+        if (!harness.beginLogin) {
+            process.stderr.write(`${plainText(harness.label)} does not support a hosted login flow. ${harness.loginHint}\n`);
+            return 2;
+        }
+        const providers = harness.loginProviders ?? [];
+        let provider = providers.find(item => item.providerId === providerId) ?? (!providerId && providers.length === 1 ? providers[0] : undefined);
+        if (!provider && !providerId && canPrompt()) {
+            const selected = await this.out.prompts.ask({ name: 'loginProvider', type: 'list', message: 'Which provider would you like to log in to?', choices: providers.map(item => ({ name: item.label, value: item.providerId })) });
+            provider = providers.find(item => item.providerId === selected);
+        }
+        if (!provider || !provider.flows.length) {
+            process.stderr.write('Choose a supported provider: ' + providers.map(item => item.providerId).join(', ') + '\n');
+            return 2;
+        }
+        let handle;
+        let cancelled = false;
+        const cancel = () => { cancelled = true; void handle?.cancel().catch(() => undefined); };
+        process.on('SIGINT', cancel);
+        process.on('SIGTERM', cancel);
+        try {
+            handle = await harness.beginLogin({ providerId: provider.providerId, flow: provider.flows.includes('device') ? 'device' : provider.flows[0] });
+            if (cancelled)
+                await handle.cancel();
+            else if (handle.prompt.flow === 'device') {
+                process.stdout.write(`Open ${plainText(handle.prompt.verificationUrl)}\nCode: ${plainText(handle.prompt.userCode)}\nWaiting for login. Press Ctrl+C to cancel.\n`);
+            }
+            else
+                process.stdout.write(`Open ${plainText(handle.prompt.authUrl)}\nWaiting for login. Press Ctrl+C to cancel.\n`);
+            return this.reportOutcome((await handle.completion).outcome);
+        }
+        finally {
+            process.removeListener('SIGINT', cancel);
+            process.removeListener('SIGTERM', cancel);
+            await handle?.close();
+        }
+    }
+    async commandPreuse(harnessArg, argsArg) {
+        let reference;
+        let prompt = defaultPreusePrompt;
+        let model;
+        const flags = new Set();
+        try {
+            for (let index = 0; index < argsArg.length; index++) {
+                const argument = argsArg[index];
+                if (argument.startsWith('--prompt=') || argument.startsWith('--model=') || argument === '--prompt' || argument === '--model') {
+                    const separator = argument.indexOf('=');
+                    const flag = separator < 0 ? argument : argument.slice(0, separator);
+                    if (flags.has(flag))
+                        throw new PreuseError(`Use ${flag} only once.`);
+                    flags.add(flag);
+                    const value = separator < 0 ? argsArg[++index] : argument.slice(separator + 1);
+                    if (value === undefined)
+                        throw new PreuseError(`${flag} requires a value.`);
+                    if (flag === '--prompt')
+                        prompt = value;
+                    else
+                        model = value;
+                }
+                else if (argument.startsWith('-') || reference !== undefined) {
+                    throw new PreuseError('Usage: authswitch [harness] preuse <account> [--prompt <text>] [--model <id>]');
+                }
+                else
+                    reference = argument;
+            }
+            validatePreuseOptions({ prompt, model });
+            if (!reference && !canPrompt())
+                throw new PreuseError('preuse requires an account outside an interactive terminal.');
+        }
+        catch (error) {
+            process.stderr.write(`${error instanceof PreuseError ? error.message : 'Invalid preuse arguments.'}\n`);
+            return 2;
+        }
+        const harness = harnessArg ?? await this.selectHarness();
+        if (!harness)
+            return canPrompt() ? 0 : 2;
+        if (!harness.preuseAccount) {
+            process.stderr.write(`Preuse is not supported by ${plainText(harness.label)}.\n`);
+            return 2;
+        }
+        const state = await harness.readState();
+        let account;
+        if (reference) {
+            const matches = state.accounts.filter(item => item.id === reference || item.label === reference);
+            if (matches.length > 1) {
+                process.stderr.write('That account reference is ambiguous; use an exact account ID.\n');
+                return 1;
+            }
+            account = matches[0];
+            if (!account) {
+                const id = await this.resolveAccount(harness, reference);
+                if (id === null)
+                    return 1;
+                account = state.accounts.find(item => item.id === id);
+            }
+        }
+        else {
+            const answer = await this.out.prompts.ask({
+                name: 'preuseAccount', type: 'list', message: `Which ${harness.label} account should receive the preuse prompt? This consumes quota.`,
+                choices: [...state.accounts.map(item => ({ name: plainText(item.label), value: item.id })), { name: 'Back', value: '' }],
+            });
+            if (!answer)
+                return 0;
+            account = state.accounts.find(item => item.id === answer);
+        }
+        if (!account) {
+            process.stderr.write('The selected account is no longer available.\n');
+            return 1;
+        }
+        const controller = new AbortController();
+        const cancel = () => controller.abort();
+        process.once('SIGINT', cancel);
+        process.once('SIGTERM', cancel);
+        try {
+            let result;
+            try {
+                process.stdout.write(`Preusing ${plainText(account.label)} (${plainText(harness.label)})…\n`);
+                result = await harness.preuseAccount(account.id, { prompt, model, signal: controller.signal });
+            }
+            catch (error) {
+                process.stderr.write(`${error instanceof PreuseError ? error.message : 'Preuse failed. Tokens may already have been consumed; check account status before trying again.'}\n`);
+                return controller.signal.aborted ? 130 : 1;
+            }
+            // Once inference completes, status or presentation failures must not report it as failed.
+            try {
+                process.stdout.write(`Prompt completed with ${plainText(result.model)}. Tokens: ${result.inputTokens ?? 'unreported'} input, ${result.outputTokens ?? 'unreported'} output, ${result.totalTokens ?? 'unreported'} total.\n`);
+                if (controller.signal.aborted)
+                    return 0;
+                const windows = orderedUsageWindows((await harness.readAccountStatus(account.id)).summary?.usageWindows);
+                if (windows?.length) {
+                    const now = Date.now();
+                    process.stdout.write('Reset schedule reported after the prompt:\n');
+                    if ((process.stdout.columns ?? 100) < 40) {
+                        for (const window of windows)
+                            process.stdout.write(`${plainText(window.label)} (${duration(window.durationSeconds)})\n  Used: ${window.usedPercent}%\n  Reset in: ${until(window.resetAt, now)}\n`);
+                    }
+                    else
+                        await this.out.table(windows, { columns: [
+                                { key: 'window', title: 'Window', value: row => `${plainText(row.label)} (${duration(row.durationSeconds)})` },
+                                { key: 'usage', title: 'Used', value: row => `${row.usedPercent}%` },
+                                { key: 'reset', title: 'Reset in', value: row => until(row.resetAt, now) },
+                            ], overflow: 'wrap' });
+                }
+                else
+                    process.stdout.write('Reset schedule could not be verified; the completed prompt will not be repeated.\n');
+            }
+            catch {
+                process.stderr.write('Prompt completed, but its reset schedule could not be verified or displayed. The prompt will not be repeated.\n');
+            }
+            return 0;
+        }
+        finally {
+            process.removeListener('SIGINT', cancel);
+            process.removeListener('SIGTERM', cancel);
+        }
+    }
+    async selectHarness() {
+        if (this.harnesses.size === 1)
+            return this.harnesses.values().next().value;
+        if (this.harnesses.size === 0 || !canPrompt()) {
+            process.stderr.write(`${red('a harness is required')}: ${[...this.harnesses.keys()].join(', ') || 'none registered'}\n`);
+            return undefined;
+        }
+        const answer = await this.out.prompts.ask({
+            name: 'harness', type: 'list', message: 'Which harness would you like to manage?', default: [...this.harnesses.keys()][0],
+            choices: [...this.harnesses.values()].map((harnessArg) => ({ name: harnessArg.label, value: harnessArg.id })).concat([{ name: 'Exit', value: '' }]),
+        });
+        return this.harnesses.get(answer);
+    }
+    async runInteractive(preferredArg) {
+        process.stdout.write(`${bold('authswitch')} ${dim(`v${commitinfo.version}`)}\nUse the arrow keys and Enter to choose.\n`);
+        while (true) {
+            const harness = preferredArg ?? await this.selectHarness();
+            preferredArg = undefined;
+            if (!harness)
+                return this.harnesses.size === 0 ? 2 : 0;
+            this.printCurrent(harness, await harness.readState());
+            const offered = await this.offerToSave(harness);
+            if (offered === 'failed')
+                return 1;
+            const code = await this.runHarnessGuide(harness);
+            if (code !== null)
+                return code;
+        }
+    }
+    /** Offer a verified save before presenting the switch picker; declining never switches. */
+    async offerToSave(harnessArg) {
+        const state = await harnessArg.readState();
+        if (state.saveUnavailableReason)
+            return 'ready';
+        for (const current of state.accounts.filter(account => account.isActive && !account.isStashed)) {
+            const answer = await this.out.prompts.ask({
+                name: 'saveCurrent', type: 'confirm',
+                message: `${plainText(current.label)}${current.slotId ? ` (${plainText(current.slotId)})` : ''} is not saved in ${harnessArg.label}. Save this login before switching?`, default: true,
+            });
+            if (answer !== true)
+                return 'declined';
+            if (this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'save', keepActive: true, accountId: current.id })) !== 0)
+                return 'failed';
+        }
+        return 'ready';
+    }
+    async runHarnessGuide(harnessArg) {
+        while (true) {
+            const state = await harnessArg.readState();
+            this.printCurrent(harnessArg, state);
+            const current = state.accounts.find(account => account.isActive && !account.isStashed) ?? state.accounts.find(account => account.isActive);
+            const hasStashes = state.accounts.some((accountArg) => accountArg.isStashed);
+            if (!hasStashes)
+                process.stdout.write(`${dim('No saved accounts yet. Choose "Save the current login" to get started.')}\n`);
+            const action = await this.out.prompts.ask({
+                name: 'action', type: 'list', message: `What would you like to do in ${harnessArg.label}?`,
+                default: current && !current.isStashed || !hasStashes ? 'stash' : 'use',
+                choices: [
+                    { name: 'Switch to a saved account', value: 'use' },
+                    { name: 'Save the current login', value: 'stash' },
+                    ...(harnessArg.beginLogin ? [{ name: 'Log in and save another account', value: 'login' }] : []),
+                    { name: 'List accounts, subscription, usage and resets', value: 'list' },
+                    { name: harnessArg.diagnosticsLabel, value: 'doctor' },
+                    { name: 'Remove a saved account', value: 'drop' },
+                    ...(this.harnesses.size > 1 ? [{ name: 'Choose another harness', value: 'harness' }] : []),
+                    { name: 'Exit', value: 'exit' },
+                ],
+            });
+            let code = 0;
+            switch (action) {
+                case 'login':
+                    code = await this.commandLogin(harnessArg);
+                    break;
+                case 'use':
+                    code = await this.commandUse(harnessArg, undefined, true);
+                    break;
+                case 'stash': {
+                    if (state.saveUnavailableReason) {
+                        process.stdout.write(`${state.saveUnavailableReason}\n`);
+                        break;
+                    }
+                    const active = await this.selectActive(harnessArg);
+                    if (!active)
+                        break;
+                    const mode = await this.out.prompts.ask({
+                        name: 'stashMode', type: 'list', message: `How would you like to save ${plainText(active.label)}?`, default: 'keep',
+                        choices: [
+                            { name: 'Save and keep this account active', value: 'keep' },
+                            { name: 'Save and clear the active login so I can log in to another account', value: 'clear' },
+                            { name: 'Back', value: 'back' },
+                        ],
+                    });
+                    if (mode === 'keep' || mode === 'clear')
+                        code = this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'save', keepActive: mode === 'keep', accountId: active.id }));
+                    break;
+                }
+                case 'list':
+                    code = await this.commandList([harnessArg]);
+                    break;
+                case 'doctor':
+                    code = this.reportOutcome(await harnessArg.diagnose());
+                    break;
+                case 'drop': {
+                    const id = await this.promptForAccount(harnessArg, `Which saved ${harnessArg.label} account should be removed?`, true, true);
+                    if (!id)
+                        break;
+                    const confirmation = await this.out.prompts.ask({
+                        name: 'confirmDrop', type: 'confirm', message: `Remove the saved login for ${plainText(id)}? The active login stays as it is.`, default: false,
+                    });
+                    if (confirmation === true)
+                        code = this.reportOutcome(await harnessArg.removeAccount(id));
+                    break;
+                }
+                case 'harness': return null;
+                case 'exit': return 0;
+                default: throw new Error('no interactive action was selected');
+            }
+            if (code !== 0)
+                return code;
+        }
+    }
+    printCurrent(harnessArg, stateArg) {
+        process.stdout.write(`\n${bold(`Current ${harnessArg.label} account`)}\n`);
+        const active = stateArg.accounts.filter(account => account.isActive);
+        if (active.length) {
+            for (const current of active)
+                process.stdout.write(`${bold(plainText(current.label))}${current.slotId ? ` (${plainText(current.slotId)})` : ''} ${current.isStashed ? green('(saved)') : orange('(not saved)')}\n`);
+        }
+        else {
+            process.stdout.write(`${dim('no account is currently active')}\n`);
+        }
+        if (stateArg.saveUnavailableReason)
+            process.stdout.write(`${dim(stateArg.saveUnavailableReason)}\n`);
+    }
+    async selectActive(harness, reference) {
+        const state = await harness.readState();
+        if (state.saveUnavailableReason) {
+            process.stderr.write(`${plainText(state.saveUnavailableReason)}\n`);
+            return undefined;
+        }
+        const accounts = state.accounts.filter(account => account.isActive && (!reference || account.id === reference || account.label === reference || account.slotId === reference));
+        if (accounts.length === 1)
+            return accounts[0];
+        if (!accounts.length) {
+            process.stderr.write('No matching active login to save.\n');
+            return undefined;
+        }
+        if (!canPrompt()) {
+            process.stderr.write(`Several logins are active. Use authswitch ${harness.id} stash <account/provider> [--keep].\n`);
+            return undefined;
+        }
+        const id = await this.out.prompts.ask({ name: 'activeAccount', type: 'list', message: 'Which active login should be saved?', choices: accounts.map(account => ({ name: `${plainText(account.label)}${account.slotId ? ` (${plainText(account.slotId)})` : ''}`, value: account.id })) });
+        return accounts.find(account => account.id === id);
+    }
+    reportOutcome(outcomeArg) {
+        for (const line of outcomeArg.lines)
+            process.stdout.write(`${line.trimEnd()}\n`);
+        for (const problem of outcomeArg.problems)
+            process.stderr.write(`${red('incomplete')} ${problem}\n`);
+        return outcomeArg.problems.length === 0 ? 0 : 1;
+    }
+    async commandList(harnessesArg, jsonArg = false) {
+        const list = await readAccountList(harnessesArg);
+        if (jsonArg)
+            process.stdout.write(`${JSON.stringify(list, null, 2)}\n`);
+        else
+            await new AccountListRenderer(this.out).render(list);
+        return list.complete ? 0 : 1;
+    }
+    printAccount(accountArg) {
+        const saved = accountArg.isStashed ? 'saved' : 'not saved';
+        process.stdout.write(`${accountArg.isActive ? green('*') : ' '} ${bold(plainText(accountArg.label))} ${dim(`(${saved})`)}\n`);
+        if (accountArg.savedAt)
+            process.stdout.write(`  ${dim('Saved: ' + plainText(accountArg.savedAt))}\n`);
+        for (const detail of accountArg.details)
+            process.stdout.write(`  ${detail}\n`);
+    }
+    async resolveAccount(harnessArg, referenceArg) {
+        const resolved = await harnessArg.resolveAccount(referenceArg);
+        if ('id' in resolved)
+            return resolved.id;
+        process.stderr.write(resolved.candidates.length === 0
+            ? `${red('no stashed account matches')} "${plainText(referenceArg)}" in ${harnessArg.label}\n`
+            : `${red('ambiguous account')} "${plainText(referenceArg)}" matches: ${resolved.candidates.map(plainText).join(', ')}\n`);
+        return null;
+    }
+    async commandUse(harnessArg, referenceArg, allowBackArg = false) {
+        let id = null;
+        if (referenceArg) {
+            id = await this.resolveAccount(harnessArg, referenceArg);
+            if (id === null)
+                return 1;
+        }
+        if (canPrompt()) {
+            const offered = await this.offerToSave(harnessArg);
+            if (offered !== 'ready')
+                return offered === 'failed' ? 1 : 0;
+        }
+        id ??= await this.promptForAccount(harnessArg, `Which ${harnessArg.label} account should be active?`, allowBackArg);
+        if (id === null)
+            return allowBackArg ? 0 : 1;
+        return this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'switch', accountId: id }));
+    }
+    async promptForAccount(harnessArg, messageArg, allowBackArg, includeIncompleteArg = false) {
+        const accounts = (await harnessArg.readState()).accounts.filter((accountArg) => accountArg.isStashed || (includeIncompleteArg && accountArg.savedAt !== null));
+        if (accounts.length === 0) {
+            process.stderr.write(`${red('no stashed accounts')} - run \`authswitch ${harnessArg.id} stash\` first\n`);
+            return null;
+        }
+        if (!canPrompt()) {
+            process.stderr.write(`${red('an account is required')} without an interactive terminal: authswitch ${harnessArg.id} use <account>\n`);
+            return null;
+        }
+        const answer = await this.out.prompts.ask({
+            name: 'account', type: 'list', message: messageArg,
+            default: accounts.find((accountArg) => accountArg.isActive)?.id ?? accounts[0].id,
+            choices: [...accounts.map((accountArg) => ({ name: `${plainText(accountArg.label)}${accountArg.slotId ? ` (${plainText(accountArg.slotId)})` : ''}${accountArg.isActive ? ' (active)' : ''}`, value: accountArg.id })),
+                ...(allowBackArg ? [{ name: 'Back', value: null }] : [])],
+        });
+        return typeof answer === 'string' ? answer : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.cli.js","sourceRoot":"","sources":["../ts/classes.cli.ts"],"names":[],"mappings":"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"}