@runloop/rl-cli 0.1.2 → 0.3.0

package/dist/commands/menu.js

@@ -1,70 +1,29 @@
-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 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, }) => {
-    const { exit } = useApp();
-    const [currentScreen, setCurrentScreen] = React.useState(initialScreen);
-    const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
-    const handleMenuSelect = (key) => {
-        setCurrentScreen(key);
-    };
-    const handleBack = () => {
-        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 }))] }));
-};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { enterAlternateScreenBuffer, exitAlternateScreenBuffer, } from "../utils/screen.js";
+import { processUtils } from "../utils/processUtils.js";
+import { Router } from "../router/Router.js";
+import { NavigationProvider } from "../store/navigationStore.js";
+function AppInner() {
+    // NavigationProvider already handles initialScreen and initialParams
+    // No need for useEffect here - provider sets state on mount
+    return _jsx(Router, {});
+}
+function App({ initialScreen = "menu", focusDevboxId, }) {
+    return (_jsx(NavigationProvider, { initialScreen: initialScreen, initialParams: focusDevboxId ? { focusDevboxId } : {}, children: _jsx(AppInner, {}) }));
+}
 export async function runMainMenu(initialScreen = "menu", focusDevboxId) {
-    // Enter alternate screen buffer once at the start
-    process.stdout.write("\x1b[?1049h");
-    let sshSessionConfig = null;
-    let shouldContinue = true;
-    let currentInitialScreen = initialScreen;
-    let currentFocusDevboxId = focusDevboxId;
-    while (shouldContinue) {
-        sshSessionConfig = null;
-        try {
-            const { waitUntilExit } = render(_jsx(App, { onSSHRequest: (config) => {
-                    sshSessionConfig = config;
-                }, initialScreen: currentInitialScreen, focusDevboxId: currentFocusDevboxId }));
-            await waitUntilExit();
-            shouldContinue = false;
-        }
-        catch (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");
-            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));
-                // Re-enter alternate screen buffer and return to devboxes list
-                process.stdout.write("\x1b[?1049h");
-                currentInitialScreen = "devboxes";
-                currentFocusDevboxId = result.returnToDevboxId;
-                shouldContinue = true;
-            }
-            else {
-                shouldContinue = false;
-            }
-        }
+    enterAlternateScreenBuffer();
+    try {
+        const { waitUntilExit } = render(_jsx(App, { initialScreen: initialScreen, focusDevboxId: focusDevboxId }, `app-${initialScreen}-${focusDevboxId}`), {
+            patchConsole: false,
+            exitOnCtrlC: false,
+        });
+        await waitUntilExit();
+    }
+    catch (error) {
+        console.error("Error in menu:", error);
     }
-    // Exit alternate screen buffer once at the end
-    process.stdout.write("\x1b[?1049l");
-    process.exit(0);
+    exitAlternateScreenBuffer();
+    processUtils.exit(0);
 }

package/dist/commands/object/delete.js

@@ -1,37 +1,15 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Delete object 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 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 }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 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 }));
+    try {
+        const client = getClient();
+        const deletedObject = await client.objects.delete(options.id);
+        output(deletedObject, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to delete object", error);
+    }
 }

package/dist/commands/object/download.js

@@ -1,62 +1,12 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Download object command
+ */
+import { writeFile } from "fs/promises";
 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 }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 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);
+    try {
+        const client = getClient();
         // Get the download URL
         const downloadUrlResponse = await client.objects.download(options.id, {
             duration_seconds: options.durationSeconds || 3600,
@@ -64,25 +14,27 @@ export async function downloadObject(options) {
         // Download the file
         const response = await fetch(downloadUrlResponse.download_url);
         if (!response.ok) {
-            throw new Error(`Download failed: HTTP ${response.status}`);
+            outputError(`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));
+        // Save the file
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await writeFile(options.path, buffer);
+        // TODO: Handle extraction if requested (options.extract)
+        const result = {
+            id: options.id,
+            path: options.path,
+            extracted: options.extract || false,
+        };
+        // Default: just output the local path for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.path);
         }
         else {
-            const arrayBuffer = await response.arrayBuffer();
-            const buffer = Buffer.from(arrayBuffer);
-            await import("fs/promises").then((fs) => fs.writeFile(options.path, buffer));
+            output(result, { format: options.output, defaultFormat: "json" });
         }
-        return {
-            objectId: options.id,
-            path: options.path,
-            extract: options.extract,
-        };
-    }, () => (_jsx(DownloadObjectUI, { objectId: options.id, path: options.path, extract: options.extract, durationSeconds: options.durationSeconds })));
+    }
+    catch (error) {
+        outputError("Failed to download object", error);
+    }
 }

package/dist/commands/object/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 object 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 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 })] }));
-};
+import { output, outputError } from "../../utils/output.js";
 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 }));
+    try {
+        const client = getClient();
+        const object = await client.objects.retrieve(options.id);
+        output(object, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to get object", error);
+    }
 }

package/dist/commands/object/list.js

@@ -1,94 +1,12 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * List objects command
+ */
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-import { colors } from "../../utils/theme.js";
-import { Table } from "../../components/Table.js";
-const ListObjectsUI = ({ options }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const listObjects = async () => {
-            try {
-                const client = getClient();
-                const params = {};
-                if (options.limit)
-                    params.limit = options.limit;
-                if (options.startingAfter)
-                    params.startingAfter = options.startingAfter;
-                if (options.name)
-                    params.name = options.name;
-                if (options.contentType)
-                    params.contentType = options.contentType;
-                if (options.state)
-                    params.state = options.state;
-                if (options.search)
-                    params.search = options.search;
-                if (options.public)
-                    params.isPublic = true;
-                const objects = options.public
-                    ? await client.objects.listPublic(params)
-                    : await client.objects.list(params);
-                setResult(objects);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        listObjects();
-    }, [options]);
-    const formatSize = (bytes) => {
-        if (bytes < 1024)
-            return `${bytes} B`;
-        if (bytes < 1024 * 1024)
-            return `${(bytes / 1024).toFixed(1)} KB`;
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    };
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Fetching objects..." }), result && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.primary, children: "Objects:" }), result.objects && result.objects.length > 0 ? (_jsx(Table, { data: result.objects, keyExtractor: (item) => item.id, columns: [
-                            {
-                                key: "id",
-                                label: "ID",
-                                width: 20,
-                                render: (row) => (_jsx(Text, { color: colors.text, children: row.id })),
-                            },
-                            {
-                                key: "name",
-                                label: "Name",
-                                width: 30,
-                                render: (row) => (_jsx(Text, { color: colors.text, children: row.name })),
-                            },
-                            {
-                                key: "type",
-                                label: "Type",
-                                width: 15,
-                                render: (row) => (_jsx(Text, { color: colors.text, children: row.content_type })),
-                            },
-                            {
-                                key: "state",
-                                label: "State",
-                                width: 15,
-                                render: (row) => (_jsx(Text, { color: colors.text, children: row.state })),
-                            },
-                            {
-                                key: "size",
-                                label: "Size",
-                                width: 10,
-                                render: (row) => (_jsx(Text, { color: colors.text, children: row.size_bytes ? formatSize(row.size_bytes) : "N/A" })),
-                            },
-                        ] })) : (_jsx(Text, { color: colors.textDim, children: "No objects found" }))] })), error && _jsx(ErrorMessage, { message: "Failed to list objects", error: error })] }));
-};
-export async function listObjects(options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeList(async () => {
-        const client = executor.getClient();
+import { output, outputError } from "../../utils/output.js";
+export async function listObjects(options = {}) {
+    try {
+        const client = getClient();
+        // Build params
         const params = {};
         if (options.limit)
             params.limit = options.limit;
@@ -104,9 +22,13 @@ export async function listObjects(options) {
             params.search = options.search;
         if (options.public)
             params.isPublic = true;
-        const objects = options.public
+        const result = options.public
             ? await client.objects.listPublic(params)
             : await client.objects.list(params);
-        return objects.objects || [];
-    }, () => _jsx(ListObjectsUI, { options: options }), options.limit || 20);
+        const objects = result.objects || [];
+        output(objects, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to list objects", error);
+    }
 }

package/dist/commands/object/upload.js

@@ -1,106 +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";
+/**
+ * Upload object command
+ */
 import { readFile, stat } from "fs/promises";
 import { extname } from "path";
-const UploadObjectUI = ({ path, name, contentType }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const uploadObject = async () => {
-            try {
-                const client = getClient();
-                // Check if file exists
-                const stats = await stat(path);
-                const fileBuffer = await readFile(path);
-                // Auto-detect content type if not provided
-                let detectedContentType = contentType;
-                if (!detectedContentType) {
-                    const ext = extname(path).toLowerCase();
-                    const contentTypeMap = {
-                        ".txt": "text",
-                        ".html": "text",
-                        ".css": "text",
-                        ".js": "text",
-                        ".json": "text",
-                        ".yaml": "text",
-                        ".yml": "text",
-                        ".md": "text",
-                        ".gz": "gzip",
-                        ".tar": "tar",
-                        ".tgz": "tgz",
-                        ".tar.gz": "tgz",
-                    };
-                    detectedContentType = contentTypeMap[ext] || "unspecified";
-                }
-                // Step 1: Create the object
-                const createResponse = await client.objects.create({
-                    name,
-                    content_type: detectedContentType,
-                });
-                // Step 2: Upload the file
-                const uploadResponse = await fetch(createResponse.upload_url, {
-                    method: "PUT",
-                    body: fileBuffer,
-                    headers: {
-                        "Content-Length": fileBuffer.length.toString(),
-                    },
-                });
-                if (!uploadResponse.ok) {
-                    throw new Error(`Upload failed: HTTP ${uploadResponse.status}`);
-                }
-                // Step 3: Complete the upload
-                await client.objects.complete(createResponse.id);
-                setResult({
-                    id: createResponse.id,
-                    name,
-                    contentType: detectedContentType,
-                    size: stats.size,
-                });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        uploadObject();
-    }, [path, name, contentType]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Uploading object..." }), result && (_jsx(SuccessMessage, { message: "Object uploaded successfully", details: `ID: ${result.id}\nName: ${result.name}\nType: ${result.contentType}\nSize: ${result.size} bytes` })), error && (_jsx(ErrorMessage, { message: "Failed to upload object", error: error }))] }));
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+const CONTENT_TYPE_MAP = {
+    ".txt": "text",
+    ".html": "text",
+    ".css": "text",
+    ".js": "text",
+    ".json": "text",
+    ".yaml": "text",
+    ".yml": "text",
+    ".md": "text",
+    ".gz": "gzip",
+    ".tar": "tar",
+    ".tgz": "tgz",
+    ".tar.gz": "tgz",
 };
 export async function uploadObject(options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        // Check if file exists
+    try {
+        const client = getClient();
+        // Check if file exists and get stats
         const stats = await stat(options.path);
         const fileBuffer = await readFile(options.path);
         // Auto-detect content type if not provided
         let detectedContentType = options.contentType;
         if (!detectedContentType) {
             const ext = extname(options.path).toLowerCase();
-            const contentTypeMap = {
-                ".txt": "text",
-                ".html": "text",
-                ".css": "text",
-                ".js": "text",
-                ".json": "text",
-                ".yaml": "text",
-                ".yml": "text",
-                ".md": "text",
-                ".gz": "gzip",
-                ".tar": "tar",
-                ".tgz": "tgz",
-                ".tar.gz": "tgz",
-            };
-            detectedContentType = contentTypeMap[ext] || "unspecified";
+            detectedContentType = CONTENT_TYPE_MAP[ext] || "unspecified";
         }
         // Step 1: Create the object
         const createResponse = await client.objects.create({
@@ -116,15 +45,25 @@ export async function uploadObject(options) {
             },
         });
         if (!uploadResponse.ok) {
-            throw new Error(`Upload failed: HTTP ${uploadResponse.status}`);
+            outputError(`Upload failed: HTTP ${uploadResponse.status}`);
         }
         // Step 3: Complete the upload
         await client.objects.complete(createResponse.id);
-        return {
+        const result = {
             id: createResponse.id,
             name: options.name,
             contentType: detectedContentType,
             size: stats.size,
         };
-    }, () => (_jsx(UploadObjectUI, { path: options.path, name: options.name, contentType: options.contentType })));
+        // Default: just output the ID for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(result.id);
+        }
+        else {
+            output(result, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to upload object", error);
+    }
 }