@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/commands/blueprint/logs.js

@@ -1,40 +1,136 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * Get blueprint build logs command
+ */
+import chalk from "chalk";
 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 }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
+function formatLogLevel(level) {
+    const normalized = level.toUpperCase();
+    switch (normalized) {
+        case "ERROR":
+        case "ERR":
+            return chalk.red.bold("ERROR");
+        case "WARN":
+        case "WARNING":
+            return chalk.yellow.bold("WARN ");
+        case "INFO":
+            return chalk.blue("INFO ");
+        case "DEBUG":
+            return chalk.gray("DEBUG");
+        default:
+            return chalk.gray(normalized.padEnd(5));
+    }
+}
+function formatTimestamp(timestampMs) {
+    const date = new Date(timestampMs);
+    const now = new Date();
+    const isToday = date.toDateString() === now.toDateString();
+    const isThisYear = date.getFullYear() === now.getFullYear();
+    const time = date.toLocaleTimeString("en-US", {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    const ms = date.getMilliseconds().toString().padStart(3, "0");
+    if (isToday) {
+        // Today: show time with milliseconds for fine granularity
+        return chalk.dim(`${time}.${ms}`);
+    }
+    else if (isThisYear) {
+        // This year: show "Jan 5 15:44:03"
+        const monthDay = date.toLocaleDateString("en-US", {
+            month: "short",
+            day: "numeric",
+        });
+        return chalk.dim(`${monthDay} ${time}`);
+    }
+    else {
+        // Older: show "Jan 5, 2024 15:44:03"
+        const fullDate = date.toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+        });
+        return chalk.dim(`${fullDate} ${time}`);
+    }
+}
+function colorizeMessage(message) {
+    // Colorize common Docker build patterns
+    if (message.startsWith("Step ") || message.startsWith("---> ")) {
+        return chalk.cyan.bold(message);
+    }
+    if (message.startsWith("Successfully")) {
+        return chalk.green.bold(message);
+    }
+    if (message.startsWith("Removing intermediate container")) {
+        return chalk.dim(message);
+    }
+    if (message.toLowerCase().includes("error") ||
+        message.toLowerCase().includes("failed")) {
+        return chalk.red(message);
+    }
+    if (message.toLowerCase().includes("warning")) {
+        return chalk.yellow(message);
+    }
+    // Dockerfile instructions
+    if (message.startsWith("RUN ") ||
+        message.startsWith("COPY ") ||
+        message.startsWith("ADD ") ||
+        message.startsWith("FROM ") ||
+        message.startsWith("WORKDIR ") ||
+        message.startsWith("ENV ")) {
+        return chalk.yellow(message);
+    }
+    return message;
+}
+function formatLogEntry(log) {
+    const parts = [];
+    // Timestamp
+    parts.push(formatTimestamp(log.timestamp_ms));
+    // Level
+    parts.push(formatLogLevel(log.level));
+    // Message with colorization
+    parts.push(colorizeMessage(log.message));
+    return parts.join(" ");
+}
+function formatLogs(response) {
+    const logs = response.logs;
+    if (!logs || logs.length === 0) {
+        console.log(chalk.dim("No build logs available"));
+        return;
+    }
+    for (const log of logs) {
+        console.log(formatLogEntry(log));
+    }
+}
 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 }));
+    try {
+        const client = getClient();
+        let blueprintId = options.id;
+        // Check if it's an ID (starts with bpt_) or a name
+        if (!options.id.startsWith("bpt_")) {
+            // It's a name, search for it
+            const result = await client.blueprints.list({ name: options.id });
+            const blueprints = result.blueprints || [];
+            if (blueprints.length === 0) {
+                outputError(`Blueprint not found: ${options.id}`);
+                return;
+            }
+            // Use the first exact match, or first result if no exact match
+            const blueprint = blueprints.find((b) => b.name === options.id) || blueprints[0];
+            blueprintId = blueprint.id;
+        }
+        const logs = await client.blueprints.logs(blueprintId);
+        // Pretty print for text output, JSON for others
+        if (!options.output || options.output === "text") {
+            formatLogs(logs);
+        }
+        else {
+            output(logs, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to get blueprint logs", error);
+    }
 }

package/dist/commands/blueprint/preview.js

@@ -1,45 +1,49 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Preview blueprint 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 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 }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 export async function previewBlueprint(options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.blueprints.preview({
+    try {
+        const client = getClient();
+        // Parse user parameters
+        let userParameters = undefined;
+        if (options.user && options.root) {
+            outputError("Only one of --user or --root can be specified");
+        }
+        else if (options.user) {
+            const [username, uid] = options.user.split(":");
+            if (!username || !uid) {
+                outputError("User must be in format 'username:uid'");
+            }
+            userParameters = { username, uid: parseInt(uid) };
+        }
+        else if (options.root) {
+            userParameters = { username: "root", uid: 0 };
+        }
+        // Build launch parameters
+        const launchParameters = {};
+        if (options.resources) {
+            launchParameters.resource_size_request = options.resources;
+        }
+        if (options.architecture) {
+            launchParameters.architecture = options.architecture;
+        }
+        if (options.availablePorts) {
+            launchParameters.available_ports = options.availablePorts.map((port) => parseInt(port, 10));
+        }
+        if (userParameters) {
+            launchParameters.user_parameters = userParameters;
+        }
+        const preview = await client.blueprints.preview({
             name: options.name,
             dockerfile: options.dockerfile,
             system_setup_commands: options.systemSetupCommands,
+            launch_parameters: launchParameters,
         });
-    }, () => (_jsx(PreviewBlueprintUI, { name: options.name, dockerfile: options.dockerfile, systemSetupCommands: options.systemSetupCommands })));
+        output(preview, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to preview blueprint", error);
+    }
 }

package/dist/commands/config.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { render, Box, Text, useInput, useApp } from "ink";
+import figures from "figures";
+import { setThemePreference, getThemePreference, clearDetectedTheme, } from "../utils/config.js";
+import { Header } from "../components/Header.js";
+import { SuccessMessage } from "../components/SuccessMessage.js";
+import { colors, getCurrentTheme, setThemeMode } from "../utils/theme.js";
+const themeOptions = [
+    {
+        value: "auto",
+        label: "Auto-detect",
+        description: "Automatically detect terminal background color",
+    },
+    {
+        value: "dark",
+        label: "Dark mode",
+        description: "Light text on dark background",
+    },
+    {
+        value: "light",
+        label: "Light mode",
+        description: "Dark text on light background",
+    },
+];
+const InteractiveThemeSelector = ({ initialTheme, }) => {
+    const { exit } = useApp();
+    const [selectedIndex, setSelectedIndex] = React.useState(() => themeOptions.findIndex((opt) => opt.value === initialTheme));
+    const [saved, setSaved] = React.useState(false);
+    const [detectedTheme] = React.useState(getCurrentTheme());
+    // Update theme preview when selection changes
+    React.useEffect(() => {
+        const newTheme = themeOptions[selectedIndex].value;
+        let targetTheme;
+        if (newTheme === "auto") {
+            // For auto mode, show the detected theme
+            targetTheme = detectedTheme;
+        }
+        else {
+            // For explicit light/dark, set directly without detection
+            targetTheme = newTheme;
+        }
+        // Apply theme change for preview
+        setThemeMode(targetTheme);
+    }, [selectedIndex, detectedTheme]);
+    useInput((input, key) => {
+        if (saved) {
+            exit();
+            return;
+        }
+        if (key.upArrow && selectedIndex > 0) {
+            setSelectedIndex(selectedIndex - 1);
+        }
+        else if (key.downArrow && selectedIndex < themeOptions.length - 1) {
+            setSelectedIndex(selectedIndex + 1);
+        }
+        else if (key.return) {
+            // Save the selected theme to config
+            const selectedTheme = themeOptions[selectedIndex].value;
+            setThemePreference(selectedTheme);
+            // If setting to 'auto', clear cached detection for re-run
+            if (selectedTheme === "auto") {
+                clearDetectedTheme();
+            }
+            setSaved(true);
+            setTimeout(() => exit(), 1500);
+        }
+        else if (key.escape || input === "q") {
+            // Restore original theme without re-running detection
+            setThemePreference(initialTheme);
+            if (initialTheme === "auto") {
+                setThemeMode(detectedTheme);
+            }
+            else {
+                setThemeMode(initialTheme);
+            }
+            exit();
+        }
+    });
+    if (saved) {
+        return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Theme Configuration" }), _jsx(SuccessMessage, { message: `Theme set to: ${themeOptions[selectedIndex].label}`, details: "Theme applied immediately!" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { title: "Theme Configuration - Interactive" }), _jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Box, { children: [_jsx(Text, { color: colors.textDim, children: "Current preference: " }), _jsx(Text, { color: colors.primary, bold: true, children: themeOptions[selectedIndex].label }), themeOptions[selectedIndex].value === "auto" && (_jsxs(Text, { color: colors.textDim, children: [" (detected: ", detectedTheme, ")"] }))] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.text, bold: true, children: "Select theme mode:" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: themeOptions.map((option, index) => {
+                            const isSelected = index === selectedIndex;
+                            return (_jsxs(Box, { marginY: 0, children: [_jsxs(Text, { color: isSelected ? colors.primary : colors.textDim, children: [isSelected ? figures.pointer : " ", " "] }), _jsx(Text, { color: isSelected ? colors.primary : colors.text, bold: isSelected, children: option.label }), _jsxs(Text, { color: colors.textDim, children: [" - ", option.description] })] }, option.value));
+                        }) })] }), _jsxs(Box, { marginTop: 2, flexDirection: "column", children: [_jsxs(Text, { color: colors.text, bold: true, children: [figures.play, " Live Preview:"] }), _jsxs(Box, { marginTop: 1, marginLeft: 2, paddingX: 2, paddingY: 1, borderStyle: "round", borderColor: colors.primary, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.tick, " Primary"] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: colors.secondary, bold: true, children: [figures.star, " Secondary"] })] }), _jsxs(Box, { children: [_jsxs(Text, { color: colors.success, children: [figures.tick, " Success"] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: colors.warning, children: [figures.warning, " Warning"] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: colors.error, children: [figures.cross, " Error"] })] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.text, children: "Normal text" }), _jsx(Text, { children: " " }), _jsx(Text, { color: colors.textDim, children: "Dim text" })] })] })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { color: colors.textDim, dimColor: true, children: [figures.arrowUp, figures.arrowDown, " Navigate \u2022 [Enter] Save \u2022 [Esc] Cancel"] }) })] }));
+};
+const StaticConfigUI = ({ action, value }) => {
+    const [saved, setSaved] = React.useState(false);
+    React.useEffect(() => {
+        if (action === "set" && value) {
+            setThemePreference(value);
+            // If setting to 'auto', clear the cached detection so it re-runs on next start
+            if (value === "auto") {
+                clearDetectedTheme();
+            }
+            setSaved(true);
+            setTimeout(() => process.exit(0), 1500);
+        }
+        else if (action === "get" || !action) {
+            setTimeout(() => process.exit(0), 2000);
+        }
+    }, [action, value]);
+    const currentPreference = getThemePreference();
+    const activeTheme = getCurrentTheme();
+    if (saved) {
+        return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Theme Configuration" }), _jsx(SuccessMessage, { message: `Theme set to: ${value}`, details: "Restart the CLI for changes to take effect" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { title: "Theme Configuration" }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: colors.textDim, children: "Current preference: " }), _jsx(Text, { color: colors.primary, bold: true, children: currentPreference })] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.textDim, children: "Active theme: " }), _jsx(Text, { color: colors.success, bold: true, children: activeTheme })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.text, bold: true, children: "Available options:" }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { color: colors.textDim, children: ["\u2022 ", _jsx(Text, { color: colors.primary, children: "auto" }), " - Detect terminal background automatically"] }), _jsxs(Text, { color: colors.textDim, children: ["\u2022 ", _jsx(Text, { color: colors.primary, children: "light" }), " - Force light mode (dark text on light background)"] }), _jsxs(Text, { color: colors.textDim, children: ["\u2022 ", _jsx(Text, { color: colors.primary, children: "dark" }), " - Force dark mode (light text on dark background)"] })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.textDim, dimColor: true, children: "Usage: rli config theme [auto|light|dark]" }), _jsx(Text, { color: colors.textDim, dimColor: true, children: "Environment variable: RUNLOOP_THEME" })] })] }));
+};
+export function showThemeConfig() {
+    const currentTheme = getThemePreference();
+    render(_jsx(InteractiveThemeSelector, { initialTheme: currentTheme }));
+}
+export function setThemeConfig(theme) {
+    render(_jsx(StaticConfigUI, { action: "set", value: theme }));
+}

package/dist/commands/devbox/create.js

@@ -1,45 +1,125 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * Create devbox 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";
-import { colors } from "../../utils/theme.js";
-const CreateDevboxUI = ({ name, template }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const create = async () => {
-            try {
-                const client = getClient();
-                const devbox = await client.devboxes.create({
-                    name: name || `devbox-${Date.now()}`,
-                    ...(template && { template }),
-                });
-                setResult(devbox);
+import { output, outputError } from "../../utils/output.js";
+// Parse environment variables from KEY=value format
+function parseEnvVars(envVars) {
+    const result = {};
+    for (const envVar of envVars) {
+        const eqIndex = envVar.indexOf("=");
+        if (eqIndex === -1) {
+            throw new Error(`Invalid environment variable format: ${envVar}. Expected KEY=value`);
+        }
+        const key = envVar.substring(0, eqIndex);
+        const value = envVar.substring(eqIndex + 1);
+        result[key] = value;
+    }
+    return result;
+}
+// Parse code mounts from JSON format
+function parseCodeMounts(codeMounts) {
+    return codeMounts.map((mount) => {
+        try {
+            return JSON.parse(mount);
+        }
+        catch {
+            throw new Error(`Invalid code mount JSON: ${mount}`);
+        }
+    });
+}
+export async function createDevbox(options = {}) {
+    try {
+        const client = getClient();
+        // Parse user parameters
+        let userParameters = undefined;
+        if (options.user && options.root) {
+            outputError("Only one of --user or --root can be specified");
+        }
+        else if (options.user) {
+            const [username, uid] = options.user.split(":");
+            if (!username || !uid) {
+                outputError("User must be in format 'username:uid'");
             }
-            catch (err) {
-                setError(err);
+            userParameters = { username, uid: parseInt(uid) };
+        }
+        else if (options.root) {
+            userParameters = { username: "root", uid: 0 };
+        }
+        // Validate idle options
+        if ((options.idleTime && !options.idleAction) ||
+            (!options.idleTime && options.idleAction)) {
+            outputError("Both --idle-time and --idle-action must be specified together");
+        }
+        // Build launch parameters
+        const launchParameters = {};
+        if (options.resources) {
+            launchParameters.resource_size_request = options.resources;
+        }
+        if (options.architecture) {
+            launchParameters.architecture = options.architecture;
+        }
+        if (options.launchCommands) {
+            launchParameters.launch_commands = options.launchCommands;
+        }
+        if (options.availablePorts) {
+            launchParameters.available_ports = options.availablePorts.map((p) => parseInt(p, 10));
+        }
+        if (userParameters) {
+            launchParameters.user_parameters = userParameters;
+        }
+        if (options.idleTime && options.idleAction) {
+            launchParameters.after_idle = {
+                idle_time_seconds: parseInt(options.idleTime, 10),
+                on_idle: options.idleAction,
+            };
+        }
+        // Build create request
+        const createRequest = {
+            name: options.name || `devbox-${Date.now()}`,
+        };
+        // Handle snapshot (--template and --snapshot are aliases)
+        const snapshotId = options.snapshot || options.template;
+        if (snapshotId) {
+            createRequest.snapshot_id = snapshotId;
+        }
+        // Handle blueprint - can be either ID or name
+        if (options.blueprint) {
+            // If it looks like an ID (starts with bp_ or similar pattern), use blueprint_id
+            // Otherwise, use blueprint_name
+            if (options.blueprint.startsWith("bp_") ||
+                options.blueprint.startsWith("bpt_")) {
+                createRequest.blueprint_id = options.blueprint;
             }
-            finally {
-                setLoading(false);
+            else {
+                createRequest.blueprint_name = options.blueprint;
             }
-        };
-        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: 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);
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.create({
-            name: options.name || `devbox-${Date.now()}`,
-            ...(options.template && { template: options.template }),
-        });
-    }, () => _jsx(CreateDevboxUI, { name: options.name, template: options.template }));
+        }
+        // Handle entrypoint
+        if (options.entrypoint) {
+            createRequest.entrypoint = options.entrypoint;
+        }
+        // Handle environment variables
+        if (options.envVars && options.envVars.length > 0) {
+            createRequest.environment_variables = parseEnvVars(options.envVars);
+        }
+        // Handle code mounts
+        if (options.codeMounts && options.codeMounts.length > 0) {
+            createRequest.code_mounts = parseCodeMounts(options.codeMounts);
+        }
+        if (Object.keys(launchParameters).length > 0) {
+            createRequest.launch_parameters = launchParameters;
+        }
+        const devbox = await client.devboxes.create(createRequest);
+        // Default: just output the ID for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(devbox.id);
+        }
+        else {
+            output(devbox, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to create devbox", error);
+    }
 }

package/dist/commands/devbox/delete.js

@@ -1,37 +1,21 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Delete (shutdown) devbox command
+ */
 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);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const deleteDevbox = async () => {
-            try {
-                const client = getClient();
-                await client.devboxes.shutdown(id);
-                setSuccess(true);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        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 }))] }));
-};
+import { output, outputError } from "../../utils/output.js";
 export async function deleteDevbox(id, options = {}) {
-    const executor = createExecutor(options);
-    await executor.executeDelete(async () => {
-        const client = executor.getClient();
+    try {
+        const client = getClient();
         await client.devboxes.shutdown(id);
-    }, id, () => _jsx(DeleteDevboxUI, { id: id }));
+        // Default: just output the ID for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(id);
+        }
+        else {
+            output({ id, status: "shutdown" }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to shutdown devbox", error);
+    }
 }