genbox 1.0.26 → 1.0.28

package/dist/api.js

@@ -49,10 +49,26 @@ async function fetchApi(endpoint, options = {}) {
     if (token) {
         headers['Authorization'] = `Bearer ${token}`;
     }
-    const response = await fetch(url, {
-        ...options,
-        headers,
-    });
+    let response;
+    try {
+        response = await fetch(url, {
+            ...options,
+            headers,
+        });
+    }
+    catch (error) {
+        // Handle network-level errors (DNS, connection refused, timeout, etc.)
+        if (error.cause?.code === 'ECONNREFUSED') {
+            throw new Error(`Cannot connect to Genbox API at ${API_URL}. Is the server running?`);
+        }
+        if (error.cause?.code === 'ENOTFOUND') {
+            throw new Error(`Cannot resolve Genbox API host. Check your internet connection.`);
+        }
+        if (error.message?.includes('fetch failed')) {
+            throw new Error(`Cannot connect to Genbox API at ${API_URL}. Check your internet connection or try again later.`);
+        }
+        throw new Error(`Network error: ${error.message}`);
+    }
     if (!response.ok) {
         // Handle authentication errors with a friendly message
         if (response.status === 401) {

package/dist/commands/create.js

@@ -763,6 +763,14 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
         gitToken: envVars.GIT_TOKEN,
         envVars: resolved.env,
         apps: resolved.apps.map(a => a.name),
+        appConfigs: resolved.apps.map(a => ({
+            name: a.name,
+            path: a.path.startsWith('/') ? a.path : `${resolved.repos[0]?.path || '/home/dev'}/${a.path}`,
+            type: a.type,
+            port: a.port,
+            framework: a.framework,
+            commands: a.commands,
+        })),
         infrastructure: resolved.infrastructure.map(i => ({
             name: i.name,
             type: i.type,

package/dist/commands/init.js

@@ -1012,35 +1012,59 @@ exports.initCommand = new commander_1.Command('init')
  * Create default profiles (sync version for non-interactive mode)
  */
 function createDefaultProfilesSync(scan, config) {
-    return createProfilesFromScan(scan);
+    const definedEnvs = Object.keys(config.environments || {});
+    return createProfilesFromScan(scan, definedEnvs);
 }
 async function createDefaultProfiles(scan, config) {
-    return createProfilesFromScan(scan);
+    // Get defined environments to use in profiles
+    const definedEnvs = Object.keys(config.environments || {});
+    return createProfilesFromScan(scan, definedEnvs);
 }
-function createProfilesFromScan(scan) {
+function createProfilesFromScan(scan, definedEnvironments = []) {
     const profiles = {};
     const frontendApps = scan.apps.filter(a => a.type === 'frontend');
     const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
     const hasApi = scan.apps.some(a => a.name === 'api' || a.type === 'backend');
+    // Determine which environment to use for remote connections
+    // Priority: staging > production > first defined
+    const remoteEnv = definedEnvironments.includes('staging')
+        ? 'staging'
+        : definedEnvironments.includes('production')
+            ? 'production'
+            : definedEnvironments[0];
     // Quick UI profiles for each frontend (v4: use default_connection instead of connect_to)
-    for (const frontend of frontendApps.slice(0, 3)) {
-        profiles[`${frontend.name}-quick`] = {
-            description: `${frontend.name} only, connected to staging`,
-            size: 'small',
-            apps: [frontend.name],
-            default_connection: 'staging',
-        };
+    // Only create if we have a remote environment defined
+    if (remoteEnv) {
+        for (const frontend of frontendApps.slice(0, 3)) {
+            profiles[`${frontend.name}-quick`] = {
+                description: `${frontend.name} only, connected to ${remoteEnv}`,
+                size: 'small',
+                apps: [frontend.name],
+                default_connection: remoteEnv,
+            };
+        }
     }
-    // Full local development
+    else {
+        // No remote environment - create local-only profiles
+        for (const frontend of frontendApps.slice(0, 3)) {
+            profiles[`${frontend.name}-local`] = {
+                description: `${frontend.name} with local API`,
+                size: 'medium',
+                apps: [frontend.name, ...(hasApi ? ['api'] : [])],
+            };
+        }
+    }
+    // Full local development (with DB copy from available environment)
     if (hasApi && frontendApps.length > 0) {
         const primaryFrontend = frontendApps[0];
+        const dbSource = remoteEnv || 'staging'; // Use defined env or default
         profiles[`${primaryFrontend.name}-full`] = {
             description: `${primaryFrontend.name} + local API + DB copy`,
             size: 'large',
             apps: [primaryFrontend.name, 'api'],
             database: {
-                mode: 'copy',
-                source: 'staging',
+                mode: remoteEnv ? 'copy' : 'local', // Only copy if we have a source
+                ...(remoteEnv && { source: dbSource }),
             },
         };
     }
@@ -1055,24 +1079,25 @@ function createProfilesFromScan(scan) {
             },
         };
     }
-    // All frontends + staging (v4: use default_connection)
-    if (frontendApps.length > 1) {
-        profiles['frontends-staging'] = {
-            description: 'All frontends with staging backend',
+    // All frontends + remote backend (only if remote env defined)
+    if (frontendApps.length > 1 && remoteEnv) {
+        profiles[`frontends-${remoteEnv}`] = {
+            description: `All frontends with ${remoteEnv} backend`,
             size: 'medium',
             apps: frontendApps.map(a => a.name),
-            default_connection: 'staging',
+            default_connection: remoteEnv,
         };
     }
     // Full stack
     if (scan.apps.length > 1) {
+        const dbSource = remoteEnv || 'staging';
         profiles['full-stack'] = {
-            description: 'Everything local with DB copy',
+            description: 'Everything local' + (remoteEnv ? ' with DB copy' : ''),
             size: 'xl',
             apps: scan.apps.filter(a => a.type !== 'library').map(a => a.name),
             database: {
-                mode: 'copy',
-                source: 'staging',
+                mode: remoteEnv ? 'copy' : 'local',
+                ...(remoteEnv && { source: dbSource }),
             },
         };
     }
@@ -1150,127 +1175,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 : '');
@@ -1304,31 +1298,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,
@@ -1339,6 +1328,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
  */

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.26",
+  "version": "1.0.28",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {