@bussolabs/closeyourit-cli 0.0.21 → 0.0.25

package/dist/lib/output.d.ts

@@ -11,7 +11,23 @@ export declare function sanitize(value: unknown): string;
  * Every other C0/C1 control char is still defused per line.
  */
 export declare function sanitizeMultiline(value: unknown): string;
+/** Terminal display width of a string (wide code points count as 2, zero-width joiners/VS as 0). */
+export declare function displayWidth(value: string): number;
 /** Minimal dependency-free table renderer for human output. */
 export declare function renderTable(headers: string[], rows: string[][]): string;
-/** Pretty-print the scalar fields of a record as `key: value` lines. */
+/**
+ * Status dots make problems scannable at a glance. Four fixed-width circles (no variation
+ * selectors, so table columns stay aligned): down=🔴, warn=🟡, ok=🟢, neutral=⚪.
+ */
+export type StatusTone = 'down' | 'warn' | 'ok' | 'neutral';
+/**
+ * Status dot for a value. With `color` (a Tailwind family name) it uses the colour map — the stable
+ * token for org-renamed status/priority; otherwise the monitoring string-enum map. Unknown → neutral.
+ */
+export declare function statusDot(value: unknown, color?: string): string;
+/** A table cell with its status dot prefixed (the emoji survives `sanitize`). */
+export declare function statusCell(value: unknown, color?: string): string;
+/** A section heading: optional emoji + title, underlined with dashes sized to the title. */
+export declare function section(title: string, icon?: string): string;
+/** Pretty-print the scalar fields of a record as `key: value` lines (status keys get a dot). */
 export declare function renderRecord(obj: Record<string, unknown>): string;

package/dist/lib/output.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitize = sanitize;
 exports.sanitizeMultiline = sanitizeMultiline;
+exports.displayWidth = displayWidth;
 exports.renderTable = renderTable;
+exports.statusDot = statusDot;
+exports.statusCell = statusCell;
+exports.section = section;
 exports.renderRecord = renderRecord;
 /**
  * Neutralize terminal control sequences (CWE-150) in server-supplied strings.
@@ -29,6 +33,32 @@ function sanitizeMultiline(value) {
         .map((line) => sanitize(line))
         .join('\n');
 }
+// Code-point ranges that render as 2 terminal columns (CJK + emoji + symbols). Emoji like 🔴 have a
+// JS `.length` of 2 while ⚪ (U+26AA) has `.length` 1 — yet both render 2-wide, so padding a column by
+// `.length` misaligns rows that mix them. Measuring by code point keeps the status column square.
+const WIDE_RANGES = [
+    [0x1100, 0x115f], // Hangul Jamo
+    [0x2600, 0x27bf], // Misc symbols + Dingbats (⚪ ⚫ ✅ …)
+    [0x2b00, 0x2bff], // Misc symbols and arrows
+    [0x2e80, 0xa4cf], // CJK & friends
+    [0xac00, 0xd7a3], // Hangul syllables
+    [0xf900, 0xfaff], // CJK compatibility ideographs
+    [0xfe30, 0xfe4f], // CJK compatibility forms
+    [0xff00, 0xff60], // Fullwidth forms
+    [0xffe0, 0xffe6], // Fullwidth signs
+    [0x1f000, 0x1faff], // emoji & pictographs (🔴 🟡 🟢 …)
+];
+/** Terminal display width of a string (wide code points count as 2, zero-width joiners/VS as 0). */
+function displayWidth(value) {
+    let width = 0;
+    for (const ch of value) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if (cp === 0x200d || (cp >= 0xfe00 && cp <= 0xfe0f) || (cp >= 0x0300 && cp <= 0x036f))
+            continue;
+        width += WIDE_RANGES.some(([lo, hi]) => cp >= lo && cp <= hi) ? 2 : 1;
+    }
+    return width;
+}
 /** Minimal dependency-free table renderer for human output. */
 function renderTable(headers, rows) {
     const safeHeaders = headers.map(sanitize);
@@ -36,15 +66,120 @@ function renderTable(headers, rows) {
     if (safeRows.length === 0) {
         return `${safeHeaders.join('  ')}\n(no results)`;
     }
-    const widths = safeHeaders.map((header, col) => Math.max(header.length, ...safeRows.map((row) => (row[col] ?? '').length)));
-    const line = (cols) => cols.map((cell, col) => (cell ?? '').padEnd(widths[col])).join('  ').trimEnd();
+    const widths = safeHeaders.map((header, col) => Math.max(displayWidth(header), ...safeRows.map((row) => displayWidth(row[col] ?? ''))));
+    const pad = (cell, col) => cell + ' '.repeat(Math.max(0, widths[col] - displayWidth(cell)));
+    const line = (cols) => cols.map((cell, col) => pad(cell ?? '', col)).join('  ').trimEnd();
     const separator = widths.map((width) => '-'.repeat(width));
     return [line(safeHeaders), line(separator), ...safeRows.map(line)].join('\n');
 }
-/** Pretty-print the scalar fields of a record as `key: value` lines. */
+const TONE_DOT = {
+    down: '🔴',
+    neutral: '⚪',
+    ok: '🟢',
+    warn: '🟡',
+};
+/**
+ * Stable enum strings of the monitoring domains → tone (keys are lowercase). These come straight
+ * from the model enums and never get org-renamed, so the CLI maps them without any backend help.
+ * Caveats baked in: agent-run failure is `fail` (not `failed`); a paused monitor/host is neutral.
+ */
+const STATUS_TONE = {
+    // ideas
+    archived: 'neutral',
+    // errors — status
+    ignored: 'neutral',
+    resolved: 'ok',
+    unresolved: 'down',
+    // errors — level
+    debug: 'neutral',
+    error: 'down',
+    fatal: 'down',
+    info: 'ok',
+    warning: 'warn',
+    // uptime monitor + server host
+    down: 'down',
+    paused: 'neutral',
+    pending: 'warn',
+    unknown: 'neutral',
+    up: 'ok',
+    // cron monitor
+    late: 'warn',
+    missed: 'down',
+    ok: 'ok',
+    // ideas
+    converted: 'ok',
+    open: 'warn',
+    // incident phase
+    detected: 'down',
+    fixing: 'warn',
+    investigating: 'warn',
+    monitoring: 'warn',
+    // agent run
+    fail: 'down',
+    running: 'warn',
+    success: 'ok',
+    // token
+    active: 'ok',
+    expired: 'neutral',
+    revoked: 'neutral',
+};
+/**
+ * Badge colour (Tailwind family name) → tone. Ticket status/priority labels are org-customisable,
+ * so the serializer ships the badge colour as a stable token and the CLI translates it here —
+ * identical to what the web badge shows. Unknown colour → falls back to the value string map.
+ */
+const COLOR_TONE = {
+    amber: 'warn',
+    emerald: 'ok',
+    gray: 'neutral',
+    green: 'ok',
+    indigo: 'warn',
+    orange: 'down',
+    red: 'down',
+    sky: 'ok',
+    teal: 'ok',
+    violet: 'warn',
+};
+/**
+ * Status dot for a value. With `color` (a Tailwind family name) it uses the colour map — the stable
+ * token for org-renamed status/priority; otherwise the monitoring string-enum map. Unknown → neutral.
+ */
+function statusDot(value, color) {
+    const tone = (color ? COLOR_TONE[color.trim().toLowerCase()] : undefined) ??
+        STATUS_TONE[String(value ?? '').trim().toLowerCase()] ??
+        'neutral';
+    return TONE_DOT[tone];
+}
+/** A table cell with its status dot prefixed (the emoji survives `sanitize`). */
+function statusCell(value, color) {
+    return `${statusDot(value, color)} ${value ?? ''}`;
+}
+/** A section heading: optional emoji + title, underlined with dashes sized to the title. */
+function section(title, icon) {
+    return `\n${icon ? `${icon} ` : ''}${title}\n${'-'.repeat(title.length)}`;
+}
+// Record keys whose value is a status/level/phase → get a dot. Keys with a `<key>_color` sibling
+// (ticket status/priority) dot by colour; the enum-string keys below dot by the string map.
+const ENUM_STATUS_KEYS = new Set(['status', 'current_status', 'last_run_status', 'level', 'phase']);
+// Metadata keys used only to pick a dot colour — never printed as their own line.
+const HIDDEN_KEYS = new Set(['status_color', 'priority_color']);
+/** The dot prefix (with trailing space) for a record line, or '' when the key isn't status-like. */
+function recordDot(key, value, obj) {
+    const color = obj[`${key}_color`];
+    if (typeof color === 'string' && color)
+        return `${statusDot(value, color)} `;
+    if (ENUM_STATUS_KEYS.has(key))
+        return `${statusDot(value)} `;
+    return '';
+}
+/** Pretty-print the scalar fields of a record as `key: value` lines (status keys get a dot). */
 function renderRecord(obj) {
     const lines = Object.entries(obj)
-        .filter(([, value]) => value === null || ['string', 'number', 'boolean'].includes(typeof value))
-        .map(([key, value]) => `${sanitize(key)}: ${value === null ? '-' : sanitize(value)}`);
+        .filter(([key, value]) => !HIDDEN_KEYS.has(key) && (value === null || ['string', 'number', 'boolean'].includes(typeof value)))
+        .map(([key, value]) => {
+        if (value === null)
+            return `${sanitize(key)}: -`;
+        return `${sanitize(key)}: ${recordDot(key, value, obj)}${sanitize(value)}`;
+    });
     return lines.length > 0 ? lines.join('\n') : JSON.stringify(obj, null, 2);
 }

package/dist/lib/stdin.d.ts

@@ -0,0 +1,3 @@
+/** Read a whole stream (default: process.stdin) into a UTF-8 string. Used by `secrets import` to accept
+ * piped input, e.g. `doppler secrets download --format json | cyi secrets import --format json`. */
+export declare function readStream(stream?: AsyncIterable<Buffer | string>): Promise<string>;

package/dist/lib/stdin.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStream = readStream;
+/** Read a whole stream (default: process.stdin) into a UTF-8 string. Used by `secrets import` to accept
+ * piped input, e.g. `doppler secrets download --format json | cyi secrets import --format json`. */
+async function readStream(stream = process.stdin) {
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/lib/subprocess.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run a child process inheriting stdio, resolving with its exit code. Unlike `openUrl` (browser.ts)
+ * this is NOT detached/unref'd: `cyi run` must stay attached and propagate the child's exit code
+ * (like `doppler run`). A terminating signal maps to a non-zero code.
+ */
+export declare function runCommand(command: string, args: string[], env: NodeJS.ProcessEnv): Promise<number>;

package/dist/lib/subprocess.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Run a child process inheriting stdio, resolving with its exit code. Unlike `openUrl` (browser.ts)
+ * this is NOT detached/unref'd: `cyi run` must stay attached and propagate the child's exit code
+ * (like `doppler run`). A terminating signal maps to a non-zero code.
+ */
+function runCommand(command, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, { stdio: 'inherit', env });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+    });
+}