@runloop/rl-cli 0.1.2 → 0.3.0

package/dist/utils/logFormatter.js

@@ -0,0 +1,208 @@
+/**
+ * Shared log formatting utilities for both CLI and interactive mode
+ */
+import chalk from "chalk";
+// Source abbreviations for consistent display
+const SOURCE_CONFIG = {
+    setup_commands: { abbrev: "setup", color: "magenta" },
+    entrypoint: { abbrev: "entry", color: "cyan" },
+    exec: { abbrev: "exec", color: "green" },
+    files: { abbrev: "files", color: "yellow" },
+    stats: { abbrev: "stats", color: "gray" },
+};
+const SOURCE_WIDTH = 5;
+/**
+ * Format timestamp based on how recent the log is
+ */
+export function formatTimestamp(timestampMs) {
+    const date = new Date(timestampMs);
+    const now = new Date();
+    const isToday = date.toDateString() === now.toDateString();
+    const isThisYear = date.getFullYear() === now.getFullYear();
+    const time = date.toLocaleTimeString("en-US", {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    const ms = date.getMilliseconds().toString().padStart(3, "0");
+    if (isToday) {
+        return `${time}.${ms}`;
+    }
+    else if (isThisYear) {
+        const monthDay = date.toLocaleDateString("en-US", {
+            month: "short",
+            day: "numeric",
+        });
+        return `${monthDay} ${time}`;
+    }
+    else {
+        const fullDate = date.toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+        });
+        return `${fullDate} ${time}`;
+    }
+}
+/**
+ * Get log level info (normalized name and color)
+ */
+export function getLogLevelInfo(level) {
+    const normalized = level.toUpperCase();
+    switch (normalized) {
+        case "ERROR":
+        case "ERR":
+            return { name: "ERROR", color: "red" };
+        case "WARN":
+        case "WARNING":
+            return { name: "WARN ", color: "yellow" };
+        case "INFO":
+            return { name: "INFO ", color: "blue" };
+        case "DEBUG":
+            return { name: "DEBUG", color: "gray" };
+        default:
+            return { name: normalized.padEnd(5), color: "gray" };
+    }
+}
+/**
+ * Get source info (abbreviated name and color)
+ */
+export function getSourceInfo(source) {
+    if (!source) {
+        return { abbrev: "sys".padEnd(SOURCE_WIDTH), color: "gray" };
+    }
+    const config = SOURCE_CONFIG[source];
+    if (config) {
+        return { abbrev: config.abbrev.padEnd(SOURCE_WIDTH), color: config.color };
+    }
+    // Unknown source: truncate/pad to width
+    const abbrev = source.length > SOURCE_WIDTH
+        ? source.slice(0, SOURCE_WIDTH)
+        : source.padEnd(SOURCE_WIDTH);
+    return { abbrev, color: "white" };
+}
+/**
+ * Parse a devbox log entry into formatted parts (for use in Ink UI)
+ */
+export function parseLogEntry(log) {
+    const levelInfo = getLogLevelInfo(log.level);
+    const sourceInfo = getSourceInfo(log.source);
+    return {
+        timestamp: formatTimestamp(log.timestamp_ms),
+        level: levelInfo.name,
+        levelColor: levelInfo.color,
+        source: sourceInfo.abbrev,
+        sourceColor: sourceInfo.color,
+        shellName: log.shell_name || null,
+        cmd: log.cmd || null,
+        message: log.message || "",
+        exitCode: log.exit_code ?? null,
+        exitCodeColor: log.exit_code === 0 ? "green" : "red",
+    };
+}
+/**
+ * Parse a blueprint log entry into formatted parts (for use in Ink UI)
+ * Blueprint logs have a simpler structure (no source, shell_name, cmd, exit_code)
+ */
+export function parseBlueprintLogEntry(log) {
+    const levelInfo = getLogLevelInfo(log.level);
+    // Blueprint logs don't have a source, use "build" as default
+    const sourceInfo = getSourceInfo("build");
+    // Handle timestamp - may be timestamp_ms or timestamp
+    let timestampMs;
+    if (log.timestamp_ms !== undefined) {
+        timestampMs = log.timestamp_ms;
+    }
+    else if (log.timestamp !== undefined) {
+        const ts = log.timestamp;
+        timestampMs = typeof ts === "number" ? ts : new Date(ts).getTime();
+    }
+    else {
+        // Fallback to current time if no timestamp
+        timestampMs = Date.now();
+    }
+    return {
+        timestamp: formatTimestamp(timestampMs),
+        level: levelInfo.name,
+        levelColor: levelInfo.color,
+        source: sourceInfo.abbrev,
+        sourceColor: sourceInfo.color,
+        shellName: null,
+        cmd: null,
+        message: log.message || "",
+        exitCode: null,
+        exitCodeColor: "gray",
+    };
+}
+/**
+ * Parse any log entry (devbox or blueprint) into formatted parts
+ */
+export function parseAnyLogEntry(log) {
+    // Check if it's a devbox log by looking for source field
+    if ("source" in log || "shell_name" in log || "cmd" in log) {
+        return parseLogEntry(log);
+    }
+    else {
+        return parseBlueprintLogEntry(log);
+    }
+}
+/**
+ * Format a log entry as a string with chalk colors (for CLI output)
+ */
+export function formatLogEntryString(log) {
+    const parts = parseLogEntry(log);
+    const result = [];
+    // Timestamp (dim)
+    result.push(chalk.dim(parts.timestamp));
+    // Level (colored, bold for errors)
+    const levelChalk = parts.levelColor === "red"
+        ? chalk.red.bold
+        : parts.levelColor === "yellow"
+            ? chalk.yellow.bold
+            : parts.levelColor === "blue"
+                ? chalk.blue
+                : chalk.gray;
+    result.push(levelChalk(parts.level));
+    // Source (colored, in brackets)
+    const sourceChalk = {
+        magenta: chalk.magenta,
+        cyan: chalk.cyan,
+        green: chalk.green,
+        yellow: chalk.yellow,
+        gray: chalk.gray,
+        white: chalk.white,
+    }[parts.sourceColor] || chalk.white;
+    result.push(sourceChalk(`[${parts.source}]`));
+    // Shell name if present
+    if (parts.shellName) {
+        result.push(chalk.dim(`(${parts.shellName})`));
+    }
+    // Command if present
+    if (parts.cmd) {
+        result.push(chalk.cyan("$") + " " + chalk.white(parts.cmd));
+    }
+    // Message
+    if (parts.message) {
+        result.push(parts.message);
+    }
+    // Exit code if present
+    if (parts.exitCode !== null) {
+        const exitChalk = parts.exitCode === 0 ? chalk.green : chalk.red;
+        result.push(exitChalk(`exit=${parts.exitCode}`));
+    }
+    return result.join(" ");
+}
+/**
+ * Format logs for CLI output
+ */
+export function formatLogsForCLI(response) {
+    const logs = response.logs;
+    if (!logs || logs.length === 0) {
+        console.log(chalk.dim("No logs available"));
+        return;
+    }
+    for (const log of logs) {
+        console.log(formatLogEntryString(log));
+    }
+}

package/dist/utils/memoryMonitor.js

@@ -0,0 +1,85 @@
+/**
+ * Memory Monitor - Track memory usage and manage GC
+ * Helps prevent heap exhaustion during navigation
+ */
+let lastMemoryUsage = null;
+let gcAttempts = 0;
+const MAX_GC_ATTEMPTS_PER_MINUTE = 5;
+let lastGCReset = Date.now();
+// Memory thresholds (in bytes)
+const HEAP_WARNING_THRESHOLD = 3.5e9; // 3.5 GB
+const HEAP_CRITICAL_THRESHOLD = 4e9; // 4 GB
+export function logMemoryUsage(label) {
+    if (process.env.NODE_ENV === "development" || process.env.DEBUG_MEMORY) {
+        const current = process.memoryUsage();
+        const heapUsedMB = (current.heapUsed / 1024 / 1024).toFixed(2);
+        const heapTotalMB = (current.heapTotal / 1024 / 1024).toFixed(2);
+        const rssMB = (current.rss / 1024 / 1024).toFixed(2);
+        let delta = "";
+        if (lastMemoryUsage) {
+            const heapDelta = current.heapUsed - lastMemoryUsage.heapUsed;
+            const heapDeltaMB = (heapDelta / 1024 / 1024).toFixed(2);
+            delta = ` (Δ ${heapDeltaMB}MB)`;
+        }
+        console.error(`[MEMORY] ${label}: Heap ${heapUsedMB}/${heapTotalMB}MB, RSS ${rssMB}MB${delta}`);
+        // Warn if approaching limits
+        if (current.heapUsed > HEAP_WARNING_THRESHOLD) {
+            console.warn(`[MEMORY WARNING] Heap usage is high: ${heapUsedMB}MB (threshold: 3500MB)`);
+        }
+        lastMemoryUsage = current;
+    }
+}
+export function getMemoryPressure() {
+    const usage = process.memoryUsage();
+    const heapUsedPercent = (usage.heapUsed / usage.heapTotal) * 100;
+    if (usage.heapUsed > HEAP_CRITICAL_THRESHOLD || heapUsedPercent > 95)
+        return "critical";
+    if (usage.heapUsed > HEAP_WARNING_THRESHOLD || heapUsedPercent > 85)
+        return "high";
+    if (heapUsedPercent > 70)
+        return "medium";
+    return "low";
+}
+export function shouldTriggerGC() {
+    const pressure = getMemoryPressure();
+    return pressure === "high" || pressure === "critical";
+}
+/**
+ * Force garbage collection if available and needed
+ * Respects rate limiting to avoid GC thrashing
+ */
+export function tryForceGC(reason) {
+    // Reset GC attempt counter every minute
+    const now = Date.now();
+    if (now - lastGCReset > 60000) {
+        gcAttempts = 0;
+        lastGCReset = now;
+    }
+    // Rate limit GC attempts
+    if (gcAttempts >= MAX_GC_ATTEMPTS_PER_MINUTE) {
+        return false;
+    }
+    // Check if global.gc is available (requires --expose-gc flag)
+    if (typeof global.gc === "function") {
+        const beforeHeap = process.memoryUsage().heapUsed;
+        global.gc();
+        gcAttempts++;
+        const afterHeap = process.memoryUsage().heapUsed;
+        const freedMB = ((beforeHeap - afterHeap) / 1024 / 1024).toFixed(2);
+        if (process.env.DEBUG_MEMORY) {
+            console.error(`[MEMORY] Forced GC${reason ? ` (${reason})` : ""}: Freed ${freedMB}MB`);
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Monitor memory and trigger GC if needed
+ * Call this after major operations like screen transitions
+ */
+export function checkMemoryPressure() {
+    const pressure = getMemoryPressure();
+    if (pressure === "critical" || pressure === "high") {
+        tryForceGC(`Memory pressure: ${pressure}`);
+    }
+}

package/dist/utils/output.js

@@ -1,17 +1,99 @@
 /**
  * Utility for handling different output formats across CLI commands
+ *
+ * Simple API:
+ * - output(data, options) - outputs data in specified format
+ * - outputError(message, error) - outputs error and exits
  */
 import YAML from "yaml";
+import { processUtils } from "./processUtils.js";
 /**
- * Check if the command should use non-interactive output
+ * Resolve the output format from options
  */
-export function shouldUseNonInteractiveOutput(options) {
-    return !!options.output && options.output !== "interactive";
+function resolveFormat(options) {
+    const format = options.format || options.defaultFormat || "json";
+    if (format === "json" || format === "yaml" || format === "text") {
+        return format;
+    }
+    console.error(`Unknown output format: ${format}. Valid options: text, json, yaml`);
+    processUtils.exit(1);
 }
 /**
- * Output data in the specified format
+ * Format a value for text output (key-value pairs)
  */
-export function outputData(data, format = "json") {
+function formatKeyValue(data, indent = 0) {
+    const prefix = "  ".repeat(indent);
+    if (data === null || data === undefined) {
+        return `${prefix}(none)`;
+    }
+    if (typeof data === "string" ||
+        typeof data === "number" ||
+        typeof data === "boolean") {
+        return String(data);
+    }
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return `${prefix}(empty)`;
+        }
+        // For arrays of primitives, join them
+        if (data.every((item) => typeof item !== "object" || item === null)) {
+            return data.join(", ");
+        }
+        // For arrays of objects, format each with separator
+        return data
+            .map((item) => {
+            if (typeof item === "object" && item !== null) {
+                const lines = [];
+                for (const [key, value] of Object.entries(item)) {
+                    if (value !== null && value !== undefined) {
+                        const formattedValue = typeof value === "object"
+                            ? formatKeyValue(value, indent + 1)
+                            : String(value);
+                        lines.push(`${prefix}${key}: ${formattedValue}`);
+                    }
+                }
+                return lines.join("\n");
+            }
+            return `${prefix}${item}`;
+        })
+            .join(`\n${prefix}---\n`);
+    }
+    if (typeof data === "object") {
+        const lines = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value !== null && value !== undefined) {
+                if (typeof value === "object" && !Array.isArray(value)) {
+                    lines.push(`${prefix}${key}:`);
+                    lines.push(formatKeyValue(value, indent + 1));
+                }
+                else if (Array.isArray(value)) {
+                    lines.push(`${prefix}${key}: ${formatKeyValue(value, 0)}`);
+                }
+                else {
+                    lines.push(`${prefix}${key}: ${value}`);
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+    return String(data);
+}
+/**
+ * Main output function - outputs data in the specified format
+ *
+ * @param data - The data to output
+ * @param options - Output options (format, defaultFormat)
+ *
+ * @example
+ * // Output a devbox as text (default for single items)
+ * output(devbox, { format: options.output, defaultFormat: 'text' });
+ *
+ * @example
+ * // Output a list as JSON (default for lists)
+ * output(devboxes, { format: options.output, defaultFormat: 'json' });
+ */
+export function output(data, options = {}) {
+    const format = resolveFormat(options);
     if (format === "json") {
         console.log(JSON.stringify(data, null, 2));
         return;
@@ -20,49 +102,78 @@ export function outputData(data, format = "json") {
         console.log(YAML.stringify(data));
         return;
     }
-    if (format === "text") {
-        // Simple text output
-        if (Array.isArray(data)) {
-            // For lists of complex objects, just output IDs
-            data.forEach((item) => {
-                if (typeof item === "object" && item !== null && "id" in item) {
-                    console.log(item.id);
-                }
-                else {
-                    console.log(formatTextOutput(item));
-                }
-            });
-        }
-        else {
-            console.log(formatTextOutput(data));
-        }
-        return;
+    // Text format - key-value pairs
+    console.log(formatKeyValue(data));
+}
+/**
+ * Output an error message and exit
+ *
+ * @param message - Human-readable error message
+ * @param error - Optional Error object with details
+ *
+ * @example
+ * outputError('Failed to get devbox', error);
+ */
+export function outputError(message, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error || message);
+    console.error(`Error: ${message}`);
+    if (error && errorMessage !== message) {
+        console.error(`  ${errorMessage}`);
     }
-    console.error(`Unknown output format: ${format}`);
-    process.exit(1);
+    processUtils.exit(1);
 }
 /**
- * Format a single item as text output
+ * Output a success message for action commands
+ *
+ * @param message - Success message
+ * @param data - Optional data to include
+ * @param options - Output options
  */
-function formatTextOutput(item) {
-    if (typeof item === "string") {
-        return item;
-    }
-    // For objects, create a simple key: value format
-    const lines = [];
-    for (const [key, value] of Object.entries(item)) {
-        if (value !== null && value !== undefined) {
-            lines.push(`${key}: ${value}`);
-        }
+export function outputSuccess(message, data, options = {}) {
+    const format = resolveFormat(options);
+    if (format === "json") {
+        console.log(JSON.stringify({
+            success: true,
+            message,
+            ...(data && typeof data === "object" ? data : { data }),
+        }, null, 2));
+        return;
     }
-    return lines.join("\n");
+    if (format === "yaml") {
+        console.log(YAML.stringify({
+            success: true,
+            message,
+            ...(data && typeof data === "object" ? data : { data }),
+        }));
+        return;
+    }
+    // Text format
+    console.log(`✓ ${message}`);
+    if (data) {
+        console.log(formatKeyValue(data));
+    }
+}
+// ============================================================================
+// Legacy API (for backward compatibility during migration)
+// ============================================================================
+/**
+ * @deprecated Use output() instead
+ */
+export function shouldUseNonInteractiveOutput(options) {
+    return !!options.output && options.output !== "interactive";
 }
 /**
- * Output a single result (for create, delete, etc)
+ * @deprecated Use output() instead
+ */
+export function outputData(data, format = "json") {
+    output(data, { format, defaultFormat: format });
+}
+/**
+ * @deprecated Use output() instead
  */
 export function outputResult(result, options, successMessage) {
     if (shouldUseNonInteractiveOutput(options)) {
-        outputData(result, options.output);
+        output(result, { format: options.output, defaultFormat: "text" });
         return;
     }
     // Interactive mode - print success message
@@ -71,34 +182,15 @@ export function outputResult(result, options, successMessage) {
     }
 }
 /**
- * Output a list of items (for list commands)
+ * @deprecated Use output() instead
  */
 export function outputList(items, options) {
     if (shouldUseNonInteractiveOutput(options)) {
-        outputData(items, options.output);
-    }
-}
-/**
- * Handle errors in both interactive and non-interactive modes
- */
-export function outputError(error, options) {
-    if (shouldUseNonInteractiveOutput(options)) {
-        if (options.output === "json") {
-            console.error(JSON.stringify({ error: error.message }, null, 2));
-        }
-        else if (options.output === "yaml") {
-            console.error(YAML.stringify({ error: error.message }));
-        }
-        else {
-            console.error(`Error: ${error.message}`);
-        }
-        process.exit(1);
+        output(items, { format: options.output, defaultFormat: "json" });
     }
-    // Let interactive UI handle the error
-    throw error;
 }
 /**
- * Validate output format option
+ * @deprecated Use validateOutputFormat with the new output() function
  */
 export function validateOutputFormat(format) {
     if (!format || format === "text") {
@@ -111,5 +203,5 @@ export function validateOutputFormat(format) {
         return "yaml";
     }
     console.error(`Unknown output format: ${format}. Valid options: text, json, yaml`);
-    process.exit(1);
+    processUtils.exit(1);
 }

package/dist/utils/process.js

@@ -0,0 +1,106 @@
+/**
+ * Process utilities wrapper for testability.
+ *
+ * This module provides wrappers around Node.js process functions
+ * that can be easily mocked in tests.
+ */
+/**
+ * Default implementation using real process
+ */
+const defaultProcess = {
+    exit: (code) => {
+        process.exit(code);
+    },
+    stdout: {
+        write: (data) => process.stdout.write(data),
+        get isTTY() {
+            return process.stdout.isTTY;
+        },
+    },
+    stderr: {
+        write: (data) => process.stderr.write(data),
+    },
+    get env() {
+        return process.env;
+    },
+    cwd: () => process.cwd(),
+};
+/**
+ * Current process implementation - can be swapped for testing
+ */
+let currentProcess = defaultProcess;
+/**
+ * Get the current process wrapper
+ */
+export function getProcess() {
+    return currentProcess;
+}
+/**
+ * Set a custom process wrapper (for testing)
+ */
+export function setProcess(proc) {
+    currentProcess = proc;
+}
+/**
+ * Reset to the default process wrapper
+ */
+export function resetProcess() {
+    currentProcess = defaultProcess;
+}
+/**
+ * Exit the process with an optional exit code
+ */
+export function exitProcess(code) {
+    return currentProcess.exit(code);
+}
+/**
+ * Write to stdout
+ */
+export function writeStdout(data) {
+    return currentProcess.stdout.write(data);
+}
+/**
+ * Write to stderr
+ */
+export function writeStderr(data) {
+    return currentProcess.stderr.write(data);
+}
+/**
+ * Check if stdout is a TTY
+ */
+export function isStdoutTTY() {
+    return !!currentProcess.stdout.isTTY;
+}
+/**
+ * Get environment variable
+ */
+export function getEnv(key) {
+    return currentProcess.env[key];
+}
+/**
+ * Get current working directory
+ */
+export function getCwd() {
+    return currentProcess.cwd();
+}
+/**
+ * Create a mock process for testing
+ */
+export function createMockProcess(overrides = {}) {
+    const exitFn = jest.fn();
+    const stdoutWriteFn = jest.fn().mockReturnValue(true);
+    const stderrWriteFn = jest.fn().mockReturnValue(true);
+    const cwdFn = jest.fn().mockReturnValue("/mock/cwd");
+    return {
+        exit: overrides.exit ?? exitFn,
+        stdout: overrides.stdout ?? {
+            write: stdoutWriteFn,
+            isTTY: true,
+        },
+        stderr: overrides.stderr ?? {
+            write: stderrWriteFn,
+        },
+        env: overrides.env ?? {},
+        cwd: overrides.cwd ?? cwdFn,
+    };
+}