@supatest/cli 0.0.4 → 0.0.5

package/dist/ui/utils/markdown.js

@@ -0,0 +1,376 @@
+/**
+ * Markdown rendering for terminal UI
+ * Custom implementation with improved table rendering, code block syntax highlighting,
+ * and full theme integration
+ */
+import chalk from "chalk";
+import { Box, Text } from "ink";
+import { all, createLowlight } from "lowlight";
+import React, { useMemo } from "react";
+import { theme } from "./theme.js";
+const lowlight = createLowlight(all);
+/**
+ * Parse markdown and extract tables, code blocks, and text sections
+ */
+function parseMarkdownSections(text) {
+    const sections = [];
+    const lines = text.split(/\r?\n/);
+    let currentTextSection = "";
+    let inCodeBlock = false;
+    let codeBlockLanguage = "";
+    let codeBlockLines = [];
+    let inTable = false;
+    let tableRows = [];
+    const flushTextSection = () => {
+        if (currentTextSection.trim()) {
+            sections.push({
+                type: "text",
+                content: currentTextSection.trim(),
+            });
+            currentTextSection = "";
+        }
+    };
+    const flushCodeBlock = () => {
+        if (codeBlockLines.length > 0) {
+            flushTextSection();
+            sections.push({
+                type: "code",
+                content: codeBlockLines.join("\n"),
+                codeLanguage: codeBlockLanguage,
+            });
+            codeBlockLines = [];
+            codeBlockLanguage = "";
+        }
+    };
+    const flushTable = () => {
+        if (tableRows.length > 0) {
+            flushTextSection();
+            sections.push({
+                type: "table",
+                content: "",
+                tableRows: [...tableRows],
+            });
+            tableRows = [];
+        }
+    };
+    for (const line of lines) {
+        // Code fence detection
+        const codeFenceMatch = line.match(/^```(\w*)/);
+        if (codeFenceMatch) {
+            if (!inCodeBlock) {
+                flushTextSection();
+                flushTable();
+                inCodeBlock = true;
+                codeBlockLanguage = codeFenceMatch[1] || "";
+            }
+            else {
+                inCodeBlock = false;
+                flushCodeBlock();
+            }
+            continue;
+        }
+        // Inside code block
+        if (inCodeBlock) {
+            codeBlockLines.push(line);
+            continue;
+        }
+        // Table detection
+        const trimmedLine = line.trim();
+        const isTableRow = trimmedLine.match(/^\|.+\|$/);
+        const isTableSeparator = trimmedLine.match(/^\|[\s\-:]+\|$/) && trimmedLine.includes("-");
+        if (isTableRow || isTableSeparator) {
+            if (!inTable) {
+                flushTextSection();
+                inTable = true;
+            }
+            // Skip separator rows
+            if (!isTableSeparator) {
+                tableRows.push(line);
+            }
+            continue;
+        }
+        // End of table
+        if (inTable) {
+            flushTable();
+            inTable = false;
+        }
+        // Regular text
+        if (currentTextSection) {
+            currentTextSection += "\n" + line;
+        }
+        else {
+            currentTextSection = line;
+        }
+    }
+    // Flush any remaining sections
+    if (inCodeBlock) {
+        flushCodeBlock();
+    }
+    if (inTable) {
+        flushTable();
+    }
+    flushTextSection();
+    return sections;
+}
+/**
+ * Parse and render markdown text for terminal display
+ */
+export const MarkdownDisplay = ({ text, isPending = false, terminalWidth = 80, }) => {
+    const sections = useMemo(() => parseMarkdownSections(text), [text]);
+    const elements = sections.map((section, index) => {
+        if (section.type === "table" && section.tableRows) {
+            return (React.createElement(Table, { key: `table-${index}`, rows: section.tableRows }));
+        }
+        if (section.type === "code") {
+            return (React.createElement(CodeBlock, { code: section.content, key: `code-${index}`, language: section.codeLanguage || "" }));
+        }
+        // Render text sections with custom markdown parser
+        return (React.createElement(TextSection, { content: section.content, key: `text-${index}` }));
+    });
+    // Add cursor for pending state
+    if (isPending) {
+        elements.push(React.createElement(Text, { color: theme.text.accent, key: "cursor" }, "\u258A"));
+    }
+    return React.createElement(Box, { flexDirection: "column" }, elements);
+};
+/**
+ * Render text section with markdown formatting
+ */
+const TextSection = ({ content }) => {
+    const lines = content.split(/\r?\n/);
+    const elements = [];
+    let lineIndex = 0;
+    for (const line of lines) {
+        lineIndex++;
+        // Header detection (# H1, ## H2, etc.)
+        const headerMatch = line.match(/^(#{1,6})\s+(.+)/);
+        if (headerMatch) {
+            const level = headerMatch[1].length;
+            const content = headerMatch[2];
+            elements.push(React.createElement(Header, { content: content, key: `header-${lineIndex}`, level: level }));
+            continue;
+        }
+        // List item detection (- item or * item or 1. item)
+        const listMatch = line.match(/^(\s*)([-*]|\d+\.)\s+(.+)/);
+        if (listMatch) {
+            const indent = listMatch[1].length;
+            const marker = listMatch[2];
+            const content = listMatch[3];
+            elements.push(React.createElement(ListItem, { content: content, indent: indent, key: `list-${lineIndex}`, marker: marker }));
+            continue;
+        }
+        // Horizontal rule
+        if (line.match(/^-{3,}$/)) {
+            elements.push(React.createElement(HorizontalRule, { key: `hr-${lineIndex}` }));
+            continue;
+        }
+        // Regular paragraph with inline formatting
+        if (line.trim()) {
+            elements.push(React.createElement(Paragraph, { content: line, key: `para-${lineIndex}` }));
+        }
+        else {
+            // Empty line
+            elements.push(React.createElement(Text, { key: `empty-${lineIndex}` }, "\n"));
+        }
+    }
+    return React.createElement(Box, { flexDirection: "column" }, elements);
+};
+/**
+ * Render a header (h1-h6)
+ */
+const Header = ({ level, content, }) => {
+    const colors = [
+        theme.text.accent, // H1
+        theme.text.accent, // H2
+        theme.text.primary, // H3
+        theme.text.secondary, // H4
+        theme.text.secondary, // H5
+        theme.text.dim, // H6
+    ];
+    const color = colors[level - 1] || theme.text.primary;
+    const bold = level <= 2;
+    return (React.createElement(Text, { bold: bold, color: color },
+        content,
+        "\n"));
+};
+/**
+ * Render a list item
+ */
+const ListItem = ({ indent, marker, content }) => {
+    const formattedContent = formatInline(content);
+    const indentStr = " ".repeat(indent);
+    return (React.createElement(Text, null,
+        indentStr,
+        React.createElement(Text, { color: theme.text.accent }, marker),
+        " ",
+        formattedContent,
+        "\n"));
+};
+/**
+ * Render a horizontal rule
+ */
+const HorizontalRule = () => {
+    return (React.createElement(Text, { color: theme.border.default },
+        "─".repeat(60),
+        "\n"));
+};
+/**
+ * Render a paragraph with inline formatting
+ */
+const Paragraph = ({ content }) => {
+    const formattedContent = formatInline(content);
+    return (React.createElement(Text, null,
+        formattedContent,
+        "\n"));
+};
+/**
+ * Format inline markdown (bold, italic, inline code, links)
+ */
+function formatInline(text) {
+    let result = text;
+    // Inline code: `code`
+    result = result.replace(/`([^`]+)`/g, (_, code) => {
+        return chalk.cyan(code);
+    });
+    // Bold: **text** or __text__
+    result = result.replace(/(\*\*|__)([^*_]+)\1/g, (_, __, text) => {
+        return chalk.bold(text);
+    });
+    // Italic: *text* or _text_ (but not **, __, or inside words)
+    result = result.replace(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g, (_, text) => {
+        return chalk.italic(text);
+    });
+    // Links: [text](url) - show as underlined cyan text
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text) => {
+        return chalk.cyan.underline(text);
+    });
+    return result;
+}
+/**
+ * Render a markdown table with improved formatting
+ */
+const Table = ({ rows }) => {
+    if (rows.length === 0) {
+        return null;
+    }
+    // Parse all rows to extract cells
+    const parsedRows = rows.map((row) => {
+        const cells = row
+            .trim()
+            .replace(/^\||\|$/g, "")
+            .split("|")
+            .map((cell) => cell.trim());
+        return cells;
+    });
+    if (parsedRows.length === 0) {
+        return null;
+    }
+    // Determine column widths (calculate based on actual content length)
+    const numColumns = parsedRows[0]?.length || 0;
+    const columnWidths = [];
+    for (let col = 0; col < numColumns; col++) {
+        let maxWidth = 0;
+        for (const row of parsedRows) {
+            const cellContent = row[col] || "";
+            // Strip ANSI codes for width calculation
+            const plainText = cellContent.replace(/\u001b\[[0-9;]*m/g, "");
+            const width = plainText.length;
+            maxWidth = Math.max(maxWidth, width);
+        }
+        columnWidths.push(Math.max(maxWidth, 3)); // Minimum width of 3
+    }
+    // Build formatted table as text with better visual separation
+    const tableLines = [];
+    // Header row (first row)
+    if (parsedRows.length > 0) {
+        const headerRow = parsedRows[0];
+        const headerCells = headerRow.map((cell, colIndex) => {
+            const formatted = formatInline(cell);
+            const width = columnWidths[colIndex] || 10;
+            return formatted.padEnd(width);
+        });
+        tableLines.push(chalk.hex(theme.text.accent).bold(headerCells.join(" │ ")));
+        // Separator line with better visual design
+        const separator = columnWidths
+            .map((width) => "─".repeat(width))
+            .join("─┼─");
+        tableLines.push(chalk.hex(theme.border.default)(separator));
+        // Data rows
+        for (let rowIndex = 1; rowIndex < parsedRows.length; rowIndex++) {
+            const row = parsedRows[rowIndex];
+            const cells = row.map((cell, colIndex) => {
+                const formatted = formatInline(cell);
+                const width = columnWidths[colIndex] || 10;
+                return formatted.padEnd(width);
+            });
+            tableLines.push(cells.join(" │ "));
+        }
+    }
+    return (React.createElement(Text, null,
+        tableLines.join("\n"),
+        "\n"));
+};
+/**
+ * Code block with syntax highlighting
+ */
+const CodeBlock = ({ code, language, }) => {
+    // Try to highlight if language is specified
+    let highlighted = code;
+    if (language) {
+        try {
+            const result = lowlight.highlight(language, code);
+            highlighted = highlightTreeToString(result);
+        }
+        catch (error) {
+            // Language not supported, use plain text
+            highlighted = code;
+        }
+    }
+    return (React.createElement(Box, { borderColor: theme.border.default, borderStyle: "round", flexDirection: "column", marginY: 0, paddingX: 1 },
+        language && (React.createElement(Text, { color: theme.text.dim },
+            language,
+            "\n")),
+        React.createElement(Text, null, highlighted)));
+};
+/**
+ * Convert lowlight AST to colored string
+ */
+function highlightTreeToString(node) {
+    if (node.type === "text") {
+        return node.value;
+    }
+    if (node.type === "element") {
+        const className = node.properties?.className?.[0] || "";
+        let content = "";
+        if (node.children) {
+            content = node.children.map(highlightTreeToString).join("");
+        }
+        // Map token types to colors
+        if (className.includes("keyword")) {
+            return chalk.magenta(content);
+        }
+        if (className.includes("string")) {
+            return chalk.green(content);
+        }
+        if (className.includes("comment")) {
+            return chalk.gray(content);
+        }
+        if (className.includes("function")) {
+            return chalk.blue(content);
+        }
+        if (className.includes("number")) {
+            return chalk.cyan(content);
+        }
+        if (className.includes("operator")) {
+            return chalk.yellow(content);
+        }
+        if (className.includes("class-name") || className.includes("type")) {
+            return chalk.yellow(content);
+        }
+        return content;
+    }
+    if (Array.isArray(node)) {
+        return node.map(highlightTreeToString).join("");
+    }
+    return "";
+}

package/dist/ui/utils/mouse.js

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { writeToStdout } from '../../utils/stdio';
+import { couldBeMouseSequence as inputCouldBeMouseSequence, SGR_EVENT_PREFIX, SGR_MOUSE_REGEX, X11_EVENT_PREFIX, X11_MOUSE_REGEX, } from './input';
+export function getMouseEventName(buttonCode, isRelease) {
+    const isMove = (buttonCode & 32) !== 0;
+    if (buttonCode === 66) {
+        return 'scroll-left';
+    }
+    else if (buttonCode === 67) {
+        return 'scroll-right';
+    }
+    else if ((buttonCode & 64) === 64) {
+        if ((buttonCode & 1) === 0) {
+            return 'scroll-up';
+        }
+        else {
+            return 'scroll-down';
+        }
+    }
+    else if (isMove) {
+        return 'move';
+    }
+    else {
+        const button = buttonCode & 3;
+        const type = isRelease ? 'release' : 'press';
+        switch (button) {
+            case 0:
+                return `left-${type}`;
+            case 1:
+                return `middle-${type}`;
+            case 2:
+                return `right-${type}`;
+            default:
+                return null;
+        }
+    }
+}
+function getButtonFromCode(code) {
+    const button = code & 3;
+    switch (button) {
+        case 0:
+            return 'left';
+        case 1:
+            return 'middle';
+        case 2:
+            return 'right';
+        default:
+            return 'none';
+    }
+}
+export function parseSGRMouseEvent(buffer) {
+    const match = buffer.match(SGR_MOUSE_REGEX);
+    if (match) {
+        const buttonCode = parseInt(match[1], 10);
+        const col = parseInt(match[2], 10);
+        const row = parseInt(match[3], 10);
+        const action = match[4];
+        const isRelease = action === 'm';
+        const shift = (buttonCode & 4) !== 0;
+        const meta = (buttonCode & 8) !== 0;
+        const ctrl = (buttonCode & 16) !== 0;
+        const name = getMouseEventName(buttonCode, isRelease);
+        if (name) {
+            return {
+                event: {
+                    name,
+                    ctrl,
+                    meta,
+                    shift,
+                    col,
+                    row,
+                    button: getButtonFromCode(buttonCode),
+                },
+                length: match[0].length,
+            };
+        }
+        return null;
+    }
+    return null;
+}
+export function parseX11MouseEvent(buffer) {
+    const match = buffer.match(X11_MOUSE_REGEX);
+    if (!match)
+        return null;
+    // The 3 bytes are in match[1]
+    const b = match[1].charCodeAt(0) - 32;
+    const col = match[1].charCodeAt(1) - 32;
+    const row = match[1].charCodeAt(2) - 32;
+    const shift = (b & 4) !== 0;
+    const meta = (b & 8) !== 0;
+    const ctrl = (b & 16) !== 0;
+    const isMove = (b & 32) !== 0;
+    const isWheel = (b & 64) !== 0;
+    let name = null;
+    if (isWheel) {
+        const button = b & 3;
+        switch (button) {
+            case 0:
+                name = 'scroll-up';
+                break;
+            case 1:
+                name = 'scroll-down';
+                break;
+            default:
+                break;
+        }
+    }
+    else if (isMove) {
+        name = 'move';
+    }
+    else {
+        const button = b & 3;
+        if (button === 3) {
+            // X11 reports 'release' (3) for all button releases without specifying which one.
+            // We'll default to 'left-release' as a best-effort guess if we don't track state.
+            name = 'left-release';
+        }
+        else {
+            switch (button) {
+                case 0:
+                    name = 'left-press';
+                    break;
+                case 1:
+                    name = 'middle-press';
+                    break;
+                case 2:
+                    name = 'right-press';
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    if (name) {
+        let button = getButtonFromCode(b);
+        if (name === 'left-release' && button === 'none') {
+            button = 'left';
+        }
+        return {
+            event: {
+                name,
+                ctrl,
+                meta,
+                shift,
+                col,
+                row,
+                button,
+            },
+            length: match[0].length,
+        };
+    }
+    return null;
+}
+export function parseMouseEvent(buffer) {
+    return parseSGRMouseEvent(buffer) || parseX11MouseEvent(buffer);
+}
+export function isIncompleteMouseSequence(buffer) {
+    if (!inputCouldBeMouseSequence(buffer))
+        return false;
+    // If it matches a complete sequence, it's not incomplete.
+    if (parseMouseEvent(buffer))
+        return false;
+    if (buffer.startsWith(X11_EVENT_PREFIX)) {
+        // X11 needs exactly 3 bytes after prefix.
+        return buffer.length < X11_EVENT_PREFIX.length + 3;
+    }
+    if (buffer.startsWith(SGR_EVENT_PREFIX)) {
+        // SGR sequences end with 'm' or 'M'.
+        // If it doesn't have it yet, it's incomplete.
+        // Add a reasonable max length check to fail early on garbage.
+        return !/[mM]/.test(buffer) && buffer.length < 50;
+    }
+    // It's a prefix of the prefix (e.g. "ESC" or "ESC [")
+    return true;
+}
+export function enableMouseEvents() {
+    // Enable mouse tracking with SGR format
+    // ?1002h = button event tracking (clicks + drags + scroll wheel)
+    // ?1006h = SGR extended mouse mode (better coordinate handling)
+    writeToStdout('\u001b[?1002h\u001b[?1006h');
+}
+export function disableMouseEvents() {
+    // Disable mouse tracking with SGR format
+    writeToStdout('\u001b[?1006l\u001b[?1002l');
+}

package/dist/ui/utils/theme.js

@@ -0,0 +1,59 @@
+/**
+ * UI Theme for Supatest CLI
+ * Defines colors and styling for the interactive terminal UI
+ */
+export const theme = {
+    // Text colors
+    text: {
+        primary: "#FFFFFF",
+        secondary: "#A0AEC0",
+        dim: "#4A5568",
+        accent: "#38B2AC", // Cyan/teal accent
+        success: "#48BB78",
+        error: "#F56565",
+        warning: "#ED8936",
+        info: "#4299E1",
+    },
+    // Background colors (for boxed content)
+    bg: {
+        primary: "#1A202C",
+        secondary: "#2D3748",
+        accent: "#234E52",
+    },
+    // Borders
+    border: {
+        default: "#4A5568",
+        accent: "#38B2AC",
+        error: "#F56565",
+    },
+    // Tool/action colors
+    tool: {
+        read: "#4299E1", // Blue
+        write: "#48BB78", // Green
+        edit: "#ED8936", // Orange
+        bash: "#38B2AC", // Cyan
+        search: "#9F7AEA", // Purple
+        agent: "#ED64A6", // Pink
+    },
+    // Status colors
+    status: {
+        pending: "#A0AEC0",
+        inProgress: "#ED8936",
+        completed: "#48BB78",
+        failed: "#F56565",
+    },
+};
+/**
+ * Get color value by path (e.g., 'text.primary', 'tool.read')
+ */
+export function getThemeColor(path) {
+    const parts = path.split(".");
+    let current = theme;
+    for (const part of parts) {
+        if (current[part] === undefined) {
+            return theme.text.primary;
+        }
+        current = current[part];
+    }
+    return typeof current === "string" ? current : theme.text.primary;
+}

package/dist/utils/banner.js

@@ -0,0 +1,9 @@
+export function getBanner() {
+    const banner = `███████╗██╗   ██╗██████╗  █████╗ ████████╗███████╗███████╗████████╗
+██╔════╝██║   ██║██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝
+███████╗██║   ██║██████╔╝███████║   ██║   █████╗  ███████╗   ██║
+╚════██║██║   ██║██╔═══╝ ██╔══██║   ██║   ██╔══╝  ╚════██║   ██║
+███████║╚██████╔╝██║     ██║  ██║   ██║   ███████╗███████║   ██║
+╚══════╝ ╚═════╝ ╚═╝     ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝   ╚═╝`;
+    return banner;
+}

package/dist/utils/encryption.js

@@ -0,0 +1,71 @@
+/**
+ * Token encryption utilities using AES-256-GCM with machine-specific key derivation.
+ * Inspired by Gemini CLI's file-token-storage implementation.
+ */
+import crypto from "node:crypto";
+import { hostname, userInfo } from "node:os";
+const ALGORITHM = "aes-256-gcm";
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+/**
+ * Derive an encryption key from machine-specific identifiers.
+ * Uses scrypt for key derivation with a salt based on hostname and username.
+ * This means tokens encrypted on one machine cannot be decrypted on another.
+ */
+function deriveEncryptionKey() {
+    const salt = `${hostname()}-${userInfo().username}-supatest-cli`;
+    return crypto.scryptSync("supatest-cli-token", salt, KEY_LENGTH);
+}
+// Cache the derived key for performance
+let cachedKey = null;
+function getEncryptionKey() {
+    if (!cachedKey) {
+        cachedKey = deriveEncryptionKey();
+    }
+    return cachedKey;
+}
+/**
+ * Encrypt plaintext using AES-256-GCM with a machine-derived key.
+ * Returns a colon-separated string: iv:authTag:ciphertext (all hex encoded)
+ */
+export function encrypt(plaintext) {
+    const key = getEncryptionKey();
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(plaintext, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag();
+    return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+/**
+ * Decrypt ciphertext that was encrypted with the encrypt() function.
+ * Expects format: iv:authTag:ciphertext (all hex encoded)
+ */
+export function decrypt(encryptedData) {
+    const parts = encryptedData.split(":");
+    if (parts.length !== 3) {
+        throw new Error("Invalid encrypted data format");
+    }
+    const [ivHex, authTagHex, encrypted] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const key = getEncryptionKey();
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}
+/**
+ * Check if a string appears to be in the encrypted format.
+ * Encrypted format has 3 hex segments separated by colons.
+ */
+export function isEncrypted(data) {
+    const parts = data.split(":");
+    if (parts.length !== 3) {
+        return false;
+    }
+    // Check each part looks like valid hex
+    const hexRegex = /^[0-9a-fA-F]+$/;
+    return parts.every((p) => p.length > 0 && hexRegex.test(p));
+}