@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/commands/devbox/logs.js

@@ -1,40 +1,22 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * Get devbox logs command
+ */
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-import { colors } from "../../utils/theme.js";
-const LogsUI = ({ devboxId }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const getLogs = async () => {
-            try {
-                const client = getClient();
-                const logs = await client.devboxes.logs.list(devboxId);
-                setResult(logs);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        getLogs();
-    }, [devboxId]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Fetching devbox logs..." }), result && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.primary, children: "Devbox Logs:" }), result.logs && result.logs.length > 0 ? (result.logs.map((log, index) => (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: colors.textDim, children: log.timestampMs
-                                    ? new Date(log.timestampMs).toISOString()
-                                    : "" }), log.source && (_jsxs(Text, { color: colors.textDim, children: [" [", log.source, "]"] })), log.cmd && (_jsxs(Text, { color: colors.primary, children: [" ", "->", " ", log.cmd] })), log.message && _jsxs(Text, { children: [" ", log.message] }), log.exitCode !== null && (_jsxs(Text, { color: colors.warning, children: [" ", "->", " exit_code=", log.exitCode] }))] }, index)))) : (_jsx(Text, { color: colors.textDim, children: "No logs available" }))] })), error && (_jsx(ErrorMessage, { message: "Failed to get devbox logs", error: error }))] }));
-};
-export async function getLogs(devboxId, options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.logs.list(devboxId);
-    }, () => _jsx(LogsUI, { devboxId: devboxId }));
+import { output, outputError } from "../../utils/output.js";
+import { formatLogsForCLI } from "../../utils/logFormatter.js";
+export async function getLogs(devboxId, options = {}) {
+    try {
+        const client = getClient();
+        const logs = await client.devboxes.logs.list(devboxId);
+        // Pretty print for text output, JSON for others
+        if (!options.output || options.output === "text") {
+            formatLogsForCLI(logs);
+        }
+        else {
+            output(logs, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to get devbox logs", error);
+    }
 }

package/dist/commands/devbox/read.js

@@ -1,49 +1,35 @@
-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";
+/**
+ * Read file from devbox command (using API)
+ */
 import { writeFile } from "fs/promises";
-const ReadFileUI = ({ devboxId, remotePath, outputPath }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const readFile = async () => {
-            try {
-                const client = getClient();
-                const contents = await client.devboxes.readFileContents(devboxId, {
-                    file_path: remotePath,
-                });
-                await writeFile(outputPath, contents);
-                setResult({ remotePath, outputPath, size: contents.length });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        readFile();
-    }, [devboxId, remotePath, outputPath]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Reading file from devbox..." }), result && (_jsx(SuccessMessage, { message: "File read successfully", details: `Remote: ${result.remotePath}\nLocal: ${result.outputPath}\nSize: ${result.size} bytes` })), error && _jsx(ErrorMessage, { message: "Failed to read file", error: error })] }));
-};
-export async function readFile(devboxId, options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+export async function readFile(devboxId, options = {}) {
+    if (!options.remote) {
+        outputError("--remote is required");
+    }
+    if (!options.outputPath) {
+        outputError("--output-path is required");
+    }
+    try {
+        const client = getClient();
         const contents = await client.devboxes.readFileContents(devboxId, {
             file_path: options.remote,
         });
         await writeFile(options.outputPath, contents);
-        return {
-            remotePath: options.remote,
-            outputPath: options.outputPath,
-            size: contents.length,
-        };
-    }, () => (_jsx(ReadFileUI, { devboxId: devboxId, remotePath: options.remote, outputPath: options.outputPath })));
+        // Default: just output the local path for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.outputPath);
+        }
+        else {
+            output({
+                remote: options.remote,
+                local: options.outputPath,
+                size: contents.length,
+            }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to read file", error);
+    }
 }

package/dist/commands/devbox/resume.js

@@ -1,37 +1,15 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Resume devbox 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 ResumeDevboxUI = ({ devboxId }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const resumeDevbox = async () => {
-            try {
-                const client = getClient();
-                const devbox = await client.devboxes.resume(devboxId);
-                setResult(devbox);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        resumeDevbox();
-    }, [devboxId]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Resuming devbox..." }), result && (_jsx(SuccessMessage, { message: "Devbox resumed", details: `ID: ${result.id}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to resume devbox", error: error }))] }));
-};
-export async function resumeDevbox(devboxId, options) {
-    const executor = createExecutor(options);
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.resume(devboxId);
-    }, () => _jsx(ResumeDevboxUI, { devboxId: devboxId }));
+import { output, outputError } from "../../utils/output.js";
+export async function resumeDevbox(devboxId, options = {}) {
+    try {
+        const client = getClient();
+        const devbox = await client.devboxes.resume(devboxId);
+        output(devbox, { format: options.output, defaultFormat: "text" });
+    }
+    catch (error) {
+        outputError("Failed to resume devbox", error);
+    }
 }

package/dist/commands/devbox/rsync.js

@@ -1,91 +1,27 @@
-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";
-import { getSSHKey, getProxyCommand, checkSSHTools } from "../../utils/ssh.js";
+/**
+ * Rsync files to/from devbox command
+ */
 import { exec } 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);
-const RsyncUI = ({ devboxId, src, dst, rsyncOptions }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const performRsync = async () => {
-            try {
-                // Check if SSH tools are available
-                const sshToolsAvailable = await checkSSHTools();
-                if (!sshToolsAvailable) {
-                    throw new Error("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) {
-                    throw new Error("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 (rsyncOptions) {
-                    rsyncCommand.push(...rsyncOptions.split(" "));
-                }
-                // Handle remote paths (starting with :)
-                if (src.startsWith(":")) {
-                    rsyncCommand.push(`${user}@${sshInfo.url}:${src.slice(1)}`);
-                    rsyncCommand.push(dst);
-                }
-                else {
-                    rsyncCommand.push(src);
-                    if (dst.startsWith(":")) {
-                        rsyncCommand.push(`${user}@${sshInfo.url}:${dst.slice(1)}`);
-                    }
-                    else {
-                        rsyncCommand.push(dst);
-                    }
-                }
-                const { stdout, stderr } = await execAsync(rsyncCommand.join(" "));
-                setResult({ src, dst, stdout, stderr });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        performRsync();
-    }, [devboxId, src, dst, rsyncOptions]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Syncing files with rsync..." }), result && (_jsx(SuccessMessage, { message: "Rsync operation completed", details: `Source: ${result.src}\nDestination: ${result.dst}` })), error && _jsx(ErrorMessage, { message: "Rsync operation failed", error: error })] }));
-};
 export async function rsyncFiles(devboxId, options) {
-    const executor = createExecutor({ output: options.outputFormat });
-    await executor.executeAction(async () => {
+    try {
         // Check if SSH tools are available
         const sshToolsAvailable = await checkSSHTools();
         if (!sshToolsAvailable) {
-            throw new Error("SSH tools (ssh, rsync, openssl) are not available on this system");
+            outputError("SSH tools (ssh, rsync, openssl) are not available on this system");
         }
-        const client = executor.getClient();
+        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) {
-            throw new Error("Failed to create SSH key");
+            outputError("Failed to create SSH key");
         }
         const proxyCommand = getProxyCommand();
         const sshOptions = `-i ${sshInfo.keyfilePath} -o ProxyCommand='${proxyCommand}' -o StrictHostKeyChecking=no`;
@@ -93,7 +29,7 @@ export async function rsyncFiles(devboxId, options) {
             "rsync",
             "-vrz", // v: verbose, r: recursive, z: compress
             "-e",
-            `ssh ${sshOptions}`,
+            `"ssh ${sshOptions}"`,
         ];
         if (options.rsyncOptions) {
             rsyncCommand.push(...options.rsyncOptions.split(" "));
@@ -112,7 +48,19 @@ export async function rsyncFiles(devboxId, options) {
                 rsyncCommand.push(options.dst);
             }
         }
-        const { stdout, stderr } = await execAsync(rsyncCommand.join(" "));
-        return { src: options.src, dst: options.dst, stdout, stderr };
-    }, () => (_jsx(RsyncUI, { devboxId: devboxId, src: options.src, dst: options.dst, rsyncOptions: options.rsyncOptions })));
+        await execAsync(rsyncCommand.join(" "));
+        // Default: just output the destination for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.dst);
+        }
+        else {
+            output({
+                source: options.src,
+                destination: options.dst,
+            }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Rsync operation failed", error);
+    }
 }

package/dist/commands/devbox/scp.js

@@ -1,93 +1,27 @@
-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";
-import { getSSHKey, getProxyCommand, checkSSHTools } from "../../utils/ssh.js";
+/**
+ * SCP files to/from devbox command
+ */
 import { exec } 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);
-const SCPUI = ({ devboxId, src, dst, scpOptions }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const performSCP = async () => {
-            try {
-                // Check if SSH tools are available
-                const sshToolsAvailable = await checkSSHTools();
-                if (!sshToolsAvailable) {
-                    throw new Error("SSH tools (ssh, scp, 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) {
-                    throw new Error("Failed to create SSH key");
-                }
-                const proxyCommand = getProxyCommand();
-                const scpCommand = [
-                    "scp",
-                    "-i",
-                    sshInfo.keyfilePath,
-                    "-o",
-                    `ProxyCommand=${proxyCommand}`,
-                    "-o",
-                    "StrictHostKeyChecking=no",
-                ];
-                if (scpOptions) {
-                    scpCommand.push(...scpOptions.split(" "));
-                }
-                // Handle remote paths (starting with :)
-                if (src.startsWith(":")) {
-                    scpCommand.push(`${user}@${sshInfo.url}:${src.slice(1)}`);
-                    scpCommand.push(dst);
-                }
-                else {
-                    scpCommand.push(src);
-                    if (dst.startsWith(":")) {
-                        scpCommand.push(`${user}@${sshInfo.url}:${dst.slice(1)}`);
-                    }
-                    else {
-                        scpCommand.push(dst);
-                    }
-                }
-                const { stdout, stderr } = await execAsync(scpCommand.join(" "));
-                setResult({ src, dst, stdout, stderr });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        performSCP();
-    }, [devboxId, src, dst, scpOptions]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Copying files with SCP..." }), result && (_jsx(SuccessMessage, { message: "SCP operation completed", details: `Source: ${result.src}\nDestination: ${result.dst}` })), error && _jsx(ErrorMessage, { message: "SCP operation failed", error: error })] }));
-};
 export async function scpFiles(devboxId, options) {
-    const executor = createExecutor({ output: options.outputFormat });
-    await executor.executeAction(async () => {
+    try {
         // Check if SSH tools are available
         const sshToolsAvailable = await checkSSHTools();
         if (!sshToolsAvailable) {
-            throw new Error("SSH tools (ssh, scp, openssl) are not available on this system");
+            outputError("SSH tools (ssh, scp, openssl) are not available on this system");
         }
-        const client = executor.getClient();
+        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) {
-            throw new Error("Failed to create SSH key");
+            outputError("Failed to create SSH key");
         }
         const proxyCommand = getProxyCommand();
         const scpCommand = [
@@ -116,7 +50,19 @@ export async function scpFiles(devboxId, options) {
                 scpCommand.push(options.dst);
             }
         }
-        const { stdout, stderr } = await execAsync(scpCommand.join(" "));
-        return { src: options.src, dst: options.dst, stdout, stderr };
-    }, () => (_jsx(SCPUI, { devboxId: devboxId, src: options.src, dst: options.dst, scpOptions: options.scpOptions })));
+        await execAsync(scpCommand.join(" "));
+        // Default: just output the destination for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.dst);
+        }
+        else {
+            output({
+                source: options.src,
+                destination: options.dst,
+            }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("SCP operation failed", error);
+    }
 }

package/dist/commands/devbox/sendStdin.js

@@ -0,0 +1,41 @@
+/**
+ * Send stdin to a running async execution
+ */
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+export async function sendStdin(devboxId, executionId, options = {}) {
+    try {
+        // Validate that either text or signal is provided, but not both
+        if (!options.text && !options.signal) {
+            outputError("Either --text or --signal must be specified");
+        }
+        if (options.text && options.signal) {
+            outputError("Only one of --text or --signal can be specified");
+        }
+        const client = getClient();
+        // Build the request body
+        const requestBody = {};
+        if (options.text) {
+            requestBody.text = options.text;
+        }
+        if (options.signal) {
+            requestBody.signal = options.signal;
+        }
+        const result = await client.devboxes.executions.sendStdIn(devboxId, executionId, requestBody);
+        // Default: just confirm success for text output
+        if (!options.output || options.output === "text") {
+            if (options.text) {
+                console.log(`Sent text to execution ${executionId}`);
+            }
+            else {
+                console.log(`Sent ${options.signal} signal to execution ${executionId}`);
+            }
+        }
+        else {
+            output(result, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to send stdin", error);
+    }
+}

package/dist/commands/devbox/shutdown.js

@@ -1,37 +1,15 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Shutdown devbox 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 ShutdownDevboxUI = ({ devboxId }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const shutdownDevbox = async () => {
-            try {
-                const client = getClient();
-                const devbox = await client.devboxes.shutdown(devboxId);
-                setResult(devbox);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        shutdownDevbox();
-    }, [devboxId]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Shutting down devbox..." }), result && (_jsx(SuccessMessage, { message: "Devbox shutdown", details: `ID: ${result.id}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to shutdown devbox", error: error }))] }));
-};
-export async function shutdownDevbox(devboxId, options) {
-    const executor = createExecutor(options);
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.shutdown(devboxId);
-    }, () => _jsx(ShutdownDevboxUI, { devboxId: devboxId }));
+import { output, outputError } from "../../utils/output.js";
+export async function shutdownDevbox(devboxId, options = {}) {
+    try {
+        const client = getClient();
+        const devbox = await client.devboxes.shutdown(devboxId);
+        output(devbox, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to shutdown devbox", error);
+    }
 }