@commissionsight/cli 0.1.0

package/dist/commands/billing.js

@@ -0,0 +1,75 @@
+import { cover } from './registry.js';
+import { makePrinter } from '../output/print.js';
+import { optStr } from '../util.js';
+const usd = (cents) => `$${(cents / 100).toFixed(2)}`;
+export function billingCommands() {
+    cover('getBilling', 'cs billing get');
+    cover('updateBilling', 'cs billing update');
+    cover('billingPreview', 'cs billing preview');
+    return [
+        {
+            path: ['billing', 'get'],
+            summary: 'Get the billing profile',
+            async run(ctx) {
+                return ctx.client().getBilling();
+            },
+        },
+        {
+            path: ['billing', 'preview'],
+            summary: 'Preview the upcoming invoice (amounts in USD)',
+            async run(ctx) {
+                return ctx.client().billingPreview();
+            },
+            render(data, ctx) {
+                const b = data;
+                const p = makePrinter(ctx.io, ctx.globals.color);
+                p.kv({
+                    period: b.period ?? '—',
+                    members: b.members,
+                    pricePerMember: usd(b.pricePerMemberCents),
+                    amount: usd(b.amountCents),
+                    method: b.method,
+                    fee: usd(b.feeCents),
+                    total: usd(b.totalCents),
+                    achSavings: usd(b.achSavingsCents),
+                    dueDate: b.dueDate ?? '—',
+                });
+            },
+        },
+        {
+            path: ['billing', 'update'],
+            summary: 'Update billing contact/address details',
+            options: {
+                'contact-name': { type: 'string', desc: 'Contact name', placeholder: '<name>' },
+                company: { type: 'string', desc: 'Company name', placeholder: '<name>' },
+                email: { type: 'string', desc: 'Billing email', placeholder: '<email>' },
+                phone: { type: 'string', desc: 'Phone', placeholder: '<phone>' },
+                'address-line1': { type: 'string', desc: 'Address line 1', placeholder: '<addr>' },
+                'address-line2': { type: 'string', desc: 'Address line 2', placeholder: '<addr>' },
+                city: { type: 'string', desc: 'City', placeholder: '<city>' },
+                state: { type: 'string', desc: 'State', placeholder: '<state>' },
+                'postal-code': { type: 'string', desc: 'Postal code', placeholder: '<zip>' },
+                country: { type: 'string', desc: 'Country', placeholder: '<country>' },
+            },
+            async run(ctx, parsed) {
+                const o = parsed.options;
+                const body = {
+                    ...set('contactName', optStr(o['contact-name'])),
+                    ...set('companyName', optStr(o['company'])),
+                    ...set('email', optStr(o['email'])),
+                    ...set('phone', optStr(o['phone'])),
+                    ...set('addressLine1', optStr(o['address-line1'])),
+                    ...set('addressLine2', optStr(o['address-line2'])),
+                    ...set('city', optStr(o['city'])),
+                    ...set('state', optStr(o['state'])),
+                    ...set('postalCode', optStr(o['postal-code'])),
+                    ...set('country', optStr(o['country'])),
+                };
+                return ctx.client().updateBilling(body);
+            },
+        },
+    ];
+}
+function set(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}

package/dist/commands/carrier.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Carrier + carrier-config commands (plan §6.2). Carrier refs accept
+ * id|slug|name via the resolver.
+ */
+import type { Cmd } from '../types.js';
+export declare function carrierCommands(): Cmd[];

package/dist/commands/carrier.js

@@ -0,0 +1,111 @@
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { loadFile } from '../lib/file.js';
+import { readJsonInput } from '../lib/input.js';
+import { UsageError } from '../errors.js';
+import { optStr, optBool } from '../util.js';
+export function carrierCommands() {
+    cover('listCarriers', 'cs carrier list');
+    cover('getCarrier', 'cs carrier get');
+    cover('listConfigs', 'cs carrier config list');
+    cover('getConfigVersion', 'cs carrier config get');
+    cover('createConfig', 'cs carrier config create');
+    cover('testConfig', 'cs carrier config test');
+    cover('inferConfig', 'cs carrier config infer');
+    return [
+        {
+            path: ['carrier', 'list'],
+            summary: 'List carriers',
+            options: {
+                'with-config': { type: 'boolean', desc: 'Include each carrier’s active config' },
+            },
+            async run(ctx, parsed) {
+                const page = await ctx.client().listCarriers({ withConfig: optBool(parsed.options['with-config']) });
+                return page.data;
+            },
+        },
+        {
+            path: ['carrier', 'get'],
+            summary: 'Get a carrier by id, slug, or name',
+            args: [{ name: 'carrier', required: true }],
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                return ctx.client().getCarrier(id);
+            },
+        },
+        {
+            path: ['carrier', 'config', 'list'],
+            summary: 'List a carrier’s config versions',
+            args: [{ name: 'carrier', required: true }],
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                const page = await ctx.client().listConfigs(id);
+                return page.data;
+            },
+        },
+        {
+            path: ['carrier', 'config', 'get'],
+            summary: 'Get a specific carrier config version',
+            args: [
+                { name: 'carrier', required: true },
+                { name: 'version', required: true },
+            ],
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                const version = Number(parsed.args[1]);
+                if (!Number.isInteger(version))
+                    throw new UsageError(`invalid version: ${parsed.args[1]}`);
+                return ctx.client().getConfigVersion(id, version);
+            },
+        },
+        {
+            path: ['carrier', 'config', 'create'],
+            summary: 'Create an account-scoped carrier config (-f file.json or stdin)',
+            args: [{ name: 'carrier', required: true }],
+            options: {
+                file: { type: 'string', short: 'f', desc: 'Config JSON file (else stdin)', placeholder: '<config.json>' },
+            },
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                const config = readJsonInput(optStr(parsed.options['file']));
+                return ctx.client().createConfig(id, config);
+            },
+        },
+        {
+            path: ['carrier', 'config', 'test'],
+            summary: 'Dry-run a config against a sample file (maps + previews)',
+            args: [{ name: 'carrier', required: true }],
+            options: {
+                config: { type: 'string', short: 'f', desc: 'Config JSON file (else stdin)', placeholder: '<config.json>' },
+                file: { type: 'string', desc: 'Sample statement file', placeholder: '<sample>' },
+            },
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                const samplePath = optStr(parsed.options['file']);
+                if (!samplePath)
+                    throw new UsageError('--file <sample> is required');
+                const config = readJsonInput(optStr(parsed.options['config']));
+                const file = loadFile(samplePath);
+                return ctx.client().testConfig(id, config, file);
+            },
+        },
+        {
+            path: ['carrier', 'config', 'infer'],
+            summary: 'Infer a draft config from a sample file',
+            args: [{ name: 'carrier', required: true }],
+            options: {
+                file: { type: 'string', desc: 'Sample statement file', placeholder: '<sample>' },
+                sheet: { type: 'string', desc: 'Sheet name (xlsx)', placeholder: '<name>' },
+            },
+            async run(ctx, parsed) {
+                const id = await resolveCarrier(ctx, parsed.args[0]);
+                const samplePath = optStr(parsed.options['file']);
+                if (!samplePath)
+                    throw new UsageError('--file <sample> is required');
+                const file = loadFile(samplePath);
+                const sheetName = optStr(parsed.options['sheet']);
+                return ctx.client().inferConfig(id, file, sheetName ? { sheetName } : undefined);
+            },
+        },
+    ];
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shell completion (plan §6.13) generated from the command table. Nice-to-have:
+ * completes top-level groups + subcommands.
+ */
+import type { Cmd } from '../types.js';
+export declare function completionCommands(getTable: () => Cmd[]): Cmd[];

package/dist/commands/completion.js

@@ -0,0 +1,56 @@
+import { UsageError } from '../errors.js';
+export function completionCommands(getTable) {
+    return [
+        {
+            path: ['completion'],
+            summary: 'Print a shell completion script (bash|zsh|fish)',
+            args: [{ name: 'shell', required: true }],
+            async run(ctx, parsed) {
+                const shell = parsed.args[0];
+                const commands = [...new Set(getTable().map((c) => c.path.join(' ')))].sort();
+                const words = [...new Set(getTable().flatMap((c) => c.path))].sort();
+                let script;
+                switch (shell) {
+                    case 'bash':
+                        script = bash(words);
+                        break;
+                    case 'zsh':
+                        script = zsh(commands);
+                        break;
+                    case 'fish':
+                        script = fish(commands);
+                        break;
+                    default:
+                        throw new UsageError(`unsupported shell: ${shell} (expected bash|zsh|fish)`);
+                }
+                ctx.io.stdout(script.endsWith('\n') ? script : script + '\n');
+                return undefined;
+            },
+        },
+    ];
+}
+function bash(words) {
+    return `# cs bash completion — source this file or add to ~/.bashrc
+_cs_complete() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  COMPREPLY=( $(compgen -W "${words.join(' ')} --help --json --version" -- "$cur") )
+}
+complete -F _cs_complete cs commissionsight`;
+}
+function zsh(commands) {
+    const lines = commands.map((c) => `    '${c.replace(/ /g, ':')}'`).join('\n');
+    return `#compdef cs commissionsight
+# cs zsh completion — add to a directory on your $fpath
+_cs() {
+  local -a cmds
+  cmds=(
+${lines}
+  )
+  _describe 'command' cmds
+}
+_cs "$@"`;
+}
+function fish(commands) {
+    return ('# cs fish completion — save to ~/.config/fish/completions/cs.fish\n' +
+        commands.map((c) => `complete -c cs -a '${c}'`).join('\n'));
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Context (multi-environment) commands (plan §4.4). A context bundles a base
+ * URL + optional token + default workspace/carrier. `current` selects one.
+ */
+import type { Cmd } from '../types.js';
+export declare function contextCommands(): Cmd[];

package/dist/commands/context.js

@@ -0,0 +1,73 @@
+import { loadConfig, saveConfig, upsertContext } from '../config/store.js';
+import { DEFAULT_BASE_URL, resolveExplicitToken } from '../context.js';
+import { UsageError } from '../errors.js';
+import { maskToken } from '../util.js';
+export function contextCommands() {
+    return [
+        {
+            path: ['context', 'list'],
+            summary: 'List configured contexts',
+            async run(ctx) {
+                const config = loadConfig(ctx.io);
+                return Object.entries(config.contexts).map(([name, c]) => ({
+                    current: name === config.current,
+                    name,
+                    baseUrl: c.baseUrl || DEFAULT_BASE_URL,
+                    token: maskToken(c.token),
+                    workspace: c.defaultWorkspaceName ?? c.defaultWorkspaceId ?? null,
+                }));
+            },
+        },
+        {
+            path: ['context', 'current'],
+            summary: 'Print the active context name',
+            async run(ctx) {
+                return { current: loadConfig(ctx.io).current };
+            },
+        },
+        {
+            path: ['context', 'use'],
+            summary: 'Switch the active context',
+            args: [{ name: 'name', required: true }],
+            async run(ctx, parsed) {
+                const name = parsed.args[0];
+                const config = loadConfig(ctx.io);
+                if (!config.contexts[name]) {
+                    throw new UsageError(`unknown context: ${name}`, Object.keys(config.contexts).map((n) => `cs context use ${n}`));
+                }
+                config.current = name;
+                saveConfig(ctx.io, config);
+                return { current: name };
+            },
+        },
+        {
+            path: ['context', 'add'],
+            summary: 'Add a context (--base-url, optional token via --token-stdin)',
+            args: [{ name: 'name', required: true }],
+            async run(ctx, parsed) {
+                const name = parsed.args[0];
+                const baseUrl = ctx.globals.baseUrl ?? DEFAULT_BASE_URL;
+                const token = resolveExplicitToken(ctx.globals, ctx.io);
+                upsertContext(ctx.io, name, { baseUrl, ...(token ? { token } : {}) });
+                return { name, baseUrl, token: maskToken(token) };
+            },
+        },
+        {
+            path: ['context', 'remove'],
+            summary: 'Remove a context',
+            args: [{ name: 'name', required: true }],
+            async run(ctx, parsed) {
+                const name = parsed.args[0];
+                const config = loadConfig(ctx.io);
+                if (!config.contexts[name])
+                    throw new UsageError(`unknown context: ${name}`);
+                delete config.contexts[name];
+                if (config.current === name) {
+                    config.current = Object.keys(config.contexts)[0] ?? 'default';
+                }
+                saveConfig(ctx.io, config);
+                return { removed: name, current: config.current };
+            },
+        },
+    ];
+}

package/dist/commands/file.d.ts

@@ -0,0 +1,6 @@
+/**
+ * File commands (plan §6.4). listFiles uses cursor pagination; retract/purge are
+ * destructive and gated by --yes. rescore-stale is a convenience sweep.
+ */
+import type { Cmd } from '../types.js';
+export declare function fileCommands(): Cmd[];

package/dist/commands/file.js

@@ -0,0 +1,97 @@
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { collectCursor } from '../lib/paginate.js';
+import { confirmDestructive } from '../lib/confirm.js';
+import { optStr, optBool, optNum } from '../util.js';
+export function fileCommands() {
+    cover('listFiles', 'cs file list');
+    cover('getFile', 'cs file get');
+    cover('rescoreFile', 'cs file rescore / cs file rescore-stale');
+    cover('retractFile', 'cs file retract');
+    cover('purgeFile', 'cs file purge');
+    return [
+        {
+            path: ['file', 'list'],
+            summary: 'List uploaded files (cursor-paginated)',
+            options: {
+                carrier: { type: 'string', desc: 'Filter by carrier id|slug|name', placeholder: '<c>' },
+                limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+                cursor: { type: 'string', desc: 'Start cursor', placeholder: '<n>' },
+                all: { type: 'boolean', desc: 'Auto-paginate all pages' },
+            },
+            async run(ctx, parsed) {
+                const carrierId = optStr(parsed.options['carrier'])
+                    ? await resolveCarrier(ctx, optStr(parsed.options['carrier']))
+                    : undefined;
+                const limit = optNum(parsed.options['limit']);
+                if (optBool(parsed.options['all'])) {
+                    const { items, truncated } = await collectCursor((p) => ctx.client().listFiles({ ...(carrierId ? { carrierId } : {}), ...p }), limit !== undefined ? { limit } : {});
+                    if (truncated)
+                        ctx.log('warning: page cap reached; results truncated');
+                    return items;
+                }
+                const page = await ctx.client().listFiles({
+                    ...(carrierId ? { carrierId } : {}),
+                    ...(limit !== undefined ? { limit } : {}),
+                    ...(optNum(parsed.options['cursor']) !== undefined ? { cursor: optNum(parsed.options['cursor']) } : {}),
+                });
+                return page.data;
+            },
+        },
+        {
+            path: ['file', 'get'],
+            summary: 'Get a file by id',
+            args: [{ name: 'fileId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getFile(parsed.args[0]);
+            },
+        },
+        {
+            path: ['file', 'rescore'],
+            summary: 'Re-score a file’s period without re-uploading',
+            args: [{ name: 'fileId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().rescoreFile(parsed.args[0]);
+            },
+        },
+        {
+            path: ['file', 'retract'],
+            summary: 'Retract (unapply) a file’s carrier+period (destructive)',
+            args: [{ name: 'fileId', required: true }],
+            async run(ctx, parsed) {
+                await confirmDestructive(ctx, `retract file ${parsed.args[0]}`);
+                return ctx.client().retractFile(parsed.args[0]);
+            },
+        },
+        {
+            path: ['file', 'purge'],
+            summary: 'Purge a file’s raw bytes from storage (destructive)',
+            args: [{ name: 'fileId', required: true }],
+            async run(ctx, parsed) {
+                await confirmDestructive(ctx, `purge file ${parsed.args[0]}`);
+                return ctx.client().purgeFile(parsed.args[0]);
+            },
+        },
+        {
+            path: ['file', 'rescore-stale'],
+            summary: 'Rescore every file flagged rescoreSuggested',
+            options: {
+                carrier: { type: 'string', desc: 'Limit to a carrier', placeholder: '<c>' },
+            },
+            async run(ctx, parsed) {
+                const carrierId = optStr(parsed.options['carrier'])
+                    ? await resolveCarrier(ctx, optStr(parsed.options['carrier']))
+                    : undefined;
+                const { items } = await collectCursor((p) => ctx.client().listFiles({ ...(carrierId ? { carrierId } : {}), ...p }));
+                const stale = items.filter((f) => f.rescoreSuggested);
+                const rescored = [];
+                for (const f of stale) {
+                    const res = await ctx.client().rescoreFile(f.id);
+                    rescored.push({ fileId: f.id, jobId: res.jobId });
+                    ctx.log(`  rescored ${f.id} → job ${res.jobId}`);
+                }
+                return { staleCount: stale.length, rescored };
+            },
+        },
+    ];
+}

package/dist/commands/job.d.ts

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

package/dist/commands/job.js

@@ -0,0 +1,186 @@
+/**
+ * Job commands (plan §6.5): list/get/wait/results/deltas/exceptions/retry.
+ */
+import { writeFileSync } from 'node:fs';
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { parsePeriod } from '../lib/period.js';
+import { waitForJob } from '../lib/poll.js';
+import { collectOffset } from '../lib/paginate.js';
+import { emitCSV, RESULT_ROW_COLUMNS } from '../output/csv.js';
+import { ApiError, CliError, EXIT } from '../errors.js';
+import { optStr, optBool, optNum } from '../util.js';
+export function jobCommands() {
+    cover('listJobs', 'cs job list');
+    cover('getJob', 'cs job get / cs job wait');
+    cover('getJobDeltas', 'cs job deltas');
+    cover('downloadExceptions', 'cs job exceptions');
+    cover('retryJob', 'cs job retry');
+    return [
+        {
+            path: ['job', 'list'],
+            summary: 'List jobs (filter by status/carrier/period)',
+            options: {
+                status: { type: 'string', desc: 'Filter by status', placeholder: '<s>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                period: { type: 'string', desc: 'Filter by period YYYY-MM', placeholder: '<YYYY-MM>' },
+                limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+                offset: { type: 'string', desc: 'Offset', placeholder: '<n>' },
+                all: { type: 'boolean', desc: 'Auto-paginate all pages' },
+            },
+            async run(ctx, parsed) {
+                const params = await jobListParams(ctx, parsed);
+                if (optBool(parsed.options['all'])) {
+                    const { items } = await collectOffset((p) => ctx.client().listJobs({ ...params, ...p }));
+                    return items;
+                }
+                const page = await ctx.client().listJobs({
+                    ...params,
+                    ...(optNum(parsed.options['limit']) !== undefined ? { limit: optNum(parsed.options['limit']) } : {}),
+                    ...(optNum(parsed.options['offset']) !== undefined ? { offset: optNum(parsed.options['offset']) } : {}),
+                });
+                return page.data;
+            },
+        },
+        {
+            path: ['job', 'get'],
+            summary: 'Get a job by id',
+            args: [{ name: 'jobId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getJob(parsed.args[0]);
+            },
+        },
+        {
+            path: ['job', 'wait'],
+            summary: 'Poll a job to completed/failed (124 on timeout, 1 on failed)',
+            args: [{ name: 'jobId', required: true }],
+            options: {
+                timeout: { type: 'string', desc: 'Timeout seconds (default 300)', placeholder: '<s>' },
+                interval: { type: 'string', desc: 'Poll interval seconds (default 2)', placeholder: '<s>' },
+            },
+            async run(ctx, parsed) {
+                const job = await waitForJob(ctx.client(), parsed.args[0], {
+                    timeoutMs: (optNum(parsed.options['timeout']) ?? 300) * 1000,
+                    intervalMs: (optNum(parsed.options['interval']) ?? 2) * 1000,
+                    onTick: (j) => ctx.log(`  ${parsed.args[0]}: ${j.status}`),
+                });
+                if (job.status === 'failed') {
+                    throw new CliError(`job failed: ${job.error ?? 'unknown error'}`, EXIT.ERROR);
+                }
+                return job;
+            },
+        },
+        {
+            path: ['job', 'results'],
+            summary: 'Scored rows for a job',
+            args: [{ name: 'jobId', required: true }],
+            options: {
+                status: { type: 'string', desc: 'Filter by status', choices: ['green', 'yellow', 'red'], placeholder: '<s>' },
+                'owed-only': { type: 'boolean', desc: 'Only rows with commission owed' },
+                chargeback: { type: 'boolean', desc: 'Only chargeback rows' },
+                limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+                offset: { type: 'string', desc: 'Offset', placeholder: '<n>' },
+                all: { type: 'boolean', desc: 'Auto-paginate all pages' },
+                csv: { type: 'boolean', desc: 'Emit CSV' },
+                output: { type: 'string', short: 'o', desc: 'Write CSV to a file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const jobId = parsed.args[0];
+                const o = parsed.options;
+                const filters = {
+                    ...(optStr(o['status']) ? { status: optStr(o['status']) } : {}),
+                    ...(optBool(o['owed-only']) ? { owedOnly: true } : {}),
+                    ...(optBool(o['chargeback']) ? { chargeback: true } : {}),
+                };
+                let rows;
+                if (optBool(o['all'])) {
+                    const { items } = await collectOffset((p) => ctx.client().getJobResults(jobId, { ...filters, ...p }));
+                    rows = items;
+                }
+                else {
+                    const page = await ctx.client().getJobResults(jobId, {
+                        ...filters,
+                        ...(optNum(o['limit']) !== undefined ? { limit: optNum(o['limit']) } : {}),
+                        ...(optNum(o['offset']) !== undefined ? { offset: optNum(o['offset']) } : {}),
+                    });
+                    rows = page.data;
+                }
+                if (optBool(o['csv']) && !ctx.globals.json) {
+                    return emitCSV(ctx.io, rows, RESULT_ROW_COLUMNS, optStr(o['output']), (p, d) => writeFileSync(p, d));
+                }
+                return rows;
+            },
+        },
+        {
+            path: ['job', 'deltas'],
+            summary: 'Field-level deltas for a job',
+            args: [{ name: 'jobId', required: true }],
+            options: {
+                member: { type: 'string', desc: 'Filter by member ref id', placeholder: '<id>' },
+                'change-type': { type: 'string', desc: 'Filter by change type', placeholder: '<t>' },
+                all: { type: 'boolean', desc: '(accepted; endpoint returns a single page)' },
+            },
+            async run(ctx, parsed) {
+                const page = await ctx.client().getJobDeltas(parsed.args[0], {
+                    ...(optStr(parsed.options['member']) ? { memberRefId: optStr(parsed.options['member']) } : {}),
+                    ...(optStr(parsed.options['change-type']) ? { changeType: optStr(parsed.options['change-type']) } : {}),
+                });
+                return page.data;
+            },
+        },
+        {
+            path: ['job', 'exceptions'],
+            summary: 'Download a job’s rejected-rows CSV (or 404 if purged/none)',
+            args: [{ name: 'jobId', required: true }],
+            options: {
+                output: { type: 'string', short: 'o', desc: 'Write CSV to a file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const jobId = parsed.args[0];
+                let csv;
+                try {
+                    csv = await ctx.client().downloadExceptions(jobId);
+                }
+                catch (e) {
+                    if (e instanceof ApiError && e.status === 404) {
+                        throw new CliError(`no exception file for job ${jobId} (purged or none)`, EXIT.NOTFOUND);
+                    }
+                    throw e;
+                }
+                const out = optStr(parsed.options['output']);
+                if (ctx.globals.json)
+                    return { jobId, csv };
+                if (out) {
+                    writeFileSync(out, csv);
+                    return { jobId, out, bytes: csv.length };
+                }
+                ctx.io.stdout(csv.endsWith('\n') ? csv : csv + '\n');
+                return undefined;
+            },
+        },
+        {
+            path: ['job', 'retry'],
+            summary: 'Retry a job',
+            args: [{ name: 'jobId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().retryJob(parsed.args[0]);
+            },
+        },
+    ];
+}
+async function jobListParams(ctx, parsed) {
+    const params = {};
+    const status = optStr(parsed.options['status']);
+    if (status)
+        params.status = status;
+    const carrier = optStr(parsed.options['carrier']);
+    if (carrier)
+        params.carrierId = await resolveCarrier(ctx, carrier);
+    const period = optStr(parsed.options['period']);
+    if (period) {
+        const p = parsePeriod(period);
+        params.periodYear = p.periodYear;
+        params.periodMonth = p.periodMonth;
+    }
+    return params;
+}

package/dist/commands/member.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Member & policy commands (plan §6.6).
+ */
+import type { Cmd } from '../types.js';
+export declare function memberCommands(): Cmd[];