genbox 1.0.101 → 1.0.103

package/dist/api.js

@@ -16,6 +16,9 @@ exports.failSnapshotUpload = failSnapshotUpload;
 exports.listProjectSnapshots = listProjectSnapshots;
 exports.getLatestSnapshot = getLatestSnapshot;
 exports.getSnapshotDownloadUrl = getSnapshotDownloadUrl;
+exports.getBackup = getBackup;
+exports.getLatestBackup = getLatestBackup;
+exports.getBackupDownloadUrl = getBackupDownloadUrl;
 const chalk_1 = __importDefault(require("chalk"));
 const config_store_1 = require("./config-store");
 const API_URL = process.env.GENBOX_API_URL || 'https://api.genbox.dev';
@@ -165,3 +168,24 @@ async function getLatestSnapshot(projectId, source) {
 async function getSnapshotDownloadUrl(snapshotId) {
     return fetchApi(`/database-snapshots/${snapshotId}/download`);
 }
+/**
+ * Get a backup by ID
+ */
+async function getBackup(backupId) {
+    return fetchApi(`/genboxes/backups/${backupId}`);
+}
+/**
+ * Get latest backup for a genbox name
+ */
+async function getLatestBackup(genboxName, workspace) {
+    const result = await fetchApi(`/genboxes/backups/latest/${encodeURIComponent(genboxName)}?workspace=${encodeURIComponent(workspace)}`);
+    if (result?.error)
+        return null;
+    return result;
+}
+/**
+ * Get download URL for a backup
+ */
+async function getBackupDownloadUrl(backupId) {
+    return fetchApi(`/genboxes/backups/${backupId}/download`);
+}

package/dist/commands/backup.js

@@ -0,0 +1,410 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backupCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const confirm_1 = __importDefault(require("@inquirer/confirm"));
+const api_1 = require("../api");
+const genbox_selector_1 = require("../genbox-selector");
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function getPrivateSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_rsa'),
+        path.join(home, '.ssh', 'id_ed25519'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return keyPath;
+        }
+    }
+    throw new Error('No SSH private key found in ~/.ssh/');
+}
+function sshExec(ip, keyPath, command, timeoutSecs = 300) {
+    const sshOpts = `-i ${keyPath} -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=10`;
+    try {
+        const result = (0, child_process_1.execSync)(`ssh ${sshOpts} dev@${ip} "${command}"`, {
+            encoding: 'utf8',
+            timeout: (timeoutSecs + 5) * 1000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large outputs
+        });
+        return result.trim();
+    }
+    catch (error) {
+        if (error.stderr)
+            return `ERROR: ${error.stderr.toString().trim()}`;
+        if (error.stdout)
+            return error.stdout.toString().trim();
+        return `ERROR: ${error.message}`;
+    }
+}
+// Generate the backup script that runs on the genbox
+function generateBackupScript(uploadUrl, callbackUrl, dbContainer, dbName) {
+    return `
+#!/bin/bash
+set -e
+BACKUP_DIR="/tmp/genbox-backup-\$(date +%Y%m%d%H%M%S)"
+ARCHIVE="\$BACKUP_DIR/backup.tar.gz"
+UPLOAD_URL="${uploadUrl}"
+CALLBACK_URL="${callbackUrl}"
+DB_CONTAINER="${dbContainer || ''}"
+DB_NAME="${dbName || ''}"
+
+mkdir -p "\$BACKUP_DIR/data"
+cd /home/dev
+
+echo '{"status":"starting"}' > "\$BACKUP_DIR/manifest.json"
+START_TIME=\$(date +%s)
+
+# === 1. Git repos - save uncommitted changes as patches ===
+echo "=== Backing up git repos ==="
+REPOS_JSON="[]"
+for d in \$(find . -maxdepth 4 -name .git -type d 2>/dev/null); do
+  repo=\$(dirname "\$d")
+  repo_name=\$(basename "\$repo")
+  cd "\$repo"
+
+  branch=\$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+  remote_url=\$(git remote get-url origin 2>/dev/null || echo "")
+
+  has_changes="false"
+  patch_file=""
+  stash_included="false"
+
+  # Check for uncommitted changes
+  if [ -n "\$(git status --porcelain 2>/dev/null)" ]; then
+    has_changes="true"
+    # Create patch of all changes (staged + unstaged + untracked)
+    mkdir -p "\$BACKUP_DIR/data/repos/\$repo_name"
+
+    # Save diff of tracked files
+    git diff HEAD > "\$BACKUP_DIR/data/repos/\$repo_name/changes.patch" 2>/dev/null || true
+
+    # Save list of untracked files
+    git ls-files --others --exclude-standard > "\$BACKUP_DIR/data/repos/\$repo_name/untracked.txt" 2>/dev/null || true
+
+    # Archive untracked files
+    if [ -s "\$BACKUP_DIR/data/repos/\$repo_name/untracked.txt" ]; then
+      tar -czf "\$BACKUP_DIR/data/repos/\$repo_name/untracked.tar.gz" -T "\$BACKUP_DIR/data/repos/\$repo_name/untracked.txt" 2>/dev/null || true
+    fi
+
+    patch_file="repos/\$repo_name"
+    echo "  Saved changes from \$repo_name (branch: \$branch)"
+  fi
+
+  # Add to JSON array
+  REPOS_JSON=\$(echo "\$REPOS_JSON" | jq --arg path "\$repo" --arg url "\$remote_url" --arg branch "\$branch" --argjson changes "\$has_changes" --arg patch "\$patch_file" --argjson stash "\$stash_included" '. + [{path: \$path, repoUrl: \$url, branch: \$branch, hadUncommittedChanges: \$changes, patchFile: \$patch, stashIncluded: \$stash}]')
+
+  cd /home/dev
+done
+
+# === 2. Database dump ===
+echo "=== Backing up database ==="
+DB_JSON="null"
+if [ -n "\$DB_CONTAINER" ] && [ -n "\$DB_NAME" ] && docker ps --format '{{.Names}}' | grep -q "\$DB_CONTAINER"; then
+  mkdir -p "\$BACKUP_DIR/data/database"
+  echo "  Dumping \$DB_NAME from \$DB_CONTAINER..."
+
+  # Use mongodump with gzip
+  docker exec "\$DB_CONTAINER" mongodump --db="\$DB_NAME" --gzip --archive > "\$BACKUP_DIR/data/database/dump.gz" 2>/dev/null
+
+  if [ -f "\$BACKUP_DIR/data/database/dump.gz" ]; then
+    DUMP_SIZE=\$(stat -c%s "\$BACKUP_DIR/data/database/dump.gz" 2>/dev/null || stat -f%z "\$BACKUP_DIR/data/database/dump.gz" 2>/dev/null || echo "0")
+    DB_JSON=\$(jq -n --arg name "\$DB_NAME" --arg container "\$DB_CONTAINER" --arg file "database/dump.gz" --argjson size "\$DUMP_SIZE" '{name: \$name, container: \$container, dumpFile: \$file, compressedSizeBytes: \$size}')
+    echo "  Database dump created: \$DUMP_SIZE bytes"
+  fi
+fi
+
+# === 3. Config files ===
+echo "=== Backing up config files ==="
+mkdir -p "\$BACKUP_DIR/data/configs"
+CONFIG_FILES="[]"
+for f in \$(find /home/dev -maxdepth 4 -name '.env*' -type f 2>/dev/null | grep -v node_modules | grep -v .git); do
+  rel_path=\${f#/home/dev/}
+  mkdir -p "\$BACKUP_DIR/data/configs/\$(dirname "\$rel_path")"
+  cp "\$f" "\$BACKUP_DIR/data/configs/\$rel_path"
+  CONFIG_FILES=\$(echo "\$CONFIG_FILES" | jq --arg f "\$rel_path" '. + [\$f]')
+  echo "  Saved \$rel_path"
+done
+
+# === 4. Claude history ===
+echo "=== Backing up Claude history ==="
+CLAUDE_INCLUDED="false"
+CLAUDE_SIZE="0"
+if [ -d "/home/dev/.claude" ]; then
+  mkdir -p "\$BACKUP_DIR/data"
+  tar -czf "\$BACKUP_DIR/data/claude-history.tar.gz" -C /home/dev .claude 2>/dev/null && {
+    CLAUDE_INCLUDED="true"
+    CLAUDE_SIZE=\$(stat -c%s "\$BACKUP_DIR/data/claude-history.tar.gz" 2>/dev/null || stat -f%z "\$BACKUP_DIR/data/claude-history.tar.gz" 2>/dev/null || echo "0")
+    echo "  Claude history saved: \$CLAUDE_SIZE bytes"
+  }
+fi
+
+# === 5. Create final archive ===
+echo "=== Creating backup archive ==="
+cd "\$BACKUP_DIR/data"
+tar -czf "\$ARCHIVE" . 2>/dev/null
+ARCHIVE_SIZE=\$(stat -c%s "\$ARCHIVE" 2>/dev/null || stat -f%z "\$ARCHIVE" 2>/dev/null || echo "0")
+echo "Archive size: \$ARCHIVE_SIZE bytes"
+
+# === 6. Upload to S3 ===
+echo "=== Uploading to S3 ==="
+UPLOAD_RESULT=\$(curl -s -w "%{http_code}" -o /dev/null -X PUT -H "Content-Type: application/gzip" --data-binary "@\$ARCHIVE" "\$UPLOAD_URL")
+if [ "\$UPLOAD_RESULT" != "200" ]; then
+  echo "Upload failed with status: \$UPLOAD_RESULT"
+  # Cleanup
+  rm -rf "\$BACKUP_DIR"
+  exit 1
+fi
+echo "Upload successful!"
+
+# === 7. Calculate duration ===
+END_TIME=\$(date +%s)
+DURATION=\$((END_TIME - START_TIME))
+
+# === 8. Send callback ===
+echo "=== Sending callback ==="
+CALLBACK_DATA=\$(jq -n \\
+  --argjson success true \\
+  --argjson size "\$ARCHIVE_SIZE" \\
+  --argjson repos "\$REPOS_JSON" \\
+  --argjson database "\$DB_JSON" \\
+  --argjson claudeIncluded "\$CLAUDE_INCLUDED" \\
+  --argjson claudeSize "\$CLAUDE_SIZE" \\
+  --argjson configs "\$CONFIG_FILES" \\
+  --argjson duration "\$DURATION" \\
+  '{success: \$success, sizeBytes: \$size, repos: \$repos, database: \$database, claudeHistoryIncluded: \$claudeIncluded, claudeHistorySizeBytes: \$claudeSize, configFiles: \$configs, durationSeconds: \$duration}')
+
+curl -s -X POST -H "Content-Type: application/json" -d "\$CALLBACK_DATA" "\$CALLBACK_URL"
+
+# === Cleanup ===
+rm -rf "\$BACKUP_DIR"
+echo ""
+echo "=== Backup complete! ==="
+echo "\$CALLBACK_DATA"
+`;
+}
+exports.backupCommand = new commander_1.Command('backup')
+    .description('Create a backup of genbox (git changes, database, configs)')
+    .argument('[name]', 'Name of the Genbox (optional - will prompt)')
+    .option('-d, --destroy', 'Destroy genbox after successful backup')
+    .option('--no-database', 'Skip database backup')
+    .option('--no-claude', 'Skip Claude history backup')
+    .action(async (name, options) => {
+    try {
+        // Select genbox
+        const { genbox: target, cancelled } = await (0, genbox_selector_1.selectGenbox)(name, {
+            selectMessage: 'Select a genbox to backup:',
+        });
+        if (cancelled) {
+            console.log(chalk_1.default.dim('Cancelled.'));
+            return;
+        }
+        if (!target) {
+            return;
+        }
+        if (target.status !== 'running') {
+            console.error(chalk_1.default.red(`Error: Genbox '${target.name}' is not running (status: ${target.status})`));
+            return;
+        }
+        if (!target.ipAddress) {
+            console.error(chalk_1.default.red(`Error: Genbox '${target.name}' has no IP address`));
+            return;
+        }
+        // Get SSH key
+        let keyPath;
+        try {
+            keyPath = getPrivateSshKey();
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(error.message));
+            return;
+        }
+        // Confirm backup
+        console.log('');
+        console.log(chalk_1.default.blue(`Creating backup of ${target.name}...`));
+        console.log(chalk_1.default.dim(`  IP: ${target.ipAddress}`));
+        console.log(chalk_1.default.dim(`  Size: ${target.size}`));
+        if (target.database) {
+            console.log(chalk_1.default.dim(`  Database: ${target.database.mode || 'none'}`));
+        }
+        console.log('');
+        if (options.destroy) {
+            const confirmed = await (0, confirm_1.default)({
+                message: chalk_1.default.yellow('This will destroy the genbox after backup. Continue?'),
+                default: false,
+            });
+            if (!confirmed) {
+                console.log(chalk_1.default.dim('Cancelled.'));
+                return;
+            }
+        }
+        // Step 1: Create backup record via API
+        const spinner = (0, ora_1.default)('Creating backup record...').start();
+        let backupResult;
+        try {
+            backupResult = await (0, api_1.fetchApi)(`/genboxes/${target._id}/backup`, {
+                method: 'POST',
+            });
+            spinner.succeed(`Backup record created: ${backupResult.backupName}`);
+        }
+        catch (error) {
+            spinner.fail('Failed to create backup record');
+            throw error;
+        }
+        // Step 2: Generate backup script and execute via SSH
+        spinner.start('Running backup on genbox...');
+        // Determine database container and name
+        let dbContainer;
+        let dbName;
+        if (options.database !== false && target.database) {
+            const dbConfig = target.database;
+            if (dbConfig.mode === 'local' || dbConfig.mode === 'copy') {
+                // Try to find MongoDB container
+                const containers = sshExec(target.ipAddress, keyPath, "docker ps --format '{{.Names}}' | grep -i mongo | head -1", 10);
+                if (containers && !containers.startsWith('ERROR:')) {
+                    dbContainer = containers.trim();
+                    // Get database name from .env or use default
+                    dbName = dbConfig.name || 'goodpass';
+                }
+            }
+        }
+        // Build callback URL
+        const callbackUrl = `${process.env.GENBOX_API_URL || 'https://api.genbox.dev'}/genboxes/backups/${backupResult.backupId}/callback?token=${target.heartbeatToken}`;
+        // Generate and execute backup script
+        const backupScript = generateBackupScript(backupResult.uploadUrl, callbackUrl, dbContainer, dbName);
+        // Write script to genbox and execute
+        const escapedScript = backupScript.replace(/'/g, "'\\''");
+        const runCommand = `echo '${escapedScript}' > /tmp/backup-runner.sh && chmod +x /tmp/backup-runner.sh && /tmp/backup-runner.sh`;
+        spinner.text = 'Running backup script (this may take a few minutes)...';
+        const result = sshExec(target.ipAddress, keyPath, runCommand, 600); // 10 minute timeout
+        if (result.startsWith('ERROR:') || result.includes('Upload failed')) {
+            spinner.fail('Backup failed');
+            console.error(chalk_1.default.red(result));
+            // Report failure to API
+            try {
+                await (0, api_1.fetchApi)(`/genboxes/backups/${backupResult.backupId}/callback?token=${target.heartbeatToken}`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        success: false,
+                        error: result.substring(0, 500),
+                    }),
+                });
+            }
+            catch (e) {
+                // Ignore callback errors
+            }
+            return;
+        }
+        spinner.succeed('Backup completed successfully!');
+        // Parse the result to show summary
+        console.log('');
+        console.log(chalk_1.default.green('Backup Summary:'));
+        // Try to extract JSON from output
+        const jsonMatch = result.match(/\{[\s\S]*\}$/);
+        if (jsonMatch) {
+            try {
+                const summary = JSON.parse(jsonMatch[0]);
+                console.log(chalk_1.default.dim(`  Size: ${formatBytes(summary.sizeBytes || 0)}`));
+                console.log(chalk_1.default.dim(`  Duration: ${summary.durationSeconds}s`));
+                if (summary.repos && summary.repos.length > 0) {
+                    const reposWithChanges = summary.repos.filter(r => r.hadUncommittedChanges);
+                    console.log(chalk_1.default.dim(`  Repos: ${summary.repos.length} (${reposWithChanges.length} with changes)`));
+                }
+                if (summary.database) {
+                    console.log(chalk_1.default.dim(`  Database: ${summary.database.name} (${formatBytes(summary.database.compressedSizeBytes || 0)})`));
+                }
+                if (summary.claudeHistoryIncluded) {
+                    console.log(chalk_1.default.dim(`  Claude history: ${formatBytes(summary.claudeHistorySizeBytes || 0)}`));
+                }
+                if (summary.configFiles && summary.configFiles.length > 0) {
+                    console.log(chalk_1.default.dim(`  Config files: ${summary.configFiles.length}`));
+                }
+            }
+            catch (e) {
+                // Couldn't parse JSON, just show raw output
+                console.log(chalk_1.default.dim(result.split('\n').slice(-5).join('\n')));
+            }
+        }
+        console.log('');
+        console.log(chalk_1.default.cyan(`Backup ID: ${backupResult.backupId}`));
+        console.log(chalk_1.default.dim(`Restore with: gb create ${target.name} --restore ${backupResult.backupId}`));
+        console.log(chalk_1.default.dim(`Or restore latest: gb create ${target.name} --restore latest`));
+        // Step 3: Optionally destroy genbox
+        if (options.destroy) {
+            console.log('');
+            spinner.start('Destroying genbox...');
+            try {
+                await (0, api_1.fetchApi)(`/genboxes/${target._id}`, { method: 'DELETE' });
+                spinner.succeed(`Genbox ${target.name} destroyed`);
+                console.log(chalk_1.default.dim('Billing has stopped.'));
+            }
+            catch (error) {
+                spinner.fail('Failed to destroy genbox');
+                console.error(chalk_1.default.yellow('Backup was successful, but destroy failed. You can manually destroy with:'));
+                console.log(chalk_1.default.dim(`  gb destroy ${target.name}`));
+            }
+        }
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+            console.log('');
+            console.log(chalk_1.default.dim('Cancelled.'));
+            return;
+        }
+        if (error instanceof api_1.AuthenticationError) {
+            (0, api_1.handleApiError)(error);
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}

package/dist/commands/backups.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backupsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function formatDate(dateStr) {
+    const date = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins}m ago`;
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    if (diffDays < 7)
+        return `${diffDays}d ago`;
+    return date.toLocaleDateString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        year: date.getFullYear() !== now.getFullYear() ? 'numeric' : undefined,
+    });
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'completed': return chalk_1.default.green;
+        case 'pending':
+        case 'uploading': return chalk_1.default.yellow;
+        case 'failed': return chalk_1.default.red;
+        default: return chalk_1.default.white;
+    }
+}
+exports.backupsCommand = new commander_1.Command('backups')
+    .description('List and manage genbox backups')
+    .option('-n, --name <genboxName>', 'Filter by genbox name')
+    .option('-l, --limit <number>', 'Number of backups to show', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        // Build query params
+        const params = new URLSearchParams();
+        if (options.name)
+            params.set('genboxName', options.name);
+        if (options.limit)
+            params.set('limit', options.limit);
+        const result = await (0, api_1.fetchApi)(`/genboxes/backups?${params.toString()}`);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.backups.length === 0) {
+            console.log(chalk_1.default.dim('No backups found.'));
+            console.log('');
+            console.log(chalk_1.default.dim('Create a backup with: gb backup <genbox-name>'));
+            return;
+        }
+        console.log(chalk_1.default.blue(`Found ${result.total} backup${result.total !== 1 ? 's' : ''}:`));
+        console.log('');
+        // Simple list - one backup per genbox
+        for (const backup of result.backups) {
+            const statusColor = getStatusColor(backup.status);
+            const statusIcon = backup.status === 'completed' ? '✓' : backup.status === 'failed' ? '✗' : '○';
+            const statusBadge = statusColor(statusIcon);
+            // Size info
+            const sizeStr = backup.sizeBytes ? formatBytes(backup.sizeBytes) : '-';
+            // Date
+            const dateStr = formatDate(backup.createdAt);
+            // Contents summary
+            const contents = [];
+            if (backup.repos && backup.repos.some(r => r.hadUncommittedChanges)) {
+                contents.push('changes');
+            }
+            if (backup.database) {
+                contents.push('db');
+            }
+            if (backup.claudeHistoryIncluded) {
+                contents.push('claude');
+            }
+            const contentsStr = contents.length > 0 ? chalk_1.default.dim(`[${contents.join(', ')}]`) : '';
+            console.log(`  ${statusBadge} ${chalk_1.default.cyan(backup.sourceGenboxName)}  ${sizeStr}  ${dateStr}  ${contentsStr}`);
+        }
+        // Show restore hint
+        console.log('');
+        console.log(chalk_1.default.dim('─'.repeat(50)));
+        console.log(chalk_1.default.dim('Restore with: gb create <name> --restore'));
+    }
+    catch (error) {
+        if (error instanceof api_1.AuthenticationError) {
+            (0, api_1.handleApiError)(error);
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+// Subcommand to delete a backup by genbox name
+exports.backupsCommand
+    .command('delete <genboxName>')
+    .description('Delete backup for a genbox')
+    .action(async (genboxName) => {
+    try {
+        // Find backup by genbox name first
+        const result = await (0, api_1.fetchApi)(`/genboxes/backups?genboxName=${encodeURIComponent(genboxName)}&limit=1`);
+        if (result.backups.length === 0) {
+            console.log(chalk_1.default.yellow(`No backup found for '${genboxName}'`));
+            return;
+        }
+        const backup = result.backups[0];
+        await (0, api_1.fetchApi)(`/genboxes/backups/${backup._id}`, { method: 'DELETE' });
+        console.log(chalk_1.default.green(`Backup for '${genboxName}' deleted.`));
+    }
+    catch (error) {
+        if (error instanceof api_1.AuthenticationError) {
+            (0, api_1.handleApiError)(error);
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+// Subcommand to show backup details by genbox name
+exports.backupsCommand
+    .command('info <genboxName>')
+    .description('Show detailed info about a genbox backup')
+    .action(async (genboxName) => {
+    try {
+        // Find backup by genbox name
+        const result = await (0, api_1.fetchApi)(`/genboxes/backups?genboxName=${encodeURIComponent(genboxName)}&limit=1`);
+        if (result.backups.length === 0) {
+            console.log(chalk_1.default.yellow(`No backup found for '${genboxName}'`));
+            return;
+        }
+        const backup = result.backups[0];
+        console.log(chalk_1.default.blue(`Backup for: ${backup.sourceGenboxName}`));
+        console.log('');
+        console.log(`Status:   ${getStatusColor(backup.status)(backup.status)}`);
+        console.log(`Created:  ${new Date(backup.createdAt).toLocaleString()}`);
+        if (backup.durationSeconds) {
+            console.log(`Duration: ${backup.durationSeconds}s`);
+        }
+        console.log(`Size:     ${backup.sizeBytes ? formatBytes(backup.sizeBytes) : '-'}`);
+        console.log('');
+        console.log(chalk_1.default.cyan('Source Configuration:'));
+        console.log(`  Server:  ${backup.sourceSize}`);
+        if (backup.sourceProfile) {
+            console.log(`  Profile: ${backup.sourceProfile}`);
+        }
+        if (backup.sourceApps && backup.sourceApps.length > 0) {
+            console.log(`  Apps:    ${backup.sourceApps.join(', ')}`);
+        }
+        console.log('');
+        if (backup.repos && backup.repos.length > 0) {
+            console.log(chalk_1.default.cyan('Repos:'));
+            for (const repo of backup.repos) {
+                const changes = repo.hadUncommittedChanges ? chalk_1.default.yellow(' (has changes)') : '';
+                console.log(`  ${repo.path}${changes}`);
+            }
+            console.log('');
+        }
+        if (backup.database) {
+            console.log(chalk_1.default.cyan('Database:'));
+            console.log(`  Name: ${backup.database.name}`);
+            console.log('');
+        }
+        if (backup.claudeHistoryIncluded) {
+            console.log(chalk_1.default.cyan('Claude history: ') + chalk_1.default.green('included'));
+            console.log('');
+        }
+        console.log(chalk_1.default.cyan('Usage:'));
+        console.log(`  Restore: gb create ${backup.sourceGenboxName} --restore`);
+        console.log(`  Delete:  gb backups delete ${backup.sourceGenboxName}`);
+    }
+    catch (error) {
+        if (error instanceof api_1.AuthenticationError) {
+            (0, api_1.handleApiError)(error);
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});