genbox 1.0.15 → 1.0.17

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)
  */
@@ -154,6 +365,81 @@ function findAppEnvFiles(apps, rootDir) {
     }
     return envFiles;
 }
+/**
+ * Read existing values from .env.genbox file
+ */
+function readExistingEnvGenbox() {
+    const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
+    const values = {};
+    if (!fs_1.default.existsSync(envPath)) {
+        return values;
+    }
+    try {
+        const content = fs_1.default.readFileSync(envPath, 'utf8');
+        for (const line of content.split('\n')) {
+            // Skip comments and empty lines
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            // Parse KEY=value
+            const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+            if (match) {
+                let value = match[2].trim();
+                // Remove quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                values[match[1]] = value;
+            }
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return values;
+}
+/**
+ * Mask a secret value for display (show first 4 and last 4 chars)
+ */
+function maskSecret(value) {
+    if (value.length <= 8) {
+        return '*'.repeat(value.length);
+    }
+    return value.slice(0, 4) + '*'.repeat(value.length - 8) + value.slice(-4);
+}
+/**
+ * Prompt for a secret with existing value support
+ */
+async function promptForSecret(message, existingValue, options = {}) {
+    if (existingValue) {
+        console.log(chalk_1.default.dim(`  Found existing value: ${maskSecret(existingValue)}`));
+        const useExisting = await prompts.confirm({
+            message: 'Use existing value?',
+            default: true,
+        });
+        if (useExisting) {
+            return existingValue;
+        }
+    }
+    if (options.showInstructions) {
+        console.log('');
+        console.log(chalk_1.default.dim('  To create a token:'));
+        console.log(chalk_1.default.dim('  1. Go to https://github.com/settings/tokens'));
+        console.log(chalk_1.default.dim('  2. Click "Generate new token" → "Classic"'));
+        console.log(chalk_1.default.dim('  3. Select scope: "repo" (Full control of private repositories)'));
+        console.log(chalk_1.default.dim('  4. Generate and copy the token'));
+        console.log('');
+    }
+    let value = await prompts.password({
+        message,
+    });
+    if (value) {
+        // Strip any "KEY=" prefix if user pasted the whole line
+        value = value.replace(/^[A-Z_]+=/, '');
+    }
+    return value || undefined;
+}
 exports.initCommand = new commander_1.Command('init')
     .description('Initialize a new Genbox configuration')
     .option('--v2', 'Use legacy v2 format (single-app only)')
@@ -186,6 +472,8 @@ exports.initCommand = new commander_1.Command('init')
         }
         console.log(chalk_1.default.blue('Initializing Genbox...'));
         console.log('');
+        // Read existing .env.genbox values (for defaults when overwriting)
+        const existingEnvValues = readExistingEnvGenbox();
         // Track env vars to add to .env.genbox
         const envVarsToAdd = {};
         // Get initial exclusions from CLI options only
@@ -378,16 +666,7 @@ exports.initCommand = new commander_1.Command('init')
                 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('');
-                    const gitToken = await prompts.password({
-                        message: 'GitHub Personal Access Token (leave empty to skip):',
-                    });
+                    const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
                     if (gitToken) {
                         envVarsToAdd['GIT_TOKEN'] = gitToken;
                         console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
@@ -412,9 +691,7 @@ 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({
-                        message: 'GitHub Personal Access Token (leave empty to skip):',
-                    });
+                    const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
                     if (gitToken) {
                         envVarsToAdd['GIT_TOKEN'] = gitToken;
                         console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
@@ -457,16 +734,7 @@ exports.initCommand = new commander_1.Command('init')
                     if (hasHttpsRepos) {
                         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('');
-                        const gitToken = await prompts.password({
-                            message: 'GitHub Personal Access Token (leave empty to skip):',
-                        });
+                        const gitToken = await promptForSecret('GitHub Personal Access Token (leave empty to skip):', existingEnvValues['GIT_TOKEN'], { showInstructions: !existingEnvValues['GIT_TOKEN'] });
                         if (gitToken) {
                             envVarsToAdd['GIT_TOKEN'] = gitToken;
                             console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
@@ -539,7 +807,7 @@ exports.initCommand = new commander_1.Command('init')
         // 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, v4Config, isMultiRepo);
+            const envConfig = await setupEnvironments(scan, v4Config, isMultiRepo, existingEnvValues);
             if (envConfig) {
                 v4Config.environments = envConfig;
             }
@@ -610,8 +878,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('');
@@ -804,7 +1083,7 @@ async function setupGitAuth(gitInfo, projectName) {
 /**
  * Setup staging/production environments (v4 format)
  */
-async function setupEnvironments(scan, config, isMultiRepo = false) {
+async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvValues = {}) {
     const setupEnvs = await prompts.confirm({
         message: 'Configure staging/production environments?',
         default: true,
@@ -818,6 +1097,9 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
     console.log(chalk_1.default.dim('Actual secrets go in .env.genbox'));
     console.log('');
     const environments = {};
+    // Get existing staging API URL if available
+    const existingStagingApiUrl = existingEnvValues['STAGING_API_URL'];
+    const existingProductionApiUrl = existingEnvValues['PRODUCTION_API_URL'] || existingEnvValues['PROD_API_URL'];
     if (isMultiRepo) {
         // For multi-repo: configure API URLs per backend app
         const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
@@ -825,6 +1107,20 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             console.log(chalk_1.default.dim('Configure staging API URLs for each backend service:'));
             const urls = {};
             for (const app of backendApps) {
+                // Check for existing app-specific URL or use general staging URL for 'api' app
+                const existingUrl = existingEnvValues[`STAGING_${app.name.toUpperCase()}_URL`] ||
+                    (app.name === 'api' ? existingStagingApiUrl : '');
+                if (existingUrl) {
+                    console.log(chalk_1.default.dim(`  Found existing value for ${app.name}: ${existingUrl}`));
+                    const useExisting = await prompts.confirm({
+                        message: `  Use existing ${app.name} staging URL?`,
+                        default: true,
+                    });
+                    if (useExisting) {
+                        urls[app.name] = existingUrl;
+                        continue;
+                    }
+                }
                 const url = await prompts.input({
                     message: `  ${app.name} staging URL (leave empty to skip):`,
                     default: '',
@@ -845,10 +1141,23 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
         }
         else {
             // No backend apps, just ask for a single URL
-            const stagingApiUrl = await prompts.input({
-                message: 'Staging API URL (leave empty to skip):',
-                default: '',
-            });
+            let stagingApiUrl = '';
+            if (existingStagingApiUrl) {
+                console.log(chalk_1.default.dim(`  Found existing value: ${existingStagingApiUrl}`));
+                const useExisting = await prompts.confirm({
+                    message: 'Use existing staging API URL?',
+                    default: true,
+                });
+                if (useExisting) {
+                    stagingApiUrl = existingStagingApiUrl;
+                }
+            }
+            if (!stagingApiUrl) {
+                stagingApiUrl = await prompts.input({
+                    message: 'Staging API URL (leave empty to skip):',
+                    default: '',
+                });
+            }
             if (stagingApiUrl) {
                 environments.staging = {
                     description: 'Staging environment',
@@ -863,10 +1172,23 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
     }
     else {
         // Single repo: simple single URL
-        const stagingApiUrl = await prompts.input({
-            message: 'Staging API URL (leave empty to skip):',
-            default: '',
-        });
+        let stagingApiUrl = '';
+        if (existingStagingApiUrl) {
+            console.log(chalk_1.default.dim(`  Found existing value: ${existingStagingApiUrl}`));
+            const useExisting = await prompts.confirm({
+                message: 'Use existing staging API URL?',
+                default: true,
+            });
+            if (useExisting) {
+                stagingApiUrl = existingStagingApiUrl;
+            }
+        }
+        if (!stagingApiUrl) {
+            stagingApiUrl = await prompts.input({
+                message: 'Staging API URL (leave empty to skip):',
+                default: '',
+            });
+        }
         if (stagingApiUrl) {
             environments.staging = {
                 description: 'Staging environment',
@@ -889,6 +1211,21 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
                 console.log(chalk_1.default.dim('Configure production API URLs for each backend service:'));
                 const prodUrls = {};
                 for (const app of backendApps) {
+                    // Check for existing app-specific URL or use general production URL for 'api' app
+                    const existingUrl = existingEnvValues[`PRODUCTION_${app.name.toUpperCase()}_URL`] ||
+                        existingEnvValues[`PROD_${app.name.toUpperCase()}_URL`] ||
+                        (app.name === 'api' ? existingProductionApiUrl : '');
+                    if (existingUrl) {
+                        console.log(chalk_1.default.dim(`  Found existing value for ${app.name}: ${existingUrl}`));
+                        const useExisting = await prompts.confirm({
+                            message: `  Use existing ${app.name} production URL?`,
+                            default: true,
+                        });
+                        if (useExisting) {
+                            prodUrls[app.name] = existingUrl;
+                            continue;
+                        }
+                    }
                     const url = await prompts.input({
                         message: `  ${app.name} production URL:`,
                         default: '',
@@ -911,10 +1248,23 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             }
         }
         else {
-            const prodApiUrl = await prompts.input({
-                message: 'Production API URL:',
-                default: '',
-            });
+            let prodApiUrl = '';
+            if (existingProductionApiUrl) {
+                console.log(chalk_1.default.dim(`  Found existing value: ${existingProductionApiUrl}`));
+                const useExisting = await prompts.confirm({
+                    message: 'Use existing production API URL?',
+                    default: true,
+                });
+                if (useExisting) {
+                    prodApiUrl = existingProductionApiUrl;
+                }
+            }
+            if (!prodApiUrl) {
+                prodApiUrl = await prompts.input({
+                    message: 'Production API URL:',
+                    default: '',
+                });
+            }
             if (prodApiUrl) {
                 environments.production = {
                     description: 'Production (use with caution)',
@@ -935,7 +1285,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 +1398,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, scripts, infrastructure
+        if (isInteractive) {
+            detected = await interactiveSelection(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,214 @@ 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 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));
+    }
+    // === 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;
+}
+/**
+ * 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 +630,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.17",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {