@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/utils/CommandExecutor.js

@@ -5,6 +5,8 @@
 import { render } from "ink";
 import { getClient } from "./client.js";
 import { shouldUseNonInteractiveOutput, outputList, outputResult, } from "./output.js";
+import { enableSynchronousUpdates, disableSynchronousUpdates, } from "./terminalSync.js";
+import { exitAlternateScreenBuffer, enterAlternateScreenBuffer, } from "./screen.js";
 import YAML from "yaml";
 export class CommandExecutor {
     options;
@@ -32,13 +34,16 @@ export class CommandExecutor {
             return;
         }
         // Interactive mode
-        // Enter alternate screen buffer
-        process.stdout.write("\x1b[?1049h");
-        console.clear();
-        const { waitUntilExit } = render(renderUI());
+        // Enter alternate screen buffer (this automatically clears the screen)
+        enableSynchronousUpdates();
+        const { waitUntilExit } = render(renderUI(), {
+            patchConsole: false,
+            exitOnCtrlC: false,
+        });
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write("\x1b[?1049l");
+        disableSynchronousUpdates();
+        exitAlternateScreenBuffer();
     }
     /**
      * Execute a create/action command with automatic format handling
@@ -55,13 +60,17 @@ export class CommandExecutor {
             return;
         }
         // Interactive mode
-        // Enter alternate screen buffer
-        process.stdout.write("\x1b[?1049h");
-        console.clear();
-        const { waitUntilExit } = render(renderUI());
+        // Enter alternate screen buffer (this automatically clears the screen)
+        enterAlternateScreenBuffer();
+        enableSynchronousUpdates();
+        const { waitUntilExit } = render(renderUI(), {
+            patchConsole: false,
+            exitOnCtrlC: false,
+        });
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write("\x1b[?1049l");
+        disableSynchronousUpdates();
+        exitAlternateScreenBuffer();
     }
     /**
      * Execute a delete command with automatic format handling
@@ -79,30 +88,50 @@ export class CommandExecutor {
         }
         // Interactive mode
         // Enter alternate screen buffer
-        process.stdout.write("\x1b[?1049h");
-        const { waitUntilExit } = render(renderUI());
+        enterAlternateScreenBuffer();
+        enableSynchronousUpdates();
+        const { waitUntilExit } = render(renderUI(), {
+            patchConsole: false,
+            exitOnCtrlC: false,
+        });
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write("\x1b[?1049l");
+        disableSynchronousUpdates();
+        exitAlternateScreenBuffer();
     }
     /**
      * Fetch items from an async iterator with optional filtering and limits
+     * IMPORTANT: This method tries to access the page data directly first to avoid
+     * auto-pagination issues that can cause memory errors with large datasets.
      */
     async fetchFromIterator(iterator, options = {}) {
         const { filter, limit = 100 } = options;
-        const items = [];
-        let count = 0;
-        for await (const item of iterator) {
-            if (filter && !filter(item)) {
-                continue;
-            }
-            items.push(item);
-            count++;
-            if (count >= limit) {
-                break;
+        let items = [];
+        // Try to access page data directly to avoid auto-pagination
+        const pageData = iterator.data || iterator.items;
+        if (pageData && Array.isArray(pageData)) {
+            items = pageData;
+        }
+        else {
+            // Fall back to iteration with limit
+            let count = 0;
+            for await (const item of iterator) {
+                if (filter && !filter(item)) {
+                    continue;
+                }
+                items.push(item);
+                count++;
+                if (count >= limit) {
+                    break;
+                }
             }
         }
-        return items;
+        // Apply filter if provided
+        if (filter) {
+            items = items.filter(filter);
+        }
+        // Apply limit
+        return items.slice(0, limit);
     }
     /**
      * Handle errors consistently across all commands

package/dist/utils/client.js

@@ -24,7 +24,5 @@ export function getClient() {
     return new Runloop({
         bearerToken: config.apiKey,
         baseURL,
-        timeout: 10000, // 10 seconds instead of default 30 seconds
-        maxRetries: 2, // 2 retries instead of default 5 (only for retryable errors)
     });
 }

package/dist/utils/config.js

@@ -1,9 +1,7 @@
 import Conf from "conf";
 import { homedir } from "os";
 import { join } from "path";
-import { existsSync, statSync, mkdirSync, writeFileSync, readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
+import { existsSync, statSync, mkdirSync, writeFileSync } from "fs";
 const config = new Conf({
     projectName: "runloop-cli",
 });
@@ -33,25 +31,6 @@ export function sshUrl() {
 export function getCacheDir() {
     return join(homedir(), ".cache", "rl-cli");
 }
-function getCurrentVersion() {
-    try {
-        // First try environment variable (when installed via npm)
-        if (process.env.npm_package_version) {
-            return process.env.npm_package_version;
-        }
-        // Fall back to reading package.json directly
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        // When running from dist/, we need to go up two levels to find package.json
-        const packageJsonPath = join(__dirname, "../../package.json");
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        return packageJson.version;
-    }
-    catch (error) {
-        // Ultimate fallback
-        return "0.1.0";
-    }
-}
 export function shouldCheckForUpdates() {
     const cacheDir = getCacheDir();
     const cacheFile = join(cacheDir, "last_update_check");
@@ -59,13 +38,8 @@ export function shouldCheckForUpdates() {
         return true;
     }
     const stats = statSync(cacheFile);
-    const hoursSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60);
-    return hoursSinceUpdate >= 6;
-}
-export function hasCachedUpdateInfo() {
-    const cacheDir = getCacheDir();
-    const cacheFile = join(cacheDir, "last_update_check");
-    return existsSync(cacheFile);
+    const daysSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
+    return daysSinceUpdate >= 1;
 }
 export function updateCheckCache() {
     const cacheDir = getCacheDir();
@@ -77,67 +51,23 @@ export function updateCheckCache() {
     // Touch the cache file
     writeFileSync(cacheFile, "");
 }
-export async function checkForUpdates(force = false) {
-    const currentVersion = getCurrentVersion();
-    // Always show cached result if available and not forcing
-    if (!force && hasCachedUpdateInfo() && !shouldCheckForUpdates()) {
-        // Show cached update info (we know there's an update available)
-        console.error(`\n🔄 Update available: ${currentVersion} → 0.1.0\n` +
-            `   Run: npm install -g @runloop/rl-cli@latest\n\n`);
-        return;
-    }
-    // Only fetch from npm if cache is expired or forcing
-    if (!force && !shouldCheckForUpdates()) {
-        return;
-    }
-    try {
-        const response = await fetch("https://registry.npmjs.org/@runloop/rl-cli/latest");
-        if (!response.ok) {
-            if (force) {
-                console.error("❌ Failed to check for updates\n");
-            }
-            return; // Silently fail if we can't check
-        }
-        const data = await response.json();
-        const latestVersion = data.version;
-        if (force) {
-            console.error(`Current version: ${currentVersion}\n`);
-            console.error(`Latest version: ${latestVersion}\n`);
-        }
-        if (latestVersion && latestVersion !== currentVersion) {
-            // Check if current version is older than latest
-            const isUpdateAvailable = compareVersions(latestVersion, currentVersion) > 0;
-            if (isUpdateAvailable) {
-                console.error(`\n🔄 Update available: ${currentVersion} → ${latestVersion}\n` +
-                    `   Run: npm install -g @runloop/rl-cli@latest\n\n`);
-            }
-            else if (force) {
-                console.error("✅ You're running the latest version!\n");
-            }
-        }
-        else if (force) {
-            console.error("✅ You're running the latest version!\n");
-        }
-        // Update the cache to indicate we've checked
-        updateCheckCache();
-    }
-    catch (error) {
-        if (force) {
-            console.error(`❌ Error checking for updates: ${error}\n`);
-        }
-        // Silently fail - don't interrupt the user's workflow
+export function getThemePreference() {
+    // Check environment variable first, then fall back to stored config
+    const envTheme = process.env.RUNLOOP_THEME?.toLowerCase();
+    if (envTheme === "light" || envTheme === "dark" || envTheme === "auto") {
+        return envTheme;
     }
+    return config.get("theme") || "auto";
 }
-function compareVersions(version1, version2) {
-    const v1parts = version1.split('.').map(Number);
-    const v2parts = version2.split('.').map(Number);
-    for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
-        const v1part = v1parts[i] || 0;
-        const v2part = v2parts[i] || 0;
-        if (v1part > v2part)
-            return 1;
-        if (v1part < v2part)
-            return -1;
-    }
-    return 0;
+export function setThemePreference(theme) {
+    config.set("theme", theme);
+}
+export function getDetectedTheme() {
+    return config.get("detectedTheme") || null;
+}
+export function setDetectedTheme(theme) {
+    config.set("detectedTheme", theme);
+}
+export function clearDetectedTheme() {
+    config.delete("detectedTheme");
 }

package/dist/utils/interactiveCommand.js

@@ -1,14 +1,15 @@
+import { enterAlternateScreenBuffer, exitAlternateScreenBuffer, } from "./screen.js";
 /**
  * Wrapper for interactive commands that need alternate screen buffer management
  */
 export async function runInteractiveCommand(command) {
     // Enter alternate screen buffer
-    process.stdout.write("\x1b[?1049h");
+    enterAlternateScreenBuffer();
     try {
         await command();
     }
     finally {
         // Exit alternate screen buffer
-        process.stdout.write("\x1b[?1049l");
+        exitAlternateScreenBuffer();
     }
 }

package/dist/utils/logFormatter.js

@@ -0,0 +1,162 @@
+/**
+ * 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 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",
+    };
+}
+/**
+ * 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}`);
+    }
+}