genbox 1.0.92 → 1.0.93

package/dist/commands/create.js

@@ -796,11 +796,15 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
                 const appPath = config.apps[app.name]?.path || app.name;
                 const repoPath = resolved.repos.find(r => r.name === app.name)?.path ||
                     (resolved.repos[0]?.path ? `${resolved.repos[0].path}/${appPath}` : `/home/dev/${config.project.name}/${appPath}`);
+                // Get runner type to determine infrastructure URL prefix (docker vs host)
+                const runner = config.apps[app.name]?.runner || 'pm2';
+                const infraUrlMap = (0, utils_1.buildInfraUrlMap)(envVarsFromFile, runner);
+                const combinedUrlMap = { ...serviceUrlMap, ...infraUrlMap };
                 const servicesSections = Array.from(sections.keys()).filter(s => s.startsWith(`${app.name}/`));
                 if (servicesSections.length > 0) {
                     for (const serviceSectionName of servicesSections) {
                         const serviceName = serviceSectionName.split('/')[1];
-                        const serviceEnvContent = (0, utils_1.buildAppEnvContent)(sections, serviceSectionName, serviceUrlMap);
+                        const serviceEnvContent = (0, utils_1.buildAppEnvContent)(sections, serviceSectionName, combinedUrlMap);
                         const stagingName = `${app.name}-${serviceName}.env`;
                         const targetPath = `${repoPath}/apps/${serviceName}/.env`;
                         files.push({
@@ -812,7 +816,7 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
                     }
                 }
                 else {
-                    const appEnvContent = (0, utils_1.buildAppEnvContent)(sections, app.name, serviceUrlMap);
+                    const appEnvContent = (0, utils_1.buildAppEnvContent)(sections, app.name, combinedUrlMap);
                     files.push({
                         path: `/home/dev/.env-staging/${app.name}.env`,
                         content: appEnvContent,
@@ -934,10 +938,39 @@ function generateSetupScript(resolved, config, envFilesToMove = []) {
         lines.push('    \' "$file" | grep -v "^$" | head -n -1');
         lines.push('  }');
         lines.push('');
+        lines.push('  # Function to expand infrastructure URL placeholders based on runner type');
+        lines.push('  # Docker apps use DOCKER_* values, PM2/host apps use HOST_* values');
+        lines.push('  expand_infra_urls() {');
+        lines.push('    local envfile="$1"');
+        lines.push('    local runner="$2"');
+        lines.push('    if [ "$runner" = "docker" ]; then');
+        lines.push('      # For docker apps, replace ${VAR} with DOCKER_VAR value');
+        lines.push('      for var in MONGODB_URI MONGO_URI REDIS_URL REDIS_URI RABBITMQ_URL AMQP_URL DATABASE_URL DATABASE_URI; do');
+        lines.push('        docker_val=$(grep "^DOCKER_${var}=" /home/dev/.env.genbox 2>/dev/null | cut -d= -f2-)');
+        lines.push('        if [ -n "$docker_val" ]; then');
+        lines.push('          sed -i "s|\\${${var}}|${docker_val}|g" "$envfile"');
+        lines.push('        fi');
+        lines.push('      done');
+        lines.push('    else');
+        lines.push('      # For PM2/host apps, replace ${VAR} with HOST_VAR value');
+        lines.push('      for var in MONGODB_URI MONGO_URI REDIS_URL REDIS_URI RABBITMQ_URL AMQP_URL DATABASE_URL DATABASE_URI; do');
+        lines.push('        host_val=$(grep "^HOST_${var}=" /home/dev/.env.genbox 2>/dev/null | cut -d= -f2-)');
+        lines.push('        if [ -n "$host_val" ]; then');
+        lines.push('          sed -i "s|\\${${var}}|${host_val}|g" "$envfile"');
+        lines.push('        fi');
+        lines.push('      done');
+        lines.push('    fi');
+        lines.push('  }');
+        lines.push('');
         for (const { stagingName, targetPath } of envFilesToMove) {
-            lines.push(`  # Create .env for ${stagingName}`);
+            // Determine runner type for this app
+            // stagingName could be "appName" or "appName/serviceName" for service sections
+            const appName = stagingName.includes('/') ? stagingName.split('/')[0] : stagingName;
+            const runner = config.apps[appName]?.runner || 'pm2';
+            lines.push(`  # Create .env for ${stagingName} (runner: ${runner})`);
             lines.push(`  mkdir -p "$(dirname "${targetPath}")"`);
             lines.push(`  extract_section "${stagingName}" /home/dev/.env.genbox > "${targetPath}"`);
+            lines.push(`  expand_infra_urls "${targetPath}" "${runner}"`);
             lines.push(`  echo "  Created ${targetPath}"`);
         }
         lines.push('');

package/dist/commands/init.js

@@ -162,12 +162,19 @@ function convertScanToDetected(scan, root) {
             }
         }
     }
+    // Map to store git info for directories with docker apps (to preserve repo info)
+    const dockerDirGitInfo = new Map();
     // Convert apps from package.json (skip if docker app builds from same directory)
     const isMultiRepo = scan.structure.type === 'hybrid';
     for (const app of scan.apps) {
         // Skip if there's a docker app building from this directory
         const normalizedPath = app.path.replace(/^\.?\/?/, '').replace(/\/$/, '');
         if (dockerBuildContexts.has(normalizedPath)) {
+            // Save git info for this directory so docker apps can use it
+            const gitInfo = detectGitForDirectory(path_1.default.join(root, app.path));
+            if (gitInfo) {
+                dockerDirGitInfo.set(normalizedPath, gitInfo);
+            }
             continue; // Docker app takes precedence
         }
         const mappedType = mapAppType(app.type);
@@ -195,6 +202,8 @@ function convertScanToDetected(scan, root) {
             git: appGit,
         };
     }
+    // Store dockerDirGitInfo for use when adding docker apps
+    const _dockerDirGitInfo = dockerDirGitInfo;
     // Convert infrastructure (keep all, no deduplication - user selects by source file)
     if (scan.compose) {
         detected.infrastructure = [];
@@ -263,6 +272,9 @@ function convertScanToDetected(scan, root) {
                         continue; // Same source, skip duplicate
                     }
                 }
+                // Look up git info for this docker app's build context
+                const buildContext = dockerApp.build?.context?.replace(/^\.?\/?/, '').replace(/\/$/, '') || '';
+                const dockerAppGit = _dockerDirGitInfo.get(buildContext);
                 detected.apps[detectedAppKey] = {
                     path: dockerApp.build?.context || '.',
                     type: mappedType,
@@ -278,6 +290,7 @@ function convertScanToDetected(scan, root) {
                     port: dockerApp.ports?.[0]?.host,
                     port_source: `${dockerApp.sourceFile || 'docker-compose.yml'} ports`,
                     source: dockerApp.sourceFile || 'docker-compose',
+                    git: dockerAppGit,
                 };
             }
         }
@@ -1408,6 +1421,36 @@ function generateEnvFile(projectName, detected, envVars, serviceUrlMappings) {
             }
         }
     }
+    // Add infrastructure URL mappings (HOST_ vs DOCKER_ prefixes)
+    // These are used to differentiate between PM2 apps (use HOST_*) and Docker apps (use DOCKER_*)
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        content += `\n# Infrastructure URL Configuration\n`;
+        content += `# HOST_* = for PM2/host-based apps (uses localhost)\n`;
+        content += `# DOCKER_* = for Docker apps (uses docker network hostnames)\n\n`;
+        for (const infra of detected.infrastructure) {
+            const name = infra.name.toLowerCase();
+            const port = infra.port;
+            if (infra.type === 'database' && infra.image?.includes('mongo')) {
+                // MongoDB - use project name as database name
+                const dbName = projectName.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+                content += `HOST_MONGODB_URI=mongodb://localhost:${port}/${dbName}\n`;
+                content += `DOCKER_MONGODB_URI=mongodb://${name}:27017/${dbName}\n`;
+                content += `MONGODB_URI=\${MONGODB_URI}\n\n`;
+            }
+            else if (infra.type === 'cache' && infra.image?.includes('redis')) {
+                // Redis
+                content += `HOST_REDIS_URL=redis://localhost:${port}\n`;
+                content += `DOCKER_REDIS_URL=redis://${name}:6379\n`;
+                content += `REDIS_URL=\${REDIS_URL}\n\n`;
+            }
+            else if (infra.type === 'queue' && infra.image?.includes('rabbitmq')) {
+                // RabbitMQ
+                content += `HOST_RABBITMQ_URL=amqp://localhost:${port}\n`;
+                content += `DOCKER_RABBITMQ_URL=amqp://${name}:5672\n`;
+                content += `RABBITMQ_URL=\${RABBITMQ_URL}\n\n`;
+            }
+        }
+    }
     // Add GIT_TOKEN placeholder if not present
     if (!envVars['GIT_TOKEN']) {
         content += `\n# Git authentication\n# GIT_TOKEN=ghp_xxxxxxxxxxxx\n`;

package/dist/scanner/index.js

@@ -133,6 +133,9 @@ class ProjectScanner {
                 type: 'backend', // Will be refined by framework detection
                 scripts,
             });
+            // Also scan first-level subdirectories for additional apps
+            const subApps = await this.discoverMultiRepoApps(root, exclude);
+            apps.push(...subApps);
         }
         return apps;
     }

package/dist/utils/env-parser.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEnvGenboxSections = parseEnvGenboxSections;
 exports.buildServiceUrlMap = buildServiceUrlMap;
 exports.buildAppEnvContent = buildAppEnvContent;
+exports.buildInfraUrlMap = buildInfraUrlMap;
 exports.parseEnvVarsFromSection = parseEnvVarsFromSection;
 /**
  * Parse .env.genbox file into segregated sections
@@ -106,6 +107,61 @@ function buildAppEnvContent(sections, appName, serviceUrlMap) {
         .trim();
     return envContent;
 }
+/**
+ * Infrastructure variable patterns that need HOST_ vs DOCKER_ prefixes
+ * These are database/cache/queue connection strings that differ between
+ * host-based apps (PM2) and containerized apps (Docker)
+ */
+const INFRA_VAR_PATTERNS = [
+    /^(MONGODB|MONGO)_URI$/i,
+    /^(MONGODB|MONGO)_URL$/i,
+    /^(REDIS)_URL$/i,
+    /^(REDIS)_URI$/i,
+    /^(RABBITMQ|RABBIT|AMQP)_URL$/i,
+    /^(RABBITMQ|RABBIT|AMQP)_URI$/i,
+    /^(POSTGRES|POSTGRESQL|PG)_URL$/i,
+    /^(POSTGRES|POSTGRESQL|PG)_URI$/i,
+    /^DATABASE_URL$/i,
+    /^DATABASE_URI$/i,
+];
+/**
+ * Build a map of infrastructure URL variables based on runner type
+ * For docker apps: use DOCKER_* prefixed values (e.g., mongodb://mongodb:27017)
+ * For host/PM2 apps: use HOST_* prefixed values (e.g., mongodb://localhost:27018)
+ *
+ * Example .env.genbox:
+ *   HOST_MONGODB_URI=mongodb://localhost:27018/myapp
+ *   DOCKER_MONGODB_URI=mongodb://mongodb:27017/myapp
+ *   MONGODB_URI=${MONGODB_URI}  # Placeholder that gets expanded
+ */
+function buildInfraUrlMap(envVarsFromFile, runner) {
+    const urlMap = {};
+    const useDocker = runner === 'docker';
+    const prefix = useDocker ? 'DOCKER_' : 'HOST_';
+    // Find all infrastructure variables that have HOST_ or DOCKER_ prefixes
+    const infraVarNames = new Set();
+    for (const key of Object.keys(envVarsFromFile)) {
+        const match = key.match(/^(HOST|DOCKER)_(.+)$/);
+        if (match) {
+            const varName = match[2];
+            // Check if it's an infrastructure variable
+            if (INFRA_VAR_PATTERNS.some(pattern => pattern.test(varName))) {
+                infraVarNames.add(varName);
+            }
+        }
+    }
+    // Build mapping: VARNAME → value from appropriate prefix
+    for (const varName of infraVarNames) {
+        const prefixedKey = `${prefix}${varName}`;
+        const fallbackKey = useDocker ? `HOST_${varName}` : `DOCKER_${varName}`;
+        // Use prefixed value if available, otherwise fall back
+        const value = envVarsFromFile[prefixedKey] || envVarsFromFile[fallbackKey];
+        if (value) {
+            urlMap[varName] = value;
+        }
+    }
+    return urlMap;
+}
 /**
  * Parse env vars from a section content string
  */

package/package.json

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