genbox 1.0.92 → 1.0.94

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);
@@ -187,14 +194,17 @@ function convertScanToDetected(scan, root) {
             framework: app.framework,
             framework_source: app.framework ? 'package.json dependencies' : undefined,
             commands: app.scripts ? {
-                dev: app.scripts.dev,
-                build: app.scripts.build,
-                start: app.scripts.start,
+                // Use script NAMES (not raw commands) - PM2 runs `pnpm run <name>`
+                dev: app.scripts.dev ? 'dev' : undefined,
+                build: app.scripts.build ? 'build' : undefined,
+                start: app.scripts.start ? 'start' : undefined,
             } : undefined,
             dependencies: app.dependencies,
             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 = [];
@@ -205,6 +215,7 @@ function convertScanToDetected(scan, root) {
                 image: db.image || 'unknown',
                 port: db.ports?.[0]?.host || 0,
                 source: db.sourceFile || 'docker-compose.yml',
+                ...(db.replicaSet && { replicaSet: db.replicaSet }),
             });
         }
         for (const cache of scan.compose.caches || []) {
@@ -263,6 +274,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 +292,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 +1423,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/profile-resolver.js

@@ -98,8 +98,8 @@ class ProfileResolver {
         // Step 3: Resolve dependencies
         const { apps, infrastructure, dependencyWarnings } = await this.resolveDependencies(config, selectedApps, options, profile);
         warnings.push(...dependencyWarnings);
-        // Step 4: Determine database mode
-        const database = await this.resolveDatabaseMode(config, options, profile);
+        // Step 4: Determine database mode (pass infrastructure for replicaSet detection)
+        const database = await this.resolveDatabaseMode(config, options, profile, infrastructure);
         // Step 5: Determine size
         const size = options.size || profile.size || this.inferSize(apps, infrastructure);
         // Step 6: Build resolved config
@@ -320,7 +320,7 @@ class ProfileResolver {
     /**
      * Resolve database mode
      */
-    async resolveDatabaseMode(config, options, profile) {
+    async resolveDatabaseMode(config, options, profile, infrastructure) {
         // Load env vars from .env.genbox (where init stores MongoDB URLs)
         const envVars = this.configLoader.loadEnvVars(process.cwd());
         // Helper to get MongoDB URL from .env.genbox
@@ -335,6 +335,9 @@ class ProfileResolver {
             // Custom environments: {NAME}_MONGODB_URL
             return envVars[`${source.toUpperCase()}_MONGODB_URL`];
         };
+        // Extract replicaSet from MongoDB infrastructure config if present
+        const mongoInfra = infrastructure.find(i => i.type === 'database' && i.image?.toLowerCase().includes('mongo'));
+        const replicaSet = mongoInfra?.replicaSet;
         // CLI flag takes precedence
         if (options.db) {
             // Normalize 'fresh' to 'local' (fresh is the UI name, local is internal)
@@ -344,6 +347,7 @@ class ProfileResolver {
                 mode: dbMode,
                 source,
                 url: dbMode === 'copy' ? getMongoUrl(source) : undefined,
+                replicaSet,
             };
         }
         // Profile setting
@@ -354,6 +358,7 @@ class ProfileResolver {
                 url: profile.database.mode === 'copy' && profile.database.source
                     ? getMongoUrl(profile.database.source)
                     : undefined,
+                replicaSet,
             };
         }
         // If default_connection is set, use remote
@@ -365,11 +370,13 @@ class ProfileResolver {
                 mode: 'remote',
                 source: profileConnection,
                 url: mongoUrl,
+                replicaSet,
             };
         }
         // Interactive mode
         if (!options.yes) {
-            return await this.selectDatabaseModeInteractive(config);
+            const interactiveResult = await this.selectDatabaseModeInteractive(config);
+            return { ...interactiveResult, replicaSet };
         }
         // Default
         const defaultMode = config.defaults?.database?.mode || 'local';
@@ -378,6 +385,7 @@ class ProfileResolver {
             mode: defaultMode,
             source: defaultSource,
             url: defaultMode === 'copy' && defaultSource ? getMongoUrl(defaultSource) : undefined,
+            replicaSet,
         };
     }
     /**

package/dist/scanner/compose-parser.js

@@ -194,21 +194,46 @@ class ComposeParser {
         return files;
     }
     normalizeService(name, config, root, composeDir, sourceFile) {
+        const command = this.normalizeCommand(config.command);
+        const environment = this.normalizeEnvironment(config.environment);
+        const image = config.image;
         return {
             name,
-            image: config.image,
+            image,
             build: this.normalizeBuild(config.build, root, composeDir),
             ports: this.normalizePorts(config.ports),
-            environment: this.normalizeEnvironment(config.environment),
+            environment,
             envFile: this.normalizeEnvFile(config.env_file),
             dependsOn: this.normalizeDependsOn(config.depends_on),
             volumes: this.normalizeVolumes(config.volumes),
             healthcheck: this.normalizeHealthcheck(config.healthcheck),
-            command: this.normalizeCommand(config.command),
+            command,
             labels: this.normalizeLabels(config.labels),
             sourceFile,
+            replicaSet: this.detectReplicaSet(image, command, environment),
         };
     }
+    /**
+     * Detect MongoDB replica set configuration from command or environment
+     */
+    detectReplicaSet(image, command, environment) {
+        // Only check MongoDB services
+        if (!image || !DATABASE_PATTERNS[0].test(image)) {
+            return undefined;
+        }
+        // Check command for --replSet flag
+        if (command) {
+            const replSetMatch = command.match(/--replSet[=\s]+(\S+)/);
+            if (replSetMatch) {
+                return replSetMatch[1];
+            }
+        }
+        // Check environment for MONGO_REPLICA_SET
+        if (environment.MONGO_REPLICA_SET) {
+            return environment.MONGO_REPLICA_SET;
+        }
+        return undefined;
+    }
     normalizeBuild(build, root, composeDir) {
         if (!build)
             return undefined;

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