@runloop/rl-cli 0.2.0 → 0.4.0

package/dist/utils/client.js

@@ -1,4 +1,5 @@
 import Runloop from "@runloop/api-client";
+import { VERSION } from "@runloop/api-client/version.js";
 import { getConfig } from "./config.js";
 /**
  * Get the base URL based on RUNLOOP_ENV environment variable
@@ -18,11 +19,14 @@ function getBaseUrl() {
 export function getClient() {
     const config = getConfig();
     if (!config.apiKey) {
-        throw new Error("API key not configured. Run: rli auth");
+        throw new Error("API key not configured. Set RUNLOOP_API_KEY environment variable.");
     }
     const baseURL = getBaseUrl();
     return new Runloop({
         bearerToken: config.apiKey,
         baseURL,
+        defaultHeaders: {
+            "User-Agent": `Runloop/JS ${VERSION} - CLI`,
+        },
     });
 }

package/dist/utils/config.js

@@ -4,6 +4,7 @@ import { join } from "path";
 import { existsSync, statSync, mkdirSync, writeFileSync } from "fs";
 const config = new Conf({
     projectName: "runloop-cli",
+    cwd: join(homedir(), ".runloop"),
 });
 export function getConfig() {
     // Check environment variable first, then fall back to stored config
@@ -29,7 +30,7 @@ export function sshUrl() {
         : "ssh.runloop.ai:443";
 }
 export function getCacheDir() {
-    return join(homedir(), ".cache", "rl-cli");
+    return join(homedir(), ".runloop", "rl-cli");
 }
 export function shouldCheckForUpdates() {
     const cacheDir = getCacheDir();

package/dist/utils/logFormatter.js

@@ -83,7 +83,7 @@ export function getSourceInfo(source) {
     return { abbrev, color: "white" };
 }
 /**
- * Parse a log entry into formatted parts (for use in Ink UI)
+ * Parse a devbox log entry into formatted parts (for use in Ink UI)
  */
 export function parseLogEntry(log) {
     const levelInfo = getLogLevelInfo(log.level);
@@ -101,6 +101,52 @@ export function parseLogEntry(log) {
         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)
  */

package/dist/utils/output.js

@@ -6,6 +6,7 @@
  * - outputError(message, error) - outputs error and exits
  */
 import YAML from "yaml";
+import { processUtils } from "./processUtils.js";
 /**
  * Resolve the output format from options
  */
@@ -15,7 +16,7 @@ function resolveFormat(options) {
         return format;
     }
     console.error(`Unknown output format: ${format}. Valid options: text, json, yaml`);
-    process.exit(1);
+    processUtils.exit(1);
 }
 /**
  * Format a value for text output (key-value pairs)
@@ -119,7 +120,7 @@ export function outputError(message, error) {
     if (error && errorMessage !== message) {
         console.error(`  ${errorMessage}`);
     }
-    process.exit(1);
+    processUtils.exit(1);
 }
 /**
  * Output a success message for action commands
@@ -202,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,
+    };
+}

package/dist/utils/processUtils.js

@@ -0,0 +1,135 @@
+/**
+ * Process utilities wrapper for testability.
+ *
+ * This module provides a mockable interface for process-related operations
+ * like exit, stdout/stderr writes, and terminal detection. In tests, you can
+ * replace these functions with mocks to avoid actual process termination
+ * and capture output.
+ *
+ * Usage in code:
+ *   import { processUtils } from '../utils/processUtils.js';
+ *   processUtils.exit(1);
+ *   processUtils.stdout.write('Hello');
+ *
+ * Usage in tests:
+ *   import { processUtils, resetProcessUtils } from '../utils/processUtils.js';
+ *   processUtils.exit = jest.fn();
+ *   // ... run tests ...
+ *   resetProcessUtils(); // restore original behavior
+ */
+// Store original references for reset
+const originalExit = process.exit.bind(process);
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+const originalCwd = process.cwd.bind(process);
+const originalOn = process.on.bind(process);
+const originalOff = process.off.bind(process);
+/**
+ * The main process utilities object.
+ * All properties are mutable for testing purposes.
+ */
+export const processUtils = {
+    exit: originalExit,
+    stdout: {
+        write: (data) => originalStdoutWrite(data),
+        get isTTY() {
+            return process.stdout.isTTY ?? false;
+        },
+    },
+    stderr: {
+        write: (data) => originalStderrWrite(data),
+        get isTTY() {
+            return process.stderr.isTTY ?? false;
+        },
+    },
+    stdin: {
+        get isTTY() {
+            return process.stdin.isTTY ?? false;
+        },
+        setRawMode: process.stdin.setRawMode?.bind(process.stdin),
+        on: process.stdin.on.bind(process.stdin),
+        removeListener: process.stdin.removeListener.bind(process.stdin),
+    },
+    cwd: originalCwd,
+    on: originalOn,
+    off: originalOff,
+    get env() {
+        return process.env;
+    },
+};
+/**
+ * Reset all process utilities to their original implementations.
+ * Call this in test teardown to restore normal behavior.
+ */
+export function resetProcessUtils() {
+    processUtils.exit = originalExit;
+    processUtils.stdout.write = (data) => originalStdoutWrite(data);
+    processUtils.stderr.write = (data) => originalStderrWrite(data);
+    processUtils.cwd = originalCwd;
+    processUtils.on = originalOn;
+    processUtils.off = originalOff;
+}
+/**
+ * Create a mock process utils for testing.
+ * Returns an object with jest mock functions.
+ */
+export function createMockProcessUtils() {
+    const exitMock = (() => {
+        throw new Error("process.exit called");
+    });
+    return {
+        exit: exitMock,
+        stdout: {
+            write: () => true,
+            isTTY: false,
+        },
+        stderr: {
+            write: () => true,
+            isTTY: false,
+        },
+        stdin: {
+            isTTY: false,
+            setRawMode: () => { },
+            on: () => { },
+            removeListener: () => { },
+        },
+        cwd: () => "/mock/cwd",
+        on: () => { },
+        off: () => { },
+        env: {},
+    };
+}
+/**
+ * Install mock process utils for testing.
+ * Returns a cleanup function to restore originals.
+ */
+export function installMockProcessUtils(mock) {
+    const backup = {
+        exit: processUtils.exit,
+        stdoutWrite: processUtils.stdout.write,
+        stderrWrite: processUtils.stderr.write,
+        cwd: processUtils.cwd,
+        on: processUtils.on,
+        off: processUtils.off,
+    };
+    if (mock.exit)
+        processUtils.exit = mock.exit;
+    if (mock.stdout?.write)
+        processUtils.stdout.write = mock.stdout.write;
+    if (mock.stderr?.write)
+        processUtils.stderr.write = mock.stderr.write;
+    if (mock.cwd)
+        processUtils.cwd = mock.cwd;
+    if (mock.on)
+        processUtils.on = mock.on;
+    if (mock.off)
+        processUtils.off = mock.off;
+    return () => {
+        processUtils.exit = backup.exit;
+        processUtils.stdout.write = backup.stdoutWrite;
+        processUtils.stderr.write = backup.stderrWrite;
+        processUtils.cwd = backup.cwd;
+        processUtils.on = backup.on;
+        processUtils.off = backup.off;
+    };
+}

package/dist/utils/screen.js

@@ -6,18 +6,56 @@
  * the current screen content and switches to a clean buffer. Upon exit,
  * the original screen content is restored.
  */
+import { processUtils } from "./processUtils.js";
 /**
  * Enter the alternate screen buffer.
  * This provides a fullscreen experience where content won't mix with
  * previous terminal output. Like vim or top.
  */
 export function enterAlternateScreenBuffer() {
-    process.stdout.write("\x1b[?1049h");
+    processUtils.stdout.write("\x1b[?1049h");
 }
 /**
  * Exit the alternate screen buffer and restore the previous screen content.
  * This returns the terminal to its original state before enterAlternateScreen() was called.
  */
 export function exitAlternateScreenBuffer() {
-    process.stdout.write("\x1b[?1049l");
+    processUtils.stdout.write("\x1b[?1049l");
+}
+/**
+ * Clear the terminal screen.
+ * Uses ANSI escape sequences to clear the screen and move cursor to top-left.
+ */
+export function clearScreen() {
+    // Clear entire screen and move cursor to top-left
+    processUtils.stdout.write("\x1b[2J\x1b[H");
+}
+/**
+ * Show the terminal cursor.
+ * Uses ANSI escape sequence to make the cursor visible.
+ */
+export function showCursor() {
+    processUtils.stdout.write("\x1b[?25h");
+}
+/**
+ * Hide the terminal cursor.
+ * Uses ANSI escape sequence to make the cursor invisible.
+ */
+export function hideCursor() {
+    processUtils.stdout.write("\x1b[?25l");
+}
+/**
+ * Reset terminal to a clean state.
+ * Exits alternate screen buffer, clears the screen, and resets cursor.
+ * Also resets terminal attributes to ensure clean state for subprocesses.
+ */
+export function resetTerminal() {
+    exitAlternateScreenBuffer();
+    clearScreen();
+    // Reset terminal attributes (SGR reset)
+    processUtils.stdout.write("\x1b[0m");
+    // Move cursor to home position
+    processUtils.stdout.write("\x1b[H");
+    // Show cursor to ensure it's visible
+    showCursor();
 }

package/dist/utils/ssh.js

@@ -4,6 +4,7 @@ import { writeFile, mkdir, chmod } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 import { getClient } from "./client.js";
+import { processUtils } from "./processUtils.js";
 const execAsync = promisify(exec);
 export function constructSSHConfig(options) {
     return `Host ${options.hostname}
@@ -91,7 +92,7 @@ export async function waitForReady(devboxId, timeoutSeconds = 180, pollIntervalS
  * Get SSH URL based on environment
  */
 export function getSSHUrl() {
-    const env = process.env.RUNLOOP_ENV?.toLowerCase();
+    const env = processUtils.env.RUNLOOP_ENV?.toLowerCase();
     return env === "dev" ? "ssh.runloop.pro:443" : "ssh.runloop.ai:443";
 }
 /**
@@ -128,7 +129,7 @@ export async function executeSSH(devboxId, user, keyfilePath, url, additionalArg
     }
     catch (error) {
         console.error("SSH command failed:", error);
-        process.exit(1);
+        processUtils.exit(1);
     }
 }
 /**

package/dist/utils/terminalDetection.js

@@ -18,80 +18,168 @@ function getLuminance(r, g, b) {
 }
 /**
  * Parse RGB color from terminal response
- * Expected format: rgb:RRRR/GGGG/BBBB or similar variations
+ * Terminal responses can come in various formats:
+ * - OSC 11;rgb:RRRR/GGGG/BBBB (xterm-style, 4 hex digits per channel)
+ * - OSC 11;rgb:RR/GG/BB (short format, 2 hex digits per channel)
+ * - rgb:RRRR/GGGG/BBBB (without OSC prefix)
  */
 function parseRGBResponse(response) {
-    // Match patterns like: rgb:RRRR/GGGG/BBBB or rgba:RRRR/GGGG/BBBB/AAAA
-    const rgbMatch = response.match(/rgba?:([0-9a-f]+)\/([0-9a-f]+)\/([0-9a-f]+)/i);
-    if (!rgbMatch) {
-        return null;
+    // Try multiple patterns to handle different terminal response formats
+    // Pattern 1: OSC 11;rgb:RRRR/GGGG/BBBB or 11;rgb:RRRR/GGGG/BBBB (xterm-style, 4 hex digits)
+    let match = response.match(/11;rgb:([0-9a-f]{4})\/([0-9a-f]{4})\/([0-9a-f]{4})/i);
+    if (match) {
+        // Take first 2 hex digits and convert to 0-255
+        const r = parseInt(match[1].substring(0, 2), 16);
+        const g = parseInt(match[2].substring(0, 2), 16);
+        const b = parseInt(match[3].substring(0, 2), 16);
+        return { r, g, b };
+    }
+    // Pattern 2: OSC 11;rgb:RR/GG/BB (short format, 2 hex digits)
+    match = response.match(/11;rgb:([0-9a-f]{2})\/([0-9a-f]{2})\/([0-9a-f]{2})/i);
+    if (match) {
+        const r = parseInt(match[1], 16);
+        const g = parseInt(match[2], 16);
+        const b = parseInt(match[3], 16);
+        return { r, g, b };
+    }
+    // Pattern 3: rgb:RRRR/GGGG/BBBB (without OSC prefix, 4 hex digits)
+    match = response.match(/rgb:([0-9a-f]{4})\/([0-9a-f]{4})\/([0-9a-f]{4})/i);
+    if (match) {
+        const r = parseInt(match[1].substring(0, 2), 16);
+        const g = parseInt(match[2].substring(0, 2), 16);
+        const b = parseInt(match[3].substring(0, 2), 16);
+        return { r, g, b };
+    }
+    // Pattern 4: rgb:RR/GG/BB (without OSC prefix, 2 hex digits)
+    match = response.match(/rgb:([0-9a-f]{2})\/([0-9a-f]{2})\/([0-9a-f]{2})/i);
+    if (match) {
+        const r = parseInt(match[1], 16);
+        const g = parseInt(match[2], 16);
+        const b = parseInt(match[3], 16);
+        return { r, g, b };
     }
-    // Parse hex values and normalize to 0-255 range
-    const r = parseInt(rgbMatch[1].substring(0, 2), 16);
-    const g = parseInt(rgbMatch[2].substring(0, 2), 16);
-    const b = parseInt(rgbMatch[3].substring(0, 2), 16);
-    return { r, g, b };
+    // Pattern 5: Generic pattern for any hex values separated by /
+    match = response.match(/([0-9a-f]{2,4})\/([0-9a-f]{2,4})\/([0-9a-f]{2,4})/i);
+    if (match) {
+        const r = parseInt(match[1].substring(0, 2), 16);
+        const g = parseInt(match[2].substring(0, 2), 16);
+        const b = parseInt(match[3].substring(0, 2), 16);
+        return { r, g, b };
+    }
+    return null;
 }
 /**
  * Detect terminal theme by querying background color
  * Returns 'light' or 'dark' based on background luminance, or null if detection fails
  *
- * NOTE: This is disabled by default to prevent flashing. Theme detection writes
- * escape sequences to stdout which can cause visible flashing on the terminal.
- * Users can explicitly enable it with RUNLOOP_ENABLE_THEME_DETECTION=1
+ * NOTE: Theme detection runs automatically when theme preference is "auto".
+ * Users can disable it by setting RUNLOOP_DISABLE_THEME_DETECTION=1 to prevent
+ * any potential terminal flashing.
  */
 export async function detectTerminalTheme() {
     // Skip detection in non-TTY environments
     if (!stdin.isTTY || !stdout.isTTY) {
         return null;
     }
-    // Theme detection is now OPT-IN instead of OPT-OUT to prevent flashing
-    // Users need to explicitly enable it
-    if (process.env.RUNLOOP_ENABLE_THEME_DETECTION !== "1") {
+    // Allow users to opt-out of theme detection if they experience flashing
+    if (process.env.RUNLOOP_DISABLE_THEME_DETECTION === "1") {
         return null;
     }
     return new Promise((resolve) => {
         let response = "";
         let timeout;
+        let hasResolved = false;
         const cleanup = () => {
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdin.removeListener("data", onData);
-            clearTimeout(timeout);
+            try {
+                stdin.setRawMode(false);
+                stdin.pause();
+                stdin.removeListener("data", onData);
+                stdin.removeListener("readable", onReadable);
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        };
+        const finish = (result) => {
+            if (hasResolved)
+                return;
+            hasResolved = true;
+            cleanup();
+            resolve(result);
         };
         const onData = (chunk) => {
-            response += chunk.toString();
-            // Check if we have a complete response (ends with ESC \ or BEL)
-            if (response.includes("\x1b\\") || response.includes("\x07")) {
-                cleanup();
+            if (hasResolved)
+                return;
+            const text = chunk.toString("utf8");
+            response += text;
+            // Check if we have a complete response
+            // Terminal responses typically end with ESC \ (ST) or BEL (\x07)
+            // Some terminals may also send the response without the OSC prefix
+            if (response.includes("\x1b\\") ||
+                response.includes("\x07") ||
+                response.includes("\x1b]")) {
                 const rgb = parseRGBResponse(response);
                 if (rgb) {
                     const luminance = getLuminance(rgb.r, rgb.g, rgb.b);
                     // Threshold: luminance > 0.5 is considered light background
-                    resolve(luminance > 0.5 ? "light" : "dark");
+                    finish(luminance > 0.5 ? "light" : "dark");
+                    return;
                 }
-                else {
-                    resolve(null);
+                // If we got a response but couldn't parse it, check if it's complete
+                if (response.includes("\x1b\\") || response.includes("\x07")) {
+                    finish(null);
+                    return;
+                }
+            }
+        };
+        // Some terminals may send responses through the readable event instead
+        const onReadable = () => {
+            if (hasResolved)
+                return;
+            let chunk;
+            while ((chunk = stdin.read()) !== null) {
+                const text = chunk.toString("utf8");
+                response += text;
+                if (text.includes("\x1b\\") || text.includes("\x07")) {
+                    const rgb = parseRGBResponse(response);
+                    if (rgb) {
+                        const luminance = getLuminance(rgb.r, rgb.g, rgb.b);
+                        finish(luminance > 0.5 ? "light" : "dark");
+                        return;
+                    }
+                    finish(null);
+                    return;
                 }
             }
         };
         // Set timeout for terminals that don't support the query
         timeout = setTimeout(() => {
-            cleanup();
-            resolve(null);
-        }, 50); // 50ms timeout - quick to minimize any visual flashing
+            finish(null);
+        }, 200); // Increased timeout to 200ms to give terminals more time to respond
         try {
             // Enable raw mode to capture escape sequences
             stdin.setRawMode(true);
             stdin.resume();
+            // Listen to both data and readable events
             stdin.on("data", onData);
+            stdin.on("readable", onReadable);
             // Query background color using OSC 11 sequence
             // Format: ESC ] 11 ; ? ESC \
+            // Some terminals may need the BEL terminator instead
             stdout.write("\x1b]11;?\x1b\\");
+            // Also try with BEL terminator as some terminals prefer it
+            // (but wait a bit to see if first one works)
+            setTimeout(() => {
+                if (!hasResolved) {
+                    stdout.write("\x1b]11;?\x07");
+                }
+            }, 10);
         }
         catch {
-            cleanup();
-            resolve(null);
+            finish(null);
         }
     });
 }