@supatest/cli 0.0.2 → 0.0.3

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));
+}

package/dist/utils/events.js

@@ -0,0 +1,36 @@
+/**
+ * Simple event emitter for app-level events
+ */
+export var AppEvent;
+(function (AppEvent) {
+    AppEvent["PasteTimeout"] = "paste-timeout";
+    AppEvent["OpenDebugConsole"] = "open-debug-console";
+    AppEvent["SelectionWarning"] = "selection-warning";
+})(AppEvent || (AppEvent = {}));
+class EventEmitter {
+    events = new Map();
+    on(event, callback) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event).push(callback);
+    }
+    emit(event, ...args) {
+        const callbacks = this.events.get(event);
+        if (callbacks) {
+            for (const callback of callbacks) {
+                callback(...args);
+            }
+        }
+    }
+    off(event, callback) {
+        const callbacks = this.events.get(event);
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index > -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    }
+}
+export const appEvents = new EventEmitter();

package/dist/utils/keychain-storage.js

@@ -0,0 +1,120 @@
+/**
+ * OS Keychain token storage using keytar.
+ * Inspired by Gemini CLI's keychain-token-storage implementation.
+ */
+import crypto from "node:crypto";
+const SERVICE_NAME = "supatest-cli";
+const ACCOUNT_NAME = "cli-token";
+const KEYCHAIN_TEST_PREFIX = "__keychain_test__";
+let keytarModule = null;
+let keytarLoadAttempted = false;
+let keychainAvailable = null;
+/**
+ * Dynamically load the keytar module.
+ * Returns null if keytar is not available (not installed or failed to load).
+ */
+async function getKeytar() {
+    if (keytarLoadAttempted) {
+        return keytarModule;
+    }
+    keytarLoadAttempted = true;
+    try {
+        const moduleName = "keytar";
+        const mod = await import(moduleName);
+        keytarModule = mod.default || mod;
+    }
+    catch {
+        // Keytar is optional, so we silently fall back to file storage
+        keytarModule = null;
+    }
+    return keytarModule;
+}
+/**
+ * Check if OS keychain is available via a set/get/delete test cycle.
+ * Respects SUPATEST_FORCE_FILE_STORAGE environment variable.
+ */
+export async function isKeychainAvailable() {
+    if (keychainAvailable !== null) {
+        return keychainAvailable;
+    }
+    if (process.env.SUPATEST_FORCE_FILE_STORAGE === "true") {
+        keychainAvailable = false;
+        return false;
+    }
+    try {
+        const keytar = await getKeytar();
+        if (!keytar) {
+            keychainAvailable = false;
+            return false;
+        }
+        // Test with a set/get/delete cycle
+        const testAccount = `${KEYCHAIN_TEST_PREFIX}${crypto.randomBytes(8).toString("hex")}`;
+        const testPassword = "test";
+        await keytar.setPassword(SERVICE_NAME, testAccount, testPassword);
+        const retrieved = await keytar.getPassword(SERVICE_NAME, testAccount);
+        const deleted = await keytar.deletePassword(SERVICE_NAME, testAccount);
+        keychainAvailable = deleted && retrieved === testPassword;
+    }
+    catch {
+        keychainAvailable = false;
+    }
+    return keychainAvailable;
+}
+/**
+ * Save token payload to OS keychain.
+ * Returns true if successful, false otherwise.
+ */
+export async function saveToKeychain(token, expiresAt) {
+    const keytar = await getKeytar();
+    if (!keytar) {
+        return false;
+    }
+    const payload = {
+        token,
+        expiresAt,
+        createdAt: new Date().toISOString(),
+    };
+    try {
+        await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(payload));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load token payload from OS keychain.
+ * Returns null if not found or keychain unavailable.
+ */
+export async function loadFromKeychain() {
+    const keytar = await getKeytar();
+    if (!keytar) {
+        return null;
+    }
+    try {
+        const data = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+        if (!data) {
+            return null;
+        }
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove token from OS keychain.
+ * Returns true if successfully removed, false otherwise.
+ */
+export async function removeFromKeychain() {
+    const keytar = await getKeytar();
+    if (!keytar) {
+        return false;
+    }
+    try {
+        return await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/logger.js

@@ -1,63 +1,161 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import chalk from "chalk";
 class Logger {
     verbose = false;
+    silent = false;
+    logFile = null;
+    isDev = false;
     setVerbose(enabled) {
         this.verbose = enabled;
     }
+    setSilent(enabled) {
+        this.silent = enabled;
+    }
+    isSilent() {
+        return this.silent;
+    }
+    /**
+     * Enable file logging (dev mode only)
+     */
+    enableFileLogging(isDev = false) {
+        this.isDev = isDev;
+        if (!isDev)
+            return;
+        // Write directly to cli.log in current directory
+        this.logFile = path.join(process.cwd(), "cli.log");
+        // Add session separator to log file
+        const separator = `\n${"=".repeat(80)}\n[${new Date().toISOString()}] New CLI session started\n${"=".repeat(80)}\n`;
+        try {
+            fs.appendFileSync(this.logFile, separator);
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Write to log file (dev mode only)
+     */
+    writeToFile(level, message, data) {
+        if (!this.isDev || !this.logFile)
+            return;
+        const timestamp = new Date().toISOString();
+        const logEntry = data
+            ? `[${timestamp}] [${level}] ${message} ${JSON.stringify(data, null, 2)}\n`
+            : `[${timestamp}] [${level}] ${message}\n`;
+        try {
+            fs.appendFileSync(this.logFile, logEntry);
+        }
+        catch (error) {
+            // Silently fail - don't disrupt CLI operation
+        }
+    }
+    /**
+     * Check if an error message is critical and should bypass silent mode
+     * Critical errors are those that prevent the CLI from starting or executing
+     */
+    isCriticalError(message) {
+        const criticalPatterns = [
+            /api key/i,
+            /authentication/i,
+            /node.*version/i,
+            /missing.*required/i,
+            /failed to install/i,
+            /fatal/i,
+        ];
+        return criticalPatterns.some((pattern) => pattern.test(message));
+    }
     info(message) {
+        if (this.silent)
+            return;
         console.log(chalk.blue("ℹ"), message);
     }
     success(message) {
+        if (this.silent)
+            return;
         console.log(chalk.green("✓"), message);
     }
     error(message) {
+        // Allow critical errors through even in silent mode
+        if (this.silent && !this.isCriticalError(message))
+            return;
         console.error(chalk.red("✗"), message);
     }
     warn(message) {
+        if (this.silent)
+            return;
         console.warn(chalk.yellow("⚠"), message);
     }
-    debug(message) {
+    debug(message, data) {
+        this.writeToFile("DEBUG", message, data);
+        if (this.silent)
+            return;
         if (this.verbose) {
             console.log(chalk.gray("→"), message);
+            if (data) {
+                console.log(chalk.gray(JSON.stringify(data, null, 2)));
+            }
         }
     }
     section(title) {
+        if (this.silent)
+            return;
         console.log("\n" + chalk.bold.red(`━━━ ${title} ━━━`));
     }
     summary(title) {
+        if (this.silent)
+            return;
         console.log("\n" + chalk.bold.cyan(`╔═══ ${title} ═══╗`));
     }
     raw(message) {
+        if (this.silent)
+            return;
         console.log(message);
     }
     stream(chunk) {
+        if (this.silent)
+            return;
         process.stdout.write(chalk.dim(chunk));
     }
     toolRead(filePath) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.blue("📖"), chalk.dim("Reading:"), chalk.white(filePath));
     }
     toolWrite(filePath) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.green("✏️"), chalk.dim("Writing:"), chalk.white(filePath));
     }
     toolEdit(filePath) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.yellow("✏️"), chalk.dim("Editing:"), chalk.white(filePath));
     }
     toolBash(command) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.cyan("🔨"), chalk.dim("Running:"), chalk.white(command));
     }
     toolSearch(type, pattern) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.cyan("🔍"), chalk.dim(`Searching ${type}:`), chalk.white(pattern));
     }
     toolAgent(agentType) {
+        if (this.silent)
+            return;
         console.log("");
         console.log(chalk.cyan("🤖"), chalk.dim("Launching agent:"), chalk.white(agentType));
     }
     todoUpdate(todos) {
+        if (this.silent)
+            return;
         const completed = todos.filter((t) => t.status === "completed");
         const inProgress = todos.filter((t) => t.status === "in_progress");
         const pending = todos.filter((t) => t.status === "pending");
@@ -88,9 +186,13 @@ class Logger {
         }
     }
     divider() {
+        if (this.silent)
+            return;
         console.log(chalk.gray("─".repeat(60)));
     }
     box(title) {
+        if (this.silent)
+            return;
         const width = 60;
         const padding = Math.max(0, width - title.length - 2);
         const leftPad = Math.floor(padding / 2);

package/dist/utils/node-version.js

@@ -1,5 +1,5 @@
 import { execSync } from "node:child_process";
-import { logger } from "./logger.js";
+import { logger } from "./logger";
 const MINIMUM_NODE_VERSION = 18;
 /**
  * Parse a version string like "v18.17.0" or "18.17.0" into components
@@ -76,8 +76,6 @@ export function checkNodeVersion() {
         process.exit(1);
     }
     // Success - version is adequate
-    // Silent unless verbose mode is enabled
-    logger.debug(`✓ Node.js ${nodeVersion.raw} detected (meets minimum requirement of ${MINIMUM_NODE_VERSION}.0.0)`);
 }
 /**
  * Get Node.js version info for display purposes

package/dist/utils/plan-file.js

@@ -0,0 +1,75 @@
+/**
+ * Plan file utilities
+ * Handles creation and management of plan files for plan mode
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const PLAN_DIR = ".supatest/plans";
+/**
+ * Generate a unique plan file name with timestamp
+ */
+function generatePlanFileName() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `plan-${timestamp}.md`;
+}
+/**
+ * Create a new plan file in the .supatest/plans directory
+ * @param cwd - The current working directory (project root)
+ * @returns The path to the created plan file
+ */
+export async function createPlanFile(cwd) {
+    const planDir = join(cwd, PLAN_DIR);
+    // Ensure the plan directory exists
+    await mkdir(planDir, { recursive: true });
+    const planFileName = generatePlanFileName();
+    const planPath = join(planDir, planFileName);
+    // Create the initial plan file with a placeholder
+    const initialContent = `# Plan
+
+_Planning in progress..._
+
+---
+
+## Summary
+
+_To be filled by the agent_
+
+## Tasks
+
+_To be filled by the agent_
+
+## Files to Modify
+
+_To be filled by the agent_
+
+---
+
+_Generated by Supatest AI_
+`;
+    await writeFile(planPath, initialContent, "utf-8");
+    return planPath;
+}
+/**
+ * Update the contents of an existing plan file
+ * @param planPath - The path to the plan file
+ * @param content - The new content to write
+ */
+export async function updatePlanFile(planPath, content) {
+    await writeFile(planPath, content, "utf-8");
+}
+/**
+ * Read the contents of a plan file
+ * @param planPath - The path to the plan file
+ * @returns The contents of the plan file
+ */
+export async function readPlanFile(planPath) {
+    return await readFile(planPath, "utf-8");
+}
+/**
+ * Get the plan directory path for a given project
+ * @param cwd - The current working directory (project root)
+ * @returns The path to the plan directory
+ */
+export function getPlanDirectory(cwd) {
+    return join(cwd, PLAN_DIR);
+}

package/dist/utils/project-instructions.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Load project-specific instructions from SUPATEST.md
+ * Checks multiple locations in order of precedence
+ */
+export function loadProjectInstructions(cwd) {
+    const paths = [
+        join(cwd, "SUPATEST.md"),
+        join(cwd, ".supatest", "SUPATEST.md"),
+    ];
+    for (const path of paths) {
+        if (existsSync(path)) {
+            try {
+                return readFileSync(path, "utf-8");
+            }
+            catch {
+                // Skip if can't read
+            }
+        }
+    }
+    return undefined;
+}

package/dist/utils/rich-logger.js

@@ -1,5 +1,5 @@
-import chalk from "chalk";
 import boxen from "boxen";
+import chalk from "chalk";
 import { highlight } from "cli-highlight";
 /**
  * Rich logger optimized for CI/CD environments

package/dist/utils/stdio.js

@@ -0,0 +1,80 @@
+/**
+ * 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

@@ -83,12 +83,8 @@ export function generateSummary(stats, result, verbose = false) {
         const summaryLines = result.summary.split("\n");
         let lineCount = 0;
         for (const line of summaryLines) {
-            if (lineCount >= 10) {
-                lines.push(chalk.gray("... (truncated)"));
-                break;
-            }
+            // Removed truncation limit to show full summary
             lines.push(line);
-            lineCount++;
         }
     }
     lines.push("");