@runloop/rl-cli 0.0.3 → 0.1.1

package/dist/commands/devbox/tunnel.js

@@ -0,0 +1,120 @@
+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 TunnelUI = ({ devboxId, ports }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const createTunnel = async () => {
+            try {
+                // Check if SSH tools are available
+                const sshToolsAvailable = await checkSSHTools();
+                if (!sshToolsAvailable) {
+                    throw new Error("SSH tools (ssh, openssl) are not available on this system");
+                }
+                if (!ports.includes(":")) {
+                    throw new Error("Ports must be specified as 'local:remote'");
+                }
+                const [localPort, remotePort] = ports.split(":");
+                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 tunnelCommand = [
+                    "/usr/bin/ssh",
+                    "-i",
+                    sshInfo.keyfilePath,
+                    "-o",
+                    `ProxyCommand=${proxyCommand}`,
+                    "-o",
+                    "StrictHostKeyChecking=no",
+                    "-N", // Do not execute a remote command
+                    "-L",
+                    `${localPort}:localhost:${remotePort}`,
+                    `${user}@${sshInfo.url}`,
+                ];
+                console.log(`Starting tunnel: local port ${localPort} -> remote port ${remotePort}`);
+                console.log("Press Ctrl+C to stop the tunnel.");
+                // Set up signal handler for graceful shutdown
+                const signalHandler = () => {
+                    console.log("\nStopping tunnel...");
+                    process.exit(0);
+                };
+                process.on("SIGINT", signalHandler);
+                const { stdout, stderr } = await execAsync(tunnelCommand.join(" "));
+                setResult({ localPort, remotePort, stdout, stderr });
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        createTunnel();
+    }, [devboxId, ports]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Creating SSH tunnel..." }), result && (_jsx(SuccessMessage, { message: "SSH tunnel created", details: `Local port: ${result.localPort}\nRemote port: ${result.remotePort}` })), error && (_jsx(ErrorMessage, { message: "Failed to create SSH tunnel", error: error }))] }));
+};
+export async function createTunnel(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, openssl) are not available on this system");
+        }
+        if (!options.ports.includes(":")) {
+            throw new Error("Ports must be specified as 'local:remote'");
+        }
+        const [localPort, remotePort] = options.ports.split(":");
+        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 tunnelCommand = [
+            "/usr/bin/ssh",
+            "-i",
+            sshInfo.keyfilePath,
+            "-o",
+            `ProxyCommand=${proxyCommand}`,
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-N", // Do not execute a remote command
+            "-L",
+            `${localPort}:localhost:${remotePort}`,
+            `${user}@${sshInfo.url}`,
+        ];
+        console.log(`Starting tunnel: local port ${localPort} -> remote port ${remotePort}`);
+        console.log("Press Ctrl+C to stop the tunnel.");
+        // Set up signal handler for graceful shutdown
+        const signalHandler = () => {
+            console.log("\nStopping tunnel...");
+            process.exit(0);
+        };
+        process.on("SIGINT", signalHandler);
+        const { stdout, stderr } = await execAsync(tunnelCommand.join(" "));
+        return { localPort, remotePort, stdout, stderr };
+    }, () => _jsx(TunnelUI, { devboxId: devboxId, ports: options.ports }));
+}

package/dist/commands/devbox/upload.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { render } from 'ink';
-import { createReadStream } from 'fs';
-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 React from "react";
+import { render } from "ink";
+import { createReadStream } from "fs";
+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";
 const UploadFileUI = ({ id, file, targetPath }) => {
     const [loading, setLoading] = React.useState(true);
     const [success, setSuccess] = React.useState(false);
@@ -16,7 +16,7 @@ const UploadFileUI = ({ id, file, targetPath }) => {
             try {
                 const client = getClient();
                 const fileStream = createReadStream(file);
-                const filename = file.split('/').pop() || 'uploaded-file';
+                const filename = file.split("/").pop() || "uploaded-file";
                 await client.devboxes.uploadFile(id, {
                     path: targetPath || filename,
                     file: fileStream,
@@ -32,7 +32,7 @@ const UploadFileUI = ({ id, file, targetPath }) => {
         };
         upload();
     }, []);
-    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Upload File", subtitle: `Uploading to devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Uploading file..." }), success && (_jsx(SuccessMessage, { message: "File uploaded successfully!", details: `File: ${file}${targetPath ? `\nTarget: ${targetPath}` : ''}` })), error && _jsx(ErrorMessage, { message: "Failed to upload file", error: error })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Upload File", subtitle: `Uploading to devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Uploading file..." }), success && (_jsx(SuccessMessage, { message: "File uploaded successfully!", details: `File: ${file}${targetPath ? `\nTarget: ${targetPath}` : ""}` })), error && _jsx(ErrorMessage, { message: "Failed to upload file", error: error })] }));
 };
 export async function uploadFile(id, file, options) {
     const { waitUntilExit } = render(_jsx(UploadFileUI, { id: id, file: file, targetPath: options.path }));

package/dist/commands/devbox/write.js

@@ -0,0 +1,51 @@
+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 { readFile } from "fs/promises";
+const WriteFileUI = ({ devboxId, inputPath, remotePath }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const writeFile = async () => {
+            try {
+                const client = getClient();
+                const contents = await readFile(inputPath, "utf-8");
+                await client.devboxes.writeFileContents(devboxId, {
+                    file_path: remotePath,
+                    contents,
+                });
+                setResult({ inputPath, remotePath, size: contents.length });
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        writeFile();
+    }, [devboxId, inputPath, remotePath]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Writing file to devbox..." }), result && (_jsx(SuccessMessage, { message: "File written successfully", details: `Local: ${result.inputPath}\nRemote: ${result.remotePath}\nSize: ${result.size} bytes` })), error && _jsx(ErrorMessage, { message: "Failed to write file", error: error })] }));
+};
+export async function writeFile(devboxId, options) {
+    const executor = createExecutor({ output: options.output });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        const contents = await readFile(options.input, "utf-8");
+        await client.devboxes.writeFileContents(devboxId, {
+            file_path: options.remote,
+            contents,
+        });
+        return {
+            inputPath: options.input,
+            remotePath: options.remote,
+            size: contents.length,
+        };
+    }, () => (_jsx(WriteFileUI, { devboxId: devboxId, inputPath: options.input, remotePath: options.remote })));
+}

package/dist/commands/mcp-http.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function startMcpHttpServer(port) {
+    // Get the path to the compiled MCP HTTP server
+    const serverPath = join(__dirname, "../mcp/server-http.js");
+    const env = { ...process.env };
+    if (port) {
+        env.PORT = port.toString();
+    }
+    console.log(`Starting Runloop MCP HTTP server on port ${port || 3000}...`);
+    console.log("Press Ctrl+C to stop\n");
+    // Start the MCP HTTP server as a child process
+    const serverProcess = spawn("node", [serverPath], {
+        stdio: "inherit",
+        env,
+    });
+    serverProcess.on("error", (error) => {
+        console.error("Failed to start MCP HTTP server:", error);
+        process.exit(1);
+    });
+    serverProcess.on("exit", (code) => {
+        if (code !== 0) {
+            console.error(`MCP HTTP server exited with code ${code}`);
+            process.exit(code || 1);
+        }
+    });
+    // Handle Ctrl+C
+    process.on("SIGINT", () => {
+        console.log("\nShutting down MCP HTTP server...");
+        serverProcess.kill("SIGINT");
+        process.exit(0);
+    });
+}

package/dist/commands/mcp-install.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { execSync } from "child_process";
+function getClaudeConfigPath() {
+    const plat = platform();
+    if (plat === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    else if (plat === "win32") {
+        const appData = process.env.APPDATA;
+        if (!appData) {
+            throw new Error("APPDATA environment variable not found");
+        }
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    else {
+        // Linux
+        return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+}
+function getRliPath() {
+    try {
+        const cmd = platform() === "win32" ? "where rli" : "which rli";
+        const path = execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+        return path;
+    }
+    catch (error) {
+        // If rli not found in PATH, just use 'rli' and hope it works
+        return "rli";
+    }
+}
+export async function installMcpConfig() {
+    try {
+        const configPath = getClaudeConfigPath();
+        const rliPath = getRliPath();
+        console.log(`\n📍 Claude Desktop config location: ${configPath}`);
+        console.log(`📍 rli command location: ${rliPath}\n`);
+        // Read or create config
+        let config = { mcpServers: {} };
+        if (existsSync(configPath)) {
+            console.log("✓ Found existing Claude Desktop config");
+            const content = readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+                if (!config.mcpServers) {
+                    config.mcpServers = {};
+                }
+            }
+            catch (error) {
+                console.error("❌ Error: Claude config file exists but is not valid JSON");
+                console.error("Please fix the file manually or delete it to create a new one");
+                process.exit(1);
+            }
+        }
+        else {
+            console.log("✓ No existing config found, will create new one");
+            // Create directory if it doesn't exist
+            const configDir = join(configPath, "..");
+            if (!existsSync(configDir)) {
+                mkdirSync(configDir, { recursive: true });
+                console.log(`✓ Created directory: ${configDir}`);
+            }
+        }
+        // Check if runloop is already configured
+        if (config.mcpServers.runloop) {
+            console.log("\n⚠️  Runloop MCP server is already configured in Claude Desktop");
+            console.log("\nCurrent configuration:");
+            console.log(JSON.stringify(config.mcpServers.runloop, null, 2));
+            // Ask if they want to overwrite
+            console.log("\n❓ Do you want to overwrite it? (y/N): ");
+            // For non-interactive mode, just exit
+            if (process.stdin.isTTY) {
+                const response = await new Promise((resolve) => {
+                    process.stdin.once("data", (data) => {
+                        resolve(data.toString().trim().toLowerCase());
+                    });
+                });
+                if (response !== "y" && response !== "yes") {
+                    console.log("\n✓ Keeping existing configuration");
+                    process.exit(0);
+                }
+            }
+            else {
+                console.log("\n✓ Keeping existing configuration (non-interactive mode)");
+                process.exit(0);
+            }
+        }
+        // Add runloop MCP server config
+        config.mcpServers.runloop = {
+            command: rliPath,
+            args: ["mcp", "start"],
+        };
+        // Write config back
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log("\n✅ Successfully installed Runloop MCP server configuration!");
+        console.log("\nConfiguration added:");
+        console.log(JSON.stringify({ mcpServers: { runloop: config.mcpServers.runloop } }, null, 2));
+        console.log("\n📝 Next steps:");
+        console.log("1. Restart Claude Desktop completely (quit and reopen)");
+        console.log('2. Ask Claude: "List my devboxes" or "What Runloop tools do you have?"');
+        console.log('\n💡 Tip: Make sure you\'ve run "rli auth" to configure your API key first!');
+    }
+    catch (error) {
+        console.error("\n❌ Error installing MCP configuration:", error.message);
+        console.error("\n💡 You can manually add this configuration to your Claude Desktop config:");
+        console.error(`\nFile location: ${getClaudeConfigPath()}`);
+        console.error("\nConfiguration to add:");
+        console.error(JSON.stringify({
+            mcpServers: {
+                runloop: {
+                    command: "rli",
+                    args: ["mcp", "start"],
+                },
+            },
+        }, null, 2));
+        process.exit(1);
+    }
+}

package/dist/commands/mcp.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function startMcpServer() {
+    // Get the path to the compiled MCP server
+    const serverPath = join(__dirname, "../mcp/server.js");
+    // Start the MCP server as a child process
+    // The server uses stdio transport, so it communicates via stdin/stdout
+    const serverProcess = spawn("node", [serverPath], {
+        stdio: "inherit", // Pass through stdin/stdout/stderr
+    });
+    serverProcess.on("error", (error) => {
+        console.error("Failed to start MCP server:", error);
+        process.exit(1);
+    });
+    serverProcess.on("exit", (code) => {
+        if (code !== 0) {
+            console.error(`MCP server exited with code ${code}`);
+            process.exit(code || 1);
+        }
+    });
+    // Handle Ctrl+C
+    process.on("SIGINT", () => {
+        serverProcess.kill("SIGINT");
+        process.exit(0);
+    });
+}

package/dist/commands/menu.js

@@ -1,32 +1,32 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { render, useApp } from 'ink';
-import { MainMenu } from '../components/MainMenu.js';
-import { runSSHSession } from '../utils/sshSession.js';
+import React from "react";
+import { render, useApp } from "ink";
+import { MainMenu } from "../components/MainMenu.js";
+import { runSSHSession } from "../utils/sshSession.js";
 // Import the UI components directly
-import { ListDevboxesUI } from './devbox/list.js';
-import { ListBlueprintsUI } from './blueprint/list.js';
-import { ListSnapshotsUI } from './snapshot/list.js';
-import { Box } from 'ink';
-const App = ({ onSSHRequest, initialScreen = 'menu', focusDevboxId }) => {
+import { ListDevboxesUI } from "./devbox/list.js";
+import { ListBlueprintsUI } from "./blueprint/list.js";
+import { ListSnapshotsUI } from "./snapshot/list.js";
+import { Box } from "ink";
+const App = ({ onSSHRequest, initialScreen = "menu", focusDevboxId, }) => {
     const { exit } = useApp();
     const [currentScreen, setCurrentScreen] = React.useState(initialScreen);
-    const [, forceUpdate] = React.useReducer(x => x + 1, 0);
+    const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
     const handleMenuSelect = (key) => {
         setCurrentScreen(key);
     };
     const handleBack = () => {
-        setCurrentScreen('menu');
+        setCurrentScreen("menu");
     };
     const handleExit = () => {
         exit();
     };
     // Wrap everything in a full-height container
-    return (_jsxs(Box, { flexDirection: "column", minHeight: process.stdout.rows || 24, children: [currentScreen === 'menu' && _jsx(MainMenu, { onSelect: handleMenuSelect }), currentScreen === 'devboxes' && (_jsx(ListDevboxesUI, { onBack: handleBack, onExit: handleExit, onSSHRequest: onSSHRequest, focusDevboxId: focusDevboxId })), currentScreen === 'blueprints' && _jsx(ListBlueprintsUI, { onBack: handleBack, onExit: handleExit }), currentScreen === 'snapshots' && _jsx(ListSnapshotsUI, { onBack: handleBack, onExit: handleExit })] }));
+    return (_jsxs(Box, { flexDirection: "column", minHeight: process.stdout.rows || 24, children: [currentScreen === "menu" && _jsx(MainMenu, { onSelect: handleMenuSelect }), currentScreen === "devboxes" && (_jsx(ListDevboxesUI, { onBack: handleBack, onExit: handleExit, onSSHRequest: onSSHRequest, focusDevboxId: focusDevboxId })), currentScreen === "blueprints" && (_jsx(ListBlueprintsUI, { onBack: handleBack, onExit: handleExit })), currentScreen === "snapshots" && (_jsx(ListSnapshotsUI, { onBack: handleBack, onExit: handleExit }))] }));
 };
-export async function runMainMenu(initialScreen = 'menu', focusDevboxId) {
+export async function runMainMenu(initialScreen = "menu", focusDevboxId) {
     // Enter alternate screen buffer once at the start
-    process.stdout.write('\x1b[?1049h');
+    process.stdout.write("\x1b[?1049h");
     let sshSessionConfig = null;
     let shouldContinue = true;
     let currentInitialScreen = initialScreen;
@@ -41,21 +41,21 @@ export async function runMainMenu(initialScreen = 'menu', focusDevboxId) {
             shouldContinue = false;
         }
         catch (error) {
-            console.error('Error in menu:', error);
+            console.error("Error in menu:", error);
             shouldContinue = false;
         }
         // If SSH was requested, handle it now after Ink has exited
         if (sshSessionConfig) {
             // Exit alternate screen buffer for SSH
-            process.stdout.write('\x1b[?1049l');
+            process.stdout.write("\x1b[?1049l");
             const result = await runSSHSession(sshSessionConfig);
             if (result.shouldRestart) {
                 console.clear();
                 console.log(`\nSSH session ended. Returning to menu...\n`);
-                await new Promise(resolve => setTimeout(resolve, 500));
+                await new Promise((resolve) => setTimeout(resolve, 500));
                 // Re-enter alternate screen buffer and return to devboxes list
-                process.stdout.write('\x1b[?1049h');
-                currentInitialScreen = 'devboxes';
+                process.stdout.write("\x1b[?1049h");
+                currentInitialScreen = "devboxes";
                 currentFocusDevboxId = result.returnToDevboxId;
                 shouldContinue = true;
             }
@@ -65,6 +65,6 @@ export async function runMainMenu(initialScreen = 'menu', focusDevboxId) {
         }
     }
     // Exit alternate screen buffer once at the end
-    process.stdout.write('\x1b[?1049l');
+    process.stdout.write("\x1b[?1049l");
     process.exit(0);
 }

package/dist/commands/object/delete.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 DeleteObjectUI = ({ objectId }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const deleteObject = async () => {
+            try {
+                const client = getClient();
+                const deletedObject = await client.objects.delete(objectId);
+                setResult(deletedObject);
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        deleteObject();
+    }, [objectId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Deleting object..." }), result && (_jsx(SuccessMessage, { message: "Object deleted successfully", details: `ID: ${result.id}\nName: ${result.name}\nThis action is irreversible` })), error && (_jsx(ErrorMessage, { message: "Failed to delete object", error: error }))] }));
+};
+export async function deleteObject(options) {
+    const executor = createExecutor({ output: options.outputFormat });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        return client.objects.delete(options.id);
+    }, () => _jsx(DeleteObjectUI, { objectId: options.id }));
+}

package/dist/commands/object/download.js

@@ -0,0 +1,88 @@
+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 DownloadObjectUI = ({ objectId, path, extract, durationSeconds }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const downloadObject = async () => {
+            try {
+                const client = getClient();
+                // Get the object metadata first
+                const object = await client.objects.retrieve(objectId);
+                // Get the download URL
+                const downloadUrlResponse = await client.objects.download(objectId, {
+                    duration_seconds: durationSeconds || 3600,
+                });
+                // Download the file
+                const response = await fetch(downloadUrlResponse.download_url);
+                if (!response.ok) {
+                    throw new Error(`Download failed: HTTP ${response.status}`);
+                }
+                // Handle extraction if requested
+                if (extract) {
+                    // For now, just save to the specified path
+                    // In a full implementation, you'd handle archive extraction here
+                    const arrayBuffer = await response.arrayBuffer();
+                    const buffer = Buffer.from(arrayBuffer);
+                    await import("fs/promises").then((fs) => fs.writeFile(path, buffer));
+                }
+                else {
+                    const arrayBuffer = await response.arrayBuffer();
+                    const buffer = Buffer.from(arrayBuffer);
+                    await import("fs/promises").then((fs) => fs.writeFile(path, buffer));
+                }
+                setResult({ objectId, path, extract });
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        downloadObject();
+    }, [objectId, path, extract, durationSeconds]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Downloading object..." }), result && (_jsx(SuccessMessage, { message: "Object downloaded successfully", details: `Object ID: ${result.objectId}\nPath: ${result.path}\nExtracted: ${result.extract ? "Yes" : "No"}` })), error && (_jsx(ErrorMessage, { message: "Failed to download object", error: error }))] }));
+};
+export async function downloadObject(options) {
+    const executor = createExecutor({ output: options.outputFormat });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        // Get the object metadata first
+        const object = await client.objects.retrieve(options.id);
+        // Get the download URL
+        const downloadUrlResponse = await client.objects.download(options.id, {
+            duration_seconds: options.durationSeconds || 3600,
+        });
+        // Download the file
+        const response = await fetch(downloadUrlResponse.download_url);
+        if (!response.ok) {
+            throw new Error(`Download failed: HTTP ${response.status}`);
+        }
+        // Handle extraction if requested
+        if (options.extract) {
+            // For now, just save to the specified path
+            // In a full implementation, you'd handle archive extraction here
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            await import("fs/promises").then((fs) => fs.writeFile(options.path, buffer));
+        }
+        else {
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            await import("fs/promises").then((fs) => fs.writeFile(options.path, buffer));
+        }
+        return {
+            objectId: options.id,
+            path: options.path,
+            extract: options.extract,
+        };
+    }, () => (_jsx(DownloadObjectUI, { objectId: options.id, path: options.path, extract: options.extract, durationSeconds: options.durationSeconds })));
+}

package/dist/commands/object/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 GetObjectUI = ({ objectId }) => {
+    const [loading, setLoading] = React.useState(true);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const getObject = async () => {
+            try {
+                const client = getClient();
+                const object = await client.objects.retrieve(objectId);
+                setResult(object);
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        getObject();
+    }, [objectId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Fetching object details..." }), result && (_jsx(SuccessMessage, { message: "Object details retrieved", details: `ID: ${result.id}\nName: ${result.name}\nType: ${result.contentType}\nState: ${result.state}\nSize: ${result.sizeBytes ? `${result.sizeBytes} bytes` : "Unknown"}` })), error && _jsx(ErrorMessage, { message: "Failed to get object", error: error })] }));
+};
+export async function getObject(options) {
+    const executor = createExecutor({ output: options.outputFormat });
+    await executor.executeAction(async () => {
+        const client = executor.getClient();
+        return client.objects.retrieve(options.id);
+    }, () => _jsx(GetObjectUI, { objectId: options.id }));
+}