genbox 1.0.101 → 1.0.102

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}`));
+    }
+});

package/dist/commands/create.js

@@ -81,6 +81,151 @@ function spawnSshConfigSetup(genboxId, name) {
     // Allow parent to exit independently
     child.unref();
 }
+/**
+ * Wait for genbox to reach a specific status
+ */
+async function waitForGenboxStatus(genboxId, targetStatus, maxAttempts = 120, // 10 minutes with 5s interval
+intervalMs = 5000) {
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const genbox = await (0, api_1.fetchApi)(`/genboxes/${genboxId}`);
+            if (targetStatus.includes(genbox.status)) {
+                return { success: true, genbox };
+            }
+            if (genbox.status === 'failed' || genbox.status === 'error') {
+                return { success: false, error: `Genbox provisioning failed: ${genbox.statusMessage || 'unknown error'}` };
+            }
+        }
+        catch (error) {
+            // Ignore fetch errors and continue polling
+        }
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return { success: false, error: 'Timeout waiting for genbox to be ready' };
+}
+/**
+ * Run restore script on genbox via SSH
+ */
+async function runRestore(ipAddress, downloadUrl, backup, onProgress) {
+    return new Promise((resolve) => {
+        // Build restore script
+        const restoreScript = `
+set -e
+
+BACKUP_DIR="/tmp/backup-restore"
+DOWNLOAD_URL="${downloadUrl}"
+
+echo "=== Starting Restore ==="
+echo "Backup: ${backup.name}"
+
+# Create temp directory
+rm -rf "$BACKUP_DIR"
+mkdir -p "$BACKUP_DIR"
+cd "$BACKUP_DIR"
+
+# Download backup
+echo "Downloading backup..."
+curl -sS -L -o backup.tar.gz "$DOWNLOAD_URL"
+if [ ! -f backup.tar.gz ]; then
+  echo "ERROR: Failed to download backup"
+  exit 1
+fi
+
+# Extract
+echo "Extracting backup..."
+tar -xzf backup.tar.gz
+rm backup.tar.gz
+
+# Restore git patches (uncommitted changes)
+if [ -d "repos" ]; then
+  echo "Restoring git changes..."
+  for patch in repos/*.patch; do
+    if [ -f "$patch" ]; then
+      # Extract repo path from patch filename (format: repo-path.patch)
+      repo_name=$(basename "$patch" .patch)
+      # Try to find the repo
+      if [ -d "/home/dev/$repo_name" ]; then
+        cd "/home/dev/$repo_name"
+        git apply "$BACKUP_DIR/repos/$repo_name.patch" 2>/dev/null || echo "  Warning: Could not apply patch for $repo_name"
+        cd "$BACKUP_DIR"
+        echo "  Applied patch: $repo_name"
+      fi
+    fi
+  done
+fi
+
+# Restore database
+if [ -f "database.archive.gz" ]; then
+  echo "Restoring database..."
+  DB_NAME="${backup.database?.name || 'genbox_db'}"
+  mongorestore --gzip --archive="database.archive.gz" --nsFrom="\${DB_NAME}.*" --nsTo="\${DB_NAME}.*" --drop 2>/dev/null || {
+    # Try without namespace mapping
+    mongorestore --gzip --archive="database.archive.gz" --drop 2>/dev/null || echo "  Warning: Database restore had issues"
+  }
+  echo "  Database restored"
+fi
+
+# Restore Claude history
+if [ -f "claude-history.tar.gz" ]; then
+  echo "Restoring Claude history..."
+  mkdir -p /home/dev/.claude
+  tar -xzf claude-history.tar.gz -C /home/dev/.claude 2>/dev/null || true
+  echo "  Claude history restored"
+fi
+
+# Restore config files
+if [ -f "configs.tar.gz" ]; then
+  echo "Restoring config files..."
+  tar -xzf configs.tar.gz -C /home/dev 2>/dev/null || true
+  echo "  Config files restored"
+fi
+
+# Cleanup
+rm -rf "$BACKUP_DIR"
+
+echo ""
+echo "=== Restore Complete ==="
+echo "Run 'gb restart' to start services"
+`;
+        const ssh = (0, child_process_1.spawn)('ssh', [
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=30',
+            `dev@${ipAddress}`,
+            restoreScript
+        ]);
+        let stdout = '';
+        let stderr = '';
+        ssh.stdout.on('data', (data) => {
+            const line = data.toString();
+            stdout += line;
+            if (onProgress) {
+                // Extract meaningful progress messages
+                const lines = line.split('\n').filter((l) => l.trim());
+                for (const l of lines) {
+                    if (l.startsWith('===') || l.startsWith('Downloading') || l.startsWith('Extracting') ||
+                        l.startsWith('Restoring') || l.startsWith('  ')) {
+                        onProgress(l.trim());
+                    }
+                }
+            }
+        });
+        ssh.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        ssh.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({ success: false, error: stderr || `SSH exited with code ${code}` });
+            }
+        });
+        ssh.on('error', (error) => {
+            resolve({ success: false, error: error.message });
+        });
+    });
+}
 const DETECTED_DIR = '.genbox';
 const PROJECT_CACHE_FILENAME = 'project.json';
 /**
@@ -197,8 +342,12 @@ exports.createCommand = new commander_1.Command('create')
     .option('-f, --from-branch <branch>', 'Source branch to create new branch from (defaults to config default or main)')
     .option('-y, --yes', 'Skip interactive prompts')
     .option('--dry-run', 'Show what would be created without actually creating')
+    .option('-r, --restore', 'Restore from backup (uses genbox name to find backup)')
     .action(async (nameArg, options) => {
     try {
+        // Handle restore mode
+        let restoreBackup = null;
+        let restoreDownloadUrl = null;
         // Load configuration
         const configLoader = new config_loader_1.ConfigLoader();
         const loadResult = await configLoader.load();
@@ -217,6 +366,66 @@ exports.createCommand = new commander_1.Command('create')
         // Support both v3 and v4 configs
         const config = loadResult.config;
         const profileResolver = new profile_resolver_1.ProfileResolver(configLoader);
+        // Get workspace early for backup resolution
+        const workspace = config.project?.name || 'default';
+        // Handle --restore option: fetch backup info by genbox name
+        if (options.restore) {
+            // Require genbox name for restore
+            if (!nameArg) {
+                console.log(chalk_1.default.red('Name required for restore'));
+                console.log(chalk_1.default.dim('  Usage: gb create <genbox-name> --restore'));
+                return;
+            }
+            console.log(chalk_1.default.blue('=== Restore Mode ==='));
+            console.log('');
+            const restoreSpinner = (0, ora_1.default)(`Looking for backup of '${nameArg}'...`).start();
+            try {
+                // Find backup by genbox name
+                restoreBackup = await (0, api_1.getLatestBackup)(nameArg, workspace);
+                if (!restoreBackup) {
+                    restoreSpinner.fail(chalk_1.default.red(`No backup found for '${nameArg}'`));
+                    console.log('');
+                    console.log(chalk_1.default.dim('  Create a backup first with: gb backup ' + nameArg));
+                    return;
+                }
+                // Verify backup is completed
+                if (restoreBackup.status !== 'completed') {
+                    restoreSpinner.fail(chalk_1.default.red(`Backup is not ready (status: ${restoreBackup.status})`));
+                    return;
+                }
+                // Get download URL
+                const downloadResult = await (0, api_1.getBackupDownloadUrl)(restoreBackup._id);
+                restoreDownloadUrl = downloadResult.downloadUrl;
+                restoreSpinner.succeed(chalk_1.default.green('Backup found'));
+                // Display backup details
+                console.log('');
+                console.log(`  ${chalk_1.default.bold('Size:')}    ${restoreBackup.sourceSize}`);
+                console.log(`  ${chalk_1.default.bold('Backed up:')} ${new Date(restoreBackup.createdAt).toLocaleString()}`);
+                // Show contents
+                const contents = [];
+                if (restoreBackup.repos && restoreBackup.repos.some(r => r.hadUncommittedChanges)) {
+                    contents.push('uncommitted changes');
+                }
+                if (restoreBackup.database) {
+                    contents.push('database');
+                }
+                if (restoreBackup.claudeHistoryIncluded) {
+                    contents.push('Claude history');
+                }
+                if (contents.length > 0) {
+                    console.log(`  ${chalk_1.default.bold('Contains:')} ${contents.join(', ')}`);
+                }
+                console.log('');
+            }
+            catch (error) {
+                restoreSpinner.fail(chalk_1.default.red(`Failed to fetch backup: ${error.message}`));
+                if (error instanceof api_1.AuthenticationError) {
+                    console.log(chalk_1.default.yellow('  Please authenticate first:'));
+                    console.log(chalk_1.default.cyan('  $ genbox login'));
+                }
+                return;
+            }
+        }
         // Interactive name prompt if not provided
         let name = nameArg;
         if (!name && !options.yes) {
@@ -233,7 +442,6 @@ exports.createCommand = new commander_1.Command('create')
             selectedProfile = await promptForProfile(config.profiles);
         }
         // Check if name is available in workspace, add suffix if taken
-        const workspace = config.project?.name || 'default';
         try {
             let { available } = await (0, api_1.checkNameAvailability)(name, workspace);
             if (!available) {
@@ -601,9 +809,51 @@ exports.createCommand = new commander_1.Command('create')
             }
             // Display results
             displayGenboxInfo(genbox, resolved);
-            // Inform user about server provisioning
-            console.log('');
-            console.log(chalk_1.default.dim('Server is provisioning. Run `genbox connect` once ready.'));
+            // Handle restore if backup was specified
+            if (restoreBackup && restoreDownloadUrl && genbox._id) {
+                console.log('');
+                console.log(chalk_1.default.blue('=== Restoring from Backup ==='));
+                // Wait for genbox to be ready
+                const waitSpinner = (0, ora_1.default)('Waiting for genbox to be ready...').start();
+                const waitResult = await waitForGenboxStatus(genbox._id, ['running']);
+                if (!waitResult.success) {
+                    waitSpinner.fail(chalk_1.default.red(waitResult.error || 'Failed to wait for genbox'));
+                    console.log(chalk_1.default.dim('  You can manually restore later: gb connect, then run the restore script'));
+                    return;
+                }
+                waitSpinner.succeed(chalk_1.default.green('Genbox is ready'));
+                // Get IP address from the ready genbox
+                const readyGenbox = waitResult.genbox;
+                const ipAddress = readyGenbox?.ipAddress || genbox.ipAddress;
+                if (!ipAddress) {
+                    console.log(chalk_1.default.red('Could not get genbox IP address'));
+                    console.log(chalk_1.default.dim('  You can manually restore by connecting and downloading the backup'));
+                    return;
+                }
+                // Run restore
+                const restoreSpinner = (0, ora_1.default)('Restoring backup...').start();
+                const restoreResult = await runRestore(ipAddress, restoreDownloadUrl, restoreBackup, (msg) => {
+                    restoreSpinner.text = msg;
+                });
+                if (restoreResult.success) {
+                    restoreSpinner.succeed(chalk_1.default.green('Backup restored successfully!'));
+                    console.log('');
+                    console.log(chalk_1.default.green('✓ Restore complete'));
+                    console.log('');
+                    console.log(chalk_1.default.bold('Next steps:'));
+                    console.log(`  1. Connect: ${chalk_1.default.cyan(`gb connect ${name}`)}`);
+                    console.log(`  2. Start services: ${chalk_1.default.cyan('gb restart')}`);
+                }
+                else {
+                    restoreSpinner.fail(chalk_1.default.red(`Restore failed: ${restoreResult.error}`));
+                    console.log(chalk_1.default.dim('  You can manually restore by connecting and running the restore script'));
+                }
+            }
+            else {
+                // Inform user about server provisioning
+                console.log('');
+                console.log(chalk_1.default.dim('Server is provisioning. Run `genbox connect` once ready.'));
+            }
         }
         catch (error) {
             spinner.fail(chalk_1.default.red(`Failed to create Genbox: ${error.message}`));

package/dist/index.js

@@ -33,6 +33,8 @@ const rebuild_1 = require("./commands/rebuild");
 const extend_1 = require("./commands/extend");
 const cleanup_ssh_1 = require("./commands/cleanup-ssh");
 const restart_1 = require("./commands/restart");
+const backup_1 = require("./commands/backup");
+const backups_1 = require("./commands/backups");
 program
     .addCommand(init_1.initCommand)
     .addCommand(create_1.createCommand)
@@ -58,5 +60,7 @@ program
     .addCommand(rebuild_1.rebuildCommand)
     .addCommand(extend_1.extendCommand)
     .addCommand(cleanup_ssh_1.cleanupSshCommand)
-    .addCommand(restart_1.restartCommand);
+    .addCommand(restart_1.restartCommand)
+    .addCommand(backup_1.backupCommand)
+    .addCommand(backups_1.backupsCommand);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.101",
+  "version": "1.0.102",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {