genbox 1.0.14 → 1.0.16

package/dist/commands/connect.js

@@ -41,6 +41,7 @@ const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const api_1 = require("../api");
 const genbox_selector_1 = require("../genbox-selector");
+const ssh_config_1 = require("../ssh-config");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -80,9 +81,13 @@ exports.connectCommand = new commander_1.Command('connect')
             console.error(chalk_1.default.yellow(`Genbox '${target.name}' is still provisioning (no IP). Please wait.`));
             return;
         }
-        // 2. Get Key
+        // 2. Ensure SSH config exists (in case background setup hasn't finished)
+        if (!(0, ssh_config_1.hasSshConfigEntry)(target.name)) {
+            (0, ssh_config_1.addSshConfigEntry)({ name: target.name, ipAddress: target.ipAddress });
+        }
+        // 3. Get Key
         const keyPath = getPrivateSshKey();
-        // 3. Connect
+        // 4. Connect
         console.log(chalk_1.default.dim(`Connecting to ${chalk_1.default.bold(target.name)} (${target.ipAddress})...`));
         const sshArgs = [
             '-i', keyPath,

package/dist/commands/create.js

@@ -48,64 +48,22 @@ const config_loader_1 = require("../config-loader");
 const profile_resolver_1 = require("../profile-resolver");
 const api_1 = require("../api");
 const ssh_config_1 = require("../ssh-config");
+const schema_v4_1 = require("../schema-v4");
 const child_process_1 = require("child_process");
 /**
- * Poll for genbox IP address (servers take a few seconds to get an IP assigned)
+ * Spawn a background process to poll for IP and add SSH config
+ * This runs detached so the main process can exit immediately
  */
-async function waitForIpAddress(genboxId, maxAttempts = 30, delayMs = 2000) {
-    for (let i = 0; i < maxAttempts; i++) {
-        try {
-            const genbox = await (0, api_1.fetchApi)(`/genboxes/${genboxId}`);
-            if (genbox.ipAddress) {
-                return genbox.ipAddress;
-            }
-        }
-        catch {
-            // Ignore errors during polling
-        }
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-    }
-    return null;
-}
-/**
- * Find SSH private key
- */
-function findSshKeyPath() {
-    const home = os.homedir();
-    const keyPaths = [
-        path.join(home, '.ssh', 'id_ed25519'),
-        path.join(home, '.ssh', 'id_rsa'),
-    ];
-    for (const keyPath of keyPaths) {
-        if (fs.existsSync(keyPath)) {
-            return keyPath;
-        }
-    }
-    return null;
-}
-/**
- * Wait for SSH to be available on the server
- */
-async function waitForSsh(ipAddress, maxAttempts = 30, delayMs = 5000) {
-    const keyPath = findSshKeyPath();
-    if (!keyPath)
-        return false;
-    const sshOpts = `-i ${keyPath} -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=5`;
-    for (let i = 0; i < maxAttempts; i++) {
-        try {
-            (0, child_process_1.execSync)(`ssh ${sshOpts} dev@${ipAddress} "echo 'SSH ready'"`, {
-                encoding: 'utf8',
-                timeout: 10000,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            return true;
-        }
-        catch {
-            // SSH not ready yet
-        }
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-    }
-    return false;
+function spawnSshConfigSetup(genboxId, name) {
+    // Get the path to the CLI executable
+    const cliPath = process.argv[1];
+    // Spawn genbox ssh-setup in background
+    const child = (0, child_process_1.spawn)(process.execPath, [cliPath, 'ssh-setup', genboxId, name], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    // Allow parent to exit independently
+    child.unref();
 }
 async function provisionGenbox(payload) {
     return (0, api_1.fetchApi)('/genboxes', {
@@ -159,11 +117,13 @@ exports.createCommand = new commander_1.Command('create')
         // Load configuration
         const configLoader = new config_loader_1.ConfigLoader();
         const loadResult = await configLoader.load();
-        if (!loadResult.config || loadResult.config.version !== '3.0') {
+        const configVersion = (0, schema_v4_1.getConfigVersion)(loadResult.config);
+        if (!loadResult.config || configVersion === 'unknown') {
             // Fall back to legacy v1/v2 handling
             await createLegacy(name, options);
             return;
         }
+        // Support both v3 and v4 configs
         const config = loadResult.config;
         const profileResolver = new profile_resolver_1.ProfileResolver(configLoader);
         // Build create options
@@ -210,7 +170,8 @@ exports.createCommand = new commander_1.Command('create')
         const publicKey = getPublicSshKey();
         // Check if SSH auth is needed for git
         let privateKeyContent;
-        const usesSSH = config.git_auth?.method === 'ssh' ||
+        const v3Config = config;
+        const usesSSH = v3Config.git_auth?.method === 'ssh' ||
             Object.values(config.repos || {}).some(r => r.auth === 'ssh');
         if (usesSSH && !options.yes) {
             const injectKey = await prompts.confirm({
@@ -231,40 +192,23 @@ exports.createCommand = new commander_1.Command('create')
         try {
             const genbox = await provisionGenbox(payload);
             spinner.succeed(chalk_1.default.green(`Genbox '${name}' created!`));
-            // Wait for IP if not immediately available
-            let ipAddress = genbox.ipAddress;
-            if (!ipAddress && genbox._id) {
-                spinner.start('Waiting for IP address...');
-                ipAddress = await waitForIpAddress(genbox._id);
-                if (ipAddress) {
-                    spinner.succeed(`IP address assigned: ${ipAddress}`);
-                    genbox.ipAddress = ipAddress;
-                }
-                else {
-                    spinner.fail('Timed out waiting for IP. Run `genbox status` to check later.');
-                    displayGenboxInfo(genbox, resolved);
-                    return;
+            // Add SSH config immediately if IP available, otherwise spawn background process
+            if (genbox.ipAddress) {
+                const sshAdded = (0, ssh_config_1.addSshConfigEntry)({ name, ipAddress: genbox.ipAddress });
+                if (sshAdded) {
+                    console.log(chalk_1.default.dim(`  SSH config added: ssh ${(0, ssh_config_1.getSshAlias)(name)}`));
                 }
             }
-            // Wait for SSH to be available
-            spinner.start('Waiting for SSH to be ready...');
-            const sshReady = await waitForSsh(ipAddress);
-            if (sshReady) {
-                spinner.succeed(chalk_1.default.green('SSH is ready!'));
-            }
-            else {
-                spinner.warn('SSH not ready yet. Server may still be booting.');
-            }
-            // Add SSH config
-            const sshAdded = (0, ssh_config_1.addSshConfigEntry)({
-                name,
-                ipAddress,
-            });
-            if (sshAdded) {
-                console.log(chalk_1.default.dim(`  SSH config added: ssh ${(0, ssh_config_1.getSshAlias)(name)}`));
+            else if (genbox._id) {
+                // Spawn background process to poll for IP and add SSH config
+                spawnSshConfigSetup(genbox._id, name);
+                console.log(chalk_1.default.dim('  SSH config will be added once IP is assigned.'));
             }
             // Display results
             displayGenboxInfo(genbox, resolved);
+            // Inform user about server provisioning
+            console.log('');
+            console.log(chalk_1.default.dim('Server is provisioning. Run `genbox connect` once ready.'));
         }
         catch (error) {
             spinner.fail(chalk_1.default.red(`Failed to create Genbox: ${error.message}`));
@@ -375,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');
@@ -391,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')
@@ -449,18 +432,19 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
                 envVarsFromFile[match[1]] = value;
             }
         }
-        // Determine API_URL based on profile's connect_to setting
-        const connectTo = resolved.profile ?
-            (config.profiles?.[resolved.profile]?.connect_to) : undefined;
-        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';
+        // 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);
         }
-        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) {
@@ -474,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({
@@ -487,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,
@@ -699,39 +683,28 @@ async function createLegacy(name, options) {
             gitToken: envVars.GIT_TOKEN,
         });
         spinner.succeed(chalk_1.default.green(`Genbox '${name}' created!`));
-        // Wait for IP if not immediately available
-        let ipAddress = genbox.ipAddress;
-        if (!ipAddress && genbox._id) {
-            spinner.start('Waiting for IP address...');
-            ipAddress = await waitForIpAddress(genbox._id);
-            if (ipAddress) {
-                spinner.succeed(`IP address assigned: ${ipAddress}`);
-                genbox.ipAddress = ipAddress;
-            }
-            else {
-                spinner.fail('Timed out waiting for IP. Run `genbox status` to check later.');
-                return;
+        // Add SSH config immediately if IP available, otherwise spawn background process
+        if (genbox.ipAddress) {
+            const sshAdded = (0, ssh_config_1.addSshConfigEntry)({ name, ipAddress: genbox.ipAddress });
+            if (sshAdded) {
+                console.log(chalk_1.default.dim(`  SSH config added: ssh ${(0, ssh_config_1.getSshAlias)(name)}`));
             }
         }
-        // Wait for SSH to be available
-        spinner.start('Waiting for SSH to be ready...');
-        const sshReady = await waitForSsh(ipAddress);
-        if (sshReady) {
-            spinner.succeed(chalk_1.default.green('SSH is ready!'));
-        }
-        else {
-            spinner.warn('SSH not ready yet. Server may still be booting.');
-        }
-        // Add SSH config
-        const sshAdded = (0, ssh_config_1.addSshConfigEntry)({ name, ipAddress });
-        if (sshAdded) {
-            console.log(chalk_1.default.dim(`  SSH config added: ssh ${(0, ssh_config_1.getSshAlias)(name)}`));
+        else if (genbox._id) {
+            // Spawn background process to poll for IP and add SSH config
+            spawnSshConfigSetup(genbox._id, name);
+            console.log(chalk_1.default.dim('  SSH config will be added once IP is assigned.'));
         }
         console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
         console.log(`  ${chalk_1.default.bold('Environment:')} ${name}`);
         console.log(`  ${chalk_1.default.bold('Status:')}      ${chalk_1.default.yellow(genbox.status)}`);
-        console.log(`  ${chalk_1.default.bold('IP:')}          ${ipAddress}`);
+        if (genbox.ipAddress) {
+            console.log(`  ${chalk_1.default.bold('IP:')}          ${genbox.ipAddress}`);
+        }
         console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
+        // Inform user about server provisioning
+        console.log('');
+        console.log(chalk_1.default.dim('Server is provisioning. Run `genbox connect` once ready.'));
     }
     catch (error) {
         spinner.fail(chalk_1.default.red(`Failed: ${error.message}`));