@burdenoff/bigconsole-cli 2026.1029.1 → 2026.1110.1

package/dist/utils/output.js

@@ -1,237 +0,0 @@
-/**
- * Output utilities for CLI display.
- * Provides consistent formatting for both interactive and non-interactive modes.
- *
- * stdout carries only command data (JSON, YAML, tables); status lines
- * (success, info, warning, error) go to stderr so piping stays clean. Remote
- * strings are made inert before they reach the terminal: tables and status
- * lines pass through `sanitizeForTerminal`, while JSON and YAML stay exact
- * data and only use escape forms their own syntax defines.
- */
-import { DEFAULT_SCALAR_STYLE_RULES, JSON_SCHEMA, SCALAR_STYLE, dump, strTag, } from 'js-yaml';
-import { escapeBidiControls, redactSecrets, sanitizeForTerminal, toUnicodeEscape, } from './sanitize.js';
-/** Widest a table column is padded to; longer cells extend past it. */
-const MAX_COLUMN_WIDTH = 50;
-/**
- * Check if the current terminal session is interactive (TTY).
- */
-export function isInteractive() {
-    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
-}
-/**
- * Determine the output format from command options, defaulting based on TTY.
- */
-export function getFormat(options) {
-    if (options.format) {
-        const f = options.format.toLowerCase();
-        if (f === 'json' || f === 'table' || f === 'yaml')
-            return f;
-        if (f === 'yml')
-            return 'yaml';
-    }
-    return isInteractive() ? 'table' : 'json';
-}
-/**
- * Characters that are valid raw inside JSON strings but act on, or are
- * invisible in, a terminal: DEL, C1 controls, line/paragraph separators and
- * bidirectional formatting controls.
- */
-const JSON_DISPLAY_ESCAPES = /[\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
-/**
- * Serialize data as pretty-printed JSON. Characters in
- * {@link JSON_DISPLAY_ESCAPES} can only occur inside JSON strings, so writing
- * them as `\uXXXX` escapes leaves the parsed value unchanged.
- */
-export function toJson(data) {
-    const json = JSON.stringify(data, null, 2) ?? 'null';
-    return json.replace(JSON_DISPLAY_ESCAPES, toUnicodeEscape);
-}
-/**
- * Print data as formatted JSON.
- */
-export function printJson(data) {
-    console.log(toJson(data));
-}
-/**
- * Print data as a simple ASCII table. Headers and cells are sanitized for the
- * terminal (single line, no control sequences) before widths are measured;
- * columns are padded to at most {@link MAX_COLUMN_WIDTH} characters.
- */
-export function printTable(headers, rows) {
-    if (headers.length === 0)
-        return;
-    const header = headers.map((h) => sanitizeForTerminal(h));
-    const body = rows.map((row) => headers.map((_, i) => sanitizeForTerminal(row[i])));
-    const colWidths = header.map((h, i) => Math.min(body.reduce((max, row) => Math.max(max, (row[i] ?? '').length), h.length), MAX_COLUMN_WIDTH));
-    const separator = colWidths.map((w) => '-'.repeat(w + 2)).join('+');
-    const formatRow = (cells) => cells.map((cell, i) => ` ${cell.padEnd(colWidths[i] ?? 0)} `).join('|');
-    console.log(formatRow(header));
-    console.log(separator);
-    for (const row of body) {
-        console.log(formatRow(row));
-    }
-}
-function allowsStyle(mask, style) {
-    return (mask & (1 << style)) !== 0;
-}
-/** Bidirectional formatting controls (see `escapeBidiControls`). */
-const BIDI_CONTROL = /[\u202a-\u202e\u2066-\u2069]/;
-/**
- * Strings that read back as the same string under the YAML 1.2 JSON and core
- * schemas and under YAML 1.1: a letter first, then only letters, digits,
- * spaces and `_ . / @ + -`, and not one of the words those schemas map to
- * booleans or null.
- */
-const UNAMBIGUOUS_PLAIN = /^\p{L}[\p{L}\p{N} _./@+-]*$/u;
-const NON_STRING_WORDS = /^(?:y|n|yes|no|on|off|true|false|null)$/i;
-/**
- * Double-quote any scalar containing a bidirectional formatting control.
- * Double-quoted YAML supports `\uXXXX` escapes, so `toYaml` can then write
- * those characters visibly without changing the parsed value.
- */
-const doubleQuoteBidiControls = (layout) => {
-    if (BIDI_CONTROL.test(layout.node.value))
-        layout.style = SCALAR_STYLE.DOUBLE_QUOTED;
-};
-/**
- * Quote string scalars (keys and values) that another YAML parser could read
- * as a number, boolean, null, date or merge key. The JSON schema alone leaves
- * values such as `yes`, `~`, `0x1F`, `2026-01-01` or the empty string plain.
- * Runs after the default rules, so strings with invisible characters are
- * already double-quoted and multi-line strings already use block scalars.
- */
-const quoteAmbiguousStrings = (layout) => {
-    if (layout.style !== SCALAR_STYLE.PLAIN || layout.node.tag !== strTag.tagName)
-        return;
-    const value = layout.node.value;
-    if (UNAMBIGUOUS_PLAIN.test(value) && !NON_STRING_WORDS.test(value))
-        return;
-    layout.style = allowsStyle(layout.allowedStylesMask, SCALAR_STYLE.SINGLE_QUOTED)
-        ? SCALAR_STYLE.SINGLE_QUOTED
-        : SCALAR_STYLE.DOUBLE_QUOTED;
-};
-const YAML_STYLE_RULES = [
-    doubleQuoteBidiControls,
-    ...Object.values(DEFAULT_SCALAR_STYLE_RULES),
-    quoteAmbiguousStrings,
-];
-/**
- * Serialize data as YAML with js-yaml, restricted to the JSON schema (no
- * custom tags) and without anchors/aliases. Control characters are escaped by
- * the dumper; bidirectional controls, which YAML treats as printable, are
- * written as `\uXXXX` inside double-quoted scalars.
- */
-export function toYaml(data) {
-    const yaml = dump(data ?? null, {
-        schema: JSON_SCHEMA,
-        noRefs: true,
-        skipInvalid: true,
-        lineWidth: -1,
-        scalarStyleRules: YAML_STYLE_RULES,
-    });
-    return escapeBidiControls(yaml).trimEnd();
-}
-/**
- * Print data as YAML.
- */
-export function printYaml(data) {
-    console.log(toYaml(data));
-}
-/**
- * Print a success message (stderr).
- */
-export function printSuccess(message) {
-    console.error(`\u2713 ${sanitizeForTerminal(message)}`);
-}
-/**
- * Print an error message to stderr. Credential-shaped values are masked.
- */
-export function printError(message) {
-    console.error(`\u2717 ${redactSecrets(sanitizeForTerminal(message))}`);
-}
-/**
- * Print a warning message to stderr. Credential-shaped values are masked.
- */
-export function printWarning(message) {
-    console.warn(`! ${redactSecrets(sanitizeForTerminal(message))}`);
-}
-/**
- * Print an info message (stderr).
- */
-export function printInfo(message) {
-    console.error(`\u2139 ${sanitizeForTerminal(message)}`);
-}
-/**
- * Format an ISO date string for display.
- */
-export function formatDate(date) {
-    if (!date)
-        return '-';
-    try {
-        return new Date(date).toLocaleString();
-    }
-    catch {
-        return date;
-    }
-}
-/**
- * Format a status string with emoji indicators.
- */
-export function formatStatus(status) {
-    if (!status)
-        return '-';
-    const upper = status.toUpperCase();
-    switch (upper) {
-        case 'ACTIVE':
-        case 'RUNNING':
-        case 'HEALTHY':
-            return `\u2713 ${status}`;
-        case 'INACTIVE':
-        case 'STOPPED':
-        case 'PENDING':
-            return `\u25CB ${status}`;
-        case 'ERROR':
-            return `\u2717 ${status}`;
-        case 'ARCHIVED':
-            return `\u2192 ${status}`;
-        case 'STARTING':
-            return `\u25B6 ${status}`;
-        case 'TERMINATED':
-            return `\u25A0 ${status}`;
-        default:
-            return status;
-    }
-}
-/**
- * Output data in the specified format.
- */
-export function outputData(format, data, tableConfig) {
-    switch (format) {
-        case 'json':
-            printJson(data);
-            break;
-        case 'yaml':
-            printYaml(data);
-            break;
-        case 'table':
-            if (tableConfig) {
-                printTable(tableConfig.headers, tableConfig.rows);
-            }
-            else {
-                printJson(data);
-            }
-            break;
-    }
-}
-/**
- * Sanitize a string for the terminal, then truncate it to a maximum length,
- * appending an ellipsis if needed.
- */
-export function truncate(str, maxLen) {
-    if (!str)
-        return '-';
-    const clean = sanitizeForTerminal(str);
-    if (clean.length <= maxLen)
-        return clean;
-    return clean.substring(0, maxLen - 3) + '...';
-}

package/dist/utils/sanitize.js

@@ -1,347 +0,0 @@
-/**
- * Text hygiene for everything the CLI prints.
- *
- * Remote data (resource names, server error messages, HTTP response bodies)
- * ends up in terminals, CI logs and support captures. The helpers here:
- *  - keep terminal output inert: escape sequences and control characters are
- *    removed, and bidirectional formatting characters are made visible;
- *  - mask credential-shaped values (bearer tokens, JWTs, URL credentials and
- *    values stored under secret-like keys);
- *  - turn any thrown value into a short, single-line message that is built
- *    from an allowlist of fields and never includes request variables,
- *    request headers or raw response bodies.
- *
- * The module is side-effect free and imports nothing from the rest of the CLI,
- * so every layer can use it (and unit-test module mocks never replace it).
- */
-/** Longest error message shown to the user. */
-export const MAX_ERROR_MESSAGE_LENGTH = 500;
-/** Longest excerpt of an HTTP response body or server message kept in an error. */
-export const MAX_HTTP_BODY_EXCERPT_LENGTH = 200;
-/** Text is cut to this length before the redaction patterns scan it. */
-const MAX_SCAN_LENGTH = 4000;
-const REDACTED = '[REDACTED]';
-const ELLIPSIS = '\u2026';
-// ---------------------------------------------------------------------------
-// Terminal output
-// ---------------------------------------------------------------------------
-const ESC = 0x1b;
-const BEL = 0x07;
-const TAB = 0x09;
-const LF = 0x0a;
-const CR = 0x0d;
-const DEL = 0x7f;
-const NEL = 0x85;
-const C1_CSI = 0x9b;
-const C1_ST = 0x9c;
-const LINE_SEPARATOR = 0x2028;
-const PARAGRAPH_SEPARATOR = 0x2029;
-/** 8-bit introducers of DCS, SOS, OSC, PM and APC control strings. */
-const C1_STRING_INTRODUCERS = new Set([0x90, 0x98, 0x9d, 0x9e, 0x9f]);
-/** Final bytes after ESC that open DCS, SOS, OSC, PM and APC control strings. */
-const ESC_STRING_INTRODUCERS = new Set(['P', 'X', ']', '^', '_'].map((c) => c.charCodeAt(0)));
-/** Bidirectional embedding, override and isolate controls. */
-const BIDI_CONTROLS = /[\u202a-\u202e\u2066-\u2069]/g;
-/** `\uXXXX` spelling of a single UTF-16 code unit (valid in JSON and YAML). */
-export function toUnicodeEscape(char) {
-    return `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`;
-}
-/** Make bidirectional formatting controls visible as `\uXXXX` text. */
-export function escapeBidiControls(text) {
-    return text.replace(BIDI_CONTROLS, toUnicodeEscape);
-}
-function isInRange(code, low, high) {
-    return code >= low && code <= high;
-}
-/** Index just past a CSI sequence whose parameters start at `index`. */
-function skipControlSequence(text, index) {
-    let i = index;
-    while (i < text.length && isInRange(text.charCodeAt(i), 0x30, 0x3f))
-        i++;
-    while (i < text.length && isInRange(text.charCodeAt(i), 0x20, 0x2f))
-        i++;
-    if (i < text.length && isInRange(text.charCodeAt(i), 0x40, 0x7e))
-        i++;
-    return i;
-}
-/**
- * Index just past a control string (OSC, DCS, ...) whose payload starts at
- * `index`. Terminated by BEL, 8-bit ST or ESC \; an unterminated string runs
- * to the end of the text, exactly as a terminal would consume it.
- */
-function skipControlString(text, index) {
-    let i = index;
-    while (i < text.length) {
-        const code = text.charCodeAt(i);
-        if (code === BEL || code === C1_ST)
-            return i + 1;
-        if (code === ESC)
-            return text.charCodeAt(i + 1) === 0x5c ? i + 2 : i;
-        i++;
-    }
-    return i;
-}
-/** Index just past an ESC-introduced sequence; `index` points at the ESC. */
-function skipEscapeSequence(text, index) {
-    const next = text.charCodeAt(index + 1);
-    if (Number.isNaN(next))
-        return index + 1;
-    if (next === 0x5b)
-        return skipControlSequence(text, index + 2);
-    if (ESC_STRING_INTRODUCERS.has(next))
-        return skipControlString(text, index + 2);
-    let i = index + 1;
-    while (i < text.length && isInRange(text.charCodeAt(i), 0x20, 0x2f))
-        i++;
-    if (i < text.length && isInRange(text.charCodeAt(i), 0x30, 0x7e))
-        i++;
-    return i;
-}
-/**
- * Make a value safe to print on a terminal.
- *
- * - ANSI/VT escape sequences (CSI, OSC, DCS, SOS, PM, APC and two-character
- *   ESC sequences, in 7-bit and 8-bit form) are removed entirely.
- * - Other C0 controls, DEL and C1 controls are removed.
- * - Line breaks and TAB become a space (see {@link TerminalSanitizeOptions}).
- * - Bidirectional formatting controls are shown as `\uXXXX` text so the
- *   printed text reads in its stored order.
- *
- * `null`/`undefined` become an empty string. The function is idempotent.
- */
-export function sanitizeForTerminal(value, options = {}) {
-    const text = value === null || value === undefined ? '' : String(value);
-    const multiline = options.preserveNewlines === true;
-    let out = '';
-    let i = 0;
-    while (i < text.length) {
-        const code = text.charCodeAt(i);
-        if (code === ESC) {
-            i = skipEscapeSequence(text, i);
-            continue;
-        }
-        if (code === C1_CSI) {
-            i = skipControlSequence(text, i + 1);
-            continue;
-        }
-        if (C1_STRING_INTRODUCERS.has(code)) {
-            i = skipControlString(text, i + 1);
-            continue;
-        }
-        if (code === CR || code === LF) {
-            const crlf = code === CR && text.charCodeAt(i + 1) === LF;
-            out += multiline ? '\n' : ' ';
-            i += crlf ? 2 : 1;
-            continue;
-        }
-        if (code === NEL || code === LINE_SEPARATOR || code === PARAGRAPH_SEPARATOR) {
-            out += multiline ? toUnicodeEscape(text.charAt(i)) : ' ';
-            i++;
-            continue;
-        }
-        if (code === TAB) {
-            out += multiline ? '\t' : ' ';
-            i++;
-            continue;
-        }
-        if (code < 0x20 || isInRange(code, DEL, 0x9f)) {
-            i++;
-            continue;
-        }
-        out += text.charAt(i);
-        i++;
-    }
-    return escapeBidiControls(out);
-}
-// ---------------------------------------------------------------------------
-// Credential masking
-// ---------------------------------------------------------------------------
-/** A key whose value is treated as a credential when it contains one of these. */
-const SECRET_KEY_HINT = /pass(?:word|wd|phrase)?|secret|token|api[-_]?key|private[-_]?key|access[-_]?key|credential|authori[sz]ation|cookie|session[-_]?id/i;
-/**
- * `key: value` / `key=value` / `"key": value` openings. Keys may be quoted,
- * including with backslash-escaped quotes (JSON serialised inside a string).
- */
-const KEY_VALUE_OPENING = /\b([A-Za-z_$][\w$-]{0,127})\\*["']?\s*[:=]\s*/g;
-/** Opening quote of a value, optionally backslash-escaped. */
-const QUOTE_OPENING = /^(\\*)(["'])/;
-/** Unquoted value: runs to whitespace, a quote, a backslash or a delimiter. */
-const UNQUOTED_VALUE = /^[^\s"'\\,;&)}\]]*/;
-/** An auth scheme word that precedes the credential in header values. */
-const AUTH_SCHEME = /^(?:Bearer|Basic|Digest|Token)\s+/i;
-const BEARER_CREDENTIAL = /\bBearer\s+[A-Za-z0-9\-._~+/]+=*/g;
-const JWT_LIKE = /\beyJ[\w-]{4,}\.[\w-]{4,}\.[\w-]*/g;
-const URL_USERINFO = /\b([a-z][a-z0-9+.-]{1,31}:\/\/)[^\s/?#@"'\\]+@/gi;
-/** Number of consecutive backslashes immediately before `index`, not before `floor`. */
-function backslashRun(text, index, floor) {
-    let run = 0;
-    while (index - run - 1 >= floor && text.charAt(index - run - 1) === '\\')
-        run++;
-    return run;
-}
-/**
- * Masked replacement for the value starting at `start`, and the index just
- * past that value. A quoted value ends at the matching quote (same escaping
- * depth) or, when unterminated, at the end of the text.
- */
-function maskValue(text, start) {
-    if (text.startsWith(REDACTED, start)) {
-        return { replacement: REDACTED, end: start + REDACTED.length };
-    }
-    const quote = QUOTE_OPENING.exec(text.slice(start, start + 64));
-    if (quote) {
-        const opener = quote[0];
-        const depth = (quote[1] ?? '').length;
-        const quoteChar = quote[2] ?? '"';
-        let search = start + opener.length;
-        while (search < text.length) {
-            const candidate = text.indexOf(quoteChar, search);
-            if (candidate === -1)
-                break;
-            if (backslashRun(text, candidate, start + opener.length) === depth) {
-                return { replacement: `${opener}${REDACTED}${opener}`, end: candidate + 1 };
-            }
-            search = candidate + 1;
-        }
-        return { replacement: `${opener}${REDACTED}`, end: text.length };
-    }
-    const rest = text.slice(start);
-    const scheme = AUTH_SCHEME.exec(rest);
-    const offset = scheme ? scheme[0].length : 0;
-    const run = UNQUOTED_VALUE.exec(rest.slice(offset));
-    const length = offset + (run ? run[0].length : 0);
-    return { replacement: length > 0 ? REDACTED : '', end: start + length };
-}
-function redactKeyValues(text) {
-    let out = '';
-    let copiedUpTo = 0;
-    KEY_VALUE_OPENING.lastIndex = 0;
-    let match;
-    while ((match = KEY_VALUE_OPENING.exec(text)) !== null) {
-        if (!SECRET_KEY_HINT.test(match[1] ?? ''))
-            continue;
-        const start = match.index + match[0].length;
-        const { replacement, end } = maskValue(text, start);
-        if (end === start)
-            continue;
-        out += text.slice(copiedUpTo, start) + replacement;
-        copiedUpTo = end;
-        KEY_VALUE_OPENING.lastIndex = end;
-    }
-    return out + text.slice(copiedUpTo);
-}
-/**
- * Mask credential-shaped values in free text: values under secret-like keys
- * (`password`, `token`, `refreshToken`, `clientSecret`, `Authorization`, ...),
- * `Bearer` credentials, JWT-shaped strings and credentials embedded in URLs.
- */
-export function redactSecrets(text) {
-    return redactKeyValues(text)
-        .replace(BEARER_CREDENTIAL, `Bearer ${REDACTED}`)
-        .replace(JWT_LIKE, REDACTED)
-        .replace(URL_USERINFO, `$1${REDACTED}@`);
-}
-// ---------------------------------------------------------------------------
-// Display lines and error messages
-// ---------------------------------------------------------------------------
-const LINE_BREAK = /\r\n|[\r\n\u0085\u2028\u2029]/;
-/**
- * Reduce untrusted text to one printable, credential-masked line of at most
- * `maxLength` characters. Returns an empty string when nothing is left.
- */
-export function toDisplayLine(value, maxLength = MAX_ERROR_MESSAGE_LENGTH) {
-    if (value === null || value === undefined)
-        return '';
-    const firstLine = String(value).split(LINE_BREAK, 1)[0] ?? '';
-    const scanned = firstLine.slice(0, MAX_SCAN_LENGTH);
-    const line = redactSecrets(sanitizeForTerminal(scanned)).trim();
-    return line.length > maxLength ? `${line.slice(0, maxLength)}${ELLIPSIS}` : line;
-}
-/** Short, printable excerpt of an HTTP response body for an error message. */
-export function summarizeHttpBody(body) {
-    return toDisplayLine(body, MAX_HTTP_BODY_EXCERPT_LENGTH) || 'empty response body';
-}
-const ERROR_CODE = /^[A-Z][A-Z0-9_]{1,63}$/;
-function asRecord(value) {
-    // Narrowing an arbitrary thrown value; every field read below is type-checked.
-    return typeof value === 'object' && value !== null
-        ? value
-        : undefined;
-}
-function stringField(record, key) {
-    const value = record?.[key];
-    return typeof value === 'string' ? value : undefined;
-}
-function isAbortError(error) {
-    const name = stringField(asRecord(error), 'name');
-    return name === 'AbortError' || name === 'TimeoutError';
-}
-/**
- * Describe an error that carries an HTTP/GraphQL `response` (graphql-request's
- * ClientError). The library-composed `message` of such errors embeds the full
- * request (query and variables) and the raw response body, so it is never
- * read: the description is built only from the status, the first GraphQL
- * error's message and its `extensions.code`.
- */
-function describeResponseError(response) {
-    const status = typeof response.status === 'number' ? response.status : undefined;
-    const errors = Array.isArray(response.errors) ? response.errors : [];
-    const first = asRecord(errors[0]);
-    const extensions = asRecord(first?.extensions);
-    // Federated subgraph errors carry the useful text under
-    // extensions.originalError.message; the top-level message is often generic.
-    const original = toDisplayLine(stringField(asRecord(extensions?.originalError), 'message'));
-    const wrapper = toDisplayLine(stringField(first, 'message'));
-    const rawCode = stringField(extensions, 'code');
-    const code = rawCode !== undefined && ERROR_CODE.test(rawCode) ? rawCode : undefined;
-    const base = original ||
-        wrapper ||
-        (status !== undefined ? `Request failed (HTTP ${status})` : 'Request failed');
-    return {
-        message: code ? `${base} [${code}]` : base,
-        ...(status !== undefined ? { status } : {}),
-        ...(code ? { code } : {}),
-    };
-}
-function networkErrorCode(error) {
-    const code = stringField(asRecord(asRecord(error)?.cause), 'code');
-    return code !== undefined && ERROR_CODE.test(code) ? code : undefined;
-}
-/**
- * Describe a failure of a GraphQL request for display. Network-level
- * `TypeError`s (fetch failures) are reported as network errors; aborted
- * requests as timeouts.
- */
-export function describeRequestError(error) {
-    const response = asRecord(asRecord(error)?.response);
-    if (response)
-        return describeResponseError(response);
-    if (isAbortError(error))
-        return { message: 'Request timed out' };
-    if (error instanceof TypeError) {
-        const detail = toDisplayLine(error.message, MAX_HTTP_BODY_EXCERPT_LENGTH);
-        const code = networkErrorCode(error);
-        return {
-            message: `Network error${detail ? `: ${detail}` : ''}${code ? ` (${code})` : ''}`,
-        };
-    }
-    return { message: toSafeErrorMessage(error) };
-}
-/**
- * Convert any thrown value into a message that is safe to print: a single
- * line, at most {@link MAX_ERROR_MESSAGE_LENGTH} characters, free of terminal
- * control sequences and with credential-shaped values masked. Response-bearing
- * errors are described from an allowlist of fields only.
- */
-export function toSafeErrorMessage(error) {
-    const response = asRecord(asRecord(error)?.response);
-    if (response)
-        return describeResponseError(response).message;
-    if (isAbortError(error))
-        return 'Request timed out';
-    if (error instanceof Error || typeof error === 'string') {
-        const text = typeof error === 'string' ? error : error.message;
-        return toDisplayLine(text) || 'Unexpected error';
-    }
-    return 'Unexpected error';
-}