genbox 1.0.19 → 1.0.20

package/dist/commands/create.js

@@ -110,6 +110,8 @@ exports.createCommand = new commander_1.Command('create')
     .option('--db-source <source>', 'Database source: staging, production')
     .option('-s, --size <size>', 'Server size: small, medium, large, xl')
     .option('-b, --branch <branch>', 'Git branch to checkout')
+    .option('-nb, --new-branch <name>', 'Create a new branch with this name')
+    .option('-sb, --source-branch <branch>', 'Source branch to create new branch from (defaults to current/default branch)')
     .option('-y, --yes', 'Skip interactive prompts')
     .option('--dry-run', 'Show what would be created without actually creating')
     .action(async (name, options) => {
@@ -137,13 +139,19 @@ exports.createCommand = new commander_1.Command('create')
             dbSource: options.dbSource,
             size: options.size,
             branch: options.branch,
+            newBranch: options.newBranch,
+            sourceBranch: options.sourceBranch,
             yes: options.yes,
             dryRun: options.dryRun,
         };
         // Resolve configuration
         console.log(chalk_1.default.blue('Resolving configuration...'));
         console.log('');
-        const resolved = await profileResolver.resolve(config, createOptions);
+        let resolved = await profileResolver.resolve(config, createOptions);
+        // Interactive branch selection if no branch was specified
+        if (!options.branch && !options.newBranch && !options.yes && resolved.repos.length > 0) {
+            resolved = await promptForBranchOptions(resolved, config);
+        }
         // Display resolved configuration
         displayResolvedConfig(resolved);
         // Ask to save as profile (if not using one already)
@@ -264,6 +272,12 @@ function displayResolvedConfig(resolved) {
         for (const repo of resolved.repos) {
             console.log(`    • ${repo.name}: ${repo.url}`);
             console.log(chalk_1.default.dim(`      → ${repo.path}`));
+            if (repo.newBranch) {
+                console.log(`      Branch: ${chalk_1.default.cyan(repo.newBranch)} ${chalk_1.default.dim(`(new, from ${repo.sourceBranch || 'main'})`)}`);
+            }
+            else if (repo.branch) {
+                console.log(`      Branch: ${chalk_1.default.cyan(repo.branch)}`);
+            }
         }
     }
     if (resolved.infrastructure.length > 0) {
@@ -292,6 +306,91 @@ function displayResolvedConfig(resolved) {
     console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
     console.log('');
 }
+/**
+ * Prompt for branch options interactively
+ */
+async function promptForBranchOptions(resolved, config) {
+    // Get the default branch from config or first repo
+    const defaultBranch = config.defaults?.branch || resolved.repos[0]?.branch || 'main';
+    console.log(chalk_1.default.blue('=== Branch Configuration ==='));
+    console.log(chalk_1.default.dim(`Default branch: ${defaultBranch}`));
+    console.log('');
+    const branchChoice = await prompts.select({
+        message: 'Branch option:',
+        choices: [
+            {
+                name: `Use default branch (${defaultBranch})`,
+                value: 'default',
+            },
+            {
+                name: 'Use a different existing branch',
+                value: 'existing',
+            },
+            {
+                name: 'Create a new branch',
+                value: 'new',
+            },
+        ],
+        default: 'default',
+    });
+    if (branchChoice === 'default') {
+        // Keep resolved repos as-is
+        return resolved;
+    }
+    if (branchChoice === 'existing') {
+        const branchName = await prompts.input({
+            message: 'Enter branch name:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                return true;
+            },
+        });
+        // Update all repos with the selected branch
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: branchName.trim(),
+                newBranch: undefined,
+                sourceBranch: undefined,
+            })),
+        };
+    }
+    if (branchChoice === 'new') {
+        const newBranchName = await prompts.input({
+            message: 'New branch name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                if (!/^[\w\-./]+$/.test(value))
+                    return 'Invalid branch name (use letters, numbers, -, _, /, .)';
+                return true;
+            },
+        });
+        const sourceBranch = await prompts.input({
+            message: 'Create from branch:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Source branch is required';
+                return true;
+            },
+        });
+        // Update all repos with new branch info
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: newBranchName.trim(),
+                newBranch: newBranchName.trim(),
+                sourceBranch: sourceBranch.trim(),
+            })),
+        };
+    }
+    return resolved;
+}
 /**
  * Parse .env.genbox file into segregated sections
  */
@@ -505,6 +604,8 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
             url: repo.url,
             path: repo.path,
             branch: repo.branch,
+            newBranch: repo.newBranch,
+            sourceBranch: repo.sourceBranch,
         };
     }
     return {

package/dist/commands/destroy.js

@@ -170,12 +170,132 @@ async function handleBulkDelete(options) {
         console.log(chalk_1.default.yellow(`Completed: ${successCount} destroyed, ${failCount} failed.`));
     }
 }
+/**
+ * Check for uncommitted changes and handle them before destroy
+ */
+async function handleUncommittedChanges(genbox, options) {
+    // Skip if --yes flag is used (user explicitly wants to skip this)
+    if (options.yes && !options.saveChanges) {
+        return { proceed: true };
+    }
+    // If save-changes is explicitly set, use that value
+    if (options.saveChanges === 'trash' || options.saveChanges === 'skip') {
+        return { proceed: true, action: options.saveChanges };
+    }
+    // Check for uncommitted changes by running git status on the genbox
+    console.log('');
+    console.log(chalk_1.default.blue('Checking for uncommitted changes...'));
+    try {
+        // Try to get git status from the genbox
+        const statusResponse = await (0, api_1.fetchApi)(`/genboxes/${genbox._id}/exec`, {
+            method: 'POST',
+            body: JSON.stringify({
+                command: 'cd /home/dev/* 2>/dev/null && git status --porcelain 2>/dev/null || echo ""',
+                timeout: 10000,
+            }),
+        });
+        const gitStatus = statusResponse?.stdout?.trim() || '';
+        if (!gitStatus) {
+            console.log(chalk_1.default.dim('  No uncommitted changes detected.'));
+            return { proceed: true, action: 'none' };
+        }
+        // There are uncommitted changes
+        const changeCount = gitStatus.split('\n').filter(line => line.trim()).length;
+        console.log(chalk_1.default.yellow(`  Found ${changeCount} uncommitted change${changeCount === 1 ? '' : 's'}.`));
+        console.log('');
+        // If save-changes is set to 'pr', auto-select that option
+        if (options.saveChanges === 'pr') {
+            return { proceed: true, action: 'pr' };
+        }
+        // Prompt user for action
+        const action = await (0, select_1.default)({
+            message: 'What would you like to do with uncommitted changes?',
+            choices: [
+                {
+                    name: 'Commit, push, and create PR (recommended)',
+                    value: 'pr',
+                    description: 'Creates a PR with your changes before destroying',
+                },
+                {
+                    name: 'Trash changes',
+                    value: 'trash',
+                    description: 'Discard all uncommitted changes',
+                },
+                {
+                    name: 'Cancel destroy',
+                    value: 'cancel',
+                    description: 'Keep the genbox running',
+                },
+            ],
+            default: 'pr',
+        });
+        if (action === 'cancel') {
+            return { proceed: false };
+        }
+        return { proceed: true, action };
+    }
+    catch (error) {
+        // If we can't check (e.g., genbox is not running), just proceed
+        console.log(chalk_1.default.dim('  Could not check for changes (genbox may not be accessible).'));
+        return { proceed: true, action: 'skip' };
+    }
+}
+/**
+ * Commit, push and create PR for changes
+ */
+async function createPRForChanges(genbox) {
+    const spinner = (0, ora_1.default)('Creating PR for uncommitted changes...').start();
+    try {
+        // Execute git commands on the genbox to commit, push, and create PR
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const branchName = `genbox-save/${genbox.name}-${timestamp}`;
+        const commands = [
+            // Ensure we're in the project directory
+            'cd /home/dev/*',
+            // Create a new branch for the changes
+            `git checkout -b "${branchName}"`,
+            // Stage all changes
+            'git add -A',
+            // Commit with a descriptive message
+            `git commit -m "Save changes from genbox '${genbox.name}' before destroy"`,
+            // Push to origin
+            `git push -u origin "${branchName}"`,
+            // Try to create PR using gh CLI if available
+            `gh pr create --title "Changes from genbox '${genbox.name}'" --body "Auto-saved changes before genbox destroy" 2>/dev/null || echo "PR_SKIP"`,
+        ].join(' && ');
+        const result = await (0, api_1.fetchApi)(`/genboxes/${genbox._id}/exec`, {
+            method: 'POST',
+            body: JSON.stringify({
+                command: commands,
+                timeout: 60000,
+            }),
+        });
+        if (result?.exitCode !== 0 && !result?.stdout?.includes('PR_SKIP')) {
+            spinner.fail(chalk_1.default.red('Failed to save changes'));
+            console.log(chalk_1.default.dim(`  Error: ${result?.stderr || 'Unknown error'}`));
+            return false;
+        }
+        if (result?.stdout?.includes('PR_SKIP')) {
+            spinner.succeed(chalk_1.default.green(`Changes pushed to branch '${branchName}'`));
+            console.log(chalk_1.default.dim('  Note: Could not create PR automatically. Create it manually on GitHub.'));
+        }
+        else {
+            spinner.succeed(chalk_1.default.green('PR created successfully'));
+        }
+        return true;
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Failed to save changes: ${error.message}`));
+        return false;
+    }
+}
 exports.destroyCommand = new commander_1.Command('destroy')
     .alias('delete')
     .description('Destroy one or more Genboxes')
     .argument('[name]', 'Name of the Genbox to destroy (optional - will prompt if not provided)')
     .option('-y, --yes', 'Skip confirmation')
     .option('-a, --all', 'Bulk delete mode - select multiple genboxes to destroy')
+    .option('--save-changes <action>', 'Handle uncommitted changes: pr (commit/push/PR), trash (discard), skip (ignore)')
     .action(async (name, options) => {
     try {
         // Bulk delete mode when --all is used without a specific name
@@ -195,6 +315,28 @@ exports.destroyCommand = new commander_1.Command('destroy')
         if (!target) {
             return;
         }
+        // Check for uncommitted changes if genbox is running
+        if (target.status === 'running') {
+            const { proceed, action } = await handleUncommittedChanges(target, options);
+            if (!proceed) {
+                console.log(chalk_1.default.dim('Destroy cancelled.'));
+                return;
+            }
+            // Handle the action
+            if (action === 'pr') {
+                const success = await createPRForChanges(target);
+                if (!success) {
+                    const continueAnyway = await (0, confirm_1.default)({
+                        message: 'Failed to save changes. Continue with destroy anyway?',
+                        default: false,
+                    });
+                    if (!continueAnyway) {
+                        console.log(chalk_1.default.dim('Destroy cancelled.'));
+                        return;
+                    }
+                }
+            }
+        }
         // Confirm
         let confirmed = options.yes;
         if (!confirmed) {

package/dist/commands/init.js

@@ -567,6 +567,7 @@ exports.initCommand = new commander_1.Command('init')
         }
         if (scan.git) {
             console.log(`  ${chalk_1.default.dim('Git:')}        ${scan.git.remote} (${scan.git.type})`);
+            console.log(`  ${chalk_1.default.dim('Branch:')}     ${chalk_1.default.cyan(scan.git.branch || 'main')}`);
         }
         console.log('');
         // Get project name (use scan value when --from-scan)
@@ -626,6 +627,20 @@ exports.initCommand = new commander_1.Command('init')
             v4Config.defaults = {};
         }
         v4Config.defaults.size = serverSize;
+        // Get default branch (use detected branch or allow override)
+        const detectedBranch = scan.git?.branch || 'main';
+        let defaultBranch = detectedBranch;
+        if (!nonInteractive && !options.fromScan) {
+            const branchInput = await prompts.input({
+                message: 'Default branch for new environments:',
+                default: detectedBranch,
+            });
+            defaultBranch = branchInput || detectedBranch;
+        }
+        // Store default branch in config defaults
+        if (defaultBranch && defaultBranch !== 'main') {
+            v4Config.defaults.branch = defaultBranch;
+        }
         // Git repository setup - different handling for multi-repo vs single-repo
         // When using --from-scan, skip git selection and use what's in detected.yaml
         const isMultiRepo = isMultiRepoStructure;

package/dist/commands/rebuild.js

@@ -0,0 +1,576 @@
+"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.rebuildCommand = void 0;
+const commander_1 = require("commander");
+const prompts = __importStar(require("@inquirer/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const config_loader_1 = require("../config-loader");
+const profile_resolver_1 = require("../profile-resolver");
+const api_1 = require("../api");
+const schema_v4_1 = require("../schema-v4");
+function getPublicSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519.pub'),
+        path.join(home, '.ssh', 'id_rsa.pub'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            const content = fs.readFileSync(keyPath, 'utf-8').trim();
+            if (content)
+                return content;
+        }
+    }
+    throw new Error('No public SSH key found in ~/.ssh/');
+}
+function getPrivateSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_ed25519'),
+        path.join(home, '.ssh', 'id_rsa'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return fs.readFileSync(keyPath, 'utf-8');
+        }
+    }
+    return undefined;
+}
+async function findGenboxByName(name) {
+    const genboxes = await (0, api_1.fetchApi)('/genboxes');
+    return genboxes.find((g) => g.name === name);
+}
+async function rebuildGenbox(id, payload) {
+    return (0, api_1.fetchApi)(`/genboxes/${id}/rebuild`, {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * Parse .env.genbox file into segregated sections
+ */
+function parseEnvGenboxSections(content) {
+    const sections = new Map();
+    let currentSection = 'GLOBAL';
+    let currentContent = [];
+    for (const line of content.split('\n')) {
+        const sectionMatch = line.match(/^# === ([^=]+) ===$/);
+        if (sectionMatch) {
+            if (currentContent.length > 0) {
+                sections.set(currentSection, currentContent.join('\n').trim());
+            }
+            currentSection = sectionMatch[1].trim();
+            currentContent = [];
+        }
+        else if (currentSection !== 'END') {
+            currentContent.push(line);
+        }
+    }
+    if (currentContent.length > 0 && currentSection !== 'END') {
+        sections.set(currentSection, currentContent.join('\n').trim());
+    }
+    return sections;
+}
+/**
+ * Build a map of service URL variables based on connection type
+ */
+function buildServiceUrlMap(envVarsFromFile, connectTo) {
+    const urlMap = {};
+    const prefix = connectTo ? `${connectTo.toUpperCase()}_` : 'LOCAL_';
+    const serviceNames = new Set();
+    for (const key of Object.keys(envVarsFromFile)) {
+        const match = key.match(/^(LOCAL|STAGING|PRODUCTION)_(.+_URL)$/);
+        if (match) {
+            serviceNames.add(match[2]);
+        }
+    }
+    for (const serviceName of serviceNames) {
+        const prefixedKey = `${prefix}${serviceName}`;
+        const localKey = `LOCAL_${serviceName}`;
+        const value = envVarsFromFile[prefixedKey] || envVarsFromFile[localKey];
+        if (value) {
+            urlMap[serviceName] = value;
+        }
+    }
+    if (!urlMap['API_URL']) {
+        const apiUrl = envVarsFromFile[`${prefix}API_URL`] ||
+            envVarsFromFile['LOCAL_API_URL'] ||
+            envVarsFromFile['STAGING_API_URL'];
+        if (apiUrl) {
+            urlMap['API_URL'] = apiUrl;
+        }
+    }
+    return urlMap;
+}
+/**
+ * Build env content for a specific app
+ */
+function buildAppEnvContent(sections, appName, serviceUrlMap) {
+    const parts = [];
+    const globalSection = sections.get('GLOBAL');
+    if (globalSection) {
+        parts.push(globalSection);
+    }
+    const appSection = sections.get(appName);
+    if (appSection) {
+        parts.push(appSection);
+    }
+    let envContent = parts.join('\n\n');
+    for (const [varName, value] of Object.entries(serviceUrlMap)) {
+        const pattern = new RegExp(`\\$\\{${varName}\\}`, 'g');
+        envContent = envContent.replace(pattern, value);
+    }
+    envContent = envContent
+        .split('\n')
+        .filter(line => {
+        const trimmed = line.trim();
+        return trimmed === '' || trimmed.includes('=') || !trimmed.startsWith('#');
+    })
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return envContent;
+}
+/**
+ * Build rebuild payload from resolved config
+ */
+function buildRebuildPayload(resolved, config, publicKey, privateKey, configLoader) {
+    const envVars = configLoader.loadEnvVars(process.cwd());
+    // Build services map
+    const services = {};
+    for (const app of resolved.apps) {
+        if (app.services) {
+            for (const [name, svc] of Object.entries(app.services)) {
+                services[name] = { port: svc.port, healthcheck: svc.healthcheck };
+            }
+        }
+        else if (app.port) {
+            services[app.name] = { port: app.port };
+        }
+    }
+    // Build files bundle
+    const files = [];
+    const envFilesToMove = [];
+    // Process .env.genbox
+    const envGenboxPath = path.join(process.cwd(), '.env.genbox');
+    if (fs.existsSync(envGenboxPath)) {
+        const rawEnvContent = fs.readFileSync(envGenboxPath, 'utf-8');
+        const sections = parseEnvGenboxSections(rawEnvContent);
+        const globalSection = sections.get('GLOBAL') || '';
+        const envVarsFromFile = {};
+        for (const line of globalSection.split('\n')) {
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+            if (match) {
+                let value = match[2].trim();
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                envVarsFromFile[match[1]] = value;
+            }
+        }
+        let connectTo;
+        if (resolved.profile && config.profiles?.[resolved.profile]) {
+            const profile = config.profiles[resolved.profile];
+            connectTo = (0, config_loader_1.getProfileConnection)(profile);
+        }
+        const serviceUrlMap = buildServiceUrlMap(envVarsFromFile, connectTo);
+        if (connectTo && Object.keys(serviceUrlMap).length > 0) {
+            console.log(chalk_1.default.dim(`  Using ${connectTo} URLs for variable expansion`));
+        }
+        for (const app of resolved.apps) {
+            const appPath = config.apps[app.name]?.path || app.name;
+            const repoPath = resolved.repos.find(r => r.name === app.name)?.path ||
+                (resolved.repos[0]?.path ? `${resolved.repos[0].path}/${appPath}` : `/home/dev/${config.project.name}/${appPath}`);
+            const servicesSections = Array.from(sections.keys()).filter(s => s.startsWith(`${app.name}/`));
+            if (servicesSections.length > 0) {
+                for (const serviceSectionName of servicesSections) {
+                    const serviceName = serviceSectionName.split('/')[1];
+                    const serviceEnvContent = buildAppEnvContent(sections, serviceSectionName, serviceUrlMap);
+                    const stagingName = `${app.name}-${serviceName}.env`;
+                    const targetPath = `${repoPath}/apps/${serviceName}/.env`;
+                    files.push({
+                        path: `/home/dev/.env-staging/${stagingName}`,
+                        content: serviceEnvContent,
+                        permissions: '0644',
+                    });
+                    envFilesToMove.push({ stagingName, targetPath });
+                }
+            }
+            else {
+                const appEnvContent = buildAppEnvContent(sections, app.name, serviceUrlMap);
+                files.push({
+                    path: `/home/dev/.env-staging/${app.name}.env`,
+                    content: appEnvContent,
+                    permissions: '0644',
+                });
+                envFilesToMove.push({
+                    stagingName: `${app.name}.env`,
+                    targetPath: `${repoPath}/.env`,
+                });
+            }
+        }
+    }
+    // Generate setup script
+    const setupScript = generateSetupScript(resolved, config, envFilesToMove);
+    if (setupScript) {
+        files.push({
+            path: '/home/dev/setup-genbox.sh',
+            content: setupScript,
+            permissions: '0755',
+        });
+    }
+    const postDetails = [];
+    if (setupScript) {
+        postDetails.push('su - dev -c "/home/dev/setup-genbox.sh"');
+    }
+    // Build repos
+    const repos = {};
+    for (const repo of resolved.repos) {
+        repos[repo.name] = {
+            url: repo.url,
+            path: repo.path,
+            branch: repo.branch,
+            newBranch: repo.newBranch,
+            sourceBranch: repo.sourceBranch,
+        };
+    }
+    return {
+        publicKey,
+        services,
+        files,
+        postDetails,
+        repos,
+        privateKey,
+        gitToken: envVars.GIT_TOKEN,
+    };
+}
+/**
+ * Generate setup script
+ */
+function generateSetupScript(resolved, config, envFilesToMove = []) {
+    const lines = [
+        '#!/bin/bash',
+        '# Generated by genbox rebuild',
+        'set -e',
+        '',
+    ];
+    if (envFilesToMove.length > 0) {
+        lines.push('# Move .env files from staging to app directories');
+        for (const { stagingName, targetPath } of envFilesToMove) {
+            lines.push(`if [ -f "/home/dev/.env-staging/${stagingName}" ]; then`);
+            lines.push(`  mkdir -p "$(dirname "${targetPath}")"`);
+            lines.push(`  mv "/home/dev/.env-staging/${stagingName}" "${targetPath}"`);
+            lines.push(`  echo "Moved .env to ${targetPath}"`);
+            lines.push('fi');
+        }
+        lines.push('rm -rf /home/dev/.env-staging 2>/dev/null || true');
+        lines.push('');
+    }
+    if (resolved.repos.length > 0) {
+        lines.push(`cd ${resolved.repos[0].path} || exit 1`);
+        lines.push('');
+    }
+    lines.push('# Install dependencies');
+    lines.push('if [ -f "pnpm-lock.yaml" ]; then');
+    lines.push('  echo "Installing dependencies with pnpm..."');
+    lines.push('  pnpm install --frozen-lockfile');
+    lines.push('elif [ -f "yarn.lock" ]; then');
+    lines.push('  echo "Installing dependencies with yarn..."');
+    lines.push('  yarn install --frozen-lockfile');
+    lines.push('elif [ -f "bun.lockb" ]; then');
+    lines.push('  echo "Installing dependencies with bun..."');
+    lines.push('  bun install --frozen-lockfile');
+    lines.push('elif [ -f "package-lock.json" ]; then');
+    lines.push('  echo "Installing dependencies with npm..."');
+    lines.push('  npm ci');
+    lines.push('fi');
+    const hasLocalApi = resolved.apps.some(a => a.name === 'api' || a.type === 'backend');
+    if (hasLocalApi) {
+        lines.push('');
+        lines.push('echo "Starting Docker services..."');
+        lines.push('if [ -f "docker-compose.yml" ] || [ -f "compose.yml" ]; then');
+        lines.push('  docker compose up -d');
+        lines.push('fi');
+    }
+    lines.push('');
+    lines.push('echo "Setup complete!"');
+    return lines.join('\n');
+}
+/**
+ * Prompt for branch options interactively
+ */
+async function promptForBranchOptions(resolved, config) {
+    // Get the default branch from config or first repo
+    const defaultBranch = config.defaults?.branch || resolved.repos[0]?.branch || 'main';
+    console.log(chalk_1.default.blue('=== Branch Configuration ==='));
+    console.log(chalk_1.default.dim(`Default branch: ${defaultBranch}`));
+    console.log('');
+    const branchChoice = await prompts.select({
+        message: 'Branch option:',
+        choices: [
+            {
+                name: `Use default branch (${defaultBranch})`,
+                value: 'default',
+            },
+            {
+                name: 'Use a different existing branch',
+                value: 'existing',
+            },
+            {
+                name: 'Create a new branch',
+                value: 'new',
+            },
+        ],
+        default: 'default',
+    });
+    if (branchChoice === 'default') {
+        return resolved;
+    }
+    if (branchChoice === 'existing') {
+        const branchName = await prompts.input({
+            message: 'Enter branch name:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                return true;
+            },
+        });
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: branchName.trim(),
+                newBranch: undefined,
+                sourceBranch: undefined,
+            })),
+        };
+    }
+    if (branchChoice === 'new') {
+        const newBranchName = await prompts.input({
+            message: 'New branch name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Branch name is required';
+                if (!/^[\w\-./]+$/.test(value))
+                    return 'Invalid branch name (use letters, numbers, -, _, /, .)';
+                return true;
+            },
+        });
+        const sourceBranch = await prompts.input({
+            message: 'Create from branch:',
+            default: defaultBranch,
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Source branch is required';
+                return true;
+            },
+        });
+        return {
+            ...resolved,
+            repos: resolved.repos.map(repo => ({
+                ...repo,
+                branch: newBranchName.trim(),
+                newBranch: newBranchName.trim(),
+                sourceBranch: sourceBranch.trim(),
+            })),
+        };
+    }
+    return resolved;
+}
+exports.rebuildCommand = new commander_1.Command('rebuild')
+    .description('Rebuild an existing Genbox environment with updated configuration')
+    .argument('<name>', 'Name of the Genbox to rebuild')
+    .option('-p, --profile <profile>', 'Use a predefined profile')
+    .option('-b, --branch <branch>', 'Git branch to checkout')
+    .option('-nb, --new-branch <name>', 'Create a new branch with this name')
+    .option('-sb, --source-branch <branch>', 'Source branch to create new branch from')
+    .option('-y, --yes', 'Skip interactive prompts')
+    .action(async (name, options) => {
+    try {
+        // Find existing genbox
+        const spinner = (0, ora_1.default)(`Finding Genbox '${name}'...`).start();
+        let genbox;
+        try {
+            genbox = await findGenboxByName(name);
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red(`Failed to find Genbox: ${error.message}`));
+            if (error instanceof api_1.AuthenticationError) {
+                console.log('');
+                console.log(chalk_1.default.yellow('  Please authenticate first:'));
+                console.log(chalk_1.default.cyan('  $ genbox login'));
+            }
+            return;
+        }
+        if (!genbox) {
+            spinner.fail(chalk_1.default.red(`Genbox '${name}' not found`));
+            return;
+        }
+        spinner.succeed(`Found Genbox '${name}'`);
+        // Load configuration
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load();
+        const configVersion = (0, schema_v4_1.getConfigVersion)(loadResult.config);
+        if (!loadResult.config || configVersion === 'unknown') {
+            console.error(chalk_1.default.red('No valid genbox.yaml configuration found'));
+            return;
+        }
+        const config = loadResult.config;
+        const profileResolver = new profile_resolver_1.ProfileResolver(configLoader);
+        // Build options for resolving
+        const createOptions = {
+            name,
+            profile: options.profile,
+            branch: options.branch,
+            newBranch: options.newBranch,
+            sourceBranch: options.sourceBranch,
+            yes: options.yes,
+        };
+        console.log(chalk_1.default.blue('Resolving configuration...'));
+        console.log('');
+        let resolved = await profileResolver.resolve(config, createOptions);
+        // Interactive branch selection if no branch was specified
+        if (!options.branch && !options.newBranch && !options.yes && resolved.repos.length > 0) {
+            resolved = await promptForBranchOptions(resolved, config);
+        }
+        // Display what will be rebuilt
+        console.log(chalk_1.default.bold('Rebuild Configuration:'));
+        console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
+        console.log(`  ${chalk_1.default.bold('Name:')}     ${name}`);
+        console.log(`  ${chalk_1.default.bold('Project:')}  ${resolved.project.name}`);
+        if (resolved.profile) {
+            console.log(`  ${chalk_1.default.bold('Profile:')}  ${resolved.profile}`);
+        }
+        console.log('');
+        console.log(`  ${chalk_1.default.bold('Apps:')}`);
+        for (const app of resolved.apps) {
+            console.log(`    - ${app.name} (${app.type})`);
+        }
+        // Display branch info
+        if (resolved.repos.length > 0) {
+            console.log('');
+            console.log(`  ${chalk_1.default.bold('Repos:')}`);
+            for (const repo of resolved.repos) {
+                const branchInfo = repo.newBranch
+                    ? `${chalk_1.default.cyan(repo.newBranch)} ${chalk_1.default.dim(`(new, from ${repo.sourceBranch || 'main'})`)}`
+                    : repo.branch
+                        ? chalk_1.default.cyan(repo.branch)
+                        : chalk_1.default.dim('default');
+                console.log(`    - ${repo.name}: ${branchInfo}`);
+            }
+        }
+        console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
+        // Confirm rebuild
+        if (!options.yes) {
+            console.log('');
+            console.log(chalk_1.default.yellow('Warning: Rebuild will reinstall the OS and rerun setup.'));
+            console.log(chalk_1.default.yellow('All unsaved work on the server will be lost.'));
+            console.log('');
+            const confirm = await prompts.confirm({
+                message: `Rebuild genbox '${name}'?`,
+                default: false,
+            });
+            if (!confirm) {
+                console.log(chalk_1.default.dim('Cancelled.'));
+                return;
+            }
+        }
+        // Get SSH keys
+        const publicKey = getPublicSshKey();
+        // Check if SSH auth is needed for git
+        let privateKeyContent;
+        const v3Config = config;
+        const usesSSH = v3Config.git_auth?.method === 'ssh' ||
+            Object.values(config.repos || {}).some(r => r.auth === 'ssh');
+        if (usesSSH && !options.yes) {
+            const injectKey = await prompts.confirm({
+                message: 'Inject SSH private key for git cloning?',
+                default: true,
+            });
+            if (injectKey) {
+                privateKeyContent = getPrivateSshKey();
+                if (privateKeyContent) {
+                    console.log(chalk_1.default.dim('  Using local SSH private key'));
+                }
+            }
+        }
+        // Build payload
+        const payload = buildRebuildPayload(resolved, config, publicKey, privateKeyContent, configLoader);
+        // Execute rebuild
+        const rebuildSpinner = (0, ora_1.default)(`Rebuilding Genbox '${name}'...`).start();
+        try {
+            await rebuildGenbox(genbox._id, payload);
+            rebuildSpinner.succeed(chalk_1.default.green(`Genbox '${name}' rebuild initiated!`));
+            console.log('');
+            console.log(chalk_1.default.dim('Server is rebuilding. This may take a few minutes.'));
+            console.log(chalk_1.default.dim('SSH connection will be temporarily unavailable.'));
+            console.log('');
+            console.log(`Run ${chalk_1.default.cyan(`genbox status ${name}`)} to check progress.`);
+        }
+        catch (error) {
+            rebuildSpinner.fail(chalk_1.default.red(`Failed to rebuild: ${error.message}`));
+            if (error instanceof api_1.AuthenticationError) {
+                console.log('');
+                console.log(chalk_1.default.yellow('  Please authenticate first:'));
+                console.log(chalk_1.default.cyan('  $ genbox login'));
+            }
+        }
+    }
+    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) {
+            console.log(chalk_1.default.red('Not logged in'));
+            console.log('');
+            console.log(chalk_1.default.yellow('  Please authenticate first:'));
+            console.log(chalk_1.default.cyan('  $ genbox login'));
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});

package/dist/commands/scan.js

@@ -656,10 +656,11 @@ function showSummary(detected) {
             console.log(`    ${chalk_1.default.cyan(infra.name)}: ${infra.type} (${infra.image})`);
         }
     }
-    // Git (root level)
+    // Git (root level) - show branch prominently
     if (detected.git?.remote) {
         console.log(`\n  Git: ${detected.git.provider || 'git'} (${detected.git.type})`);
-        console.log(chalk_1.default.dim(`    Branch: ${detected.git.branch || 'unknown'}`));
+        console.log(`    Remote: ${chalk_1.default.dim(detected.git.remote)}`);
+        console.log(`    Branch: ${chalk_1.default.cyan(detected.git.branch || 'main')} ${chalk_1.default.dim('← default branch for new environments')}`);
     }
     // Per-app git repos (for multi-repo workspaces)
     const appsWithGit = Object.entries(detected.apps).filter(([, app]) => app.git);
@@ -669,6 +670,7 @@ function showSummary(detected) {
             const git = app.git;
             console.log(`    ${chalk_1.default.cyan(name)}: ${git.provider} (${git.type})`);
             console.log(chalk_1.default.dim(`      ${git.remote}`));
+            console.log(`      Branch: ${chalk_1.default.cyan(git.branch || 'main')}`);
         }
     }
     // Service URLs (for staging URL configuration)

package/dist/index.js

@@ -30,6 +30,7 @@ const resolve_1 = require("./commands/resolve");
 const validate_1 = require("./commands/validate");
 const migrate_1 = require("./commands/migrate");
 const ssh_setup_1 = require("./commands/ssh-setup");
+const rebuild_1 = require("./commands/rebuild");
 program
     .addCommand(init_1.initCommand)
     .addCommand(create_1.createCommand)
@@ -52,5 +53,6 @@ program
     .addCommand(validate_1.validateCommand)
     .addCommand(migrate_1.migrateCommand)
     .addCommand(migrate_1.deprecationsCommand)
-    .addCommand(ssh_setup_1.sshSetupCommand);
+    .addCommand(ssh_setup_1.sshSetupCommand)
+    .addCommand(rebuild_1.rebuildCommand);
 program.parse(process.argv);

package/dist/profile-resolver.js

@@ -114,7 +114,7 @@ class ProfileResolver {
             apps,
             infrastructure,
             database,
-            repos: this.resolveRepos(config, apps),
+            repos: this.resolveRepos(config, apps, options),
             env: this.resolveEnvVars(config, apps, infrastructure, database, (0, config_loader_1.getProfileConnection)(profile)),
             hooks: config.hooks || {},
             profile: options.profile,
@@ -430,9 +430,13 @@ class ProfileResolver {
     /**
      * Resolve repositories to clone
      */
-    resolveRepos(config, apps) {
+    resolveRepos(config, apps, options) {
         const repos = [];
         const seen = new Set();
+        // Determine the effective branch to use
+        // Priority: newBranch > branch (CLI) > defaults.branch (config) > repo.branch
+        const effectiveBranch = options.newBranch || options.branch;
+        const defaultBranch = config.defaults?.branch;
         for (const app of apps) {
             const appConfig = config.apps[app.name];
             // Check if app has specific repo field
@@ -443,7 +447,10 @@ class ProfileResolver {
                         name: appConfig.repo,
                         url: repoConfig.url,
                         path: repoConfig.path,
-                        branch: repoConfig.branch,
+                        branch: effectiveBranch || repoConfig.branch || defaultBranch,
+                        // Track branch creation info for new branches
+                        newBranch: options.newBranch,
+                        sourceBranch: options.newBranch ? (options.sourceBranch || repoConfig.branch || defaultBranch || 'main') : undefined,
                     });
                     seen.add(repoConfig.url);
                 }
@@ -456,7 +463,9 @@ class ProfileResolver {
                         name: app.name,
                         url: repoConfig.url,
                         path: repoConfig.path,
-                        branch: repoConfig.branch,
+                        branch: effectiveBranch || repoConfig.branch || defaultBranch,
+                        newBranch: options.newBranch,
+                        sourceBranch: options.newBranch ? (options.sourceBranch || repoConfig.branch || defaultBranch || 'main') : undefined,
                     });
                     seen.add(repoConfig.url);
                 }
@@ -470,7 +479,9 @@ class ProfileResolver {
                     name: mainRepo[0],
                     url: mainRepo[1].url,
                     path: mainRepo[1].path,
-                    branch: mainRepo[1].branch,
+                    branch: effectiveBranch || mainRepo[1].branch || defaultBranch,
+                    newBranch: options.newBranch,
+                    sourceBranch: options.newBranch ? (options.sourceBranch || mainRepo[1].branch || defaultBranch || 'main') : undefined,
                 });
             }
         }

package/package.json

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