@runloop/rl-cli 0.0.3 → 0.1.1

package/dist/commands/blueprint/logs.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+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 BlueprintLogsUI = ({ blueprintId }) => {
+    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.blueprints.logs(blueprintId);
+                setResult(logs);
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        getLogs();
+    }, [blueprintId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && (_jsx(SpinnerComponent, { message: "Fetching blueprint build logs..." })), result && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.primary, children: "Blueprint Build 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()
+                                    : "" }), _jsxs(Text, { color: colors.textDim, children: [" [", log.level, "]"] }), _jsxs(Text, { children: [" ", log.message] })] }, index)))) : (_jsx(Text, { color: colors.textDim, children: "No logs available" }))] })), error && (_jsx(ErrorMessage, { message: "Failed to get blueprint logs", error: error }))] }));
+};
+export async function getBlueprintLogs(options) {
+    const executor = createExecutor({ output: options.output });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        return client.blueprints.logs(options.id);
+    }, () => _jsx(BlueprintLogsUI, { blueprintId: options.id }));
+}

package/dist/commands/blueprint/preview.js

@@ -0,0 +1,45 @@
+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";
+const PreviewBlueprintUI = ({ name, dockerfile, systemSetupCommands }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const previewBlueprint = async () => {
+            try {
+                const client = getClient();
+                const blueprint = await client.blueprints.preview({
+                    name,
+                    dockerfile,
+                    system_setup_commands: systemSetupCommands,
+                });
+                setResult(blueprint);
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        previewBlueprint();
+    }, [name, dockerfile, systemSetupCommands]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Previewing blueprint..." }), result && (_jsx(SuccessMessage, { message: "Blueprint preview generated", details: `Name: ${result.name}\nDockerfile: ${result.dockerfile ? "Present" : "Not provided"}\nSetup Commands: ${result.systemSetupCommands?.length || 0}` })), error && (_jsx(ErrorMessage, { message: "Failed to preview blueprint", error: error }))] }));
+};
+export async function previewBlueprint(options) {
+    const executor = createExecutor({ output: options.output });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        return client.blueprints.preview({
+            name: options.name,
+            dockerfile: options.dockerfile,
+            system_setup_commands: options.systemSetupCommands,
+        });
+    }, () => (_jsx(PreviewBlueprintUI, { name: options.name, dockerfile: options.dockerfile, systemSetupCommands: options.systemSetupCommands })));
+}

package/dist/commands/devbox/create.js

@@ -1,12 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from 'react';
-import { Box, Text } from 'ink';
-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 React from "react";
+import { Box, Text } from "ink";
+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 { colors } from "../../utils/theme.js";
 const CreateDevboxUI = ({ name, template }) => {
     const [loading, setLoading] = React.useState(true);
     const [result, setResult] = React.useState(null);
@@ -30,7 +31,7 @@ const CreateDevboxUI = ({ name, template }) => {
         };
         create();
     }, []);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Creating..." }), result && (_jsxs(_Fragment, { children: [_jsx(SuccessMessage, { message: "Devbox created!", details: `ID: ${result.id}\nStatus: ${result.status}` }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "gray", children: "Try: " }), _jsxs(Text, { color: "cyan", children: ["rln devbox exec ", result.id, " ls"] })] })] })), error && _jsx(ErrorMessage, { message: "Failed to create devbox", error: error })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Creating..." }), result && (_jsxs(_Fragment, { children: [_jsx(SuccessMessage, { message: "Devbox created!", details: `ID: ${result.id}\nStatus: ${result.status}` }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.textDim, children: "Try: " }), _jsxs(Text, { color: colors.primary, children: ["rli devbox exec ", result.id, " ls"] })] })] })), error && (_jsx(ErrorMessage, { message: "Failed to create devbox", error: error }))] }));
 };
 export async function createDevbox(options) {
     const executor = createExecutor(options);

package/dist/commands/devbox/delete.js

@@ -1,11 +1,11 @@
 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 { Header } from '../../components/Header.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 React from "react";
+import { getClient } from "../../utils/client.js";
+import { Header } from "../../components/Header.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 DeleteDevboxUI = ({ id }) => {
     const [loading, setLoading] = React.useState(true);
     const [success, setSuccess] = React.useState(false);
@@ -26,7 +26,7 @@ const DeleteDevboxUI = ({ id }) => {
         };
         deleteDevbox();
     }, []);
-    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Shutdown Devbox", subtitle: `Shutting down devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Shutting down devbox..." }), success && (_jsx(SuccessMessage, { message: "Devbox shut down successfully!", details: `ID: ${id}` })), error && _jsx(ErrorMessage, { message: "Failed to shutdown devbox", error: error })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Shutdown Devbox", subtitle: `Shutting down devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Shutting down devbox..." }), success && (_jsx(SuccessMessage, { message: "Devbox shut down successfully!", details: `ID: ${id}` })), error && (_jsx(ErrorMessage, { message: "Failed to shutdown devbox", error: error }))] }));
 };
 export async function deleteDevbox(id, options = {}) {
     const executor = createExecutor(options);

package/dist/commands/devbox/download.js

@@ -0,0 +1,49 @@
+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 { 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();
+        const result = await client.devboxes.downloadFile(devboxId, {
+            path: options.filePath,
+        });
+        writeFileSync(options.outputPath, result);
+        return {
+            filePath: options.filePath,
+            outputPath: options.outputPath,
+        };
+    }, () => (_jsx(DownloadFileUI, { devboxId: devboxId, filePath: options.filePath, outputPath: options.outputPath })));
+}

package/dist/commands/devbox/exec.js

@@ -1,22 +1,24 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { render, Box, Text } from 'ink';
-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 React from "react";
+import { Box, Text } from "ink";
+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 [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(' '),
+                    command: command.join(" "),
                 });
-                setOutput(result.stdout || result.stderr || 'Command executed successfully');
+                setOutput(result.stdout || result.stderr || "Command executed successfully");
             }
             catch (err) {
                 setError(err);
@@ -27,9 +29,17 @@ const ExecCommandUI = ({ id, command, }) => {
         };
         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: "green", padding: 1, children: _jsx(Text, { children: output }) }) })), error && _jsx(ErrorMessage, { message: "Failed to execute command", error: error })] }));
+    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 }))] }));
 };
-export async function execCommand(id, command) {
-    const { waitUntilExit } = render(_jsx(ExecCommandUI, { id: id, command: command }));
-    await waitUntilExit();
+export async function execCommand(id, command, options = {}) {
+    const executor = createExecutor({ output: options.output });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        const result = await client.devboxes.executeSync(id, {
+            command: command.join(" "),
+        });
+        return {
+            result: result.stdout || result.stderr || "Command executed successfully",
+        };
+    }, () => _jsx(ExecCommandUI, { id: id, command: command }));
 }

package/dist/commands/devbox/execAsync.js

@@ -0,0 +1,43 @@
+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";
+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 }))] }));
+};
+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, {
+            command: options.command,
+            shell_name: options.shellName || undefined,
+        });
+    }, () => (_jsx(ExecAsyncUI, { devboxId: devboxId, command: options.command, shellName: options.shellName })));
+}

package/dist/commands/devbox/get.js

@@ -0,0 +1,37 @@
+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";
+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 }));
+}

package/dist/commands/devbox/getAsync.js

@@ -0,0 +1,37 @@
+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";
+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 }))] }));
+};
+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 }));
+}