@runloop/rl-cli 0.0.3 → 0.1.1

package/dist/commands/devbox/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 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 }));
+}

package/dist/commands/devbox/read.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 { 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();
+        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 })));
+}

package/dist/commands/devbox/resume.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 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 }));
+}

package/dist/commands/devbox/rsync.js

@@ -0,0 +1,118 @@
+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";
+import { exec } from "child_process";
+import { promisify } from "util";
+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 () => {
+        // 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 = executor.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 (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);
+        }
+        else {
+            rsyncCommand.push(options.src);
+            if (options.dst.startsWith(":")) {
+                rsyncCommand.push(`${user}@${sshInfo.url}:${options.dst.slice(1)}`);
+            }
+            else {
+                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 })));
+}

package/dist/commands/devbox/scp.js

@@ -0,0 +1,122 @@
+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";
+import { exec } from "child_process";
+import { promisify } from "util";
+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 () => {
+        // 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 = executor.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 (options.scpOptions) {
+            scpCommand.push(...options.scpOptions.split(" "));
+        }
+        // Handle remote paths (starting with :)
+        if (options.src.startsWith(":")) {
+            scpCommand.push(`${user}@${sshInfo.url}:${options.src.slice(1)}`);
+            scpCommand.push(options.dst);
+        }
+        else {
+            scpCommand.push(options.src);
+            if (options.dst.startsWith(":")) {
+                scpCommand.push(`${user}@${sshInfo.url}:${options.dst.slice(1)}`);
+            }
+            else {
+                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 })));
+}

package/dist/commands/devbox/shutdown.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 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 }));
+}

package/dist/commands/devbox/ssh.js

@@ -0,0 +1,104 @@
+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 { colors } from "../../utils/theme.js";
+import { getSSHKey, waitForReady, generateSSHConfig, checkSSHTools, } from "../../utils/ssh.js";
+const SSHDevboxUI = ({ devboxId, options }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const connectSSH = async () => {
+            try {
+                // Check if SSH tools are available
+                const sshToolsAvailable = await checkSSHTools();
+                if (!sshToolsAvailable) {
+                    throw new Error("SSH tools (ssh, scp, rsync, openssl) are not available on this system");
+                }
+                const client = getClient();
+                // Wait for devbox to be ready unless --no-wait is specified
+                if (!options.noWait) {
+                    console.log(`Waiting for devbox ${devboxId} to be ready...`);
+                    const isReady = await waitForReady(devboxId, options.timeout || 180, options.pollInterval || 3);
+                    if (!isReady) {
+                        throw new Error(`Devbox ${devboxId} is not ready. Please try again later.`);
+                    }
+                }
+                // 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");
+                }
+                if (options.configOnly) {
+                    const config = generateSSHConfig(devboxId, user, sshInfo.keyfilePath, sshInfo.url);
+                    setResult({ config });
+                }
+                else {
+                    setResult({
+                        devboxId,
+                        user,
+                        keyfilePath: sshInfo.keyfilePath,
+                        url: sshInfo.url,
+                    });
+                }
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        connectSSH();
+    }, [devboxId, options]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Setting up SSH connection..." }), result && result.config && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.primary, children: "SSH Config:" }), _jsx(Text, { children: result.config })] })), result && !result.config && (_jsx(SuccessMessage, { message: "SSH connection ready", details: `Devbox: ${result.devboxId}\nUser: ${result.user}\nKey: ${result.keyfilePath}` })), error && (_jsx(ErrorMessage, { message: "Failed to setup SSH connection", error: error }))] }));
+};
+export async function sshDevbox(devboxId, options) {
+    const executor = createExecutor(options);
+    await executor.executeAction(async () => {
+        // Check if SSH tools are available
+        const sshToolsAvailable = await checkSSHTools();
+        if (!sshToolsAvailable) {
+            throw new Error("SSH tools (ssh, scp, rsync, openssl) are not available on this system");
+        }
+        const client = executor.getClient();
+        // Wait for devbox to be ready unless --no-wait is specified
+        if (!options.noWait) {
+            console.log(`Waiting for devbox ${devboxId} to be ready...`);
+            const isReady = await waitForReady(devboxId, options.timeout || 180, options.pollInterval || 3);
+            if (!isReady) {
+                throw new Error(`Devbox ${devboxId} is not ready. Please try again later.`);
+            }
+        }
+        // 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");
+        }
+        if (options.configOnly) {
+            return {
+                config: generateSSHConfig(devboxId, user, sshInfo.keyfilePath, sshInfo.url),
+            };
+        }
+        else {
+            return {
+                devboxId,
+                user,
+                keyfilePath: sshInfo.keyfilePath,
+                url: sshInfo.url,
+            };
+        }
+    }, () => _jsx(SSHDevboxUI, { devboxId: devboxId, options: options }));
+}

package/dist/commands/devbox/suspend.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 SuspendDevboxUI = ({ devboxId }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const suspendDevbox = async () => {
+            try {
+                const client = getClient();
+                const devbox = await client.devboxes.suspend(devboxId);
+                setResult(devbox);
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        suspendDevbox();
+    }, [devboxId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Suspending devbox..." }), result && (_jsx(SuccessMessage, { message: "Devbox suspended", details: `ID: ${result.id}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to suspend devbox", error: error }))] }));
+};
+export async function suspendDevbox(devboxId, options) {
+    const executor = createExecutor(options);
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        return client.devboxes.suspend(devboxId);
+    }, () => _jsx(SuspendDevboxUI, { devboxId: devboxId }));
+}