genbox 1.0.3 → 1.0.5

package/dist/commands/init.js

@@ -38,451 +38,952 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initCommand = void 0;
 const commander_1 = require("commander");
-const inquirer_1 = __importDefault(require("inquirer"));
+const prompts = __importStar(require("@inquirer/prompts"));
 const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const config_1 = require("../config");
-const scan_1 = require("../scan");
+const yaml = __importStar(require("js-yaml"));
 const process = __importStar(require("process"));
 const os = __importStar(require("os"));
+const scanner_1 = require("../scanner");
+const config_generator_1 = require("../scanner/config-generator");
+const scan_1 = require("../scan");
+const CONFIG_FILENAME = 'genbox.yaml';
+const ENV_FILENAME = '.env.genbox';
+/**
+ * Detect git repositories in app directories (for multi-repo workspaces)
+ */
+function detectAppGitRepos(apps, rootDir) {
+    const { execSync } = require('child_process');
+    const repos = [];
+    for (const app of apps) {
+        const appDir = path_1.default.join(rootDir, app.path);
+        const gitDir = path_1.default.join(appDir, '.git');
+        if (!fs_1.default.existsSync(gitDir))
+            continue;
+        try {
+            const remote = execSync('git remote get-url origin', {
+                cwd: appDir,
+                stdio: 'pipe',
+                encoding: 'utf8',
+            }).trim();
+            if (!remote)
+                continue;
+            const isSSH = remote.startsWith('git@') || remote.startsWith('ssh://');
+            let provider = 'other';
+            if (remote.includes('github.com'))
+                provider = 'github';
+            else if (remote.includes('gitlab.com'))
+                provider = 'gitlab';
+            else if (remote.includes('bitbucket.org'))
+                provider = 'bitbucket';
+            let branch = 'main';
+            try {
+                branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                    cwd: appDir,
+                    stdio: 'pipe',
+                    encoding: 'utf8',
+                }).trim();
+            }
+            catch { }
+            repos.push({
+                appName: app.name,
+                appPath: app.path,
+                remote,
+                type: isSSH ? 'ssh' : 'https',
+                provider,
+                branch,
+            });
+        }
+        catch {
+            // No git remote in this directory
+        }
+    }
+    return repos;
+}
+/**
+ * Find .env files in app directories
+ */
+function findAppEnvFiles(apps, rootDir) {
+    const envFiles = [];
+    const envPatterns = ['.env', '.env.local', '.env.development'];
+    for (const app of apps) {
+        const appDir = path_1.default.join(rootDir, app.path);
+        for (const pattern of envPatterns) {
+            const envPath = path_1.default.join(appDir, pattern);
+            if (fs_1.default.existsSync(envPath)) {
+                envFiles.push({
+                    appName: app.name,
+                    envFile: pattern,
+                    fullPath: envPath,
+                });
+                break; // Only take the first match per app
+            }
+        }
+    }
+    return envFiles;
+}
 exports.initCommand = new commander_1.Command('init')
     .description('Initialize a new Genbox configuration')
-    .action(async () => {
+    .option('--v2', 'Use legacy v2 format (single-app only)')
+    .option('--workspace', 'Initialize as workspace config (for multi-repo projects)')
+    .option('--force', 'Overwrite existing configuration')
+    .option('-y, --yes', 'Use defaults without prompting')
+    .option('--exclude <dirs>', 'Comma-separated directories to exclude')
+    .option('--name <name>', 'Project name (for non-interactive mode)')
+    .action(async (options) => {
     try {
-        if ((0, config_1.hasConfig)()) {
+        const configPath = path_1.default.join(process.cwd(), CONFIG_FILENAME);
+        const nonInteractive = options.yes || !process.stdin.isTTY;
+        // Check for existing config
+        if (fs_1.default.existsSync(configPath) && !options.force) {
+            if (nonInteractive) {
+                console.log(chalk_1.default.yellow('genbox.yaml already exists. Use --force to overwrite.'));
+                return;
+            }
             console.log(chalk_1.default.yellow('genbox.yaml already exists.'));
-            const { overwrite } = await inquirer_1.default.prompt([
-                {
-                    type: 'confirm',
-                    name: 'overwrite',
-                    message: 'Do you want to overwrite it?',
-                    default: false,
-                },
-            ]);
+            const overwrite = await prompts.confirm({
+                message: 'Do you want to overwrite it?',
+                default: false,
+            });
             if (!overwrite) {
                 return;
             }
         }
         console.log(chalk_1.default.blue('Initializing Genbox...'));
-        console.log(chalk_1.default.dim('Scanning project...'));
-        const info = (0, scan_1.scanProject)(process.cwd());
-        console.log(chalk_1.default.green(`Detected: ${info.name}`));
-        if (info.hasDocker)
-            console.log(chalk_1.default.dim('  - Docker detected'));
-        // 1. Project Name
-        const { project_name } = await inquirer_1.default.prompt([
-            {
-                type: 'input',
-                name: 'project_name',
-                message: 'Project Name:',
-                default: info.name,
+        console.log('');
+        // Get directory exclusions
+        let exclude = [];
+        if (options.exclude) {
+            exclude = options.exclude.split(',').map((d) => d.trim()).filter(Boolean);
+        }
+        else if (!nonInteractive) {
+            const excludeDirs = await prompts.input({
+                message: 'Directories to exclude (comma-separated, or empty to skip):',
+                default: '',
+            });
+            exclude = excludeDirs
+                ? excludeDirs.split(',').map((d) => d.trim()).filter(Boolean)
+                : [];
+        }
+        // Scan project (skip scripts initially - we'll ask about them later)
+        const spinner = (0, ora_1.default)('Scanning project...').start();
+        const scanner = new scanner_1.ProjectScanner();
+        const scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
+        spinner.succeed('Project scanned');
+        // Display scan results
+        console.log('');
+        console.log(chalk_1.default.bold('Detected:'));
+        console.log(`  ${chalk_1.default.dim('Project:')}    ${scan.projectName}`);
+        console.log(`  ${chalk_1.default.dim('Structure:')}  ${scan.structure.type} (${scan.structure.confidence} confidence)`);
+        if (scan.runtimes.length > 0) {
+            const runtimeStr = scan.runtimes
+                .map(r => `${r.language}${r.version ? ` ${r.version}` : ''}`)
+                .join(', ');
+            console.log(`  ${chalk_1.default.dim('Runtimes:')}   ${runtimeStr}`);
+        }
+        if (scan.frameworks.length > 0) {
+            const frameworkStr = scan.frameworks.map(f => f.name).join(', ');
+            console.log(`  ${chalk_1.default.dim('Frameworks:')} ${frameworkStr}`);
+        }
+        if (scan.apps.length > 0) {
+            console.log(`  ${chalk_1.default.dim('Apps:')}       ${scan.apps.length} discovered`);
+            for (const app of scan.apps.slice(0, 5)) {
+                console.log(`               - ${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`);
             }
-        ]);
-        // 2. Scripts Selection
-        let selectedScripts = [];
-        if (info.foundScripts.length > 0) {
-            const scriptAnswers = await inquirer_1.default.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'scripts',
-                    message: 'Select setup scripts to run:',
-                    choices: info.foundScripts,
-                    default: info.foundScripts,
-                },
-            ]);
-            selectedScripts = scriptAnswers.scripts;
-        }
-        // 3. Server Size
-        const { server_size } = await inquirer_1.default.prompt([
-            {
-                type: 'select',
-                name: 'server_size',
-                message: 'Default Server Size:',
-                choices: ['small', 'medium', 'large', 'xl'],
-                default: 'small',
+            if (scan.apps.length > 5) {
+                console.log(`               ... and ${scan.apps.length - 5} more`);
             }
-        ]);
-        // 4. Git Repository Setup
-        let gitAuth;
-        let repoUrl = info.gitRemote;
-        let repoAuthMethod;
-        if (info.gitRemote) {
-            console.log('');
-            console.log(chalk_1.default.blue('=== Git Repository Setup ==='));
-            console.log(chalk_1.default.dim(`Detected remote: ${info.gitRemote}`));
-            // Ask about authentication method - default to PAT (token)
-            const { authMethod } = await inquirer_1.default.prompt([
-                {
-                    type: 'select',
-                    name: 'authMethod',
-                    message: 'How should the genbox access this repository?',
-                    choices: [
-                        { name: 'Personal Access Token (PAT) - recommended', value: 'token' },
-                        { name: 'SSH Key - use existing key', value: 'ssh' },
-                        { name: 'Public - no authentication needed', value: 'public' },
-                    ],
-                    default: 'token',
-                }
-            ]);
-            if (authMethod === 'token') {
-                repoAuthMethod = 'token';
-                // Convert SSH URL to HTTPS if needed
-                if (info.gitRemoteType === 'ssh') {
-                    const httpsUrl = (0, scan_1.sshToHttps)(info.gitRemote);
-                    console.log(chalk_1.default.dim(`  Will use HTTPS URL: ${httpsUrl}`));
-                    repoUrl = httpsUrl;
-                }
-                gitAuth = { method: 'token' };
-                // Detect git provider for specific instructions
-                const isGitHub = info.gitRemote.includes('github.com');
-                const isGitLab = info.gitRemote.includes('gitlab.com');
-                const isBitbucket = info.gitRemote.includes('bitbucket.org');
-                console.log('');
-                console.log(chalk_1.default.yellow('  Personal Access Token Setup:'));
+        }
+        if (scan.compose) {
+            console.log(`  ${chalk_1.default.dim('Docker:')}     ${scan.compose.applications.length} services`);
+        }
+        if (scan.git) {
+            console.log(`  ${chalk_1.default.dim('Git:')}        ${scan.git.remote} (${scan.git.type})`);
+        }
+        console.log('');
+        // Get project name
+        const projectName = nonInteractive
+            ? (options.name || scan.projectName)
+            : await prompts.input({
+                message: 'Project name:',
+                default: scan.projectName,
+            });
+        // Determine if workspace or single project
+        let isWorkspace = options.workspace;
+        if (!isWorkspace && (scan.structure.type.startsWith('monorepo') || scan.structure.type === 'hybrid')) {
+            if (nonInteractive) {
+                isWorkspace = true; // Default to workspace for monorepos
+            }
+            else {
+                isWorkspace = await prompts.confirm({
+                    message: 'Detected monorepo/workspace structure. Configure as workspace?',
+                    default: true,
+                });
+            }
+        }
+        // Generate initial config (v2 format)
+        const generator = new config_generator_1.ConfigGenerator();
+        const generated = generator.generate(scan);
+        // Convert to v3 format
+        const v3Config = convertV2ToV3(generated.config, scan);
+        // Update project name
+        v3Config.project.name = projectName;
+        // Ask about profiles
+        let createProfiles = true;
+        if (!nonInteractive) {
+            createProfiles = await prompts.confirm({
+                message: 'Create predefined profiles for common scenarios?',
+                default: true,
+            });
+        }
+        if (createProfiles) {
+            v3Config.profiles = nonInteractive
+                ? createDefaultProfilesSync(scan, v3Config)
+                : await createDefaultProfiles(scan, v3Config);
+        }
+        // Get server size
+        const serverSize = nonInteractive
+            ? generated.config.system.size
+            : await prompts.select({
+                message: 'Default server size:',
+                choices: [
+                    { name: 'Small  - 2 CPU, 4GB RAM', value: 'small' },
+                    { name: 'Medium - 4 CPU, 8GB RAM', value: 'medium' },
+                    { name: 'Large  - 8 CPU, 16GB RAM', value: 'large' },
+                    { name: 'XL     - 16 CPU, 32GB RAM', value: 'xl' },
+                ],
+                default: generated.config.system.size,
+            });
+        if (!v3Config.defaults) {
+            v3Config.defaults = {};
+        }
+        v3Config.defaults.size = serverSize;
+        // Git repository setup - different handling for multi-repo vs single-repo
+        const isMultiRepo = scan.structure.type === 'hybrid';
+        if (isMultiRepo) {
+            // Multi-repo workspace: detect git repos in app directories
+            const appGitRepos = detectAppGitRepos(scan.apps, process.cwd());
+            if (appGitRepos.length > 0 && !nonInteractive) {
                 console.log('');
-                if (isGitHub) {
-                    console.log(chalk_1.default.bold('  GitHub Fine-grained Token Setup:'));
-                    console.log(chalk_1.default.dim('  1. Go to: https://github.com/settings/tokens?type=beta'));
-                    console.log(chalk_1.default.dim('  2. Click "Generate new token"'));
-                    console.log(chalk_1.default.dim('  3. Token name: "genbox-' + project_name + '"'));
-                    console.log(chalk_1.default.dim('  4. Set expiration (90 days or custom)'));
-                    console.log(chalk_1.default.dim('  5. Repository access: Select "Only select repositories"'));
-                    console.log(chalk_1.default.dim('     Then choose your repository from the dropdown'));
-                    console.log(chalk_1.default.dim('  6. Scroll down to "Repository permissions" (not Account permissions!)'));
-                    console.log(chalk_1.default.dim('     - Contents: Read and write'));
-                    console.log(chalk_1.default.dim('     - Pull requests: Read and write (optional, for PR creation)'));
-                    console.log(chalk_1.default.dim('  7. Click "Generate token" at the bottom and copy it'));
-                }
-                else if (isGitLab) {
-                    console.log(chalk_1.default.bold('  GitLab Token Setup:'));
-                    console.log(chalk_1.default.dim('  1. Go to: https://gitlab.com/-/profile/personal_access_tokens'));
-                    console.log(chalk_1.default.dim('  2. Token name: "genbox-' + project_name + '"'));
-                    console.log(chalk_1.default.dim('  3. Select scopes: "read_repository", "write_repository"'));
-                    console.log(chalk_1.default.dim('  4. Click "Create personal access token"'));
-                }
-                else if (isBitbucket) {
-                    console.log(chalk_1.default.bold('  Bitbucket App Password Setup:'));
-                    console.log(chalk_1.default.dim('  1. Go to: https://bitbucket.org/account/settings/app-passwords/'));
-                    console.log(chalk_1.default.dim('  2. Click "Create app password"'));
-                    console.log(chalk_1.default.dim('  3. Label: "genbox-' + project_name + '"'));
-                    console.log(chalk_1.default.dim('  4. Select: Repositories (Read, Write)'));
-                }
-                else {
-                    console.log(chalk_1.default.dim('  Create a personal access token with repo read/write permissions'));
+                console.log(chalk_1.default.blue('=== Git Repositories ==='));
+                console.log(chalk_1.default.dim(`Found ${appGitRepos.length} git repositories in app directories`));
+                const repoChoices = appGitRepos.map(repo => ({
+                    name: `${repo.appName} - ${repo.remote}`,
+                    value: repo.appName,
+                    checked: true, // Default to include all
+                }));
+                const selectedRepos = await prompts.checkbox({
+                    message: 'Select repositories to include:',
+                    choices: repoChoices,
+                });
+                if (selectedRepos.length > 0) {
+                    v3Config.repos = {};
+                    for (const repoName of selectedRepos) {
+                        const repo = appGitRepos.find(r => r.appName === repoName);
+                        v3Config.repos[repo.appName] = {
+                            url: repo.remote,
+                            path: `/home/dev/${projectName}/${repo.appPath}`,
+                            branch: repo.branch !== 'main' && repo.branch !== 'master' ? repo.branch : undefined,
+                            auth: repo.type === 'ssh' ? 'ssh' : 'token',
+                        };
+                    }
                 }
-                console.log('');
-                console.log(chalk_1.default.cyan('  Add the token to .env.genbox:'));
-                console.log(chalk_1.default.white('    GIT_TOKEN=ghp_xxxxxxxxxxxx'));
-                console.log('');
             }
-            else if (authMethod === 'ssh') {
-                repoAuthMethod = 'ssh';
-                // Convert HTTPS URL to SSH if needed
-                if (info.gitRemoteType === 'https') {
-                    const sshUrl = (0, scan_1.httpsToSsh)(info.gitRemote);
-                    console.log(chalk_1.default.dim(`  Will use SSH URL: ${sshUrl}`));
-                    repoUrl = sshUrl;
+            else if (appGitRepos.length > 0) {
+                // Non-interactive: include all repos
+                v3Config.repos = {};
+                for (const repo of appGitRepos) {
+                    v3Config.repos[repo.appName] = {
+                        url: repo.remote,
+                        path: `/home/dev/${projectName}/${repo.appPath}`,
+                        auth: repo.type === 'ssh' ? 'ssh' : 'token',
+                    };
                 }
-                // Ask consent before scanning SSH keys
-                const { scanSshKeys } = await inquirer_1.default.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'scanSshKeys',
-                        message: 'May we scan ~/.ssh/ for available SSH keys?',
-                        default: true,
-                    }
-                ]);
-                if (scanSshKeys) {
-                    const sshKeys = (0, scan_1.detectSshKeys)();
-                    if (sshKeys.length > 0) {
-                        console.log(chalk_1.default.green(`  Found ${sshKeys.length} SSH key(s)`));
-                        const keyChoices = sshKeys.map((key) => ({
-                            name: `${key.name} (${key.type})`,
-                            value: key.path,
-                        }));
-                        keyChoices.push({ name: 'Enter custom path...', value: 'custom' });
-                        const { selectedKey } = await inquirer_1.default.prompt([
-                            {
-                                type: 'select',
-                                name: 'selectedKey',
-                                message: 'Select SSH key to use:',
-                                choices: keyChoices,
-                            }
-                        ]);
-                        if (selectedKey === 'custom') {
-                            const { customKeyPath } = await inquirer_1.default.prompt([
-                                {
-                                    type: 'input',
-                                    name: 'customKeyPath',
-                                    message: 'Enter path to SSH private key:',
-                                    default: path_1.default.join(os.homedir(), '.ssh', 'id_rsa'),
-                                }
-                            ]);
-                            gitAuth = { method: 'ssh', ssh_key_path: customKeyPath };
-                        }
-                        else {
-                            gitAuth = { method: 'ssh', ssh_key_path: selectedKey };
-                        }
-                    }
-                    else {
-                        console.log(chalk_1.default.yellow('  No SSH keys found'));
-                        const { keyPath } = await inquirer_1.default.prompt([
-                            {
-                                type: 'input',
-                                name: 'keyPath',
-                                message: 'Enter path to SSH private key:',
-                                default: path_1.default.join(os.homedir(), '.ssh', 'id_ed25519'),
-                            }
-                        ]);
-                        gitAuth = { method: 'ssh', ssh_key_path: keyPath };
-                    }
+            }
+        }
+        else if (scan.git) {
+            // Single repo or monorepo with root git
+            if (nonInteractive) {
+                const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
+                v3Config.repos = {
+                    [repoName]: {
+                        url: scan.git.remote,
+                        path: `/home/dev/${repoName}`,
+                        auth: scan.git.type === 'ssh' ? 'ssh' : 'token',
+                    },
+                };
+            }
+            else {
+                const gitConfig = await setupGitAuth(scan.git, projectName);
+                if (gitConfig.repos) {
+                    v3Config.repos = gitConfig.repos;
                 }
-                else {
-                    // User declined scanning, ask for path directly
-                    const { keyPath } = await inquirer_1.default.prompt([
-                        {
-                            type: 'input',
-                            name: 'keyPath',
-                            message: 'Enter path to SSH private key:',
-                            default: path_1.default.join(os.homedir(), '.ssh', 'id_ed25519'),
-                        }
-                    ]);
-                    gitAuth = { method: 'ssh', ssh_key_path: keyPath };
+                if (gitConfig.git_auth) {
+                    v3Config.git_auth = gitConfig.git_auth;
                 }
-                console.log('');
-                console.log(chalk_1.default.cyan('  Add your SSH private key to .env.genbox:'));
-                console.log(chalk_1.default.white(`    GIT_SSH_KEY="$(cat ${gitAuth?.ssh_key_path})"`));
-                console.log('');
-                console.log(chalk_1.default.dim('  Or manually paste the key content'));
             }
-            // If 'public', no auth needed
         }
-        else {
-            // No git remote detected
-            console.log('');
-            console.log(chalk_1.default.dim('  No git remote detected.'));
-            const { addRepo } = await inquirer_1.default.prompt([
-                {
-                    type: 'confirm',
-                    name: 'addRepo',
-                    message: 'Would you like to add a git repository?',
-                    default: false,
-                }
-            ]);
+        else if (!nonInteractive && !isMultiRepo) {
+            // Only ask to add repo for non-multi-repo projects
+            const addRepo = await prompts.confirm({
+                message: 'No git remote detected. Add a repository?',
+                default: false,
+            });
             if (addRepo) {
-                const { repoUrlInput } = await inquirer_1.default.prompt([
-                    {
-                        type: 'input',
-                        name: 'repoUrlInput',
-                        message: 'Enter repository URL (HTTPS recommended):',
-                        validate: (input) => {
-                            if (!input)
-                                return 'Repository URL is required';
-                            if (!input.startsWith('git@') && !input.startsWith('https://') && !input.startsWith('http://')) {
-                                return 'Please enter a valid git URL (https://... or git@...)';
-                            }
-                            return true;
+                const repoUrl = await prompts.input({
+                    message: 'Repository URL (HTTPS recommended):',
+                    validate: (value) => {
+                        if (!value)
+                            return 'Repository URL is required';
+                        if (!value.startsWith('git@') && !value.startsWith('https://')) {
+                            return 'Enter a valid git URL';
                         }
-                    }
-                ]);
-                repoUrl = repoUrlInput;
-                const urlType = repoUrlInput.startsWith('git@') || repoUrlInput.startsWith('ssh://') ? 'ssh' : 'https';
-                if (urlType === 'https') {
-                    gitAuth = { method: 'token' };
-                    repoAuthMethod = 'token';
-                    console.log(chalk_1.default.cyan('  Add GIT_TOKEN to .env.genbox for authentication'));
+                        return true;
+                    },
+                });
+                const repoName = path_1.default.basename(repoUrl, '.git');
+                v3Config.repos = {
+                    [repoName]: {
+                        url: repoUrl,
+                        path: `/home/dev/${repoName}`,
+                        auth: repoUrl.startsWith('git@') ? 'ssh' : 'token',
+                    },
+                };
+            }
+        }
+        // Environment configuration (skip in non-interactive mode)
+        if (!nonInteractive) {
+            const envConfig = await setupEnvironments(scan, v3Config, isMultiRepo);
+            if (envConfig) {
+                v3Config.environments = envConfig;
+            }
+        }
+        // Script selection - always show multi-select UI (skip in non-interactive mode)
+        if (!nonInteractive) {
+            // Scan for scripts
+            const scriptsSpinner = (0, ora_1.default)('Scanning for scripts...').start();
+            const fullScan = await scanner.scan(process.cwd(), { exclude, skipScripts: false });
+            scriptsSpinner.stop();
+            if (fullScan.scripts.length > 0) {
+                console.log('');
+                console.log(chalk_1.default.blue('=== Setup Scripts ==='));
+                // Group scripts by directory for display
+                const scriptsByDir = new Map();
+                for (const script of fullScan.scripts) {
+                    const dir = script.path.includes('/') ? script.path.split('/')[0] : '(root)';
+                    const existing = scriptsByDir.get(dir) || [];
+                    existing.push(script);
+                    scriptsByDir.set(dir, existing);
                 }
-                else {
-                    // SSH URL entered, ask about key with consent
-                    const { scanSshKeys } = await inquirer_1.default.prompt([
-                        {
-                            type: 'confirm',
-                            name: 'scanSshKeys',
-                            message: 'May we scan ~/.ssh/ for available SSH keys?',
-                            default: true,
-                        }
-                    ]);
-                    if (scanSshKeys) {
-                        const sshKeys = (0, scan_1.detectSshKeys)();
-                        if (sshKeys.length > 0) {
-                            const { selectedKey } = await inquirer_1.default.prompt([
-                                {
-                                    type: 'select',
-                                    name: 'selectedKey',
-                                    message: 'Select SSH key:',
-                                    choices: sshKeys.map((k) => ({ name: k.name, value: k.path })),
-                                }
-                            ]);
-                            gitAuth = { method: 'ssh', ssh_key_path: selectedKey };
-                        }
-                        else {
-                            gitAuth = { method: 'ssh', ssh_key_path: path_1.default.join(os.homedir(), '.ssh', 'id_ed25519') };
-                        }
-                    }
-                    else {
-                        const { keyPath } = await inquirer_1.default.prompt([
-                            {
-                                type: 'input',
-                                name: 'keyPath',
-                                message: 'Enter path to SSH private key:',
-                                default: path_1.default.join(os.homedir(), '.ssh', 'id_ed25519'),
-                            }
-                        ]);
-                        gitAuth = { method: 'ssh', ssh_key_path: keyPath };
-                    }
-                    repoAuthMethod = 'ssh';
+                // Show grouped scripts
+                for (const [dir, scripts] of scriptsByDir) {
+                    console.log(chalk_1.default.dim(`  ${dir}/ (${scripts.length} scripts)`));
+                }
+                // Let user select scripts with multi-select
+                const scriptChoices = fullScan.scripts.map(s => ({
+                    name: `${s.path} (${s.stage})`,
+                    value: s.path,
+                    checked: s.path.startsWith('scripts/'), // Default select scripts/ directory
+                }));
+                const selectedScripts = await prompts.checkbox({
+                    message: 'Select scripts to include (space to toggle, enter to confirm):',
+                    choices: scriptChoices,
+                });
+                if (selectedScripts.length > 0) {
+                    v3Config.scripts = fullScan.scripts
+                        .filter(s => selectedScripts.includes(s.path))
+                        .map(s => ({
+                        name: s.name,
+                        path: s.path,
+                        stage: s.stage,
+                    }));
                 }
             }
+            else {
+                console.log(chalk_1.default.dim('No scripts found.'));
+            }
         }
-        // Smart Suggestion: Create setup script if none selected but Docker exists
-        let extraScripts = [];
-        if (selectedScripts.length === 0 && info.hasDocker) {
-            const { createSetup } = await inquirer_1.default.prompt([{
-                    type: 'confirm',
-                    name: 'createSetup',
-                    message: 'No setup scripts selected. Create default Docker setup script (scripts/setup-genbox.sh)?',
-                    default: true
-                }]);
-            if (createSetup) {
-                const scriptsDir = path_1.default.join(process.cwd(), 'scripts');
-                if (!fs_1.default.existsSync(scriptsDir))
-                    fs_1.default.mkdirSync(scriptsDir);
-                // Setup directory logic
-                const repoName = repoUrl ? path_1.default.basename(repoUrl, '.git') : project_name;
-                const projectDir = repoUrl ? `/home/dev/${repoName}` : '/home/dev'; // If no git, assume files uploaded to root or handled differently
-                const setupFile = path_1.default.join(scriptsDir, 'setup-genbox.sh');
-                const setupContent = `#!/bin/bash
-# Auto-generated by Genbox
-echo "Starting services..."
-cd ${projectDir} || echo "Directory ${projectDir} not found, staying in $(pwd)"
-
-if [ -f "docker-compose.secure.yml" ]; then
-  docker compose -f docker-compose.secure.yml up -d
-elif [ -f "docker-compose.yml" ]; then
-  docker compose up -d
-else
-  echo "No docker-compose file found in $(pwd)!"
-fi
-`;
-                fs_1.default.writeFileSync(setupFile, setupContent, { mode: 0o755 });
-                console.log(chalk_1.default.green(`Created scripts/setup-genbox.sh`));
-                extraScripts.push('scripts/setup-genbox.sh');
+        // Save configuration
+        const yamlContent = yaml.dump(v3Config, {
+            lineWidth: 120,
+            noRefs: true,
+            quotingType: '"',
+        });
+        fs_1.default.writeFileSync(configPath, yamlContent);
+        console.log(chalk_1.default.green(`\n✔ Configuration saved to ${CONFIG_FILENAME}`));
+        // Generate .env.genbox
+        await setupEnvFile(projectName, v3Config, nonInteractive, scan, isMultiRepo);
+        // Show warnings
+        if (generated.warnings.length > 0) {
+            console.log('');
+            console.log(chalk_1.default.yellow('Warnings:'));
+            for (const warning of generated.warnings) {
+                console.log(chalk_1.default.dim(`  - ${warning}`));
             }
         }
-        // Build repos config
-        const reposConfig = {};
-        if (repoUrl) {
-            const repoName = path_1.default.basename(repoUrl, '.git');
-            reposConfig[repoName] = {
-                url: repoUrl,
-                path: `/home/dev/${repoName}`,
-                ...(repoAuthMethod && { auth: repoAuthMethod }),
-            };
+        // Next steps
+        console.log('');
+        console.log(chalk_1.default.bold('Next steps:'));
+        console.log(chalk_1.default.dim(`  1. Review and edit ${CONFIG_FILENAME}`));
+        console.log(chalk_1.default.dim(`  2. Add secrets to ${ENV_FILENAME}`));
+        console.log(chalk_1.default.dim(`  3. Run 'genbox profiles' to see available profiles`));
+        console.log(chalk_1.default.dim(`  4. Run 'genbox create <name> --profile <profile>' to create an environment`));
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+            console.log('');
+            console.log(chalk_1.default.dim('Cancelled.'));
+            process.exit(0);
         }
-        const config = {
-            version: '1.0',
-            project_name: project_name,
-            system: {
-                languages: info.languages,
-                server_size: server_size,
+        throw error;
+    }
+});
+/**
+ * Create default profiles (sync version for non-interactive mode)
+ */
+function createDefaultProfilesSync(scan, config) {
+    return createProfilesFromScan(scan);
+}
+async function createDefaultProfiles(scan, config) {
+    return createProfilesFromScan(scan);
+}
+function createProfilesFromScan(scan) {
+    const profiles = {};
+    const frontendApps = scan.apps.filter(a => a.type === 'frontend');
+    const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+    const hasApi = scan.apps.some(a => a.name === 'api' || a.type === 'backend');
+    // Quick UI profiles for each frontend
+    for (const frontend of frontendApps.slice(0, 3)) {
+        profiles[`${frontend.name}-quick`] = {
+            description: `${frontend.name} only, connected to staging`,
+            size: 'small',
+            apps: [frontend.name],
+            connect_to: 'staging',
+        };
+    }
+    // Full local development
+    if (hasApi && frontendApps.length > 0) {
+        const primaryFrontend = frontendApps[0];
+        profiles[`${primaryFrontend.name}-full`] = {
+            description: `${primaryFrontend.name} + local API + DB copy`,
+            size: 'large',
+            apps: [primaryFrontend.name, 'api'],
+            database: {
+                mode: 'copy',
+                source: 'staging',
             },
-            scripts: [...selectedScripts, ...extraScripts],
-            repos: reposConfig,
-            files: [],
-            hooks: {
-                post_checkout: info.languages.node ? ['npm install'] : [],
+        };
+    }
+    // API development only
+    if (hasApi) {
+        profiles['api-dev'] = {
+            description: 'API with local infrastructure',
+            size: 'medium',
+            apps: ['api'],
+            database: {
+                mode: 'local',
             },
-            ...(gitAuth && { git_auth: gitAuth }),
         };
-        (0, config_1.saveConfig)(config);
-        console.log(chalk_1.default.green(`\n✔ Configuration saved to genbox.yaml`));
-        // 5. Generate .env.genbox file
-        if (!(0, config_1.hasEnvFile)()) {
-            // Check for existing .env or .env.local (without reading content yet)
-            const existingEnvFile = (0, config_1.findExistingEnvFile)();
-            if (existingEnvFile) {
-                // Ask consent before reading the file
-                const { copyEnv } = await inquirer_1.default.prompt([{
-                        type: 'confirm',
-                        name: 'copyEnv',
-                        message: `Found ${existingEnvFile}. May we read and copy it to .env.genbox?`,
-                        default: true
-                    }]);
-                if (copyEnv) {
-                    // User consented, now read the content
-                    const content = (0, config_1.readEnvFileContent)(existingEnvFile);
-                    (0, config_1.copyExistingEnvToGenbox)(content, existingEnvFile);
-                    console.log(chalk_1.default.green(`✔ Copied ${existingEnvFile} to .env.genbox`));
-                    console.log(chalk_1.default.dim(`  Review and update ${(0, config_1.getEnvPath)()} as needed`));
+    }
+    // All frontends + staging
+    if (frontendApps.length > 1) {
+        profiles['frontends-staging'] = {
+            description: 'All frontends with staging backend',
+            size: 'medium',
+            apps: frontendApps.map(a => a.name),
+            connect_to: 'staging',
+        };
+    }
+    // Full stack
+    if (scan.apps.length > 1) {
+        profiles['full-stack'] = {
+            description: 'Everything local with DB copy',
+            size: 'xl',
+            apps: scan.apps.filter(a => a.type !== 'library').map(a => a.name),
+            database: {
+                mode: 'copy',
+                source: 'staging',
+            },
+        };
+    }
+    return profiles;
+}
+/**
+ * Setup git authentication
+ */
+async function setupGitAuth(gitInfo, projectName) {
+    console.log('');
+    console.log(chalk_1.default.blue('=== Git Repository Setup ==='));
+    console.log(chalk_1.default.dim(`Detected: ${gitInfo.remote}`));
+    const authMethod = await prompts.select({
+        message: 'How should genbox access this repository?',
+        choices: [
+            { name: 'Personal Access Token (PAT) - recommended', value: 'token' },
+            { name: 'SSH Key', value: 'ssh' },
+            { name: 'Public (no auth needed)', value: 'public' },
+        ],
+        default: 'token',
+    });
+    let repoUrl = gitInfo.remote;
+    let git_auth;
+    if (authMethod === 'token') {
+        // Convert SSH to HTTPS if needed
+        if (gitInfo.type === 'ssh') {
+            repoUrl = (0, scan_1.sshToHttps)(gitInfo.remote);
+            console.log(chalk_1.default.dim(`  Will use HTTPS: ${repoUrl}`));
+        }
+        git_auth = { method: 'token' };
+        // Show token setup instructions
+        console.log('');
+        console.log(chalk_1.default.yellow('  Add your token to .env.genbox:'));
+        console.log(chalk_1.default.white('    GIT_TOKEN=ghp_xxxxxxxxxxxx'));
+    }
+    else if (authMethod === 'ssh') {
+        // Convert HTTPS to SSH if needed
+        if (gitInfo.type === 'https') {
+            repoUrl = (0, scan_1.httpsToSsh)(gitInfo.remote);
+            console.log(chalk_1.default.dim(`  Will use SSH: ${repoUrl}`));
+        }
+        // Detect SSH keys
+        const scanKeys = await prompts.confirm({
+            message: 'Scan ~/.ssh/ for available keys?',
+            default: true,
+        });
+        let sshKeyPath = path_1.default.join(os.homedir(), '.ssh', 'id_ed25519');
+        if (scanKeys) {
+            const keys = (0, scan_1.detectSshKeys)();
+            if (keys.length > 0) {
+                const keyChoices = keys.map((k) => ({
+                    name: `${k.name} (${k.type})`,
+                    value: k.path,
+                }));
+                sshKeyPath = await prompts.select({
+                    message: 'Select SSH key:',
+                    choices: keyChoices,
+                });
+            }
+        }
+        git_auth = { method: 'ssh', ssh_key_path: sshKeyPath };
+        console.log('');
+        console.log(chalk_1.default.yellow('  Add your SSH key to .env.genbox:'));
+        console.log(chalk_1.default.white(`    GIT_SSH_KEY="$(cat ${sshKeyPath})"`));
+    }
+    const repoName = path_1.default.basename(repoUrl, '.git');
+    return {
+        repos: {
+            [repoName]: {
+                url: repoUrl,
+                path: `/home/dev/${repoName}`,
+                auth: authMethod === 'public' ? undefined : authMethod,
+            },
+        },
+        git_auth,
+    };
+}
+/**
+ * Setup staging/production environments
+ */
+async function setupEnvironments(scan, config, isMultiRepo = false) {
+    const setupEnvs = await prompts.confirm({
+        message: 'Configure staging/production environments?',
+        default: true,
+    });
+    if (!setupEnvs) {
+        return undefined;
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Environment Setup ==='));
+    console.log(chalk_1.default.dim('These URLs will be used when connecting to external services.'));
+    console.log(chalk_1.default.dim('Actual secrets go in .env.genbox'));
+    console.log('');
+    const environments = {};
+    if (isMultiRepo) {
+        // For multi-repo: configure API URLs per backend app
+        const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+        if (backendApps.length > 0) {
+            console.log(chalk_1.default.dim('Configure staging API URLs for each backend service:'));
+            const stagingApi = {};
+            for (const app of backendApps) {
+                const url = await prompts.input({
+                    message: `  ${app.name} staging URL (leave empty to skip):`,
+                    default: '',
+                });
+                if (url) {
+                    stagingApi[app.name] = url;
                 }
-                else {
-                    // User declined to copy, offer to create template instead
-                    const { createTemplate } = await inquirer_1.default.prompt([{
-                            type: 'confirm',
-                            name: 'createTemplate',
-                            message: 'Create .env.genbox with template variables instead?',
-                            default: true
-                        }]);
-                    if (createTemplate) {
-                        const envTemplate = (0, config_1.generateEnvTemplate)(project_name);
-                        (0, config_1.saveEnvVars)(envTemplate);
-                        console.log(chalk_1.default.green(`✔ Created .env.genbox with template variables`));
-                        console.log(chalk_1.default.yellow(`  Edit ${(0, config_1.getEnvPath)()} with your actual values`));
+            }
+            if (Object.keys(stagingApi).length > 0) {
+                environments.staging = {
+                    description: 'Staging environment',
+                    api: stagingApi,
+                    mongodb: { url: '${STAGING_MONGODB_URL}' },
+                    redis: { url: '${STAGING_REDIS_URL}' },
+                };
+            }
+        }
+        else {
+            // No backend apps, just ask for a single URL
+            const stagingApiUrl = await prompts.input({
+                message: 'Staging API URL (leave empty to skip):',
+                default: '',
+            });
+            if (stagingApiUrl) {
+                environments.staging = {
+                    description: 'Staging environment',
+                    api: { gateway: stagingApiUrl },
+                    mongodb: { url: '${STAGING_MONGODB_URL}' },
+                    redis: { url: '${STAGING_REDIS_URL}' },
+                };
+            }
+        }
+    }
+    else {
+        // Single repo: simple single URL
+        const stagingApiUrl = await prompts.input({
+            message: 'Staging API URL (leave empty to skip):',
+            default: '',
+        });
+        if (stagingApiUrl) {
+            environments.staging = {
+                description: 'Staging environment',
+                api: { gateway: stagingApiUrl },
+                mongodb: { url: '${STAGING_MONGODB_URL}' },
+                redis: { url: '${STAGING_REDIS_URL}' },
+            };
+        }
+    }
+    const setupProd = await prompts.confirm({
+        message: 'Also configure production environment?',
+        default: false,
+    });
+    if (setupProd) {
+        if (isMultiRepo) {
+            const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+            if (backendApps.length > 0) {
+                console.log(chalk_1.default.dim('Configure production API URLs for each backend service:'));
+                const prodApi = {};
+                for (const app of backendApps) {
+                    const url = await prompts.input({
+                        message: `  ${app.name} production URL:`,
+                        default: '',
+                    });
+                    if (url) {
+                        prodApi[app.name] = url;
                     }
                 }
-            }
-            else {
-                // No existing .env file, create template
-                const { createEnv } = await inquirer_1.default.prompt([{
-                        type: 'confirm',
-                        name: 'createEnv',
-                        message: 'Create .env.genbox file for sensitive environment variables?',
-                        default: true
-                    }]);
-                if (createEnv) {
-                    const envTemplate = (0, config_1.generateEnvTemplate)(project_name);
-                    (0, config_1.saveEnvVars)(envTemplate);
-                    console.log(chalk_1.default.green(`✔ Created .env.genbox with template variables`));
-                    console.log(chalk_1.default.yellow(`  Edit ${(0, config_1.getEnvPath)()} with your actual values`));
+                if (Object.keys(prodApi).length > 0) {
+                    environments.production = {
+                        description: 'Production (use with caution)',
+                        api: prodApi,
+                        mongodb: {
+                            url: '${PROD_MONGODB_URL}',
+                            read_only: true,
+                        },
+                    };
                 }
             }
-            // Add .env.genbox to .gitignore if it exists
-            if ((0, config_1.hasEnvFile)()) {
-                console.log(chalk_1.default.dim(`  Remember: Don't commit .env.genbox to version control!`));
-                const gitignorePath = path_1.default.join(process.cwd(), '.gitignore');
-                if (fs_1.default.existsSync(gitignorePath)) {
-                    const gitignoreContent = fs_1.default.readFileSync(gitignorePath, 'utf8');
-                    if (!gitignoreContent.includes('.env.genbox')) {
-                        fs_1.default.appendFileSync(gitignorePath, '\n# Genbox environment variables (sensitive)\n.env.genbox\n');
-                        console.log(chalk_1.default.dim(`  Added .env.genbox to .gitignore`));
-                    }
+        }
+        else {
+            const prodApiUrl = await prompts.input({
+                message: 'Production API URL:',
+                default: '',
+            });
+            if (prodApiUrl) {
+                environments.production = {
+                    description: 'Production (use with caution)',
+                    api: { gateway: prodApiUrl },
+                    mongodb: {
+                        url: '${PROD_MONGODB_URL}',
+                        read_only: true,
+                    },
+                };
+            }
+        }
+    }
+    return Object.keys(environments).length > 0 ? environments : undefined;
+}
+/**
+ * Setup .env.genbox file
+ */
+async function setupEnvFile(projectName, config, nonInteractive = false, scan, isMultiRepo = false) {
+    const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
+    if (fs_1.default.existsSync(envPath)) {
+        console.log(chalk_1.default.dim(`  ${ENV_FILENAME} already exists, skipping...`));
+        return;
+    }
+    // For multi-repo: find env files in app directories
+    if (isMultiRepo && scan) {
+        const appEnvFiles = findAppEnvFiles(scan.apps, process.cwd());
+        if (appEnvFiles.length > 0 && !nonInteractive) {
+            console.log('');
+            console.log(chalk_1.default.blue('=== Environment Files ==='));
+            console.log(chalk_1.default.dim(`Found .env files in ${appEnvFiles.length} app directories`));
+            const envChoices = appEnvFiles.map(env => ({
+                name: `${env.appName}/${env.envFile}`,
+                value: env.fullPath,
+                checked: true,
+            }));
+            const selectedEnvFiles = await prompts.checkbox({
+                message: 'Select .env files to merge into .env.genbox:',
+                choices: envChoices,
+            });
+            if (selectedEnvFiles.length > 0) {
+                let mergedContent = `# Genbox Environment Variables
+# Merged from: ${selectedEnvFiles.map(f => path_1.default.relative(process.cwd(), f)).join(', ')}
+# DO NOT COMMIT THIS FILE
+#
+# Add staging/production URLs:
+# STAGING_MONGODB_URL=mongodb+srv://...
+# STAGING_REDIS_URL=redis://...
+# PROD_MONGODB_URL=mongodb+srv://...
+#
+# Git authentication:
+# GIT_TOKEN=ghp_xxxxxxxxxxxx
+
+`;
+                for (const envFilePath of selectedEnvFiles) {
+                    const appInfo = appEnvFiles.find(e => e.fullPath === envFilePath);
+                    const content = fs_1.default.readFileSync(envFilePath, 'utf8');
+                    mergedContent += `\n# === ${appInfo?.appName || path_1.default.dirname(envFilePath)} ===\n`;
+                    mergedContent += content;
+                    mergedContent += '\n';
                 }
+                fs_1.default.writeFileSync(envPath, mergedContent);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${selectedEnvFiles.length} app env files`));
+            }
+        }
+        else if (appEnvFiles.length > 0 && nonInteractive) {
+            // Non-interactive: merge all env files
+            let mergedContent = `# Genbox Environment Variables
+# Merged from app directories
+# DO NOT COMMIT THIS FILE
+
+`;
+            for (const envFile of appEnvFiles) {
+                const content = fs_1.default.readFileSync(envFile.fullPath, 'utf8');
+                mergedContent += `\n# === ${envFile.appName} ===\n`;
+                mergedContent += content;
+                mergedContent += '\n';
+            }
+            fs_1.default.writeFileSync(envPath, mergedContent);
+            console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${appEnvFiles.length} app env files`));
+        }
+    }
+    // If no env file created yet, check for root .env
+    if (!fs_1.default.existsSync(envPath)) {
+        const existingEnvFiles = ['.env.local', '.env', '.env.development'];
+        let existingEnvPath;
+        for (const envFile of existingEnvFiles) {
+            const fullPath = path_1.default.join(process.cwd(), envFile);
+            if (fs_1.default.existsSync(fullPath)) {
+                existingEnvPath = fullPath;
+                break;
+            }
+        }
+        if (existingEnvPath) {
+            const copyExisting = nonInteractive ? true : await prompts.confirm({
+                message: `Found ${path_1.default.basename(existingEnvPath)}. Copy to ${ENV_FILENAME}?`,
+                default: true,
+            });
+            if (copyExisting) {
+                const content = fs_1.default.readFileSync(existingEnvPath, 'utf8');
+                const header = `# Genbox Environment Variables
+# Generated from ${path_1.default.basename(existingEnvPath)}
+# DO NOT COMMIT THIS FILE
+#
+# Add staging/production URLs:
+# STAGING_MONGODB_URL=mongodb+srv://...
+# STAGING_REDIS_URL=redis://...
+# PROD_MONGODB_URL=mongodb+srv://...
+#
+# Git authentication:
+# GIT_TOKEN=ghp_xxxxxxxxxxxx
+
+`;
+                fs_1.default.writeFileSync(envPath, header + content);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${path_1.default.basename(existingEnvPath)}`));
             }
         }
         else {
-            console.log(chalk_1.default.dim(`  .env.genbox already exists, skipping...`));
+            const createEnv = nonInteractive ? true : await prompts.confirm({
+                message: `Create ${ENV_FILENAME} template?`,
+                default: true,
+            });
+            if (createEnv) {
+                const template = generateEnvTemplate(projectName, config);
+                fs_1.default.writeFileSync(envPath, template);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} template`));
+            }
         }
-        // Add GIT_TOKEN entry if PAT auth was selected
-        if (repoAuthMethod === 'token' && (0, config_1.hasEnvFile)()) {
-            (0, config_1.ensureGitTokenInEnv)();
-            console.log(chalk_1.default.dim(`  Added GIT_TOKEN entry to .env.genbox`));
+    }
+    // Add to .gitignore
+    const gitignorePath = path_1.default.join(process.cwd(), '.gitignore');
+    if (fs_1.default.existsSync(gitignorePath)) {
+        const content = fs_1.default.readFileSync(gitignorePath, 'utf8');
+        if (!content.includes(ENV_FILENAME)) {
+            fs_1.default.appendFileSync(gitignorePath, `\n# Genbox secrets\n${ENV_FILENAME}\n`);
+            console.log(chalk_1.default.dim(`  Added ${ENV_FILENAME} to .gitignore`));
         }
-        console.log('');
-        console.log(chalk_1.default.bold('Next steps:'));
-        console.log(chalk_1.default.dim(`  1. Edit genbox.yaml to configure services, repos, etc.`));
-        console.log(chalk_1.default.dim(`  2. Edit .env.genbox with your environment variables`));
-        console.log(chalk_1.default.dim(`  3. Run 'genbox push' to upload configuration to the cloud`));
-        console.log(chalk_1.default.dim(`  4. Run 'genbox create <name>' to provision a dev environment`));
     }
-    catch (error) {
-        // Handle user cancellation (Ctrl+C) gracefully
-        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
-            console.log('');
-            console.log(chalk_1.default.dim('Cancelled.'));
-            process.exit(0);
+}
+/**
+ * Generate .env.genbox template
+ */
+function generateEnvTemplate(projectName, config) {
+    const lines = [
+        '# Genbox Environment Variables',
+        `# Project: ${projectName}`,
+        '# DO NOT COMMIT THIS FILE',
+        '',
+        '# ============================================',
+        '# STAGING ENVIRONMENT',
+        '# ============================================',
+        '',
+        '# Database',
+        'STAGING_MONGODB_URL=mongodb+srv://user:password@staging.mongodb.net',
+        '',
+        '# Cache & Queue',
+        'STAGING_REDIS_URL=redis://staging-redis:6379',
+        'STAGING_RABBITMQ_URL=amqp://user:password@staging-rabbitmq:5672',
+        '',
+        '# ============================================',
+        '# PRODUCTION ENVIRONMENT',
+        '# ============================================',
+        '',
+        'PROD_MONGODB_URL=mongodb+srv://readonly:password@prod.mongodb.net',
+        '',
+        '# ============================================',
+        '# GIT AUTHENTICATION',
+        '# ============================================',
+        '',
+        '# For HTTPS repos (Personal Access Token)',
+        'GIT_TOKEN=ghp_xxxxxxxxxxxx',
+        '',
+        '# For SSH repos (paste private key content)',
+        '# GIT_SSH_KEY="-----BEGIN OPENSSH PRIVATE KEY-----',
+        '# ...',
+        '# -----END OPENSSH PRIVATE KEY-----"',
+        '',
+        '# ============================================',
+        '# APPLICATION SECRETS',
+        '# ============================================',
+        '',
+        'JWT_SECRET=your-jwt-secret-here',
+        '',
+        '# OAuth',
+        'GOOGLE_CLIENT_ID=',
+        'GOOGLE_CLIENT_SECRET=',
+        '',
+        '# Payments',
+        'STRIPE_SECRET_KEY=sk_test_xxx',
+        'STRIPE_WEBHOOK_SECRET=whsec_xxx',
+        '',
+    ];
+    return lines.join('\n');
+}
+/**
+ * Convert GenboxConfigV2 to GenboxConfigV3 format
+ */
+function convertV2ToV3(v2Config, scan) {
+    // Convert services to apps
+    const apps = {};
+    for (const [name, service] of Object.entries(v2Config.services || {})) {
+        const appConfig = {
+            path: service.path || `/home/dev/${v2Config.project.name}/${name}`,
+            type: service.type === 'api' ? 'backend' : service.type,
+            port: service.port,
+        };
+        // Only add framework if defined
+        if (service.framework) {
+            appConfig.framework = service.framework;
         }
-        // Re-throw other errors
-        throw error;
+        // Only add requires if there are dependencies
+        if (service.dependsOn?.length) {
+            appConfig.requires = service.dependsOn.reduce((acc, dep) => {
+                acc[dep] = 'required';
+                return acc;
+            }, {});
+        }
+        // Build commands object without undefined values
+        const commands = {};
+        if (service.build?.command)
+            commands.build = service.build.command;
+        if (service.start?.command)
+            commands.start = service.start.command;
+        if (service.start?.dev)
+            commands.dev = service.start.dev;
+        if (Object.keys(commands).length > 0) {
+            appConfig.commands = commands;
+        }
+        // Only add env if defined
+        if (service.env?.length) {
+            appConfig.env = service.env;
+        }
+        apps[name] = appConfig;
     }
-});
+    // Convert infrastructure
+    const infrastructure = {};
+    if (v2Config.infrastructure?.databases) {
+        for (const db of v2Config.infrastructure.databases) {
+            infrastructure[db.container || db.type] = {
+                type: 'database',
+                image: `${db.type}:latest`,
+                port: db.port,
+            };
+        }
+    }
+    if (v2Config.infrastructure?.caches) {
+        for (const cache of v2Config.infrastructure.caches) {
+            infrastructure[cache.container || cache.type] = {
+                type: 'cache',
+                image: `${cache.type}:latest`,
+                port: cache.port,
+            };
+        }
+    }
+    if (v2Config.infrastructure?.queues) {
+        for (const queue of v2Config.infrastructure.queues) {
+            infrastructure[queue.container || queue.type] = {
+                type: 'queue',
+                image: `${queue.type}:latest`,
+                port: queue.port,
+                management_port: queue.managementPort,
+            };
+        }
+    }
+    // Convert repos
+    const repos = {};
+    for (const [name, repo] of Object.entries(v2Config.repos || {})) {
+        repos[name] = {
+            url: repo.url,
+            path: repo.path,
+            branch: repo.branch,
+            auth: repo.auth,
+        };
+    }
+    // Build v3 config
+    const v3Config = {
+        version: '3.0',
+        project: {
+            name: v2Config.project.name,
+            structure: v2Config.project.structure === 'single-app' ? 'single-app' :
+                v2Config.project.structure.startsWith('monorepo') ? 'monorepo' :
+                    v2Config.project.structure,
+            description: v2Config.project.description,
+        },
+        apps,
+        infrastructure: Object.keys(infrastructure).length > 0 ? infrastructure : undefined,
+        repos: Object.keys(repos).length > 0 ? repos : undefined,
+        defaults: {
+            size: v2Config.system.size,
+        },
+        hooks: v2Config.hooks ? {
+            post_checkout: v2Config.hooks.postCheckout,
+            post_start: v2Config.hooks.postStart,
+            pre_start: v2Config.hooks.preStart,
+        } : undefined,
+    };
+    return v3Config;
+}