genbox 1.0.14 → 1.0.16

package/dist/commands/init.js

@@ -51,6 +51,217 @@ const config_generator_1 = require("../scanner/config-generator");
 const scan_1 = require("../scan");
 const CONFIG_FILENAME = 'genbox.yaml';
 const ENV_FILENAME = '.env.genbox';
+/**
+ * Extract unique HTTP URLs from frontend app sections in .env.genbox content
+ * Catches both localhost URLs and Docker internal service references
+ */
+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);
+        }
+    }
+    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);
+            }
+        }
+    }
+    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`
+        };
+    }
+    // Generate from port for localhost URLs
+    if (port) {
+        return {
+            name: `port-${port}`,
+            varPrefix: `PORT_${port}`,
+            description: `localhost:${port}`
+        };
+    }
+    return { name: 'unknown', varPrefix: 'UNKNOWN', description: 'Unknown Service' };
+}
+/**
+ * Prompt user for staging URLs for each unique service URL found in frontend apps
+ */
+async function promptForStagingUrls(serviceUrls, existingStagingApiUrl) {
+    const mappings = [];
+    if (serviceUrls.size === 0) {
+        return mappings;
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Frontend Service URL Configuration ==='));
+    console.log(chalk_1.default.dim('Frontend apps have service URLs that need staging equivalents.'));
+    console.log(chalk_1.default.dim('This enables profiles like admin-quick to connect to staging backend.'));
+    console.log('');
+    // 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;
+    });
+    for (const [baseUrl, { urls, vars }] of sortedServices) {
+        const serviceInfo = getServiceNameFromUrl(baseUrl);
+        // Show what URLs use this service
+        console.log(chalk_1.default.cyan(`${serviceInfo.description} (${baseUrl})`));
+        console.log(chalk_1.default.dim(`  Used by: ${vars.slice(0, 3).join(', ')}${vars.length > 3 ? ` +${vars.length - 3} more` : ''}`));
+        // For gateway, suggest existing staging URL if available
+        let defaultUrl = '';
+        if ((serviceInfo.name === 'gateway' || baseUrl.includes(':3050')) && existingStagingApiUrl) {
+            defaultUrl = existingStagingApiUrl;
+        }
+        const stagingUrl = await prompts.input({
+            message: `  Staging URL (leave empty to skip):`,
+            default: defaultUrl,
+        });
+        mappings.push({
+            varName: `${serviceInfo.varPrefix}_URL`,
+            localUrl: baseUrl,
+            stagingUrl: stagingUrl || undefined,
+            description: serviceInfo.description,
+        });
+    }
+    return mappings;
+}
+/**
+ * Transform .env.genbox content to use expandable variables
+ */
+function transformEnvWithVariables(envContent, mappings, frontendApps) {
+    if (mappings.length === 0) {
+        return envContent;
+    }
+    let result = envContent;
+    // Build GLOBAL section additions
+    const globalAdditions = [
+        '',
+        '# Service URL Configuration',
+        '# These expand based on profile: ${GATEWAY_URL} → LOCAL or STAGING value',
+    ];
+    for (const mapping of mappings) {
+        globalAdditions.push(`LOCAL_${mapping.varName}=${mapping.localUrl}`);
+        if (mapping.stagingUrl) {
+            globalAdditions.push(`STAGING_${mapping.varName}=${mapping.stagingUrl}`);
+        }
+        else {
+            globalAdditions.push(`# STAGING_${mapping.varName}=https://your-staging-url.com`);
+        }
+    }
+    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);
+        }
+    }
+    return transformedLines.join('\n');
+}
 /**
  * Detect git repositories in app directories (for multi-repo workspaces)
  */
@@ -162,6 +373,7 @@ exports.initCommand = new commander_1.Command('init')
     .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);
@@ -192,11 +404,34 @@ exports.initCommand = new commander_1.Command('init')
         if (options.exclude) {
             exclude = options.exclude.split(',').map((d) => d.trim()).filter(Boolean);
         }
-        // Scan project first (skip scripts initially)
-        const spinner = (0, ora_1.default)('Scanning project...').start();
+        let scan;
         const scanner = new scanner_1.ProjectScanner();
-        let scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
-        spinner.succeed('Project scanned');
+        // 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 {
+            // 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');
+        }
         // Display scan results
         console.log('');
         console.log(chalk_1.default.bold('Detected:'));
@@ -213,9 +448,10 @@ exports.initCommand = new commander_1.Command('init')
             console.log(`  ${chalk_1.default.dim('Frameworks:')} ${frameworkStr}`);
         }
         // 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) {
+        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 => ({
@@ -232,6 +468,14 @@ exports.initCommand = new commander_1.Command('init')
             // 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)) {
@@ -248,17 +492,17 @@ exports.initCommand = new commander_1.Command('init')
             console.log(`  ${chalk_1.default.dim('Git:')}        ${scan.git.remote} (${scan.git.type})`);
         }
         console.log('');
-        // Get project name
-        const projectName = nonInteractive
+        // 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
+        // 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) {
+            if (nonInteractive || options.fromScan) {
                 isWorkspace = true; // Default to workspace for monorepos
             }
             else {
@@ -271,25 +515,25 @@ exports.initCommand = new commander_1.Command('init')
         // Generate initial config (v2 format)
         const generator = new config_generator_1.ConfigGenerator();
         const generated = generator.generate(scan);
-        // Convert to v3 format
-        const v3Config = convertV2ToV3(generated.config, scan);
+        // Convert to v4 format (declarative-first architecture)
+        const v4Config = convertV2ToV4(generated.config, scan);
         // Update project name
-        v3Config.project.name = projectName;
-        // Ask about profiles
+        v4Config.project.name = projectName;
+        // Ask about profiles (skip prompt when using --from-scan)
         let createProfiles = true;
-        if (!nonInteractive) {
+        if (!nonInteractive && !options.fromScan) {
             createProfiles = await prompts.confirm({
                 message: 'Create predefined profiles for common scenarios?',
                 default: true,
             });
         }
         if (createProfiles) {
-            v3Config.profiles = nonInteractive
-                ? createDefaultProfilesSync(scan, v3Config)
-                : await createDefaultProfiles(scan, v3Config);
+            v4Config.profiles = (nonInteractive || options.fromScan)
+                ? createDefaultProfilesSync(scan, v4Config)
+                : await createDefaultProfiles(scan, v4Config);
         }
-        // Get server size
-        const serverSize = nonInteractive
+        // Get server size (use defaults when --from-scan)
+        const serverSize = (nonInteractive || options.fromScan)
             ? generated.config.system.size
             : await prompts.select({
                 message: 'Default server size:',
@@ -301,13 +545,99 @@ exports.initCommand = new commander_1.Command('init')
                 ],
                 default: generated.config.system.size,
             });
-        if (!v3Config.defaults) {
-            v3Config.defaults = {};
+        if (!v4Config.defaults) {
+            v4Config.defaults = {};
         }
-        v3Config.defaults.size = serverSize;
+        v4Config.defaults.size = serverSize;
         // 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 (isMultiRepo) {
+        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.'));
+                    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('');
+                    let gitToken = await prompts.password({
+                        message: 'GitHub Personal Access Token (leave empty to skip):',
+                    });
+                    if (gitToken) {
+                        // Strip any "GIT_TOKEN=" prefix if user pasted the whole line
+                        gitToken = gitToken.replace(/^GIT_TOKEN=/i, '');
+                        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.'));
+                    let gitToken = await prompts.password({
+                        message: 'GitHub Personal Access Token (leave empty to skip):',
+                    });
+                    if (gitToken) {
+                        // Strip any "GIT_TOKEN=" prefix if user pasted the whole line
+                        gitToken = gitToken.replace(/^GIT_TOKEN=/i, '');
+                        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) {
@@ -324,11 +654,11 @@ exports.initCommand = new commander_1.Command('init')
                     choices: repoChoices,
                 });
                 if (selectedRepos.length > 0) {
-                    v3Config.repos = {};
+                    v4Config.repos = {};
                     let hasHttpsRepos = false;
                     for (const repoName of selectedRepos) {
                         const repo = appGitRepos.find(r => r.appName === repoName);
-                        v3Config.repos[repo.appName] = {
+                        v4Config.repos[repo.appName] = {
                             url: repo.remote,
                             path: `/home/dev/${projectName}/${repo.appPath}`,
                             branch: repo.branch !== 'main' && repo.branch !== 'master' ? repo.branch : undefined,
@@ -349,10 +679,12 @@ exports.initCommand = new commander_1.Command('init')
                         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('');
-                        const gitToken = await prompts.password({
+                        let gitToken = await prompts.password({
                             message: 'GitHub Personal Access Token (leave empty to skip):',
                         });
                         if (gitToken) {
+                            // Strip any "GIT_TOKEN=" prefix if user pasted the whole line
+                            gitToken = gitToken.replace(/^GIT_TOKEN=/i, '');
                             envVarsToAdd['GIT_TOKEN'] = gitToken;
                             console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
                         }
@@ -364,9 +696,9 @@ exports.initCommand = new commander_1.Command('init')
             }
             else if (appGitRepos.length > 0) {
                 // Non-interactive: include all repos
-                v3Config.repos = {};
+                v4Config.repos = {};
                 for (const repo of appGitRepos) {
-                    v3Config.repos[repo.appName] = {
+                    v4Config.repos[repo.appName] = {
                         url: repo.remote,
                         path: `/home/dev/${projectName}/${repo.appPath}`,
                         auth: repo.type === 'ssh' ? 'ssh' : 'token',
@@ -378,7 +710,7 @@ exports.initCommand = new commander_1.Command('init')
             // Single repo or monorepo with root git
             if (nonInteractive) {
                 const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
-                v3Config.repos = {
+                v4Config.repos = {
                     [repoName]: {
                         url: scan.git.remote,
                         path: `/home/dev/${repoName}`,
@@ -389,10 +721,7 @@ exports.initCommand = new commander_1.Command('init')
             else {
                 const gitConfig = await setupGitAuth(scan.git, projectName);
                 if (gitConfig.repos) {
-                    v3Config.repos = gitConfig.repos;
-                }
-                if (gitConfig.git_auth) {
-                    v3Config.git_auth = gitConfig.git_auth;
+                    v4Config.repos = gitConfig.repos;
                 }
             }
         }
@@ -415,7 +744,7 @@ exports.initCommand = new commander_1.Command('init')
                     },
                 });
                 const repoName = path_1.default.basename(repoUrl, '.git');
-                v3Config.repos = {
+                v4Config.repos = {
                     [repoName]: {
                         url: repoUrl,
                         path: `/home/dev/${repoName}`,
@@ -424,15 +753,16 @@ exports.initCommand = new commander_1.Command('init')
                 };
             }
         }
-        // Environment configuration (skip in non-interactive mode)
+        // Environment configuration (skip only in non-interactive mode)
+        // For --from-scan, we still want to prompt for environments since they're required for genbox to work
         if (!nonInteractive) {
-            const envConfig = await setupEnvironments(scan, v3Config, isMultiRepo);
+            const envConfig = await setupEnvironments(scan, v4Config, isMultiRepo);
             if (envConfig) {
-                v3Config.environments = envConfig;
+                v4Config.environments = envConfig;
             }
         }
-        // Script selection - always show multi-select UI (skip in non-interactive mode)
-        if (!nonInteractive) {
+        // 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 });
@@ -463,7 +793,7 @@ exports.initCommand = new commander_1.Command('init')
                     choices: scriptChoices,
                 });
                 if (selectedScripts.length > 0) {
-                    v3Config.scripts = fullScan.scripts
+                    v4Config.scripts = fullScan.scripts
                         .filter(s => selectedScripts.includes(s.path))
                         .map(s => ({
                         name: s.name,
@@ -477,7 +807,7 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // Save configuration
-        const yamlContent = yaml.dump(v3Config, {
+        const yamlContent = yaml.dump(v4Config, {
             lineWidth: 120,
             noRefs: true,
             quotingType: '"',
@@ -487,19 +817,29 @@ exports.initCommand = new commander_1.Command('init')
         // Add API URLs from environments to envVarsToAdd
         // Always add LOCAL_API_URL for local development
         envVarsToAdd['LOCAL_API_URL'] = 'http://localhost:3050';
-        if (v3Config.environments) {
-            for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
-                const apiUrl = envConfig.api?.api ||
-                    envConfig.api?.url ||
-                    envConfig.api?.gateway;
+        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, v3Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting);
+        await setupEnvFile(projectName, v4Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting, detectedServiceUrls);
         // Show warnings
         if (generated.warnings.length > 0) {
             console.log('');
@@ -509,16 +849,15 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // Show API URL guidance if environments are configured
-        if (v3Config.environments && Object.keys(v3Config.environments).length > 0) {
+        if (v4Config.environments && Object.keys(v4Config.environments).length > 0) {
             console.log('');
             console.log(chalk_1.default.blue('=== API URL Configuration ==='));
             console.log(chalk_1.default.dim('The following API URLs were added to .env.genbox:'));
             console.log('');
             console.log(chalk_1.default.dim('  LOCAL_API_URL=http://localhost:3050'));
-            for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
-                const apiUrl = envConfig.api?.api ||
-                    envConfig.api?.url ||
-                    envConfig.api?.gateway;
+            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`;
                     console.log(chalk_1.default.dim(`  ${varName}=${apiUrl}`));
@@ -531,9 +870,9 @@ exports.initCommand = new commander_1.Command('init')
             console.log(chalk_1.default.cyan('    NEXT_PUBLIC_API_URL=${API_URL}'));
             console.log('');
             console.log(chalk_1.default.dim('  At create time, ${API_URL} expands based on profile:'));
-            console.log(chalk_1.default.dim('    • connect_to: staging → uses STAGING_API_URL'));
-            console.log(chalk_1.default.dim('    • connect_to: production → uses PRODUCTION_API_URL'));
-            console.log(chalk_1.default.dim('    • local/no connect_to → uses LOCAL_API_URL'));
+            console.log(chalk_1.default.dim('    • default_connection: staging → uses STAGING_API_URL'));
+            console.log(chalk_1.default.dim('    • default_connection: production → uses PRODUCTION_API_URL'));
+            console.log(chalk_1.default.dim('    • local/no default_connection → uses LOCAL_API_URL'));
         }
         // Next steps
         console.log('');
@@ -566,13 +905,13 @@ function createProfilesFromScan(scan) {
     const frontendApps = scan.apps.filter(a => a.type === 'frontend');
     const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
     const hasApi = scan.apps.some(a => a.name === 'api' || a.type === 'backend');
-    // Quick UI profiles for each frontend
+    // Quick UI profiles for each frontend (v4: use default_connection instead of connect_to)
     for (const frontend of frontendApps.slice(0, 3)) {
         profiles[`${frontend.name}-quick`] = {
             description: `${frontend.name} only, connected to staging`,
             size: 'small',
             apps: [frontend.name],
-            connect_to: 'staging',
+            default_connection: 'staging',
         };
     }
     // Full local development
@@ -599,13 +938,13 @@ function createProfilesFromScan(scan) {
             },
         };
     }
-    // All frontends + staging
+    // All frontends + staging (v4: use default_connection)
     if (frontendApps.length > 1) {
         profiles['frontends-staging'] = {
             description: 'All frontends with staging backend',
             size: 'medium',
             apps: frontendApps.map(a => a.name),
-            connect_to: 'staging',
+            default_connection: 'staging',
         };
     }
     // Full stack
@@ -639,14 +978,12 @@ async function setupGitAuth(gitInfo, projectName) {
         default: 'token',
     });
     let repoUrl = gitInfo.remote;
-    let git_auth;
     if (authMethod === 'token') {
         // Convert SSH to HTTPS if needed
         if (gitInfo.type === 'ssh') {
             repoUrl = (0, scan_1.sshToHttps)(gitInfo.remote);
             console.log(chalk_1.default.dim(`  Will use HTTPS: ${repoUrl}`));
         }
-        git_auth = { method: 'token' };
         // Show token setup instructions
         console.log('');
         console.log(chalk_1.default.yellow('  Add your token to .env.genbox:'));
@@ -677,7 +1014,6 @@ async function setupGitAuth(gitInfo, projectName) {
                 });
             }
         }
-        git_auth = { method: 'ssh', ssh_key_path: sshKeyPath };
         console.log('');
         console.log(chalk_1.default.yellow('  Add your SSH key to .env.genbox:'));
         console.log(chalk_1.default.white(`    GIT_SSH_KEY="$(cat ${sshKeyPath})"`));
@@ -691,11 +1027,10 @@ async function setupGitAuth(gitInfo, projectName) {
                 auth: authMethod === 'public' ? undefined : authMethod,
             },
         },
-        git_auth,
     };
 }
 /**
- * Setup staging/production environments
+ * Setup staging/production environments (v4 format)
  */
 async function setupEnvironments(scan, config, isMultiRepo = false) {
     const setupEnvs = await prompts.confirm({
@@ -716,22 +1051,23 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
         const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
         if (backendApps.length > 0) {
             console.log(chalk_1.default.dim('Configure staging API URLs for each backend service:'));
-            const stagingApi = {};
+            const urls = {};
             for (const app of backendApps) {
                 const url = await prompts.input({
                     message: `  ${app.name} staging URL (leave empty to skip):`,
                     default: '',
                 });
                 if (url) {
-                    stagingApi[app.name] = url;
+                    urls[app.name] = url;
                 }
             }
-            if (Object.keys(stagingApi).length > 0) {
+            if (Object.keys(urls).length > 0) {
+                // Add database URLs
+                urls['mongodb'] = '${STAGING_MONGODB_URL}';
+                urls['redis'] = '${STAGING_REDIS_URL}';
                 environments.staging = {
                     description: 'Staging environment',
-                    api: stagingApi,
-                    mongodb: { url: '${STAGING_MONGODB_URL}' },
-                    redis: { url: '${STAGING_REDIS_URL}' },
+                    urls,
                 };
             }
         }
@@ -744,9 +1080,11 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             if (stagingApiUrl) {
                 environments.staging = {
                     description: 'Staging environment',
-                    api: { gateway: stagingApiUrl },
-                    mongodb: { url: '${STAGING_MONGODB_URL}' },
-                    redis: { url: '${STAGING_REDIS_URL}' },
+                    urls: {
+                        api: stagingApiUrl,
+                        mongodb: '${STAGING_MONGODB_URL}',
+                        redis: '${STAGING_REDIS_URL}',
+                    },
                 };
             }
         }
@@ -760,9 +1098,11 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
         if (stagingApiUrl) {
             environments.staging = {
                 description: 'Staging environment',
-                api: { gateway: stagingApiUrl },
-                mongodb: { url: '${STAGING_MONGODB_URL}' },
-                redis: { url: '${STAGING_REDIS_URL}' },
+                urls: {
+                    api: stagingApiUrl,
+                    mongodb: '${STAGING_MONGODB_URL}',
+                    redis: '${STAGING_REDIS_URL}',
+                },
             };
         }
     }
@@ -775,23 +1115,24 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
             if (backendApps.length > 0) {
                 console.log(chalk_1.default.dim('Configure production API URLs for each backend service:'));
-                const prodApi = {};
+                const prodUrls = {};
                 for (const app of backendApps) {
                     const url = await prompts.input({
                         message: `  ${app.name} production URL:`,
                         default: '',
                     });
                     if (url) {
-                        prodApi[app.name] = url;
+                        prodUrls[app.name] = url;
                     }
                 }
-                if (Object.keys(prodApi).length > 0) {
+                if (Object.keys(prodUrls).length > 0) {
+                    prodUrls['mongodb'] = '${PROD_MONGODB_URL}';
                     environments.production = {
                         description: 'Production (use with caution)',
-                        api: prodApi,
-                        mongodb: {
-                            url: '${PROD_MONGODB_URL}',
+                        urls: prodUrls,
+                        safety: {
                             read_only: true,
+                            require_confirmation: true,
                         },
                     };
                 }
@@ -805,10 +1146,13 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             if (prodApiUrl) {
                 environments.production = {
                     description: 'Production (use with caution)',
-                    api: { gateway: prodApiUrl },
-                    mongodb: {
-                        url: '${PROD_MONGODB_URL}',
+                    urls: {
+                        api: prodApiUrl,
+                        mongodb: '${PROD_MONGODB_URL}',
+                    },
+                    safety: {
                         read_only: true,
+                        require_confirmation: true,
                     },
                 };
             }
@@ -819,7 +1163,7 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
 /**
  * Setup .env.genbox file with segregated app sections
  */
-async function setupEnvFile(projectName, config, nonInteractive = false, scan, isMultiRepo = false, extraEnvVars = {}, overwriteExisting = false) {
+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)) {
@@ -932,6 +1276,52 @@ async function setupEnvFile(projectName, config, nonInteractive = false, scan, i
             }
         }
     }
+    // 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);
+            }
+        }
+    }
+    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,
+                });
+            }
+            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) {
+            // Get existing staging API URL if configured
+            const existingStagingApiUrl = extraEnvVars['STAGING_API_URL'] ||
+                (config.environments?.staging?.urls?.api);
+            // Prompt for staging equivalents
+            const urlMappings = await promptForStagingUrls(serviceUrls, existingStagingApiUrl);
+            // Transform content with expandable variables
+            if (urlMappings.length > 0) {
+                segregatedContent = transformEnvWithVariables(segregatedContent, urlMappings, frontendApps);
+                console.log('');
+                console.log(chalk_1.default.green(`✓ Configured ${urlMappings.length} service URL(s) for staging support`));
+            }
+        }
+    }
     // Add END marker
     segregatedContent += `# === END ===\n`;
     // Write the file
@@ -1031,10 +1421,10 @@ function generateEnvTemplate(projectName, config) {
     return lines.join('\n');
 }
 /**
- * Convert GenboxConfigV2 to GenboxConfigV3 format
+ * Convert GenboxConfigV2 to GenboxConfigV4 format
  */
-function convertV2ToV3(v2Config, scan) {
-    // Convert services to apps
+function convertV2ToV4(v2Config, scan) {
+    // Convert services to apps (v4 format)
     const apps = {};
     for (const [name, service] of Object.entries(v2Config.services || {})) {
         const appConfig = {
@@ -1046,10 +1436,13 @@ function convertV2ToV3(v2Config, scan) {
         if (service.framework) {
             appConfig.framework = service.framework;
         }
-        // Only add requires if there are dependencies
+        // Convert requires to connects_to (v4 format)
         if (service.dependsOn?.length) {
-            appConfig.requires = service.dependsOn.reduce((acc, dep) => {
-                acc[dep] = 'required';
+            appConfig.connects_to = service.dependsOn.reduce((acc, dep) => {
+                acc[dep] = {
+                    mode: 'local',
+                    required: true,
+                };
                 return acc;
             }, {});
         }
@@ -1070,11 +1463,11 @@ function convertV2ToV3(v2Config, scan) {
         }
         apps[name] = appConfig;
     }
-    // Convert infrastructure
-    const infrastructure = {};
+    // Convert infrastructure to provides (v4 format)
+    const provides = {};
     if (v2Config.infrastructure?.databases) {
         for (const db of v2Config.infrastructure.databases) {
-            infrastructure[db.container || db.type] = {
+            provides[db.container || db.type] = {
                 type: 'database',
                 image: `${db.type}:latest`,
                 port: db.port,
@@ -1083,7 +1476,7 @@ function convertV2ToV3(v2Config, scan) {
     }
     if (v2Config.infrastructure?.caches) {
         for (const cache of v2Config.infrastructure.caches) {
-            infrastructure[cache.container || cache.type] = {
+            provides[cache.container || cache.type] = {
                 type: 'cache',
                 image: `${cache.type}:latest`,
                 port: cache.port,
@@ -1092,15 +1485,15 @@ function convertV2ToV3(v2Config, scan) {
     }
     if (v2Config.infrastructure?.queues) {
         for (const queue of v2Config.infrastructure.queues) {
-            infrastructure[queue.container || queue.type] = {
+            provides[queue.container || queue.type] = {
                 type: 'queue',
                 image: `${queue.type}:latest`,
                 port: queue.port,
-                management_port: queue.managementPort,
+                additional_ports: queue.managementPort ? { management: queue.managementPort } : undefined,
             };
         }
     }
-    // Convert repos
+    // Convert repos (v4 format)
     const repos = {};
     for (const [name, repo] of Object.entries(v2Config.repos || {})) {
         repos[name] = {
@@ -1110,18 +1503,25 @@ function convertV2ToV3(v2Config, scan) {
             auth: repo.auth,
         };
     }
-    // Build v3 config
-    const v3Config = {
-        version: '3.0',
+    // 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: v2Config.project.structure === 'single-app' ? 'single-app' :
-                v2Config.project.structure.startsWith('monorepo') ? 'monorepo' :
-                    v2Config.project.structure,
+            structure: structureMap[v2Config.project.structure] || 'single-app',
             description: v2Config.project.description,
         },
         apps,
-        infrastructure: Object.keys(infrastructure).length > 0 ? infrastructure : undefined,
+        provides: Object.keys(provides).length > 0 ? provides : undefined,
         repos: Object.keys(repos).length > 0 ? repos : undefined,
         defaults: {
             size: v2Config.system.size,
@@ -1131,6 +1531,135 @@ function convertV2ToV3(v2Config, scan) {
             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',
+        };
+        apps.push({
+            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 || '',
+            } : {},
+        });
+    }
+    // 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
+    let compose = null;
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        compose = {
+            files: ['docker-compose.yml'],
+            applications: [],
+            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(),
+        };
+    }
+    // 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,
     };
-    return v3Config;
 }