genbox 1.0.27 → 1.0.29

package/dist/commands/init.js

@@ -153,44 +153,65 @@ function getServiceNameFromUrl(baseUrl) {
     return { name: 'unknown', varPrefix: 'UNKNOWN', description: 'Unknown Service' };
 }
 /**
- * Prompt user for staging URLs for each unique service URL found in frontend apps
+ * Create service URL mappings based on configured environments
+ * Uses URLs from configured environments instead of prompting again
  */
-async function promptForStagingUrls(serviceUrls, existingStagingApiUrl) {
+async function createServiceUrlMappings(serviceUrls, configuredEnvs) {
     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('');
+    // Determine which environment to use (prefer staging, then production)
+    const envNames = Object.keys(configuredEnvs || {});
+    const primaryEnv = envNames.includes('staging') ? 'staging' :
+        envNames.includes('production') ? 'production' :
+            envNames[0];
+    if (!primaryEnv || !configuredEnvs?.[primaryEnv]) {
+        // No environments configured - skip service URL mapping
+        return mappings;
+    }
+    const envConfig = configuredEnvs[primaryEnv];
+    const apiUrl = envConfig.urls?.api;
+    if (!apiUrl) {
+        // No API URL configured - skip
+        return mappings;
+    }
     // Sort by port number for consistent ordering
     const sortedServices = Array.from(serviceUrls.entries()).sort((a, b) => {
         const portA = parseInt(a[0].match(/:(\d+)/)?.[1] || '0');
         const portB = parseInt(b[0].match(/:(\d+)/)?.[1] || '0');
         return portA - portB;
     });
-    for (const [baseUrl, { urls, vars }] of sortedServices) {
+    console.log('');
+    console.log(chalk_1.default.blue('=== Service URL Mapping ==='));
+    console.log(chalk_1.default.dim(`Mapping localhost URLs to ${primaryEnv} environment`));
+    console.log('');
+    for (const [baseUrl, { vars }] of sortedServices) {
         const serviceInfo = getServiceNameFromUrl(baseUrl);
-        // 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,
-        });
+        // Auto-map API/gateway URLs to the configured API URL
+        const isApiService = serviceInfo.name === 'gateway' ||
+            baseUrl.includes(':3050') ||
+            baseUrl.includes(':3105') ||
+            vars.some(v => v.toLowerCase().includes('api'));
+        if (isApiService && apiUrl) {
+            console.log(chalk_1.default.green(`✓ ${serviceInfo.description}: ${baseUrl} → ${apiUrl}`));
+            mappings.push({
+                varName: `${serviceInfo.varPrefix}_URL`,
+                localUrl: baseUrl,
+                remoteUrl: apiUrl,
+                remoteEnv: primaryEnv,
+                description: serviceInfo.description,
+            });
+        }
+        else {
+            // For non-API services, just record the local URL without remote
+            console.log(chalk_1.default.dim(`  ${serviceInfo.description}: ${baseUrl} (local only)`));
+            mappings.push({
+                varName: `${serviceInfo.varPrefix}_URL`,
+                localUrl: baseUrl,
+                description: serviceInfo.description,
+            });
+        }
     }
     return mappings;
 }
@@ -202,19 +223,19 @@ function transformEnvWithVariables(envContent, mappings, frontendApps) {
         return envContent;
     }
     let result = envContent;
+    // Determine the environment name for comments
+    const envName = mappings.find(m => m.remoteEnv)?.remoteEnv?.toUpperCase() || 'REMOTE';
     // Build GLOBAL section additions
     const globalAdditions = [
         '',
         '# Service URL Configuration',
-        '# These expand based on profile: ${GATEWAY_URL} → LOCAL or STAGING value',
+        `# These expand based on profile: \${GATEWAY_URL} → LOCAL or ${envName} value`,
     ];
     for (const mapping of mappings) {
         globalAdditions.push(`LOCAL_${mapping.varName}=${mapping.localUrl}`);
-        if (mapping.stagingUrl) {
-            globalAdditions.push(`STAGING_${mapping.varName}=${mapping.stagingUrl}`);
-        }
-        else {
-            globalAdditions.push(`# STAGING_${mapping.varName}=https://your-staging-url.com`);
+        if (mapping.remoteUrl && mapping.remoteEnv) {
+            const prefix = mapping.remoteEnv.toUpperCase();
+            globalAdditions.push(`${prefix}_${mapping.varName}=${mapping.remoteUrl}`);
         }
     }
     globalAdditions.push('');
@@ -1175,127 +1196,96 @@ async function setupGitAuth(gitInfo, projectName) {
  * Setup staging/production environments (v4 format)
  */
 async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvValues = {}) {
-    const setupEnvs = await prompts.confirm({
-        message: 'Configure staging/production environments?',
-        default: true,
+    // First ask which environments they want to configure
+    const envChoice = await prompts.select({
+        message: 'Which environments do you want to configure?',
+        choices: [
+            { name: 'Staging only', value: 'staging', description: 'Connect to staging API' },
+            { name: 'Production only', value: 'production', description: 'Connect to production API' },
+            { name: 'Both staging and production', value: 'both', description: 'Configure both environments' },
+            { name: 'Skip for now', value: 'skip', description: 'No remote environments' },
+        ],
+        default: 'staging',
     });
-    if (!setupEnvs) {
+    if (envChoice === 'skip') {
         return undefined;
     }
     console.log('');
     console.log(chalk_1.default.blue('=== Environment Setup ==='));
     console.log(chalk_1.default.dim('These URLs will be used when connecting to external services.'));
     console.log(chalk_1.default.dim('Actual secrets go in .env.genbox'));
-    console.log('');
     const environments = {};
-    // Get existing staging API URL if available
+    // Get existing URLs 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');
-        if (backendApps.length > 0) {
-            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,
+    const configureStaging = envChoice === 'staging' || envChoice === 'both';
+    const configureProduction = envChoice === 'production' || envChoice === 'both';
+    // Configure staging if selected
+    if (configureStaging) {
+        console.log('');
+        console.log(chalk_1.default.cyan('Staging Environment:'));
+        if (isMultiRepo) {
+            const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+            if (backendApps.length > 0) {
+                const urls = {};
+                for (const app of backendApps) {
+                    const existingUrl = existingEnvValues[`STAGING_${app.name.toUpperCase()}_URL`] ||
+                        (app.name === 'api' ? existingStagingApiUrl : '');
+                    if (existingUrl) {
+                        console.log(chalk_1.default.dim(`  Found existing value for ${app.name}: ${existingUrl}`));
+                        const useExisting = await prompts.confirm({
+                            message: `  Use existing ${app.name} staging URL?`,
+                            default: true,
+                        });
+                        if (useExisting) {
+                            urls[app.name] = existingUrl;
+                            continue;
+                        }
+                    }
+                    const url = await prompts.input({
+                        message: `  ${app.name} staging URL:`,
+                        default: '',
                     });
-                    if (useExisting) {
-                        urls[app.name] = existingUrl;
-                        continue;
+                    if (url) {
+                        urls[app.name] = url;
                     }
                 }
-                const url = await prompts.input({
-                    message: `  ${app.name} staging URL (leave empty to skip):`,
-                    default: '',
-                });
-                if (url) {
-                    urls[app.name] = url;
+                if (Object.keys(urls).length > 0) {
+                    environments.staging = {
+                        description: 'Staging environment',
+                        urls,
+                    };
                 }
             }
-            if (Object.keys(urls).length > 0) {
-                environments.staging = {
-                    description: 'Staging environment',
-                    urls,
-                };
+            else {
+                const stagingApiUrl = await promptForApiUrl('staging', existingStagingApiUrl);
+                if (stagingApiUrl) {
+                    environments.staging = {
+                        description: 'Staging environment',
+                        urls: { api: stagingApiUrl },
+                    };
+                }
             }
         }
         else {
-            // No backend apps, just ask for a single URL
-            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: '',
-                });
-            }
+            const stagingApiUrl = await promptForApiUrl('staging', existingStagingApiUrl);
             if (stagingApiUrl) {
                 environments.staging = {
                     description: 'Staging environment',
-                    urls: {
-                        api: stagingApiUrl,
-                    },
+                    urls: { api: stagingApiUrl },
                 };
             }
         }
     }
-    else {
-        // Single repo: simple single URL
-        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',
-                urls: {
-                    api: stagingApiUrl,
-                },
-            };
-        }
-    }
-    const setupProd = await prompts.confirm({
-        message: 'Also configure production environment?',
-        default: false,
-    });
-    if (setupProd) {
+    // Configure production if selected
+    if (configureProduction) {
+        console.log('');
+        console.log(chalk_1.default.cyan('Production Environment:'));
         if (isMultiRepo) {
             const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
             if (backendApps.length > 0) {
-                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 : '');
@@ -1329,31 +1319,26 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                     };
                 }
             }
-        }
-        else {
-            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;
+            else {
+                const prodApiUrl = await promptForApiUrl('production', existingProductionApiUrl);
+                if (prodApiUrl) {
+                    environments.production = {
+                        description: 'Production (use with caution)',
+                        urls: { api: prodApiUrl },
+                        safety: {
+                            read_only: true,
+                            require_confirmation: true,
+                        },
+                    };
                 }
             }
-            if (!prodApiUrl) {
-                prodApiUrl = await prompts.input({
-                    message: 'Production API URL:',
-                    default: '',
-                });
-            }
+        }
+        else {
+            const prodApiUrl = await promptForApiUrl('production', existingProductionApiUrl);
             if (prodApiUrl) {
                 environments.production = {
                     description: 'Production (use with caution)',
-                    urls: {
-                        api: prodApiUrl,
-                    },
+                    urls: { api: prodApiUrl },
                     safety: {
                         read_only: true,
                         require_confirmation: true,
@@ -1364,6 +1349,25 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
     }
     return Object.keys(environments).length > 0 ? environments : undefined;
 }
+/**
+ * Prompt for a single API URL with existing value support
+ */
+async function promptForApiUrl(envName, existingUrl) {
+    if (existingUrl) {
+        console.log(chalk_1.default.dim(`  Found existing value: ${existingUrl}`));
+        const useExisting = await prompts.confirm({
+            message: `  Use existing ${envName} API URL?`,
+            default: true,
+        });
+        if (useExisting) {
+            return existingUrl;
+        }
+    }
+    return await prompts.input({
+        message: `  ${envName.charAt(0).toUpperCase() + envName.slice(1)} API URL:`,
+        default: '',
+    });
+}
 /**
  * Setup .env.genbox file with segregated app sections
  */
@@ -1512,17 +1516,18 @@ async function setupEnvFile(projectName, config, nonInteractive = false, scan, i
             // 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);
+        if (serviceUrls.size > 0 && config.environments) {
+            // Create mappings based on configured environments (no prompting needed)
+            const urlMappings = await createServiceUrlMappings(serviceUrls, config.environments);
             // Transform content with expandable variables
             if (urlMappings.length > 0) {
-                segregatedContent = transformEnvWithVariables(segregatedContent, urlMappings, frontendApps);
-                console.log('');
-                console.log(chalk_1.default.green(`✓ Configured ${urlMappings.length} service URL(s) for staging support`));
+                const mappedCount = urlMappings.filter(m => m.remoteUrl).length;
+                if (mappedCount > 0) {
+                    segregatedContent = transformEnvWithVariables(segregatedContent, urlMappings, frontendApps);
+                    const envName = urlMappings.find(m => m.remoteEnv)?.remoteEnv || 'remote';
+                    console.log('');
+                    console.log(chalk_1.default.green(`✓ Configured ${mappedCount} service URL(s) for ${envName} environment`));
+                }
             }
         }
     }

package/dist/commands/status.js

@@ -165,16 +165,28 @@ exports.statusCommand = new commander_1.Command('status')
             }
         }
         else if (status.includes('done')) {
-            // Get uptime for timing display
-            const uptimeRaw = sshExec(target.ipAddress, keyPath, "cat /proc/uptime 2>/dev/null | cut -d' ' -f1");
-            let uptimeFormatted = '';
-            if (uptimeRaw) {
-                const uptimeSecs = Math.floor(parseFloat(uptimeRaw));
-                const mins = Math.floor(uptimeSecs / 60);
-                const secs = uptimeSecs % 60;
-                uptimeFormatted = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+            // Try to get actual cloud-init completion time from logs first
+            let completionTimeFormatted = '';
+            // First, try to extract "Setup Complete in Xm Ys" from cloud-init logs
+            const setupTime = sshExec(target.ipAddress, keyPath, "sudo grep -oP 'Setup Complete in \\K[0-9]+m [0-9]+s' /var/log/cloud-init-output.log 2>/dev/null | tail -1");
+            if (setupTime && setupTime.trim()) {
+                completionTimeFormatted = setupTime.trim();
+            }
+            else {
+                // Fallback: Calculate from cloud-init result.json timestamp vs boot time
+                // Get boot timestamp and cloud-init finish timestamp
+                const timestamps = sshExec(target.ipAddress, keyPath, "echo $(date -d \"$(uptime -s)\" +%s) $(stat -c %Y /run/cloud-init/result.json 2>/dev/null || echo 0)");
+                if (timestamps && timestamps.trim()) {
+                    const [bootTime, finishTime] = timestamps.trim().split(' ').map(Number);
+                    if (bootTime && finishTime && finishTime > bootTime) {
+                        const elapsedSecs = finishTime - bootTime;
+                        const mins = Math.floor(elapsedSecs / 60);
+                        const secs = elapsedSecs % 60;
+                        completionTimeFormatted = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+                    }
+                }
             }
-            console.log(chalk_1.default.green(`[SUCCESS] Cloud-init completed!${uptimeFormatted ? ` (${uptimeFormatted})` : ''}`));
+            console.log(chalk_1.default.green(`[SUCCESS] Cloud-init completed!${completionTimeFormatted ? ` (${completionTimeFormatted})` : ''}`));
             console.log('');
             // Show Database Stats - only if configured
             let dbContainer = '';

package/package.json

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