@runloop/rl-cli 0.2.0 → 0.3.0

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

package/dist/utils/theme.js

@@ -4,6 +4,7 @@
  */
 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
@@ -68,27 +69,21 @@ 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") {
-        // Check cache first - only detect if we haven't cached a result
-        const cachedTheme = getDetectedTheme();
-        if (cachedTheme) {
-            // Use cached detection result (no flashing!)
-            detectedTheme = cachedTheme;
-        }
-        else {
-            // First time detection - run it and cache the result
-            try {
-                detectedTheme = await detectTerminalTheme();
-                if (detectedTheme) {
-                    // Cache the result so we don't detect again
-                    setDetectedTheme(detectedTheme);
-                }
-            }
-            catch {
-                // Detection failed, fall back to dark mode
-                detectedTheme = null;
+        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") {
@@ -117,12 +112,32 @@ export function getCurrentTheme() {
     return currentTheme;
 }
 /**
- * Get chalk function for a color name
+ * 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

package/dist/utils/versionCheck.js

@@ -0,0 +1,53 @@
+import { shouldCheckForUpdates, updateCheckCache } from "./config.js";
+import { VERSION } from "../cli.js";
+/**
+ * Check if a new version is available on npm
+ * Uses caching to avoid checking too frequently
+ */
+export async function checkForUpdates() {
+    const currentVersion = VERSION;
+    // Check if we should check for updates (respects cache)
+    if (!shouldCheckForUpdates()) {
+        return {
+            isUpdateAvailable: false,
+            latestVersion: null,
+            currentVersion,
+        };
+    }
+    try {
+        // Fetch latest version from npm registry
+        const response = await fetch("https://registry.npmjs.org/@runloop/rl-cli/latest", {
+            headers: {
+                Accept: "application/json",
+            },
+        });
+        if (!response.ok) {
+            // If fetch fails, don't show update message
+            return {
+                isUpdateAvailable: false,
+                latestVersion: null,
+                currentVersion,
+            };
+        }
+        const data = (await response.json());
+        const latestVersion = data.version;
+        // Update the cache
+        updateCheckCache();
+        // Compare versions (simple string comparison works for semver)
+        const isUpdateAvailable = latestVersion !== currentVersion;
+        return {
+            isUpdateAvailable,
+            latestVersion,
+            currentVersion,
+        };
+    }
+    catch (error) {
+        // Silently fail - don't show update message if check fails
+        // This prevents network errors from disrupting the user experience
+        return {
+            isUpdateAvailable: false,
+            latestVersion: null,
+            currentVersion,
+        };
+    }
+}

package/dist/version.js

@@ -0,0 +1,12 @@
+/**
+ * Version information for the CLI.
+ * Separated from cli.ts to allow importing without side effects.
+ */
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
+export const VERSION = packageJson.version;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@runloop/rl-cli",
-  "version": "0.2.0",
-  "description": "Beautiful CLI for Runloop devbox management",
+  "version": "0.3.0",
+  "description": "Beautiful CLI for the Runloop platform",
   "type": "module",
   "bin": {
     "rli": "./dist/cli.js"
@@ -21,11 +21,9 @@
     "lint": "eslint src --ext .ts,.tsx",
     "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "test": "jest",
-    "test:unit": "jest tests/__tests__/unit",
-    "test:integration": "jest tests/__tests__/integration",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "test:e2e": "RUN_E2E=1 jest tests/__tests__/integration"
+    "test:components": "NODE_OPTIONS='--experimental-vm-modules' jest --config jest.components.config.js --coverage --forceExit"
   },
   "keywords": [
     "runloop",
@@ -89,6 +87,7 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^6.1.1",
     "globals": "^16.4.0",
+    "ink-testing-library": "^4.0.0",
     "jest": "^29.7.0",
     "prettier": "^3.6.2",
     "ts-jest": "^29.1.0",