@runloop/rl-cli 0.1.2 → 0.2.0

package/dist/commands/devbox/download.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";
+/**
+ * Download file from devbox command
+ */
 import { writeFileSync } from "fs";
-const DownloadFileUI = ({ devboxId, filePath, outputPath }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const downloadFile = async () => {
-            try {
-                const client = getClient();
-                const result = await client.devboxes.downloadFile(devboxId, {
-                    path: filePath,
-                });
-                // The result should contain the file contents, write them to the output path
-                writeFileSync(outputPath, result);
-                setResult({ filePath, outputPath });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        downloadFile();
-    }, [devboxId, filePath, outputPath]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && (_jsx(SpinnerComponent, { message: "Downloading file from devbox..." })), result && (_jsx(SuccessMessage, { message: "File downloaded successfully", details: `Remote: ${result.filePath}\nLocal: ${result.outputPath}` })), error && (_jsx(ErrorMessage, { message: "Failed to download file", error: error }))] }));
-};
-export async function downloadFile(devboxId, options) {
-    const executor = createExecutor({ output: options.outputFormat });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+export async function downloadFile(devboxId, options = {}) {
+    if (!options.filePath) {
+        outputError("--file-path is required");
+    }
+    if (!options.outputPath) {
+        outputError("--output-path is required");
+    }
+    try {
+        const client = getClient();
         const result = await client.devboxes.downloadFile(devboxId, {
             path: options.filePath,
         });
+        // Write the file contents to the output path
         writeFileSync(options.outputPath, result);
-        return {
-            filePath: options.filePath,
-            outputPath: options.outputPath,
-        };
-    }, () => (_jsx(DownloadFileUI, { devboxId: devboxId, filePath: options.filePath, 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.filePath,
+                local: options.outputPath,
+            }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to download file", error);
+    }
 }

package/dist/commands/devbox/exec.js

@@ -1,45 +1,28 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * Execute command in devbox
+ */
 import { getClient } from "../../utils/client.js";
-import { Header } from "../../components/Header.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { colors } from "../../utils/theme.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-const ExecCommandUI = ({ id, command, }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [output, setOutput] = React.useState("");
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const exec = async () => {
-            try {
-                const client = getClient();
-                const result = await client.devboxes.executeSync(id, {
-                    command: command.join(" "),
-                });
-                setOutput(result.stdout || result.stderr || "Command executed successfully");
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        exec();
-    }, []);
-    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Execute Command", subtitle: `Running in devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Executing command..." }), !loading && !error && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(Box, { borderStyle: "round", borderColor: colors.success, padding: 1, children: _jsx(Text, { children: output }) }) })), error && (_jsx(ErrorMessage, { message: "Failed to execute command", error: error }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 export async function execCommand(id, command, options = {}) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
+    try {
+        const client = getClient();
         const result = await client.devboxes.executeSync(id, {
             command: command.join(" "),
+            shell_name: options.shellName || undefined,
         });
-        return {
-            result: result.stdout || result.stderr || "Command executed successfully",
-        };
-    }, () => _jsx(ExecCommandUI, { id: id, command: command }));
+        // For text output, just print stdout/stderr directly
+        if (!options.output || options.output === "text") {
+            if (result.stdout) {
+                console.log(result.stdout);
+            }
+            if (result.stderr) {
+                console.error(result.stderr);
+            }
+            return;
+        }
+        output(result, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to execute command", error);
+    }
 }

package/dist/commands/devbox/execAsync.js

@@ -1,43 +1,26 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Execute command asynchronously in devbox
+ */
 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 ExecAsyncUI = ({ devboxId, command, shellName }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const execAsync = async () => {
-            try {
-                const client = getClient();
-                const execution = await client.devboxes.executeAsync(devboxId, {
-                    command,
-                    shell_name: shellName || undefined,
-                });
-                setResult(execution);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        execAsync();
-    }, [devboxId, command, shellName]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Starting async execution..." }), result && (_jsx(SuccessMessage, { message: "Async execution started", details: `Execution ID: ${result.id}\nCommand: ${command}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to start async execution", error: error }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 export async function execAsync(devboxId, options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.executeAsync(devboxId, {
+    try {
+        const client = getClient();
+        const execution = await client.devboxes.executeAsync(devboxId, {
             command: options.command,
             shell_name: options.shellName || undefined,
         });
-    }, () => (_jsx(ExecAsyncUI, { devboxId: devboxId, command: options.command, shellName: options.shellName })));
+        // Default: just output the execution ID for easy scripting
+        if (!options.output || options.output === "text") {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const execId = execution.execution_id || execution.id;
+            console.log(execId);
+        }
+        else {
+            output(execution, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to start async execution", error);
+    }
 }

package/dist/commands/devbox/get.js

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

package/dist/commands/devbox/getAsync.js

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