@runloop/rl-cli 1.8.0 → 1.10.0

package/dist/commands/devbox/create.js

@@ -42,6 +42,33 @@ function parseCodeMounts(codeMounts) {
         }
     });
 }
+// Parse gateways from ENV_PREFIX=gateway,secret format
+function parseGateways(gateways) {
+    const result = {};
+    for (const gateway of gateways) {
+        const eqIndex = gateway.indexOf("=");
+        if (eqIndex === -1) {
+            throw new Error(`Invalid gateway format: ${gateway}. Expected ENV_PREFIX=gateway_id_or_name,secret_id_or_name`);
+        }
+        const envPrefix = gateway.substring(0, eqIndex);
+        const valueStr = gateway.substring(eqIndex + 1);
+        // Split by comma to get gateway and secret
+        const commaIndex = valueStr.indexOf(",");
+        if (commaIndex === -1) {
+            throw new Error(`Invalid gateway format: ${gateway}. Expected ENV_PREFIX=gateway_id_or_name,secret_id_or_name`);
+        }
+        const gatewayIdOrName = valueStr.substring(0, commaIndex);
+        const secretIdOrName = valueStr.substring(commaIndex + 1);
+        if (!envPrefix || !gatewayIdOrName || !secretIdOrName) {
+            throw new Error(`Invalid gateway format: ${gateway}. Expected ENV_PREFIX=gateway_id_or_name,secret_id_or_name`);
+        }
+        result[envPrefix] = {
+            gateway: gatewayIdOrName,
+            secret: secretIdOrName,
+        };
+    }
+    return result;
+}
 export async function createDevbox(options = {}) {
     try {
         const client = getClient();
@@ -65,6 +92,10 @@ export async function createDevbox(options = {}) {
             (!options.idleTime && options.idleAction)) {
             outputError("Both --idle-time and --idle-action must be specified together");
         }
+        // Validate tunnel option
+        if (options.tunnel && !["open", "authenticated"].includes(options.tunnel)) {
+            outputError("Invalid tunnel mode. Must be either 'open' or 'authenticated'");
+        }
         // Build launch parameters
         const launchParameters = {};
         if (options.resources) {
@@ -128,6 +159,16 @@ export async function createDevbox(options = {}) {
         if (options.secrets && options.secrets.length > 0) {
             createRequest.secrets = parseSecrets(options.secrets);
         }
+        // Handle tunnel configuration
+        if (options.tunnel) {
+            createRequest.tunnel = {
+                auth_mode: options.tunnel,
+            };
+        }
+        // Handle gateways
+        if (options.gateways && options.gateways.length > 0) {
+            createRequest.gateways = parseGateways(options.gateways);
+        }
         if (Object.keys(launchParameters).length > 0) {
             createRequest.launch_parameters = launchParameters;
         }

package/dist/commands/devbox/list.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import React from "react";
-import { Box, Text, useInput, useApp } from "ink";
+import { Box, Text, useApp } from "ink";
 import figures from "figures";
 import { getClient } from "../../utils/client.js";
 import { SpinnerComponent } from "../../components/Spinner.js";
@@ -21,6 +21,8 @@ import { useViewportHeight } from "../../hooks/useViewportHeight.js";
 import { useExitOnCtrlC } from "../../hooks/useExitOnCtrlC.js";
 import { useCursorPagination } from "../../hooks/useCursorPagination.js";
 import { useListSearch } from "../../hooks/useListSearch.js";
+import { openInBrowser } from "../../utils/browser.js";
+import { useInputHandler, } from "../../hooks/useInputHandler.js";
 import { colors } from "../../utils/theme.js";
 import { useDevboxStore } from "../../store/devboxStore.js";
 const DEFAULT_PAGE_SIZE = 10;
@@ -302,8 +304,10 @@ const ListDevboxesUI = ({ status, onBack, onExit, onNavigateToDetail, }) => {
     const startIndex = currentPage * PAGE_SIZE;
     const endIndex = startIndex + devboxes.length;
     // Filter operations based on devbox status
+    const hasTunnel = !!(selectedDevbox?.tunnel && selectedDevbox.tunnel.tunnel_key);
     const operations = selectedDevbox
-        ? allOperations.filter((op) => {
+        ? allOperations
+            .filter((op) => {
             const devboxStatus = selectedDevbox.status;
             if (devboxStatus === "suspended") {
                 return op.key === "resume" || op.key === "logs";
@@ -318,127 +322,155 @@ const ListDevboxesUI = ({ status, onBack, onExit, onNavigateToDetail, }) => {
             }
             return op.key === "logs" || op.key === "delete";
         })
-        : allOperations;
-    useInput((input, key) => {
-        const pageDevboxes = devboxes.length;
-        // Skip input handling when in search mode - let TextInput handle it
-        if (search.searchMode) {
-            if (key.escape) {
-                search.cancelSearch();
+            .map((op) => {
+            // Dynamic tunnel label based on whether tunnel is active
+            if (op.key === "tunnel") {
+                return hasTunnel
+                    ? {
+                        ...op,
+                        label: "Tunnel (Active)",
+                        color: colors.success,
+                        icon: figures.tick,
+                    }
+                    : op;
             }
+            return op;
+        })
+        : allOperations;
+    const closePopup = React.useCallback(() => {
+        setShowPopup(false);
+        setSelectedOperation(0);
+    }, []);
+    const handleListEscape = React.useCallback(() => {
+        if (search.handleEscape())
             return;
+        if (onBack) {
+            onBack();
         }
-        // Skip input handling when in details view
-        if (showDetails) {
-            return;
+        else if (onExit) {
+            onExit();
         }
-        // Skip input handling when in create view
-        if (showCreate) {
-            return;
+        else {
+            inkExit();
         }
-        // Skip input handling when in actions view
-        if (showActions) {
+    }, [search, onBack, onExit, inkExit]);
+    const handleOpenInBrowser = React.useCallback(() => {
+        if (!selectedDevbox)
             return;
-        }
-        // Handle popup navigation
-        if (showPopup) {
-            if (key.escape || input === "q") {
-                setShowPopup(false);
-                setSelectedOperation(0);
-            }
-            else if (key.upArrow && selectedOperation > 0) {
-                setSelectedOperation(selectedOperation - 1);
-            }
-            else if (key.downArrow && selectedOperation < operations.length - 1) {
-                setSelectedOperation(selectedOperation + 1);
-            }
-            else if (key.return) {
-                setShowPopup(false);
-                setShowActions(true);
-            }
-            else if (input) {
-                const matchedOpIndex = operations.findIndex((op) => op.shortcut === input);
-                if (matchedOpIndex !== -1) {
-                    setSelectedOperation(matchedOpIndex);
-                    setShowPopup(false);
-                    setShowActions(true);
-                }
-            }
-            return;
-        }
-        // Handle list view
-        if (key.upArrow && selectedIndex > 0) {
-            setSelectedIndex(selectedIndex - 1);
-        }
-        else if (key.downArrow && selectedIndex < pageDevboxes - 1) {
-            setSelectedIndex(selectedIndex + 1);
-        }
-        else if ((input === "n" || key.rightArrow) &&
-            !loading &&
-            !navigating &&
-            hasMore) {
+        openInBrowser(getDevboxUrl(selectedDevbox.id));
+    }, [selectedDevbox]);
+    const goToNextPage = React.useCallback(() => {
+        if (!loading && !navigating && hasMore) {
             nextPage();
             setSelectedIndex(0);
         }
-        else if ((input === "p" || key.leftArrow) &&
-            !loading &&
-            !navigating &&
-            hasPrev) {
+    }, [loading, navigating, hasMore, nextPage]);
+    const goToPrevPage = React.useCallback(() => {
+        if (!loading && !navigating && hasPrev) {
             prevPage();
             setSelectedIndex(0);
         }
-        else if (key.return) {
-            if (onNavigateToDetail && selectedDevbox) {
-                onNavigateToDetail(selectedDevbox.id);
-            }
-            else {
-                setShowDetails(true);
-            }
-        }
-        else if (input === "a") {
-            setShowPopup(true);
-            setSelectedOperation(0);
-        }
-        else if (input === "c") {
-            setShowCreate(true);
-        }
-        else if (input === "o" && selectedDevbox) {
-            const url = getDevboxUrl(selectedDevbox.id);
-            const openBrowser = async () => {
-                const { exec } = await import("child_process");
-                const platform = process.platform;
-                let openCommand;
-                if (platform === "darwin") {
-                    openCommand = `open "${url}"`;
-                }
-                else if (platform === "win32") {
-                    openCommand = `start "${url}"`;
-                }
-                else {
-                    openCommand = `xdg-open "${url}"`;
+    }, [loading, navigating, hasPrev, prevPage]);
+    const inputModes = React.useMemo(() => [
+        // Search mode: only escape to cancel, swallow everything else
+        {
+            name: "search",
+            active: () => search.searchMode,
+            bindings: {
+                escape: () => search.cancelSearch(),
+            },
+            captureAll: true,
+        },
+        // Subview guards: swallow all input when a child view is active
+        {
+            name: "subviews",
+            active: () => showDetails || showCreate || showActions,
+            bindings: {},
+            captureAll: true,
+        },
+        // Popup navigation
+        {
+            name: "popup",
+            active: () => showPopup,
+            bindings: {
+                escape: closePopup,
+                q: closePopup,
+                up: () => {
+                    if (selectedOperation > 0)
+                        setSelectedOperation(selectedOperation - 1);
+                },
+                down: () => {
+                    if (selectedOperation < operations.length - 1)
+                        setSelectedOperation(selectedOperation + 1);
+                },
+                enter: () => {
+                    setShowPopup(false);
+                    setShowActions(true);
+                },
+            },
+            onUnmatched: (input) => {
+                const idx = operations.findIndex((op) => op.shortcut === input);
+                if (idx !== -1) {
+                    setSelectedOperation(idx);
+                    setShowPopup(false);
+                    setShowActions(true);
                 }
-                exec(openCommand);
-            };
-            openBrowser();
-        }
-        else if (input === "/") {
-            search.enterSearchMode();
-        }
-        else if (key.escape) {
-            if (search.handleEscape()) {
-                return;
-            }
-            if (onBack) {
-                onBack();
-            }
-            else if (onExit) {
-                onExit();
-            }
-            else {
-                inkExit();
-            }
-        }
-    });
+            },
+        },
+        // List navigation (default mode)
+        {
+            name: "list",
+            active: () => true,
+            bindings: {
+                up: () => {
+                    if (selectedIndex > 0)
+                        setSelectedIndex(selectedIndex - 1);
+                },
+                down: () => {
+                    if (selectedIndex < devboxes.length - 1)
+                        setSelectedIndex(selectedIndex + 1);
+                },
+                n: goToNextPage,
+                right: goToNextPage,
+                p: goToPrevPage,
+                left: goToPrevPage,
+                enter: () => {
+                    if (onNavigateToDetail && selectedDevbox) {
+                        onNavigateToDetail(selectedDevbox.id);
+                    }
+                    else {
+                        setShowDetails(true);
+                    }
+                },
+                a: () => {
+                    setShowPopup(true);
+                    setSelectedOperation(0);
+                },
+                c: () => setShowCreate(true),
+                o: handleOpenInBrowser,
+                "/": () => search.enterSearchMode(),
+                escape: handleListEscape,
+            },
+        },
+    ], [
+        search,
+        showDetails,
+        showCreate,
+        showActions,
+        showPopup,
+        closePopup,
+        selectedOperation,
+        operations,
+        selectedIndex,
+        devboxes.length,
+        goToNextPage,
+        goToPrevPage,
+        onNavigateToDetail,
+        selectedDevbox,
+        handleOpenInBrowser,
+        handleListEscape,
+    ]);
+    useInputHandler(inputModes);
     // Create view
     if (showCreate) {
         return (_jsx(DevboxCreatePage, { onBack: () => {

package/dist/commands/devbox/rsync.js

@@ -1,62 +1,90 @@
 /**
  * Rsync files to/from devbox command
+ *
+ * Supports standard rsync-like syntax where the devbox ID (dbx_*) is used as a hostname:
+ *   rli devbox rsync dbx_abc123:/remote/path ./local/path          # download
+ *   rli devbox rsync ./local/path dbx_abc123:/remote/path          # upload
+ *   rli devbox rsync root@dbx_abc123:/remote/path ./local/path     # explicit user
+ *
+ * If no user is specified for a remote path, the devbox's configured user is used.
+ * Paths without a dbx_ hostname are treated as local paths.
  */
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
-import { getClient } from "../../utils/client.js";
 import { output, outputError } from "../../utils/output.js";
-import { getSSHKey, getProxyCommand, checkSSHTools } from "../../utils/ssh.js";
-const execAsync = promisify(exec);
-export async function rsyncFiles(devboxId, options) {
+import { getProxyCommand, checkSSHTools } from "../../utils/ssh.js";
+import { parseSCPPath, resolveRemote } from "./scp.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Build the rsync command for a single-remote transfer (local <-> devbox).
+ */
+export function buildRsyncCommand(opts) {
+    // Rsync re-splits the -e value on whitespace internally, so the
+    // ProxyCommand (which contains spaces) must be single-quoted.
+    const sshTransport = `ssh -i ${opts.sshInfo.keyfilePath} -o 'ProxyCommand=${opts.proxyCommand}' -o StrictHostKeyChecking=no`;
+    const rsyncCommand = [
+        "rsync",
+        "-vrz", // v: verbose, r: recursive, z: compress
+        "-e",
+        sshTransport,
+    ];
+    if (opts.rsyncOptions) {
+        rsyncCommand.push(...opts.rsyncOptions.split(" "));
+    }
+    // Build src argument
+    if (opts.parsedSrc.isRemote) {
+        const user = opts.parsedSrc.user || opts.defaultUser;
+        rsyncCommand.push(`${user}@${opts.sshInfo.url}:${opts.parsedSrc.path}`);
+    }
+    else {
+        rsyncCommand.push(opts.parsedSrc.path);
+    }
+    // Build dst argument
+    if (opts.parsedDst.isRemote) {
+        const user = opts.parsedDst.user || opts.defaultUser;
+        rsyncCommand.push(`${user}@${opts.sshInfo.url}:${opts.parsedDst.path}`);
+    }
+    else {
+        rsyncCommand.push(opts.parsedDst.path);
+    }
+    return rsyncCommand;
+}
+export async function rsyncFiles(src, dst, options) {
     try {
         // Check if SSH tools are available
         const sshToolsAvailable = await checkSSHTools();
         if (!sshToolsAvailable) {
             outputError("SSH tools (ssh, rsync, openssl) are not available on this system");
         }
-        const client = getClient();
-        // Get devbox details to determine user
-        const devbox = await client.devboxes.retrieve(devboxId);
-        const user = devbox.launch_parameters?.user_parameters?.username || "user";
-        // Get SSH key
-        const sshInfo = await getSSHKey(devboxId);
-        if (!sshInfo) {
-            outputError("Failed to create SSH key");
-        }
-        const proxyCommand = getProxyCommand();
-        const sshOptions = `-i ${sshInfo.keyfilePath} -o ProxyCommand='${proxyCommand}' -o StrictHostKeyChecking=no`;
-        const rsyncCommand = [
-            "rsync",
-            "-vrz", // v: verbose, r: recursive, z: compress
-            "-e",
-            `"ssh ${sshOptions}"`,
-        ];
-        if (options.rsyncOptions) {
-            rsyncCommand.push(...options.rsyncOptions.split(" "));
-        }
-        // Handle remote paths (starting with :)
-        if (options.src.startsWith(":")) {
-            rsyncCommand.push(`${user}@${sshInfo.url}:${options.src.slice(1)}`);
-            rsyncCommand.push(options.dst);
+        const parsedSrc = parseSCPPath(src);
+        const parsedDst = parseSCPPath(dst);
+        if (!parsedSrc.isRemote && !parsedDst.isRemote) {
+            outputError("At least one of src or dst must be a remote devbox path (e.g. dbx_<id>:/path)");
         }
-        else {
-            rsyncCommand.push(options.src);
-            if (options.dst.startsWith(":")) {
-                rsyncCommand.push(`${user}@${sshInfo.url}:${options.dst.slice(1)}`);
-            }
-            else {
-                rsyncCommand.push(options.dst);
-            }
+        if (parsedSrc.isRemote && parsedDst.isRemote) {
+            outputError("Devbox-to-devbox rsync is not supported. Only one side can be a remote devbox path.");
         }
-        await execAsync(rsyncCommand.join(" "));
+        const devboxId = parsedSrc.isRemote ? parsedSrc.host : parsedDst.host;
+        const remote = await resolveRemote(devboxId);
+        const proxyCommand = getProxyCommand();
+        const rsyncCommand = buildRsyncCommand({
+            sshInfo: remote.sshInfo,
+            proxyCommand,
+            parsedSrc,
+            parsedDst,
+            defaultUser: remote.defaultUser,
+            rsyncOptions: options.rsyncOptions,
+        });
+        const [cmd, ...args] = rsyncCommand;
+        await execFileAsync(cmd, args);
         // Default: just output the destination for easy scripting
         if (!options.output || options.output === "text") {
-            console.log(options.dst);
+            console.log(dst);
         }
         else {
             output({
-                source: options.src,
-                destination: options.dst,
+                source: src,
+                destination: dst,
             }, { format: options.output, defaultFormat: "json" });
         }
     }