genbox 1.0.15 → 1.0.16

package/dist/commands/create.js

@@ -319,10 +319,46 @@ function parseEnvGenboxSections(content) {
     }
     return sections;
 }
+/**
+ * Build a map of service URL variables based on connection type
+ * e.g., if connectTo=staging: GATEWAY_URL → STAGING_GATEWAY_URL value
+ */
+function buildServiceUrlMap(envVarsFromFile, connectTo) {
+    const urlMap = {};
+    const prefix = connectTo ? `${connectTo.toUpperCase()}_` : 'LOCAL_';
+    // Find all service URL variables (LOCAL_*_URL and STAGING_*_URL patterns)
+    const serviceNames = new Set();
+    for (const key of Object.keys(envVarsFromFile)) {
+        const match = key.match(/^(LOCAL|STAGING|PRODUCTION)_(.+_URL)$/);
+        if (match) {
+            serviceNames.add(match[2]);
+        }
+    }
+    // Build mapping: VARNAME → value from appropriate prefix
+    for (const serviceName of serviceNames) {
+        const prefixedKey = `${prefix}${serviceName}`;
+        const localKey = `LOCAL_${serviceName}`;
+        // Use prefixed value if available, otherwise fall back to local
+        const value = envVarsFromFile[prefixedKey] || envVarsFromFile[localKey];
+        if (value) {
+            urlMap[serviceName] = value;
+        }
+    }
+    // Also handle legacy API_URL for backwards compatibility
+    if (!urlMap['API_URL']) {
+        const apiUrl = envVarsFromFile[`${prefix}API_URL`] ||
+            envVarsFromFile['LOCAL_API_URL'] ||
+            envVarsFromFile['STAGING_API_URL'];
+        if (apiUrl) {
+            urlMap['API_URL'] = apiUrl;
+        }
+    }
+    return urlMap;
+}
 /**
  * Build env content for a specific app by combining GLOBAL + app-specific sections
  */
-function buildAppEnvContent(sections, appName, apiUrl) {
+function buildAppEnvContent(sections, appName, serviceUrlMap) {
     const parts = [];
     // Always include GLOBAL section
     const globalSection = sections.get('GLOBAL');
@@ -335,8 +371,11 @@ function buildAppEnvContent(sections, appName, apiUrl) {
         parts.push(appSection);
     }
     let envContent = parts.join('\n\n');
-    // Expand ${API_URL} references
-    envContent = envContent.replace(/\$\{API_URL\}/g, apiUrl);
+    // Expand all ${VARNAME} references using the service URL map
+    for (const [varName, value] of Object.entries(serviceUrlMap)) {
+        const pattern = new RegExp(`\\$\\{${varName}\\}`, 'g');
+        envContent = envContent.replace(pattern, value);
+    }
     // Keep only actual env vars (filter out pure comment lines but keep var definitions)
     envContent = envContent
         .split('\n')
@@ -393,21 +432,19 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
                 envVarsFromFile[match[1]] = value;
             }
         }
-        // Determine API_URL based on profile's connect_to (v3) or default_connection (v4)
+        // Determine connection type from profile's connect_to (v3) or default_connection (v4)
         let connectTo;
         if (resolved.profile && config.profiles?.[resolved.profile]) {
             const profile = config.profiles[resolved.profile];
             connectTo = (0, config_loader_1.getProfileConnection)(profile);
         }
-        let apiUrl;
-        if (connectTo) {
-            // Use the environment-specific API URL (e.g., STAGING_API_URL)
-            const envApiVarName = `${connectTo.toUpperCase()}_API_URL`;
-            apiUrl = envVarsFromFile[envApiVarName] || resolved.env['API_URL'] || 'http://localhost:3050';
-        }
-        else {
-            // Use local API URL
-            apiUrl = envVarsFromFile['LOCAL_API_URL'] || 'http://localhost:3050';
+        // Build service URL map for variable expansion
+        // This maps GATEWAY_URL → STAGING_GATEWAY_URL value (if connectTo=staging)
+        // or GATEWAY_URL → LOCAL_GATEWAY_URL value (if local)
+        const serviceUrlMap = buildServiceUrlMap(envVarsFromFile, connectTo);
+        // Log what's being expanded for debugging
+        if (connectTo && Object.keys(serviceUrlMap).length > 0) {
+            console.log(chalk_1.default.dim(`  Using ${connectTo} URLs for variable expansion`));
         }
         // Add env file for each app - filtered by selected apps only
         for (const app of resolved.apps) {
@@ -421,7 +458,7 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
                 for (const serviceSectionName of servicesSections) {
                     const serviceName = serviceSectionName.split('/')[1];
                     // Build service-specific env content (GLOBAL + service section)
-                    const serviceEnvContent = buildAppEnvContent(sections, serviceSectionName, apiUrl);
+                    const serviceEnvContent = buildAppEnvContent(sections, serviceSectionName, serviceUrlMap);
                     const stagingName = `${app.name}-${serviceName}.env`;
                     const targetPath = `${repoPath}/apps/${serviceName}/.env`;
                     files.push({
@@ -434,7 +471,7 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
             }
             else {
                 // Regular app - build app-specific env content (GLOBAL + app section)
-                const appEnvContent = buildAppEnvContent(sections, app.name, apiUrl);
+                const appEnvContent = buildAppEnvContent(sections, app.name, serviceUrlMap);
                 files.push({
                     path: `/home/dev/.env-staging/${app.name}.env`,
                     content: appEnvContent,

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)
  */
@@ -385,10 +596,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'));
                     }
@@ -412,10 +625,12 @@ exports.initCommand = new commander_1.Command('init')
                 if (scan.git.type === 'https' && !nonInteractive) {
                     console.log('');
                     console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
-                    const gitToken = await 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'));
                     }
@@ -464,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'));
                         }
@@ -610,8 +827,19 @@ exports.initCommand = new commander_1.Command('init')
                 }
             }
         }
+        // Load detected service URLs if using --from-scan
+        let detectedServiceUrls;
+        if (options.fromScan) {
+            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
+            try {
+                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
+                const detectedConfig = yaml.load(content);
+                detectedServiceUrls = detectedConfig.service_urls;
+            }
+            catch { }
+        }
         // Generate .env.genbox
-        await setupEnvFile(projectName, v4Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting);
+        await setupEnvFile(projectName, v4Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting, detectedServiceUrls);
         // Show warnings
         if (generated.warnings.length > 0) {
             console.log('');
@@ -935,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)) {
@@ -1048,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

package/dist/commands/scan.js

@@ -12,6 +12,7 @@
  *   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;
@@ -52,6 +53,7 @@ var __importDefault = (this && this.__importDefault) || function (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"));
@@ -109,9 +111,11 @@ exports.scanCommand = new commander_1.Command('scan')
     .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('-e, --exclude <patterns>', 'Comma-separated patterns to exclude', '')
     .action(async (options) => {
     const cwd = process.cwd();
+    const isInteractive = options.interactive && !options.stdout && process.stdin.isTTY;
     console.log(chalk_1.default.cyan('\n🔍 Scanning project...\n'));
     try {
         // Run the scanner
@@ -122,7 +126,21 @@ exports.scanCommand = new commander_1.Command('scan')
             skipScripts: !options.scripts,
         });
         // Convert scan result to DetectedConfig format
-        const detected = convertScanToDetected(scan, cwd);
+        let detected = convertScanToDetected(scan, cwd);
+        // Interactive mode: let user select apps
+        if (isInteractive && Object.keys(detected.apps).length > 0) {
+            detected = await interactiveAppSelection(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) {
+            const serviceUrls = scanEnvFilesForUrls(detected.apps, cwd);
+            if (serviceUrls.length > 0) {
+                detected.service_urls = serviceUrls;
+            }
+        }
         // Output
         if (options.stdout) {
             outputToStdout(detected, options.json);
@@ -133,10 +151,156 @@ exports.scanCommand = new commander_1.Command('scan')
         }
     }
     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 selection
+ */
+async function interactiveAppSelection(detected) {
+    const appEntries = Object.entries(detected.apps);
+    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 choices = 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 in detected.yaml:',
+        choices,
+    });
+    // Filter apps to only selected ones
+    const filteredApps = {};
+    for (const appName of selectedApps) {
+        filteredApps[appName] = detected.apps[appName];
+    }
+    return {
+        ...detected,
+        apps: filteredApps,
+    };
+}
+/**
+ * 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;
+        let envSource;
+        for (const pattern of envPatterns) {
+            const envPath = path.join(appDir, pattern);
+            if (fs.existsSync(envPath)) {
+                envContent = fs.readFileSync(envPath, 'utf8');
+                envSource = pattern;
+                break;
+            }
+        }
+        if (!envContent)
+            continue;
+        // Find all HTTP URLs
+        const urlRegex = /^([A-Z_][A-Z0-9_]*)=["']?(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?[^"'\s]*)["']?/gm;
+        let match;
+        while ((match = urlRegex.exec(envContent)) !== null) {
+            const varName = match[1];
+            const fullUrl = match[2];
+            // Extract hostname
+            const hostMatch = fullUrl.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;
+            // Extract base URL
+            const baseMatch = fullUrl.match(/^(https?:\/\/[a-zA-Z0-9_.-]+(?::\d+)?)/);
+            if (!baseMatch)
+                continue;
+            const baseUrl = baseMatch[1];
+            // 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
  */
@@ -408,6 +572,15 @@ function showSummary(detected) {
             console.log(chalk_1.default.dim(`      ${git.remote}`));
         }
     }
+    // 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');

package/package.json

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