@runloop/rl-cli 0.1.2 → 0.3.0

package/dist/screens/DevboxDetailScreen.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * DevboxDetailScreen - Pure UI component for devbox details
+ * Refactored from components/DevboxDetailPage.tsx
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { useDevboxStore } from "../store/devboxStore.js";
+import { DevboxDetailPage } from "../components/DevboxDetailPage.js";
+import { getDevbox } from "../services/devboxService.js";
+import { SpinnerComponent } from "../components/Spinner.js";
+import { ErrorMessage } from "../components/ErrorMessage.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+export function DevboxDetailScreen({ devboxId }) {
+    const { goBack } = useNavigation();
+    const devboxes = useDevboxStore((state) => state.devboxes);
+    const setDevboxesInStore = useDevboxStore((state) => state.setDevboxes);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [fetchedDevbox, setFetchedDevbox] = React.useState(null);
+    // Find devbox in store first
+    const devboxFromStore = devboxes.find((d) => d.id === devboxId);
+    // Fetch devbox from API if not in store
+    React.useEffect(() => {
+        if (!devboxFromStore && devboxId && !loading && !fetchedDevbox) {
+            setLoading(true);
+            setError(null);
+            getDevbox(devboxId)
+                .then((devbox) => {
+                setFetchedDevbox(devbox);
+                // Cache it in store for future access
+                setDevboxesInStore([devbox]);
+                setLoading(false);
+            })
+                .catch((err) => {
+                setError(err);
+                setLoading(false);
+            });
+        }
+    }, [devboxFromStore, devboxId, loading, fetchedDevbox, setDevboxesInStore]);
+    // Use devbox from store or fetched devbox
+    const devbox = devboxFromStore || fetchedDevbox;
+    // Show loading state while fetching
+    if (loading) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Loading...", active: true }] }), _jsx(SpinnerComponent, { message: "Loading devbox details..." })] }));
+    }
+    // Show error state if fetch failed
+    if (error) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Error", active: true }] }), _jsx(ErrorMessage, { message: "Failed to load devbox details", error: error })] }));
+    }
+    // Show error if no devbox found and not loading
+    if (!devbox && !loading) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Not Found", active: true }] }), _jsx(ErrorMessage, { message: `Devbox ${devboxId || "unknown"} not found`, error: new Error("Devbox not found in cache and could not be fetched") })] }));
+    }
+    // At this point devbox is guaranteed to exist (loading check above handles the null case)
+    if (!devbox) {
+        return null; // TypeScript guard - should never reach here
+    }
+    return _jsx(DevboxDetailPage, { devbox: devbox, onBack: goBack });
+}

package/dist/screens/DevboxListScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * DevboxListScreen - Pure UI component using devboxStore
+ * Simplified version for now - wraps existing component
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { ListDevboxesUI } from "../commands/devbox/list.js";
+export function DevboxListScreen({ status, focusDevboxId, }) {
+    const { goBack, navigate } = useNavigation();
+    // If focusDevboxId is provided, navigate directly to detail screen
+    // instead of letting ListDevboxesUI handle it internally
+    React.useEffect(() => {
+        if (focusDevboxId) {
+            navigate("devbox-detail", { devboxId: focusDevboxId });
+        }
+    }, [focusDevboxId, navigate]);
+    // Navigation callback to handle detail view via Router
+    const handleNavigateToDetail = React.useCallback((devboxId) => {
+        navigate("devbox-detail", { devboxId });
+    }, [navigate]);
+    return (_jsx(ListDevboxesUI, { status: status, onBack: goBack, onExit: goBack, onNavigateToDetail: handleNavigateToDetail }));
+}

package/dist/screens/LogsSessionScreen.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * LogsSessionScreen - Logs viewer using custom InteractiveSpawn
+ * Runs the CLI logs command as a subprocess within the Ink UI without exiting
+ */
+import React from "react";
+import { Box, Text } from "ink";
+import { InteractiveSpawn } from "../components/InteractiveSpawn.js";
+import { useNavigation, } from "../store/navigationStore.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { colors } from "../utils/theme.js";
+import figures from "figures";
+import { useExitOnCtrlC } from "../hooks/useExitOnCtrlC.js";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+export function LogsSessionScreen() {
+    const { params, navigate } = useNavigation();
+    // Handle Ctrl+C to exit (before logs command runs or on error)
+    useExitOnCtrlC();
+    // Extract params
+    const devboxId = params.devboxId;
+    const devboxName = params.devboxName || params.devboxId || "devbox";
+    const returnScreen = params.returnScreen || "devbox-list";
+    const returnParams = params.returnParams || {};
+    // Get the path to the CLI executable
+    const cliPath = React.useMemo(() => {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // When compiled, this file is in dist/screens/, so go up one level to dist/cli.js
+        return join(__dirname, "../cli.js");
+    }, []);
+    // Validate required params
+    if (!devboxId) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Logs", active: true }] }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Text, { color: colors.error, children: [figures.cross, " Missing devbox ID. Returning..."] }) })] }));
+    }
+    // Build CLI command args
+    const cliArgs = React.useMemo(() => ["devbox", "logs", devboxId], [devboxId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Logs", active: true }] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.info, " Viewing logs for ", devboxName, "..."] }), _jsx(Text, { color: colors.textDim, dimColor: true, children: "Press Ctrl+C to exit" })] }), _jsx(InteractiveSpawn, { command: "node", args: [cliPath, ...cliArgs], onExit: (_code) => {
+                    // Navigate back to previous screen when logs command exits
+                    setTimeout(() => {
+                        navigate(returnScreen, returnParams || {});
+                    }, 100);
+                }, onError: (_error) => {
+                    // On error, navigate back as well
+                    setTimeout(() => {
+                        navigate(returnScreen, returnParams || {});
+                    }, 100);
+                } })] }));
+}

package/dist/screens/MenuScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { MainMenu } from "../components/MainMenu.js";
+export function MenuScreen() {
+    const { navigate } = useNavigation();
+    const handleSelect = (key) => {
+        switch (key) {
+            case "devboxes":
+                navigate("devbox-list");
+                break;
+            case "blueprints":
+                navigate("blueprint-list");
+                break;
+            case "snapshots":
+                navigate("snapshot-list");
+                break;
+            default:
+                // Fallback for any other screen names
+                navigate(key);
+        }
+    };
+    return _jsx(MainMenu, { onSelect: handleSelect });
+}

package/dist/screens/SSHSessionScreen.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * SSHSessionScreen - SSH session using custom InteractiveSpawn
+ * Runs SSH as a subprocess within the Ink UI without exiting
+ */
+import React from "react";
+import { Box, Text } from "ink";
+import { InteractiveSpawn } from "../components/InteractiveSpawn.js";
+import { useNavigation, } from "../store/navigationStore.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { colors } from "../utils/theme.js";
+import figures from "figures";
+export function SSHSessionScreen() {
+    const { params, replace } = useNavigation();
+    // NOTE: Do NOT use useExitOnCtrlC here - SSH handles Ctrl+C itself
+    // Using useInput would conflict with the subprocess's terminal control
+    // Extract SSH config from params
+    const keyPath = params.keyPath;
+    const proxyCommand = params.proxyCommand;
+    const sshUser = params.sshUser;
+    const url = params.url;
+    const devboxName = params.devboxName || params.devboxId || "devbox";
+    const returnScreen = params.returnScreen || "devbox-list";
+    const returnParams = params.returnParams || {};
+    // Validate required params
+    if (!keyPath || !proxyCommand || !sshUser || !url) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "SSH Session", active: true }] }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Text, { color: colors.error, children: [figures.cross, " Missing SSH configuration. Returning..."] }) })] }));
+    }
+    // Build SSH command args
+    // The proxy command needs to be passed as a single value in the -o option
+    const sshArgs = React.useMemo(() => [
+        "-t", // Force pseudo-terminal allocation for proper input handling
+        "-i",
+        keyPath,
+        "-o",
+        `ProxyCommand=${proxyCommand}`,
+        "-o",
+        "StrictHostKeyChecking=no",
+        "-o",
+        "UserKnownHostsFile=/dev/null",
+        `${sshUser}@${url}`,
+    ], [keyPath, proxyCommand, sshUser, url]);
+    return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "SSH Session", active: true }] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.play, " Connecting to ", devboxName, "..."] }), _jsx(Text, { color: colors.textDim, dimColor: true, children: "Press Ctrl+C or type exit to disconnect" })] }), _jsx(InteractiveSpawn, { command: "ssh", args: sshArgs, onExit: (_code) => {
+                    // Replace current screen (don't add SSH to history stack)
+                    // Using replace() instead of navigate() prevents "escape goes back to SSH" bug
+                    setTimeout(() => {
+                        replace(returnScreen, returnParams || {});
+                    }, 100);
+                }, onError: (_error) => {
+                    // On error, replace current screen as well
+                    setTimeout(() => {
+                        replace(returnScreen, returnParams || {});
+                    }, 100);
+                } })] }));
+}

package/dist/screens/SnapshotListScreen.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { ListSnapshotsUI } from "../commands/snapshot/list.js";
+export function SnapshotListScreen() {
+    const { goBack } = useNavigation();
+    return _jsx(ListSnapshotsUI, { onBack: goBack, onExit: goBack });
+}

package/dist/services/blueprintService.js

@@ -0,0 +1,101 @@
+/**
+ * Blueprint Service - Handles all blueprint API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List blueprints with pagination
+ */
+export async function listBlueprints(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.search) {
+        queryParams.name = options.search;
+    }
+    const pagePromise = client.blueprints.list(queryParams);
+    const page = (await pagePromise);
+    const blueprints = [];
+    if (page.blueprints && Array.isArray(page.blueprints)) {
+        page.blueprints.forEach((b) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_STATUS_LENGTH = 50;
+            const MAX_ARCH_LENGTH = 50;
+            const MAX_RESOURCES_LENGTH = 100;
+            // Extract architecture and resources from launch_parameters
+            const architecture = b.parameters?.launch_parameters?.architecture;
+            const resources = b.parameters?.launch_parameters?.resource_size_request;
+            blueprints.push({
+                id: String(b.id || "").substring(0, MAX_ID_LENGTH),
+                name: String(b.name || "").substring(0, MAX_NAME_LENGTH),
+                status: String(b.status || "").substring(0, MAX_STATUS_LENGTH),
+                create_time_ms: b.create_time_ms,
+                build_status: b.status
+                    ? String(b.status).substring(0, MAX_STATUS_LENGTH)
+                    : undefined,
+                architecture: architecture
+                    ? String(architecture).substring(0, MAX_ARCH_LENGTH)
+                    : undefined,
+                resources: resources
+                    ? String(resources).substring(0, MAX_RESOURCES_LENGTH)
+                    : undefined,
+            });
+        });
+    }
+    const result = {
+        blueprints,
+        totalCount: page.total_count || blueprints.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single blueprint by ID
+ */
+export async function getBlueprint(id) {
+    const client = getClient();
+    const blueprint = await client.blueprints.retrieve(id);
+    return {
+        id: blueprint.id,
+        name: blueprint.name,
+        status: blueprint.status,
+        create_time_ms: blueprint.create_time_ms,
+        build_status: blueprint.build_status,
+        architecture: blueprint.architecture,
+        resources: blueprint.resources,
+    };
+}
+/**
+ * Get blueprint logs
+ * Returns the raw logs array from the API response
+ * Similar to getDevboxLogs - formatting is handled by logFormatter
+ */
+export async function getBlueprintLogs(id) {
+    const client = getClient();
+    const response = await client.blueprints.logs(id);
+    // Return the logs array directly - formatting is handled by logFormatter
+    // Ensure timestamp_ms is present (API may return timestamp or timestamp_ms)
+    if (response.logs && Array.isArray(response.logs)) {
+        return response.logs.map((log) => {
+            // Normalize timestamp field to timestamp_ms if needed
+            // Create a new object to avoid mutating the original
+            const normalizedLog = { ...log };
+            if (normalizedLog.timestamp && !normalizedLog.timestamp_ms) {
+                // If timestamp is a number, use it directly; if it's a string, parse it
+                if (typeof normalizedLog.timestamp === "number") {
+                    normalizedLog.timestamp_ms = normalizedLog.timestamp;
+                }
+                else if (typeof normalizedLog.timestamp === "string") {
+                    normalizedLog.timestamp_ms = new Date(normalizedLog.timestamp).getTime();
+                }
+            }
+            return normalizedLog;
+        });
+    }
+    return [];
+}

package/dist/services/devboxService.js

@@ -0,0 +1,215 @@
+/**
+ * Devbox Service - Handles all devbox API calls
+ * Returns plain data objects with no SDK reference retention
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * Recursively truncate all strings in an object to prevent Yoga crashes
+ * CRITICAL: Must be applied to ALL data from API before storing/rendering
+ */
+function truncateStrings(obj, maxLength = 200) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj === "string") {
+        return (obj.length > maxLength ? obj.substring(0, maxLength) : obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => truncateStrings(item, maxLength));
+    }
+    if (typeof obj === "object") {
+        const result = {};
+        for (const key in obj) {
+            if (Object.hasOwn(obj, key)) {
+                result[key] = truncateStrings(obj[key], maxLength);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * List devboxes with pagination
+ * CRITICAL: Creates defensive copies to break SDK reference chains
+ */
+export async function listDevboxes(options) {
+    // Check if aborted before making request
+    if (options.signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.status) {
+        queryParams.status = options.status;
+    }
+    if (options.search) {
+        queryParams.name = options.search;
+    }
+    // Fetch ONE page only - never iterate
+    const pagePromise = client.devboxes.list(queryParams);
+    // Wrap in Promise.race to support abort
+    let page;
+    if (options.signal) {
+        const abortPromise = new Promise((_, reject) => {
+            options.signal.addEventListener("abort", () => {
+                reject(new DOMException("Aborted", "AbortError"));
+            });
+        });
+        try {
+            page = (await Promise.race([
+                pagePromise,
+                abortPromise,
+            ]));
+        }
+        catch (err) {
+            // Re-throw abort errors, convert others
+            if (err?.name === "AbortError") {
+                throw err;
+            }
+            throw err;
+        }
+    }
+    else {
+        page = (await pagePromise);
+    }
+    // Check again after await (in case abort happened during request)
+    if (options.signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    // Extract data and create defensive copies immediately
+    const devboxes = [];
+    if (page.devboxes && Array.isArray(page.devboxes)) {
+        page.devboxes.forEach((d) => {
+            // CRITICAL: Recursively truncate ALL strings in the object to prevent Yoga crashes
+            // This catches nested fields like launch_parameters.user_parameters.username
+            const truncated = truncateStrings(d, 200);
+            devboxes.push(truncated);
+        });
+    }
+    const result = {
+        devboxes,
+        totalCount: page.total_count || devboxes.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single devbox by ID
+ */
+export async function getDevbox(id) {
+    const client = getClient();
+    const devbox = await client.devboxes.retrieve(id);
+    // CRITICAL: Recursively truncate ALL strings in the object to prevent Yoga crashes
+    return truncateStrings(devbox, 200);
+}
+/**
+ * Delete a devbox (actually shuts it down)
+ */
+export async function deleteDevbox(id) {
+    const client = getClient();
+    await client.devboxes.shutdown(id);
+}
+/**
+ * Shutdown a devbox
+ */
+export async function shutdownDevbox(id) {
+    const client = getClient();
+    await client.devboxes.shutdown(id);
+}
+/**
+ * Suspend a devbox
+ */
+export async function suspendDevbox(id) {
+    const client = getClient();
+    await client.devboxes.suspend(id);
+}
+/**
+ * Resume a devbox
+ */
+export async function resumeDevbox(id) {
+    const client = getClient();
+    await client.devboxes.resume(id);
+}
+/**
+ * Upload file to devbox
+ */
+export async function uploadFile(id, filepath, remotePath) {
+    const client = getClient();
+    const fs = await import("fs");
+    const fileStream = fs.createReadStream(filepath);
+    await client.devboxes.uploadFile(id, {
+        file: fileStream,
+        path: remotePath,
+    });
+}
+/**
+ * Create snapshot of devbox
+ */
+export async function createSnapshot(id, name) {
+    const client = getClient();
+    const snapshot = await client.devboxes.snapshotDisk(id, { name });
+    return {
+        id: String(snapshot.id || "").substring(0, 100),
+        name: snapshot.name ? String(snapshot.name).substring(0, 200) : undefined,
+    };
+}
+/**
+ * Create SSH key for devbox
+ */
+export async function createSSHKey(id) {
+    const client = getClient();
+    const result = await client.devboxes.createSSHKey(id);
+    // Truncate keys if they're unexpectedly long (shouldn't happen, but safety)
+    return {
+        ssh_private_key: String(result.ssh_private_key || "").substring(0, 10000),
+        url: String(result.url || "").substring(0, 500),
+    };
+}
+/**
+ * Create tunnel to devbox
+ */
+export async function createTunnel(id, port) {
+    const client = getClient();
+    const tunnel = await client.devboxes.createTunnel(id, { port });
+    return {
+        url: String(tunnel.url || "").substring(0, 500),
+    };
+}
+/**
+ * Execute command in devbox
+ */
+export async function execCommand(id, command) {
+    const client = getClient();
+    const result = await client.devboxes.executeSync(id, { command });
+    // CRITICAL: Truncate output to prevent Yoga crashes
+    const MAX_OUTPUT_LENGTH = 10000; // Allow more for command output
+    let stdout = String(result.stdout || "");
+    let stderr = String(result.stderr || "");
+    if (stdout.length > MAX_OUTPUT_LENGTH) {
+        stdout =
+            stdout.substring(0, MAX_OUTPUT_LENGTH) + "\n... (output truncated)";
+    }
+    if (stderr.length > MAX_OUTPUT_LENGTH) {
+        stderr =
+            stderr.substring(0, MAX_OUTPUT_LENGTH) + "\n... (output truncated)";
+    }
+    return {
+        stdout,
+        stderr,
+        exit_code: result.exit_code || 0,
+    };
+}
+/**
+ * Get devbox logs
+ * Returns the raw logs array from the API response
+ */
+export async function getDevboxLogs(id) {
+    const client = getClient();
+    const response = await client.devboxes.logs.list(id);
+    // Return the logs array directly - formatting is handled by logFormatter
+    return response.logs || [];
+}

package/dist/services/snapshotService.js

@@ -0,0 +1,81 @@
+/**
+ * Snapshot Service - Handles all snapshot API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List snapshots with pagination
+ */
+export async function listSnapshots(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.devboxId) {
+        queryParams.devbox_id = options.devboxId;
+    }
+    const pagePromise = client.devboxes.listDiskSnapshots(queryParams);
+    const page = (await pagePromise);
+    const snapshots = [];
+    if (page.snapshots && Array.isArray(page.snapshots)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        page.snapshots.forEach((s) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_STATUS_LENGTH = 50;
+            // Status is constructed/available in API response but not in type definition
+            const snapshotView = s;
+            snapshots.push({
+                id: String(snapshotView.id || "").substring(0, MAX_ID_LENGTH),
+                name: snapshotView.name
+                    ? String(snapshotView.name).substring(0, MAX_NAME_LENGTH)
+                    : undefined,
+                devbox_id: String(snapshotView.source_devbox_id || "").substring(0, MAX_ID_LENGTH),
+                status: snapshotView.status
+                    ? String(snapshotView.status).substring(0, MAX_STATUS_LENGTH)
+                    : "",
+                create_time_ms: snapshotView.create_time_ms,
+            });
+        });
+    }
+    const result = {
+        snapshots,
+        totalCount: page.total_count || snapshots.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get snapshot status by ID
+ */
+export async function getSnapshotStatus(id) {
+    const client = getClient();
+    const status = await client.devboxes.diskSnapshots.queryStatus(id);
+    return status;
+}
+/**
+ * Create a snapshot
+ */
+export async function createSnapshot(devboxId, name) {
+    const client = getClient();
+    const snapshot = await client.devboxes.snapshotDisk(devboxId, {
+        name,
+    });
+    return {
+        id: snapshot.id,
+        name: snapshot.name || undefined,
+        devbox_id: snapshot.devbox_id || devboxId,
+        status: snapshot.status || "pending",
+        create_time_ms: snapshot.create_time_ms,
+    };
+}
+/**
+ * Delete a snapshot
+ */
+export async function deleteSnapshot(id) {
+    const client = getClient();
+    await client.devboxes.diskSnapshots.delete(id);
+}