genbox 1.0.46 → 1.0.48

package/dist/commands/init.js

@@ -1,4 +1,17 @@
 "use strict";
+/**
+ * Unified Init Command (v4)
+ *
+ * Combines scanning, configuration, and initialization into a single flow:
+ * 1. Scan project structure
+ * 2. App selection and editing
+ * 3. Project settings (name, size, branch)
+ * 4. Git auth setup
+ * 5. Script selection
+ * 6. Environment + Service URL configuration
+ * 7. Profile generation and editing
+ * 8. Generate genbox.yaml and .env.genbox
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -45,1342 +58,623 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 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");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require('../../package.json');
 const CONFIG_FILENAME = 'genbox.yaml';
 const ENV_FILENAME = '.env.genbox';
+const DETECTED_DIR = '.genbox';
+const DETECTED_FILENAME = 'detected.yaml';
+// =============================================================================
+// Scan Phase
+// =============================================================================
 /**
- * Extract unique HTTP URLs from frontend app sections in .env.genbox content
- * Catches both localhost URLs and Docker internal service references
+ * Scan project and convert to DetectedConfig
  */
-function extractFrontendHttpUrls(envContent, frontendApps) {
-    const serviceUrls = new Map();
-    // Parse sections
-    const sections = new Map();
-    let currentSection = 'GLOBAL';
-    let currentContent = [];
-    for (const line of envContent.split('\n')) {
-        const sectionMatch = line.match(/^# === ([^=]+) ===$/);
-        if (sectionMatch) {
-            if (currentContent.length > 0) {
-                sections.set(currentSection, currentContent.join('\n'));
-            }
-            currentSection = sectionMatch[1].trim();
-            currentContent = [];
-        }
-        else {
-            currentContent.push(line);
+async function scanProject(rootDir, exclude = []) {
+    const scanner = new scanner_1.ProjectScanner();
+    const scan = await scanner.scan(rootDir, { exclude, skipScripts: false });
+    return convertScanToDetected(scan, rootDir);
+}
+/**
+ * Convert ProjectScan to DetectedConfig format
+ */
+function convertScanToDetected(scan, root) {
+    const detected = {
+        _meta: {
+            generated_at: new Date().toISOString(),
+            genbox_version: version,
+            scanned_root: root,
+        },
+        structure: {
+            type: mapStructureType(scan.structure.type),
+            confidence: scan.structure.confidence || 'medium',
+            indicators: scan.structure.indicators || [],
+        },
+        runtimes: scan.runtimes.map(r => ({
+            language: r.language,
+            version: r.version,
+            version_source: r.versionSource,
+            package_manager: r.packageManager,
+            lockfile: r.lockfile,
+        })),
+        apps: {},
+    };
+    // Convert apps
+    const isMultiRepo = scan.structure.type === 'hybrid';
+    for (const app of scan.apps) {
+        const mappedType = mapAppType(app.type);
+        let appGit = undefined;
+        if (isMultiRepo) {
+            appGit = detectGitForDirectory(path_1.default.join(root, app.path));
         }
+        const { runner, runner_reason } = detectRunner(app, scan);
+        detected.apps[app.name] = {
+            path: app.path,
+            type: mappedType,
+            type_reason: inferTypeReason(app),
+            runner,
+            runner_reason,
+            port: app.port,
+            port_source: app.port ? inferPortSource(app) : undefined,
+            framework: app.framework,
+            framework_source: app.framework ? 'package.json dependencies' : undefined,
+            commands: app.scripts ? {
+                dev: app.scripts.dev,
+                build: app.scripts.build,
+                start: app.scripts.start,
+            } : undefined,
+            dependencies: app.dependencies,
+            git: appGit,
+        };
     }
-    if (currentContent.length > 0) {
-        sections.set(currentSection, currentContent.join('\n'));
-    }
-    // Only process frontend app sections
-    for (const appName of frontendApps) {
-        const appSection = sections.get(appName);
-        if (!appSection)
-            continue;
-        // Find all HTTP URLs
-        // Match: VAR_NAME="http://host:port/path" or VAR_NAME=http://host:port/path
-        const urlRegex = /^([A-Z_][A-Z0-9_]*)=["']?(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?[^"'\s]*)["']?/gm;
-        let match;
-        while ((match = urlRegex.exec(appSection)) !== null) {
-            const varName = match[1];
-            const fullUrl = match[2];
-            // Extract hostname from URL
-            const hostMatch = fullUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)/);
-            if (!hostMatch)
-                continue;
-            const hostname = hostMatch[1];
-            // Only include URLs that look like local/development URLs:
-            // - localhost
-            // - Single-word hosts (Docker internal names like "auth", "gateway", "redis")
-            // - IP addresses
-            const isLocalUrl = hostname === 'localhost' ||
-                !hostname.includes('.') || // No dots = likely Docker internal name
-                /^\d+\.\d+\.\d+\.\d+$/.test(hostname); // IP address
-            if (!isLocalUrl) {
-                continue;
-            }
-            // Extract base URL (protocol + host + port)
-            const baseMatch = fullUrl.match(/^(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?)/);
-            if (!baseMatch)
-                continue;
-            const baseUrl = baseMatch[1];
-            // Group by base URL
-            if (!serviceUrls.has(baseUrl)) {
-                serviceUrls.set(baseUrl, { urls: new Set(), vars: [] });
-            }
-            serviceUrls.get(baseUrl).urls.add(fullUrl);
-            if (!serviceUrls.get(baseUrl).vars.includes(varName)) {
-                serviceUrls.get(baseUrl).vars.push(varName);
+    // Convert infrastructure
+    if (scan.compose) {
+        detected.infrastructure = [];
+        for (const db of scan.compose.databases || []) {
+            detected.infrastructure.push({
+                name: db.name,
+                type: 'database',
+                image: db.image || 'unknown',
+                port: db.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+        for (const cache of scan.compose.caches || []) {
+            detected.infrastructure.push({
+                name: cache.name,
+                type: 'cache',
+                image: cache.image || 'unknown',
+                port: cache.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+        for (const queue of scan.compose.queues || []) {
+            detected.infrastructure.push({
+                name: queue.name,
+                type: 'queue',
+                image: queue.image || 'unknown',
+                port: queue.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+        // Add Docker application services as apps with runner: 'docker'
+        if (scan.compose.applications && scan.compose.applications.length > 0) {
+            for (const dockerApp of scan.compose.applications) {
+                if (detected.apps[dockerApp.name])
+                    continue;
+                const { type: mappedType, reason: typeReason } = inferDockerAppType(dockerApp.name, dockerApp.build?.context, root);
+                detected.apps[dockerApp.name] = {
+                    path: dockerApp.build?.context || '.',
+                    type: mappedType,
+                    type_reason: typeReason,
+                    runner: 'docker',
+                    runner_reason: 'defined in docker-compose.yml',
+                    docker: {
+                        service: dockerApp.name,
+                        build_context: dockerApp.build?.context,
+                        dockerfile: dockerApp.build?.dockerfile,
+                        image: dockerApp.image,
+                    },
+                    port: dockerApp.ports?.[0]?.host,
+                    port_source: 'docker-compose.yml ports',
+                };
             }
         }
     }
-    return serviceUrls;
-}
-/**
- * Determine service name from URL (hostname or port)
- * Generates variable prefix from hostname or port number
- */
-function getServiceNameFromUrl(baseUrl) {
-    // Parse the URL
-    const urlMatch = baseUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)(?::(\d+))?/);
-    if (!urlMatch) {
-        return { name: 'unknown', varPrefix: 'UNKNOWN', description: 'Unknown Service' };
-    }
-    const hostname = urlMatch[1];
-    const port = urlMatch[2] ? parseInt(urlMatch[2]) : undefined;
-    // Generate from hostname if not localhost
-    if (hostname !== 'localhost') {
-        const varPrefix = hostname.toUpperCase().replace(/-/g, '_');
-        return {
-            name: hostname,
-            varPrefix: `${varPrefix}`,
-            description: `${hostname} service`
+    // Git info
+    if (scan.git) {
+        detected.git = {
+            remote: scan.git.remote,
+            type: scan.git.type,
+            provider: scan.git.provider,
+            branch: scan.git.branch,
         };
     }
-    // Generate from port for localhost URLs
-    if (port) {
-        return {
-            name: `port-${port}`,
-            varPrefix: `PORT_${port}`,
-            description: `localhost:${port}`
-        };
+    // Scripts
+    if (scan.scripts && scan.scripts.length > 0) {
+        detected.scripts = scan.scripts.map(s => ({
+            name: s.name,
+            path: s.path,
+            stage: s.stage,
+            stage_reason: inferStageReason(s),
+            executable: s.isExecutable,
+        }));
     }
-    return { name: 'unknown', varPrefix: 'UNKNOWN', description: 'Unknown Service' };
+    return detected;
 }
 /**
- * Create service URL mappings based on configured environments
- * Uses URLs from configured environments instead of prompting again
+ * Load existing detected.yaml if present
  */
-async function createServiceUrlMappings(serviceUrls, configuredEnvs) {
-    const mappings = [];
-    if (serviceUrls.size === 0) {
-        return mappings;
+function loadDetectedConfig(rootDir) {
+    const detectedPath = path_1.default.join(rootDir, DETECTED_DIR, DETECTED_FILENAME);
+    if (!fs_1.default.existsSync(detectedPath))
+        return null;
+    try {
+        const content = fs_1.default.readFileSync(detectedPath, 'utf8');
+        return yaml.load(content);
     }
-    // Determine which environment to use (prefer staging, then production)
-    const envNames = Object.keys(configuredEnvs || {});
-    const primaryEnv = envNames.includes('staging') ? 'staging' :
-        envNames.includes('production') ? 'production' :
-            envNames[0];
-    if (!primaryEnv || !configuredEnvs?.[primaryEnv]) {
-        // No environments configured - skip service URL mapping
-        return mappings;
-    }
-    const envConfig = configuredEnvs[primaryEnv];
-    const apiUrl = envConfig.urls?.api;
-    if (!apiUrl) {
-        // No API URL configured - skip
-        return mappings;
-    }
-    // Sort by port number for consistent ordering
-    const sortedServices = Array.from(serviceUrls.entries()).sort((a, b) => {
-        const portA = parseInt(a[0].match(/:(\d+)/)?.[1] || '0');
-        const portB = parseInt(b[0].match(/:(\d+)/)?.[1] || '0');
-        return portA - portB;
-    });
-    console.log('');
-    console.log(chalk_1.default.blue('=== Service URL Mapping ==='));
-    console.log(chalk_1.default.dim(`Mapping localhost URLs to ${primaryEnv} environment`));
-    console.log('');
-    for (const [baseUrl, { vars }] of sortedServices) {
-        const serviceInfo = getServiceNameFromUrl(baseUrl);
-        // Auto-map API/gateway URLs to the configured API URL
-        const isApiService = serviceInfo.name === 'gateway' ||
-            baseUrl.includes(':3050') ||
-            baseUrl.includes(':3105') ||
-            vars.some(v => v.toLowerCase().includes('api'));
-        if (isApiService && apiUrl) {
-            console.log(chalk_1.default.green(`✓ ${serviceInfo.description}: ${baseUrl} → ${apiUrl}`));
-            mappings.push({
-                varName: `${serviceInfo.varPrefix}_URL`,
-                localUrl: baseUrl,
-                remoteUrl: apiUrl,
-                remoteEnv: primaryEnv,
-                description: serviceInfo.description,
-            });
-        }
-        else {
-            // For non-API services, just record the local URL without remote
-            console.log(chalk_1.default.dim(`  ${serviceInfo.description}: ${baseUrl} (local only)`));
-            mappings.push({
-                varName: `${serviceInfo.varPrefix}_URL`,
-                localUrl: baseUrl,
-                description: serviceInfo.description,
-            });
-        }
+    catch {
+        return null;
     }
-    return mappings;
 }
 /**
- * Transform .env.genbox content to use expandable variables
+ * Save detected config to .genbox/detected.yaml
  */
-function transformEnvWithVariables(envContent, mappings, frontendApps) {
-    if (mappings.length === 0) {
-        return envContent;
-    }
-    let result = envContent;
-    // Determine the environment name for comments
-    const envName = mappings.find(m => m.remoteEnv)?.remoteEnv?.toUpperCase() || 'REMOTE';
-    // Build GLOBAL section additions
-    const globalAdditions = [
-        '',
-        '# Service URL Configuration',
-        `# These expand based on profile: \${GATEWAY_URL} → LOCAL or ${envName} value`,
-    ];
-    for (const mapping of mappings) {
-        globalAdditions.push(`LOCAL_${mapping.varName}=${mapping.localUrl}`);
-        if (mapping.remoteUrl && mapping.remoteEnv) {
-            const prefix = mapping.remoteEnv.toUpperCase();
-            globalAdditions.push(`${prefix}_${mapping.varName}=${mapping.remoteUrl}`);
-        }
+function saveDetectedConfig(rootDir, detected) {
+    const genboxDir = path_1.default.join(rootDir, DETECTED_DIR);
+    if (!fs_1.default.existsSync(genboxDir)) {
+        fs_1.default.mkdirSync(genboxDir, { recursive: true });
     }
-    globalAdditions.push('');
-    // Insert after GLOBAL section header and existing content
-    const globalInsertPoint = result.indexOf('# === GLOBAL ===');
-    if (globalInsertPoint !== -1) {
-        // Find the next section or end of GLOBAL
-        const nextSectionMatch = result.substring(globalInsertPoint + 20).match(/\n# === [^=]+ ===/);
-        const insertAt = nextSectionMatch
-            ? globalInsertPoint + 20 + nextSectionMatch.index
-            : result.length;
-        result = result.substring(0, insertAt) + globalAdditions.join('\n') + result.substring(insertAt);
-    }
-    // Replace localhost URLs with variable syntax in frontend app sections
-    // Parse sections again after modification
-    const lines = result.split('\n');
-    const transformedLines = [];
-    let currentSection = 'GLOBAL';
-    let inFrontendSection = false;
-    for (const line of lines) {
-        const sectionMatch = line.match(/^# === ([^=]+) ===$/);
-        if (sectionMatch) {
-            currentSection = sectionMatch[1].trim();
-            inFrontendSection = frontendApps.includes(currentSection);
-            transformedLines.push(line);
-            continue;
-        }
-        if (inFrontendSection && line.includes('http://localhost:')) {
-            // Check if this line matches any of our mappings
-            let transformedLine = line;
-            for (const mapping of mappings) {
-                if (line.includes(mapping.localUrl)) {
-                    // Replace the full URL, preserving any path suffix
-                    const urlPattern = new RegExp(mapping.localUrl.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '(/[^"\'\\s]*)?', 'g');
-                    transformedLine = transformedLine.replace(urlPattern, (match, pathSuffix) => {
-                        return `\${${mapping.varName}}${pathSuffix || ''}`;
-                    });
-                }
-            }
-            transformedLines.push(transformedLine);
-        }
-        else {
-            transformedLines.push(line);
+    // Add .genbox to .gitignore if not already there
+    const gitignorePath = path_1.default.join(rootDir, '.gitignore');
+    if (fs_1.default.existsSync(gitignorePath)) {
+        const gitignore = fs_1.default.readFileSync(gitignorePath, 'utf8');
+        if (!gitignore.includes('.genbox')) {
+            fs_1.default.appendFileSync(gitignorePath, '\n# Genbox generated files\n.genbox/\n');
         }
     }
-    return transformedLines.join('\n');
+    const filePath = path_1.default.join(genboxDir, DETECTED_FILENAME);
+    const content = yaml.dump(detected, { lineWidth: 120, noRefs: true });
+    fs_1.default.writeFileSync(filePath, content);
 }
+// =============================================================================
+// App Configuration
+// =============================================================================
 /**
- * Detect git repositories in app directories (for multi-repo workspaces)
+ * Interactive app selection
  */
-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
+async function selectApps(detected) {
+    const appEntries = Object.entries(detected.apps);
+    if (appEntries.length === 0)
+        return detected;
+    console.log('');
+    console.log(chalk_1.default.blue('=== Detected Apps ==='));
+    console.log('');
+    for (const [name, app] of appEntries) {
+        const parts = [
+            chalk_1.default.cyan(name),
+            app.type ? `(${app.type})` : '',
+            app.framework ? `[${app.framework}]` : '',
+            app.port ? `port:${app.port}` : '',
+            app.runner ? chalk_1.default.dim(`runner:${app.runner}`) : '',
+        ].filter(Boolean);
+        console.log(`  ${parts.join(' ')}`);
+        if (app.git) {
+            console.log(chalk_1.default.dim(`    └─ ${app.git.remote}`));
         }
     }
-    return repos;
+    console.log('');
+    const appChoices = appEntries.map(([name, app]) => ({
+        name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+        value: name,
+        checked: app.type !== 'library',
+    }));
+    const selectedApps = await prompts.checkbox({
+        message: 'Select apps to include:',
+        choices: appChoices,
+    });
+    const filteredApps = {};
+    for (const appName of selectedApps) {
+        filteredApps[appName] = detected.apps[appName];
+    }
+    return { ...detected, apps: filteredApps };
 }
 /**
- * Find .env files in app directories (including nested microservices)
+ * Interactive app editing
  */
-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);
-        // Check for direct .env file in app directory
-        let foundDirectEnv = false;
-        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,
-                });
-                foundDirectEnv = true;
-                break;
-            }
-        }
-        // Check for nested microservices (e.g., api/apps/*)
-        const appsSubdir = path_1.default.join(appDir, 'apps');
-        if (fs_1.default.existsSync(appsSubdir) && fs_1.default.statSync(appsSubdir).isDirectory()) {
-            try {
-                const services = fs_1.default.readdirSync(appsSubdir);
-                for (const service of services) {
-                    const serviceDir = path_1.default.join(appsSubdir, service);
-                    if (!fs_1.default.statSync(serviceDir).isDirectory())
-                        continue;
-                    for (const pattern of envPatterns) {
-                        const envPath = path_1.default.join(serviceDir, pattern);
-                        if (fs_1.default.existsSync(envPath)) {
-                            envFiles.push({
-                                appName: `${app.name}/${service}`,
-                                envFile: pattern,
-                                fullPath: envPath,
-                                isService: true,
-                            });
-                            break;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Ignore errors reading subdirectories
-            }
-        }
+async function editApps(detected) {
+    const appEntries = Object.entries(detected.apps);
+    if (appEntries.length === 0)
+        return detected;
+    const editAppsChoice = await prompts.confirm({
+        message: 'Do you want to edit any app configurations?',
+        default: false,
+    });
+    if (!editAppsChoice)
+        return detected;
+    const appChoices = appEntries.map(([name, app]) => ({
+        name: `${name} (${app.type || 'unknown'}, ${app.runner || 'pm2'})`,
+        value: name,
+    }));
+    const appsToEdit = await prompts.checkbox({
+        message: 'Select apps to edit:',
+        choices: appChoices,
+    });
+    const result = { ...detected, apps: { ...detected.apps } };
+    for (const appName of appsToEdit) {
+        result.apps[appName] = await editSingleApp(appName, result.apps[appName], detected._meta.scanned_root);
     }
-    return envFiles;
+    return result;
 }
 /**
- * Read existing values from .env.genbox file
+ * Edit a single app's configuration
  */
-function readExistingEnvGenbox() {
-    const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
-    const values = {};
-    if (!fs_1.default.existsSync(envPath)) {
-        return values;
+async function editSingleApp(name, app, rootDir) {
+    console.log('');
+    console.log(chalk_1.default.blue(`=== Editing: ${name} ===`));
+    console.log(chalk_1.default.dim('Current values:'));
+    console.log(`  Type:      ${chalk_1.default.cyan(app.type || 'unknown')} ${chalk_1.default.dim(`(${app.type_reason || 'detected'})`)}`);
+    console.log(`  Runner:    ${chalk_1.default.cyan(app.runner || 'pm2')} ${chalk_1.default.dim(`(${app.runner_reason || 'default'})`)}`);
+    console.log(`  Port:      ${app.port ? chalk_1.default.cyan(String(app.port)) : chalk_1.default.dim('not set')} ${app.port_source ? chalk_1.default.dim(`(${app.port_source})`) : ''}`);
+    console.log(`  Framework: ${app.framework ? chalk_1.default.cyan(app.framework) : chalk_1.default.dim('not detected')}`);
+    console.log('');
+    const result = { ...app };
+    // Edit type
+    const typeChoices = [
+        { name: `frontend ${app.type === 'frontend' ? chalk_1.default.green('(current)') : ''}`, value: 'frontend' },
+        { name: `backend ${app.type === 'backend' ? chalk_1.default.green('(current)') : ''}`, value: 'backend' },
+        { name: `worker ${app.type === 'worker' ? chalk_1.default.green('(current)') : ''}`, value: 'worker' },
+        { name: `gateway ${app.type === 'gateway' ? chalk_1.default.green('(current)') : ''}`, value: 'gateway' },
+        { name: `library ${app.type === 'library' ? chalk_1.default.green('(current)') : ''}`, value: 'library' },
+    ];
+    const newType = await prompts.select({
+        message: 'App type:',
+        choices: typeChoices,
+        default: app.type || 'backend',
+    });
+    if (newType !== app.type) {
+        result.type = newType;
+        result.type_reason = 'manually set';
     }
-    try {
-        const content = fs_1.default.readFileSync(envPath, 'utf8');
-        for (const line of content.split('\n')) {
-            // Skip comments and empty lines
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            // Parse KEY=value
-            const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
-            if (match) {
-                let value = match[2].trim();
-                // Remove quotes if present
-                if ((value.startsWith('"') && value.endsWith('"')) ||
-                    (value.startsWith("'") && value.endsWith("'"))) {
-                    value = value.slice(1, -1);
+    // Edit runner
+    const runnerChoices = [
+        { name: `pm2 - Process manager (recommended for Node.js) ${app.runner === 'pm2' ? chalk_1.default.green('(current)') : ''}`, value: 'pm2' },
+        { name: `docker - Docker compose service ${app.runner === 'docker' ? chalk_1.default.green('(current)') : ''}`, value: 'docker' },
+        { name: `bun - Bun runtime ${app.runner === 'bun' ? chalk_1.default.green('(current)') : ''}`, value: 'bun' },
+        { name: `node - Direct Node.js execution ${app.runner === 'node' ? chalk_1.default.green('(current)') : ''}`, value: 'node' },
+        { name: `none - Library/not runnable ${app.runner === 'none' ? chalk_1.default.green('(current)') : ''}`, value: 'none' },
+    ];
+    const newRunner = await prompts.select({
+        message: 'Runner:',
+        choices: runnerChoices,
+        default: app.runner || 'pm2',
+    });
+    if (newRunner !== app.runner) {
+        result.runner = newRunner;
+        result.runner_reason = 'manually set';
+    }
+    // If runner is docker, ask for docker config
+    if (newRunner === 'docker') {
+        const dockerService = await prompts.input({
+            message: 'Docker service name:',
+            default: app.docker?.service || name,
+        });
+        const composeInfo = getDockerComposeServiceInfo(rootDir, dockerService);
+        if (composeInfo) {
+            console.log(chalk_1.default.blue('\n  Detected from docker-compose.yml:'));
+            if (composeInfo.buildContext)
+                console.log(chalk_1.default.dim(`    build context: ${composeInfo.buildContext}`));
+            if (composeInfo.dockerfile)
+                console.log(chalk_1.default.dim(`    dockerfile: ${composeInfo.dockerfile}`));
+            if (composeInfo.port)
+                console.log(chalk_1.default.dim(`    port: ${composeInfo.port}`));
+            if (composeInfo.healthcheck)
+                console.log(chalk_1.default.dim(`    healthcheck: ${composeInfo.healthcheck}`));
+            console.log('');
+        }
+        const defaultContext = composeInfo?.buildContext || app.docker?.build_context || app.path || '.';
+        const dockerContext = await prompts.input({
+            message: 'Docker build context:',
+            default: defaultContext,
+        });
+        const defaultDockerfile = composeInfo?.dockerfile || app.docker?.dockerfile;
+        const dockerfile = defaultDockerfile ? await prompts.input({
+            message: 'Dockerfile:',
+            default: defaultDockerfile,
+        }) : undefined;
+        result.docker = {
+            service: dockerService,
+            build_context: dockerContext,
+            dockerfile: dockerfile || app.docker?.dockerfile,
+        };
+        if (composeInfo?.port) {
+            result.port = composeInfo.port;
+            result.port_source = 'docker-compose.yml';
+        }
+        if (composeInfo?.healthcheck) {
+            result.healthcheck = composeInfo.healthcheck;
+        }
+        if (composeInfo?.dependsOn?.length) {
+            result.depends_on = composeInfo.dependsOn;
+        }
+    }
+    // Edit port (only if not a library)
+    if (newRunner !== 'none' && result.type !== 'library') {
+        const currentPort = result.port;
+        const portDefault = currentPort ? String(currentPort) : '';
+        const portInput = await prompts.input({
+            message: currentPort ? `Port (detected: ${currentPort}, press Enter to keep):` : 'Port (leave empty to skip):',
+            default: portDefault,
+        });
+        if (portInput) {
+            const portNum = parseInt(portInput, 10);
+            if (!isNaN(portNum) && portNum > 0 && portNum < 65536) {
+                if (portNum !== currentPort) {
+                    result.port = portNum;
+                    result.port_source = 'manually set';
                 }
-                values[match[1]] = value;
             }
         }
     }
-    catch {
-        // Ignore read errors
+    // Edit framework
+    const frameworkChoices = [
+        { name: `Keep current: ${app.framework || 'none'}`, value: app.framework || '' },
+        { name: 'nextjs', value: 'nextjs' },
+        { name: 'react', value: 'react' },
+        { name: 'vue', value: 'vue' },
+        { name: 'vite', value: 'vite' },
+        { name: 'nestjs', value: 'nestjs' },
+        { name: 'express', value: 'express' },
+        { name: 'hono', value: 'hono' },
+        { name: 'Other (type manually)', value: '__other__' },
+        { name: 'None / Clear', value: '__none__' },
+    ];
+    const frameworkChoice = await prompts.select({
+        message: 'Framework:',
+        choices: frameworkChoices,
+        default: app.framework || '',
+    });
+    if (frameworkChoice === '__other__') {
+        const customFramework = await prompts.input({
+            message: 'Enter framework name:',
+        });
+        if (customFramework) {
+            result.framework = customFramework;
+            result.framework_source = 'manually set';
+        }
     }
-    return values;
+    else if (frameworkChoice === '__none__') {
+        result.framework = undefined;
+        result.framework_source = undefined;
+    }
+    else if (frameworkChoice && frameworkChoice !== app.framework) {
+        result.framework = frameworkChoice;
+        result.framework_source = 'manually set';
+    }
+    console.log(chalk_1.default.green(`✓ Updated ${name}`));
+    return result;
 }
+// =============================================================================
+// Project Settings
+// =============================================================================
 /**
- * Mask a secret value for display (show first 4 and last 4 chars)
+ * Get project settings with editing capability
  */
-function maskSecret(value) {
-    if (value.length <= 8) {
-        return '*'.repeat(value.length);
-    }
-    return value.slice(0, 4) + '*'.repeat(value.length - 8) + value.slice(-4);
+async function getProjectSettings(detected, existingEnvValues) {
+    console.log('');
+    console.log(chalk_1.default.blue('=== Project Settings ==='));
+    console.log('');
+    // Project name
+    const defaultName = path_1.default.basename(detected._meta.scanned_root);
+    const projectName = await prompts.input({
+        message: 'Project name:',
+        default: defaultName,
+    });
+    // Server size
+    const serverSize = await prompts.select({
+        message: 'Default server size:',
+        choices: [
+            { name: 'Small  - 2 CPU, 4GB RAM (1 credit/hr)', value: 'small' },
+            { name: 'Medium - 4 CPU, 8GB RAM (2 credits/hr)', value: 'medium' },
+            { name: 'Large  - 8 CPU, 16GB RAM (4 credits/hr)', value: 'large' },
+            { name: 'XL     - 16 CPU, 32GB RAM (8 credits/hr)', value: 'xl' },
+        ],
+        default: 'medium',
+    });
+    // Base branch
+    const detectedBranch = detected.git?.branch || 'main';
+    console.log('');
+    console.log(chalk_1.default.dim('  When creating environments, a new branch is created from this base branch.'));
+    console.log(chalk_1.default.dim('  The new branch name defaults to the environment name.'));
+    const baseBranch = await prompts.input({
+        message: 'Base branch for new environments:',
+        default: detectedBranch,
+    });
+    // Claude Code installation
+    const installClaudeCode = await prompts.confirm({
+        message: 'Install Claude Code CLI on genbox servers?',
+        default: true,
+    });
+    return { projectName, serverSize, baseBranch, installClaudeCode };
 }
+// =============================================================================
+// Git Auth Setup
+// =============================================================================
 /**
- * Prompt for a secret with existing value support
+ * Setup git authentication for detected repos
  */
-async function promptForSecret(message, existingValue, options = {}) {
-    if (existingValue) {
-        console.log(chalk_1.default.dim(`  Found existing value: ${maskSecret(existingValue)}`));
-        const useExisting = await prompts.confirm({
-            message: 'Use existing value?',
-            default: true,
+async function setupGitAuth(detected, projectName, existingEnvValues) {
+    const envVars = {};
+    const repos = {};
+    // Collect all git repos (root + per-app)
+    const gitRepos = [];
+    // Root git
+    if (detected.git?.remote) {
+        const repoName = path_1.default.basename(detected.git.remote, '.git').replace(/.*[:/]/, '');
+        gitRepos.push({
+            name: repoName,
+            path: `/home/dev/${projectName}`,
+            remote: detected.git.remote,
+            type: detected.git.type || 'https',
+            branch: detected.git.branch,
         });
-        if (useExisting) {
-            return existingValue;
+    }
+    // Per-app git repos
+    for (const [appName, app] of Object.entries(detected.apps)) {
+        if (app.git?.remote) {
+            gitRepos.push({
+                name: appName,
+                path: `/home/dev/${projectName}/${app.path}`,
+                remote: app.git.remote,
+                type: app.git.type || 'https',
+                branch: app.git.branch,
+            });
         }
     }
-    if (options.showInstructions) {
-        console.log('');
-        console.log(chalk_1.default.dim('  To create a token:'));
-        console.log(chalk_1.default.dim('  1. Go to https://github.com/settings/tokens'));
-        console.log(chalk_1.default.dim('  2. Click "Generate new token" → "Classic"'));
-        console.log(chalk_1.default.dim('  3. Select scope: "repo" (Full control of private repositories)'));
-        console.log(chalk_1.default.dim('  4. Generate and copy the token'));
-        console.log('');
+    if (gitRepos.length === 0) {
+        console.log(chalk_1.default.dim('  No git repositories detected.'));
+        return { repos, envVars };
     }
-    let value = await prompts.password({
-        message,
-    });
-    if (value) {
-        // Strip any "KEY=" prefix if user pasted the whole line
-        value = value.replace(/^[A-Z_]+=/, '');
+    console.log('');
+    console.log(chalk_1.default.blue('=== Git Repository Setup ==='));
+    console.log('');
+    for (const repo of gitRepos) {
+        console.log(`  ${chalk_1.default.cyan(repo.name)}: ${repo.remote}`);
     }
-    return value || undefined;
-}
-exports.initCommand = new commander_1.Command('init')
-    .description('Initialize a new Genbox configuration')
-    .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)')
-    .option('--from-scan', 'Initialize from existing .genbox/detected.yaml (created by genbox scan)')
-    .action(async (options) => {
-    try {
-        const configPath = path_1.default.join(process.cwd(), CONFIG_FILENAME);
-        const nonInteractive = options.yes || !process.stdin.isTTY;
-        // Check for existing config
-        let overwriteExisting = options.force || false;
-        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 prompts.confirm({
-                message: 'Do you want to overwrite it?',
-                default: false,
-            });
-            if (!overwrite) {
-                return;
-            }
-            overwriteExisting = true;
-        }
-        console.log(chalk_1.default.blue('Initializing Genbox...'));
-        console.log('');
-        // Read existing .env.genbox values (for defaults when overwriting)
-        const existingEnvValues = readExistingEnvGenbox();
-        // Track env vars to add to .env.genbox
-        const envVarsToAdd = {};
-        // Get initial exclusions from CLI options only
-        let exclude = [];
-        if (options.exclude) {
-            exclude = options.exclude.split(',').map((d) => d.trim()).filter(Boolean);
+    console.log('');
+    // Ask for auth method
+    const authMethod = await prompts.select({
+        message: 'How should genbox access these repositories?',
+        choices: [
+            { name: 'Personal Access Token (PAT) - recommended', value: 'token' },
+            { name: 'SSH Key', value: 'ssh' },
+            { name: 'Public (no auth needed)', value: 'public' },
+        ],
+        default: 'token',
+    });
+    let hasHttpsRepos = false;
+    for (const repo of gitRepos) {
+        let repoUrl = repo.remote;
+        if (authMethod === 'token' && repo.type === 'ssh') {
+            repoUrl = sshToHttps(repo.remote);
         }
-        let scan;
-        const scanner = new scanner_1.ProjectScanner();
-        // If --from-scan is specified, load from detected.yaml
-        if (options.fromScan) {
-            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
-            if (!fs_1.default.existsSync(detectedPath)) {
-                console.log(chalk_1.default.red('No .genbox/detected.yaml found. Run "genbox scan" first.'));
-                process.exit(1);
-            }
-            const spinner = (0, ora_1.default)('Loading detected configuration...').start();
-            try {
-                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
-                const detected = yaml.load(content);
-                scan = convertDetectedToScan(detected);
-                spinner.succeed('Loaded from detected.yaml');
-            }
-            catch (err) {
-                spinner.fail('Failed to load detected.yaml');
-                console.error(chalk_1.default.red(String(err)));
-                process.exit(1);
-            }
+        else if (authMethod === 'ssh' && repo.type === 'https') {
+            repoUrl = httpsToSsh(repo.remote);
         }
-        else {
-            // Scan project first (skip scripts initially)
-            const spinner = (0, ora_1.default)('Scanning project...').start();
-            scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
-            spinner.succeed('Project scanned');
+        if (authMethod === 'token' || repo.type === 'https') {
+            hasHttpsRepos = true;
         }
-        // Display scan results
+        repos[repo.name] = {
+            url: repoUrl,
+            path: repo.path,
+            branch: repo.branch !== 'main' && repo.branch !== 'master' ? repo.branch : undefined,
+            auth: authMethod === 'public' ? undefined : authMethod,
+        };
+    }
+    // Prompt for GIT_TOKEN if using token auth
+    if (authMethod === 'token' && hasHttpsRepos) {
         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}`);
+        console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
+        const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
+        if (gitToken) {
+            envVars['GIT_TOKEN'] = gitToken;
+            console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
         }
-        // For multi-repo: show apps and let user select which to include
-        // When using --from-scan, skip app selection - use exactly what's in detected.yaml
-        const isMultiRepoStructure = scan.structure.type === 'hybrid';
-        let selectedApps = scan.apps;
-        if (isMultiRepoStructure && scan.apps.length > 0 && !nonInteractive && !options.fromScan) {
-            console.log('');
-            console.log(chalk_1.default.blue('=== Apps Detected ==='));
-            const appChoices = scan.apps.map(app => ({
-                name: `${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`,
-                value: app.name,
-                checked: app.type !== 'library', // Default select non-libraries
-            }));
-            const selectedAppNames = await prompts.checkbox({
-                message: 'Select apps to include:',
-                choices: appChoices,
-            });
-            // Filter scan.apps to only selected ones
-            selectedApps = scan.apps.filter(a => selectedAppNames.includes(a.name));
-            // Update scan with filtered apps
-            scan = { ...scan, apps: selectedApps };
-        }
-        else if (options.fromScan && scan.apps.length > 0) {
-            // When using --from-scan, show what was loaded and use it directly
-            console.log(`  ${chalk_1.default.dim('Apps:')}       ${scan.apps.length} from detected.yaml`);
-            for (const app of scan.apps) {
-                console.log(`               - ${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`);
-            }
-            console.log(chalk_1.default.dim('\n  (Edit .genbox/detected.yaml to change app selection)'));
-        }
-        else 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}` : ''})`);
-            }
-            if (scan.apps.length > 5) {
-                console.log(`               ... and ${scan.apps.length - 5} more`);
-            }
+        else {
+            console.log(chalk_1.default.dim('  Skipped - add GIT_TOKEN to .env.genbox later if needed'));
         }
-        // Show Docker app count (apps with runner: 'docker')
-        const dockerApps = scan.apps.filter(a => a.runner === 'docker');
-        if (dockerApps.length > 0) {
-            console.log(`  ${chalk_1.default.dim('Docker:')}     ${dockerApps.length} app(s) with docker runner`);
-        }
-        // Show infrastructure services from docker-compose (databases, caches, etc.)
-        if (scan.compose && scan.compose.databases.length + scan.compose.caches.length + scan.compose.queues.length > 0) {
-            const infraCount = scan.compose.databases.length + scan.compose.caches.length + scan.compose.queues.length;
-            console.log(`  ${chalk_1.default.dim('Infra:')}      ${infraCount} infrastructure service(s)`);
-        }
-        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)
-        const projectName = (nonInteractive || options.fromScan)
-            ? (options.name || scan.projectName)
-            : await prompts.input({
-                message: 'Project name:',
-                default: scan.projectName,
-            });
-        // Determine if workspace or single project (auto-detect when --from-scan)
-        let isWorkspace = options.workspace;
-        if (!isWorkspace && (scan.structure.type.startsWith('monorepo') || scan.structure.type === 'hybrid')) {
-            if (nonInteractive || options.fromScan) {
-                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 v4 format (declarative-first architecture)
-        const v4Config = convertV2ToV4(generated.config, scan);
-        // Update project name
-        v4Config.project.name = projectName;
-        // Environment configuration - do this BEFORE profiles so profiles can reference environments
-        // (skip only in non-interactive mode, always show for --from-scan since environments are required)
-        if (!nonInteractive) {
-            const envResult = await setupEnvironments(scan, v4Config, isMultiRepoStructure, existingEnvValues);
-            if (envResult.environments) {
-                v4Config.environments = envResult.environments;
-            }
-            // Add collected database URLs to envVarsToAdd (for .env.genbox)
-            Object.assign(envVarsToAdd, envResult.databaseUrls);
-        }
-        // Ask about profiles (skip prompt when using --from-scan)
-        let createProfiles = true;
-        if (!nonInteractive && !options.fromScan) {
-            createProfiles = await prompts.confirm({
-                message: 'Create predefined profiles for common scenarios?',
-                default: true,
-            });
-        }
-        if (createProfiles) {
-            v4Config.profiles = (nonInteractive || options.fromScan)
-                ? createDefaultProfilesSync(scan, v4Config)
-                : await createDefaultProfiles(scan, v4Config);
-        }
-        // Get server size (use defaults when --from-scan)
-        const serverSize = (nonInteractive || options.fromScan)
-            ? 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 (!v4Config.defaults) {
-            v4Config.defaults = {};
-        }
-        v4Config.defaults.size = serverSize;
-        // Ask about Claude Code installation
-        if (!nonInteractive && !options.fromScan) {
-            const installClaudeCode = await prompts.confirm({
-                message: 'Install Claude Code CLI on genbox servers?',
-                default: true,
-            });
-            if (installClaudeCode) {
-                v4Config.defaults.install_claude_code = true;
-            }
-        }
-        // Get default/base branch (source branch for creating new environment branches)
-        const detectedBranch = scan.git?.branch || 'main';
-        let defaultBranch = detectedBranch;
-        if (!nonInteractive && !options.fromScan) {
-            console.log('');
-            console.log(chalk_1.default.dim('  When creating environments, a new branch is created from this base branch.'));
-            console.log(chalk_1.default.dim('  The new branch name defaults to the environment name.'));
-            const branchInput = await prompts.input({
-                message: 'Base branch for new environment branches:',
-                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;
-        if (options.fromScan) {
-            // When using --from-scan, extract git repos from detected.yaml apps
-            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
-            let detectedConfig = null;
-            try {
-                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
-                detectedConfig = yaml.load(content);
-            }
-            catch { }
-            // Check for per-app git repos first (multi-repo workspace)
-            const appsWithGit = detectedConfig
-                ? Object.entries(detectedConfig.apps).filter(([, app]) => app.git)
-                : [];
-            if (appsWithGit.length > 0) {
-                // Multi-repo: use per-app git repos
-                console.log('');
-                console.log(chalk_1.default.blue('=== Git Repositories (from detected.yaml) ==='));
-                console.log(chalk_1.default.dim(`Found ${appsWithGit.length} repositories`));
-                v4Config.repos = {};
-                let hasHttpsRepos = false;
-                for (const [appName, app] of appsWithGit) {
-                    const git = app.git;
-                    v4Config.repos[appName] = {
-                        url: git.remote,
-                        path: `/home/dev/${projectName}/${app.path}`,
-                        branch: git.branch !== 'main' && git.branch !== 'master' ? git.branch : undefined,
-                        auth: git.type === 'ssh' ? 'ssh' : 'token',
-                    };
-                    console.log(`  ${chalk_1.default.cyan(appName)}: ${git.remote}`);
-                    if (git.type === 'https') {
-                        hasHttpsRepos = true;
-                    }
-                }
-                // Prompt for GIT_TOKEN if any HTTPS repos are found
-                if (hasHttpsRepos && !nonInteractive) {
-                    console.log('');
-                    console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
-                    const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
-                    if (gitToken) {
-                        envVarsToAdd['GIT_TOKEN'] = gitToken;
-                        console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
-                    }
-                    else {
-                        console.log(chalk_1.default.dim('  Skipped - add GIT_TOKEN to .env.genbox later if needed'));
-                    }
-                }
-            }
-            else if (scan.git) {
-                // Single repo or monorepo with root git
-                const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
-                v4Config.repos = {
-                    [repoName]: {
-                        url: scan.git.remote,
-                        path: `/home/dev/${projectName}`,
-                        auth: scan.git.type === 'ssh' ? 'ssh' : 'token',
-                    },
-                };
-                console.log(chalk_1.default.dim(`  Git:        Using ${repoName} from detected.yaml`));
-                // Prompt for GIT_TOKEN if HTTPS
-                if (scan.git.type === 'https' && !nonInteractive) {
-                    console.log('');
-                    console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
-                    const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
-                    if (gitToken) {
-                        envVarsToAdd['GIT_TOKEN'] = gitToken;
-                        console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
-                    }
-                }
-            }
-        }
-        else 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('');
-                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) {
-                    v4Config.repos = {};
-                    let hasHttpsRepos = false;
-                    for (const repoName of selectedRepos) {
-                        const repo = appGitRepos.find(r => r.appName === repoName);
-                        v4Config.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',
-                        };
-                        if (repo.type === 'https') {
-                            hasHttpsRepos = true;
-                        }
-                    }
-                    // Prompt for GIT_TOKEN if any HTTPS repos are selected
-                    if (hasHttpsRepos) {
-                        console.log('');
-                        console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
-                        const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
-                        if (gitToken) {
-                            envVarsToAdd['GIT_TOKEN'] = gitToken;
-                            console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
-                        }
-                        else {
-                            console.log(chalk_1.default.dim('  Skipped - add GIT_TOKEN to .env.genbox later if needed'));
-                        }
-                    }
-                }
-            }
-            else if (appGitRepos.length > 0) {
-                // Non-interactive: include all repos
-                v4Config.repos = {};
-                for (const repo of appGitRepos) {
-                    v4Config.repos[repo.appName] = {
-                        url: repo.remote,
-                        path: `/home/dev/${projectName}/${repo.appPath}`,
-                        auth: repo.type === 'ssh' ? 'ssh' : 'token',
-                    };
-                }
-            }
-        }
-        else if (scan.git) {
-            // Single repo or monorepo with root git
-            if (nonInteractive) {
-                const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
-                v4Config.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) {
-                    v4Config.repos = gitConfig.repos;
-                }
-            }
-        }
-        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 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';
-                        }
-                        return true;
-                    },
-                });
-                const repoName = path_1.default.basename(repoUrl, '.git');
-                v4Config.repos = {
-                    [repoName]: {
-                        url: repoUrl,
-                        path: `/home/dev/${repoName}`,
-                        auth: repoUrl.startsWith('git@') ? 'ssh' : 'token',
-                    },
-                };
-            }
-        }
-        // Script selection - always show multi-select UI (skip in non-interactive mode and --from-scan)
-        if (!nonInteractive && !options.fromScan) {
-            // 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);
-                }
-                // 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) {
-                    v4Config.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.'));
-            }
-        }
-        // Save configuration
-        const yamlContent = yaml.dump(v4Config, {
-            lineWidth: 120,
-            noRefs: true,
-            quotingType: '"',
-        });
-        fs_1.default.writeFileSync(configPath, yamlContent);
-        console.log(chalk_1.default.green(`\n✔ Configuration saved to ${CONFIG_FILENAME}`));
-        // Add API URLs from environments to envVarsToAdd
-        // Always add LOCAL_API_URL for local development
-        envVarsToAdd['LOCAL_API_URL'] = 'http://localhost:3050';
-        if (v4Config.environments) {
-            for (const [envName, envConfig] of Object.entries(v4Config.environments)) {
-                // v4 format: urls.api contains the API URL
-                const apiUrl = envConfig.urls?.api || envConfig.urls?.gateway;
-                if (apiUrl) {
-                    const varName = `${envName.toUpperCase()}_API_URL`;
-                    envVarsToAdd[varName] = apiUrl;
-                }
-            }
-        }
-        // Load detected service URLs if using --from-scan
-        let detectedServiceUrls;
-        if (options.fromScan) {
-            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
-            try {
-                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
-                const detectedConfig = yaml.load(content);
-                detectedServiceUrls = detectedConfig.service_urls;
-            }
-            catch { }
-        }
-        // Generate .env.genbox
-        await setupEnvFile(projectName, v4Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting, detectedServiceUrls);
-        // 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}`));
-            }
-        }
-        // CORS Configuration Warning
-        const hasBackendApps = scan.apps.some(a => a.type === 'backend' || a.type === 'api');
-        const hasFrontendApps = scan.apps.some(a => a.type === 'frontend');
-        if (hasBackendApps && hasFrontendApps) {
-            console.log('');
-            console.log(chalk_1.default.yellow('=== CORS Configuration Required ==='));
-            console.log(chalk_1.default.white('To use genbox environments, add .genbox.dev to your backend CORS config:'));
-            console.log('');
-            console.log(chalk_1.default.dim('  NestJS (main.ts):'));
-            console.log(chalk_1.default.cyan(`    app.enableCors({`));
-            console.log(chalk_1.default.cyan(`      origin: [/\\.genbox\\.dev$/, ...otherOrigins],`));
-            console.log(chalk_1.default.cyan(`      credentials: true,`));
-            console.log(chalk_1.default.cyan(`    });`));
-            console.log('');
-            console.log(chalk_1.default.dim('  Express:'));
-            console.log(chalk_1.default.cyan(`    app.use(cors({ origin: /\\.genbox\\.dev$/ }));`));
-            console.log('');
-            console.log(chalk_1.default.dim('  Or use env var: CORS_ORIGINS=*.genbox.dev'));
-            console.log('');
-            console.log(chalk_1.default.red('  Without this, you will see CORS errors when accessing genbox environments.'));
-            // OAuth Configuration Instructions
-            console.log('');
-            console.log(chalk_1.default.yellow('=== OAuth Provider Configuration ==='));
-            console.log(chalk_1.default.white('If your app uses OAuth (Google, GitHub, etc.), add *.genbox.dev to allowed domains:'));
-            console.log('');
-            console.log(chalk_1.default.dim('  Google OAuth (console.cloud.google.com):'));
-            console.log(chalk_1.default.cyan('    Authorized JavaScript origins:'));
-            console.log(chalk_1.default.cyan('      https://*.genbox.dev'));
-            console.log(chalk_1.default.cyan('    Authorized redirect URIs:'));
-            console.log(chalk_1.default.cyan('      https://*.genbox.dev/api/auth/callback/google'));
-            console.log(chalk_1.default.cyan('      https://*.genbox.dev/auth/google/callback'));
-            console.log('');
-            console.log(chalk_1.default.dim('  GitHub OAuth (github.com/settings/developers):'));
-            console.log(chalk_1.default.cyan('    Authorization callback URL:'));
-            console.log(chalk_1.default.cyan('      https://*.genbox.dev/api/auth/callback/github'));
-            console.log('');
-            console.log(chalk_1.default.dim('  Other providers (Auth0, Clerk, etc.):'));
-            console.log(chalk_1.default.cyan('    Add *.genbox.dev to allowed callback URLs/origins'));
-            console.log('');
-            console.log(chalk_1.default.red('  Without this, OAuth flows will fail in genbox environments.'));
-        }
-        // Next steps
-        console.log('');
-        console.log(chalk_1.default.bold('Next steps:'));
-        console.log(chalk_1.default.dim(`  1. Review and edit ${CONFIG_FILENAME}`));
-        if (hasBackendApps && hasFrontendApps) {
-            console.log(chalk_1.default.yellow(`  2. Add .genbox.dev to your backend CORS configuration`));
-            console.log(chalk_1.default.yellow(`  3. Add *.genbox.dev to OAuth providers (Google, GitHub, etc.) if using auth`));
-            console.log(chalk_1.default.dim(`  4. Update ${ENV_FILENAME} to use API URL variables where needed`));
-            console.log(chalk_1.default.dim(`  5. Run 'genbox profiles' to see available profiles`));
-            console.log(chalk_1.default.dim(`  6. Run 'genbox create <name> --profile <profile>' to create an environment`));
-        }
-        else {
-            console.log(chalk_1.default.dim(`  2. Update ${ENV_FILENAME} to use API URL variables where needed`));
-            console.log(chalk_1.default.dim(`  3. Add *.genbox.dev to OAuth providers if using auth`));
-            console.log(chalk_1.default.dim(`  4. Run 'genbox profiles' to see available profiles`));
-            console.log(chalk_1.default.dim(`  5. 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);
-        }
-        throw error;
     }
-});
+    return { repos, envVars };
+}
+// =============================================================================
+// Script Selection
+// =============================================================================
 /**
- * Create default profiles (sync version for non-interactive mode)
+ * Interactive script selection
  */
-function createDefaultProfilesSync(scan, config) {
-    const definedEnvs = Object.keys(config.environments || {});
-    return createProfilesFromScan(scan, definedEnvs);
-}
-async function createDefaultProfiles(scan, config) {
-    // Get defined environments to use in profiles
-    const definedEnvs = Object.keys(config.environments || {});
-    return createProfilesFromScan(scan, definedEnvs);
-}
-function createProfilesFromScan(scan, definedEnvironments = []) {
-    const profiles = {};
-    const frontendApps = scan.apps.filter(a => a.type === 'frontend');
-    const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
-    // Docker services are also runnable (api, web services from docker-compose)
-    const dockerServices = scan.compose?.applications || [];
-    const dockerServiceNames = dockerServices.map(s => s.name);
-    // Combine backend apps + Docker services (avoid duplicates)
-    const allBackendNames = new Set([
-        ...backendApps.map(a => a.name),
-        ...dockerServiceNames.filter(name => {
-            // Include Docker services that aren't already in apps OR aren't frontend
-            const existingApp = scan.apps.find(a => a.name === name);
-            return !existingApp || existingApp.type !== 'frontend';
-        }),
-    ]);
-    const backendAppNames = Array.from(allBackendNames);
-    const hasBackend = backendAppNames.length > 0;
-    // Determine which environment to use for remote connections
-    // Priority: staging > production > first defined
-    const remoteEnv = definedEnvironments.includes('staging')
-        ? 'staging'
-        : definedEnvironments.includes('production')
-            ? 'production'
-            : definedEnvironments[0];
-    // Quick UI profiles for each frontend (v4: use default_connection instead of connect_to)
-    // Only create if we have a remote environment defined
-    if (remoteEnv) {
-        for (const frontend of frontendApps.slice(0, 3)) {
-            profiles[`${frontend.name}-quick`] = {
-                description: `${frontend.name} only, connected to ${remoteEnv}`,
-                size: 'small',
-                apps: [frontend.name],
-                default_connection: remoteEnv,
-            };
-        }
-    }
-    else {
-        // No remote environment - create local-only profiles
-        for (const frontend of frontendApps.slice(0, 3)) {
-            profiles[`${frontend.name}-local`] = {
-                description: `${frontend.name} with local backend`,
-                size: 'medium',
-                apps: [frontend.name, ...backendAppNames],
-            };
-        }
-    }
-    // Full local development (with DB copy from available environment)
-    if (hasBackend && frontendApps.length > 0) {
-        const primaryFrontend = frontendApps[0];
-        const dbSource = remoteEnv || 'staging'; // Use defined env or default
-        profiles[`${primaryFrontend.name}-full`] = {
-            description: `${primaryFrontend.name} + local backend + DB copy`,
-            size: 'large',
-            apps: [primaryFrontend.name, ...backendAppNames],
-            database: {
-                mode: remoteEnv ? 'copy' : 'local', // Only copy if we have a source
-                ...(remoteEnv && { source: dbSource }),
-            },
-        };
+async function selectScripts(detected) {
+    if (!detected.scripts || detected.scripts.length === 0) {
+        console.log(chalk_1.default.dim('  No scripts detected.'));
+        return detected;
     }
-    // Backend/service development only (for each backend app and Docker service)
-    for (const backendName of backendAppNames) {
-        profiles[`${backendName}-dev`] = {
-            description: `${backendName} with local infrastructure`,
-            size: 'medium',
-            apps: [backendName],
-            database: {
-                mode: 'local',
-            },
-        };
-    }
-    // All frontends + remote backend (only if remote env defined)
-    if (frontendApps.length > 1 && remoteEnv) {
-        profiles[`frontends-${remoteEnv}`] = {
-            description: `All frontends with ${remoteEnv} backend`,
-            size: 'medium',
-            apps: frontendApps.map(a => a.name),
-            default_connection: remoteEnv,
-        };
+    console.log('');
+    console.log(chalk_1.default.blue('=== Setup Scripts ==='));
+    console.log('');
+    // Group scripts by directory
+    const scriptsByDir = new Map();
+    for (const script of detected.scripts) {
+        const dir = script.path.includes('/') ? script.path.split('/')[0] : '(root)';
+        const existing = scriptsByDir.get(dir) || [];
+        existing.push(script);
+        scriptsByDir.set(dir, existing);
     }
-    // Full stack - combine apps + Docker services (deduplicated)
-    const allRunnableNames = new Set([
-        ...scan.apps.filter(a => a.type !== 'library').map(a => a.name),
-        ...dockerServiceNames,
-    ]);
-    if (allRunnableNames.size > 1) {
-        const dbSource = remoteEnv || 'staging';
-        profiles['full-stack'] = {
-            description: 'Everything local' + (remoteEnv ? ' with DB copy' : ''),
-            size: 'xl',
-            apps: Array.from(allRunnableNames),
-            database: {
-                mode: remoteEnv ? 'copy' : 'local',
-                ...(remoteEnv && { source: dbSource }),
-            },
-        };
+    for (const [dir, scripts] of scriptsByDir) {
+        console.log(chalk_1.default.dim(`  ${dir}/ (${scripts.length} scripts)`));
     }
-    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',
+    const scriptChoices = detected.scripts.map(s => ({
+        name: `${s.path} (${s.stage})`,
+        value: s.path,
+        checked: s.path.startsWith('scripts/'),
+    }));
+    const selectedScripts = await prompts.checkbox({
+        message: 'Select scripts to include:',
+        choices: scriptChoices,
     });
-    let repoUrl = gitInfo.remote;
-    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}`));
-        }
-        // 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,
-                });
-            }
-        }
-        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,
-            },
-        },
+        ...detected,
+        scripts: detected.scripts.filter(s => selectedScripts.includes(s.path)),
     };
 }
+// =============================================================================
+// Environment + Service URL Configuration (Combined)
+// =============================================================================
 /**
- * Setup staging/production environments (v4 format)
+ * Combined environment and service URL configuration
  */
-async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvValues = {}) {
-    const databaseUrls = {};
-    // First ask which environments they want to configure
+async function setupEnvironmentsAndServiceUrls(detected, existingEnvValues) {
+    const envVars = {};
+    let environments = {};
+    console.log('');
+    console.log(chalk_1.default.blue('=== Environment Configuration ==='));
+    console.log('');
+    // Which environments to configure
     const envChoice = await prompts.select({
         message: 'Which environments do you want to configure?',
         choices: [
-            { name: 'Staging only', value: 'staging', description: 'Connect to staging API' },
-            { name: 'Production only', value: 'production', description: 'Connect to production API' },
-            { name: 'Both staging and production', value: 'both', description: 'Configure both environments' },
-            { name: 'Skip for now', value: 'skip', description: 'No remote environments' },
+            { name: 'Staging only', value: 'staging' },
+            { name: 'Production only', value: 'production' },
+            { name: 'Both staging and production', value: 'both' },
+            { name: 'Skip for now', value: 'skip' },
         ],
         default: 'staging',
     });
-    if (envChoice === 'skip') {
-        return { environments: undefined, databaseUrls };
-    }
-    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('Database URLs are stored in .env.genbox for database copy operations.'));
-    const environments = {};
-    // Get existing URLs if available
-    const existingStagingApiUrl = existingEnvValues['STAGING_API_URL'];
-    const existingProductionApiUrl = existingEnvValues['PRODUCTION_API_URL'] || existingEnvValues['PROD_API_URL'];
-    const existingStagingMongoUrl = existingEnvValues['STAGING_MONGODB_URL'];
-    const existingProdMongoUrl = existingEnvValues['PROD_MONGODB_URL'] || existingEnvValues['PRODUCTION_MONGODB_URL'];
-    const configureStaging = envChoice === 'staging' || envChoice === 'both';
-    const configureProduction = envChoice === 'production' || envChoice === 'both';
-    // Configure staging if selected
-    if (configureStaging) {
+    if (envChoice !== 'skip') {
         console.log('');
-        console.log(chalk_1.default.cyan('Staging Environment:'));
-        if (isMultiRepo) {
-            const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
-            if (backendApps.length > 0) {
-                const urls = {};
-                for (const app of backendApps) {
-                    const existingUrl = existingEnvValues[`STAGING_${app.name.toUpperCase()}_URL`] ||
-                        (app.name === 'api' ? existingStagingApiUrl : '');
-                    if (existingUrl) {
-                        console.log(chalk_1.default.dim(`  Found existing value for ${app.name}: ${existingUrl}`));
-                        const useExisting = await prompts.confirm({
-                            message: `  Use existing ${app.name} staging URL?`,
-                            default: true,
-                        });
-                        if (useExisting) {
-                            urls[app.name] = existingUrl;
-                            continue;
-                        }
-                    }
-                    const url = await prompts.input({
-                        message: `  ${app.name} staging URL:`,
-                        default: '',
-                    });
-                    if (url) {
-                        urls[app.name] = url;
-                    }
-                }
-                if (Object.keys(urls).length > 0) {
-                    environments.staging = {
-                        description: 'Staging environment',
-                        urls,
-                    };
-                }
-            }
-            else {
-                const stagingApiUrl = await promptForApiUrl('staging', existingStagingApiUrl);
-                if (stagingApiUrl) {
-                    environments.staging = {
-                        description: 'Staging environment',
-                        urls: { api: stagingApiUrl },
-                    };
-                }
-            }
-        }
-        else {
-            const stagingApiUrl = await promptForApiUrl('staging', existingStagingApiUrl);
+        console.log(chalk_1.default.dim('These URLs will be used when connecting to external services.'));
+        const configureStaging = envChoice === 'staging' || envChoice === 'both';
+        const configureProduction = envChoice === 'production' || envChoice === 'both';
+        if (configureStaging) {
+            console.log('');
+            console.log(chalk_1.default.cyan('Staging Environment:'));
+            const stagingApiUrl = await promptWithExisting('  Staging API URL:', existingEnvValues['STAGING_API_URL']);
             if (stagingApiUrl) {
                 environments.staging = {
                     description: 'Staging environment',
                     urls: { api: stagingApiUrl },
                 };
+                envVars['STAGING_API_URL'] = stagingApiUrl;
             }
-        }
-        // Prompt for staging database URL (for database copy operations)
-        console.log('');
-        console.log(chalk_1.default.dim('  Database URL (for "Copy from staging" database mode):'));
-        console.log(chalk_1.default.dim('  Format: mongodb+srv://user:password@staging.mongodb.net/dbname'));
-        if (existingStagingMongoUrl) {
-            console.log(chalk_1.default.dim(`  Found existing value: ${existingStagingMongoUrl.substring(0, 50)}...`));
-            const useExisting = await prompts.confirm({
-                message: '  Use existing staging MongoDB URL?',
-                default: true,
-            });
-            if (useExisting) {
-                databaseUrls['STAGING_MONGODB_URL'] = existingStagingMongoUrl;
-            }
-            else {
-                const mongoUrl = await prompts.input({
-                    message: '  Staging MongoDB URL:',
-                });
-                if (mongoUrl) {
-                    databaseUrls['STAGING_MONGODB_URL'] = mongoUrl;
-                }
-            }
-        }
-        else {
-            const mongoUrl = await prompts.input({
-                message: '  Staging MongoDB URL (optional, press Enter to skip):',
-            });
-            if (mongoUrl) {
-                databaseUrls['STAGING_MONGODB_URL'] = mongoUrl;
-            }
-        }
-    }
-    // Configure production if selected
-    if (configureProduction) {
-        console.log('');
-        console.log(chalk_1.default.cyan('Production Environment:'));
-        if (isMultiRepo) {
-            const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
-            if (backendApps.length > 0) {
-                const prodUrls = {};
-                for (const app of backendApps) {
-                    const existingUrl = existingEnvValues[`PRODUCTION_${app.name.toUpperCase()}_URL`] ||
-                        existingEnvValues[`PROD_${app.name.toUpperCase()}_URL`] ||
-                        (app.name === 'api' ? existingProductionApiUrl : '');
-                    if (existingUrl) {
-                        console.log(chalk_1.default.dim(`  Found existing value for ${app.name}: ${existingUrl}`));
-                        const useExisting = await prompts.confirm({
-                            message: `  Use existing ${app.name} production URL?`,
-                            default: true,
-                        });
-                        if (useExisting) {
-                            prodUrls[app.name] = existingUrl;
-                            continue;
-                        }
-                    }
-                    const url = await prompts.input({
-                        message: `  ${app.name} production URL:`,
-                        default: '',
-                    });
-                    if (url) {
-                        prodUrls[app.name] = url;
-                    }
-                }
-                if (Object.keys(prodUrls).length > 0) {
-                    environments.production = {
-                        description: 'Production (use with caution)',
-                        urls: prodUrls,
-                        safety: {
-                            read_only: true,
-                            require_confirmation: true,
-                        },
-                    };
-                }
-            }
-            else {
-                const prodApiUrl = await promptForApiUrl('production', existingProductionApiUrl);
-                if (prodApiUrl) {
-                    environments.production = {
-                        description: 'Production (use with caution)',
-                        urls: { api: prodApiUrl },
-                        safety: {
-                            read_only: true,
-                            require_confirmation: true,
-                        },
-                    };
-                }
+            const stagingMongoUrl = await promptWithExisting('  Staging MongoDB URL (optional):', existingEnvValues['STAGING_MONGODB_URL'], true);
+            if (stagingMongoUrl) {
+                envVars['STAGING_MONGODB_URL'] = stagingMongoUrl;
             }
         }
-        else {
-            const prodApiUrl = await promptForApiUrl('production', existingProductionApiUrl);
+        if (configureProduction) {
+            console.log('');
+            console.log(chalk_1.default.cyan('Production Environment:'));
+            const prodApiUrl = await promptWithExisting('  Production API URL:', existingEnvValues['PRODUCTION_API_URL'] || existingEnvValues['PROD_API_URL']);
             if (prodApiUrl) {
                 environments.production = {
                     description: 'Production (use with caution)',
@@ -1390,613 +684,947 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                         require_confirmation: true,
                     },
                 };
+                envVars['PRODUCTION_API_URL'] = prodApiUrl;
+            }
+            const prodMongoUrl = await promptWithExisting('  Production MongoDB URL (optional):', existingEnvValues['PROD_MONGODB_URL'] || existingEnvValues['PRODUCTION_MONGODB_URL'], true);
+            if (prodMongoUrl) {
+                envVars['PROD_MONGODB_URL'] = prodMongoUrl;
             }
         }
-        // Prompt for production database URL (for database copy operations)
+    }
+    // Service URL detection and mapping
+    const serviceUrlMappings = await setupServiceUrls(detected, environments, existingEnvValues);
+    // Always add LOCAL_API_URL
+    envVars['LOCAL_API_URL'] = 'http://localhost:3050';
+    return {
+        environments: Object.keys(environments).length > 0 ? environments : undefined,
+        serviceUrlMappings,
+        envVars,
+    };
+}
+/**
+ * Setup service URL mappings for frontend apps
+ */
+async function setupServiceUrls(detected, environments, existingEnvValues) {
+    const frontendApps = Object.entries(detected.apps)
+        .filter(([, app]) => app.type === 'frontend')
+        .map(([name]) => name);
+    if (frontendApps.length === 0) {
+        return [];
+    }
+    // Scan env files for service URLs
+    const serviceUrls = scanEnvFilesForUrls(detected.apps, detected._meta.scanned_root);
+    if (serviceUrls.length === 0) {
+        return [];
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Service URL Configuration ==='));
+    console.log(chalk_1.default.dim('Detected local service URLs in frontend env files:'));
+    console.log('');
+    for (const svc of serviceUrls) {
+        console.log(`  ${chalk_1.default.cyan(svc.base_url)}`);
+        console.log(chalk_1.default.dim(`    Used by: ${svc.used_by.slice(0, 3).join(', ')}${svc.used_by.length > 3 ? ` +${svc.used_by.length - 3} more` : ''}`));
+    }
+    console.log('');
+    // Let user select which to configure
+    const urlChoices = serviceUrls.map(svc => ({
+        name: `${svc.base_url} (${svc.used_by.length} var${svc.used_by.length > 1 ? 's' : ''})`,
+        value: svc.base_url,
+        checked: true,
+    }));
+    const selectedUrls = await prompts.checkbox({
+        message: 'Select service URLs to configure for remote environments:',
+        choices: urlChoices,
+    });
+    const selectedServices = serviceUrls.filter(svc => selectedUrls.includes(svc.base_url));
+    const mappings = [];
+    // Determine primary remote environment
+    const envNames = Object.keys(environments || {});
+    const primaryEnv = envNames.includes('staging') ? 'staging' :
+        envNames.includes('production') ? 'production' :
+            envNames[0];
+    const apiUrl = primaryEnv && environments?.[primaryEnv]?.urls?.api;
+    if (selectedServices.length > 0 && primaryEnv) {
         console.log('');
-        console.log(chalk_1.default.dim('  Database URL (for "Copy from production" database mode):'));
-        console.log(chalk_1.default.dim('  Format: mongodb+srv://readonly:password@prod.mongodb.net/dbname'));
-        if (existingProdMongoUrl) {
-            console.log(chalk_1.default.dim(`  Found existing value: ${existingProdMongoUrl.substring(0, 50)}...`));
-            const useExisting = await prompts.confirm({
-                message: '  Use existing production MongoDB URL?',
-                default: true,
-            });
-            if (useExisting) {
-                databaseUrls['PROD_MONGODB_URL'] = existingProdMongoUrl;
+        console.log(chalk_1.default.dim(`Mapping selected URLs to ${primaryEnv} environment:`));
+        for (const svc of selectedServices) {
+            const serviceInfo = getServiceInfoFromUrl(svc.base_url);
+            // Auto-map API/gateway URLs
+            const isApiService = serviceInfo.name === 'gateway' ||
+                svc.base_url.includes(':3050') ||
+                svc.used_by.some(v => v.toLowerCase().includes('api'));
+            let remoteUrl = '';
+            if (isApiService && apiUrl) {
+                remoteUrl = apiUrl;
+                console.log(chalk_1.default.green(`  ✓ ${svc.base_url} → ${apiUrl}`));
             }
             else {
-                const mongoUrl = await prompts.input({
-                    message: '  Production MongoDB URL:',
+                const inputUrl = await prompts.input({
+                    message: `  ${svc.base_url} → (${primaryEnv} URL, leave empty to skip):`,
+                    default: '',
                 });
-                if (mongoUrl) {
-                    databaseUrls['PROD_MONGODB_URL'] = mongoUrl;
+                remoteUrl = inputUrl;
+                if (remoteUrl) {
+                    console.log(chalk_1.default.green(`  ✓ Mapped to ${remoteUrl}`));
                 }
             }
-        }
-        else {
-            const mongoUrl = await prompts.input({
-                message: '  Production MongoDB URL (optional, press Enter to skip):',
+            mappings.push({
+                varName: `${serviceInfo.varPrefix}_URL`,
+                localUrl: svc.base_url,
+                remoteUrl: remoteUrl || undefined,
+                remoteEnv: remoteUrl ? primaryEnv : undefined,
+                description: serviceInfo.description,
             });
-            if (mongoUrl) {
-                databaseUrls['PROD_MONGODB_URL'] = mongoUrl;
-            }
         }
     }
-    return {
-        environments: Object.keys(environments).length > 0 ? environments : undefined,
-        databaseUrls,
-    };
+    return mappings;
 }
+// =============================================================================
+// Profile Generation and Editing
+// =============================================================================
 /**
- * Prompt for a single API URL with existing value support
+ * Generate and allow editing of profiles
  */
-async function promptForApiUrl(envName, existingUrl) {
-    if (existingUrl) {
-        console.log(chalk_1.default.dim(`  Found existing value: ${existingUrl}`));
-        const useExisting = await prompts.confirm({
-            message: `  Use existing ${envName} API URL?`,
-            default: true,
-        });
-        if (useExisting) {
-            return existingUrl;
+async function setupProfiles(detected, environments) {
+    console.log('');
+    console.log(chalk_1.default.blue('=== Profile Configuration ==='));
+    console.log('');
+    // Generate default profiles
+    const profiles = generateDefaultProfiles(detected, environments);
+    if (Object.keys(profiles).length === 0) {
+        console.log(chalk_1.default.dim('  No profiles generated (no runnable apps detected).'));
+        return {};
+    }
+    // Display profiles
+    console.log(chalk_1.default.dim('Generated profiles:'));
+    console.log('');
+    for (const [name, profile] of Object.entries(profiles)) {
+        console.log(`  ${chalk_1.default.cyan(name)}`);
+        console.log(chalk_1.default.dim(`    ${profile.description || 'No description'}`));
+        console.log(chalk_1.default.dim(`    Apps: ${profile.apps?.join(', ') || 'all'}`));
+        console.log(chalk_1.default.dim(`    Size: ${profile.size || 'default'}`));
+        if (profile.default_connection) {
+            console.log(chalk_1.default.dim(`    Connection: ${profile.default_connection}`));
+        }
+        if (profile.database) {
+            console.log(chalk_1.default.dim(`    Database: ${profile.database.mode}${profile.database.source ? ` from ${profile.database.source}` : ''}`));
         }
+        console.log('');
     }
-    return await prompts.input({
-        message: `  ${envName.charAt(0).toUpperCase() + envName.slice(1)} API URL:`,
-        default: '',
+    // Ask if user wants to edit
+    const editProfiles = await prompts.confirm({
+        message: 'Do you want to edit any profiles?',
+        default: false,
     });
-}
-/**
- * Setup .env.genbox file with segregated app sections
+    if (!editProfiles) {
+        return profiles;
+    }
+    const profileChoices = Object.entries(profiles).map(([name, profile]) => ({
+        name: `${name} - ${profile.description || 'No description'}`,
+        value: name,
+    }));
+    const profilesToEdit = await prompts.checkbox({
+        message: 'Select profiles to edit:',
+        choices: profileChoices,
+    });
+    for (const profileName of profilesToEdit) {
+        profiles[profileName] = await editSingleProfile(profileName, profiles[profileName], detected, environments);
+    }
+    return profiles;
+}
+/**
+ * Edit a single profile
  */
-async function setupEnvFile(projectName, config, nonInteractive = false, scan, isMultiRepo = false, extraEnvVars = {}, overwriteExisting = false, detectedServiceUrls) {
-    const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
-    // If overwriting, delete existing file
-    if (fs_1.default.existsSync(envPath)) {
-        if (overwriteExisting) {
-            fs_1.default.unlinkSync(envPath);
+async function editSingleProfile(name, profile, detected, environments) {
+    console.log('');
+    console.log(chalk_1.default.blue(`=== Editing Profile: ${name} ===`));
+    const result = { ...profile };
+    // Edit description
+    const description = await prompts.input({
+        message: 'Description:',
+        default: profile.description || '',
+    });
+    result.description = description || undefined;
+    // Edit size
+    const size = await prompts.select({
+        message: 'Server size:',
+        choices: [
+            { name: `small ${profile.size === 'small' ? chalk_1.default.green('(current)') : ''}`, value: 'small' },
+            { name: `medium ${profile.size === 'medium' ? chalk_1.default.green('(current)') : ''}`, value: 'medium' },
+            { name: `large ${profile.size === 'large' ? chalk_1.default.green('(current)') : ''}`, value: 'large' },
+            { name: `xl ${profile.size === 'xl' ? chalk_1.default.green('(current)') : ''}`, value: 'xl' },
+        ],
+        default: profile.size || 'medium',
+    });
+    result.size = size;
+    // Edit apps
+    const appChoices = Object.keys(detected.apps).map(appName => ({
+        name: appName,
+        value: appName,
+        checked: profile.apps?.includes(appName) ?? true,
+    }));
+    const selectedApps = await prompts.checkbox({
+        message: 'Include apps:',
+        choices: appChoices,
+    });
+    result.apps = selectedApps.length > 0 ? selectedApps : undefined;
+    // Edit connection mode (if environments exist)
+    const envNames = Object.keys(environments || {});
+    if (envNames.length > 0) {
+        const connectionChoices = [
+            { name: 'local (run everything locally)', value: 'local' },
+            ...envNames.map(env => ({
+                name: `${env} (connect to ${env})`,
+                value: env,
+            })),
+        ];
+        const connection = await prompts.select({
+            message: 'Default connection:',
+            choices: connectionChoices,
+            default: profile.default_connection || 'local',
+        });
+        result.default_connection = connection === 'local' ? undefined : connection;
+    }
+    // Edit database mode
+    const dbMode = await prompts.select({
+        message: 'Database mode:',
+        choices: [
+            { name: 'local (fresh local database)', value: 'local' },
+            { name: 'copy (copy from remote)', value: 'copy' },
+            { name: 'none (no database)', value: 'none' },
+        ],
+        default: profile.database?.mode || 'local',
+    });
+    if (dbMode === 'copy' && envNames.length > 0) {
+        const dbSource = await prompts.select({
+            message: 'Copy database from:',
+            choices: envNames.map(env => ({ name: env, value: env })),
+            default: profile.database?.source || envNames[0],
+        });
+        result.database = { mode: 'copy', source: dbSource };
+    }
+    else if (dbMode === 'local') {
+        result.database = { mode: 'local' };
+    }
+    else {
+        result.database = undefined;
+    }
+    console.log(chalk_1.default.green(`✓ Updated profile: ${name}`));
+    return result;
+}
+/**
+ * Generate default profiles based on detected apps and environments
+ */
+function generateDefaultProfiles(detected, environments) {
+    const profiles = {};
+    const frontendApps = Object.entries(detected.apps).filter(([, app]) => app.type === 'frontend');
+    const backendApps = Object.entries(detected.apps).filter(([, app]) => app.type === 'backend' || app.type === 'gateway');
+    const allRunnableApps = Object.entries(detected.apps).filter(([, app]) => app.type !== 'library');
+    const envNames = Object.keys(environments || {});
+    const remoteEnv = envNames.includes('staging') ? 'staging' :
+        envNames.includes('production') ? 'production' :
+            envNames[0];
+    // Quick UI profiles for frontends
+    if (remoteEnv) {
+        for (const [name] of frontendApps.slice(0, 2)) {
+            profiles[`${name}-quick`] = {
+                description: `${name} only, connected to ${remoteEnv}`,
+                size: 'small',
+                apps: [name],
+                default_connection: remoteEnv,
+            };
         }
-        else {
-            console.log(chalk_1.default.dim(`  ${ENV_FILENAME} already exists, skipping...`));
-            return;
+    }
+    // Full local development
+    if (frontendApps.length > 0 && backendApps.length > 0) {
+        const [frontendName] = frontendApps[0];
+        profiles[`${frontendName}-full`] = {
+            description: `${frontendName} + local backend` + (remoteEnv ? ' + DB copy' : ''),
+            size: 'large',
+            apps: [frontendName, ...backendApps.map(([n]) => n)],
+            database: remoteEnv ? { mode: 'copy', source: remoteEnv } : { mode: 'local' },
+        };
+    }
+    // Backend development
+    for (const [name] of backendApps.slice(0, 2)) {
+        profiles[`${name}-dev`] = {
+            description: `${name} with local infrastructure`,
+            size: 'medium',
+            apps: [name],
+            database: { mode: 'local' },
+        };
+    }
+    // Full stack
+    if (allRunnableApps.length > 1) {
+        profiles['full-stack'] = {
+            description: 'Everything local' + (remoteEnv ? ' with DB copy' : ''),
+            size: 'xl',
+            apps: allRunnableApps.map(([n]) => n),
+            database: remoteEnv ? { mode: 'copy', source: remoteEnv } : { mode: 'local' },
+        };
+    }
+    return profiles;
+}
+// =============================================================================
+// Config Generation
+// =============================================================================
+/**
+ * Generate GenboxConfig from detected config and user inputs
+ */
+function generateConfig(detected, settings, repos, environments, profiles) {
+    // Convert apps
+    const apps = {};
+    for (const [name, app] of Object.entries(detected.apps)) {
+        const appConfig = {
+            path: app.path,
+            type: app.type || 'backend',
+        };
+        if (app.port)
+            appConfig.port = app.port;
+        if (app.framework)
+            appConfig.framework = app.framework;
+        if (app.runner)
+            appConfig.runner = app.runner;
+        if (app.docker)
+            appConfig.docker = app.docker;
+        if (app.healthcheck)
+            appConfig.healthcheck = app.healthcheck;
+        if (app.depends_on)
+            appConfig.depends_on = app.depends_on;
+        if (app.commands) {
+            appConfig.commands = {};
+            if (app.commands.dev)
+                appConfig.commands.dev = app.commands.dev;
+            if (app.commands.build)
+                appConfig.commands.build = app.commands.build;
+            if (app.commands.start)
+                appConfig.commands.start = app.commands.start;
         }
+        apps[name] = appConfig;
+    }
+    // Convert infrastructure to provides
+    const provides = {};
+    if (detected.infrastructure) {
+        for (const infra of detected.infrastructure) {
+            provides[infra.name] = {
+                type: infra.type,
+                image: infra.image,
+                port: infra.port,
+            };
+        }
+    }
+    // Build defaults
+    const defaults = {
+        size: settings.serverSize,
+    };
+    if (settings.baseBranch !== 'main') {
+        defaults.branch = settings.baseBranch;
+    }
+    if (settings.installClaudeCode) {
+        defaults.install_claude_code = true;
     }
-    // Build segregated content with GLOBAL section first
-    let segregatedContent = `# Genbox Environment Variables
+    // Map structure type
+    const structureMap = {
+        'single-app': 'single-app',
+        'monorepo': 'monorepo',
+        'workspace': 'workspace',
+        'microservices': 'microservices',
+        'hybrid': 'hybrid',
+    };
+    const config = {
+        version: 4,
+        project: {
+            name: settings.projectName,
+            structure: structureMap[detected.structure.type] || 'single-app',
+        },
+        apps,
+        defaults,
+    };
+    if (Object.keys(provides).length > 0)
+        config.provides = provides;
+    if (Object.keys(repos).length > 0)
+        config.repos = repos;
+    if (environments && Object.keys(environments).length > 0)
+        config.environments = environments;
+    if (Object.keys(profiles).length > 0)
+        config.profiles = profiles;
+    // Scripts
+    if (detected.scripts && detected.scripts.length > 0) {
+        config.scripts = detected.scripts.map(s => ({
+            name: s.name,
+            path: s.path,
+            stage: s.stage,
+        }));
+    }
+    return config;
+}
+// =============================================================================
+// .env.genbox Generation
+// =============================================================================
+/**
+ * Generate .env.genbox file
+ */
+function generateEnvFile(projectName, detected, envVars, serviceUrlMappings) {
+    let content = `# Genbox Environment Variables
 # Project: ${projectName}
 # DO NOT COMMIT THIS FILE
 #
 # This file uses segregated sections for each app/service.
 # At 'genbox create' time, only GLOBAL + selected app sections are used.
-# Use \${API_URL} for dynamic API URLs based on profile's connect_to setting.
 
 # === GLOBAL ===
 # These variables are always included regardless of which apps are selected
 
 `;
-    // Add global env vars
-    for (const [key, value] of Object.entries(extraEnvVars)) {
-        segregatedContent += `${key}=${value}\n`;
-    }
-    // Add GIT authentication placeholder if not already added
-    if (!extraEnvVars['GIT_TOKEN']) {
-        segregatedContent += `# GIT_TOKEN=ghp_xxxxxxxxxxxx\n`;
-    }
-    // Add database URL section (only show templates for missing URLs)
-    const hasStagingMongo = !!extraEnvVars['STAGING_MONGODB_URL'];
-    const hasProdMongo = !!extraEnvVars['PROD_MONGODB_URL'];
-    if (!hasStagingMongo || !hasProdMongo) {
-        segregatedContent += `\n# Database URLs (used by profiles with database mode)\n`;
-        if (!hasStagingMongo) {
-            segregatedContent += `# STAGING_MONGODB_URL=mongodb+srv://user:password@staging.mongodb.net\n`;
-        }
-        if (!hasProdMongo) {
-            segregatedContent += `# PROD_MONGODB_URL=mongodb+srv://readonly:password@prod.mongodb.net\n`;
+    // Add env vars
+    for (const [key, value] of Object.entries(envVars)) {
+        content += `${key}=${value}\n`;
+    }
+    // Add service URL mappings
+    if (serviceUrlMappings.length > 0) {
+        content += `\n# Service URL Configuration\n`;
+        for (const mapping of serviceUrlMappings) {
+            content += `LOCAL_${mapping.varName}=${mapping.localUrl}\n`;
+            if (mapping.remoteUrl && mapping.remoteEnv) {
+                content += `${mapping.remoteEnv.toUpperCase()}_${mapping.varName}=${mapping.remoteUrl}\n`;
+            }
         }
     }
-    segregatedContent += '\n';
-    // 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 ==='));
-            // Group by app type
-            const directApps = appEnvFiles.filter(e => !e.isService);
-            const serviceApps = appEnvFiles.filter(e => e.isService);
-            if (directApps.length > 0) {
-                console.log(chalk_1.default.dim(`Found ${directApps.length} app env files`));
+    // Add GIT_TOKEN placeholder if not present
+    if (!envVars['GIT_TOKEN']) {
+        content += `\n# Git authentication\n# GIT_TOKEN=ghp_xxxxxxxxxxxx\n`;
+    }
+    // Add app-specific sections from existing env files
+    const appEnvFiles = findAppEnvFiles(detected.apps, detected._meta.scanned_root);
+    for (const envFile of appEnvFiles) {
+        try {
+            const fileContent = fs_1.default.readFileSync(envFile.fullPath, 'utf8').trim();
+            if (fileContent) {
+                content += `\n# === ${envFile.appName} ===\n`;
+                content += fileContent;
+                content += '\n';
             }
-            if (serviceApps.length > 0) {
-                console.log(chalk_1.default.dim(`Found ${serviceApps.length} microservice env files`));
+        }
+        catch {
+            // Skip if can't read
+        }
+    }
+    content += `\n# === END ===\n`;
+    return content;
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+function mapStructureType(type) {
+    if (type.startsWith('monorepo'))
+        return 'monorepo';
+    if (type === 'hybrid')
+        return 'workspace';
+    if (type === 'microservices')
+        return 'microservices';
+    return 'single-app';
+}
+function mapAppType(type) {
+    switch (type) {
+        case 'frontend': return 'frontend';
+        case 'backend':
+        case 'api': return 'backend';
+        case 'worker': return 'worker';
+        case 'gateway': return 'gateway';
+        case 'library': return 'library';
+        default: return undefined;
+    }
+}
+function detectRunner(app, scan) {
+    if (app.type === 'library') {
+        return { runner: 'none', runner_reason: 'library apps are not runnable' };
+    }
+    const hasBunLockfile = scan.runtimes?.some(r => r.lockfile === 'bun.lockb');
+    if (hasBunLockfile) {
+        return { runner: 'bun', runner_reason: 'bun.lockb detected' };
+    }
+    const hasStartScript = app.scripts?.start || app.scripts?.dev;
+    const isTypicalApp = ['frontend', 'backend', 'api', 'worker', 'gateway'].includes(app.type || '');
+    if (hasStartScript || isTypicalApp) {
+        return { runner: 'pm2', runner_reason: 'typical Node.js app with start script' };
+    }
+    return { runner: 'pm2', runner_reason: 'default for Node.js apps' };
+}
+function inferTypeReason(app) {
+    if (!app.type)
+        return 'unknown';
+    const name = (app.name || app.path || '').toLowerCase();
+    if (name.includes('web') || name.includes('frontend') || name.includes('ui') || name.includes('client')) {
+        return `naming convention ('${app.name}' contains frontend keyword)`;
+    }
+    if (name.includes('api') || name.includes('backend') || name.includes('server') || name.includes('gateway')) {
+        return `naming convention ('${app.name}' contains backend keyword)`;
+    }
+    return 'dependency analysis';
+}
+function inferPortSource(app) {
+    if (app.scripts?.dev?.includes('--port'))
+        return 'package.json scripts.dev (--port flag)';
+    if (app.scripts?.dev?.includes('PORT='))
+        return 'package.json scripts.dev (PORT= env)';
+    return 'framework default';
+}
+function inferStageReason(script) {
+    const name = script.name.toLowerCase();
+    if (name.includes('setup') || name.includes('init'))
+        return `filename contains setup/init`;
+    if (name.includes('build'))
+        return `filename contains build`;
+    if (name.includes('start'))
+        return `filename contains start`;
+    return 'default assignment';
+}
+function inferDockerAppType(name, buildContext, rootDir) {
+    if (buildContext && rootDir) {
+        const contextPath = path_1.default.resolve(rootDir, buildContext);
+        const frontendConfigs = ['vite.config.ts', 'next.config.js', 'nuxt.config.ts'];
+        for (const config of frontendConfigs) {
+            if (fs_1.default.existsSync(path_1.default.join(contextPath, config))) {
+                return { type: 'frontend', reason: `config file found: ${config}` };
             }
-            const envChoices = appEnvFiles.map(env => ({
-                name: env.isService ? `${env.appName} (service)` : env.appName,
-                value: env.fullPath,
-                checked: true,
-            }));
-            const selectedEnvFiles = await prompts.checkbox({
-                message: 'Select .env files to include in .env.genbox:',
-                choices: envChoices,
-            });
-            if (selectedEnvFiles.length > 0) {
-                for (const envFilePath of selectedEnvFiles) {
-                    const appInfo = appEnvFiles.find(e => e.fullPath === envFilePath);
-                    if (!appInfo)
-                        continue;
-                    const content = fs_1.default.readFileSync(envFilePath, 'utf8').trim();
-                    // Add section header and content
-                    segregatedContent += `# === ${appInfo.appName} ===\n`;
-                    segregatedContent += content;
-                    segregatedContent += '\n\n';
-                }
+        }
+        const backendConfigs = ['nest-cli.json', 'tsconfig.build.json'];
+        for (const config of backendConfigs) {
+            if (fs_1.default.existsSync(path_1.default.join(contextPath, config))) {
+                return { type: 'backend', reason: `config file found: ${config}` };
             }
         }
-        else if (appEnvFiles.length > 0 && nonInteractive) {
-            // Non-interactive: merge all env files
-            for (const envFile of appEnvFiles) {
-                const content = fs_1.default.readFileSync(envFile.fullPath, 'utf8').trim();
-                segregatedContent += `# === ${envFile.appName} ===\n`;
-                segregatedContent += content;
-                segregatedContent += '\n\n';
+    }
+    const lowerName = name.toLowerCase();
+    if (lowerName.includes('web') || lowerName.includes('frontend') || lowerName.includes('ui')) {
+        return { type: 'frontend', reason: `naming convention` };
+    }
+    if (lowerName.includes('api') || lowerName.includes('backend') || lowerName.includes('gateway')) {
+        return { type: 'backend', reason: `naming convention` };
+    }
+    return { type: 'backend', reason: 'default for Docker services' };
+}
+function detectGitForDirectory(dir) {
+    const { execSync } = require('child_process');
+    const gitDir = path_1.default.join(dir, '.git');
+    if (!fs_1.default.existsSync(gitDir))
+        return undefined;
+    try {
+        const remote = execSync('git remote get-url origin', { cwd: dir, stdio: 'pipe', encoding: 'utf8' }).trim();
+        if (!remote)
+            return undefined;
+        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: dir, stdio: 'pipe', encoding: 'utf8' }).trim();
+        }
+        catch { }
+        return { remote, type: isSSH ? 'ssh' : 'https', provider, branch };
+    }
+    catch {
+        return undefined;
+    }
+}
+function getDockerComposeServiceInfo(rootDir, serviceName) {
+    const composeFiles = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
+    for (const filename of composeFiles) {
+        const composePath = path_1.default.join(rootDir, filename);
+        if (fs_1.default.existsSync(composePath)) {
+            try {
+                const content = fs_1.default.readFileSync(composePath, 'utf8');
+                const compose = yaml.load(content);
+                if (compose?.services?.[serviceName]) {
+                    const service = compose.services[serviceName];
+                    const info = {};
+                    if (service.ports?.[0]) {
+                        const portDef = service.ports[0];
+                        if (typeof portDef === 'string') {
+                            info.port = parseInt(portDef.split(':')[0], 10);
+                        }
+                        else if (typeof portDef === 'number') {
+                            info.port = portDef;
+                        }
+                    }
+                    if (service.build) {
+                        if (typeof service.build === 'string') {
+                            info.buildContext = service.build;
+                        }
+                        else {
+                            info.buildContext = service.build.context;
+                            info.dockerfile = service.build.dockerfile;
+                        }
+                    }
+                    if (service.healthcheck?.test) {
+                        const test = service.healthcheck.test;
+                        if (Array.isArray(test)) {
+                            const healthCmd = test.slice(1).join(' ');
+                            const urlMatch = healthCmd.match(/https?:\/\/[^/]+(\S+)/);
+                            if (urlMatch)
+                                info.healthcheck = urlMatch[1];
+                        }
+                    }
+                    if (service.depends_on) {
+                        info.dependsOn = Array.isArray(service.depends_on) ? service.depends_on : Object.keys(service.depends_on);
+                    }
+                    return info;
+                }
             }
+            catch { }
         }
     }
-    // If no app env files found, check for root .env
-    const hasAppSections = segregatedContent.includes('# === ') &&
-        !segregatedContent.endsWith('# === GLOBAL ===\n');
-    if (!hasAppSections) {
-        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;
+    return undefined;
+}
+function scanEnvFilesForUrls(apps, rootDir) {
+    const serviceUrls = new Map();
+    const envPatterns = ['.env', '.env.local', '.env.development'];
+    for (const [appName, app] of Object.entries(apps)) {
+        if (app.type !== 'frontend')
+            continue;
+        const appDir = path_1.default.join(rootDir, app.path);
+        let envContent;
+        for (const pattern of envPatterns) {
+            const envPath = path_1.default.join(appDir, pattern);
+            if (fs_1.default.existsSync(envPath)) {
+                envContent = fs_1.default.readFileSync(envPath, 'utf8');
                 break;
             }
         }
-        if (existingEnvPath) {
-            const copyExisting = nonInteractive ? true : await prompts.confirm({
-                message: `Found ${path_1.default.basename(existingEnvPath)}. Include in ${ENV_FILENAME}?`,
-                default: true,
-            });
-            if (copyExisting) {
-                const content = fs_1.default.readFileSync(existingEnvPath, 'utf8').trim();
-                segregatedContent += `# === root ===\n`;
-                segregatedContent += `# From ${path_1.default.basename(existingEnvPath)}\n`;
-                segregatedContent += content;
-                segregatedContent += '\n\n';
+        if (!envContent)
+            continue;
+        for (const line of envContent.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const lineMatch = trimmed.match(/^([A-Z_][A-Z0-9_]*)=["']?(.+?)["']?$/);
+            if (!lineMatch)
+                continue;
+            const varName = lineMatch[1];
+            const value = lineMatch[2];
+            if (value.includes('@'))
+                continue;
+            const urlMatch = value.match(/^(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?)/);
+            if (!urlMatch)
+                continue;
+            const baseUrl = urlMatch[1];
+            const hostMatch = baseUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)/);
+            if (!hostMatch)
+                continue;
+            const hostname = hostMatch[1];
+            const isLocalUrl = hostname === 'localhost' || !hostname.includes('.') || /^\d+\.\d+\.\d+\.\d+$/.test(hostname);
+            if (!isLocalUrl)
+                continue;
+            if (!serviceUrls.has(baseUrl)) {
+                serviceUrls.set(baseUrl, { vars: new Set(), apps: new Set() });
             }
+            serviceUrls.get(baseUrl).vars.add(varName);
+            serviceUrls.get(baseUrl).apps.add(appName);
         }
     }
-    // Identify frontend apps for URL transformation
-    const frontendApps = scan?.apps
-        .filter(a => a.type === 'frontend')
-        .map(a => a.name) || [];
-    // Also get frontend apps from config if available
-    if (config.apps) {
-        for (const [name, app] of Object.entries(config.apps)) {
-            if (app.type === 'frontend' && !frontendApps.includes(name)) {
-                frontendApps.push(name);
-            }
-        }
+    const result = [];
+    for (const [baseUrl, { vars, apps }] of serviceUrls) {
+        const serviceInfo = getServiceInfoFromUrl(baseUrl);
+        result.push({
+            base_url: baseUrl,
+            var_name: serviceInfo.varName,
+            description: serviceInfo.description,
+            used_by: Array.from(vars),
+            apps: Array.from(apps),
+            source: 'env files',
+        });
     }
-    if (frontendApps.length > 0 && !nonInteractive) {
-        // Use service URLs from detected.yaml if available (preferred)
-        // Otherwise fall back to scanning the collected env content
-        let serviceUrls;
-        if (detectedServiceUrls && detectedServiceUrls.length > 0) {
-            // Convert detected service URLs to the Map format
-            serviceUrls = new Map();
-            for (const svc of detectedServiceUrls) {
-                serviceUrls.set(svc.base_url, {
-                    urls: new Set([svc.base_url]),
-                    vars: svc.used_by,
-                });
+    return result.sort((a, b) => {
+        const portA = parseInt(a.base_url.match(/:(\d+)/)?.[1] || '0');
+        const portB = parseInt(b.base_url.match(/:(\d+)/)?.[1] || '0');
+        return portA - portB;
+    });
+}
+function getServiceInfoFromUrl(baseUrl) {
+    const urlMatch = baseUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)(?::(\d+))?/);
+    if (!urlMatch) {
+        return { name: 'unknown', varPrefix: 'UNKNOWN', varName: 'UNKNOWN_URL', description: 'Unknown service' };
+    }
+    const hostname = urlMatch[1];
+    const port = urlMatch[2] ? parseInt(urlMatch[2]) : undefined;
+    if (hostname !== 'localhost') {
+        const varPrefix = hostname.toUpperCase().replace(/-/g, '_');
+        return { name: hostname, varPrefix, varName: `${varPrefix}_URL`, description: `${hostname} service` };
+    }
+    if (port) {
+        return { name: `port-${port}`, varPrefix: `PORT_${port}`, varName: `PORT_${port}_URL`, description: `localhost:${port}` };
+    }
+    return { name: 'localhost', varPrefix: 'LOCALHOST', varName: 'LOCALHOST_URL', description: 'localhost' };
+}
+function findAppEnvFiles(apps, rootDir) {
+    const envFiles = [];
+    const envPatterns = ['.env', '.env.local', '.env.development'];
+    for (const [name, app] of Object.entries(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: name, fullPath: envPath });
+                break;
             }
-            console.log('');
-            console.log(chalk_1.default.dim(`Found ${detectedServiceUrls.length} service URL(s) from detected.yaml`));
-        }
-        else {
-            // Fall back to extracting from collected env content
-            serviceUrls = extractFrontendHttpUrls(segregatedContent, frontendApps);
         }
-        if (serviceUrls.size > 0 && config.environments) {
-            // Create mappings based on configured environments (no prompting needed)
-            const urlMappings = await createServiceUrlMappings(serviceUrls, config.environments);
-            // Transform content with expandable variables
-            if (urlMappings.length > 0) {
-                const mappedCount = urlMappings.filter(m => m.remoteUrl).length;
-                if (mappedCount > 0) {
-                    segregatedContent = transformEnvWithVariables(segregatedContent, urlMappings, frontendApps);
-                    const envName = urlMappings.find(m => m.remoteEnv)?.remoteEnv || 'remote';
-                    console.log('');
-                    console.log(chalk_1.default.green(`✓ Configured ${mappedCount} service URL(s) for ${envName} environment`));
+        // Check for nested microservices
+        const appsSubdir = path_1.default.join(appDir, 'apps');
+        if (fs_1.default.existsSync(appsSubdir) && fs_1.default.statSync(appsSubdir).isDirectory()) {
+            try {
+                const services = fs_1.default.readdirSync(appsSubdir);
+                for (const service of services) {
+                    const serviceDir = path_1.default.join(appsSubdir, service);
+                    if (!fs_1.default.statSync(serviceDir).isDirectory())
+                        continue;
+                    for (const pattern of envPatterns) {
+                        const envPath = path_1.default.join(serviceDir, pattern);
+                        if (fs_1.default.existsSync(envPath)) {
+                            envFiles.push({ appName: `${name}/${service}`, fullPath: envPath });
+                            break;
+                        }
+                    }
                 }
             }
+            catch { }
         }
     }
-    // Add END marker
-    segregatedContent += `# === END ===\n`;
-    // Write the file
-    fs_1.default.writeFileSync(envPath, segregatedContent);
-    const sectionCount = (segregatedContent.match(/# === [^=]+ ===/g) || []).length - 2; // Exclude GLOBAL and END
-    if (sectionCount > 0) {
-        console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} with ${sectionCount} app section(s)`));
+    return envFiles;
+}
+async function promptForSecret(message, existingValue, options = {}) {
+    if (existingValue) {
+        const masked = existingValue.length <= 8 ? '*'.repeat(existingValue.length) : existingValue.slice(0, 4) + '*'.repeat(existingValue.length - 8) + existingValue.slice(-4);
+        console.log(chalk_1.default.dim(`  Found existing value: ${masked}`));
+        const useExisting = await prompts.confirm({ message: 'Use existing value?', default: true });
+        if (useExisting)
+            return existingValue;
     }
-    else {
-        console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME}`));
+    if (options.showInstructions) {
+        console.log('');
+        console.log(chalk_1.default.dim('  To create a token:'));
+        console.log(chalk_1.default.dim('  1. Go to https://github.com/settings/tokens'));
+        console.log(chalk_1.default.dim('  2. Click "Generate new token" → "Classic"'));
+        console.log(chalk_1.default.dim('  3. Select scope: "repo" (Full control of private repositories)'));
+        console.log('');
     }
-    // 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`));
-        }
+    let value = await prompts.password({ message });
+    if (value)
+        value = value.replace(/^[A-Z_]+=/, '');
+    return value || undefined;
+}
+async function promptWithExisting(message, existingValue, optional = false) {
+    if (existingValue) {
+        console.log(chalk_1.default.dim(`  Found existing: ${existingValue}`));
+        const useExisting = await prompts.confirm({ message: 'Use existing value?', default: true });
+        if (useExisting)
+            return existingValue;
     }
+    return await prompts.input({
+        message,
+        default: existingValue || '',
+    });
 }
-/**
- * Generate .env.genbox template
- */
-function generateEnvTemplate(projectName, config) {
-    const lines = [
-        '# Genbox Environment Variables',
-        `# Project: ${projectName}`,
-        '# DO NOT COMMIT THIS FILE',
-        '',
-        '# ============================================',
-        '# API URL CONFIGURATION',
-        '# ============================================',
-        '# Use ${API_URL} in your app env vars (e.g., VITE_API_BASE_URL=${API_URL})',
-        '# At create time, ${API_URL} expands based on profile:',
-        '#   - connect_to: staging → uses STAGING_API_URL',
-        '#   - connect_to: production → uses PRODUCTION_API_URL',
-        '#   - local/no connect_to → uses LOCAL_API_URL',
-        '',
-        'LOCAL_API_URL=http://localhost:3050',
-        'STAGING_API_URL=https://api.staging.example.com',
-        '# PRODUCTION_API_URL=https://api.example.com',
-        '',
-        '# ============================================',
-        '# 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',
-        '',
-        '# ============================================',
-        '# APPLICATION ENV VARS',
-        '# ============================================',
-        '# Use ${API_URL} for dynamic API URLs',
-        '',
-        '# Example:',
-        '# VITE_API_BASE_URL=${API_URL}',
-        '# NEXT_PUBLIC_API_URL=${API_URL}',
-        '',
-    ];
-    return lines.join('\n');
+function sshToHttps(url) {
+    const match = url.match(/git@([^:]+):(.+)/);
+    if (match)
+        return `https://${match[1]}/${match[2]}`;
+    return url;
 }
-/**
- * Convert GenboxConfigV2 to GenboxConfigV4 format
- */
-function convertV2ToV4(v2Config, scan) {
-    // Convert services to apps (v4 format)
-    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;
-        }
-        // Convert requires to connects_to (v4 format)
-        if (service.dependsOn?.length) {
-            appConfig.connects_to = service.dependsOn.reduce((acc, dep) => {
-                acc[dep] = {
-                    mode: 'local',
-                    required: true,
-                };
-                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;
+function httpsToSsh(url) {
+    const match = url.match(/https:\/\/([^/]+)\/(.+)/);
+    if (match)
+        return `git@${match[1]}:${match[2]}`;
+    return url;
+}
+function readExistingEnvGenbox() {
+    const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
+    const values = {};
+    if (!fs_1.default.existsSync(envPath))
+        return values;
+    try {
+        const content = fs_1.default.readFileSync(envPath, 'utf8');
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const match = trimmed.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);
+                }
+                values[match[1]] = value;
+            }
         }
-        // Only add env if defined
-        if (service.env?.length) {
-            appConfig.env = service.env;
+    }
+    catch { }
+    return values;
+}
+// =============================================================================
+// Main Command
+// =============================================================================
+exports.initCommand = new commander_1.Command('init')
+    .description('Initialize a new Genbox configuration')
+    .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)')
+    .option('--skip-edit', 'Skip app editing phase')
+    .action(async (options) => {
+    try {
+        const rootDir = process.cwd();
+        const configPath = path_1.default.join(rootDir, 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 prompts.confirm({ message: 'Do you want to overwrite it?', default: false });
+            if (!overwrite)
+                return;
         }
-        // Set runner and docker config
-        if (service.runner) {
-            appConfig.runner = service.runner;
+        console.log(chalk_1.default.blue('\nInitializing Genbox...\n'));
+        // Read existing .env.genbox values
+        const existingEnvValues = readExistingEnvGenbox();
+        // =========================================
+        // PHASE 1: Scan or Load
+        // =========================================
+        let detected;
+        const existingDetected = loadDetectedConfig(rootDir);
+        if (existingDetected && !nonInteractive) {
+            console.log(chalk_1.default.dim(`Found existing .genbox/detected.yaml (${existingDetected._meta.generated_at})`));
+            const useExisting = await prompts.confirm({
+                message: 'Use existing scan results or rescan?',
+                default: true,
+            });
+            if (useExisting) {
+                detected = existingDetected;
+                console.log(chalk_1.default.dim('Using existing scan results.'));
+            }
+            else {
+                const spinner = (0, ora_1.default)('Scanning project...').start();
+                const exclude = options.exclude?.split(',').map(s => s.trim()) || [];
+                detected = await scanProject(rootDir, exclude);
+                spinner.succeed('Project scanned');
+                saveDetectedConfig(rootDir, detected);
+            }
         }
-        if (service.docker) {
-            appConfig.docker = service.docker;
+        else {
+            const spinner = (0, ora_1.default)('Scanning project...').start();
+            const exclude = options.exclude?.split(',').map(s => s.trim()) || [];
+            detected = await scanProject(rootDir, exclude);
+            spinner.succeed('Project scanned');
+            saveDetectedConfig(rootDir, detected);
         }
-        apps[name] = appConfig;
-    }
-    // Convert infrastructure to provides (v4 format)
-    const provides = {};
-    if (v2Config.infrastructure?.databases) {
-        for (const db of v2Config.infrastructure.databases) {
-            provides[db.container || db.type] = {
-                type: 'database',
-                image: `${db.type}:latest`,
-                port: db.port,
+        // Display summary
+        console.log('');
+        console.log(chalk_1.default.bold('Detected:'));
+        console.log(`  ${chalk_1.default.dim('Structure:')}  ${detected.structure.type} (${detected.structure.confidence} confidence)`);
+        console.log(`  ${chalk_1.default.dim('Apps:')}       ${Object.keys(detected.apps).length} detected`);
+        if (detected.infrastructure?.length) {
+            console.log(`  ${chalk_1.default.dim('Infra:')}      ${detected.infrastructure.length} services`);
+        }
+        if (detected.git?.remote) {
+            console.log(`  ${chalk_1.default.dim('Git:')}        ${detected.git.remote}`);
+            console.log(`  ${chalk_1.default.dim('Branch:')}     ${detected.git.branch || 'main'}`);
+        }
+        if (nonInteractive) {
+            // Non-interactive mode - use all defaults
+            const settings = {
+                projectName: options.name || path_1.default.basename(rootDir),
+                serverSize: 'medium',
+                baseBranch: detected.git?.branch || 'main',
+                installClaudeCode: true,
             };
+            const { repos, envVars: gitEnvVars } = await setupGitAuth(detected, settings.projectName, existingEnvValues);
+            const environments = {};
+            const profiles = generateDefaultProfiles(detected, environments);
+            const config = generateConfig(detected, settings, repos, environments, profiles);
+            const yamlContent = yaml.dump(config, { lineWidth: 120, noRefs: true, quotingType: '"' });
+            fs_1.default.writeFileSync(configPath, yamlContent);
+            console.log(chalk_1.default.green(`\n✔ Configuration saved to ${CONFIG_FILENAME}`));
+            const envContent = generateEnvFile(settings.projectName, detected, { ...gitEnvVars, LOCAL_API_URL: 'http://localhost:3050' }, []);
+            fs_1.default.writeFileSync(path_1.default.join(rootDir, ENV_FILENAME), envContent);
+            console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME}`));
+            return;
         }
-    }
-    if (v2Config.infrastructure?.caches) {
-        for (const cache of v2Config.infrastructure.caches) {
-            provides[cache.container || cache.type] = {
-                type: 'cache',
-                image: `${cache.type}:latest`,
-                port: cache.port,
-            };
+        // =========================================
+        // PHASE 2: App Configuration
+        // =========================================
+        detected = await selectApps(detected);
+        if (!options.skipEdit) {
+            detected = await editApps(detected);
+        }
+        // Save updated detected config
+        saveDetectedConfig(rootDir, detected);
+        // =========================================
+        // PHASE 3: Project Settings
+        // =========================================
+        const settings = await getProjectSettings(detected, existingEnvValues);
+        // =========================================
+        // PHASE 4: Git & Scripts
+        // =========================================
+        const { repos, envVars: gitEnvVars } = await setupGitAuth(detected, settings.projectName, existingEnvValues);
+        detected = await selectScripts(detected);
+        // =========================================
+        // PHASE 5: Environments & Service URLs
+        // =========================================
+        const { environments, serviceUrlMappings, envVars: envEnvVars } = await setupEnvironmentsAndServiceUrls(detected, existingEnvValues);
+        // =========================================
+        // PHASE 6: Profiles
+        // =========================================
+        const profiles = await setupProfiles(detected, environments);
+        // =========================================
+        // PHASE 7: Generate Config
+        // =========================================
+        const config = generateConfig(detected, settings, repos, environments, profiles);
+        const yamlContent = yaml.dump(config, { 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
+        const allEnvVars = { ...gitEnvVars, ...envEnvVars };
+        const envContent = generateEnvFile(settings.projectName, detected, allEnvVars, serviceUrlMappings);
+        fs_1.default.writeFileSync(path_1.default.join(rootDir, ENV_FILENAME), envContent);
+        console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME}`));
+        // Add .env.genbox to .gitignore
+        const gitignorePath = path_1.default.join(rootDir, '.gitignore');
+        if (fs_1.default.existsSync(gitignorePath)) {
+            const gitignore = fs_1.default.readFileSync(gitignorePath, 'utf8');
+            if (!gitignore.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`));
+            }
         }
-    }
-    if (v2Config.infrastructure?.queues) {
-        for (const queue of v2Config.infrastructure.queues) {
-            provides[queue.container || queue.type] = {
-                type: 'queue',
-                image: `${queue.type}:latest`,
-                port: queue.port,
-                additional_ports: queue.managementPort ? { management: queue.managementPort } : undefined,
-            };
+        // =========================================
+        // Show Instructions
+        // =========================================
+        const hasBackend = Object.values(detected.apps).some(a => a.type === 'backend' || a.type === 'gateway');
+        const hasFrontend = Object.values(detected.apps).some(a => a.type === 'frontend');
+        if (hasBackend && hasFrontend) {
+            console.log('');
+            console.log(chalk_1.default.yellow('=== CORS Configuration Required ==='));
+            console.log(chalk_1.default.white('Add .genbox.dev to your backend CORS config:'));
+            console.log(chalk_1.default.cyan(`  origin: [/\\.genbox\\.dev$/]`));
         }
+        console.log('');
+        console.log(chalk_1.default.bold('Next steps:'));
+        console.log(chalk_1.default.dim(`  1. Review ${CONFIG_FILENAME}`));
+        console.log(chalk_1.default.dim(`  2. Run 'genbox profiles' to see available profiles`));
+        console.log(chalk_1.default.dim(`  3. Run 'genbox create <name>' to create an environment`));
     }
-    // Convert repos (v4 format)
-    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,
-        };
-    }
-    // Map structure type to v4
-    const structureMap = {
-        'single-app': 'single-app',
-        'monorepo-pnpm': 'monorepo',
-        'monorepo-yarn': 'monorepo',
-        'monorepo-npm': 'monorepo',
-        'microservices': 'microservices',
-        'hybrid': 'hybrid',
-    };
-    // Build v4 config
-    const v4Config = {
-        version: 4,
-        project: {
-            name: v2Config.project.name,
-            structure: structureMap[v2Config.project.structure] || 'single-app',
-            description: v2Config.project.description,
-        },
-        apps,
-        provides: Object.keys(provides).length > 0 ? provides : 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,
-        strict: {
-            enabled: true,
-            allow_detect: true,
-            warnings_as_errors: false,
-        },
-    };
-    return v4Config;
-}
-/**
- * Convert DetectedConfig (from detected.yaml) to ProjectScan format
- * This allows --from-scan to use the same code paths as fresh scanning
- */
-function convertDetectedToScan(detected) {
-    // Convert structure type
-    const structureTypeMap = {
-        'single-app': 'single-app',
-        'monorepo': 'monorepo-pnpm',
-        'workspace': 'hybrid',
-        'microservices': 'microservices',
-        'hybrid': 'hybrid',
-    };
-    // Convert apps
-    const apps = [];
-    for (const [name, app] of Object.entries(detected.apps || {})) {
-        // Map detected type to scanner type
-        const typeMap = {
-            'frontend': 'frontend',
-            'backend': 'backend',
-            'worker': 'worker',
-            'gateway': 'gateway',
-            'library': 'library',
-        };
-        // Map runner types
-        const runnerMap = {
-            'pm2': 'pm2',
-            'docker': 'docker',
-            'node': 'node',
-            'bun': 'bun',
-            'none': 'none',
-        };
-        const discoveredApp = {
-            name,
-            path: app.path,
-            type: typeMap[app.type || 'library'] || 'library',
-            framework: app.framework,
-            port: app.port,
-            dependencies: app.dependencies,
-            scripts: app.commands ? {
-                dev: app.commands.dev || '',
-                build: app.commands.build || '',
-                start: app.commands.start || '',
-            } : {},
-            runner: app.runner ? runnerMap[app.runner] : undefined,
-        };
-        // Add docker config if present
-        if (app.docker) {
-            discoveredApp.docker = {
-                service: app.docker.service,
-                build_context: app.docker.build_context,
-                dockerfile: app.docker.dockerfile,
-            };
+    catch (error) {
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+            console.log('\n' + chalk_1.default.dim('Cancelled.'));
+            process.exit(0);
         }
-        apps.push(discoveredApp);
-    }
-    // Convert runtimes
-    const runtimes = detected.runtimes.map(r => ({
-        language: r.language,
-        version: r.version,
-        versionSource: r.version_source,
-        packageManager: r.package_manager,
-        lockfile: r.lockfile,
-    }));
-    // Convert infrastructure to compose analysis
-    // Note: docker_services is deprecated - apps with runner: 'docker' are now tracked per-app
-    let compose = null;
-    const hasInfra = detected.infrastructure && detected.infrastructure.length > 0;
-    // Get docker apps from apps with runner: 'docker' (new approach)
-    const dockerApps = Object.entries(detected.apps || {})
-        .filter(([, app]) => app.runner === 'docker')
-        .map(([name, app]) => ({
-        name,
-        image: app.docker?.service || name,
-        build: app.docker?.build_context ? {
-            context: app.docker.build_context,
-            dockerfile: app.docker.dockerfile,
-        } : undefined,
-        ports: app.port ? [{ host: app.port, container: app.port }] : [],
-        environment: {},
-        dependsOn: app.depends_on || [],
-        volumes: [],
-    }));
-    if (hasInfra || dockerApps.length > 0) {
-        compose = {
-            files: ['docker-compose.yml'],
-            applications: dockerApps,
-            databases: (detected.infrastructure || [])
-                .filter(i => i.type === 'database')
-                .map(i => ({
-                name: i.name,
-                image: i.image,
-                ports: [{ host: i.port, container: i.port }],
-                environment: {},
-                dependsOn: [],
-                volumes: [],
-            })),
-            caches: (detected.infrastructure || [])
-                .filter(i => i.type === 'cache')
-                .map(i => ({
-                name: i.name,
-                image: i.image,
-                ports: [{ host: i.port, container: i.port }],
-                environment: {},
-                dependsOn: [],
-                volumes: [],
-            })),
-            queues: (detected.infrastructure || [])
-                .filter(i => i.type === 'queue')
-                .map(i => ({
-                name: i.name,
-                image: i.image,
-                ports: [{ host: i.port, container: i.port }],
-                environment: {},
-                dependsOn: [],
-                volumes: [],
-            })),
-            infrastructure: [],
-            portMap: new Map(),
-            dependencyGraph: new Map(),
-        };
+        throw error;
     }
-    // Convert git
-    const git = detected.git ? {
-        remote: detected.git.remote || '',
-        type: detected.git.type || 'https',
-        provider: (detected.git.provider || 'other'),
-        branch: detected.git.branch || 'main',
-    } : undefined;
-    // Convert scripts
-    const scripts = (detected.scripts || []).map(s => ({
-        name: s.name,
-        path: s.path,
-        stage: s.stage,
-        isExecutable: s.executable,
-    }));
-    return {
-        projectName: path_1.default.basename(detected._meta.scanned_root),
-        root: detected._meta.scanned_root,
-        structure: {
-            type: structureTypeMap[detected.structure.type] || 'single-app',
-            confidence: detected.structure.confidence,
-            indicators: detected.structure.indicators,
-        },
-        runtimes,
-        frameworks: [], // Not stored in detected.yaml
-        compose,
-        apps,
-        envAnalysis: {
-            required: [],
-            optional: [],
-            secrets: [],
-            references: [],
-            sources: [],
-        },
-        git,
-        scripts,
-    };
-}
+});