@burdenoff/bigconsole-cli 2026.802.1 → 2026.1029.1

package/dist/utils/sanitize.js

@@ -0,0 +1,347 @@
+/**
+ * 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';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/bigconsole-cli",
-  "version": "2026.802.1",
+  "version": "2026.1029.1",
   "description": "Command-line interface for BigConsole platform operations and management",
   "type": "module",
   "main": "dist/index.js",
@@ -33,7 +33,8 @@
     "audit": "bunx better-npm-audit audit",
     "start": "bun dist/cli.js",
     "publish:alpha": "bun run build && bunx npm@latest publish --tag alpha",
-    "publish:prod": "bun run build && bunx npm@latest publish"
+    "publish:prod": "bun run build && bunx npm@latest publish",
+    "schema:pull": "bash scripts/schema-pull.sh"
   },
   "keywords": [
     "algoshred",
@@ -56,41 +57,42 @@
   },
   "homepage": "https://github.com/Algoshred/bigconsole-cli#readme",
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
   "dependencies": {
     "boxen": "^8.0.1",
-    "chalk": "^5.5.0",
-    "commander": "^14.0.0",
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
     "cross-fetch": "^4.1.0",
-    "graphql": "^16.11.0",
-    "graphql-request": "^7.2.0",
-    "inquirer": "^12.9.2",
-    "js-yaml": "^4.1.0",
-    "ora": "^8.2.0",
+    "graphql": "^17.0.2",
+    "graphql-request": "^7.4.0",
+    "inquirer": "^14.1.0",
+    "js-yaml": "^5.4.1",
+    "ora": "^9.4.1",
     "table": "^6.9.0",
     "update-notifier": "^7.3.1"
   },
   "devDependencies": {
-    "@playwright/test": "^1.59.1",
-    "@types/inquirer": "^9.0.9",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^24.3.0",
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.62.1",
+    "@types/inquirer": "^9.0.10",
+    "@types/node": "^26.3.0",
     "@types/update-notifier": "^6.0.8",
-    "@typescript-eslint/eslint-plugin": "^8.39.1",
-    "@typescript-eslint/parser": "^8.39.1",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
-    "eslint": "^9.33.0",
+    "@typescript-eslint/eslint-plugin": "^8.68.0",
+    "@typescript-eslint/parser": "^8.68.0",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/ui": "^4.1.11",
+    "eslint": "^10.9.1",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^16.3.0",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "tsc-alias": "^1.8.16",
-    "tsx": "^4.20.4",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.11.0",
+    "prettier": "^3.9.6",
+    "rimraf": "^6.1.3",
+    "tsc-alias": "^1.9.2",
+    "tsx": "^4.23.12",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11",
+    "yaml": "^2.8.3"
   },
   "engines": {
     "node": ">=24.11.0",
@@ -103,14 +105,19 @@
     "fast-xml-parser": ">=4.5.5",
     "@xmldom/xmldom": ">=0.8.12",
     "swiper": ">=12.1.2",
-    "brace-expansion": ">=1.1.13",
+    "brace-expansion": "5.0.9",
     "follow-redirects": ">=1.15.12",
     "smol-toml": ">=1.6.1",
     "axios": ">=1.15.0",
-    "flatted": ">=3.4.1",
-    "yaml": ">=2.8.3",
-    "picomatch": ">=2.3.2",
+    "flatted": "3.4.4",
+    "yaml": "$yaml",
+    "picomatch": "4.0.7",
     "immutable": ">=3.8.3",
-    "minimatch": ">=3.1.3"
+    "minimatch": ">=3.1.3",
+    "nanoid": "6.0.1",
+    "postcss": "8.5.26",
+    "vite": "8.2.2",
+    "fast-uri": "4.1.3",
+    "esbuild": "0.28.2"
   }
 }