@commissionsight/cli 0.1.0

package/dist/commands/admin.js

@@ -0,0 +1,409 @@
+import { cover } from './registry.js';
+import { loadFile } from '../lib/file.js';
+import { readJsonInput } from '../lib/input.js';
+import { confirmDestructive } from '../lib/confirm.js';
+import { ApiError, CliError, UsageError, EXIT } from '../errors.js';
+import { optStr, optBool, optNum } from '../util.js';
+async function adminGate(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        if (e instanceof ApiError && (e.status === 401 || e.status === 403)) {
+            throw new CliError('admin token required: this token is not authorized for admin endpoints', EXIT.AUTH);
+        }
+        throw e;
+    }
+}
+const a = (ctx) => ctx.client().admin;
+export function adminCommands() {
+    registerCoverage();
+    return [
+        // ---- accounts -------------------------------------------------------
+        {
+            path: ['admin', 'account', 'list'],
+            summary: 'List accounts',
+            options: { status: { type: 'string', desc: 'Filter by status', choices: ['active', 'pending', 'suspended'], placeholder: '<s>' } },
+            run: (ctx, p) => adminGate(async () => (await a(ctx).listAccounts(optStr(p.options['status']))).data),
+        },
+        {
+            path: ['admin', 'account', 'create'],
+            summary: 'Create an account',
+            args: [{ name: 'name', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).createAccount(p.args[0])),
+        },
+        {
+            path: ['admin', 'account', 'approve'],
+            summary: 'Approve a pending account',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).approveAccount(p.args[0])),
+        },
+        {
+            path: ['admin', 'account', 'provision'],
+            summary: 'Provision (or re-provision) an account data store',
+            args: [{ name: 'id', required: true }],
+            options: { 'conn-string': { type: 'string', desc: 'Use an out-of-band DB connection string', placeholder: '<s>' } },
+            run: (ctx, p) => adminGate(() => a(ctx).provisionAccount(p.args[0], optStr(p.options['conn-string']))),
+        },
+        {
+            path: ['admin', 'account', 'overview'],
+            summary: 'Per-account dashboard (counts + latest rollup)',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).accountOverview(p.args[0])),
+        },
+        {
+            path: ['admin', 'account', 'files'],
+            summary: 'List an account’s files',
+            args: [{ name: 'id', required: true }],
+            options: pageOpts(),
+            run: (ctx, p) => adminGate(async () => (await a(ctx).accountFiles(p.args[0], pageParams(p.options))).data),
+        },
+        {
+            path: ['admin', 'account', 'jobs'],
+            summary: 'List an account’s jobs',
+            args: [{ name: 'id', required: true }],
+            options: pageOpts(),
+            run: (ctx, p) => adminGate(async () => (await a(ctx).accountJobs(p.args[0], pageParams(p.options))).data),
+        },
+        {
+            path: ['admin', 'account', 'users'],
+            summary: 'List an account’s users',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(async () => (await a(ctx).accountUsers(p.args[0])).data),
+        },
+        {
+            path: ['admin', 'account', 'purge-files'],
+            summary: 'Purge ALL raw bytes for an account (destructive)',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(async () => {
+                await confirmDestructive(ctx, `purge ALL files for account ${p.args[0]}`);
+                return a(ctx).purgeAccountFiles(p.args[0]);
+            }),
+        },
+        {
+            path: ['admin', 'account', 'billing'],
+            summary: 'Get an account’s billing record',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).getAccountBilling(p.args[0])),
+        },
+        {
+            path: ['admin', 'account', 'billing-rate'],
+            summary: 'Set/clear an account’s custom billing rate (cents)',
+            args: [{ name: 'id', required: true }],
+            options: {
+                cents: { type: 'string', desc: 'Custom per-member rate in cents', placeholder: '<n>' },
+                clear: { type: 'boolean', desc: 'Clear the custom rate' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                if (optBool(p.options['clear']))
+                    return a(ctx).setBillingRate(p.args[0], null);
+                const cents = optNum(p.options['cents']);
+                if (cents === undefined)
+                    throw new UsageError('provide --cents <n> or --clear');
+                return a(ctx).setBillingRate(p.args[0], cents);
+            }),
+        },
+        {
+            path: ['admin', 'account', 'ai-settings'],
+            summary: 'Set an account’s AI cap + pass-through billing',
+            args: [{ name: 'id', required: true }],
+            options: {
+                'cap-cents': { type: 'string', desc: 'Monthly AI cap in cents', placeholder: '<n>' },
+                passthrough: { type: 'boolean', desc: 'Enable pass-through billing' },
+            },
+            run: (ctx, p) => adminGate(() => a(ctx).setAiSettings(p.args[0], {
+                ...(optNum(p.options['cap-cents']) !== undefined ? { capCents: optNum(p.options['cap-cents']) } : {}),
+                ...(optBool(p.options['passthrough']) ? { passthrough: true } : {}),
+            })),
+        },
+        {
+            path: ['admin', 'account', 'surcharge'],
+            summary: 'Enable/disable an account surcharge',
+            args: [{ name: 'id', required: true }],
+            options: {
+                enabled: { type: 'boolean', desc: 'Enable the surcharge' },
+                disabled: { type: 'boolean', desc: 'Disable the surcharge' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const on = optBool(p.options['enabled']);
+                const off = optBool(p.options['disabled']);
+                if (on === off)
+                    throw new UsageError('pass exactly one of --enabled or --disabled');
+                return a(ctx).setSurcharge(p.args[0], on);
+            }),
+        },
+        {
+            path: ['admin', 'account', 'credentials'],
+            summary: 'Store DB credentials for an account',
+            args: [{ name: 'accountId', required: true }],
+            options: {
+                'conn-string': { type: 'string', desc: 'Connection string (required)', placeholder: '<s>' },
+                region: { type: 'string', desc: 'Region', placeholder: '<r>' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const connString = optStr(p.options['conn-string']);
+                if (!connString)
+                    throw new UsageError('--conn-string is required');
+                return a(ctx).storeCredentials(p.args[0], {
+                    connString,
+                    ...(optStr(p.options['region']) ? { region: optStr(p.options['region']) } : {}),
+                });
+            }),
+        },
+        // ---- tokens ---------------------------------------------------------
+        {
+            path: ['admin', 'token', 'issue'],
+            summary: 'Issue an API token for an account (shown once)',
+            args: [{ name: 'accountId', required: true }],
+            options: { label: { type: 'string', desc: 'Token label', placeholder: '<l>' } },
+            run: (ctx, p) => adminGate(async () => {
+                const res = await a(ctx).issueToken(p.args[0], optStr(p.options['label']));
+                ctx.log('token shown once and not stored — copy it now');
+                return res;
+            }),
+        },
+        {
+            path: ['admin', 'token', 'list'],
+            summary: 'List an account’s API tokens (metadata only)',
+            args: [{ name: 'accountId', required: true }],
+            run: (ctx, p) => adminGate(async () => (await a(ctx).listTokens(p.args[0])).data),
+        },
+        {
+            path: ['admin', 'token', 'revoke'],
+            summary: 'Revoke an API token',
+            args: [{ name: 'tokenId', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).revokeToken(p.args[0])),
+        },
+        // ---- carriers -------------------------------------------------------
+        {
+            path: ['admin', 'carrier', 'create'],
+            summary: 'Create a carrier',
+            options: {
+                name: { type: 'string', desc: 'Carrier name (required)', placeholder: '<n>' },
+                slug: { type: 'string', desc: 'Carrier slug (required)', placeholder: '<s>' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const name = optStr(p.options['name']);
+                const slug = optStr(p.options['slug']);
+                if (!name || !slug)
+                    throw new UsageError('--name and --slug are required');
+                return a(ctx).createCarrier(name, slug);
+            }),
+        },
+        {
+            path: ['admin', 'carrier', 'rename'],
+            summary: 'Rename a carrier',
+            args: [{ name: 'id', required: true }],
+            options: {
+                name: { type: 'string', desc: 'New name (required)', placeholder: '<n>' },
+                slug: { type: 'string', desc: 'New slug (optional)', placeholder: '<s>' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const name = optStr(p.options['name']);
+                if (!name)
+                    throw new UsageError('--name is required');
+                return a(ctx).renameCarrier(p.args[0], name, optStr(p.options['slug']));
+            }),
+        },
+        {
+            path: ['admin', 'carrier', 'config', 'create'],
+            summary: 'Create a global carrier config (-f file.json or stdin)',
+            args: [{ name: 'carrierId', required: true }],
+            options: { file: { type: 'string', short: 'f', desc: 'Config JSON', placeholder: '<f.json>' } },
+            run: (ctx, p) => adminGate(() => a(ctx).createGlobalConfig(p.args[0], readJsonInput(optStr(p.options['file'])))),
+        },
+        {
+            path: ['admin', 'carrier', 'config', 'list'],
+            summary: 'List a carrier’s global configs',
+            args: [{ name: 'carrierId', required: true }],
+            run: (ctx, p) => adminGate(async () => (await a(ctx).listCarrierConfigs(p.args[0])).data),
+        },
+        {
+            path: ['admin', 'carrier', 'config', 'update'],
+            summary: 'Update a carrier config (-f file.json or stdin)',
+            args: [
+                { name: 'carrierId', required: true },
+                { name: 'configId', required: true },
+            ],
+            options: { file: { type: 'string', short: 'f', desc: 'Config JSON', placeholder: '<f.json>' } },
+            run: (ctx, p) => adminGate(() => a(ctx).updateCarrierConfig(p.args[0], p.args[1], readJsonInput(optStr(p.options['file'])))),
+        },
+        {
+            path: ['admin', 'carrier', 'config', 'infer'],
+            summary: 'Infer a draft config from a sample file',
+            args: [{ name: 'carrierId', required: true }],
+            options: {
+                file: { type: 'string', desc: 'Sample file (required)', placeholder: '<sample>' },
+                sheet: { type: 'string', desc: 'Sheet name (xlsx)', placeholder: '<name>' },
+                type: { type: 'string', desc: 'File type', choices: ['csv', 'xlsx'], placeholder: '<t>' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const file = optStr(p.options['file']);
+                if (!file)
+                    throw new UsageError('--file <sample> is required');
+                const opts = {
+                    ...(optStr(p.options['sheet']) ? { sheetName: optStr(p.options['sheet']) } : {}),
+                    ...(optStr(p.options['type']) ? { fileType: optStr(p.options['type']) } : {}),
+                };
+                return a(ctx).inferConfig(p.args[0], loadFile(file), Object.keys(opts).length ? opts : undefined);
+            }),
+        },
+        // ---- users ----------------------------------------------------------
+        {
+            path: ['admin', 'user', 'list'],
+            summary: 'List all users',
+            run: (ctx) => adminGate(async () => (await a(ctx).listUsers()).data),
+        },
+        {
+            path: ['admin', 'user', 'create'],
+            summary: 'Create a user',
+            options: {
+                email: { type: 'string', desc: 'Email (required)', placeholder: '<email>' },
+                account: { type: 'string', desc: 'Account id', placeholder: '<id>' },
+                role: { type: 'string', desc: 'Role', choices: ['member', 'admin'], placeholder: '<r>' },
+            },
+            run: (ctx, p) => adminGate(() => {
+                const email = optStr(p.options['email']);
+                if (!email)
+                    throw new UsageError('--email is required');
+                return a(ctx).createUser({
+                    email,
+                    ...(optStr(p.options['account']) ? { accountId: optStr(p.options['account']) } : {}),
+                    ...(optStr(p.options['role']) ? { role: optStr(p.options['role']) } : {}),
+                });
+            }),
+        },
+        {
+            path: ['admin', 'user', 'update'],
+            summary: 'Update a user’s role',
+            args: [{ name: 'id', required: true }],
+            options: { role: { type: 'string', desc: 'Role (required)', choices: ['member', 'admin'], placeholder: '<r>' } },
+            run: (ctx, p) => adminGate(() => {
+                const role = optStr(p.options['role']);
+                if (!role)
+                    throw new UsageError('--role member|admin is required');
+                return a(ctx).updateUser(p.args[0], { role });
+            }),
+        },
+        {
+            path: ['admin', 'user', 'delete'],
+            summary: 'Delete a user (destructive)',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(async () => {
+                await confirmDestructive(ctx, `delete user ${p.args[0]}`);
+                return a(ctx).deleteUser(p.args[0]);
+            }),
+        },
+        // ---- allowlist / jobs / system -------------------------------------
+        {
+            path: ['admin', 'allowlist', 'add'],
+            summary: 'Add an email to the allowlist',
+            args: [{ name: 'email', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).addAllowlist(p.args[0])),
+        },
+        {
+            path: ['admin', 'job', 'list'],
+            summary: 'List jobs across accounts',
+            options: pageOpts({ status: { type: 'string', desc: 'Filter by status', placeholder: '<s>' } }),
+            run: (ctx, p) => adminGate(async () => (await a(ctx).listJobs({
+                ...(optStr(p.options['status']) ? { status: optStr(p.options['status']) } : {}),
+                ...pageParams(p.options),
+            })).data),
+        },
+        {
+            path: ['admin', 'job', 'get'],
+            summary: 'Get full job detail',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).jobDetail(p.args[0])),
+        },
+        {
+            path: ['admin', 'job', 'retry'],
+            summary: 'Retry a job',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).retryJob(p.args[0])),
+        },
+        {
+            path: ['admin', 'job', 'rescore'],
+            summary: 'Rescore a job',
+            args: [{ name: 'id', required: true }],
+            run: (ctx, p) => adminGate(() => a(ctx).rescoreJob(p.args[0])),
+        },
+        {
+            path: ['admin', 'metrics'],
+            summary: 'Platform metrics',
+            run: (ctx) => adminGate(() => a(ctx).metrics()),
+        },
+        {
+            path: ['admin', 'logs'],
+            summary: 'Recent platform log events',
+            options: pageOpts(),
+            run: (ctx, p) => adminGate(() => a(ctx).logs(pageParams(p.options))),
+        },
+        {
+            path: ['admin', 'revenue'],
+            summary: 'Platform billing/revenue summary',
+            run: (ctx) => adminGate(() => a(ctx).revenue()),
+        },
+        {
+            path: ['admin', 'cron-runs'],
+            summary: 'Recent scheduled-maintenance runs',
+            options: { limit: { type: 'string', desc: 'Max runs', placeholder: '<n>' } },
+            run: (ctx, p) => adminGate(() => a(ctx).cronRuns(optNum(p.options['limit']) !== undefined ? { limit: optNum(p.options['limit']) } : undefined)),
+        },
+    ];
+}
+function pageOpts(extra = {}) {
+    return {
+        limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+        offset: { type: 'string', desc: 'Offset', placeholder: '<n>' },
+        ...extra,
+    };
+}
+function pageParams(options) {
+    return {
+        ...(optNum(options['limit']) !== undefined ? { limit: optNum(options['limit']) } : {}),
+        ...(optNum(options['offset']) !== undefined ? { offset: optNum(options['offset']) } : {}),
+    };
+}
+function registerCoverage() {
+    const map = {
+        'admin.listAccounts': 'cs admin account list',
+        'admin.createAccount': 'cs admin account create',
+        'admin.approveAccount': 'cs admin account approve',
+        'admin.provisionAccount': 'cs admin account provision',
+        'admin.accountOverview': 'cs admin account overview',
+        'admin.accountFiles': 'cs admin account files',
+        'admin.accountJobs': 'cs admin account jobs',
+        'admin.accountUsers': 'cs admin account users',
+        'admin.purgeAccountFiles': 'cs admin account purge-files',
+        'admin.getAccountBilling': 'cs admin account billing',
+        'admin.setBillingRate': 'cs admin account billing-rate',
+        'admin.setAiSettings': 'cs admin account ai-settings',
+        'admin.setSurcharge': 'cs admin account surcharge',
+        'admin.storeCredentials': 'cs admin account credentials',
+        'admin.issueToken': 'cs admin token issue',
+        'admin.listTokens': 'cs admin token list',
+        'admin.revokeToken': 'cs admin token revoke',
+        'admin.createCarrier': 'cs admin carrier create',
+        'admin.renameCarrier': 'cs admin carrier rename',
+        'admin.createGlobalConfig': 'cs admin carrier config create',
+        'admin.listCarrierConfigs': 'cs admin carrier config list',
+        'admin.updateCarrierConfig': 'cs admin carrier config update',
+        'admin.inferConfig': 'cs admin carrier config infer',
+        'admin.listUsers': 'cs admin user list',
+        'admin.createUser': 'cs admin user create',
+        'admin.updateUser': 'cs admin user update',
+        'admin.deleteUser': 'cs admin user delete',
+        'admin.addAllowlist': 'cs admin allowlist add',
+        'admin.listJobs': 'cs admin job list',
+        'admin.jobDetail': 'cs admin job get',
+        'admin.retryJob': 'cs admin job retry',
+        'admin.rescoreJob': 'cs admin job rescore',
+        'admin.metrics': 'cs admin metrics',
+        'admin.logs': 'cs admin logs',
+        'admin.revenue': 'cs admin revenue',
+        'admin.cronRuns': 'cs admin cron-runs',
+    };
+    for (const [method, command] of Object.entries(map))
+        cover(method, command);
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth commands (plan §4.3): login (store + verify), status, logout, and the
+ * admin-only `token issue`. Tokens are stored in the config file (0600) and
+ * never printed except as a masked suffix.
+ */
+import type { Cmd } from '../types.js';
+export declare function authCommands(): Cmd[];

package/dist/commands/auth.js

@@ -0,0 +1,107 @@
+import { cover } from './registry.js';
+import { resolveExplicitToken, resolveBaseUrl, resolveToken, clientFor, } from '../context.js';
+import { upsertContext, loadConfig, saveConfig, activeContextName } from '../config/store.js';
+import { DEFAULT_CONTEXT_NAME } from '../config/schema.js';
+import { UsageError } from '../errors.js';
+import { maskToken, optStr } from '../util.js';
+export function authCommands() {
+    cover('admin.issueToken', 'cs auth token issue');
+    return [
+        {
+            path: ['auth', 'login'],
+            summary: 'Store an API token in a context and verify it via me()',
+            options: {
+            // token sources + base-url + context are global flags.
+            },
+            async run(ctx) {
+                const { globals, io } = ctx;
+                const token = resolveExplicitToken(globals, io);
+                if (!token) {
+                    throw new UsageError('no token provided. pass --token-stdin, --token-file <f>, --token <t>, or set COMMISSIONSIGHT_TOKEN');
+                }
+                if (globals.token && io.isTTY) {
+                    io.stderr('warning: --token is visible in shell history; prefer --token-stdin\n');
+                }
+                const name = globals.context || DEFAULT_CONTEXT_NAME;
+                const baseUrl = resolveBaseUrl(globals, io);
+                upsertContext(io, name, { baseUrl, token }, { setCurrent: true });
+                // Verify against the API with the captured token (avoids re-reading stdin).
+                const me = await clientFor(baseUrl, token, io).me();
+                ctx.log(`logged in to context "${name}" (${baseUrl})`);
+                return {
+                    context: name,
+                    baseUrl,
+                    token: maskToken(token),
+                    accountId: me.accountId,
+                    name: me.name,
+                    status: me.status,
+                };
+            },
+        },
+        {
+            path: ['auth', 'status'],
+            summary: 'Verify the resolved token via me() and show account + context',
+            async run(ctx) {
+                const { globals, io } = ctx;
+                const token = resolveToken(globals, io);
+                const baseUrl = resolveBaseUrl(globals, io);
+                const config = loadConfig(io);
+                const name = activeContextName(io, config, globals.context);
+                const me = await ctx.client().me();
+                return {
+                    context: name,
+                    baseUrl,
+                    token: maskToken(token),
+                    accountId: me.accountId,
+                    name: me.name,
+                    status: me.status,
+                };
+            },
+        },
+        {
+            path: ['auth', 'logout'],
+            summary: 'Remove the stored token from a context (keep the context)',
+            options: {
+                all: { type: 'boolean', desc: 'Remove the token from every context' },
+            },
+            async run(ctx, parsed) {
+                const { globals, io } = ctx;
+                const config = loadConfig(io);
+                if (parsed.options['all'] === true) {
+                    let cleared = 0;
+                    for (const c of Object.values(config.contexts)) {
+                        if (c.token) {
+                            delete c.token;
+                            cleared++;
+                        }
+                    }
+                    saveConfig(io, config);
+                    return { cleared };
+                }
+                const name = activeContextName(io, config, globals.context);
+                const target = config.contexts[name];
+                if (!target)
+                    throw new UsageError(`unknown context: ${name}`);
+                const had = Boolean(target.token);
+                delete target.token;
+                saveConfig(io, config);
+                return { context: name, cleared: had ? 1 : 0 };
+            },
+        },
+        {
+            path: ['auth', 'token', 'issue'],
+            summary: 'Admin-only: issue an API token for an account (printed once)',
+            args: [{ name: 'accountId', required: true }],
+            options: {
+                label: { type: 'string', desc: 'Human label for the token', placeholder: '<l>' },
+            },
+            async run(ctx, parsed) {
+                const accountId = parsed.args[0];
+                const label = optStr(parsed.options['label']);
+                const res = await ctx.client().admin.issueToken(accountId, label);
+                ctx.log('this token is shown once and is not stored — copy it now');
+                return res;
+            },
+        },
+    ];
+}

package/dist/commands/batch.d.ts

@@ -0,0 +1,2 @@
+import type { Cmd } from '../types.js';
+export declare function batchCommands(): Cmd[];

package/dist/commands/batch.js

@@ -0,0 +1,68 @@
+/**
+ * `cs upload batch <target>` (plan §6.3) — bulk, idempotent, resumable uploader.
+ * Target is a directory, a glob, or a manifest (JSON/CSV). Writes an optional
+ * JSON report and respects the --json envelope for the aggregate summary.
+ */
+import { writeFileSync } from 'node:fs';
+import { runBatch } from '../lib/batch.js';
+import { CliError, EXIT } from '../errors.js';
+import { optStr, optBool, optNum } from '../util.js';
+export function batchCommands() {
+    return [
+        {
+            path: ['upload', 'batch'],
+            summary: 'Bulk-upload statements from a directory, glob, or manifest',
+            args: [{ name: 'target', required: false }],
+            options: {
+                manifest: { type: 'string', desc: 'Manifest file (JSON/CSV) of uploads', placeholder: '<file>' },
+                pattern: { type: 'string', desc: 'Discovery regex with <carrier>/<period> groups', placeholder: '<re>' },
+                concurrency: { type: 'string', desc: 'Parallel uploads (default 3)', placeholder: '<n>' },
+                workspace: { type: 'string', desc: 'Target workspace for all rows', placeholder: '<w>' },
+                replace: { type: 'boolean', desc: 'Replace existing carrier+period' },
+                wait: { type: 'boolean', desc: 'Poll each job to a terminal state' },
+                'dry-run': { type: 'boolean', desc: 'Plan only; upload nothing' },
+                'continue-on-error': { type: 'boolean', desc: 'Keep going past failures' },
+                strict: { type: 'boolean', desc: 'Fail if any file does not match discovery' },
+                report: { type: 'string', desc: 'Write the full outcome array to JSON', placeholder: '<out.json>' },
+                timeout: { type: 'string', desc: 'Per-job wait timeout seconds (default 300)', placeholder: '<s>' },
+                interval: { type: 'string', desc: 'Poll interval seconds (default 2)', placeholder: '<s>' },
+            },
+            async run(ctx, parsed) {
+                const o = parsed.options;
+                const opts = {
+                    target: parsed.args[0] ?? '',
+                    ...(optStr(o['manifest']) ? { manifest: optStr(o['manifest']) } : {}),
+                    ...(optStr(o['pattern']) ? { pattern: optStr(o['pattern']) } : {}),
+                    ...(optNum(o['concurrency']) !== undefined ? { concurrency: optNum(o['concurrency']) } : {}),
+                    ...(optStr(o['workspace']) ? { workspace: optStr(o['workspace']) } : {}),
+                    replace: optBool(o['replace']),
+                    wait: optBool(o['wait']),
+                    dryRun: optBool(o['dry-run']),
+                    continueOnError: optBool(o['continue-on-error']),
+                    strict: optBool(o['strict']),
+                    timeoutMs: (optNum(o['timeout']) ?? 300) * 1000,
+                    intervalMs: (optNum(o['interval']) ?? 2) * 1000,
+                };
+                const summary = await runBatch(ctx, opts);
+                const reportPath = optStr(o['report']);
+                if (reportPath) {
+                    writeFileSync(reportPath, JSON.stringify(summary, null, 2) + '\n');
+                    ctx.log(`report written to ${reportPath}`);
+                }
+                // Non-zero exit when anything failed (unless continuing past errors).
+                if (summary.failed > 0 && !opts.continueOnError) {
+                    ctx.log(`${summary.failed} upload(s) failed`);
+                    throw new CliError(`batch completed with ${summary.failed} failure(s)`, EXIT.ERROR);
+                }
+                return summary;
+            },
+            render(data, ctx) {
+                const s = data;
+                ctx.io.stdout(`total ${s.total}  uploaded ${s.uploaded}  replaced ${s.replaced}  skipped ${s.skipped}  failed ${s.failed}` +
+                    (s.unmatched ? `  unmatched ${s.unmatched}` : '') +
+                    (s.planned ? `  planned ${s.planned}` : '') +
+                    '\n');
+            },
+        },
+    ];
+}

package/dist/commands/billing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Billing commands (plan §6.11). Payment-method / setup-intent are web-app-only
+ * Stripe flows (non-goal §1) and intentionally not exposed here.
+ */
+import type { Cmd } from '../types.js';
+export declare function billingCommands(): Cmd[];