@runloop/rl-cli 0.1.1 → 0.2.0

package/README.md

@@ -63,6 +63,60 @@ export RUNLOOP_API_KEY=your_api_key_here
 
 The CLI will automatically use `RUNLOOP_API_KEY` if set, otherwise it will use the stored configuration.
 
+### Theme Configuration
+
+The CLI supports both light and dark terminal themes with automatic detection:
+
+```bash
+# Interactive theme selector with live preview
+rli config theme
+
+# Or set theme directly
+rli config theme auto    # Auto-detect terminal background (default)
+rli config theme light   # Force light mode (dark text on light background)
+rli config theme dark    # Force dark mode (light text on dark background)
+
+# Or use environment variable
+export RUNLOOP_THEME=light
+```
+
+**Interactive Mode:**
+
+- When you run `rli config theme` without arguments, you get an interactive selector
+- Use arrow keys to navigate between auto/light/dark options
+- See live preview of colors as you navigate
+- Press Enter to save, Esc to cancel
+
+**How it works:**
+
+- **auto** (default): Uses dark mode by default (theme detection is disabled to prevent terminal flashing)
+- **light**: Optimized for light-themed terminals (uses dark text colors)
+- **dark**: Optimized for dark-themed terminals (uses light text colors)
+
+**Terminal Compatibility:**
+
+- Works with all modern terminals (iTerm2, Terminal.app, VS Code integrated terminal, tmux)
+- The CLI defaults to dark mode for the best experience
+- You can manually set light or dark mode based on your terminal theme
+
+**Note on Auto-Detection:**
+
+- Auto theme detection is **disabled by default** to prevent screen flashing
+- To enable it, set `RUNLOOP_ENABLE_THEME_DETECTION=1`
+- If you use a light terminal, we recommend setting: `rli config theme light`
+- The result is cached, so subsequent runs are instant (no flashing!)
+- If you change your terminal theme, you can re-detect by running:
+
+  ```bash
+  rli config theme auto
+  ```
+- To manually set your theme without detection:
+  ```bash
+  export RUNLOOP_THEME=dark  # or light
+  # Or disable auto-detection entirely:
+  export RUNLOOP_DISABLE_THEME_DETECTION=1
+  ```
+
 ### Devbox Commands
 
 ```bash

package/dist/cli.js

@@ -14,10 +14,11 @@ 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;
+import { exitAlternateScreenBuffer } from "./utils/screen.js";
 // Global Ctrl+C handler to ensure it always exits
 process.on("SIGINT", () => {
     // Force exit immediately, clearing alternate screen buffer
-    process.stdout.write("\x1b[?1049l");
+    exitAlternateScreenBuffer();
     process.stdout.write("\n");
     process.exit(130); // Standard exit code for SIGINT
 });
@@ -33,34 +34,50 @@ program
     const { default: auth } = await import("./commands/auth.js");
     auth();
 });
-program
-    .command("check-updates")
-    .description("Check for CLI updates")
+// Config commands
+const config = program
+    .command("config")
+    .description("Configure CLI settings")
     .action(async () => {
-    const { checkForUpdates } = await import("./utils/config.js");
-    console.log("Checking for updates...");
-    await checkForUpdates(true);
+    const { showThemeConfig } = await import("./commands/config.js");
+    showThemeConfig();
+});
+config
+    .command("theme [mode]")
+    .description("Get or set theme mode (auto|light|dark)")
+    .action(async (mode) => {
+    const { showThemeConfig, setThemeConfig } = await import("./commands/config.js");
+    if (!mode) {
+        showThemeConfig();
+    }
+    else if (mode === "auto" || mode === "light" || mode === "dark") {
+        setThemeConfig(mode);
+    }
+    else {
+        console.error(`\n❌ Invalid theme mode: ${mode}\nValid options: auto, light, dark\n`);
+        process.exit(1);
+    }
 });
 // Devbox commands
 const devbox = program
     .command("devbox")
     .description("Manage devboxes")
-    .alias("d")
-    .action(async () => {
-    // Open interactive devbox list when no subcommand provided
-    const { runInteractiveCommand } = await import("./utils/interactiveCommand.js");
-    const { listDevboxes } = await import("./commands/devbox/list.js");
-    await runInteractiveCommand(() => listDevboxes({ output: "interactive" }));
-});
+    .alias("d");
 devbox
     .command("create")
     .description("Create a new devbox")
     .option("-n, --name <name>", "Devbox name")
-    .option("-t, --template <template>", "Template to use")
-    .option("--blueprint <blueprint>", "Blueprint ID to use")
+    .option("-t, --template <template>", "Snapshot ID to use (alias: --snapshot)")
+    .option("-s, --snapshot <snapshot>", "Snapshot ID to use")
+    .option("--blueprint <blueprint>", "Blueprint name or ID to use")
     .option("--resources <size>", "Resource size (X_SMALL, SMALL, MEDIUM, LARGE, X_LARGE, XX_LARGE)")
     .option("--architecture <arch>", "Architecture (arm64, x86_64)")
     .option("--entrypoint <command>", "Entrypoint command to run")
+    .option("--launch-commands <commands...>", "Initialization commands to run on startup")
+    .option("--env-vars <vars...>", "Environment variables (format: KEY=value)")
+    .option("--code-mounts <mounts...>", "Code mount configurations (JSON format)")
+    .option("--idle-time <seconds>", "Idle time in seconds before idle action")
+    .option("--idle-action <action>", "Action on idle (shutdown, suspend)")
     .option("--available-ports <ports...>", "Available ports")
     .option("--root", "Run as root")
     .option("--user <user:uid>", "Run as this user (format: username:uid)")
@@ -69,7 +86,8 @@ devbox
 devbox
     .command("list")
     .description("List all devboxes")
-    .option("-s, --status <status>", "Filter by status")
+    .option("-s, --status <status>", "Filter by status (initializing, running, suspending, suspended, resuming, failure, shutdown)")
+    .option("-l, --limit <n>", "Max results", "20")
     .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
     .action(async (options) => {
     await listDevboxes(options);
@@ -83,6 +101,7 @@ devbox
 devbox
     .command("exec <id> <command...>")
     .description("Execute a command in a devbox")
+    .option("--shell-name <name>", "Shell name to use (optional)")
     .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
     .action(async (id, command, options) => {
     await execCommand(id, command, options);
@@ -211,6 +230,16 @@ devbox
     const { getAsync } = await import("./commands/devbox/getAsync.js");
     await getAsync(id, { executionId, ...options });
 });
+devbox
+    .command("send-stdin <id> <execution-id>")
+    .description("Send stdin to a running async execution")
+    .option("--text <text>", "Text content to send to stdin")
+    .option("--signal <signal>", "Signal to send (EOF, INTERRUPT)")
+    .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+    .action(async (id, executionId, options) => {
+    const { sendStdin } = await import("./commands/devbox/sendStdin.js");
+    await sendStdin(id, executionId, options);
+});
 devbox
     .command("logs <id>")
     .description("View devbox logs")
@@ -223,13 +252,7 @@ devbox
 const snapshot = program
     .command("snapshot")
     .description("Manage devbox snapshots")
-    .alias("snap")
-    .action(async () => {
-    // Open interactive snapshot list when no subcommand provided
-    const { runInteractiveCommand } = await import("./utils/interactiveCommand.js");
-    const { listSnapshots } = await import("./commands/snapshot/list.js");
-    await runInteractiveCommand(() => listSnapshots({ output: "interactive" }));
-});
+    .alias("snap");
 snapshot
     .command("list")
     .description("List all snapshots")
@@ -257,6 +280,14 @@ snapshot
     const { deleteSnapshot } = await import("./commands/snapshot/delete.js");
     deleteSnapshot(id, options);
 });
+snapshot
+    .command("get <id>")
+    .description("Get snapshot details")
+    .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+    .action(async (id, options) => {
+    const { getSnapshot } = await import("./commands/snapshot/get.js");
+    await getSnapshot({ id, ...options });
+});
 snapshot
     .command("status <snapshot-id>")
     .description("Get snapshot operation status")
@@ -269,24 +300,20 @@ snapshot
 const blueprint = program
     .command("blueprint")
     .description("Manage blueprints")
-    .alias("bp")
-    .action(async () => {
-    // Open interactive blueprint list when no subcommand provided
-    const { runInteractiveCommand } = await import("./utils/interactiveCommand.js");
-    const { listBlueprints } = await import("./commands/blueprint/list.js");
-    await runInteractiveCommand(() => listBlueprints({ output: "interactive" }));
-});
+    .alias("bp");
 blueprint
     .command("list")
     .description("List all blueprints")
+    .option("-n, --name <name>", "Filter by blueprint name")
     .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
     .action(async (options) => {
     const { listBlueprints } = await import("./commands/blueprint/list.js");
     await listBlueprints(options);
 });
 blueprint
-    .command("create <name>")
+    .command("create")
     .description("Create a new blueprint")
+    .requiredOption("--name <name>", "Blueprint name (required)")
     .option("--dockerfile <content>", "Dockerfile contents")
     .option("--dockerfile-path <path>", "Dockerfile path")
     .option("--system-setup-commands <commands...>", "System setup commands")
@@ -295,37 +322,22 @@ blueprint
     .option("--available-ports <ports...>", "Available ports")
     .option("--root", "Run as root")
     .option("--user <user:uid>", "Run as this user (format: username:uid)")
-    .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
-    .action(async (name, options) => {
+    .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+    .action(async (options) => {
     const { createBlueprint } = await import("./commands/blueprint/create.js");
-    await createBlueprint({ name, ...options });
-});
-blueprint
-    .command("preview <name>")
-    .description("Preview blueprint before creation")
-    .option("--dockerfile <content>", "Dockerfile contents")
-    .option("--system-setup-commands <commands...>", "System setup commands")
-    .option("--resources <size>", "Resource size (X_SMALL, SMALL, MEDIUM, LARGE, X_LARGE, XX_LARGE)")
-    .option("--architecture <arch>", "Architecture (arm64, x86_64)")
-    .option("--available-ports <ports...>", "Available ports")
-    .option("--root", "Run as root")
-    .option("--user <user:uid>", "Run as this user (format: username:uid)")
-    .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
-    .action(async (name, options) => {
-    const { previewBlueprint } = await import("./commands/blueprint/preview.js");
-    await previewBlueprint({ name, ...options });
+    await createBlueprint(options);
 });
 blueprint
-    .command("get <id>")
-    .description("Get blueprint details")
-    .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+    .command("get <name-or-id>")
+    .description("Get blueprint details by name or ID (IDs start with bpt_)")
+    .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
     .action(async (id, options) => {
     const { getBlueprint } = await import("./commands/blueprint/get.js");
     await getBlueprint({ id, ...options });
 });
 blueprint
-    .command("logs <id>")
-    .description("Get blueprint build logs")
+    .command("logs <name-or-id>")
+    .description("Get blueprint build logs by name or ID (IDs start with bpt_)")
     .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
     .action(async (id, options) => {
     const { getBlueprintLogs } = await import("./commands/blueprint/logs.js");
@@ -437,9 +449,13 @@ program
 });
 // Main CLI entry point
 (async () => {
-    // Check if API key is configured (except for auth and mcp commands)
+    // Initialize theme system early (before any UI rendering)
+    const { initializeTheme } = await import("./utils/theme.js");
+    await initializeTheme();
+    // Check if API key is configured (except for auth, config, and mcp commands)
     const args = process.argv.slice(2);
     if (args[0] !== "auth" &&
+        args[0] !== "config" &&
         args[0] !== "mcp" &&
         args[0] !== "mcp-server" &&
         args[0] !== "--help" &&
@@ -451,15 +467,12 @@ program
             process.exit(1);
         }
     }
-    // If no command provided, show main menu (version check handled in UI)
+    // If no command provided, show main menu
     if (args.length === 0) {
         const { runMainMenu } = await import("./commands/menu.js");
         runMainMenu();
     }
     else {
-        // Check for updates for non-interactive commands (stderr output)
-        const { checkForUpdates } = await import("./utils/config.js");
-        await checkForUpdates();
         program.parse();
     }
 })();

package/dist/commands/auth.js

@@ -24,6 +24,5 @@ const AuthUI = () => {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Banner, {}), _jsx(Header, { title: "Authentication" }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: colors.textDim, children: "Get your key: " }), _jsx(Text, { color: colors.primary, children: getSettingsUrl() })] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.primary, children: "API Key: " }), _jsx(TextInput, { value: apiKey, onChange: setApiKeyInput, placeholder: "ak_...", mask: "*" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.textDim, dimColor: true, children: "Press Enter to save" }) })] }));
 };
 export default function auth() {
-    console.clear();
     render(_jsx(AuthUI, {}));
 }

package/dist/commands/blueprint/create.js

@@ -1,78 +1,12 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
+/**
+ * Create blueprint command
+ */
 import { readFile } from "fs/promises";
-const CreateBlueprintUI = ({ name, dockerfile, dockerfilePath, systemSetupCommands, resources, architecture, availablePorts, root, user, }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const createBlueprint = async () => {
-            try {
-                const client = getClient();
-                // Read dockerfile from file if path is provided
-                let dockerfileContents = dockerfile;
-                if (dockerfilePath) {
-                    dockerfileContents = await readFile(dockerfilePath, "utf-8");
-                }
-                // Parse user parameters
-                let userParameters = undefined;
-                if (user && root) {
-                    throw new Error("Only one of --user or --root can be specified");
-                }
-                else if (user) {
-                    const [username, uid] = user.split(":");
-                    if (!username || !uid) {
-                        throw new Error("User must be in format 'username:uid'");
-                    }
-                    userParameters = { username, uid: parseInt(uid) };
-                }
-                else if (root) {
-                    userParameters = { username: "root", uid: 0 };
-                }
-                const blueprint = await client.blueprints.create({
-                    name,
-                    dockerfile: dockerfileContents,
-                    system_setup_commands: systemSetupCommands,
-                    launch_parameters: {
-                        resource_size_request: resources,
-                        architecture: architecture,
-                        available_ports: availablePorts?.map((port) => parseInt(port, 10)),
-                        user_parameters: userParameters,
-                    },
-                });
-                setResult(blueprint);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        createBlueprint();
-    }, [
-        name,
-        dockerfile,
-        dockerfilePath,
-        systemSetupCommands,
-        resources,
-        architecture,
-        availablePorts,
-        root,
-        user,
-    ]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Creating blueprint..." }), result && (_jsx(SuccessMessage, { message: "Blueprint created successfully", details: `ID: ${result.id}\nName: ${result.name}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to create blueprint", error: error }))] }));
-};
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
 export async function createBlueprint(options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
+    try {
+        const client = getClient();
         // Read dockerfile from file if path is provided
         let dockerfileContents = options.dockerfile;
         if (options.dockerfilePath) {
@@ -81,28 +15,42 @@ export async function createBlueprint(options) {
         // Parse user parameters
         let userParameters = undefined;
         if (options.user && options.root) {
-            throw new Error("Only one of --user or --root can be specified");
+            outputError("Only one of --user or --root can be specified");
         }
         else if (options.user) {
             const [username, uid] = options.user.split(":");
             if (!username || !uid) {
-                throw new Error("User must be in format 'username:uid'");
+                outputError("User must be in format 'username:uid'");
             }
             userParameters = { username, uid: parseInt(uid) };
         }
         else if (options.root) {
             userParameters = { username: "root", uid: 0 };
         }
-        return client.blueprints.create({
+        // Build launch parameters
+        const launchParameters = {};
+        if (options.resources) {
+            launchParameters.resource_size_request = options.resources;
+        }
+        if (options.architecture) {
+            launchParameters.architecture = options.architecture;
+        }
+        if (options.availablePorts) {
+            launchParameters.available_ports = options.availablePorts.map((port) => parseInt(port, 10));
+        }
+        if (userParameters) {
+            launchParameters.user_parameters = userParameters;
+        }
+        const blueprint = await client.blueprints.create({
             name: options.name,
             dockerfile: dockerfileContents,
             system_setup_commands: options.systemSetupCommands,
-            launch_parameters: {
-                resource_size_request: options.resources,
-                architecture: options.architecture,
-                available_ports: options.availablePorts?.map((port) => parseInt(port, 10)),
-                user_parameters: userParameters,
-            },
+            launch_parameters: launchParameters,
         });
-    }, () => (_jsx(CreateBlueprintUI, { name: options.name, dockerfile: options.dockerfile, dockerfilePath: options.dockerfilePath, systemSetupCommands: options.systemSetupCommands, resources: options.resources, architecture: options.architecture, availablePorts: options.availablePorts, root: options.root, user: options.user })));
+        // Default: output JSON
+        output(blueprint, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to create blueprint", error);
+    }
 }

package/dist/commands/blueprint/get.js

@@ -1,37 +1,32 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Get blueprint details command
+ */
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-const GetBlueprintUI = ({ blueprintId }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const getBlueprint = async () => {
-            try {
-                const client = getClient();
-                const blueprint = await client.blueprints.retrieve(blueprintId);
-                setResult(blueprint);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        getBlueprint();
-    }, [blueprintId]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Fetching blueprint details..." }), result && (_jsx(SuccessMessage, { message: "Blueprint details retrieved", details: `ID: ${result.id}\nName: ${result.name}\nStatus: ${result.status}\nCreated: ${new Date(result.createdAt).toLocaleString()}` })), error && (_jsx(ErrorMessage, { message: "Failed to get blueprint", error: error }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 export async function getBlueprint(options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.blueprints.retrieve(options.id);
-    }, () => _jsx(GetBlueprintUI, { blueprintId: options.id }));
+    try {
+        const client = getClient();
+        let blueprint;
+        // Check if it's an ID (starts with bpt_) or a name
+        if (options.id.startsWith("bpt_")) {
+            // It's an ID, retrieve directly
+            blueprint = await client.blueprints.retrieve(options.id);
+        }
+        else {
+            // It's a name, search for it
+            const result = await client.blueprints.list({ name: options.id });
+            const blueprints = result.blueprints || [];
+            if (blueprints.length === 0) {
+                outputError(`Blueprint not found: ${options.id}`);
+                return;
+            }
+            // Return the first exact match, or first result if no exact match
+            blueprint =
+                blueprints.find((b) => b.name === options.id) || blueprints[0];
+        }
+        output(blueprint, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to get blueprint", error);
+    }
 }