genbox 1.0.100 → 1.0.102

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/commands/extend.js

@@ -92,13 +92,18 @@ exports.extendCommand = new commander_1.Command('extend')
         spinner.stop();
         if (result.success) {
             console.log(chalk_1.default.green(`✓ ${result.message}`));
-            if (result.currentHourEnd) {
-                const endTime = new Date(result.currentHourEnd);
-                const minutesUntil = Math.ceil((endTime.getTime() - Date.now()) / (60 * 1000));
-                console.log(chalk_1.default.dim(`  Current hour ends in: ${minutesUntil} minutes`));
+            if (result.protectedUntil && result.autoDestroyEnabled) {
+                const protectedTime = new Date(result.protectedUntil);
+                const minutesUntil = Math.ceil((protectedTime.getTime() - Date.now()) / (60 * 1000));
+                const hoursUntil = Math.floor(minutesUntil / 60);
+                const remainingMins = minutesUntil % 60;
+                const timeStr = hoursUntil > 0
+                    ? `${hoursUntil}h ${remainingMins}m`
+                    : `${minutesUntil} min`;
+                console.log(chalk_1.default.dim(`  Protected from auto-destroy for: ${timeStr}`));
             }
             console.log(chalk_1.default.dim(`  Auto-destroy: ${result.autoDestroyEnabled ? 'enabled' : 'disabled'}`));
-            console.log(chalk_1.default.dim(`  Note: Credits charged at the end of each hour`));
+            console.log(chalk_1.default.dim(`  Note: Credits charged at the end of each billing hour`));
         }
         else {
             console.error(chalk_1.default.red(`Error: ${result.message}`));

package/dist/commands/profiles.js

@@ -337,3 +337,136 @@ exports.profilesCommand
         console.error(chalk_1.default.red(`Error: ${error.message}`));
     }
 });
+// Subcommand: profiles edit [name]
+exports.profilesCommand
+    .command('edit [name]')
+    .description('Interactively edit a profile')
+    .action(async (name) => {
+    try {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load();
+        if (!loadResult.config) {
+            console.log(chalk_1.default.red('Not a genbox project'));
+            console.log(chalk_1.default.dim('No genbox.yaml found in current directory.'));
+            return;
+        }
+        const configVersion = (0, schema_v4_1.getConfigVersion)(loadResult.config);
+        if (configVersion === 'invalid') {
+            console.log(chalk_1.default.red('Unknown config version'));
+            return;
+        }
+        const config = loadResult.config;
+        const profiles = configLoader.listProfiles(config);
+        if (profiles.length === 0) {
+            console.log(chalk_1.default.yellow('No profiles defined'));
+            console.log(chalk_1.default.dim('Run "genbox profiles create" to create a profile first'));
+            return;
+        }
+        // If no name provided, let user select from list
+        let profileName = name;
+        if (!profileName) {
+            const profileChoices = profiles.map(p => ({
+                name: `${p.name}${p.description ? ` - ${p.description}` : ''}`,
+                value: p.name,
+            }));
+            profileName = await prompts.select({
+                message: 'Select profile to edit:',
+                choices: profileChoices,
+            });
+        }
+        // Check if profile exists
+        if (!config.profiles?.[profileName]) {
+            console.log(chalk_1.default.red(`Profile '${profileName}' not found in genbox.yaml`));
+            return;
+        }
+        const existingProfile = config.profiles[profileName];
+        console.log(chalk_1.default.blue(`\nEditing Profile: ${profileName}\n`));
+        // Description
+        const description = await prompts.input({
+            message: 'Description:',
+            default: existingProfile.description || '',
+        });
+        // Apps selection
+        const appChoices = Object.entries(config.apps)
+            .filter(([_, app]) => app.type !== 'library')
+            .map(([appName, app]) => ({
+            name: `${appName} (${app.type})`,
+            value: appName,
+            checked: existingProfile.apps?.includes(appName) ?? false,
+        }));
+        const selectedApps = await prompts.checkbox({
+            message: 'Select apps to include:',
+            choices: appChoices,
+        });
+        // Size
+        const currentSize = existingProfile.size || 'medium';
+        const size = await prompts.select({
+            message: 'Server size:',
+            choices: [
+                { name: 'Small', value: 'small' },
+                { name: 'Medium', value: 'medium' },
+                { name: 'Large', value: 'large' },
+                { name: 'XL', value: 'xl' },
+            ],
+            default: currentSize,
+        });
+        // Connect to environment
+        const currentConnection = existingProfile.default_connection || 'local';
+        const connectTo = await prompts.select({
+            message: 'How should dependencies be resolved?',
+            choices: [
+                { name: 'Include locally', value: 'local' },
+                { name: 'Connect to staging', value: 'staging' },
+                { name: 'Connect to production', value: 'production' },
+            ],
+            default: currentConnection,
+        });
+        // Database mode - determine current setting
+        let currentDbMode = 'none';
+        if (existingProfile.database) {
+            if (existingProfile.database.mode === 'local') {
+                currentDbMode = 'local';
+            }
+            else if (existingProfile.database.mode === 'copy') {
+                currentDbMode = `copy-${existingProfile.database.source || 'staging'}`;
+            }
+            else if (existingProfile.database.mode === 'remote') {
+                currentDbMode = `remote-${existingProfile.database.source || 'staging'}`;
+            }
+        }
+        const dbMode = await prompts.select({
+            message: 'Database mode:',
+            choices: [
+                { name: 'None', value: 'none' },
+                { name: 'Fresh (empty)', value: 'local' },
+                { name: 'Copy from staging', value: 'copy-staging' },
+                { name: 'Connect to staging', value: 'remote-staging' },
+            ],
+            default: currentDbMode,
+        });
+        // Build updated profile
+        const updatedProfile = {
+            description: description || undefined,
+            size: size,
+            apps: selectedApps,
+            default_connection: connectTo !== 'local' ? connectTo : undefined,
+            database: dbMode !== 'none' ? {
+                mode: dbMode.startsWith('copy') ? 'copy' : dbMode.startsWith('remote') ? 'remote' : 'local',
+                source: dbMode.includes('staging') ? 'staging' : dbMode.includes('production') ? 'production' : undefined,
+            } : undefined,
+        };
+        // Update and save
+        config.profiles[profileName] = updatedProfile;
+        const configPath = configLoader.getConfigPath();
+        const yamlContent = yaml.dump(config, { lineWidth: 120, noRefs: true });
+        fs.writeFileSync(configPath, yamlContent);
+        console.log(chalk_1.default.green(`\n✔ Profile '${profileName}' updated in genbox.yaml`));
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError') {
+            console.log(chalk_1.default.dim('\nCancelled.'));
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});