@runloop/rl-cli 0.1.2 → 0.3.0

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

@@ -0,0 +1,61 @@
+/**
+ * Terminal screen buffer utilities.
+ *
+ * The alternate screen buffer provides a fullscreen experience similar to
+ * applications like vim, top, or htop. When enabled, the terminal saves
+ * 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() {
+    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() {
+    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";
 }
 /**
@@ -99,7 +100,9 @@ export function getSSHUrl() {
  */
 export function getProxyCommand() {
     const sshUrl = getSSHUrl();
-    return `openssl s_client -quiet -verify_quiet -servername %h -connect ${sshUrl} 2>/dev/null`;
+    // macOS openssl doesn't support -verify_quiet, use compatible flags
+    // servername should be %h (target hostname) - SSH will replace %h with the actual hostname from the SSH command
+    return `openssl s_client -quiet -servername %h -connect ${sshUrl} 2>/dev/null`;
 }
 /**
  * Execute SSH command
@@ -126,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/sshSession.js

@@ -1,29 +1,5 @@
-import { spawnSync } from "child_process";
-export async function runSSHSession(config) {
-    // Reset terminal to fix input visibility issues
-    // This ensures the terminal is in a proper state after exiting Ink
-    spawnSync("reset", [], { stdio: "inherit" });
-    console.clear();
-    console.log(`\nConnecting to devbox ${config.devboxName}...\n`);
-    // Spawn SSH in foreground with proper terminal settings
-    const result = spawnSync("ssh", [
-        "-t", // Force pseudo-terminal allocation for proper input handling
-        "-i",
-        config.keyPath,
-        "-o",
-        `ProxyCommand=${config.proxyCommand}`,
-        "-o",
-        "StrictHostKeyChecking=no",
-        "-o",
-        "UserKnownHostsFile=/dev/null",
-        `${config.sshUser}@${config.url}`,
-    ], {
-        stdio: "inherit",
-        shell: false,
-    });
-    return {
-        exitCode: result.status || 0,
-        shouldRestart: true,
-        returnToDevboxId: config.devboxId,
-    };
-}
+/**
+ * SSH Session types - kept for compatibility and type references
+ * Actual SSH session handling is now done via ink-spawn in SSHSessionScreen
+ */
+export {};

package/dist/utils/terminalDetection.js

@@ -0,0 +1,185 @@
+/**
+ * Terminal background color detection utility
+ * Uses ANSI escape sequences to query the terminal's background color
+ */
+import { stdin, stdout } from "process";
+/**
+ * Calculate luminance from RGB values to determine if background is light or dark
+ * Using relative luminance formula: https://www.w3.org/TR/WCAG20/#relativeluminancedef
+ */
+function getLuminance(r, g, b) {
+    const [rs, gs, bs] = [r, g, b].map((c) => {
+        const normalized = c / 255;
+        return normalized <= 0.03928
+            ? normalized / 12.92
+            : Math.pow((normalized + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+/**
+ * Parse RGB color from terminal response
+ * 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) {
+    // 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 };
+    }
+    // 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: 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;
+    }
+    // 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 = () => {
+            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) => {
+            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
+                    finish(luminance > 0.5 ? "light" : "dark");
+                    return;
+                }
+                // 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(() => {
+            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 {
+            finish(null);
+        }
+    });
+}

package/dist/utils/terminalSync.js

@@ -0,0 +1,39 @@
+/**
+ * Terminal synchronous update mode utilities
+ *
+ * Uses ANSI escape sequences to prevent screen flicker by batching terminal updates.
+ * This tells the terminal to buffer all output between BEGIN and END markers
+ * and only display it atomically, preventing the visible flashing during redraws.
+ *
+ * Supported by most modern terminals (iTerm2, Terminal.app, Alacritty, etc.)
+ * When not supported, these sequences are simply ignored.
+ */
+// Begin Synchronous Update (BSU) - tells terminal to start buffering
+export const BEGIN_SYNC = "\x1b[?2026h";
+// End Synchronous Update (ESU) - tells terminal to flush buffer atomically
+export const END_SYNC = "\x1b[?2026l";
+/**
+ * Enable synchronous updates for the terminal
+ * Call this once at application startup
+ */
+export function enableSynchronousUpdates() {
+    return;
+    //process.stdout.write(BEGIN_SYNC);
+}
+/**
+ * Disable synchronous updates for the terminal
+ * Call this at application shutdown
+ */
+export function disableSynchronousUpdates() {
+    return;
+    //process.stdout.write(END_SYNC);
+}
+/**
+ * Wrap terminal output with synchronous update markers
+ * This ensures the output is displayed atomically without flicker
+ */
+export function withSynchronousUpdate(fn) {
+    //process.stdout.write(BEGIN_SYNC);
+    fn();
+    //process.stdout.write(END_SYNC);
+}

package/dist/utils/theme.js

@@ -2,21 +2,170 @@
  * Color theme constants for the CLI application
  * Centralized color definitions for easy theme customization
  */
-export const colors = {
+import { detectTerminalTheme } from "./terminalDetection.js";
+import { getThemePreference, getDetectedTheme, setDetectedTheme, } from "./config.js";
+import chalk from "chalk";
+// Dark mode color palette (default)
+const darkColors = {
     // Primary brand colors
-    primary: "cyan",
-    secondary: "magenta",
+    primary: "#00D9FF", // Bright cyan
+    secondary: "#FF6EC7", // Vibrant magenta
     // Status colors
-    success: "green",
-    warning: "yellow",
-    error: "red",
-    info: "blue",
+    success: "#10B981", // Emerald green
+    warning: "#F59E0B", // Amber
+    error: "#EF4444", // Red
+    info: "#3B82F6", // Blue
     // UI colors
-    text: "white",
-    textDim: "gray",
-    border: "gray",
+    text: "#FFFFFF", // White
+    textDim: "#9CA3AF", // Gray
+    border: "#6B7280", // Medium gray
+    background: "#000000", // Black
     // Accent colors for menu items and highlights
-    accent1: "cyan",
-    accent2: "magenta",
-    accent3: "green",
+    accent1: "#00D9FF", // Same as primary
+    accent2: "#FF6EC7", // Same as secondary
+    accent3: "#10B981", // Same as success
+    // ID color for displaying resource IDs
+    idColor: "#60A5FA", // Muted blue for IDs
 };
+// Light mode color palette
+const lightColors = {
+    // Primary brand colors (brighter/darker for visibility on light backgrounds)
+    primary: "#2563EB", // Deep blue
+    secondary: "#C026D3", // Deep magenta
+    // Status colors
+    success: "#059669", // Deep green
+    warning: "#D97706", // Deep amber
+    error: "#DC2626", // Deep red
+    info: "#2563EB", // Deep blue
+    // UI colors
+    text: "#000000", // Black
+    textDim: "#4B5563", // Dark gray for better contrast on light backgrounds
+    border: "#9CA3AF", // Medium gray
+    background: "#FFFFFF", // White
+    // Accent colors for menu items and highlights
+    accent1: "#2563EB", // Same as primary
+    accent2: "#C026D3", // Same as secondary
+    accent3: "#059669", // Same as success
+    // ID color for displaying resource IDs
+    idColor: "#0284C7", // Deeper blue for IDs on light backgrounds
+};
+// Current active color palette (initialized by initializeTheme)
+let activeColors = darkColors;
+let currentTheme = "dark";
+/**
+ * Get the current color palette
+ * This is the main export that components should use
+ */
+export const colors = new Proxy({}, {
+    get(_target, prop) {
+        return activeColors[prop];
+    },
+});
+/**
+ * Initialize the theme system
+ * Must be called at CLI startup before rendering any UI
+ */
+export async function initializeTheme() {
+    const preference = getThemePreference();
+    let detectedTheme = null;
+    // Auto-detect if preference is 'auto'
+    // Always detect on startup to support different terminal profiles
+    // (users may have different terminal profiles with different themes)
+    if (preference === "auto") {
+        try {
+            detectedTheme = await detectTerminalTheme();
+            // Cache the result for reference, but we always re-detect on startup
+            if (detectedTheme) {
+                setDetectedTheme(detectedTheme);
+            }
+        }
+        catch {
+            // Detection failed, fall back to cached value or dark mode
+            const cachedTheme = getDetectedTheme();
+            detectedTheme = cachedTheme || null;
+        }
+    }
+    // Determine final theme
+    if (preference === "light") {
+        currentTheme = "light";
+        activeColors = lightColors;
+    }
+    else if (preference === "dark") {
+        currentTheme = "dark";
+        activeColors = darkColors;
+    }
+    else if (detectedTheme) {
+        // Auto mode with successful detection
+        currentTheme = detectedTheme;
+        activeColors = detectedTheme === "light" ? lightColors : darkColors;
+    }
+    else {
+        // Auto mode with failed detection - default to dark
+        currentTheme = "dark";
+        activeColors = darkColors;
+    }
+}
+/**
+ * Get the current theme mode
+ */
+export function getCurrentTheme() {
+    return currentTheme;
+}
+/**
+ * Get hex color value for a color name
+ * Useful for applying colors dynamically
+ */
+export function getChalkColor(colorName) {
+    return activeColors[colorName];
+}
+/**
+ * Get chalk text color function for a color name
+ * Converts hex color to chalk function for text coloring
+ * @param colorName - Name of the color from the palette
+ * @returns Chalk function that can be used to color text
+ */
+export function getChalkTextColor(colorName) {
+    const hexColor = activeColors[colorName];
+    return chalk.hex(hexColor);
+}
+/**
+ * Get chalk background color function for a color name
+ * Converts hex color to chalk function for background coloring
+ * @param colorName - Name of the color from the palette
+ * @returns Chalk function that can be used to color backgrounds
+ */
+export function getChalkBgColor(colorName) {
+    const hexColor = activeColors[colorName];
+    return chalk.bgHex(hexColor);
+}
+/**
+ * Check if we should use inverted colors (light mode)
+ * Useful for components that need to explicitly set backgrounds
+ */
+export function isLightMode() {
+    return currentTheme === "light";
+}
+/**
+ * Force set theme mode directly without detection
+ * Used for live preview in theme selector
+ */
+export function setThemeMode(mode) {
+    currentTheme = mode;
+    activeColors = mode === "light" ? lightColors : darkColors;
+}
+/**
+ * Sanitize width values to prevent Yoga WASM crashes
+ * Ensures width is a valid, finite number within safe bounds
+ *
+ * @param width - The width value to sanitize
+ * @param min - Minimum allowed width (default: 1)
+ * @param max - Maximum allowed width (default: 100)
+ * @returns A safe width value guaranteed to be within [min, max]
+ */
+export function sanitizeWidth(width, min = 1, max = 100) {
+    // Check for NaN, Infinity, or other invalid numbers
+    if (!Number.isFinite(width) || width < min) {
+        return min;
+    }
+    return Math.min(width, max);
+}