@supatest/cli 0.0.3 → 0.0.4

package/dist/utils/rich-logger.js

@@ -1,208 +0,0 @@
-import boxen from "boxen";
-import chalk from "chalk";
-import { highlight } from "cli-highlight";
-/**
- * Rich logger optimized for CI/CD environments
- * Provides structured, timestamped, grep-able output
- */
-export class RichLogger {
-    startTime = Date.now();
-    verbose = false;
-    setVerbose(enabled) {
-        this.verbose = enabled;
-    }
-    timestamp() {
-        const now = new Date();
-        return chalk.gray(`[${now.toISOString()}]`);
-    }
-    elapsed() {
-        const ms = Date.now() - this.startTime;
-        const seconds = (ms / 1000).toFixed(1);
-        return chalk.dim(`(+${seconds}s)`);
-    }
-    /** Print major section header */
-    section(title) {
-        console.log("");
-        console.log(chalk.bold.cyan("═".repeat(60)));
-        console.log(chalk.bold.cyan(` ${title}`));
-        console.log(chalk.bold.cyan("═".repeat(60)));
-    }
-    /** Print subsection divider */
-    subsection(title) {
-        console.log("");
-        console.log(chalk.cyan("─".repeat(60)));
-        console.log(chalk.cyan(` ${title}`));
-        console.log(chalk.cyan("─".repeat(60)));
-    }
-    /** Agent task started */
-    taskStart(task, model, maxIterations) {
-        this.startTime = Date.now();
-        this.section("Supatest AI Agent - Task Started");
-        console.log(`${this.timestamp()} ${chalk.bold("Task:")} ${task}`);
-        if (model) {
-            console.log(`${this.timestamp()} ${chalk.bold("Model:")} ${model}`);
-        }
-        if (maxIterations) {
-            console.log(`${this.timestamp()} ${chalk.bold("Max Iterations:")} ${maxIterations}`);
-        }
-        console.log(`${this.timestamp()} ${chalk.bold("Started:")} ${new Date().toISOString()}`);
-    }
-    /** Start of iteration */
-    iteration(current, total) {
-        this.subsection(`Iteration ${current}/${total}`);
-    }
-    /** Agent thinking/response text */
-    agentText(text) {
-        console.log(`${this.timestamp()} ${chalk.blue("🤖 Agent:")} ${text}`);
-    }
-    /** Tool call started */
-    toolCall(toolName, input, verbose = false) {
-        console.log("");
-        console.log(`${this.timestamp()} ${chalk.yellow("🔧 Tool Call:")} ${chalk.bold(toolName)}`);
-        if (verbose || this.verbose) {
-            // Show formatted input
-            const inputStr = JSON.stringify(input, null, 2);
-            console.log(chalk.dim(boxen(inputStr, {
-                padding: 0,
-                margin: { left: 11 },
-                borderStyle: "round",
-                borderColor: "gray",
-                title: "Input",
-                titleAlignment: "left",
-            })));
-        }
-        else {
-            // Show compact input
-            for (const [key, value] of Object.entries(input)) {
-                console.log(`${" ".repeat(11)} ${chalk.dim(key + ":")} ${String(value).substring(0, 80)}`);
-            }
-        }
-    }
-    /** Tool call completed successfully */
-    toolSuccess(toolName, duration) {
-        const durationStr = duration ? chalk.dim(` (${duration.toFixed(2)}s)`) : "";
-        console.log(`${this.timestamp()} ${chalk.green("✓")} ${chalk.bold(toolName)} completed${durationStr}`);
-    }
-    /** Tool call failed */
-    toolError(toolName, error) {
-        console.log(`${this.timestamp()} ${chalk.red("✗")} ${chalk.bold(toolName)} failed`);
-        console.log(chalk.red(boxen(error, {
-            padding: { left: 1, right: 1 },
-            margin: { left: 11 },
-            borderStyle: "round",
-            borderColor: "red",
-            title: "Error",
-        })));
-    }
-    /** Show tool output (file contents, command output, etc) */
-    toolOutput(content, language) {
-        // Limit output length for readability
-        const maxLength = this.verbose ? 5000 : 500;
-        const truncated = content.length > maxLength;
-        const displayContent = truncated
-            ? content.substring(0, maxLength) + "\n... (truncated)"
-            : content;
-        try {
-            // Try syntax highlighting
-            const highlighted = language && displayContent.length < 2000
-                ? highlight(displayContent, { language })
-                : displayContent;
-            console.log(boxen(highlighted, {
-                padding: { left: 1, right: 1 },
-                margin: { left: 11 },
-                borderStyle: "round",
-                borderColor: "gray",
-                title: language ? `Output (${language})` : "Output",
-            }));
-        }
-        catch {
-            // Fallback to plain output if highlighting fails
-            console.log(boxen(displayContent, {
-                padding: { left: 1, right: 1 },
-                margin: { left: 11 },
-                borderStyle: "round",
-                borderColor: "gray",
-                title: "Output",
-            }));
-        }
-    }
-    /** Show bash command being executed */
-    bashCommand(command) {
-        console.log(`${this.timestamp()} ${chalk.yellow("🔧 Running:")} ${chalk.bold(command)}`);
-    }
-    /** Show bash command output */
-    bashOutput(output) {
-        if (output.trim()) {
-            this.toolOutput(output, "bash");
-        }
-    }
-    /** File being read */
-    fileRead(path) {
-        console.log(`${this.timestamp()} ${chalk.blue("📖 Reading:")} ${chalk.underline(path)}`);
-    }
-    /** File being written */
-    fileWrite(path) {
-        console.log(`${this.timestamp()} ${chalk.green("✏️  Writing:")} ${chalk.underline(path)}`);
-    }
-    /** General info message */
-    info(message) {
-        console.log(`${this.timestamp()} ${chalk.blue("ℹ")} ${message}`);
-    }
-    /** Success message */
-    success(message) {
-        console.log(`${this.timestamp()} ${chalk.green("✓")} ${message}`);
-    }
-    /** Error message */
-    error(message) {
-        console.log(`${this.timestamp()} ${chalk.red("✗")} ${message}`);
-    }
-    /** Warning message */
-    warn(message) {
-        console.log(`${this.timestamp()} ${chalk.yellow("⚠")} ${message}`);
-    }
-    /** Debug message (only shown in verbose mode) */
-    debug(message) {
-        if (this.verbose) {
-            console.log(`${this.timestamp()} ${chalk.gray("→")} ${message}`);
-        }
-    }
-    /** Final summary */
-    summary(data) {
-        this.section("Summary");
-        const status = data.success
-            ? chalk.green("✓ Success")
-            : chalk.red("✗ Failed");
-        console.log(`${this.timestamp()} ${chalk.bold("Status:")} ${status}`);
-        console.log(`${this.timestamp()} ${chalk.bold("Duration:")} ${(data.duration / 1000).toFixed(1)}s`);
-        console.log(`${this.timestamp()} ${chalk.bold("Iterations:")} ${data.iterations}`);
-        if (data.filesModified.length > 0) {
-            console.log("");
-            console.log(`${this.timestamp()} ${chalk.bold("Files Modified:")}`);
-            for (const file of data.filesModified) {
-                console.log(`${" ".repeat(11)} ${chalk.cyan("→")} ${file}`);
-            }
-        }
-        if (data.commandsRun.length > 0) {
-            console.log("");
-            console.log(`${this.timestamp()} ${chalk.bold("Commands Executed:")}`);
-            for (const cmd of data.commandsRun) {
-                console.log(`${" ".repeat(11)} ${chalk.gray("$")} ${cmd}`);
-            }
-        }
-        if (data.errors && data.errors.length > 0) {
-            console.log("");
-            console.log(`${this.timestamp()} ${chalk.bold.red("Errors Encountered:")}`);
-            for (const error of data.errors) {
-                console.log(`${" ".repeat(11)} ${chalk.red("✗")} ${error}`);
-            }
-        }
-        console.log(chalk.cyan("═".repeat(60)));
-        console.log("");
-    }
-    /** Raw output without formatting */
-    raw(text) {
-        console.log(text);
-    }
-}
-// Export singleton instance
-export const richLogger = new RichLogger();

package/dist/utils/stdin.js

@@ -1,25 +0,0 @@
-export async function readStdin() {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        // Check if stdin is connected (not a TTY)
-        if (process.stdin.isTTY) {
-            resolve("");
-            return;
-        }
-        process.stdin.on("data", (chunk) => {
-            chunks.push(chunk);
-        });
-        process.stdin.on("end", () => {
-            resolve(Buffer.concat(chunks).toString("utf-8"));
-        });
-        process.stdin.on("error", (error) => {
-            reject(error);
-        });
-        // Set a timeout to avoid hanging
-        setTimeout(() => {
-            if (chunks.length === 0) {
-                resolve("");
-            }
-        }, 100);
-    });
-}

package/dist/utils/stdio.js

@@ -1,80 +0,0 @@
-/**
- * Stdio utilities for writing to stdout/stderr
- * Based on Gemini CLI's stdio handling
- */
-// Capture the original stdout and stderr write methods before any monkey patching occurs.
-const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-const originalStderrWrite = process.stderr.write.bind(process.stderr);
-/**
- * Writes to the real stdout, bypassing any monkey patching on process.stdout.write.
- */
-export function writeToStdout(...args) {
-    return originalStdoutWrite(...args);
-}
-/**
- * Writes to the real stderr, bypassing any monkey patching on process.stderr.write.
- */
-export function writeToStderr(...args) {
-    return originalStderrWrite(...args);
-}
-/**
- * Monkey patches process.stdout.write and process.stderr.write to suppress output.
- * This prevents stray output from libraries (or the app itself) from corrupting the UI.
- * Returns a cleanup function that restores the original write methods.
- */
-export function patchStdio() {
-    const previousStdoutWrite = process.stdout.write;
-    const previousStderrWrite = process.stderr.write;
-    process.stdout.write = (chunk, encodingOrCb, cb) => {
-        // Suppress the output (don't write it anywhere)
-        const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
-        if (callback) {
-            callback();
-        }
-        return true;
-    };
-    process.stderr.write = (chunk, encodingOrCb, cb) => {
-        // Suppress the output (don't write it anywhere)
-        const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
-        if (callback) {
-            callback();
-        }
-        return true;
-    };
-    return () => {
-        process.stdout.write = previousStdoutWrite;
-        process.stderr.write = previousStderrWrite;
-    };
-}
-/**
- * Creates proxies for process.stdout and process.stderr that use the real write methods
- * (writeToStdout and writeToStderr) bypassing any monkey patching.
- * This is used by Ink to render to the real output.
- */
-export function createInkStdio() {
-    const inkStdout = new Proxy(process.stdout, {
-        get(target, prop, receiver) {
-            if (prop === 'write') {
-                return writeToStdout;
-            }
-            const value = Reflect.get(target, prop, receiver);
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        },
-    });
-    const inkStderr = new Proxy(process.stderr, {
-        get(target, prop, receiver) {
-            if (prop === 'write') {
-                return writeToStderr;
-            }
-            const value = Reflect.get(target, prop, receiver);
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        },
-    });
-    return { stdout: inkStdout, stderr: inkStderr };
-}

package/dist/utils/summary.js

@@ -1,94 +0,0 @@
-import chalk from "chalk";
-export function generateSummary(stats, result, verbose = false) {
-    const duration = stats.endTime
-        ? ((stats.endTime - stats.startTime) / 1000).toFixed(2)
-        : "N/A";
-    const lines = [];
-    lines.push("");
-    lines.push(chalk.bold.cyan("AGENT EXECUTION SUMMARY"));
-    lines.push(chalk.gray("─".repeat(60)));
-    lines.push("");
-    // Status with colored indicator
-    const statusIcon = result.success ? chalk.green("●") : chalk.red("●");
-    const statusText = result.success
-        ? chalk.green.bold("SUCCESS")
-        : chalk.red.bold("FAILED");
-    lines.push(statusIcon +
-        " " +
-        chalk.white.bold("Status:") +
-        " ".repeat(11) +
-        statusText);
-    // Duration with clock icon
-    lines.push(chalk.blue("◷") +
-        " " +
-        chalk.white.bold("Duration:") +
-        " ".repeat(9) +
-        chalk.white(`${duration}s`));
-    // Iterations with counter icon (verbose only)
-    if (verbose) {
-        lines.push(chalk.cyan("🔄") +
-            " " +
-            chalk.white.bold("Iterations:") +
-            " ".repeat(7) +
-            chalk.white(`${stats.iterations}`));
-    }
-    // Files modified section
-    if (stats.filesModified.size > 0) {
-        lines.push("");
-        lines.push(chalk.green("📝") +
-            " " +
-            chalk.white.bold(`Files Modified (${stats.filesModified.size})`));
-        let count = 0;
-        for (const file of stats.filesModified) {
-            if (count >= 5) {
-                const remaining = stats.filesModified.size - 5;
-                lines.push(chalk.gray(`   ... and ${remaining} more`));
-                break;
-            }
-            lines.push(chalk.yellow("  →") + " " + chalk.white(file));
-            count++;
-        }
-    }
-    // Commands executed section (verbose only)
-    if (verbose && stats.commandsRun.length > 0) {
-        lines.push("");
-        lines.push(chalk.cyan("🔨") +
-            " " +
-            chalk.white.bold(`Commands Executed (${stats.commandsRun.length})`));
-        let count = 0;
-        for (const cmd of stats.commandsRun) {
-            if (count >= 3) {
-                const remaining = stats.commandsRun.length - 3;
-                lines.push(chalk.gray(`   ... and ${remaining} more`));
-                break;
-            }
-            lines.push(chalk.gray("  $") + " " + chalk.white(cmd));
-            count++;
-        }
-    }
-    // Errors section
-    if (stats.errors.length > 0) {
-        lines.push("");
-        lines.push(chalk.red("❌") +
-            " " +
-            chalk.red.bold(`Errors Encountered (${stats.errors.length})`));
-        for (const error of stats.errors.slice(0, 3)) {
-            lines.push(chalk.red("  ✗") + " " + chalk.white(error));
-        }
-    }
-    // Summary section (agent's output already includes its own header)
-    if (result.summary && result.summary.trim()) {
-        lines.push("");
-        // Split summary into lines
-        const summaryLines = result.summary.split("\n");
-        let lineCount = 0;
-        for (const line of summaryLines) {
-            // Removed truncation limit to show full summary
-            lines.push(line);
-        }
-    }
-    lines.push("");
-    lines.push(chalk.gray("─".repeat(60)));
-    lines.push("");
-    return lines.join("\n");
-}

package/dist/utils/token-storage.js

@@ -1,242 +0,0 @@
-/**
- * CLI token storage with encryption and keychain support.
- * Inspired by Gemini CLI's hybrid-token-storage pattern.
- *
- * Storage priority:
- * 1. OS Keychain (if available)
- * 2. Encrypted file (~/.supatest/token.json)
- */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { decrypt, encrypt } from "./encryption";
-import { isKeychainAvailable, loadFromKeychain, removeFromKeychain, saveToKeychain, } from "./keychain-storage";
-const CONFIG_DIR = join(homedir(), ".supatest");
-const TOKEN_FILE = join(CONFIG_DIR, "token.json");
-const STORAGE_VERSION = 2;
-export { CONFIG_DIR, TOKEN_FILE };
-export var StorageType;
-(function (StorageType) {
-    StorageType["KEYCHAIN"] = "keychain";
-    StorageType["ENCRYPTED_FILE"] = "encrypted_file";
-})(StorageType || (StorageType = {}));
-// Track which storage is being used
-let activeStorageType = null;
-let storageInitPromise = null;
-function isV2Format(stored) {
-    return "version" in stored && stored.version === 2;
-}
-/**
- * Ensure the config directory exists
- */
-function ensureConfigDir() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    }
-}
-/**
- * Initialize storage and determine which backend to use.
- * Uses a singleton promise to avoid race conditions.
- */
-async function initializeStorage() {
-    if (await isKeychainAvailable()) {
-        activeStorageType = StorageType.KEYCHAIN;
-    }
-    else {
-        activeStorageType = StorageType.ENCRYPTED_FILE;
-    }
-    return activeStorageType;
-}
-async function getStorageType() {
-    if (activeStorageType !== null) {
-        return activeStorageType;
-    }
-    if (!storageInitPromise) {
-        storageInitPromise = initializeStorage();
-    }
-    return storageInitPromise;
-}
-// ============================================================================
-// File-based storage (encrypted)
-// ============================================================================
-/**
- * Save CLI token to encrypted file
- */
-function saveTokenToFile(token, expiresAt) {
-    ensureConfigDir();
-    const payload = {
-        token,
-        expiresAt,
-        createdAt: new Date().toISOString(),
-    };
-    const stored = {
-        version: STORAGE_VERSION,
-        encryptedData: encrypt(JSON.stringify(payload)),
-    };
-    writeFileSync(TOKEN_FILE, JSON.stringify(stored, null, 2), { mode: 0o600 });
-}
-/**
- * Load CLI token from file, decrypting if necessary
- */
-function loadTokenFromFile() {
-    if (!existsSync(TOKEN_FILE)) {
-        return null;
-    }
-    try {
-        const data = readFileSync(TOKEN_FILE, "utf8");
-        const stored = JSON.parse(data);
-        if (isV2Format(stored)) {
-            return JSON.parse(decrypt(stored.encryptedData));
-        }
-        // Legacy plaintext format (version 1 or no version)
-        return stored;
-    }
-    catch (error) {
-        const err = error;
-        if (err.message?.includes("Invalid encrypted data format") ||
-            err.message?.includes("Unsupported state or unable to authenticate data")) {
-            // Token file corrupted, remove it
-            try {
-                unlinkSync(TOKEN_FILE);
-            }
-            catch {
-                // Ignore
-            }
-        }
-        return null;
-    }
-}
-/**
- * Remove token file
- */
-function removeTokenFile() {
-    if (existsSync(TOKEN_FILE)) {
-        unlinkSync(TOKEN_FILE);
-    }
-}
-// ============================================================================
-// Synchronous API (file-only, for backward compatibility)
-// ============================================================================
-/**
- * Save CLI token to disk with AES-256-GCM encryption (sync, file-only)
- */
-export function saveToken(token, expiresAt) {
-    saveTokenToFile(token, expiresAt);
-}
-/**
- * Load CLI token from disk (sync, file-only)
- */
-export function loadToken() {
-    const payload = loadTokenFromFile();
-    if (!payload) {
-        return null;
-    }
-    if (payload.expiresAt) {
-        const expiresAt = new Date(payload.expiresAt);
-        if (expiresAt < new Date()) {
-            console.warn("CLI token has expired. Please run 'supatest login' again.");
-            return null;
-        }
-    }
-    return payload.token;
-}
-/**
- * Remove stored token (sync, file-only)
- */
-export function removeToken() {
-    removeTokenFile();
-}
-/**
- * Check if user is logged in (sync, file-only)
- */
-export function isLoggedIn() {
-    return loadToken() !== null;
-}
-/**
- * Get token info for display (sync, file-only)
- */
-export function getTokenInfo() {
-    const payload = loadTokenFromFile();
-    if (!payload) {
-        return null;
-    }
-    return {
-        createdAt: payload.createdAt,
-        expiresAt: payload.expiresAt,
-    };
-}
-// ============================================================================
-// Async API (hybrid: keychain with file fallback)
-// ============================================================================
-/**
- * Save CLI token using best available storage (async, hybrid)
- * Priority: Keychain > Encrypted File
- */
-export async function saveTokenAsync(token, expiresAt) {
-    const storageType = await getStorageType();
-    if (storageType === StorageType.KEYCHAIN) {
-        const saved = await saveToKeychain(token, expiresAt);
-        if (saved) {
-            // Remove file-based token if keychain succeeds
-            removeTokenFile();
-            return;
-        }
-        // Fall through to file storage if keychain save fails
-    }
-    saveTokenToFile(token, expiresAt);
-}
-/**
- * Load CLI token from best available storage (async, hybrid)
- * Priority: Keychain > Encrypted File
- */
-export async function loadTokenAsync() {
-    const storageType = await getStorageType();
-    // Try keychain first
-    if (storageType === StorageType.KEYCHAIN) {
-        const payload = await loadFromKeychain();
-        if (payload) {
-            if (payload.expiresAt && new Date(payload.expiresAt) < new Date()) {
-                console.warn("CLI token has expired. Please run 'supatest login' again.");
-                return null;
-            }
-            return payload.token;
-        }
-    }
-    // Fallback to file
-    return loadToken();
-}
-/**
- * Remove token from all storage locations (async, hybrid)
- */
-export async function removeTokenAsync() {
-    await removeFromKeychain();
-    removeTokenFile();
-}
-/**
- * Check if user is logged in (async, hybrid)
- */
-export async function isLoggedInAsync() {
-    return (await loadTokenAsync()) !== null;
-}
-/**
- * Get token info for display (async, hybrid)
- */
-export async function getTokenInfoAsync() {
-    const storageType = await getStorageType();
-    if (storageType === StorageType.KEYCHAIN) {
-        const payload = await loadFromKeychain();
-        if (payload) {
-            return {
-                createdAt: payload.createdAt,
-                expiresAt: payload.expiresAt,
-            };
-        }
-    }
-    return getTokenInfo();
-}
-/**
- * Get the currently active storage type
- */
-export async function getActiveStorageType() {
-    return getStorageType();
-}