genbox 1.0.78 → 1.0.79

package/dist/commands/scan.js

@@ -0,0 +1,1162 @@
+"use strict";
+/**
+ * Scan Command
+ *
+ * Analyzes the project structure and outputs detected configuration
+ * to .genbox/detected.yaml (or stdout with --stdout flag)
+ *
+ * This separates detection from configuration - users can review
+ * what was detected before using it.
+ *
+ * Usage:
+ *   genbox scan              # Output to .genbox/detected.yaml
+ *   genbox scan --stdout     # Output to stdout
+ *   genbox scan --json       # Output as JSON
+ *   genbox scan -i           # Interactive mode (select apps)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommand = void 0;
+const commander_1 = require("commander");
+const prompts = __importStar(require("@inquirer/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const child_process_1 = require("child_process");
+const scanner_1 = require("../scanner");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require('../../package.json');
+/**
+ * Detect git repository info for a specific directory
+ */
+function detectGitForDirectory(dir) {
+    const gitDir = path.join(dir, '.git');
+    if (!fs.existsSync(gitDir))
+        return undefined;
+    try {
+        const remote = (0, child_process_1.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 = (0, child_process_1.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;
+    }
+}
+exports.scanCommand = new commander_1.Command('scan')
+    .description('Analyze project structure and output detected configuration')
+    .option('--stdout', 'Output to stdout instead of .genbox/detected.yaml')
+    .option('--json', 'Output as JSON instead of YAML')
+    .option('--no-infra', 'Skip infrastructure detection (docker-compose)')
+    .option('--no-scripts', 'Skip script detection')
+    .option('-i, --interactive', 'Interactive mode - select apps before writing')
+    .option('--edit', 'Edit mode - review and modify detected values for each app')
+    .option('-e, --exclude <patterns>', 'Comma-separated patterns to exclude', '')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const isInteractive = (options.interactive || options.edit) && !options.stdout && process.stdin.isTTY;
+    const isEditMode = options.edit && !options.stdout && process.stdin.isTTY;
+    console.log(chalk_1.default.cyan('\n🔍 Scanning project...\n'));
+    try {
+        // Run the scanner
+        const scanner = new scanner_1.ProjectScanner();
+        const exclude = options.exclude ? options.exclude.split(',').map(s => s.trim()) : [];
+        const scan = await scanner.scan(cwd, {
+            exclude,
+            skipScripts: !options.scripts,
+        });
+        // Convert scan result to DetectedConfig format
+        let detected = convertScanToDetected(scan, cwd);
+        // Interactive mode: let user select apps, scripts, infrastructure
+        if (isInteractive) {
+            detected = await interactiveSelection(detected);
+        }
+        // Edit mode: let user modify detected values for each app
+        if (isEditMode) {
+            detected = await interactiveEditMode(detected);
+        }
+        // Scan env files for service URLs (only for selected frontend apps)
+        const frontendApps = Object.entries(detected.apps)
+            .filter(([, app]) => app.type === 'frontend')
+            .map(([name]) => name);
+        if (frontendApps.length > 0) {
+            let serviceUrls = scanEnvFilesForUrls(detected.apps, cwd);
+            // In interactive mode, let user select which URLs to configure
+            if (isInteractive && serviceUrls.length > 0) {
+                serviceUrls = await interactiveUrlSelection(serviceUrls);
+            }
+            if (serviceUrls.length > 0) {
+                detected.service_urls = serviceUrls;
+            }
+        }
+        // Output
+        if (options.stdout) {
+            outputToStdout(detected, options.json);
+        }
+        else {
+            await outputToFile(detected, cwd, options.json);
+            showSummary(detected);
+        }
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+            console.log('\n' + chalk_1.default.dim('Cancelled.'));
+            process.exit(0);
+        }
+        console.error(chalk_1.default.red('Scan failed:'), error);
+        process.exit(1);
+    }
+});
+/**
+ * Interactive app and script selection
+ */
+async function interactiveSelection(detected) {
+    let result = { ...detected };
+    // === App Selection ===
+    const appEntries = Object.entries(detected.apps);
+    if (appEntries.length > 0) {
+        console.log(chalk_1.default.blue('=== Detected Apps ===\n'));
+        // Show detected apps
+        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}` : '',
+            ].filter(Boolean);
+            console.log(`  ${parts.join(' ')}`);
+            if (app.git) {
+                console.log(chalk_1.default.dim(`    └─ ${app.git.remote}`));
+            }
+        }
+        console.log();
+        // Let user select which apps to include
+        const appChoices = appEntries.map(([name, app]) => ({
+            name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+            value: name,
+            checked: app.type !== 'library', // Default: include non-libraries
+        }));
+        const selectedApps = await prompts.checkbox({
+            message: 'Select apps to include:',
+            choices: appChoices,
+        });
+        // Filter apps to only selected ones
+        const filteredApps = {};
+        for (const appName of selectedApps) {
+            filteredApps[appName] = detected.apps[appName];
+        }
+        result.apps = filteredApps;
+    }
+    // === Script Selection ===
+    if (detected.scripts && detected.scripts.length > 0) {
+        console.log('');
+        console.log(chalk_1.default.blue('=== Detected Scripts ===\n'));
+        // Group scripts by directory for display
+        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);
+        }
+        // Show grouped scripts
+        for (const [dir, scripts] of scriptsByDir) {
+            console.log(chalk_1.default.dim(`  ${dir}/ (${scripts.length} scripts)`));
+            for (const script of scripts.slice(0, 3)) {
+                console.log(`    ${chalk_1.default.cyan(script.name)} (${script.stage})`);
+            }
+            if (scripts.length > 3) {
+                console.log(chalk_1.default.dim(`    ... and ${scripts.length - 3} more`));
+            }
+        }
+        console.log();
+        // Let user select which scripts to include
+        const scriptChoices = detected.scripts.map(s => ({
+            name: `${s.path} (${s.stage})`,
+            value: s.path,
+            checked: s.path.startsWith('scripts/'), // Default: include scripts/ directory
+        }));
+        const selectedScripts = await prompts.checkbox({
+            message: 'Select scripts to include:',
+            choices: scriptChoices,
+        });
+        // Filter scripts to only selected ones
+        result.scripts = detected.scripts.filter(s => selectedScripts.includes(s.path));
+    }
+    // === Docker Services Selection ===
+    if (detected.docker_services && detected.docker_services.length > 0) {
+        console.log('');
+        console.log(chalk_1.default.blue('=== Detected Docker Services ===\n'));
+        for (const svc of detected.docker_services) {
+            const portInfo = svc.port ? ` port:${svc.port}` : '';
+            console.log(`  ${chalk_1.default.cyan(svc.name)}${portInfo}`);
+            if (svc.build_context) {
+                console.log(chalk_1.default.dim(`    build: ${svc.dockerfile || 'Dockerfile'}`));
+            }
+        }
+        console.log();
+        const dockerChoices = detected.docker_services.map(svc => ({
+            name: `${svc.name}${svc.port ? ` (port ${svc.port})` : ''}`,
+            value: svc.name,
+            checked: true, // Default: include all
+        }));
+        const selectedDocker = await prompts.checkbox({
+            message: 'Select Docker services to include:',
+            choices: dockerChoices,
+        });
+        // Filter docker services to only selected ones
+        result.docker_services = detected.docker_services.filter(svc => selectedDocker.includes(svc.name));
+    }
+    // === Infrastructure Selection ===
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        console.log('');
+        console.log(chalk_1.default.blue('=== Detected Infrastructure ===\n'));
+        for (const infra of detected.infrastructure) {
+            console.log(`  ${chalk_1.default.cyan(infra.name)}: ${infra.type} (${infra.image})`);
+        }
+        console.log();
+        const infraChoices = detected.infrastructure.map(i => ({
+            name: `${i.name} (${i.type}, ${i.image})`,
+            value: i.name,
+            checked: true, // Default: include all
+        }));
+        const selectedInfra = await prompts.checkbox({
+            message: 'Select infrastructure to include:',
+            choices: infraChoices,
+        });
+        // Filter infrastructure to only selected ones
+        result.infrastructure = detected.infrastructure.filter(i => selectedInfra.includes(i.name));
+    }
+    return result;
+}
+/**
+ * Interactive edit mode - allows modifying detected values for each app
+ */
+async function interactiveEditMode(detected) {
+    const result = { ...detected, apps: { ...detected.apps } };
+    const appEntries = Object.entries(result.apps);
+    if (appEntries.length === 0) {
+        console.log(chalk_1.default.dim('No apps to edit.'));
+        return result;
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Edit Detected Values ==='));
+    console.log(chalk_1.default.dim('Review and modify detected values for each app.\n'));
+    // Show summary of all apps first
+    console.log(chalk_1.default.bold('Detected apps:'));
+    for (const [name, app] of appEntries) {
+        const runner = app.runner || 'pm2';
+        const port = app.port ? `:${app.port}` : '';
+        console.log(`  ${chalk_1.default.cyan(name)} - ${app.type || 'unknown'} (${runner})${port}`);
+    }
+    console.log('');
+    // Ask if user wants to edit any apps
+    const editApps = await prompts.confirm({
+        message: 'Do you want to edit any app configurations?',
+        default: false,
+    });
+    if (!editApps) {
+        return result;
+    }
+    // Let user select which apps to edit
+    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,
+    });
+    // Edit each selected app
+    // Pass the scanned root dir for docker-compose lookup
+    const rootDir = detected._meta.scanned_root;
+    for (const appName of appsToEdit) {
+        result.apps[appName] = await editAppConfig(appName, result.apps[appName], rootDir);
+    }
+    return result;
+}
+/**
+ * Look up service info from docker-compose.yml
+ */
+function getDockerComposeServiceInfo(rootDir, serviceName) {
+    const composeFiles = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
+    for (const filename of composeFiles) {
+        const composePath = path.join(rootDir, filename);
+        if (fs.existsSync(composePath)) {
+            try {
+                const content = fs.readFileSync(composePath, 'utf8');
+                const compose = yaml.load(content);
+                if (compose?.services?.[serviceName]) {
+                    const service = compose.services[serviceName];
+                    const info = {};
+                    // Parse port
+                    if (service.ports && service.ports.length > 0) {
+                        const portDef = service.ports[0];
+                        if (typeof portDef === 'string') {
+                            const parts = portDef.split(':');
+                            info.port = parseInt(parts[0], 10);
+                        }
+                        else if (typeof portDef === 'number') {
+                            info.port = portDef;
+                        }
+                        else if (portDef.published) {
+                            info.port = portDef.published;
+                        }
+                    }
+                    // Parse build context and dockerfile
+                    if (service.build) {
+                        if (typeof service.build === 'string') {
+                            info.buildContext = service.build;
+                        }
+                        else {
+                            info.buildContext = service.build.context;
+                            info.dockerfile = service.build.dockerfile;
+                        }
+                    }
+                    // Parse healthcheck
+                    if (service.healthcheck?.test) {
+                        const test = service.healthcheck.test;
+                        if (Array.isArray(test)) {
+                            // ["CMD", "curl", "-f", "http://localhost:3000/health"]
+                            const cmdIndex = test.indexOf('CMD') + 1 || test.indexOf('CMD-SHELL') + 1;
+                            if (cmdIndex > 0) {
+                                const healthCmd = test.slice(cmdIndex).join(' ');
+                                // Extract health endpoint from curl command
+                                const urlMatch = healthCmd.match(/https?:\/\/[^/]+(\S+)/);
+                                if (urlMatch) {
+                                    info.healthcheck = urlMatch[1];
+                                }
+                            }
+                        }
+                        else if (typeof test === 'string') {
+                            const urlMatch = test.match(/https?:\/\/[^/]+(\S+)/);
+                            if (urlMatch) {
+                                info.healthcheck = urlMatch[1];
+                            }
+                        }
+                    }
+                    // Parse depends_on
+                    if (service.depends_on) {
+                        if (Array.isArray(service.depends_on)) {
+                            info.dependsOn = service.depends_on;
+                        }
+                        else if (typeof service.depends_on === 'object') {
+                            info.dependsOn = Object.keys(service.depends_on);
+                        }
+                    }
+                    // Parse environment variables (names only)
+                    if (service.environment) {
+                        if (Array.isArray(service.environment)) {
+                            info.envVars = service.environment.map((e) => e.split('=')[0]);
+                        }
+                        else if (typeof service.environment === 'object') {
+                            info.envVars = Object.keys(service.environment);
+                        }
+                    }
+                    return info;
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Edit a single app's configuration
+ */
+async function editAppConfig(name, app, rootDir) {
+    console.log('');
+    console.log(chalk_1.default.blue(`=== Editing: ${name} ===`));
+    // Show current values
+    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';
+    }
+    // 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 and auto-detect from docker-compose
+    if (newRunner === 'docker') {
+        // First ask for service name to look up in docker-compose
+        const dockerService = await prompts.input({
+            message: 'Docker service name:',
+            default: app.docker?.service || name,
+        });
+        // Look up service info from docker-compose.yml
+        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}`));
+            if (composeInfo.dependsOn?.length)
+                console.log(chalk_1.default.dim(`    depends_on: ${composeInfo.dependsOn.join(', ')}`));
+            if (composeInfo.envVars?.length)
+                console.log(chalk_1.default.dim(`    env vars: ${composeInfo.envVars.slice(0, 5).join(', ')}${composeInfo.envVars.length > 5 ? ` +${composeInfo.envVars.length - 5} more` : ''}`));
+            console.log('');
+        }
+        // Use detected values as defaults
+        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,
+        };
+        // Auto-set values from docker-compose
+        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 and not already set by docker-compose)
+    if (newRunner !== 'none' && result.type !== 'library') {
+        // For docker runner, only ask if port wasn't auto-detected
+        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';
+                }
+            }
+        }
+        else if (!currentPort) {
+            result.port = undefined;
+            result.port_source = undefined;
+        }
+    }
+    // Edit framework
+    const frameworkChoices = [
+        { name: `Keep current: ${app.framework || 'none'}`, value: app.framework || '' },
+        { name: '---', value: '__separator__', disabled: true },
+        { name: 'nextjs', value: 'nextjs' },
+        { name: 'react', value: 'react' },
+        { name: 'vue', value: 'vue' },
+        { name: 'nuxt', value: 'nuxt' },
+        { name: 'vite', value: 'vite' },
+        { name: 'astro', value: 'astro' },
+        { name: 'nestjs', value: 'nestjs' },
+        { name: 'express', value: 'express' },
+        { name: 'fastify', value: 'fastify' },
+        { 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';
+        }
+    }
+    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;
+}
+/**
+ * Interactive service URL selection
+ */
+async function interactiveUrlSelection(serviceUrls) {
+    if (serviceUrls.length === 0) {
+        return [];
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Detected Service URLs ==='));
+    console.log(chalk_1.default.dim('These are local/development URLs found in frontend env files.'));
+    console.log(chalk_1.default.dim('Select which ones need staging URL equivalents.\n'));
+    // Show detected URLs
+    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 URLs 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, // Default: include all
+    }));
+    const selectedUrls = await prompts.checkbox({
+        message: 'Select service URLs to configure for staging:',
+        choices: urlChoices,
+    });
+    // Filter to selected URLs
+    return serviceUrls.filter(svc => selectedUrls.includes(svc.base_url));
+}
+/**
+ * Scan env files in app directories for service URLs
+ */
+function scanEnvFilesForUrls(apps, rootDir) {
+    const serviceUrls = new Map();
+    const envPatterns = ['.env', '.env.local', '.env.development'];
+    for (const [appName, app] of Object.entries(apps)) {
+        // Only scan frontend apps
+        if (app.type !== 'frontend')
+            continue;
+        const appDir = path.join(rootDir, app.path);
+        // Find env file
+        let envContent;
+        for (const pattern of envPatterns) {
+            const envPath = path.join(appDir, pattern);
+            if (fs.existsSync(envPath)) {
+                envContent = fs.readFileSync(envPath, 'utf8');
+                break;
+            }
+        }
+        if (!envContent)
+            continue;
+        // Process each line individually
+        for (const line of envContent.split('\n')) {
+            // Skip comments and empty lines
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('#'))
+                continue;
+            // Parse VAR=value format
+            const lineMatch = trimmedLine.match(/^([A-Z_][A-Z0-9_]*)=["']?(.+?)["']?$/);
+            if (!lineMatch)
+                continue;
+            const varName = lineMatch[1];
+            const value = lineMatch[2];
+            // Skip URLs with @ symbol (credentials, connection strings)
+            if (value.includes('@'))
+                continue;
+            // Check if it's a URL
+            const urlMatch = value.match(/^(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?)/);
+            if (!urlMatch)
+                continue;
+            const baseUrl = urlMatch[1];
+            // Extract hostname
+            const hostMatch = baseUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)/);
+            if (!hostMatch)
+                continue;
+            const hostname = hostMatch[1];
+            // Only include local URLs (localhost, Docker internal names, IPs)
+            const isLocalUrl = hostname === 'localhost' ||
+                !hostname.includes('.') ||
+                /^\d+\.\d+\.\d+\.\d+$/.test(hostname);
+            if (!isLocalUrl)
+                continue;
+            // Add to map
+            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);
+        }
+    }
+    // Convert to DetectedServiceUrl array
+    const result = [];
+    for (const [baseUrl, { vars, apps: appNames }] 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(appNames),
+            source: 'env files',
+        });
+    }
+    // Sort by port for consistent output
+    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;
+    });
+    return result;
+}
+/**
+ * Get service info from URL
+ */
+function getServiceInfoFromUrl(baseUrl) {
+    const urlMatch = baseUrl.match(/^https?:\/\/([a-zA-Z0-9_.-]+)(?::(\d+))?/);
+    if (!urlMatch) {
+        return { varName: 'UNKNOWN_URL', 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 varName = hostname.toUpperCase().replace(/-/g, '_') + '_URL';
+        return {
+            varName,
+            description: `${hostname} service`,
+        };
+    }
+    // Generate from port for localhost
+    if (port) {
+        return {
+            varName: `PORT_${port}_URL`,
+            description: `localhost:${port}`,
+        };
+    }
+    return { varName: 'LOCALHOST_URL', description: 'localhost' };
+}
+/**
+ * Convert ProjectScan to DetectedConfig
+ */
+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 (detect git info for each app in multi-repo workspaces)
+    const isMultiRepo = scan.structure.type === 'hybrid';
+    for (const app of scan.apps) {
+        // Map scanner AppType to DetectedApp type
+        const mappedType = mapAppType(app.type);
+        // Detect git info for this app (for multi-repo workspaces)
+        let appGit;
+        if (isMultiRepo) {
+            const appDir = path.join(root, app.path);
+            appGit = detectGitForDirectory(appDir);
+        }
+        // Detect runner based on app type and context
+        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 is a string type
+            framework_source: app.framework ? inferFrameworkSource(app) : undefined,
+            commands: app.scripts ? {
+                dev: app.scripts.dev,
+                build: app.scripts.build,
+                start: app.scripts.start,
+            } : undefined,
+            dependencies: app.dependencies,
+            git: appGit,
+        };
+    }
+    // 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'
+        // (Only add if not already detected as a PM2 app)
+        if (scan.compose.applications && scan.compose.applications.length > 0) {
+            for (const dockerApp of scan.compose.applications) {
+                // Skip if already exists as a PM2 app
+                if (detected.apps[dockerApp.name])
+                    continue;
+                // Infer type by checking file structure in build context
+                const { type: mappedType, reason: typeReason } = inferDockerAppType(dockerApp.name, dockerApp.build?.context, scan.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',
+                };
+            }
+        }
+    }
+    // Git info
+    if (scan.git) {
+        detected.git = {
+            remote: scan.git.remote,
+            type: scan.git.type,
+            provider: scan.git.provider,
+            branch: scan.git.branch,
+        };
+    }
+    // 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 detected;
+}
+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) {
+    // Map scanner's AppType to DetectedApp type
+    switch (type) {
+        case 'frontend':
+            return 'frontend';
+        case 'backend':
+        case 'api': // Scanner has 'api', map to 'backend'
+            return 'backend';
+        case 'worker':
+            return 'worker';
+        case 'gateway':
+            return 'gateway';
+        case 'library':
+            return 'library';
+        default:
+            return undefined; // Unknown type
+    }
+}
+/**
+ * Detect the appropriate runner for an app
+ * Priority:
+ * 1. Library apps → none
+ * 2. Bun lockfile present → bun
+ * 3. Has start script or is a typical app → pm2
+ * 4. Simple CLI/script → node
+ */
+function detectRunner(app, scan) {
+    // Libraries don't run
+    if (app.type === 'library') {
+        return { runner: 'none', runner_reason: 'library apps are not runnable' };
+    }
+    // Check for Bun
+    const hasBunLockfile = scan.runtimes?.some(r => r.lockfile === 'bun.lockb');
+    if (hasBunLockfile) {
+        return { runner: 'bun', runner_reason: 'bun.lockb detected' };
+    }
+    // Check for typical app patterns that benefit from PM2
+    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' };
+    }
+    // CLI tools or simple scripts can use direct node
+    const name = (app.name || '').toLowerCase();
+    if (name.includes('cli') || name.includes('tool') || name.includes('script')) {
+        return { runner: 'node', runner_reason: 'CLI/tool detected' };
+    }
+    // Default to pm2 for most apps
+    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)`;
+    }
+    if (name.includes('worker') || name.includes('queue') || name.includes('job')) {
+        return `naming convention ('${app.name}' contains worker keyword)`;
+    }
+    return 'dependency analysis';
+}
+/**
+ * Infer app type by examining file structure in the build context directory
+ * Falls back to name-based detection only if file analysis doesn't find anything
+ */
+function inferDockerAppType(name, buildContext, rootDir) {
+    // If we have a build context, check file structure first
+    if (buildContext && rootDir) {
+        const contextPath = path.resolve(rootDir, buildContext);
+        // Check for frontend indicators
+        const frontendConfigs = ['vite.config.ts', 'vite.config.js', 'next.config.js', 'next.config.mjs', 'nuxt.config.ts', 'astro.config.mjs'];
+        for (const config of frontendConfigs) {
+            if (fs.existsSync(path.join(contextPath, config))) {
+                return { type: 'frontend', reason: `config file found: ${config}` };
+            }
+        }
+        // Check for backend indicators
+        const backendConfigs = ['nest-cli.json', 'tsconfig.build.json'];
+        for (const config of backendConfigs) {
+            if (fs.existsSync(path.join(contextPath, config))) {
+                return { type: 'backend', reason: `config file found: ${config}` };
+            }
+        }
+        // Check package.json dependencies
+        const packageJsonPath = path.join(contextPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+                // Frontend dependencies
+                const frontendDeps = ['react', 'react-dom', 'vue', '@angular/core', 'svelte', 'next', 'nuxt', 'vite', '@remix-run/react', 'astro'];
+                for (const dep of frontendDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'frontend', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+                // Backend dependencies
+                const backendDeps = ['@nestjs/core', 'express', 'fastify', 'koa', 'hapi', '@hono/node-server'];
+                for (const dep of backendDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'backend', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+                // Worker dependencies
+                const workerDeps = ['bull', 'bullmq', 'agenda', 'bee-queue'];
+                for (const dep of workerDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'worker', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // Fall back to name-based detection
+    const lowerName = name.toLowerCase();
+    if (lowerName.includes('web') || lowerName.includes('frontend') || lowerName.includes('ui') || lowerName.includes('client')) {
+        return { type: 'frontend', reason: `naming convention ('${name}' contains frontend keyword)` };
+    }
+    if (lowerName.includes('api') || lowerName.includes('backend') || lowerName.includes('server') || lowerName.includes('gateway')) {
+        return { type: 'backend', reason: `naming convention ('${name}' contains backend keyword)` };
+    }
+    if (lowerName.includes('worker') || lowerName.includes('queue') || lowerName.includes('job')) {
+        return { type: 'worker', reason: `naming convention ('${name}' contains worker keyword)` };
+    }
+    // Default to backend for Docker services
+    return { type: 'backend', reason: 'default for Docker services' };
+}
+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)';
+    }
+    if (app.scripts?.start?.includes('--port')) {
+        return 'package.json scripts.start (--port flag)';
+    }
+    return 'framework default';
+}
+function inferFrameworkSource(app) {
+    const framework = app.framework;
+    if (!framework)
+        return 'unknown';
+    // Config file based detection
+    const configFrameworks = ['nextjs', 'nuxt', 'nestjs', 'astro', 'gatsby'];
+    if (configFrameworks.includes(framework)) {
+        return `config file (${framework}.config.* or similar)`;
+    }
+    return 'package.json dependencies';
+}
+function inferStageReason(script) {
+    const name = script.name.toLowerCase();
+    if (name.includes('setup') || name.includes('init') || name.includes('install')) {
+        return `filename contains '${name.match(/setup|init|install/)?.[0]}'`;
+    }
+    if (name.includes('build') || name.includes('compile')) {
+        return `filename contains '${name.match(/build|compile/)?.[0]}'`;
+    }
+    if (name.includes('start') || name.includes('run') || name.includes('serve')) {
+        return `filename contains '${name.match(/start|run|serve/)?.[0]}'`;
+    }
+    if (name.includes('deploy') || name.includes('release')) {
+        return `filename contains '${name.match(/deploy|release/)?.[0]}'`;
+    }
+    return 'default assignment';
+}
+function outputToStdout(detected, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(detected, null, 2));
+    }
+    else {
+        console.log(yaml.dump(detected, { lineWidth: 120, noRefs: true }));
+    }
+}
+async function outputToFile(detected, root, asJson) {
+    const genboxDir = path.join(root, '.genbox');
+    // Create .genbox directory if it doesn't exist
+    if (!fs.existsSync(genboxDir)) {
+        fs.mkdirSync(genboxDir, { recursive: true });
+    }
+    // Add .genbox to .gitignore if not already there
+    const gitignorePath = path.join(root, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, 'utf8');
+        if (!gitignore.includes('.genbox')) {
+            fs.appendFileSync(gitignorePath, '\n# Genbox generated files\n.genbox/\n');
+            console.log(chalk_1.default.dim('Added .genbox/ to .gitignore'));
+        }
+    }
+    // Write detected config
+    const filename = asJson ? 'detected.json' : 'detected.yaml';
+    const filePath = path.join(genboxDir, filename);
+    const content = asJson
+        ? JSON.stringify(detected, null, 2)
+        : yaml.dump(detected, { lineWidth: 120, noRefs: true });
+    fs.writeFileSync(filePath, content);
+    console.log(chalk_1.default.green(`\n✓ Detected configuration written to: ${filePath}`));
+}
+function showSummary(detected) {
+    console.log(chalk_1.default.bold('\n📊 Detection Summary:\n'));
+    // Structure
+    console.log(`  Structure: ${chalk_1.default.cyan(detected.structure.type)} (${detected.structure.confidence} confidence)`);
+    if (detected.structure.indicators.length > 0) {
+        console.log(chalk_1.default.dim(`    Indicators: ${detected.structure.indicators.join(', ')}`));
+    }
+    // Runtimes
+    if (detected.runtimes.length > 0) {
+        console.log(`\n  Runtimes:`);
+        for (const runtime of detected.runtimes) {
+            console.log(`    ${chalk_1.default.cyan(runtime.language)}${runtime.version ? ` ${runtime.version}` : ''}`);
+            if (runtime.package_manager) {
+                console.log(chalk_1.default.dim(`      Package manager: ${runtime.package_manager}`));
+            }
+        }
+    }
+    // Apps
+    const appNames = Object.keys(detected.apps);
+    if (appNames.length > 0) {
+        console.log(`\n  Apps (${appNames.length}):`);
+        for (const name of appNames) {
+            const app = detected.apps[name];
+            const parts = [
+                chalk_1.default.cyan(name),
+                app.type ? `(${app.type})` : '',
+                app.framework ? `[${app.framework}]` : '',
+                app.port ? `port:${app.port}` : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
+        }
+    }
+    // Docker Services (applications with build context)
+    if (detected.docker_services && detected.docker_services.length > 0) {
+        console.log(`\n  Docker Services (${detected.docker_services.length}):`);
+        for (const svc of detected.docker_services) {
+            const portInfo = svc.port ? ` port:${svc.port}` : '';
+            console.log(`    ${chalk_1.default.cyan(svc.name)}${portInfo}`);
+            if (svc.build_context) {
+                console.log(chalk_1.default.dim(`      build: ${svc.build_context}`));
+            }
+        }
+    }
+    // Infrastructure
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        console.log(`\n  Infrastructure (${detected.infrastructure.length}):`);
+        for (const infra of detected.infrastructure) {
+            console.log(`    ${chalk_1.default.cyan(infra.name)}: ${infra.type} (${infra.image})`);
+        }
+    }
+    // Git (root level) - show branch prominently
+    if (detected.git?.remote) {
+        console.log(`\n  Git: ${detected.git.provider || 'git'} (${detected.git.type})`);
+        console.log(`    Remote: ${chalk_1.default.dim(detected.git.remote)}`);
+        console.log(`    Branch: ${chalk_1.default.cyan(detected.git.branch || 'main')} ${chalk_1.default.dim('← base branch for new environment branches')}`);
+    }
+    // Per-app git repos (for multi-repo workspaces)
+    const appsWithGit = Object.entries(detected.apps).filter(([, app]) => app.git);
+    if (appsWithGit.length > 0) {
+        console.log(`\n  App Repositories (${appsWithGit.length}):`);
+        for (const [name, app] of appsWithGit) {
+            const git = app.git;
+            console.log(`    ${chalk_1.default.cyan(name)}: ${git.provider} (${git.type})`);
+            console.log(chalk_1.default.dim(`      ${git.remote}`));
+            console.log(`      Branch: ${chalk_1.default.cyan(git.branch || 'main')}`);
+        }
+    }
+    // Service URLs (for staging URL configuration)
+    if (detected.service_urls && detected.service_urls.length > 0) {
+        console.log(`\n  Service URLs (${detected.service_urls.length}):`);
+        for (const svc of detected.service_urls) {
+            console.log(`    ${chalk_1.default.cyan(svc.var_name)}: ${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(chalk_1.default.dim('\n  These URLs will need staging equivalents in init.'));
+    }
+    console.log(chalk_1.default.bold('\n📝 Next steps:\n'));
+    console.log('  1. Review the detected configuration in .genbox/detected.yaml');
+    console.log('  2. Run ' + chalk_1.default.cyan('genbox init --from-scan') + ' to create genbox.yaml');
+    console.log('  3. Or manually create genbox.yaml using detected values');
+    console.log();
+}