genbox 1.0.91 → 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

@@ -151,9 +151,32 @@ function convertScanToDetected(scan, root) {
         })),
         apps: {},
     };
-    // Convert apps
+    // Collect docker app build contexts first (docker takes precedence over package.json)
+    const dockerBuildContexts = new Set();
+    if (scan.compose?.applications) {
+        for (const dockerApp of scan.compose.applications) {
+            if (dockerApp.build?.context) {
+                // Normalize the path for comparison
+                const ctx = dockerApp.build.context.replace(/^\.?\/?/, '').replace(/\/$/, '');
+                dockerBuildContexts.add(ctx);
+            }
+        }
+    }
+    // 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);
         let appGit = undefined;
         if (isMultiRepo) {
@@ -179,7 +202,9 @@ function convertScanToDetected(scan, root) {
             git: appGit,
         };
     }
-    // Convert infrastructure
+    // 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 = [];
         for (const db of scan.compose.databases || []) {
@@ -188,7 +213,7 @@ function convertScanToDetected(scan, root) {
                 type: 'database',
                 image: db.image || 'unknown',
                 port: db.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: db.sourceFile || 'docker-compose.yml',
             });
         }
         for (const cache of scan.compose.caches || []) {
@@ -197,7 +222,7 @@ function convertScanToDetected(scan, root) {
                 type: 'cache',
                 image: cache.image || 'unknown',
                 port: cache.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: cache.sourceFile || 'docker-compose.yml',
             });
         }
         for (const queue of scan.compose.queues || []) {
@@ -206,21 +231,56 @@ function convertScanToDetected(scan, root) {
                 type: 'queue',
                 image: queue.image || 'unknown',
                 port: queue.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: queue.sourceFile || 'docker-compose.yml',
+            });
+        }
+        // Add other infrastructure (vector DBs, search engines, etc.)
+        for (const infra of scan.compose.infrastructure || []) {
+            detected.infrastructure.push({
+                name: infra.name,
+                type: 'other',
+                image: infra.image || 'unknown',
+                port: infra.ports?.[0]?.host || 0,
+                source: infra.sourceFile || 'docker-compose.yml',
             });
         }
         // Add Docker application services as apps with runner: 'docker'
         if (scan.compose.applications && scan.compose.applications.length > 0) {
+            // Collect infrastructure service keys (name@source) to exclude from apps
+            // Only exclude if same name AND same source file
+            const infraKeys = new Set([
+                ...(scan.compose.databases || []).map(d => `${d.name}@${d.sourceFile || ''}`),
+                ...(scan.compose.caches || []).map(c => `${c.name}@${c.sourceFile || ''}`),
+                ...(scan.compose.queues || []).map(q => `${q.name}@${q.sourceFile || ''}`),
+                ...(scan.compose.infrastructure || []).map(i => `${i.name}@${i.sourceFile || ''}`),
+            ]);
             for (const dockerApp of scan.compose.applications) {
-                if (detected.apps[dockerApp.name])
-                    continue;
+                const infraCheckKey = `${dockerApp.name}@${dockerApp.sourceFile || ''}`;
+                if (infraKeys.has(infraCheckKey))
+                    continue; // Skip infrastructure services from same file
                 const { type: mappedType, reason: typeReason } = inferDockerAppType(dockerApp.name, dockerApp.build?.context, root);
-                detected.apps[dockerApp.name] = {
+                // Use unique key if app name already exists (from different source)
+                let detectedAppKey = dockerApp.name;
+                if (detected.apps[detectedAppKey]) {
+                    // Check if it's from a different source - if so, use source in key
+                    const existingSource = detected.apps[detectedAppKey].source;
+                    const newSource = dockerApp.sourceFile || 'docker-compose';
+                    if (existingSource !== newSource) {
+                        detectedAppKey = `${dockerApp.name}@${newSource}`;
+                    }
+                    else {
+                        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,
                     type_reason: typeReason,
                     runner: 'docker',
-                    runner_reason: 'defined in docker-compose.yml',
+                    runner_reason: `defined in ${dockerApp.sourceFile || 'docker-compose.yml'}`,
                     docker: {
                         service: dockerApp.name,
                         build_context: dockerApp.build?.context,
@@ -228,7 +288,9 @@ function convertScanToDetected(scan, root) {
                         image: dockerApp.image,
                     },
                     port: dockerApp.ports?.[0]?.host,
-                    port_source: 'docker-compose.yml ports',
+                    port_source: `${dockerApp.sourceFile || 'docker-compose.yml'} ports`,
+                    source: dockerApp.sourceFile || 'docker-compose',
+                    git: dockerAppGit,
                 };
             }
         }
@@ -293,74 +355,216 @@ function saveDetectedConfig(rootDir, detected) {
 // App Configuration
 // =============================================================================
 /**
- * Interactive app selection
+ * Get app source group for grouping purposes
+ */
+function getAppSourceGroup(name, app) {
+    // Docker apps - group by docker-compose source file
+    if (app.runner === 'docker' && app.source) {
+        return app.source;
+    }
+    // Use app path for grouping
+    if (app.path && app.path !== '.') {
+        return app.path;
+    }
+    return 'root';
+}
+/**
+ * Interactive app selection (grouped by source)
  */
 async function selectApps(detected) {
     const appEntries = Object.entries(detected.apps);
     if (appEntries.length === 0)
         return detected;
+    // Group apps by source
+    const appsBySource = new Map();
+    for (const [name, app] of appEntries) {
+        const source = getAppSourceGroup(name, app);
+        if (!appsBySource.has(source)) {
+            appsBySource.set(source, []);
+        }
+        appsBySource.get(source).push([name, app]);
+    }
     console.log('');
     console.log(chalk_1.default.blue('=== Detected Apps ==='));
     console.log('');
-    for (const [name, app] of appEntries) {
-        const parts = [
-            chalk_1.default.cyan(name),
-            app.type ? `(${app.type})` : '',
-            app.framework ? `[${app.framework}]` : '',
-            app.port ? `port:${app.port}` : '',
-            app.runner ? chalk_1.default.dim(`runner:${app.runner}`) : '',
-        ].filter(Boolean);
-        console.log(`  ${parts.join(' ')}`);
-        if (app.git) {
-            console.log(chalk_1.default.dim(`    └─ ${app.git.remote}`));
+    // Display grouped by source
+    for (const [source, apps] of appsBySource) {
+        console.log(chalk_1.default.dim(`  ${source}:`));
+        for (const [name, app] of apps) {
+            const parts = [
+                chalk_1.default.cyan(name),
+                app.type ? `(${app.type})` : '',
+                app.framework ? `[${app.framework}]` : '',
+                app.port ? `port:${app.port}` : '',
+                app.runner ? chalk_1.default.dim(`runner:${app.runner}`) : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
         }
     }
     console.log('');
-    const appChoices = appEntries.map(([name, app]) => ({
-        name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
-        value: name,
-        checked: app.type !== 'library',
-    }));
-    const selectedApps = await prompts.checkbox({
-        message: 'Select apps to include:',
-        choices: appChoices,
+    // If only one source group, select individual apps
+    if (appsBySource.size === 1) {
+        const appChoices = appEntries.map(([name, app]) => ({
+            name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+            value: name,
+            checked: app.type !== 'library',
+        }));
+        const selectedApps = await prompts.checkbox({
+            message: 'Select apps to include:',
+            choices: appChoices,
+        });
+        const filteredApps = {};
+        for (const appName of selectedApps) {
+            filteredApps[appName] = detected.apps[appName];
+        }
+        return { ...detected, apps: filteredApps };
+    }
+    // Multiple source groups - let user select by group first
+    const sourceChoices = Array.from(appsBySource.entries()).map(([source, apps]) => {
+        const hasLibraryOnly = apps.every(([, a]) => a.type === 'library');
+        const appNames = apps.map(([n]) => n).join(', ');
+        return {
+            name: `${source} (${appNames})`,
+            value: source,
+            checked: !hasLibraryOnly, // Uncheck if all are libraries
+        };
+    });
+    const selectedSources = await prompts.checkbox({
+        message: 'Select app groups to include:',
+        choices: sourceChoices,
     });
+    // Collect all apps from selected sources (excluding libraries by default)
     const filteredApps = {};
-    for (const appName of selectedApps) {
-        filteredApps[appName] = detected.apps[appName];
+    for (const source of selectedSources) {
+        const apps = appsBySource.get(source);
+        if (apps) {
+            for (const [name, app] of apps) {
+                // Include non-libraries by default from selected groups
+                if (app.type !== 'library') {
+                    filteredApps[name] = app;
+                }
+            }
+        }
+    }
+    // If user selected groups, ask if they want to fine-tune individual apps
+    if (selectedSources.length > 0 && Object.keys(filteredApps).length > 0) {
+        const fineTune = await prompts.confirm({
+            message: `${Object.keys(filteredApps).length} apps selected. Fine-tune individual apps?`,
+            default: false,
+        });
+        if (fineTune) {
+            // Show all apps from selected groups for fine-tuning
+            const allAppsInGroups = [];
+            for (const source of selectedSources) {
+                const apps = appsBySource.get(source);
+                if (apps)
+                    allAppsInGroups.push(...apps);
+            }
+            const appChoices = allAppsInGroups.map(([name, app]) => ({
+                name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+                value: name,
+                checked: app.type !== 'library',
+            }));
+            const selectedApps = await prompts.checkbox({
+                message: 'Select individual apps:',
+                choices: appChoices,
+            });
+            const finalApps = {};
+            for (const appName of selectedApps) {
+                finalApps[appName] = detected.apps[appName];
+            }
+            return { ...detected, apps: finalApps };
+        }
     }
     return { ...detected, apps: filteredApps };
 }
 /**
- * Interactive infrastructure selection
+ * Interactive infrastructure selection (grouped by source file)
  */
 async function selectInfrastructure(detected) {
     if (!detected.infrastructure || detected.infrastructure.length === 0) {
         return detected;
     }
+    // Group infrastructure by source file
+    const infraBySource = new Map();
+    for (const infra of detected.infrastructure) {
+        const source = infra.source || 'unknown';
+        if (!infraBySource.has(source)) {
+            infraBySource.set(source, []);
+        }
+        infraBySource.get(source).push(infra);
+    }
     console.log('');
     console.log(chalk_1.default.blue('=== Detected Infrastructure ==='));
     console.log('');
-    for (const infra of detected.infrastructure) {
-        const parts = [
-            chalk_1.default.cyan(infra.name),
-            `(${infra.type})`,
-            infra.image ? `[${infra.image}]` : '',
-            infra.port ? `port:${infra.port}` : '',
-        ].filter(Boolean);
-        console.log(`  ${parts.join(' ')}`);
+    // Display grouped by source
+    for (const [source, infraList] of infraBySource) {
+        console.log(chalk_1.default.dim(`  ${source}:`));
+        for (const infra of infraList) {
+            const parts = [
+                chalk_1.default.cyan(infra.name),
+                `(${infra.type})`,
+                infra.image && infra.image !== 'unknown' ? `[${infra.image}]` : '',
+                infra.port ? `port:${infra.port}` : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
+        }
     }
     console.log('');
-    const infraChoices = detected.infrastructure.map(infra => ({
-        name: `${infra.name} (${infra.type}${infra.image ? `, ${infra.image}` : ''})`,
-        value: infra.name,
-        checked: true, // Infrastructure is typically required, so default to selected
-    }));
-    const selectedInfra = await prompts.checkbox({
-        message: 'Select infrastructure to include:',
-        choices: infraChoices,
+    // If only one source file, select individual services
+    if (infraBySource.size === 1) {
+        const infraChoices = detected.infrastructure.map(infra => ({
+            name: `${infra.name} (${infra.type}${infra.image && infra.image !== 'unknown' ? `, ${infra.image}` : ''})`,
+            value: infra.name,
+            checked: true,
+        }));
+        const selectedInfra = await prompts.checkbox({
+            message: 'Select infrastructure to include:',
+            choices: infraChoices,
+        });
+        const filteredInfra = detected.infrastructure.filter(infra => selectedInfra.includes(infra.name));
+        return { ...detected, infrastructure: filteredInfra.length > 0 ? filteredInfra : undefined };
+    }
+    // Multiple source files - let user select by file first
+    const sourceChoices = Array.from(infraBySource.entries()).map(([source, infraList]) => {
+        const serviceNames = infraList.map(i => i.name).join(', ');
+        return {
+            name: `${source} (${serviceNames})`,
+            value: source,
+            checked: true,
+        };
     });
-    const filteredInfra = detected.infrastructure.filter(infra => selectedInfra.includes(infra.name));
+    const selectedSources = await prompts.checkbox({
+        message: 'Select infrastructure sources to include:',
+        choices: sourceChoices,
+    });
+    // Collect all infrastructure from selected sources
+    let filteredInfra = [];
+    for (const source of selectedSources) {
+        const infraList = infraBySource.get(source);
+        if (infraList) {
+            filteredInfra.push(...infraList);
+        }
+    }
+    // If user selected sources, ask if they want to fine-tune individual services
+    if (selectedSources.length > 0 && filteredInfra.length > 0) {
+        const fineTune = await prompts.confirm({
+            message: `${filteredInfra.length} infrastructure services selected. Fine-tune individual services?`,
+            default: false,
+        });
+        if (fineTune) {
+            const infraChoices = filteredInfra.map(infra => ({
+                name: `${infra.name} (${infra.type}${infra.image && infra.image !== 'unknown' ? `, ${infra.image}` : ''}) - ${infra.source}`,
+                value: `${infra.name}@${infra.source}`, // Unique key
+                checked: true,
+            }));
+            const selectedInfraKeys = await prompts.checkbox({
+                message: 'Select individual infrastructure services:',
+                choices: infraChoices,
+            });
+            filteredInfra = filteredInfra.filter(infra => selectedInfraKeys.includes(`${infra.name}@${infra.source}`));
+        }
+    }
     return { ...detected, infrastructure: filteredInfra.length > 0 ? filteredInfra : undefined };
 }
 /**
@@ -1217,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/compose-parser.js

@@ -93,6 +93,18 @@ const INFRA_PATTERNS = [
     /^zipkin/i,
     /^vault/i,
     /^consul/i,
+    // Vector databases
+    /^qdrant/i,
+    /^weaviate/i,
+    /^semitechnologies\/weaviate/i,
+    /^pinecone/i,
+    /^milvus/i,
+    /^chroma/i,
+    // Logging
+    /^loki/i,
+    /^promtail/i,
+    /^fluentd/i,
+    /^logstash/i,
 ];
 class ComposeParser {
     /**
@@ -107,9 +119,13 @@ class ComposeParser {
         for (const file of composeFiles) {
             try {
                 const content = yaml.load(fs.readFileSync(file, 'utf8'));
+                // Get relative path for cleaner display
+                const relativeFile = path.relative(root, file);
+                // Get compose file's directory for resolving relative build contexts
+                const composeDir = path.dirname(file);
                 if (content && content.services) {
                     for (const [name, config] of Object.entries(content.services)) {
-                        const service = this.normalizeService(name, config, root);
+                        const service = this.normalizeService(name, config, root, composeDir, relativeFile);
                         allServices.push(service);
                     }
                 }
@@ -177,11 +193,11 @@ class ComposeParser {
         findRecursively(root);
         return files;
     }
-    normalizeService(name, config, root) {
+    normalizeService(name, config, root, composeDir, sourceFile) {
         return {
             name,
             image: config.image,
-            build: this.normalizeBuild(config.build, root),
+            build: this.normalizeBuild(config.build, root, composeDir),
             ports: this.normalizePorts(config.ports),
             environment: this.normalizeEnvironment(config.environment),
             envFile: this.normalizeEnvFile(config.env_file),
@@ -190,20 +206,25 @@ class ComposeParser {
             healthcheck: this.normalizeHealthcheck(config.healthcheck),
             command: this.normalizeCommand(config.command),
             labels: this.normalizeLabels(config.labels),
+            sourceFile,
         };
     }
-    normalizeBuild(build, root) {
+    normalizeBuild(build, root, composeDir) {
         if (!build)
             return undefined;
         if (typeof build === 'string') {
+            // Resolve relative to compose file directory, then make relative to root
+            const absoluteContext = path.resolve(composeDir, build);
             return {
-                context: path.resolve(root, build),
+                context: path.relative(root, absoluteContext),
             };
         }
         if (typeof build === 'object') {
             const b = build;
+            // Resolve relative to compose file directory, then make relative to root
+            const absoluteContext = path.resolve(composeDir, b.context || '.');
             return {
-                context: path.resolve(root, b.context || '.'),
+                context: path.relative(root, absoluteContext),
                 dockerfile: b.dockerfile,
                 target: b.target,
             };

package/dist/scanner/env-analyzer.js

@@ -323,8 +323,8 @@ class EnvAnalyzer {
                 return type;
             }
         }
-        // Check value format
-        if (value) {
+        // Check value format (ensure value is a string)
+        if (value && typeof value === 'string') {
             if (/^(true|false)$/i.test(value))
                 return 'boolean';
             if (/^\d+$/.test(value))

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