@runloop/rl-cli 1.1.0 → 1.2.0

package/README.md

@@ -106,6 +106,7 @@ rli blueprint list                       # List all blueprints
 rli blueprint create                     # Create a new blueprint
 rli blueprint get <name-or-id>           # Get blueprint details by name or ID (...
 rli blueprint logs <name-or-id>          # Get blueprint build logs by name or I...
+rli blueprint prune <name>               # Delete old blueprint builds, keeping ...
 ```
 
 ### Object Commands (alias: `obj`)

package/dist/commands/blueprint/prune.js

@@ -0,0 +1,270 @@
+/**
+ * Blueprint prune command - Delete old blueprint builds
+ */
+import * as readline from "readline";
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+/**
+ * Fetch all blueprints with a given name (handles pagination)
+ */
+async function fetchAllBlueprintsWithName(name) {
+    const client = getClient();
+    const allBlueprints = [];
+    let hasMore = true;
+    let startingAfter = undefined;
+    while (hasMore) {
+        const params = { name, limit: 100 };
+        if (startingAfter) {
+            params.starting_after = startingAfter;
+        }
+        try {
+            const page = await client.blueprints.list(params);
+            const blueprints = (page.blueprints || []);
+            allBlueprints.push(...blueprints);
+            hasMore = page.has_more || false;
+            if (hasMore && blueprints.length > 0) {
+                startingAfter = blueprints[blueprints.length - 1].id;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+        catch (error) {
+            console.error("Warning: Error fetching blueprints:", error);
+            // Continue with partial results
+            hasMore = false;
+        }
+    }
+    return allBlueprints;
+}
+/**
+ * Categorize blueprints into successful and failed, and determine what to keep/delete
+ */
+function categorizeBlueprints(blueprints, keepCount) {
+    // Filter successful builds
+    const successful = blueprints.filter((b) => b.status === "build_complete" || b.status === "building_complete");
+    // Filter failed builds
+    const failed = blueprints.filter((b) => b.status !== "build_complete" && b.status !== "building_complete");
+    // 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,
+    };
+}
+/**
+ * Format a timestamp for display
+ */
+function formatTimestamp(createTimeMs) {
+    if (!createTimeMs) {
+        return "unknown time";
+    }
+    const now = Date.now();
+    const diffMs = now - createTimeMs;
+    const diffMinutes = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+    if (diffMinutes < 60) {
+        return `${diffMinutes} minute${diffMinutes !== 1 ? "s" : ""} ago`;
+    }
+    else if (diffHours < 24) {
+        return `${diffHours} hour${diffHours !== 1 ? "s" : ""} ago`;
+    }
+    else {
+        return `${diffDays} day${diffDays !== 1 ? "s" : ""} ago`;
+    }
+}
+/**
+ * Display a summary of what will be kept and deleted
+ */
+function displaySummary(name, result, isDryRun) {
+    const total = result.successful.length + result.failed.length;
+    console.log(`\nAnalyzing blueprints named "${name}"...`);
+    console.log(`\nFound ${total} blueprint${total !== 1 ? "s" : ""}:`);
+    console.log(`  ✓ ${result.successful.length} successful build${result.successful.length !== 1 ? "s" : ""}`);
+    console.log(`  ✗ ${result.failed.length} failed build${result.failed.length !== 1 ? "s" : ""}`);
+    // Show what will be kept
+    console.log(`\nKeeping (${result.toKeep.length} most recent successful):`);
+    if (result.toKeep.length === 0) {
+        console.log("  (none - no successful builds found)");
+    }
+    else {
+        for (const blueprint of result.toKeep) {
+            console.log(`  ✓ ${blueprint.id} - Created ${formatTimestamp(blueprint.create_time_ms)}`);
+        }
+    }
+    // Show what will be deleted
+    console.log(`\n${isDryRun ? "Would delete" : "To be deleted"} (${result.toDelete.length} blueprint${result.toDelete.length !== 1 ? "s" : ""}):`);
+    if (result.toDelete.length === 0) {
+        console.log("  (none)");
+    }
+    else {
+        // Show all blueprints without summarizing
+        for (const blueprint of result.toDelete) {
+            const icon = blueprint.status === "build_complete" ||
+                blueprint.status === "building_complete"
+                ? "✓"
+                : "✗";
+            const statusLabel = blueprint.status === "build_complete" ||
+                blueprint.status === "building_complete"
+                ? "successful"
+                : "failed";
+            console.log(`  ${icon} ${blueprint.id} - Created ${formatTimestamp(blueprint.create_time_ms)} (${statusLabel})`);
+        }
+    }
+}
+/**
+ * Display all deleted blueprints
+ */
+function displayDeletedBlueprints(deleted) {
+    if (deleted.length === 0) {
+        return;
+    }
+    console.log("\nDeleted blueprints:");
+    for (const blueprint of deleted) {
+        const icon = blueprint.status === "build_complete" ||
+            blueprint.status === "building_complete"
+            ? "✓"
+            : "✗";
+        const statusLabel = blueprint.status === "build_complete" ||
+            blueprint.status === "building_complete"
+            ? "successful"
+            : "failed";
+        console.log(`  ${icon} ${blueprint.id} - Created ${formatTimestamp(blueprint.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} blueprint${count !== 1 ? "s" : ""}? (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+/**
+ * Delete blueprints with error tracking
+ */
+async function deleteBlueprintsWithTracking(blueprints) {
+    const client = getClient();
+    const results = {
+        deleted: [],
+        failed: [],
+    };
+    for (const blueprint of blueprints) {
+        try {
+            await client.blueprints.delete(blueprint.id);
+            results.deleted.push(blueprint);
+        }
+        catch (error) {
+            results.failed.push({
+                id: blueprint.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Main prune function
+ */
+export async function pruneBlueprints(name, options = {}) {
+    try {
+        // Parse and validate options
+        const isDryRun = options.dryRun || false;
+        const autoConfirm = options.yes || false;
+        const keepCount = parseInt(options.keep || "1", 10);
+        if (isNaN(keepCount) || keepCount < 1) {
+            outputError("--keep must be a positive integer");
+        }
+        // Fetch all blueprints with the given name
+        console.log(`Fetching blueprints named "${name}"...`);
+        const blueprints = await fetchAllBlueprintsWithName(name);
+        // Handle no blueprints found
+        if (blueprints.length === 0) {
+            console.log(`No blueprints found with name: ${name}`);
+            return;
+        }
+        // Categorize blueprints
+        const categorized = categorizeBlueprints(blueprints, keepCount);
+        // Display summary
+        displaySummary(name, categorized, isDryRun);
+        // Handle dry-run mode
+        if (isDryRun) {
+            console.log("\n(Dry run - no changes made)");
+            const result = {
+                blueprintName: name,
+                totalFound: blueprints.length,
+                successfulBuilds: categorized.successful.length,
+                failedBuilds: 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 builds
+        if (categorized.successful.length === 0) {
+            console.log("\nWarning: No successful builds found. Only deleting failed builds.");
+        }
+        // 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} blueprint${categorized.toDelete.length !== 1 ? "s" : ""}...`);
+        const deletionResults = await deleteBlueprintsWithTracking(categorized.toDelete);
+        // Display results
+        console.log("\nResults:");
+        console.log(`  ✓ Successfully deleted: ${deletionResults.deleted.length} blueprint${deletionResults.deleted.length !== 1 ? "s" : ""}`);
+        // Show all deleted blueprints
+        displayDeletedBlueprints(deletionResults.deleted);
+        if (deletionResults.failed.length > 0) {
+            console.log(`\n  ✗ Failed to delete: ${deletionResults.failed.length} blueprint${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 = {
+                blueprintName: name,
+                totalFound: blueprints.length,
+                successfulBuilds: categorized.successful.length,
+                failedBuilds: 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 blueprints", error);
+    }
+}

package/dist/utils/commands.js

@@ -300,6 +300,17 @@ export function createProgram() {
         const { getBlueprintLogs } = await import("../commands/blueprint/logs.js");
         await getBlueprintLogs({ id, ...options });
     });
+    blueprint
+        .command("prune <name>")
+        .description("Delete old blueprint builds, keeping only recent successful ones")
+        .option("--dry-run", "Show what would be deleted without actually deleting")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .option("--keep <n>", "Number of successful builds to keep", "1")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (name, options) => {
+        const { pruneBlueprints } = await import("../commands/blueprint/prune.js");
+        await pruneBlueprints(name, options);
+    });
     // Object storage commands
     const object = program
         .command("object")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runloop/rl-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Beautiful CLI for the Runloop platform",
   "type": "module",
   "bin": {