genbox 1.0.37 → 1.0.39

package/dist/commands/init.js

@@ -1736,6 +1736,13 @@ function convertV2ToV4(v2Config, scan) {
         if (service.env?.length) {
             appConfig.env = service.env;
         }
+        // Set runner and docker config
+        if (service.runner) {
+            appConfig.runner = service.runner;
+        }
+        if (service.docker) {
+            appConfig.docker = service.docker;
+        }
         apps[name] = appConfig;
     }
     // Convert infrastructure to provides (v4 format)
@@ -1838,7 +1845,15 @@ function convertDetectedToScan(detected) {
             'gateway': 'gateway',
             'library': 'library',
         };
-        apps.push({
+        // Map runner types
+        const runnerMap = {
+            'pm2': 'pm2',
+            'docker': 'docker',
+            'node': 'node',
+            'bun': 'bun',
+            'none': 'none',
+        };
+        const discoveredApp = {
             name,
             path: app.path,
             type: typeMap[app.type || 'library'] || 'library',
@@ -1850,7 +1865,17 @@ function convertDetectedToScan(detected) {
                 build: app.commands.build || '',
                 start: app.commands.start || '',
             } : {},
-        });
+            runner: app.runner ? runnerMap[app.runner] : undefined,
+        };
+        // Add docker config if present
+        if (app.docker) {
+            discoveredApp.docker = {
+                service: app.docker.service,
+                build_context: app.docker.build_context,
+                dockerfile: app.docker.dockerfile,
+            };
+        }
+        apps.push(discoveredApp);
     }
     // Convert runtimes
     const runtimes = detected.runtimes.map(r => ({

package/dist/commands/profiles.js

@@ -42,7 +42,6 @@ const prompts = __importStar(require("@inquirer/prompts"));
 const chalk_1 = __importDefault(require("chalk"));
 const yaml = __importStar(require("js-yaml"));
 const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
 const config_loader_1 = require("../config-loader");
 const schema_v4_1 = require("../schema-v4");
 exports.profilesCommand = new commander_1.Command('profiles')
@@ -278,29 +277,15 @@ exports.profilesCommand
                 source: dbMode.includes('staging') ? 'staging' : dbMode.includes('production') ? 'production' : undefined,
             } : undefined,
         };
-        // Where to save?
-        const saveLocation = await prompts.select({
-            message: 'Where to save this profile?',
-            choices: [
-                { name: 'genbox.yaml (shared with team)', value: 'project' },
-                { name: '~/.genbox/profiles.yaml (personal)', value: 'user' },
-            ],
-        });
-        if (saveLocation === 'user') {
-            configLoader.saveUserProfile(profileName, profile);
-            console.log(chalk_1.default.green(`\n✔ Profile '${profileName}' saved to ~/.genbox/profiles.yaml`));
-        }
-        else {
-            // Add to project config
-            if (!config.profiles) {
-                config.profiles = {};
-            }
-            config.profiles[profileName] = profile;
-            const configPath = configLoader.getConfigPath();
-            const yamlContent = yaml.dump(config, { lineWidth: 120, noRefs: true });
-            fs.writeFileSync(configPath, yamlContent);
-            console.log(chalk_1.default.green(`\n✔ Profile '${profileName}' added to genbox.yaml`));
+        // Save to project config (user/global profiles removed - they reference project-specific apps)
+        if (!config.profiles) {
+            config.profiles = {};
         }
+        config.profiles[profileName] = profile;
+        const configPath = configLoader.getConfigPath();
+        const yamlContent = yaml.dump(config, { lineWidth: 120, noRefs: true });
+        fs.writeFileSync(configPath, yamlContent);
+        console.log(chalk_1.default.green(`\n✔ Profile '${profileName}' added to genbox.yaml`));
         console.log(chalk_1.default.dim(`Use: genbox create <name> --profile ${profileName}`));
     }
     catch (error) {
@@ -315,8 +300,7 @@ exports.profilesCommand
 exports.profilesCommand
     .command('delete <name>')
     .description('Delete a profile')
-    .option('--user', 'Delete from user profiles')
-    .action(async (name, options) => {
+    .action(async (name) => {
     try {
         const configLoader = new config_loader_1.ConfigLoader();
         const loadResult = await configLoader.load();
@@ -331,12 +315,9 @@ exports.profilesCommand
             return;
         }
         const config = loadResult.config;
-        // Check if profile exists
-        const inProject = config.profiles?.[name];
-        const userProfiles = configLoader.loadUserProfiles();
-        const inUser = userProfiles?.profiles?.[name];
-        if (!inProject && !inUser) {
-            console.log(chalk_1.default.red(`Profile '${name}' not found`));
+        // Check if profile exists in project
+        if (!config.profiles?.[name]) {
+            console.log(chalk_1.default.red(`Profile '${name}' not found in genbox.yaml`));
             return;
         }
         // Confirm deletion
@@ -348,20 +329,11 @@ exports.profilesCommand
             console.log(chalk_1.default.dim('Cancelled.'));
             return;
         }
-        if (options.user && inUser) {
-            // Delete from user profiles
-            delete userProfiles.profiles[name];
-            const userProfilesPath = path.join(require('os').homedir(), '.genbox', 'profiles.yaml');
-            fs.writeFileSync(userProfilesPath, yaml.dump(userProfiles));
-            console.log(chalk_1.default.green(`✔ Deleted '${name}' from user profiles`));
-        }
-        else if (inProject) {
-            // Delete from project config
-            delete config.profiles[name];
-            const configPath = configLoader.getConfigPath();
-            fs.writeFileSync(configPath, yaml.dump(config, { lineWidth: 120, noRefs: true }));
-            console.log(chalk_1.default.green(`✔ Deleted '${name}' from genbox.yaml`));
-        }
+        // Delete from project config
+        delete config.profiles[name];
+        const configPath = configLoader.getConfigPath();
+        fs.writeFileSync(configPath, yaml.dump(config, { lineWidth: 120, noRefs: true }));
+        console.log(chalk_1.default.green(`✔ Deleted '${name}' from genbox.yaml`));
     }
     catch (error) {
         if (error.name === 'ExitPromptError') {

package/dist/commands/scan.js

@@ -112,10 +112,12 @@ exports.scanCommand = new commander_1.Command('scan')
     .option('--no-infra', 'Skip infrastructure detection (docker-compose)')
     .option('--no-scripts', 'Skip script detection')
     .option('-i, --interactive', 'Interactive mode - select apps before writing')
+    .option('--edit', 'Edit mode - review and modify detected values for each app')
     .option('-e, --exclude <patterns>', 'Comma-separated patterns to exclude', '')
     .action(async (options) => {
     const cwd = process.cwd();
-    const isInteractive = options.interactive && !options.stdout && process.stdin.isTTY;
+    const isInteractive = (options.interactive || options.edit) && !options.stdout && process.stdin.isTTY;
+    const isEditMode = options.edit && !options.stdout && process.stdin.isTTY;
     console.log(chalk_1.default.cyan('\n🔍 Scanning project...\n'));
     try {
         // Run the scanner
@@ -131,6 +133,10 @@ exports.scanCommand = new commander_1.Command('scan')
         if (isInteractive) {
             detected = await interactiveSelection(detected);
         }
+        // Edit mode: let user modify detected values for each app
+        if (isEditMode) {
+            detected = await interactiveEditMode(detected);
+        }
         // Scan env files for service URLs (only for selected frontend apps)
         const frontendApps = Object.entries(detected.apps)
             .filter(([, app]) => app.type === 'frontend')
@@ -285,6 +291,176 @@ async function interactiveSelection(detected) {
     }
     return result;
 }
+/**
+ * Interactive edit mode - allows modifying detected values for each app
+ */
+async function interactiveEditMode(detected) {
+    const result = { ...detected, apps: { ...detected.apps } };
+    const appEntries = Object.entries(result.apps);
+    if (appEntries.length === 0) {
+        console.log(chalk_1.default.dim('No apps to edit.'));
+        return result;
+    }
+    console.log('');
+    console.log(chalk_1.default.blue('=== Edit Detected Values ==='));
+    console.log(chalk_1.default.dim('Review and modify detected values for each app.\n'));
+    // Show summary of all apps first
+    console.log(chalk_1.default.bold('Detected apps:'));
+    for (const [name, app] of appEntries) {
+        const runner = app.runner || 'pm2';
+        const port = app.port ? `:${app.port}` : '';
+        console.log(`  ${chalk_1.default.cyan(name)} - ${app.type || 'unknown'} (${runner})${port}`);
+    }
+    console.log('');
+    // Ask if user wants to edit any apps
+    const editApps = await prompts.confirm({
+        message: 'Do you want to edit any app configurations?',
+        default: false,
+    });
+    if (!editApps) {
+        return result;
+    }
+    // Let user select which apps to edit
+    const appChoices = appEntries.map(([name, app]) => ({
+        name: `${name} (${app.type || 'unknown'}, ${app.runner || 'pm2'})`,
+        value: name,
+    }));
+    const appsToEdit = await prompts.checkbox({
+        message: 'Select apps to edit:',
+        choices: appChoices,
+    });
+    // Edit each selected app
+    for (const appName of appsToEdit) {
+        result.apps[appName] = await editAppConfig(appName, result.apps[appName]);
+    }
+    return result;
+}
+/**
+ * Edit a single app's configuration
+ */
+async function editAppConfig(name, app) {
+    console.log('');
+    console.log(chalk_1.default.blue(`=== Editing: ${name} ===`));
+    // Show current values
+    console.log(chalk_1.default.dim('Current values:'));
+    console.log(`  Type:      ${chalk_1.default.cyan(app.type || 'unknown')} ${chalk_1.default.dim(`(${app.type_reason || 'detected'})`)}`);
+    console.log(`  Runner:    ${chalk_1.default.cyan(app.runner || 'pm2')} ${chalk_1.default.dim(`(${app.runner_reason || 'default'})`)}`);
+    console.log(`  Port:      ${app.port ? chalk_1.default.cyan(String(app.port)) : chalk_1.default.dim('not set')} ${app.port_source ? chalk_1.default.dim(`(${app.port_source})`) : ''}`);
+    console.log(`  Framework: ${app.framework ? chalk_1.default.cyan(app.framework) : chalk_1.default.dim('not detected')}`);
+    console.log('');
+    const result = { ...app };
+    // Edit type
+    const typeChoices = [
+        { name: `frontend ${app.type === 'frontend' ? chalk_1.default.green('(current)') : ''}`, value: 'frontend' },
+        { name: `backend ${app.type === 'backend' ? chalk_1.default.green('(current)') : ''}`, value: 'backend' },
+        { name: `worker ${app.type === 'worker' ? chalk_1.default.green('(current)') : ''}`, value: 'worker' },
+        { name: `gateway ${app.type === 'gateway' ? chalk_1.default.green('(current)') : ''}`, value: 'gateway' },
+        { name: `library ${app.type === 'library' ? chalk_1.default.green('(current)') : ''}`, value: 'library' },
+    ];
+    const newType = await prompts.select({
+        message: 'App type:',
+        choices: typeChoices,
+        default: app.type || 'backend',
+    });
+    if (newType !== app.type) {
+        result.type = newType;
+        result.type_reason = 'manually set';
+    }
+    // Edit runner
+    const runnerChoices = [
+        { name: `pm2 - Process manager (recommended for Node.js) ${app.runner === 'pm2' ? chalk_1.default.green('(current)') : ''}`, value: 'pm2' },
+        { name: `docker - Docker compose service ${app.runner === 'docker' ? chalk_1.default.green('(current)') : ''}`, value: 'docker' },
+        { name: `bun - Bun runtime ${app.runner === 'bun' ? chalk_1.default.green('(current)') : ''}`, value: 'bun' },
+        { name: `node - Direct Node.js execution ${app.runner === 'node' ? chalk_1.default.green('(current)') : ''}`, value: 'node' },
+        { name: `none - Library/not runnable ${app.runner === 'none' ? chalk_1.default.green('(current)') : ''}`, value: 'none' },
+    ];
+    const newRunner = await prompts.select({
+        message: 'Runner:',
+        choices: runnerChoices,
+        default: app.runner || 'pm2',
+    });
+    if (newRunner !== app.runner) {
+        result.runner = newRunner;
+        result.runner_reason = 'manually set';
+    }
+    // If runner is docker, ask for docker config
+    if (newRunner === 'docker') {
+        const dockerService = await prompts.input({
+            message: 'Docker service name:',
+            default: app.docker?.service || name,
+        });
+        const dockerContext = await prompts.input({
+            message: 'Docker build context:',
+            default: app.docker?.build_context || app.path || '.',
+        });
+        result.docker = {
+            service: dockerService,
+            build_context: dockerContext,
+            dockerfile: app.docker?.dockerfile,
+        };
+    }
+    // Edit port (only if not a library)
+    if (newRunner !== 'none' && result.type !== 'library') {
+        const portInput = await prompts.input({
+            message: 'Port (leave empty to skip):',
+            default: app.port ? String(app.port) : '',
+        });
+        if (portInput) {
+            const portNum = parseInt(portInput, 10);
+            if (!isNaN(portNum) && portNum > 0 && portNum < 65536) {
+                result.port = portNum;
+                if (portNum !== app.port) {
+                    result.port_source = 'manually set';
+                }
+            }
+        }
+        else {
+            result.port = undefined;
+            result.port_source = undefined;
+        }
+    }
+    // Edit framework
+    const frameworkChoices = [
+        { name: `Keep current: ${app.framework || 'none'}`, value: app.framework || '' },
+        { name: '---', value: '__separator__', disabled: true },
+        { name: 'nextjs', value: 'nextjs' },
+        { name: 'react', value: 'react' },
+        { name: 'vue', value: 'vue' },
+        { name: 'nuxt', value: 'nuxt' },
+        { name: 'vite', value: 'vite' },
+        { name: 'astro', value: 'astro' },
+        { name: 'nestjs', value: 'nestjs' },
+        { name: 'express', value: 'express' },
+        { name: 'fastify', value: 'fastify' },
+        { name: 'hono', value: 'hono' },
+        { name: 'Other (type manually)', value: '__other__' },
+        { name: 'None / Clear', value: '__none__' },
+    ];
+    const frameworkChoice = await prompts.select({
+        message: 'Framework:',
+        choices: frameworkChoices,
+        default: app.framework || '',
+    });
+    if (frameworkChoice === '__other__') {
+        const customFramework = await prompts.input({
+            message: 'Enter framework name:',
+        });
+        if (customFramework) {
+            result.framework = customFramework;
+            result.framework_source = 'manually set';
+        }
+    }
+    else if (frameworkChoice === '__none__') {
+        result.framework = undefined;
+        result.framework_source = undefined;
+    }
+    else if (frameworkChoice && frameworkChoice !== app.framework) {
+        result.framework = frameworkChoice;
+        result.framework_source = 'manually set';
+    }
+    console.log(chalk_1.default.green(`✓ Updated ${name}`));
+    return result;
+}
 /**
  * Interactive service URL selection
  */
@@ -459,10 +635,14 @@ function convertScanToDetected(scan, root) {
             const appDir = path.join(root, app.path);
             appGit = detectGitForDirectory(appDir);
         }
+        // Detect runner based on app type and context
+        const { runner, runner_reason } = detectRunner(app, scan);
         detected.apps[app.name] = {
             path: app.path,
             type: mappedType,
             type_reason: inferTypeReason(app),
+            runner,
+            runner_reason,
             port: app.port,
             port_source: app.port ? inferPortSource(app) : undefined,
             framework: app.framework, // Framework is a string type
@@ -506,17 +686,31 @@ function convertScanToDetected(scan, root) {
                 source: 'docker-compose.yml',
             });
         }
-        // Save Docker application services (services with build context)
+        // Add Docker application services as apps with runner: 'docker'
+        // (Only add if not already detected as a PM2 app)
         if (scan.compose.applications && scan.compose.applications.length > 0) {
-            detected.docker_services = scan.compose.applications.map(app => ({
-                name: app.name,
-                build_context: app.build?.context,
-                dockerfile: app.build?.dockerfile,
-                image: app.image,
-                port: app.ports?.[0]?.host,
-                depends_on: app.dependsOn?.length ? app.dependsOn : undefined,
-                source: 'docker-compose.yml',
-            }));
+            for (const dockerApp of scan.compose.applications) {
+                // Skip if already exists as a PM2 app
+                if (detected.apps[dockerApp.name])
+                    continue;
+                // Infer type by checking file structure in build context
+                const { type: mappedType, reason: typeReason } = inferDockerAppType(dockerApp.name, dockerApp.build?.context, scan.root);
+                detected.apps[dockerApp.name] = {
+                    path: dockerApp.build?.context || '.',
+                    type: mappedType,
+                    type_reason: typeReason,
+                    runner: 'docker',
+                    runner_reason: 'defined in docker-compose.yml',
+                    docker: {
+                        service: dockerApp.name,
+                        build_context: dockerApp.build?.context,
+                        dockerfile: dockerApp.build?.dockerfile,
+                        image: dockerApp.image,
+                    },
+                    port: dockerApp.ports?.[0]?.host,
+                    port_source: 'docker-compose.yml ports',
+                };
+            }
         }
     }
     // Git info
@@ -567,6 +761,38 @@ function mapAppType(type) {
             return undefined; // Unknown type
     }
 }
+/**
+ * Detect the appropriate runner for an app
+ * Priority:
+ * 1. Library apps → none
+ * 2. Bun lockfile present → bun
+ * 3. Has start script or is a typical app → pm2
+ * 4. Simple CLI/script → node
+ */
+function detectRunner(app, scan) {
+    // Libraries don't run
+    if (app.type === 'library') {
+        return { runner: 'none', runner_reason: 'library apps are not runnable' };
+    }
+    // Check for Bun
+    const hasBunLockfile = scan.runtimes?.some(r => r.lockfile === 'bun.lockb');
+    if (hasBunLockfile) {
+        return { runner: 'bun', runner_reason: 'bun.lockb detected' };
+    }
+    // Check for typical app patterns that benefit from PM2
+    const hasStartScript = app.scripts?.start || app.scripts?.dev;
+    const isTypicalApp = ['frontend', 'backend', 'api', 'worker', 'gateway'].includes(app.type || '');
+    if (hasStartScript || isTypicalApp) {
+        return { runner: 'pm2', runner_reason: 'typical Node.js app with start script' };
+    }
+    // CLI tools or simple scripts can use direct node
+    const name = (app.name || '').toLowerCase();
+    if (name.includes('cli') || name.includes('tool') || name.includes('script')) {
+        return { runner: 'node', runner_reason: 'CLI/tool detected' };
+    }
+    // Default to pm2 for most apps
+    return { runner: 'pm2', runner_reason: 'default for Node.js apps' };
+}
 function inferTypeReason(app) {
     if (!app.type)
         return 'unknown';
@@ -582,6 +808,75 @@ function inferTypeReason(app) {
     }
     return 'dependency analysis';
 }
+/**
+ * Infer app type by examining file structure in the build context directory
+ * Falls back to name-based detection only if file analysis doesn't find anything
+ */
+function inferDockerAppType(name, buildContext, rootDir) {
+    // If we have a build context, check file structure first
+    if (buildContext && rootDir) {
+        const contextPath = path.resolve(rootDir, buildContext);
+        // Check for frontend indicators
+        const frontendConfigs = ['vite.config.ts', 'vite.config.js', 'next.config.js', 'next.config.mjs', 'nuxt.config.ts', 'astro.config.mjs'];
+        for (const config of frontendConfigs) {
+            if (fs.existsSync(path.join(contextPath, config))) {
+                return { type: 'frontend', reason: `config file found: ${config}` };
+            }
+        }
+        // Check for backend indicators
+        const backendConfigs = ['nest-cli.json', 'tsconfig.build.json'];
+        for (const config of backendConfigs) {
+            if (fs.existsSync(path.join(contextPath, config))) {
+                return { type: 'backend', reason: `config file found: ${config}` };
+            }
+        }
+        // Check package.json dependencies
+        const packageJsonPath = path.join(contextPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+                // Frontend dependencies
+                const frontendDeps = ['react', 'react-dom', 'vue', '@angular/core', 'svelte', 'next', 'nuxt', 'vite', '@remix-run/react', 'astro'];
+                for (const dep of frontendDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'frontend', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+                // Backend dependencies
+                const backendDeps = ['@nestjs/core', 'express', 'fastify', 'koa', 'hapi', '@hono/node-server'];
+                for (const dep of backendDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'backend', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+                // Worker dependencies
+                const workerDeps = ['bull', 'bullmq', 'agenda', 'bee-queue'];
+                for (const dep of workerDeps) {
+                    if (allDeps[dep]) {
+                        return { type: 'worker', reason: `package.json dependency: ${dep}` };
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // Fall back to name-based detection
+    const lowerName = name.toLowerCase();
+    if (lowerName.includes('web') || lowerName.includes('frontend') || lowerName.includes('ui') || lowerName.includes('client')) {
+        return { type: 'frontend', reason: `naming convention ('${name}' contains frontend keyword)` };
+    }
+    if (lowerName.includes('api') || lowerName.includes('backend') || lowerName.includes('server') || lowerName.includes('gateway')) {
+        return { type: 'backend', reason: `naming convention ('${name}' contains backend keyword)` };
+    }
+    if (lowerName.includes('worker') || lowerName.includes('queue') || lowerName.includes('job')) {
+        return { type: 'worker', reason: `naming convention ('${name}' contains worker keyword)` };
+    }
+    // Default to backend for Docker services
+    return { type: 'backend', reason: 'default for Docker services' };
+}
 function inferPortSource(app) {
     if (app.scripts?.dev?.includes('--port')) {
         return 'package.json scripts.dev (--port flag)';

package/dist/config-loader.js

@@ -467,7 +467,8 @@ class ConfigLoader {
      */
     listProfiles(config) {
         const profiles = [];
-        // Project profiles
+        // Project profiles only (user/global profiles removed - they don't make sense
+        // because profiles reference project-specific app names)
         for (const [name, profile] of Object.entries(config.profiles || {})) {
             const resolved = this.getProfile(config, name);
             profiles.push({
@@ -479,24 +480,6 @@ class ConfigLoader {
                 connection: resolved ? getProfileConnection(resolved) : undefined,
             });
         }
-        // User profiles
-        const userProfiles = this.loadUserProfiles();
-        if (userProfiles) {
-            for (const [name, profile] of Object.entries(userProfiles.profiles || {})) {
-                // Skip if already defined in project
-                if (config.profiles?.[name])
-                    continue;
-                const resolved = this.getProfile(config, name);
-                profiles.push({
-                    name,
-                    description: profile.description,
-                    source: 'user',
-                    apps: resolved?.apps || [],
-                    size: resolved?.size,
-                    connection: resolved ? getProfileConnection(resolved) : undefined,
-                });
-            }
-        }
         return profiles;
     }
     /**

package/dist/migration.js

@@ -244,7 +244,8 @@ function migrateApp(appName, appConfig, v3Config, changes, warnings) {
     if (appConfig.env)
         v4App.env = appConfig.env;
     if (appConfig.compose_file) {
-        v4App.compose = { file: appConfig.compose_file };
+        v4App.runner = 'docker';
+        v4App.docker = { file: appConfig.compose_file };
     }
     // Warn about missing explicit type
     if (!appConfig.type) {

package/dist/scanner/config-generator.js

@@ -77,6 +77,18 @@ class ConfigGenerator {
                         output: framework?.outputDir,
                     };
                 }
+                // Set runner from app if available
+                if (app.runner) {
+                    serviceConfig.runner = app.runner;
+                }
+                // Set docker config if present
+                if (app.docker) {
+                    serviceConfig.docker = {
+                        service: app.docker.service,
+                        build_context: app.docker.build_context,
+                        dockerfile: app.docker.dockerfile,
+                    };
+                }
                 services[app.name] = serviceConfig;
             }
         }
@@ -120,8 +132,42 @@ class ConfigGenerator {
                         output: framework?.outputDir,
                     };
                 }
+                // Set runner from app if available
+                if (app.runner) {
+                    serviceConfig.runner = app.runner;
+                }
+                // Set docker config if present
+                if (app.docker) {
+                    serviceConfig.docker = {
+                        service: app.docker.service,
+                        build_context: app.docker.build_context,
+                        dockerfile: app.docker.dockerfile,
+                    };
+                }
                 services[app.name] = serviceConfig;
             }
+            // Also include Docker services from compose (if not already added as apps)
+            // This is a fallback for services not detected during scan
+            if (scan.compose?.applications) {
+                for (const dockerApp of scan.compose.applications) {
+                    // Skip if already exists as an app
+                    if (services[dockerApp.name])
+                        continue;
+                    const port = dockerApp.ports[0]?.host || 3000;
+                    services[dockerApp.name] = {
+                        type: this.inferServiceType(dockerApp.name),
+                        port,
+                        runner: 'docker',
+                        docker: {
+                            service: dockerApp.name,
+                            build_context: dockerApp.build?.context,
+                            dockerfile: dockerApp.build?.dockerfile,
+                        },
+                        dependsOn: dockerApp.dependsOn.map(d => this.normalizeServiceName(d)),
+                        env: Object.keys(dockerApp.environment || {}).filter(k => !k.startsWith('_')),
+                    };
+                }
+            }
         }
         // Single app fallback
         if (Object.keys(services).length === 0 && scan.frameworks.length > 0) {

package/package.json

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