@commissionsight/cli 0.1.0

package/dist/globals.js

@@ -0,0 +1,38 @@
+export const GLOBAL_OPTIONS = {
+    json: { type: 'boolean', desc: 'Emit only the JSON envelope on stdout (also CS_OUTPUT=json)' },
+    quiet: { type: 'boolean', short: 'q', desc: 'Suppress human chrome (spinners, headers)' },
+    'no-color': { type: 'boolean', desc: 'Disable ANSI color (also NO_COLOR)' },
+    yes: { type: 'boolean', short: 'y', desc: 'Assume "yes" for destructive confirmations' },
+    token: { type: 'string', desc: 'API bearer token (discouraged on a TTY)', placeholder: '<t>' },
+    'token-file': { type: 'string', desc: 'Read API token from a file', placeholder: '<path>' },
+    'token-stdin': { type: 'boolean', desc: 'Read API token from stdin' },
+    'base-url': { type: 'string', desc: 'Override API base URL', placeholder: '<url>' },
+    context: { type: 'string', desc: 'Use a named configuration context', placeholder: '<name>' },
+    help: { type: 'boolean', short: 'h', desc: 'Show help' },
+    version: { type: 'boolean', short: 'V', desc: 'Show version' },
+};
+/** Keys that are global control flags, not passed down to commands as data. */
+export const GLOBAL_KEYS = new Set(Object.keys(GLOBAL_OPTIONS));
+export function resolveGlobals(values, io) {
+    const json = Boolean(values['json']) || io.env['CS_OUTPUT'] === 'json';
+    const noColor = Boolean(values['no-color']) || io.env['NO_COLOR'] !== undefined && io.env['NO_COLOR'] !== '';
+    const color = io.isTTY && !noColor && !json;
+    return {
+        json,
+        quiet: Boolean(values['quiet']),
+        color,
+        yes: Boolean(values['yes']),
+        token: str(values['token']),
+        tokenFile: str(values['token-file']),
+        tokenStdin: Boolean(values['token-stdin']),
+        baseUrl: str(values['base-url']),
+        context: str(values['context']),
+    };
+}
+function str(v) {
+    if (typeof v === 'string')
+        return v;
+    if (Array.isArray(v))
+        return v[v.length - 1];
+    return undefined;
+}

package/dist/io.d.ts

@@ -0,0 +1,28 @@
+/**
+ * IO abstraction so the whole CLI is testable without touching real stdout/
+ * stderr/env/filesystem. Tests inject capturing writers and a mock fetch.
+ */
+export interface IO {
+    stdout(s: string): void;
+    stderr(s: string): void;
+    env: Record<string, string | undefined>;
+    cwd: string;
+    /** Injectable fetch threaded into the SDK client (mock-fetch in tests). */
+    fetch?: typeof fetch;
+    /** Whether stdout is an interactive TTY (drives color + prompts). */
+    isTTY: boolean;
+    /** Override config file path (tests point this at a temp dir). */
+    configPath?: string;
+}
+/** Build the default IO bound to the real process. */
+export declare function defaultIO(): IO;
+/** Build an IO that captures stdout/stderr into strings, for tests. */
+export interface CaptureIO extends IO {
+    out: {
+        value: string;
+    };
+    err: {
+        value: string;
+    };
+}
+export declare function captureIO(overrides?: Partial<IO>): CaptureIO;

package/dist/io.js

@@ -0,0 +1,28 @@
+/** Build the default IO bound to the real process. */
+export function defaultIO() {
+    return {
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s),
+        env: process.env,
+        cwd: process.cwd(),
+        isTTY: Boolean(process.stdout.isTTY),
+    };
+}
+export function captureIO(overrides = {}) {
+    const out = { value: '' };
+    const err = { value: '' };
+    return {
+        stdout: (s) => {
+            out.value += s;
+        },
+        stderr: (s) => {
+            err.value += s;
+        },
+        env: {},
+        cwd: process.cwd(),
+        isTTY: false,
+        out,
+        err,
+        ...overrides,
+    };
+}

package/dist/lib/batch.d.ts

@@ -0,0 +1,52 @@
+import type { RunCtx } from '../types.js';
+export interface BatchTask {
+    file: string;
+    carrier: string;
+    period: string;
+    workspace?: string;
+    replace?: boolean;
+}
+export interface BatchOutcome {
+    file: string;
+    carrier: string;
+    period: string;
+    jobId?: string;
+    fileId?: string;
+    mode?: string;
+    status: 'uploaded' | 'replaced' | 'skipped' | 'failed' | 'planned' | 'unmatched';
+    jobStatus?: string;
+    error?: string;
+}
+export interface BatchSummary {
+    total: number;
+    uploaded: number;
+    replaced: number;
+    skipped: number;
+    failed: number;
+    planned: number;
+    unmatched: number;
+    outcomes: BatchOutcome[];
+}
+export interface BatchOptions {
+    target: string;
+    manifest?: string;
+    pattern?: string;
+    concurrency?: number;
+    workspace?: string;
+    replace?: boolean;
+    wait?: boolean;
+    dryRun?: boolean;
+    continueOnError?: boolean;
+    strict?: boolean;
+    timeoutMs?: number;
+    intervalMs?: number;
+}
+export declare function buildTasks(opts: BatchOptions): {
+    tasks: BatchTask[];
+    unmatched: string[];
+};
+/** Tiny RFC-4180-ish CSV reader (handles quotes + embedded commas/newlines). */
+export declare function parseCsv(text: string): Record<string, unknown>[];
+/** Bounded worker pool preserving input order in the results array. */
+export declare function runPool<T, R>(items: T[], concurrency: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export declare function runBatch(ctx: RunCtx, opts: BatchOptions): Promise<BatchSummary>;

package/dist/lib/confirm.d.ts

@@ -0,0 +1,2 @@
+import type { RunCtx } from '../types.js';
+export declare function confirmDestructive(ctx: RunCtx, action: string): Promise<void>;

package/dist/lib/confirm.js

@@ -0,0 +1,23 @@
+/**
+ * Destructive-op gate (plan §5): require --yes in non-interactive contexts;
+ * prompt on a TTY. Commands call this before retract/purge/remove/delete.
+ */
+import { createInterface } from 'node:readline/promises';
+import { UsageError, CliError, EXIT } from '../errors.js';
+export async function confirmDestructive(ctx, action) {
+    if (ctx.globals.yes)
+        return;
+    if (!ctx.io.isTTY) {
+        throw new UsageError(`refusing to ${action} without confirmation; re-run with --yes/-y`);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = (await rl.question(`About to ${action}. Continue? [y/N] `)).trim().toLowerCase();
+        if (answer !== 'y' && answer !== 'yes') {
+            throw new CliError('aborted by user', EXIT.ERROR);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/lib/file.d.ts

@@ -0,0 +1,6 @@
+export declare function sniffMime(path: string): string;
+/** Read a file from disk into a `File` with its basename + sniffed mime. */
+export declare function loadFile(path: string): File;
+/** First 8 hex chars of the SHA-256 of a file's contents (idempotency keys). */
+export declare function sha8(path: string): string;
+export declare function sha8OfBuffer(buf: Uint8Array): string;

package/dist/lib/file.js

@@ -0,0 +1,43 @@
+/**
+ * File loading (plan §9.3). The server derives `originalFilename` from the
+ * multipart part name, so the CLI must wrap bytes in a `File` carrying the
+ * basename — never a bare Blob. Also: mime sniffing + short content hash for
+ * idempotency keys.
+ */
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { CliError, UsageError, EXIT } from '../errors.js';
+const MIME = {
+    '.csv': 'text/csv',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.xls': 'application/vnd.ms-excel',
+};
+export function sniffMime(path) {
+    const ext = extname(path).toLowerCase();
+    const mime = MIME[ext];
+    if (!mime) {
+        throw new UsageError(`unsupported file type: ${ext || '(none)'} (expected .csv or .xlsx) for ${basename(path)}`);
+    }
+    return mime;
+}
+/** Read a file from disk into a `File` with its basename + sniffed mime. */
+export function loadFile(path) {
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        throw new CliError(`file not found: ${path}`, EXIT.NOTFOUND);
+    }
+    const type = sniffMime(path);
+    const buf = readFileSync(path);
+    // Wrap in a Uint8Array view so the global File constructor accepts it.
+    return new File([new Uint8Array(buf)], basename(path), { type });
+}
+/** First 8 hex chars of the SHA-256 of a file's contents (idempotency keys). */
+export function sha8(path) {
+    if (!existsSync(path))
+        throw new CliError(`file not found: ${path}`, EXIT.NOTFOUND);
+    const hash = createHash('sha256').update(readFileSync(path)).digest('hex');
+    return hash.slice(0, 8);
+}
+export function sha8OfBuffer(buf) {
+    return createHash('sha256').update(buf).digest('hex').slice(0, 8);
+}

package/dist/lib/input.d.ts

@@ -0,0 +1,2 @@
+/** Read JSON from a path, or stdin (fd 0) when no path is given. */
+export declare function readJsonInput(path: string | undefined): unknown;

package/dist/lib/input.js

@@ -0,0 +1,35 @@
+/**
+ * Read structured input from a file (`-f`) or stdin. Used by config create/test
+ * which take a JSON config document.
+ */
+import { readFileSync } from 'node:fs';
+import { CliError, UsageError, EXIT } from '../errors.js';
+/** Read JSON from a path, or stdin (fd 0) when no path is given. */
+export function readJsonInput(path) {
+    let text;
+    if (path) {
+        try {
+            text = readFileSync(path, 'utf8');
+        }
+        catch {
+            throw new CliError(`could not read file: ${path}`, EXIT.NOTFOUND);
+        }
+    }
+    else {
+        try {
+            text = readFileSync(0, 'utf8');
+        }
+        catch {
+            throw new UsageError('provide a config via -f <file.json> or pipe JSON on stdin');
+        }
+    }
+    if (!text.trim()) {
+        throw new UsageError('empty config input (expected JSON)');
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        throw new UsageError(`invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}

package/dist/lib/paginate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Auto-pagination helpers (plan §9.5) powering `--all`. Offset endpoints follow
+ * `pagination.hasMore`; cursor endpoints (listFiles) follow `nextCursor`. Both
+ * cap total pages to avoid runaway loops and report truncation to the caller.
+ */
+export interface PageLike<T> {
+    data: T[];
+    pagination?: {
+        limit?: number;
+        offset?: number;
+        nextCursor?: number | null;
+        hasMore?: boolean;
+    };
+}
+export interface CollectResult<T> {
+    items: T[];
+    pages: number;
+    truncated: boolean;
+}
+export declare function collectOffset<T>(fn: (params: {
+    limit: number;
+    offset: number;
+}) => Promise<PageLike<T>>, opts?: {
+    limit?: number;
+    maxPages?: number;
+}): Promise<CollectResult<T>>;
+export declare function collectCursor<T>(fn: (params: {
+    limit: number;
+    cursor?: number;
+}) => Promise<PageLike<T>>, opts?: {
+    limit?: number;
+    maxPages?: number;
+}): Promise<CollectResult<T>>;

package/dist/lib/paginate.js

@@ -0,0 +1,47 @@
+const DEFAULT_LIMIT = 100;
+const DEFAULT_MAX_PAGES = 1000;
+export async function collectOffset(fn, opts = {}) {
+    const limit = opts.limit ?? DEFAULT_LIMIT;
+    const maxPages = opts.maxPages ?? DEFAULT_MAX_PAGES;
+    const items = [];
+    let offset = 0;
+    let pages = 0;
+    let truncated = false;
+    for (;;) {
+        const page = await fn({ limit, offset });
+        items.push(...page.data);
+        pages++;
+        const hasMore = page.pagination?.hasMore ?? false;
+        if (!hasMore || page.data.length === 0)
+            break;
+        if (pages >= maxPages) {
+            truncated = true;
+            break;
+        }
+        offset += limit;
+    }
+    return { items, pages, truncated };
+}
+export async function collectCursor(fn, opts = {}) {
+    const limit = opts.limit ?? DEFAULT_LIMIT;
+    const maxPages = opts.maxPages ?? DEFAULT_MAX_PAGES;
+    const items = [];
+    let cursor;
+    let pages = 0;
+    let truncated = false;
+    for (;;) {
+        const page = await fn(cursor !== undefined ? { limit, cursor } : { limit });
+        items.push(...page.data);
+        pages++;
+        const next = page.pagination?.nextCursor;
+        const hasMore = page.pagination?.hasMore ?? next != null;
+        if (!hasMore || next == null)
+            break;
+        if (pages >= maxPages) {
+            truncated = true;
+            break;
+        }
+        cursor = next;
+    }
+    return { items, pages, truncated };
+}

package/dist/lib/period.d.ts

@@ -0,0 +1,15 @@
+export interface Period {
+    periodYear: number;
+    periodMonth: number;
+}
+export declare function parsePeriod(input: string): Period;
+export declare function validatePeriod(year: number, month: number, raw?: string): Period;
+/** Resolve a period from either --period or --year/--month. */
+export declare function periodFromOptions(opts: {
+    period?: string;
+    year?: number;
+    month?: number;
+}): Period;
+export declare function formatPeriod(year: number, month: number): string;
+/** Infer a "YYYY-MM" period from a filename, or undefined if none is present. */
+export declare function inferPeriodFromFilename(name: string): string | undefined;

package/dist/lib/period.js

@@ -0,0 +1,43 @@
+/**
+ * Period parsing/formatting (plan §9.2). The API splits periods into
+ * `periodYear` + `periodMonth`; the CLI accepts `--period YYYY-MM` or the
+ * `--year`/`--month` pair.
+ */
+import { UsageError } from '../errors.js';
+export function parsePeriod(input) {
+    const m = /^(\d{4})-(\d{1,2})$/.exec(input.trim());
+    if (!m)
+        throw new UsageError(`invalid --period: "${input}" (expected YYYY-MM, e.g. 2026-05)`);
+    return validatePeriod(Number(m[1]), Number(m[2]), input);
+}
+export function validatePeriod(year, month, raw) {
+    if (!Number.isInteger(month) || month < 1 || month > 12) {
+        throw new UsageError(`invalid period month: ${month} (expected 1–12)`);
+    }
+    if (!Number.isInteger(year) || year < 2000 || year > 2100) {
+        throw new UsageError(`invalid period year: ${year}${raw ? ` (from "${raw}")` : ''}`);
+    }
+    return { periodYear: year, periodMonth: month };
+}
+/** Resolve a period from either --period or --year/--month. */
+export function periodFromOptions(opts) {
+    if (opts.period)
+        return parsePeriod(opts.period);
+    if (opts.year !== undefined && opts.month !== undefined) {
+        return validatePeriod(opts.year, opts.month);
+    }
+    throw new UsageError('a period is required: pass --period YYYY-MM (or --year and --month)');
+}
+export function formatPeriod(year, month) {
+    return `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}`;
+}
+/** Infer a "YYYY-MM" period from a filename, or undefined if none is present. */
+export function inferPeriodFromFilename(name) {
+    const m = /(\d{4})-(\d{2})/.exec(name);
+    if (!m)
+        return undefined;
+    const month = Number(m[2]);
+    if (month < 1 || month > 12)
+        return undefined;
+    return `${m[1]}-${m[2]}`;
+}

package/dist/lib/poll.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Job poller (plan §9.4). Polls getJob until a terminal state, surfacing each
+ * tick to stderr. Throws TimeoutError (→ exit 124) past the deadline. `now`
+ * and `sleep` are injectable so tests run without real time.
+ */
+import type { CommissionSightClient, JobSummary } from '@commissionsight/sdk';
+export interface WaitOptions {
+    timeoutMs: number;
+    intervalMs: number;
+    onTick?: (job: JobSummary) => void;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function waitForJob(client: CommissionSightClient, jobId: string, opts: WaitOptions): Promise<JobSummary>;

package/dist/lib/poll.js

@@ -0,0 +1,17 @@
+import { TimeoutError } from '../errors.js';
+const TERMINAL = new Set(['completed', 'failed']);
+export async function waitForJob(client, jobId, opts) {
+    const now = opts.now ?? (() => Date.now());
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const start = now();
+    for (;;) {
+        const job = await client.getJob(jobId);
+        opts.onTick?.(job);
+        if (TERMINAL.has(job.status))
+            return job;
+        if (now() - start >= opts.timeoutMs) {
+            throw new TimeoutError(`timed out after ${Math.round(opts.timeoutMs / 1000)}s waiting for job ${jobId} (last status: ${job.status})`);
+        }
+        await sleep(opts.intervalMs);
+    }
+}

package/dist/lib/resolve.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reference resolvers (plan §9.1). Carrier: id|slug|name → id. Workspace:
+ * id|name → id, with the "workspace required when enabled" rule. Both cache
+ * their list on the RunCtx so a batch resolves once.
+ */
+import type { RunCtx } from '../types.js';
+interface Carrier {
+    id: string;
+    name: string;
+    slug: string;
+}
+interface WorkspaceList {
+    enabled: boolean;
+    workspaces: {
+        id: string;
+        name: string;
+        isDefault: boolean;
+    }[];
+}
+export declare function resolveCarrierEntry(ctx: RunCtx, ref: string): Promise<Carrier>;
+export declare function resolveCarrier(ctx: RunCtx, ref: string): Promise<string>;
+/**
+ * Resolve a workspace id (or undefined for single-workspace accounts).
+ * When the account has multi-workspace enabled and no ref/default is set, this
+ * fails with exit 6 and actionable guidance.
+ */
+export declare function resolveWorkspace(ctx: RunCtx, ref?: string): Promise<string | undefined>;
+/** Expose the cached workspace metadata (used by `workspace list/use`). */
+export declare function getWorkspaces(ctx: RunCtx): Promise<WorkspaceList>;
+export {};

package/dist/lib/resolve.js

@@ -0,0 +1,81 @@
+import { UsageError, CliError, EXIT } from '../errors.js';
+import { activeContext } from '../config/store.js';
+async function carriersCached(ctx) {
+    const hit = ctx.cache.get('carriers');
+    if (hit)
+        return hit;
+    const page = await ctx.client().listCarriers();
+    const list = page.data;
+    ctx.cache.set('carriers', list);
+    return list;
+}
+async function workspacesCached(ctx) {
+    const hit = ctx.cache.get('workspaces');
+    if (hit)
+        return hit;
+    const ws = await ctx.client().listWorkspaces();
+    ctx.cache.set('workspaces', ws);
+    return ws;
+}
+/** Looks like an opaque server id rather than a slug/name. */
+function looksLikeId(ref) {
+    return /_/.test(ref) && /^[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9]{6,}$/.test(ref);
+}
+export async function resolveCarrierEntry(ctx, ref) {
+    const carriers = await carriersCached(ctx);
+    const byId = carriers.find((c) => c.id === ref);
+    if (byId)
+        return byId;
+    const lower = ref.toLowerCase();
+    const bySlug = carriers.filter((c) => c.slug.toLowerCase() === lower);
+    if (bySlug.length === 1)
+        return bySlug[0];
+    if (bySlug.length > 1) {
+        throw new UsageError(`ambiguous carrier slug "${ref}"`, bySlug.map((c) => `${c.name} (${c.slug}) → ${c.id}`));
+    }
+    const byName = carriers.filter((c) => c.name.toLowerCase() === lower);
+    if (byName.length === 1)
+        return byName[0];
+    if (byName.length > 1) {
+        throw new UsageError(`ambiguous carrier name "${ref}"`, byName.map((c) => `${c.name} (${c.slug}) → ${c.id}`));
+    }
+    // Unknown but id-shaped → pass through and let the API validate.
+    if (looksLikeId(ref))
+        return { id: ref, name: ref, slug: ref };
+    throw new CliError(`carrier not found: ${ref} (known: ${carriers.map((c) => c.slug).join(', ') || 'none'})`, EXIT.NOTFOUND);
+}
+export async function resolveCarrier(ctx, ref) {
+    return (await resolveCarrierEntry(ctx, ref)).id;
+}
+/**
+ * Resolve a workspace id (or undefined for single-workspace accounts).
+ * When the account has multi-workspace enabled and no ref/default is set, this
+ * fails with exit 6 and actionable guidance.
+ */
+export async function resolveWorkspace(ctx, ref) {
+    const ws = await workspacesCached(ctx);
+    if (ref) {
+        const byId = ws.workspaces.find((w) => w.id === ref);
+        if (byId)
+            return byId.id;
+        const lower = ref.toLowerCase();
+        const byName = ws.workspaces.filter((w) => w.name.toLowerCase() === lower);
+        if (byName.length === 1)
+            return byName[0].id;
+        if (byName.length > 1) {
+            throw new UsageError(`ambiguous workspace name "${ref}"`, byName.map((w) => `${w.name} → ${w.id}`));
+        }
+        throw new CliError(`workspace not found: ${ref}`, EXIT.NOTFOUND);
+    }
+    if (!ws.enabled)
+        return undefined; // single-workspace account — nothing to target
+    // Multi-workspace enabled: fall back to the context default.
+    const def = activeContext(ctx.io, ctx.globals.context).context?.defaultWorkspaceId;
+    if (def)
+        return def;
+    throw new CliError('workspace required (this account has multiple workspaces). Set one with `cs workspace use <name|id>` or pass --workspace', EXIT.VALIDATION);
+}
+/** Expose the cached workspace metadata (used by `workspace list/use`). */
+export async function getWorkspaces(ctx) {
+    return workspacesCached(ctx);
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: string[]): Promise<void>;

package/dist/main.js

@@ -0,0 +1,17 @@
+/**
+ * Process entrypoint. `bin/cs.mjs` imports `run` and passes argv. This is the
+ * only place that calls process.exit; commands and the router never do.
+ */
+import { run as routerRun } from './router.js';
+export async function run(argv) {
+    let code;
+    try {
+        code = await routerRun(argv);
+    }
+    catch (err) {
+        // Last-resort guard; the router normally handles all errors.
+        process.stderr.write(`fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+        code = 1;
+    }
+    process.exit(code);
+}

package/dist/output/color.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Zero-dependency ANSI coloring. Color is enabled only when stdout is a TTY,
+ * NO_COLOR is unset, and --no-color was not passed (decided in the router and
+ * passed in as `enabled`).
+ */
+declare const CODES: {
+    readonly reset: 0;
+    readonly bold: 1;
+    readonly dim: 2;
+    readonly red: 31;
+    readonly green: 32;
+    readonly yellow: 33;
+    readonly blue: 34;
+    readonly magenta: 35;
+    readonly cyan: 36;
+    readonly gray: 90;
+};
+export type ColorName = keyof typeof CODES;
+export interface Painter {
+    (name: ColorName, s: string): string;
+    enabled: boolean;
+}
+export declare function makePainter(enabled: boolean): Painter;
+/** Map a domain status word to a color. */
+export declare function statusColor(status: string): ColorName;
+export {};

package/dist/output/color.js

@@ -0,0 +1,37 @@
+/**
+ * Zero-dependency ANSI coloring. Color is enabled only when stdout is a TTY,
+ * NO_COLOR is unset, and --no-color was not passed (decided in the router and
+ * passed in as `enabled`).
+ */
+const CODES = {
+    reset: 0,
+    bold: 1,
+    dim: 2,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    gray: 90,
+};
+export function makePainter(enabled) {
+    const paint = ((name, s) => {
+        if (!enabled)
+            return s;
+        return `[${CODES[name]}m${s}`;
+    });
+    paint.enabled = enabled;
+    return paint;
+}
+/** Map a domain status word to a color. */
+export function statusColor(status) {
+    const s = status.toLowerCase();
+    if (['green', 'completed', 'ok', 'active', 'success'].includes(s))
+        return 'green';
+    if (['yellow', 'watch', 'processing', 'queued', 'pending'].includes(s))
+        return 'yellow';
+    if (['red', 'alert', 'failed', 'suspended', 'error'].includes(s))
+        return 'red';
+    return 'gray';
+}