@runloop/rl-cli 1.7.1 → 1.9.0

package/dist/commands/secret/list.js

@@ -1,9 +1,384 @@
-/**
- * List secrets command
- */
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import figures from "figures";
 import { getClient } from "../../utils/client.js";
+import { Header } from "../../components/Header.js";
+import { SpinnerComponent } from "../../components/Spinner.js";
+import { ErrorMessage } from "../../components/ErrorMessage.js";
+import { SuccessMessage } from "../../components/SuccessMessage.js";
+import { Breadcrumb } from "../../components/Breadcrumb.js";
+import { NavigationTips } from "../../components/NavigationTips.js";
+import { Table, createTextColumn } from "../../components/Table.js";
+import { ActionsPopup } from "../../components/ActionsPopup.js";
+import { formatTimeAgo } from "../../components/ResourceListView.js";
+import { SearchBar } from "../../components/SearchBar.js";
 import { output, outputError } from "../../utils/output.js";
-const DEFAULT_PAGE_SIZE = 20;
+import { colors } from "../../utils/theme.js";
+import { useViewportHeight } from "../../hooks/useViewportHeight.js";
+import { useExitOnCtrlC } from "../../hooks/useExitOnCtrlC.js";
+import { useCursorPagination } from "../../hooks/useCursorPagination.js";
+import { useListSearch } from "../../hooks/useListSearch.js";
+import { useNavigation } from "../../store/navigationStore.js";
+import { ConfirmationPrompt } from "../../components/ConfirmationPrompt.js";
+const DEFAULT_PAGE_SIZE = 10;
+const ListSecretsUI = ({ onBack, onExit, }) => {
+    const { exit: inkExit } = useApp();
+    const { navigate } = useNavigation();
+    const [selectedIndex, setSelectedIndex] = React.useState(0);
+    const [showPopup, setShowPopup] = React.useState(false);
+    const [selectedOperation, setSelectedOperation] = React.useState(0);
+    const [selectedSecret, setSelectedSecret] = React.useState(null);
+    const [executingOperation, setExecutingOperation] = React.useState(null);
+    const [operationResult, setOperationResult] = React.useState(null);
+    const [operationError, setOperationError] = React.useState(null);
+    const [operationLoading, setOperationLoading] = React.useState(false);
+    const [showDeleteConfirm, setShowDeleteConfirm] = React.useState(false);
+    // Search state
+    const search = useListSearch({
+        onSearchSubmit: () => setSelectedIndex(0),
+        onSearchClear: () => setSelectedIndex(0),
+    });
+    // Calculate overhead for viewport height
+    const overhead = 13 + search.getSearchOverhead();
+    const { viewportHeight, terminalWidth } = useViewportHeight({
+        overhead,
+        minHeight: 5,
+    });
+    const PAGE_SIZE = viewportHeight;
+    // All width constants
+    const fixedWidth = 6; // border + padding
+    const idWidth = 30;
+    const timeWidth = 20;
+    // Name width uses remaining space after fixed columns
+    const baseWidth = fixedWidth + idWidth + timeWidth;
+    const remainingWidth = terminalWidth - baseWidth;
+    const nameWidth = Math.min(80, Math.max(15, remainingWidth));
+    // Fetch function for pagination hook
+    const fetchPage = React.useCallback(async (params) => {
+        const client = getClient();
+        const pageSecrets = [];
+        // Secrets API doesn't support cursor pagination, fetch all and paginate client-side
+        const result = await client.secrets.list({ limit: 5000 });
+        // Extract data and filter by search if needed
+        if (result.secrets && Array.isArray(result.secrets)) {
+            let filtered = result.secrets;
+            // Client-side search filtering
+            if (search.submittedSearchQuery) {
+                const query = search.submittedSearchQuery.toLowerCase();
+                filtered = filtered.filter((s) => s.name?.toLowerCase().includes(query) ||
+                    s.id?.toLowerCase().includes(query));
+            }
+            // Client-side pagination
+            const startIdx = params.startingAt
+                ? filtered.findIndex((s) => s.id === params.startingAt) + 1
+                : 0;
+            const pageItems = filtered.slice(startIdx, startIdx + params.limit);
+            pageItems.forEach((s) => {
+                pageSecrets.push({
+                    id: s.id,
+                    name: s.name,
+                    create_time_ms: s.create_time_ms,
+                    update_time_ms: s.update_time_ms,
+                });
+            });
+            return {
+                items: pageSecrets,
+                hasMore: startIdx + params.limit < filtered.length,
+                totalCount: filtered.length,
+            };
+        }
+        return {
+            items: pageSecrets,
+            hasMore: false,
+            totalCount: 0,
+        };
+    }, [search.submittedSearchQuery]);
+    // Use the shared pagination hook
+    const { items: secrets, loading, navigating, error, currentPage, hasMore, hasPrev, totalCount, nextPage, prevPage, refresh, } = useCursorPagination({
+        fetchPage,
+        pageSize: PAGE_SIZE,
+        getItemId: (secret) => secret.id,
+        pollInterval: 10000,
+        pollingEnabled: !showPopup &&
+            !executingOperation &&
+            !showDeleteConfirm &&
+            !search.searchMode,
+        deps: [PAGE_SIZE, search.submittedSearchQuery],
+    });
+    // Operations for a specific secret (shown in popup)
+    const operations = React.useMemo(() => [
+        {
+            key: "view_details",
+            label: "View Details",
+            color: colors.primary,
+            icon: figures.pointer,
+        },
+        {
+            key: "delete",
+            label: "Delete Secret",
+            color: colors.error,
+            icon: figures.cross,
+        },
+    ], []);
+    // Build columns
+    const columns = React.useMemo(() => [
+        createTextColumn("id", "ID", (secret) => secret.id, {
+            width: idWidth + 1,
+            color: colors.idColor,
+            dimColor: false,
+            bold: false,
+        }),
+        createTextColumn("name", "Name", (secret) => secret.name || "", {
+            width: nameWidth,
+        }),
+        createTextColumn("created", "Created", (secret) => secret.create_time_ms ? formatTimeAgo(secret.create_time_ms) : "-", {
+            width: timeWidth,
+            color: colors.textDim,
+            dimColor: false,
+            bold: false,
+        }),
+    ], [idWidth, nameWidth, timeWidth]);
+    // Handle Ctrl+C to exit
+    useExitOnCtrlC();
+    // Ensure selected index is within bounds
+    React.useEffect(() => {
+        if (secrets.length > 0 && selectedIndex >= secrets.length) {
+            setSelectedIndex(Math.max(0, secrets.length - 1));
+        }
+    }, [secrets.length, selectedIndex]);
+    const selectedSecretItem = secrets[selectedIndex];
+    // Calculate pagination info for display
+    const totalPages = Math.max(1, Math.ceil(totalCount / PAGE_SIZE));
+    const startIndex = currentPage * PAGE_SIZE;
+    const endIndex = startIndex + secrets.length;
+    const executeOperation = async (secret, operationKey) => {
+        const client = getClient();
+        if (!secret)
+            return;
+        try {
+            setOperationLoading(true);
+            switch (operationKey) {
+                case "delete":
+                    await client.secrets.delete(secret.name);
+                    setOperationResult(`Secret "${secret.name}" deleted successfully`);
+                    break;
+            }
+        }
+        catch (err) {
+            setOperationError(err);
+        }
+        finally {
+            setOperationLoading(false);
+        }
+    };
+    useInput((input, key) => {
+        // Handle search mode input
+        if (search.searchMode) {
+            if (key.escape) {
+                search.cancelSearch();
+            }
+            return;
+        }
+        // Handle operation result display
+        if (operationResult || operationError) {
+            if (input === "q" || key.escape || key.return) {
+                const wasDelete = executingOperation === "delete";
+                const hadError = operationError !== null;
+                setOperationResult(null);
+                setOperationError(null);
+                setExecutingOperation(null);
+                setSelectedSecret(null);
+                // Refresh the list after delete to show updated data
+                if (wasDelete && !hadError) {
+                    setTimeout(() => refresh(), 0);
+                }
+            }
+            return;
+        }
+        // Handle popup navigation
+        if (showPopup) {
+            if (key.upArrow && selectedOperation > 0) {
+                setSelectedOperation(selectedOperation - 1);
+            }
+            else if (key.downArrow && selectedOperation < operations.length - 1) {
+                setSelectedOperation(selectedOperation + 1);
+            }
+            else if (key.return) {
+                setShowPopup(false);
+                const operationKey = operations[selectedOperation].key;
+                if (operationKey === "view_details") {
+                    navigate("secret-detail", {
+                        secretId: selectedSecretItem.id,
+                    });
+                }
+                else if (operationKey === "delete") {
+                    // Show delete confirmation
+                    setSelectedSecret(selectedSecretItem);
+                    setShowDeleteConfirm(true);
+                }
+                else {
+                    setSelectedSecret(selectedSecretItem);
+                    setExecutingOperation(operationKey);
+                    // Execute immediately with values passed directly
+                    executeOperation(selectedSecretItem, operationKey);
+                }
+            }
+            else if (input === "c") {
+                // Create hotkey
+                setShowPopup(false);
+                navigate("secret-create");
+            }
+            else if (input === "v" && selectedSecretItem) {
+                // View details hotkey
+                setShowPopup(false);
+                navigate("secret-detail", {
+                    secretId: selectedSecretItem.id,
+                });
+            }
+            else if (key.escape || input === "q") {
+                setShowPopup(false);
+                setSelectedOperation(0);
+            }
+            else if (input === "d") {
+                // Delete hotkey - show confirmation
+                setShowPopup(false);
+                setSelectedSecret(selectedSecretItem);
+                setShowDeleteConfirm(true);
+            }
+            return;
+        }
+        const pageSecrets = secrets.length;
+        // Handle list view navigation
+        if (key.upArrow && selectedIndex > 0) {
+            setSelectedIndex(selectedIndex - 1);
+        }
+        else if (key.downArrow && selectedIndex < pageSecrets - 1) {
+            setSelectedIndex(selectedIndex + 1);
+        }
+        else if ((input === "n" || key.rightArrow) &&
+            !loading &&
+            !navigating &&
+            hasMore) {
+            nextPage();
+            setSelectedIndex(0);
+        }
+        else if ((input === "p" || key.leftArrow) &&
+            !loading &&
+            !navigating &&
+            hasPrev) {
+            prevPage();
+            setSelectedIndex(0);
+        }
+        else if (key.return && selectedSecretItem) {
+            // Enter key navigates to detail view
+            navigate("secret-detail", {
+                secretId: selectedSecretItem.id,
+            });
+        }
+        else if (input === "a") {
+            setShowPopup(true);
+            setSelectedOperation(0);
+        }
+        else if (input === "c") {
+            // Create shortcut
+            navigate("secret-create");
+        }
+        else if (input === "/") {
+            search.enterSearchMode();
+        }
+        else if (key.escape) {
+            if (search.handleEscape()) {
+                return;
+            }
+            if (onBack) {
+                onBack();
+            }
+            else if (onExit) {
+                onExit();
+            }
+            else {
+                inkExit();
+            }
+        }
+    });
+    // Delete confirmation
+    if (showDeleteConfirm && selectedSecret) {
+        return (_jsx(ConfirmationPrompt, { title: "Delete Secret", message: `Are you sure you want to delete "${selectedSecret.name}"?`, details: "This action cannot be undone. Any devboxes using this secret will no longer have access to it.", breadcrumbItems: [
+                { label: "Settings" },
+                { label: "Secrets" },
+                { label: selectedSecret.name || selectedSecret.id },
+                { label: "Delete", active: true },
+            ], onConfirm: () => {
+                setShowDeleteConfirm(false);
+                setExecutingOperation("delete");
+                executeOperation(selectedSecret, "delete");
+            }, onCancel: () => {
+                setShowDeleteConfirm(false);
+                setSelectedSecret(null);
+            } }));
+    }
+    // Operation result display
+    if (operationResult || operationError) {
+        const operationLabel = operations.find((o) => o.key === executingOperation)?.label ||
+            "Operation";
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Settings" },
+                        { label: "Secrets" },
+                        {
+                            label: selectedSecret?.name || selectedSecret?.id || "Secret",
+                        },
+                        { label: operationLabel, active: true },
+                    ] }), _jsx(Header, { title: "Operation Result" }), operationResult && _jsx(SuccessMessage, { message: operationResult }), operationError && (_jsx(ErrorMessage, { message: "Operation failed", error: operationError })), _jsx(NavigationTips, { tips: [{ key: "Enter/q/esc", label: "Continue" }] })] }));
+    }
+    // Operation loading state
+    if (operationLoading && selectedSecret) {
+        const operationLabel = operations.find((o) => o.key === executingOperation)?.label ||
+            "Operation";
+        const messages = {
+            delete: "Deleting secret...",
+        };
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Settings" },
+                        { label: "Secrets" },
+                        { label: selectedSecret.name || selectedSecret.id },
+                        { label: operationLabel, active: true },
+                    ] }), _jsx(Header, { title: "Executing Operation" }), _jsx(SpinnerComponent, { message: messages[executingOperation] || "Please wait..." })] }));
+    }
+    // Loading state
+    if (loading && secrets.length === 0) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Settings" }, { label: "Secrets", active: true }] }), _jsx(SpinnerComponent, { message: "Loading secrets..." })] }));
+    }
+    // Error state
+    if (error) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Settings" }, { label: "Secrets", active: true }] }), _jsx(ErrorMessage, { message: "Failed to list secrets", error: error })] }));
+    }
+    // Main list view
+    return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Settings" }, { label: "Secrets", active: true }] }), _jsx(SearchBar, { searchMode: search.searchMode, searchQuery: search.searchQuery, submittedSearchQuery: search.submittedSearchQuery, resultCount: totalCount, onSearchChange: search.setSearchQuery, onSearchSubmit: search.submitSearch, placeholder: "Search secrets..." }), !showPopup && (_jsx(Table, { data: secrets, keyExtractor: (secret) => secret.id, selectedIndex: selectedIndex, title: `secrets[${totalCount}]`, columns: columns, emptyState: _jsxs(Text, { color: colors.textDim, children: [figures.info, " No secrets found. Press [c] to create one."] }) })), !showPopup && (_jsxs(Box, { marginTop: 1, paddingX: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.hamburger, " ", totalCount] }), _jsxs(Text, { color: colors.textDim, dimColor: true, children: [" ", "total"] }), totalPages > 1 && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: colors.textDim, dimColor: true, children: [" ", "\u2022", " "] }), navigating ? (_jsxs(Text, { color: colors.warning, children: [figures.pointer, " Loading page ", currentPage + 1, "..."] })) : (_jsxs(Text, { color: colors.textDim, dimColor: true, children: ["Page ", currentPage + 1, " of ", totalPages] }))] })), _jsxs(Text, { color: colors.textDim, dimColor: true, children: [" ", "\u2022", " "] }), _jsxs(Text, { color: colors.textDim, dimColor: true, children: ["Showing ", startIndex + 1, "-", endIndex, " of ", totalCount] }), search.submittedSearchQuery && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: colors.textDim, dimColor: true, children: [" ", "\u2022", " "] }), _jsxs(Text, { color: colors.warning, children: ["Filtered: \"", search.submittedSearchQuery, "\""] })] }))] })), showPopup && selectedSecretItem && (_jsx(Box, { marginTop: 2, justifyContent: "center", children: _jsx(ActionsPopup, { devbox: selectedSecretItem, operations: operations.map((op) => ({
+                        key: op.key,
+                        label: op.label,
+                        color: op.color,
+                        icon: op.icon,
+                        shortcut: op.key === "view_details"
+                            ? "v"
+                            : op.key === "delete"
+                                ? "d"
+                                : "",
+                    })), selectedOperation: selectedOperation, onClose: () => setShowPopup(false) }) })), _jsx(NavigationTips, { showArrows: true, tips: [
+                    {
+                        icon: `${figures.arrowLeft}${figures.arrowRight}`,
+                        label: "Page",
+                        condition: hasMore || hasPrev,
+                    },
+                    { key: "Enter", label: "Details" },
+                    { key: "c", label: "Create" },
+                    { key: "a", label: "Actions" },
+                    { key: "/", label: "Search" },
+                    { key: "Esc", label: "Back" },
+                ] })] }));
+};
+// Export the UI component for use in the main menu
+export { ListSecretsUI };
 export async function listSecrets(options = {}) {
     try {
         const client = getClient();

package/dist/commands/snapshot/list.js

@@ -436,8 +436,17 @@ export async function listSnapshots(options) {
         }
         // Fetch snapshots
         const page = (await client.devboxes.listDiskSnapshots(queryParams));
-        // Extract snapshots array
-        const snapshots = page.snapshots || [];
+        // Extract snapshots array and strip to plain objects to avoid
+        // camelCase aliases added by the API client library
+        const snapshots = (page.snapshots || []).map((s) => ({
+            id: s.id,
+            name: s.name ?? undefined,
+            create_time_ms: s.create_time_ms,
+            metadata: s.metadata,
+            source_devbox_id: s.source_devbox_id,
+            source_blueprint_id: s.source_blueprint_id ?? undefined,
+            commit_message: s.commit_message ?? undefined,
+        }));
         output(snapshots, { format: options.output, defaultFormat: "json" });
     }
     catch (error) {

package/dist/commands/snapshot/prune.js

@@ -0,0 +1,265 @@
+/**
+ * Snapshot prune command - Delete old snapshots for a given source devbox
+ */
+import * as readline from "readline";
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+import { formatRelativeTime } from "../../utils/time.js";
+/**
+ * Query the async status for a snapshot and return a normalized status string.
+ * Maps API statuses: "complete" → "ready", others passed through.
+ */
+async function querySnapshotStatus(snapshotId) {
+    const client = getClient();
+    try {
+        const statusResponse = await client.devboxes.diskSnapshots.queryStatus(snapshotId);
+        const operationStatus = statusResponse.status;
+        return operationStatus === "complete" ? "ready" : operationStatus;
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Fetch all snapshots for a given source devbox (handles pagination)
+ * and enrich each snapshot with its async operation status.
+ */
+async function fetchAllSnapshotsForDevbox(devboxId) {
+    const client = getClient();
+    const allSnapshots = [];
+    let hasMore = true;
+    let startingAfter = undefined;
+    while (hasMore) {
+        const params = {
+            devbox_id: devboxId,
+            limit: 100,
+        };
+        if (startingAfter) {
+            params.starting_after = startingAfter;
+        }
+        try {
+            const page = await client.devboxes.listDiskSnapshots(params);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const snapshots = (page.snapshots || []);
+            allSnapshots.push(...snapshots);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            hasMore = page.has_more || false;
+            if (hasMore && snapshots.length > 0) {
+                startingAfter = snapshots[snapshots.length - 1].id;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+        catch (error) {
+            console.error("Warning: Error fetching snapshots:", error);
+            // Continue with partial results
+            hasMore = false;
+        }
+    }
+    // The listDiskSnapshots endpoint does not include status — query it for each snapshot
+    const enriched = await Promise.all(allSnapshots.map(async (snapshot) => ({
+        ...snapshot,
+        status: await querySnapshotStatus(snapshot.id),
+    })));
+    return enriched;
+}
+/**
+ * Categorize snapshots into successful and failed, and determine what to keep/delete
+ */
+function categorizeSnapshots(snapshots, keepCount) {
+    // Filter successful snapshots (status "ready" means completed successfully)
+    const successful = snapshots.filter((s) => s.status === "ready");
+    // Filter failed/incomplete snapshots
+    const failed = snapshots.filter((s) => s.status !== "ready");
+    // Sort successful by create_time_ms descending (newest first)
+    successful.sort((a, b) => (b.create_time_ms || 0) - (a.create_time_ms || 0));
+    // Determine what to keep and delete
+    const toKeep = successful.slice(0, keepCount);
+    const toDelete = [...successful.slice(keepCount), ...failed];
+    return {
+        toKeep,
+        toDelete,
+        successful,
+        failed,
+    };
+}
+/**
+ * Display a summary of what will be kept and deleted
+ */
+function displaySummary(devboxId, result, isDryRun) {
+    const total = result.successful.length + result.failed.length;
+    console.log(`\nAnalyzing snapshots for devbox "${devboxId}"...`);
+    console.log(`\nFound ${total} snapshot${total !== 1 ? "s" : ""}:`);
+    console.log(`  ✓ ${result.successful.length} ready snapshot${result.successful.length !== 1 ? "s" : ""}`);
+    console.log(`  ✗ ${result.failed.length} failed/incomplete snapshot${result.failed.length !== 1 ? "s" : ""}`);
+    // Show what will be kept
+    console.log(`\nKeeping (${result.toKeep.length} most recent ready):`);
+    if (result.toKeep.length === 0) {
+        console.log("  (none - no ready snapshots found)");
+    }
+    else {
+        for (const snapshot of result.toKeep) {
+            const label = snapshot.name ? ` "${snapshot.name}"` : "";
+            console.log(`  ✓ ${snapshot.id}${label} - Created ${formatRelativeTime(snapshot.create_time_ms)}`);
+        }
+    }
+    // Show what will be deleted
+    console.log(`\n${isDryRun ? "Would delete" : "To be deleted"} (${result.toDelete.length} snapshot${result.toDelete.length !== 1 ? "s" : ""}):`);
+    if (result.toDelete.length === 0) {
+        console.log("  (none)");
+    }
+    else {
+        for (const snapshot of result.toDelete) {
+            const icon = snapshot.status === "ready" ? "✓" : "⚠";
+            const statusLabel = snapshot.status === "ready" ? "ready" : snapshot.status || "unknown";
+            const label = snapshot.name ? ` "${snapshot.name}"` : "";
+            console.log(`  ${icon} ${snapshot.id}${label} - Created ${formatRelativeTime(snapshot.create_time_ms)} (${statusLabel})`);
+        }
+    }
+}
+/**
+ * Display all deleted snapshots
+ */
+function displayDeletedSnapshots(deleted) {
+    if (deleted.length === 0) {
+        return;
+    }
+    console.log("\nDeleted snapshots:");
+    for (const snapshot of deleted) {
+        const icon = snapshot.status === "ready" ? "✓" : "⚠";
+        const statusLabel = snapshot.status === "ready" ? "ready" : snapshot.status || "unknown";
+        const label = snapshot.name ? ` "${snapshot.name}"` : "";
+        console.log(`  ${icon} ${snapshot.id}${label} - Created ${formatRelativeTime(snapshot.create_time_ms)} (${statusLabel})`);
+    }
+}
+/**
+ * Prompt user for confirmation
+ */
+async function confirmDeletion(count) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`\nDelete ${count} snapshot${count !== 1 ? "s" : ""}? (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+/**
+ * Delete snapshots with error tracking
+ */
+async function deleteSnapshotsWithTracking(snapshots) {
+    const client = getClient();
+    const results = {
+        deleted: [],
+        failed: [],
+    };
+    for (const snapshot of snapshots) {
+        try {
+            await client.devboxes.diskSnapshots.delete(snapshot.id);
+            results.deleted.push(snapshot);
+        }
+        catch (error) {
+            results.failed.push({
+                id: snapshot.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Main prune function
+ */
+export async function pruneSnapshots(devboxId, options = {}) {
+    try {
+        // Parse and validate options
+        const isDryRun = !!options.dryRun;
+        const autoConfirm = !!options.yes;
+        const keepCount = parseInt(options.keep || "1", 10);
+        if (isNaN(keepCount) || keepCount < 0) {
+            outputError("--keep must be a non-negative integer");
+        }
+        // Fetch all snapshots for the given devbox
+        console.log(`Fetching snapshots for devbox "${devboxId}"...`);
+        const snapshots = await fetchAllSnapshotsForDevbox(devboxId);
+        // Handle no snapshots found
+        if (snapshots.length === 0) {
+            console.log(`No snapshots found for devbox: ${devboxId}`);
+            return;
+        }
+        // Categorize snapshots
+        const categorized = categorizeSnapshots(snapshots, keepCount);
+        // Display summary
+        displaySummary(devboxId, categorized, isDryRun);
+        // Handle dry-run mode
+        if (isDryRun) {
+            console.log("\n(Dry run - no changes made)");
+            const result = {
+                sourceDevboxId: devboxId,
+                totalFound: snapshots.length,
+                successfulSnapshots: categorized.successful.length,
+                failedSnapshots: categorized.failed.length,
+                kept: categorized.toKeep,
+                deleted: [],
+                failed: [],
+                dryRun: true,
+            };
+            if (options.output && options.output !== "text") {
+                output(result, { format: options.output, defaultFormat: "json" });
+            }
+            return;
+        }
+        // Handle nothing to delete
+        if (categorized.toDelete.length === 0) {
+            console.log("\nNothing to delete.");
+            return;
+        }
+        // Warn if no successful snapshots
+        if (categorized.successful.length === 0) {
+            console.log("\nWarning: No ready snapshots found. Only deleting failed/incomplete snapshots.");
+        }
+        // Get confirmation unless --yes flag is set
+        if (!autoConfirm) {
+            const confirmed = await confirmDeletion(categorized.toDelete.length);
+            if (!confirmed) {
+                console.log("\nOperation cancelled.");
+                return;
+            }
+        }
+        // Perform deletions
+        console.log(`\nDeleting ${categorized.toDelete.length} snapshot${categorized.toDelete.length !== 1 ? "s" : ""}...`);
+        const deletionResults = await deleteSnapshotsWithTracking(categorized.toDelete);
+        // Display results
+        console.log("\nResults:");
+        console.log(`  ✓ Successfully deleted: ${deletionResults.deleted.length} snapshot${deletionResults.deleted.length !== 1 ? "s" : ""}`);
+        // Show all deleted snapshots
+        displayDeletedSnapshots(deletionResults.deleted);
+        if (deletionResults.failed.length > 0) {
+            console.log(`\n  ✗ Failed to delete: ${deletionResults.failed.length} snapshot${deletionResults.failed.length !== 1 ? "s" : ""}`);
+            for (const failure of deletionResults.failed) {
+                console.log(`    - ${failure.id}: ${failure.error}`);
+            }
+        }
+        // Output structured data if requested
+        if (options.output && options.output !== "text") {
+            const result = {
+                sourceDevboxId: devboxId,
+                totalFound: snapshots.length,
+                successfulSnapshots: categorized.successful.length,
+                failedSnapshots: categorized.failed.length,
+                kept: categorized.toKeep,
+                deleted: deletionResults.deleted,
+                failed: deletionResults.failed,
+                dryRun: false,
+            };
+            output(result, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to prune snapshots", error);
+    }
+}