@inboxychat/cli 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,624 @@
+/**
+ * The `inboxy` command line (local, scoped).
+ *
+ * Inputs are parsed with node:util parseArgs and only ever reach the network
+ * as validated, percent-encoded path segments or URLSearchParams values.
+ * Nothing here spawns a shell; the only child processes are the OS keychain
+ * tools, started with argument arrays by @inboxychat/sdk.
+ */
+import { parseArgs } from 'node:util';
+import { describeOperations, prepareOperation, CONTACT_STATUSES, FULFILLMENT_STATUSES, InboxyClient, InboxyError, LIFECYCLE_STAGES, ORDER_SOURCES, ORDER_STATUSES, PAGE_LIMIT_MAX, PAYMENT_STATUSES, PUBLIC_CAPABILITIES, collectPages, loadConfig, looksLikeInboxyKey, normalizeBaseUrl, resolveCredentials, saveConfig, systemKeychain, validateProfileName, } from '@inboxychat/sdk';
+import { loginWithDeviceFlow } from './device-login.js';
+import { runDoctor } from './doctor.js';
+import { EXIT, Output, UsageError, table } from './output.js';
+export const CLI_VERSION = '0.2.0';
+const HELP = `inboxy ${CLI_VERSION} — scoped command line for Inboxy
+
+Usage: inboxy <command> [options]
+
+Account
+  auth login [--store keychain|file] [--no-verify]   Sign in (browser on a terminal; a key on stdin otherwise)
+  auth logout                                         Remove the stored key of the profile
+  auth status [--offline]                             Where the key comes from, and whether Inboxy accepts it
+  whoami                                              Company, key name, scopes, expiry, rate limits
+  usage                                               Plan usage against limits
+  stores list                                         Connected-store count against the plan limit
+  doctor                                              Check URL, key, scopes, clock skew and config permissions
+
+Data
+  orders list [filters] [paging]                      --status --payment-status --fulfillment-status --source
+                                                      --store <id> --contact <id> --search <text>
+                                                      --after <iso> --before <iso>
+  orders get <id>
+  contacts search [text] [paging]                     --status --stage --tags <ids> --created-after --created-before
+
+Operations
+  operations list
+  operations inspect <operation>
+  operations preview <operation> --input <json> --idempotency-key <key>
+  operations run <operation> --input <json> --idempotency-key <key> --confirm <preview-hash>
+  campaigns send <operation> --input <json> --idempotency-key <key> --confirm <preview-hash>
+  campaigns schedule --input <json> --idempotency-key <key> --confirm <preview-hash>
+  lifecycle activate <operation> --input <json> --idempotency-key <key> --confirm <preview-hash>
+  messages send --input <json> --idempotency-key <key> --confirm <preview-hash>
+  Mutations need explicit approval of the exact preview. No automatic retries.
+
+Paging
+  --limit <1-${PAGE_LIMIT_MAX}>   --cursor <nextCursor>   --all [--max-pages <n>, default 10]
+
+Global options
+  --json              One JSON document on stdout (schemaVersion 1)
+  --profile <name>    Use a stored profile (one per company; default "default", or INBOXY_PROFILE)
+  --url <origin>      API origin (default INBOXY_API_URL, the profile, or https://api.inboxy.chat)
+  --timeout <ms>      Per-request timeout (default 20000)
+  -h, --help          This help        --version   Print the version
+
+Credentials: INBOXY_API_KEY, else the OS keychain entry written by \`auth login\`,
+else (machines without a keychain) the 0600 config file. The key is never printed.
+Exit codes: 0 ok, 2 usage, 3 config, 4 key refused, 5 forbidden, 6 not found,
+7 rate limited, 8 network/timeout, 9 server, 10 doctor checks failed, 1 unexpected.`;
+const KEY_ON_COMMAND_LINE = 'The API key is never passed as an argument (it would stay in shell history). On a terminal, `inboxy auth login` opens the browser. Otherwise paste it at the hidden prompt, or pipe it: `pbpaste | inboxy auth login`.';
+const GLOBAL_OPTIONS = {
+    json: { type: 'boolean' },
+    profile: { type: 'string' },
+    url: { type: 'string' },
+    timeout: { type: 'string' },
+    help: { type: 'boolean', short: 'h' },
+    version: { type: 'boolean' },
+};
+const PAGING_OPTIONS = {
+    limit: { type: 'string' },
+    cursor: { type: 'string' },
+    all: { type: 'boolean' },
+    'max-pages': { type: 'string' },
+};
+function intOption(value, name, min, max) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value))
+        throw new UsageError(`--${name} must be a whole number.`);
+    const n = Number(value);
+    if (n < min || n > max)
+        throw new UsageError(`--${name} must be between ${min} and ${max}.`);
+    return n;
+}
+function enumOption(value, name, allowed) {
+    if (value === undefined)
+        return undefined;
+    if (!allowed.includes(value)) {
+        throw new UsageError(`--${name} must be one of: ${allowed.join(', ')}.`);
+    }
+    return value;
+}
+function isoOption(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (Number.isNaN(Date.parse(value)))
+        throw new UsageError(`--${name} must be an ISO-8601 date or date-time.`);
+    return value;
+}
+/**
+ * Splits `argv` into the command words and the rest, without interpreting
+ * values. Global options may come before the command (`inboxy --profile a whoami`).
+ */
+const GLOBAL_VALUE_FLAGS = new Set(['--profile', '--url', '--timeout']);
+function commandWords(argv) {
+    const words = [];
+    const rest = [];
+    let i = 0;
+    while (i < argv.length && words.length < 2) {
+        const arg = argv[i];
+        if (GLOBAL_VALUE_FLAGS.has(arg)) {
+            rest.push(arg, ...(i + 1 < argv.length ? [argv[i + 1]] : []));
+            i += 2;
+        }
+        else if (arg === '--json') {
+            rest.push(arg);
+            i += 1;
+        }
+        else if (arg.startsWith('-')) {
+            break;
+        }
+        else {
+            words.push(arg);
+            i += 1;
+        }
+    }
+    return { words, rest: [...rest, ...argv.slice(i)] };
+}
+/** Commands that only touch local configuration (no capability behind them). */
+export const LOCAL_COMMANDS = ['auth login', 'auth logout', 'auth status', 'doctor'];
+/**
+ * Data commands: each is the adapter of one registered capability (UX26-F,
+ * apps/api/src/lib/capabilities). A command without one is not offered.
+ */
+export const DATA_COMMANDS = PUBLIC_CAPABILITIES.flatMap((c) => c.cliCommand ? [c.cliCommand] : []);
+export const OPERATION_COMMANDS = [
+    'operations list',
+    'operations inspect',
+    'operations preview',
+    'operations run',
+    'messages send',
+    'lifecycle activate',
+    'campaigns send',
+    'campaigns schedule',
+];
+const COMMANDS = new Set([...LOCAL_COMMANDS, ...DATA_COMMANDS, ...OPERATION_COMMANDS]);
+function matchCommand(words) {
+    if (words.length >= 2 && COMMANDS.has(`${words[0]} ${words[1]}`)) {
+        return { name: `${words[0]} ${words[1]}`, positionals: [] };
+    }
+    if (words.length >= 1 && COMMANDS.has(words[0])) {
+        return { name: words[0], positionals: words.slice(1) };
+    }
+    return null;
+}
+export async function runCli(argv, io, deps = {}) {
+    const wantsJson = argv.includes('--json');
+    const { words, rest } = commandWords(argv);
+    const matched = matchCommand(words);
+    const commandName = matched?.name ?? words.join(' ');
+    let activeKey = null;
+    const out = new Output(io, wantsJson, commandName || 'help', () => activeKey ? [activeKey] : []);
+    try {
+        if (!matched) {
+            if (argv.includes('--version')) {
+                io.stdout(`${CLI_VERSION}\n`);
+                return EXIT.OK;
+            }
+            if (words.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+                io.stdout(`${HELP}\n`);
+                return words.length === 0 && !argv.includes('--help') && !argv.includes('-h')
+                    ? EXIT.USAGE
+                    : EXIT.OK;
+            }
+            throw new UsageError(`Unknown command "${words.join(' ')}".`);
+        }
+        const extra = {};
+        const name = matched.name;
+        if (name.startsWith('operations ') ||
+            name === 'messages send' ||
+            name === 'lifecycle activate' ||
+            name === 'campaigns send' ||
+            name === 'campaigns schedule') {
+            Object.assign(extra, {
+                input: { type: 'string' },
+                'idempotency-key': { type: 'string' },
+                confirm: { type: 'string' },
+            });
+        }
+        else if (name === 'orders list') {
+            Object.assign(extra, PAGING_OPTIONS, {
+                status: { type: 'string' },
+                'payment-status': { type: 'string' },
+                'fulfillment-status': { type: 'string' },
+                source: { type: 'string' },
+                store: { type: 'string' },
+                contact: { type: 'string' },
+                search: { type: 'string' },
+                after: { type: 'string' },
+                before: { type: 'string' },
+            });
+        }
+        else if (name === 'contacts search') {
+            Object.assign(extra, PAGING_OPTIONS, {
+                status: { type: 'string' },
+                stage: { type: 'string' },
+                tags: { type: 'string' },
+                'created-after': { type: 'string' },
+                'created-before': { type: 'string' },
+            });
+        }
+        else if (name === 'auth login') {
+            Object.assign(extra, { store: { type: 'string' }, 'no-verify': { type: 'boolean' } });
+        }
+        else if (name === 'auth status') {
+            Object.assign(extra, { offline: { type: 'boolean' } });
+        }
+        // A key typed as an argument stays in shell history and process lists:
+        // refuse it before parsing, without echoing what was typed.
+        const KEY_FLAG = /^--(key|token|api-key|apikey|secret)(=|$)/i;
+        if (rest.some((arg) => KEY_FLAG.test(arg))) {
+            throw new UsageError(KEY_ON_COMMAND_LINE);
+        }
+        let parsed;
+        try {
+            parsed = parseArgs({
+                args: rest,
+                options: { ...GLOBAL_OPTIONS, ...extra },
+                allowPositionals: true,
+                strict: true,
+            });
+        }
+        catch (error) {
+            throw new UsageError(error.message.replace(/\. To specify.*$/s, '.'));
+        }
+        const opts = parsed.values;
+        const positionals = [...matched.positionals, ...parsed.positionals];
+        if (opts.help) {
+            io.stdout(`${HELP}\n`);
+            return EXIT.OK;
+        }
+        const profile = typeof opts.profile === 'string' ? validateProfileName(opts.profile) : undefined;
+        const timeoutMs = intOption(opts.timeout, 'timeout', 100, 120_000);
+        const env = typeof opts.url === 'string' ? { ...io.env, INBOXY_API_URL: opts.url } : io.env;
+        const keychainFor = async () => deps.keychain !== undefined ? deps.keychain : systemKeychain(env);
+        const credentials = async () => {
+            const creds = await resolveCredentials({ env, profile, keychain: await keychainFor() });
+            activeKey = creds.apiKey;
+            return creds;
+        };
+        const clientFrom = (creds) => {
+            if (!creds.apiKey) {
+                throw new InboxyError({
+                    kind: 'config',
+                    code: 'API_KEY_MISSING',
+                    message: `No API key for profile "${creds.profile}". Set INBOXY_API_KEY or run \`inboxy auth login\`.`,
+                });
+            }
+            return new InboxyClient({
+                apiKey: creds.apiKey,
+                baseUrl: creds.apiUrl,
+                timeoutMs,
+                userAgent: `inboxy-cli/${CLI_VERSION}`,
+            });
+        };
+        const noPositionals = () => {
+            if (!positionals.length)
+                return;
+            // `auth login <key>`: never echo the argument back (it is probably the key).
+            if (name === 'auth login')
+                throw new UsageError(KEY_ON_COMMAND_LINE);
+            throw new UsageError(`Unexpected argument "${positionals[0]}".`);
+        };
+        if (name.startsWith('operations ') ||
+            name === 'messages send' ||
+            name === 'lifecycle activate' ||
+            name === 'campaigns send' ||
+            name === 'campaigns schedule') {
+            if (name === 'operations list') {
+                noPositionals();
+                return out.success(describeOperations(), undefined, () => JSON.stringify(describeOperations(), null, 2));
+            }
+            if (positionals.length !== (['messages send', 'campaigns schedule'].includes(name) ? 0 : 1))
+                throw new UsageError('Supply one operation id, or use messages send with --input.');
+            const operation = name === 'messages send'
+                ? 'inbox.message.send'
+                : name === 'campaigns schedule'
+                    ? 'campaigns.schedule'
+                    : positionals[0];
+            if (name === 'operations inspect') {
+                const descriptor = describeOperations().find((op) => op.id === operation);
+                if (!descriptor)
+                    throw new UsageError('Unknown operation.');
+                return out.success(descriptor, undefined, () => JSON.stringify(descriptor, null, 2));
+            }
+            let input;
+            try {
+                input = JSON.parse(typeof opts.input === 'string' ? opts.input : '{}');
+            }
+            catch {
+                throw new UsageError('--input must be valid JSON.');
+            }
+            const idempotencyKey = opts['idempotency-key'];
+            const preview = prepareOperation(operation, input, idempotencyKey);
+            if (name === 'operations preview')
+                return out.success(preview, undefined, () => JSON.stringify(preview, null, 2));
+            if (name === 'campaigns send' && !['campaigns.send', 'campaigns.resume'].includes(operation))
+                throw new UsageError('Only campaigns.send and campaigns.resume are accepted.');
+            if (name === 'lifecycle activate' && preview.effect !== 'activate')
+                throw new UsageError('Only activate-effect operations are accepted.');
+            if (name === 'operations run' && ['send', 'activate', 'schedule'].includes(preview.effect))
+                throw new UsageError('Use messages send, lifecycle activate, campaigns send or campaigns schedule after explicit approval of the exact preview.');
+            const result = await clientFrom(await credentials()).executeOperation(operation, input, {
+                idempotencyKey,
+                confirmation: opts.confirm,
+            });
+            return out.success(result, undefined, () => JSON.stringify(result, null, 2));
+        }
+        switch (name) {
+            // ------------------------------------------------------------------
+            case 'whoami': {
+                noPositionals();
+                const { data } = await clientFrom(await credentials()).getCompany();
+                return out.success(data, undefined, () => [
+                    `Company   ${data.company.name} (${data.company.id})`,
+                    `Key       ${data.token.name} · ${data.token.prefix}…`,
+                    `Scopes    ${data.token.scopes.join(', ') || 'none'}`,
+                    `Expires   ${data.token.expiresAt ?? 'never'}`,
+                    `Limits    ${data.rateLimits.perKey.limit}/min per key · ${data.rateLimits.perCompany.limit}/min per company`,
+                ].join('\n'));
+            }
+            // ------------------------------------------------------------------
+            case 'usage': {
+                noPositionals();
+                const { data } = await clientFrom(await credentials()).getUsage();
+                return out.success(data, undefined, () => {
+                    const rows = Object.entries(data.usage).map(([k, c]) => [
+                        k,
+                        c.used,
+                        c.limit === null ? 'unlimited' : c.limit,
+                    ]);
+                    return [
+                        `Plan ${data.plan.name} (${data.plan.status}${data.plan.isTrial ? ', trial' : ''}) · period ends ${data.plan.currentPeriodEnd}`,
+                        table(['counter', 'used', 'limit'], rows),
+                        `API requests in the last 24 h: ${data.api.requestsLast24h}`,
+                    ].join('\n');
+                });
+            }
+            // ------------------------------------------------------------------
+            case 'stores list': {
+                noPositionals();
+                const { data } = await clientFrom(await credentials()).getUsage();
+                const result = {
+                    stores: data.usage.stores,
+                    items: null,
+                    note: 'Public API v1 has no stores route yet; this is the connected-store count from plan usage. Per-store details and health are in the dashboard.',
+                };
+                return out.success(result, undefined, () => [
+                    `Connected stores: ${data.usage.stores.used} of ${data.usage.stores.limit ?? 'unlimited'}`,
+                    result.note,
+                ].join('\n'));
+            }
+            // ------------------------------------------------------------------
+            case 'orders list': {
+                noPositionals();
+                const query = {
+                    status: enumOption(opts.status, 'status', ORDER_STATUSES),
+                    paymentStatus: enumOption(opts['payment-status'], 'payment-status', PAYMENT_STATUSES),
+                    fulfillmentStatus: enumOption(opts['fulfillment-status'], 'fulfillment-status', FULFILLMENT_STATUSES),
+                    source: enumOption(opts.source, 'source', ORDER_SOURCES),
+                    storeId: opts.store,
+                    contactId: opts.contact,
+                    search: opts.search,
+                    dateAfter: isoOption(opts.after, 'after'),
+                    dateBefore: isoOption(opts.before, 'before'),
+                    limit: intOption(opts.limit, 'limit', 1, PAGE_LIMIT_MAX),
+                    cursor: opts.cursor,
+                };
+                const client = clientFrom(await credentials());
+                const page = await listPages((q) => client.listOrders(q), query, opts);
+                return out.success(page.items, page.meta, () => [
+                    table(['id', 'number', 'status', 'payment', 'total', 'customer', 'date'], page.items.map((o) => [
+                        o.id,
+                        o.orderNumber,
+                        o.status,
+                        o.paymentStatus,
+                        `${o.total} ${o.currency}`,
+                        o.contact?.name,
+                        o.orderDate.slice(0, 10),
+                    ])),
+                    pagingHint(page.meta),
+                ]
+                    .filter(Boolean)
+                    .join('\n'));
+            }
+            case 'orders get': {
+                if (positionals.length !== 1)
+                    throw new UsageError('Usage: inboxy orders get <id>');
+                const { data: o } = await clientFrom(await credentials()).getOrder(positionals[0]);
+                return out.success(o, undefined, () => [
+                    `Order ${o.orderNumber} (${o.id}) · ${o.source}`,
+                    `Status ${o.status} · payment ${o.paymentStatus} · fulfillment ${o.fulfillmentStatus} · confirmation ${o.confirmationStatus}`,
+                    `Total ${o.total} ${o.currency} (subtotal ${o.subtotal}, shipping ${o.shipping ?? '-'}, discount ${o.discount ?? '-'})`,
+                    `Customer ${o.contact ? `${o.contact.name} ${o.contact.phone ?? ''}`.trim() : '-'}`,
+                    `Date ${o.orderDate}`,
+                    table(['item', 'sku', 'qty', 'total'], o.items.map((i) => [
+                        i.variant ? `${i.name} (${i.variant})` : i.name,
+                        i.sku,
+                        i.quantity,
+                        i.totalPrice,
+                    ])),
+                ].join('\n'));
+            }
+            // ------------------------------------------------------------------
+            case 'contacts search': {
+                if (positionals.length > 1)
+                    throw new UsageError('Usage: inboxy contacts search [text]');
+                const query = {
+                    search: positionals[0],
+                    status: enumOption(opts.status, 'status', CONTACT_STATUSES),
+                    lifecycleStage: enumOption(opts.stage, 'stage', LIFECYCLE_STAGES),
+                    tagIds: opts.tags,
+                    createdAfter: isoOption(opts['created-after'], 'created-after'),
+                    createdBefore: isoOption(opts['created-before'], 'created-before'),
+                    limit: intOption(opts.limit, 'limit', 1, PAGE_LIMIT_MAX),
+                    cursor: opts.cursor,
+                };
+                const client = clientFrom(await credentials());
+                const page = await listPages((q) => client.listContacts(q), query, opts);
+                return out.success(page.items, page.meta, () => [
+                    table(['id', 'name', 'phone', 'email', 'stage', 'orders'], page.items.map((c) => [
+                        c.id,
+                        c.name,
+                        c.phone,
+                        c.email,
+                        c.lifecycleStage,
+                        c.totalOrders,
+                    ])),
+                    pagingHint(page.meta),
+                ]
+                    .filter(Boolean)
+                    .join('\n'));
+            }
+            // ------------------------------------------------------------------
+            case 'doctor': {
+                noPositionals();
+                let creds;
+                let credentialError;
+                try {
+                    creds = await credentials();
+                }
+                catch (error) {
+                    // A refused config (e.g. a key in a world-readable file) is a failed
+                    // check, not a crash.
+                    if (!(error instanceof InboxyError) || error.kind !== 'config')
+                        throw error;
+                    credentialError = `${error.code}: ${error.message}`;
+                    creds = {
+                        profile: profile ?? env.INBOXY_PROFILE ?? 'default',
+                        apiKey: null,
+                        keySource: 'none',
+                        apiUrl: env.INBOXY_API_URL ?? 'https://api.inboxy.chat',
+                        urlSource: env.INBOXY_API_URL ? 'env' : 'default',
+                        configPath: '',
+                        warnings: [],
+                    };
+                }
+                const report = await runDoctor(creds, { env, timeoutMs, now: io.now, credentialError });
+                const code = out.success(report, undefined, () => [
+                    `Profile "${report.profile}" · ${report.apiUrl}`,
+                    ...report.checks.map((c) => `${c.status.toUpperCase().padEnd(4)}  ${c.id.padEnd(14)} ${c.message}`),
+                    report.ok ? 'All checks passed.' : 'Some checks failed.',
+                ].join('\n'));
+                return report.ok ? code : EXIT.CHECKS_FAILED;
+            }
+            // ------------------------------------------------------------------
+            case 'auth status': {
+                noPositionals();
+                const creds = await credentials();
+                const status = {
+                    profile: creds.profile,
+                    apiUrl: creds.apiUrl,
+                    urlSource: creds.urlSource,
+                    keySource: creds.keySource,
+                    keyPrefix: creds.apiKey ? `${creds.apiKey.slice(0, 8)}…` : null,
+                    verified: null,
+                    company: null,
+                };
+                if (!creds.apiKey) {
+                    throw new InboxyError({
+                        kind: 'config',
+                        code: 'API_KEY_MISSING',
+                        message: `Not signed in (profile "${creds.profile}"). Run \`inboxy auth login\` or set INBOXY_API_KEY.`,
+                    });
+                }
+                if (!opts.offline) {
+                    const { data } = await clientFrom(creds).getCompany();
+                    status.verified = true;
+                    status.company = { id: data.company.id, name: data.company.name };
+                }
+                return out.success(status, undefined, () => [
+                    `Profile   ${creds.profile}`,
+                    `API       ${creds.apiUrl} (from ${creds.urlSource})`,
+                    `Key       ${status.keyPrefix} (from ${creds.keySource})`,
+                    status.company
+                        ? `Verified  ${status.company.name} accepts this key`
+                        : 'Verified  skipped (--offline)',
+                ].join('\n'));
+            }
+            case 'auth login': {
+                noPositionals();
+                const profileName = profile ?? io.env.INBOXY_PROFILE ?? 'default';
+                validateProfileName(profileName);
+                const storeOpt = opts.store;
+                if (storeOpt !== undefined && storeOpt !== 'keychain' && storeOpt !== 'file') {
+                    throw new UsageError('--store must be keychain or file.');
+                }
+                const apiUrl = normalizeBaseUrl(opts.url ?? io.env.INBOXY_API_URL ?? 'https://api.inboxy.chat');
+                const key = io.interactive
+                    ? await loginWithDeviceFlow(apiUrl, {
+                        stderr: (text) => io.stderr(text),
+                        openUrl: io.openUrl,
+                        sleep: io.sleep,
+                        fetch: io.fetch,
+                        now: () => io.now(),
+                    })
+                    : (await io.readSecret('Inboxy API key (input hidden): ')).trim();
+                activeKey = key;
+                if (!key)
+                    throw new UsageError('No API key received on stdin.');
+                if (!looksLikeInboxyKey(key)) {
+                    throw new InboxyError({
+                        kind: 'config',
+                        code: 'API_KEY_INVALID_FORMAT',
+                        message: 'That does not look like an Inboxy API key (inboxy_ followed by 64 hex characters).',
+                    });
+                }
+                let company = null;
+                if (!opts['no-verify']) {
+                    const client = new InboxyClient({
+                        apiKey: key,
+                        baseUrl: apiUrl,
+                        timeoutMs,
+                        userAgent: `inboxy-cli/${CLI_VERSION}`,
+                    });
+                    const { data } = await client.getCompany();
+                    company = { id: data.company.id, name: data.company.name };
+                }
+                const keychain = storeOpt === 'file' ? null : await keychainFor();
+                if (storeOpt === 'keychain' && !keychain) {
+                    throw new InboxyError({
+                        kind: 'config',
+                        code: 'KEYCHAIN_UNAVAILABLE',
+                        message: 'No OS keychain is available on this machine. Use --store file, or set INBOXY_API_KEY.',
+                    });
+                }
+                const loaded = await loadConfig(env);
+                const config = loaded.config;
+                if (keychain) {
+                    await keychain.set(profileName, key);
+                    config.profiles[profileName] = { apiUrl, keyStorage: 'keychain' };
+                }
+                else {
+                    config.profiles[profileName] = { apiUrl, keyStorage: 'file', apiKey: key };
+                }
+                if (!config.defaultProfile)
+                    config.defaultProfile = profileName;
+                const file = await saveConfig(config, env);
+                const result = {
+                    profile: profileName,
+                    apiUrl,
+                    keyStorage: keychain ? 'keychain' : 'file',
+                    keychain: keychain?.name ?? null,
+                    configPath: file,
+                    verified: company !== null,
+                    company,
+                };
+                if (!keychain)
+                    out.note(`No OS keychain in use: the key is stored in ${file} (mode 600).`);
+                return out.success(result, undefined, () => `Saved profile "${profileName}" (${keychain ? keychain.name : `file ${file}`}).${company ? ` Company: ${company.name}.` : ' Not verified (--no-verify).'}`);
+            }
+            case 'auth logout': {
+                noPositionals();
+                const loaded = await loadConfig(env);
+                const profileName = profile ?? io.env.INBOXY_PROFILE ?? loaded.config.defaultProfile ?? 'default';
+                validateProfileName(profileName);
+                const keychain = await keychainFor();
+                let removedFromKeychain = false;
+                if (keychain)
+                    removedFromKeychain = await keychain.delete(profileName).catch(() => false);
+                const had = profileName in loaded.config.profiles;
+                if (had) {
+                    delete loaded.config.profiles[profileName];
+                    if (loaded.config.defaultProfile === profileName)
+                        delete loaded.config.defaultProfile;
+                    await saveConfig(loaded.config, env);
+                }
+                const result = { profile: profileName, removedFromKeychain, removedFromConfig: had };
+                return out.success(result, undefined, () => had || removedFromKeychain
+                    ? `Removed profile "${profileName}".`
+                    : `Profile "${profileName}" was not stored.`);
+            }
+        }
+        throw new UsageError(`Unknown command "${name}".`);
+    }
+    catch (error) {
+        return out.failure(error);
+    }
+}
+async function listPages(fetchPage, query, opts) {
+    const maxPages = intOption(opts['max-pages'], 'max-pages', 1, 1000);
+    if (maxPages !== undefined && !opts.all)
+        throw new UsageError('--max-pages needs --all.');
+    if (!opts.all) {
+        const page = await fetchPage(query);
+        return { items: page.data, meta: { ...page.meta, pages: 1 } };
+    }
+    const all = await collectPages(fetchPage, query, maxPages ?? 10);
+    return { items: all.items, meta: { ...all.meta, pages: all.pages } };
+}
+function pagingHint(meta) {
+    return meta.hasMore && meta.nextCursor ? `More results: --cursor ${meta.nextCursor}` : '';
+}
+//# sourceMappingURL=cli.js.map