@nonbot/cli 0.5.13

package/dist/lib/output.js

@@ -0,0 +1,382 @@
+import { ANSI, renderBannerHeader } from './banner.js';
+export { ANSI };
+export const BRAND = {
+    white: '\x1b[38;2;255;255;255m',
+    cyan: '\x1b[38;2;79;195;247m',
+    green: '\x1b[38;2;40;199;111m',
+    amber: '\x1b[38;2;255;159;67m',
+    red: '\x1b[38;2;255;76;81m',
+    muted: '\x1b[38;2;139;148;158m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+    underline: '\x1b[4m',
+};
+export function isTTY(stream = process.stdout) {
+    const noColor = process.env.NO_COLOR;
+    if (noColor && noColor.length > 0)
+        return false;
+    const force = process.env.FORCE_COLOR;
+    if (force && force.length > 0)
+        return true;
+    const tty = stream.isTTY;
+    return tty === true;
+}
+export function paintRaw(s, code, stream = process.stdout) {
+    if (!isTTY(stream))
+        return s;
+    return code + s + BRAND.reset;
+}
+function paint(s, code, stream = process.stdout) {
+    return paintRaw(s, code, stream);
+}
+export const c = {
+    white: (s, stream) => paintRaw(s, BRAND.white, stream),
+    cyan: (s, stream) => paintRaw(s, BRAND.cyan, stream),
+    green: (s, stream) => paintRaw(s, BRAND.green, stream),
+    amber: (s, stream) => paintRaw(s, BRAND.amber, stream),
+    red: (s, stream) => paintRaw(s, BRAND.red, stream),
+    muted: (s, stream) => paintRaw(s, BRAND.muted, stream),
+    bold: (s, stream) => paintRaw(s, BRAND.bold, stream),
+    underline: (s, stream) => paintRaw(s, BRAND.underline, stream),
+    reset: () => BRAND.reset,
+};
+const STATUS_COLOR = {
+    '✓': ANSI.green,
+    '⚠': ANSI.yellow,
+    '✗': ANSI.red,
+    '▶': ANSI.primary,
+    '●': ANSI.green,
+    'ℹ': ANSI.cyan,
+};
+const SIGIL_ASCII = {
+    '✓': 'OK',
+    '⚠': '!!',
+    '✗': 'XX',
+    '▶': '>',
+    '●': '*',
+    'ℹ': 'i',
+};
+function asciiOnly(env = process.env) {
+    return env.NONBOT_ASCII_ONLY === '1' || env.NONBOT_ASCII_ONLY === 'true';
+}
+function sigil(status, stream = process.stdout) {
+    const char = asciiOnly() ? SIGIL_ASCII[status] : status;
+    return paint(char, STATUS_COLOR[status], stream);
+}
+export function header(title, subtitle, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const status = opts.status ?? '▶';
+    const sig = sigil(status, stream);
+    const titlePainted = paint(title, ANSI.bold, stream);
+    if (!subtitle)
+        return `${sig}  ${titlePainted}`;
+    const sep = paint('·', ANSI.dim, stream);
+    const sub = paint(subtitle, ANSI.dim, stream);
+    return `${sig}  ${titlePainted}  ${sep}  ${sub}`;
+}
+export function boxHeader(title, opts) {
+    return renderBannerHeader(title, opts);
+}
+export function kvRow(key, value, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const width = opts.keyWidth ?? 12;
+    const paddedKey = key.padEnd(width, ' ');
+    const keyPainted = paint(paddedKey, ANSI.cyan, stream);
+    const valuePainted = paint(value, ANSI.dim, stream);
+    return `   ${keyPainted} ${valuePainted}`;
+}
+export function statusRow(status, label, detail = '', opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const width = opts.labelWidth ?? 18;
+    const sig = sigil(status, stream);
+    const paddedLabel = label.padEnd(width, ' ');
+    const labelPainted = paint(paddedLabel, ANSI.cyan, stream);
+    if (!detail)
+        return `   ${sig}  ${labelPainted}`;
+    const detailPainted = paint(detail, ANSI.dim, stream);
+    return `   ${sig}  ${labelPainted} ${detailPainted}`;
+}
+export function formatKV(rows, opts = {}) {
+    const maxKey = opts.maxKeyWidth ?? 18;
+    const longest = rows.reduce((m, [k]) => Math.max(m, k.length), 0);
+    const width = Math.min(longest, maxKey);
+    return rows.map(([k, v]) => kvRow(k, v, { keyWidth: width, stream: opts.stream }));
+}
+export function errorBlock(what, fix, opts = {}) {
+    const stream = opts.stream ?? process.stderr;
+    const head = statusRow('✗', what, '', { labelWidth: what.length, stream });
+    if (!fix)
+        return head + '\n';
+    const fixLabel = paint('Fix:', ANSI.cyan, stream);
+    const fixText = paint(fix, ANSI.dim, stream);
+    return head + '\n      ' + fixLabel + ' ' + fixText + '\n';
+}
+export function eventRow(parts, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const status = opts.status ?? '▶';
+    const sig = sigil(status, stream);
+    const sep = paint('·', ANSI.dim, stream);
+    const painted = parts.map((p, i) => {
+        if (i === 0)
+            return p;
+        return paint(p, ANSI.dim, stream);
+    });
+    return `${sig}  ` + painted.join(`  ${sep}  `);
+}
+export function clockTime(d = new Date()) {
+    const pad = (n) => (n < 10 ? '0' + n : String(n));
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+const WORDMARK_LINES = [
+    '███╗   ██╗  ██████╗  ███╗   ██╗   ██████╗    ██████╗  ████████╗',
+    '████╗  ██║ ██╔═══██╗ ████╗  ██║   ██╔══██╗  ██╔═══██╗ ╚══██╔══╝',
+    '██╔██╗ ██║ ██║   ██║ ██╔██╗ ██║   ██████╔╝  ██║   ██║    ██║   ',
+    '██║╚██╗██║ ██║   ██║ ██║╚██╗██║   ██╔══██╗  ██║   ██║    ██║   ',
+    '██║ ╚████║ ╚██████╔╝ ██║ ╚████║██╗██████╔╝  ╚██████╔╝    ██║   ',
+    '╚═╝  ╚═══╝  ╚═════╝  ╚═╝  ╚═══╝╚═╝╚═════╝    ╚═════╝     ╚═╝   ',
+];
+export const WORDMARK_WIDTH = 63;
+export const WORDMARK_HEIGHT = 6;
+export function terminalWidth(width) {
+    const cols = width ?? (process.stdout && process.stdout.columns) ?? 80;
+    const min = WORDMARK_WIDTH + 6;
+    const max = 200;
+    if (cols < min)
+        return min;
+    if (cols > max)
+        return max;
+    return cols;
+}
+function trackedCaps(s) {
+    return s.split('').join(' ');
+}
+export function wordmark(version, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const state = opts.state;
+    const headLines = WORDMARK_LINES.map((line) => c.bold(c.white(line, stream), stream));
+    const parts = [c.cyan(trackedCaps('DAEMON'), stream)];
+    if (version) {
+        parts.push(c.muted('·', stream));
+        parts.push(c.muted(version, stream));
+    }
+    if (state) {
+        parts.push(c.muted('·', stream));
+        parts.push(c.muted(trackedCaps(state), stream));
+    }
+    const subtitle = parts.join('  ');
+    return [...headLines, '', subtitle].join('\n');
+}
+export function visibleLength(s) {
+    return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').length;
+}
+export function renderWordmarkWithBadge(opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const cols = terminalWidth(opts.width);
+    const color = opts.badgeColor ?? 'green';
+    const label = opts.badgeLabel ?? 'CONNECTED';
+    const sublines = opts.badgeSublines ?? [];
+    const dotColored = {
+        green: (s) => c.green(s, stream),
+        amber: (s) => c.amber(s, stream),
+        red: (s) => c.red(s, stream),
+        muted: (s) => c.muted(s, stream),
+    };
+    const minGap = 2;
+    const rightColWidth = cols - WORDMARK_WIDTH - minGap;
+    const headVisible = `●  ${label}`;
+    const headRaw = `${dotColored[color]('●')}  ${dotColored[color](label)}`;
+    const inlineSublines = [];
+    const overflowSublines = [];
+    for (const s of sublines) {
+        if (s.length <= rightColWidth && inlineSublines.length < WORDMARK_HEIGHT - 1) {
+            inlineSublines.push(s);
+        }
+        else {
+            overflowSublines.push(s);
+        }
+    }
+    const headFits = headVisible.length <= rightColWidth;
+    if (!headFits) {
+        overflowSublines.unshift(`${label}`);
+    }
+    const rightRowsVisible = [];
+    const rightRowsRaw = [];
+    if (headFits) {
+        rightRowsVisible.push(headVisible);
+        rightRowsRaw.push(headRaw);
+    }
+    for (const s of inlineSublines) {
+        rightRowsVisible.push(s);
+        rightRowsRaw.push(c.muted(s, stream));
+    }
+    const lines = [];
+    for (let r = 0; r < WORDMARK_LINES.length; r++) {
+        const wm = WORDMARK_LINES[r];
+        const wmPainted = c.bold(c.white(wm, stream), stream);
+        if (r >= rightRowsRaw.length) {
+            lines.push(wmPainted);
+            continue;
+        }
+        const rightRaw = rightRowsRaw[r];
+        const rightVisible = rightRowsVisible[r] ?? '';
+        const wmVisibleLen = wm.length;
+        const rightLen = rightVisible.length;
+        const gap = Math.max(minGap, cols - wmVisibleLen - rightLen);
+        lines.push(wmPainted + ' '.repeat(gap) + rightRaw);
+    }
+    for (const s of overflowSublines) {
+        lines.push(`  ${c.muted(s, stream)}`);
+    }
+    return lines.join('\n');
+}
+export function statusBadge(color, label, sublines = [], opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const dotColored = {
+        green: (s) => c.green(s, stream),
+        amber: (s) => c.amber(s, stream),
+        red: (s) => c.red(s, stream),
+        muted: (s) => c.muted(s, stream),
+    };
+    const dot = dotColored[color]('●');
+    const head = `${dot}  ${dotColored[color](trackedCaps(label))}`;
+    if (sublines.length === 0)
+        return head;
+    const indented = sublines.map((s) => `   ${c.muted(s, stream)}`);
+    return [head, ...indented].join('\n');
+}
+function bracketMarker(marker) {
+    return `[ ${marker} ]`;
+}
+function colorize(s, color, stream) {
+    const map = {
+        green: (s) => c.green(s, stream),
+        amber: (s) => c.amber(s, stream),
+        red: (s) => c.red(s, stream),
+        muted: (s) => c.muted(s, stream),
+    };
+    return map[color](s);
+}
+export function activationCard(args) {
+    const stream = args.stream ?? process.stdout;
+    const marker = colorize(bracketMarker(args.marker), args.color, stream);
+    const id = c.bold(c.white(args.id, stream), stream);
+    const sep = c.muted('·', stream);
+    const suffix = colorize(args.headerSuffix, args.color, stream);
+    const head = `${marker} ${id} ${sep} ${suffix}`;
+    if (args.kv.length === 0)
+        return head;
+    const LABEL_WIDTH = 9;
+    const rows = args.kv.map(([k, v]) => {
+        const label = c.cyan(k.padEnd(LABEL_WIDTH, ' '), stream);
+        const value = c.white(v, stream);
+        return `      ${label} ${value}`;
+    });
+    return [head, ...rows].join('\n');
+}
+function formatMsToS(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${Math.round(ms / 1000)}s`;
+}
+export function pollTick(args) {
+    const stream = args.stream ?? process.stdout;
+    const ts = c.cyan(clockTime(args.now ?? new Date()), stream);
+    const pollCount = args.pending > 0
+        ? c.green(`poll +${args.pending}`, stream)
+        : c.white(`poll +${args.pending}`, stream);
+    const sep = c.muted('·', stream);
+    const sleepText = args.sleepMs !== undefined
+        ? `sleep ${formatMsToS(args.sleepMs)}`
+        : 'backing off';
+    const sleepSeg = args.backingOff
+        ? c.amber(sleepText, stream)
+        : c.muted(sleepText, stream);
+    const statusText = args.status ?? (args.pending > 0
+        ? `fired ${args.pending}`
+        : 'no new activations');
+    const statusSeg = c.muted(statusText, stream);
+    return `${ts}  ${pollCount}  ${sep}  ${sleepSeg}  ${sep}  ${statusSeg}`;
+}
+export function fixBlock(args) {
+    const stream = args.stream ?? process.stdout;
+    const title = c.amber(`| ${args.title.toUpperCase()} |`, stream);
+    const lines = [title];
+    args.steps.forEach((step, i) => {
+        const num = c.muted(`${i + 1}.`, stream);
+        const text = c.white(step.text, stream);
+        let line = `${num} ${text}`;
+        if (step.url) {
+            const url = c.underline(c.cyan(step.url, stream), stream);
+            line += ` ${url}`;
+        }
+        if (step.detail) {
+            line += `   ${c.muted(step.detail, stream)}`;
+        }
+        lines.push(line);
+    });
+    return lines.join('\n');
+}
+export const DAEMON_TAGLINES = [
+    'wired in. every Run lands here.',
+    "the canvas thinks. this runs. that's the whole deal.",
+    "click ▶ on the canvas. terminal opens here. that's it.",
+    'listening for chevrons. it\'s go time.',
+    'halfway between intent and shipped. ready when you are.',
+    'between the canvas and your terminal — door\'s open.',
+    'you click, this catches. no rituals required.',
+    'standing by. nothing fancy, just nothing missed.',
+];
+export function pickDaemonTagline(seed, pool = DAEMON_TAGLINES) {
+    const n = pool.length;
+    if (n === 0)
+        return '';
+    const idx = Math.abs(Math.trunc(seed)) % n;
+    return pool[idx];
+}
+export function daemonOpener(version, opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const seed = opts.seed ?? Date.now();
+    const tagline = pickDaemonTagline(seed, opts.pool);
+    const state = opts.state ?? 'IDLE';
+    const breadcrumb = opts.breadcrumb ?? 'SYS://nonbot/daemon';
+    const breadcrumbLine = breadcrumb
+        ? `  ${c.cyan(breadcrumb, stream)}\n\n`
+        : '';
+    const stamp = renderWordmarkWithBadge({
+        badgeColor: opts.badgeColor ?? 'green',
+        badgeLabel: opts.badgeLabel ?? 'CONNECTED',
+        badgeSublines: opts.badgeSublines ?? [],
+        width: opts.width,
+        stream,
+    });
+    const subParts = [c.cyan(trackedCaps('DAEMON'), stream)];
+    if (version) {
+        subParts.push(c.muted('·', stream));
+        subParts.push(c.muted(version, stream));
+    }
+    if (state) {
+        subParts.push(c.muted('·', stream));
+        subParts.push(c.muted(trackedCaps(state), stream));
+    }
+    const subtitleLine = `  ${subParts.join('  ')}`;
+    const taglineLine = tagline ? `\n\n  ${c.muted(tagline, stream)}` : '';
+    return `${breadcrumbLine}${stamp}\n\n${subtitleLine}${taglineLine}`;
+}
+export function daemonCloser(opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const pulse = c.green('░▒▓█', stream);
+    const wiredLabel = opts.activeCount && opts.activeCount > 0
+        ? `wired  ·  ${opts.activeCount} active`
+        : 'wired';
+    const wired = c.muted(wiredLabel, stream);
+    const sep = c.muted('·', stream);
+    const ctrlC = c.cyan('^C', stream);
+    const stopHint = c.muted('to stop daemon', stream);
+    const parts = [`${pulse}  ${wired}`, ` ${sep} `, `${ctrlC} ${stopHint}`];
+    if (opts.inTmux) {
+        const ctrlBd = c.cyan('^B d', stream);
+        const detachHint = c.muted('to detach tmux', stream);
+        parts.push(` ${sep} `, `${ctrlBd} ${detachHint}`);
+    }
+    return parts.join('');
+}

package/dist/lib/payload-validator.js

@@ -0,0 +1,174 @@
+import { PROVIDER_PROFILES, PROVIDER_TEST_PROFILES } from './command-builders.js';
+export class ValidationError extends Error {
+    field;
+    reason;
+    constructor(field, reason) {
+        super(`invalid payload (${field}): ${reason}`);
+        this.name = 'ValidationError';
+        this.field = field;
+        this.reason = reason;
+    }
+}
+const ACTIVATION_ID_RE = /^act_[a-f0-9]{8,32}$/i;
+const STORY_TITLE_MAX = 200;
+const AGENTS_MD_MAX = 24 * 1024;
+const REPO_PATH_MAX = 1024;
+const AGENTS_MD_HEREDOC_DELIMITER = 'NONBOT_AGENTS_EOF';
+const THEME_ID_MAX = 128;
+const THEME_NAME_MAX = 128;
+const THEME_TMUX_CONF_MAX = 8 * 1024;
+const THEME_ITERM_JSON_MAX = 16 * 1024;
+export function validateActivationId(s) {
+    if (typeof s !== 'string') {
+        throw new ValidationError('activationId', 'must be a string');
+    }
+    if (!ACTIVATION_ID_RE.test(s)) {
+        throw new ValidationError('activationId', `must match /^act_[a-f0-9]{8,32}$/i (got ${JSON.stringify(s.slice(0, 64))})`);
+    }
+    return s;
+}
+export function validateRepoPath(s, opts = {}) {
+    if (s === undefined || s === null || s === '') {
+        if (opts.allowEmpty)
+            return '';
+        throw new ValidationError('repoPath', 'is required');
+    }
+    if (typeof s !== 'string') {
+        throw new ValidationError('repoPath', 'must be a string');
+    }
+    if (s.length > REPO_PATH_MAX) {
+        throw new ValidationError('repoPath', `exceeds ${REPO_PATH_MAX} chars`);
+    }
+    if (!s.startsWith('/')) {
+        throw new ValidationError('repoPath', 'must be an absolute POSIX path');
+    }
+    if (s.includes('..')) {
+        throw new ValidationError('repoPath', 'must not contain ".."');
+    }
+    if (/[\n\r\0;`$"\\]/.test(s)) {
+        throw new ValidationError('repoPath', 'contains shell metacharacters');
+    }
+    return s;
+}
+export function validateStoryTitle(s) {
+    if (s === undefined || s === null)
+        return undefined;
+    if (typeof s !== 'string') {
+        throw new ValidationError('storyTitle', 'must be a string');
+    }
+    if (s.length > STORY_TITLE_MAX) {
+        throw new ValidationError('storyTitle', `exceeds ${STORY_TITLE_MAX} chars`);
+    }
+    if (/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(s)) {
+        throw new ValidationError('storyTitle', 'contains control bytes');
+    }
+    return s;
+}
+export function validateAgentsMd(s) {
+    if (s === undefined || s === null || s === '')
+        return undefined;
+    if (typeof s !== 'string') {
+        throw new ValidationError('agentsMd', 'must be a string');
+    }
+    if (s.length > AGENTS_MD_MAX) {
+        throw new ValidationError('agentsMd', `exceeds ${AGENTS_MD_MAX} bytes`);
+    }
+    const heredocLine = new RegExp(`(^|\\n)\\s*${AGENTS_MD_HEREDOC_DELIMITER}\\s*(\\n|$)`);
+    if (heredocLine.test(s)) {
+        throw new ValidationError('agentsMd', `contains the heredoc-closing literal "${AGENTS_MD_HEREDOC_DELIMITER}" on its own line`);
+    }
+    if (s.includes('\0')) {
+        throw new ValidationError('agentsMd', 'contains NUL bytes');
+    }
+    return s;
+}
+export function validateProvider(s) {
+    if (typeof s !== 'string') {
+        throw new ValidationError('provider', 'must be a string');
+    }
+    if (!(s in PROVIDER_PROFILES)) {
+        throw new ValidationError('provider', `not in allowlist (${Object.keys(PROVIDER_PROFILES).join(', ')})`);
+    }
+    return s;
+}
+export function validateTerminalTheme(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const t = raw;
+    if (typeof t.id !== 'string' || t.id.length === 0 || t.id.length > THEME_ID_MAX)
+        return null;
+    if (typeof t.name !== 'string' || t.name.length === 0 || t.name.length > THEME_NAME_MAX)
+        return null;
+    if (/[\x00-\x1f\x7f]/.test(t.name))
+        return null;
+    if (typeof t.tmuxConf !== 'string' || t.tmuxConf.length > THEME_TMUX_CONF_MAX)
+        return null;
+    if (typeof t.itermProfileJson !== 'string' || t.itermProfileJson.length > THEME_ITERM_JSON_MAX)
+        return null;
+    return {
+        id: t.id,
+        name: t.name,
+        tmuxConf: t.tmuxConf,
+        itermProfileJson: t.itermProfileJson,
+    };
+}
+export function validateProviderTest(s) {
+    if (typeof s !== 'string') {
+        throw new ValidationError('provider', 'must be a string');
+    }
+    if (!(s in PROVIDER_TEST_PROFILES)) {
+        throw new ValidationError('provider', `not in test allowlist (${Object.keys(PROVIDER_TEST_PROFILES).join(', ')})`);
+    }
+    return s;
+}
+export function extractTerminalTheme(rawPayload) {
+    if (!rawPayload || typeof rawPayload !== 'object')
+        return null;
+    const p = rawPayload;
+    return validateTerminalTheme(p.terminalTheme);
+}
+export function validatePayload(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new ValidationError('payload', 'must be an object');
+    }
+    const p = raw;
+    const template = p.template;
+    if (typeof template !== 'string') {
+        throw new ValidationError('template', 'must be a string');
+    }
+    switch (template) {
+        case 'diagnostic': {
+            return {
+                template: 'diagnostic',
+                activationId: validateActivationId(p.activationId),
+                repoPath: validateRepoPath(p.repoPath, { allowEmpty: true }),
+            };
+        }
+        case 'provider-test': {
+            return {
+                template: 'provider-test',
+                provider: validateProviderTest(p.provider),
+                activationId: validateActivationId(p.activationId),
+                repoPath: validateRepoPath(p.repoPath, { allowEmpty: true }),
+            };
+        }
+        case 'real': {
+            return {
+                template: 'real',
+                provider: validateProvider(p.provider),
+                activationId: validateActivationId(p.activationId),
+                repoPath: validateRepoPath(p.repoPath),
+                storyTitle: validateStoryTitle(p.storyTitle),
+                agentsMd: validateAgentsMd(p.agentsMd),
+                perStoryOverride: p.perStoryOverride === true || p.perStoryOverride === false
+                    ? p.perStoryOverride
+                    : undefined,
+            };
+        }
+        default: {
+            throw new ValidationError('template', `must be one of: diagnostic, provider-test, real (got ${JSON.stringify(template)})`);
+        }
+    }
+}