genbox 1.0.14 → 1.0.15

package/dist/commands/init.js

@@ -162,6 +162,7 @@ exports.initCommand = new commander_1.Command('init')
     .option('-y, --yes', 'Use defaults without prompting')
     .option('--exclude <dirs>', 'Comma-separated directories to exclude')
     .option('--name <name>', 'Project name (for non-interactive mode)')
+    .option('--from-scan', 'Initialize from existing .genbox/detected.yaml (created by genbox scan)')
     .action(async (options) => {
     try {
         const configPath = path_1.default.join(process.cwd(), CONFIG_FILENAME);
@@ -192,11 +193,34 @@ exports.initCommand = new commander_1.Command('init')
         if (options.exclude) {
             exclude = options.exclude.split(',').map((d) => d.trim()).filter(Boolean);
         }
-        // Scan project first (skip scripts initially)
-        const spinner = (0, ora_1.default)('Scanning project...').start();
+        let scan;
         const scanner = new scanner_1.ProjectScanner();
-        let scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
-        spinner.succeed('Project scanned');
+        // If --from-scan is specified, load from detected.yaml
+        if (options.fromScan) {
+            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
+            if (!fs_1.default.existsSync(detectedPath)) {
+                console.log(chalk_1.default.red('No .genbox/detected.yaml found. Run "genbox scan" first.'));
+                process.exit(1);
+            }
+            const spinner = (0, ora_1.default)('Loading detected configuration...').start();
+            try {
+                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
+                const detected = yaml.load(content);
+                scan = convertDetectedToScan(detected);
+                spinner.succeed('Loaded from detected.yaml');
+            }
+            catch (err) {
+                spinner.fail('Failed to load detected.yaml');
+                console.error(chalk_1.default.red(String(err)));
+                process.exit(1);
+            }
+        }
+        else {
+            // Scan project first (skip scripts initially)
+            const spinner = (0, ora_1.default)('Scanning project...').start();
+            scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
+            spinner.succeed('Project scanned');
+        }
         // Display scan results
         console.log('');
         console.log(chalk_1.default.bold('Detected:'));
@@ -213,9 +237,10 @@ exports.initCommand = new commander_1.Command('init')
             console.log(`  ${chalk_1.default.dim('Frameworks:')} ${frameworkStr}`);
         }
         // For multi-repo: show apps and let user select which to include
+        // When using --from-scan, skip app selection - use exactly what's in detected.yaml
         const isMultiRepoStructure = scan.structure.type === 'hybrid';
         let selectedApps = scan.apps;
-        if (isMultiRepoStructure && scan.apps.length > 0 && !nonInteractive) {
+        if (isMultiRepoStructure && scan.apps.length > 0 && !nonInteractive && !options.fromScan) {
             console.log('');
             console.log(chalk_1.default.blue('=== Apps Detected ==='));
             const appChoices = scan.apps.map(app => ({
@@ -232,6 +257,14 @@ exports.initCommand = new commander_1.Command('init')
             // Update scan with filtered apps
             scan = { ...scan, apps: selectedApps };
         }
+        else if (options.fromScan && scan.apps.length > 0) {
+            // When using --from-scan, show what was loaded and use it directly
+            console.log(`  ${chalk_1.default.dim('Apps:')}       ${scan.apps.length} from detected.yaml`);
+            for (const app of scan.apps) {
+                console.log(`               - ${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`);
+            }
+            console.log(chalk_1.default.dim('\n  (Edit .genbox/detected.yaml to change app selection)'));
+        }
         else if (scan.apps.length > 0) {
             console.log(`  ${chalk_1.default.dim('Apps:')}       ${scan.apps.length} discovered`);
             for (const app of scan.apps.slice(0, 5)) {
@@ -248,17 +281,17 @@ exports.initCommand = new commander_1.Command('init')
             console.log(`  ${chalk_1.default.dim('Git:')}        ${scan.git.remote} (${scan.git.type})`);
         }
         console.log('');
-        // Get project name
-        const projectName = nonInteractive
+        // Get project name (use scan value when --from-scan)
+        const projectName = (nonInteractive || options.fromScan)
             ? (options.name || scan.projectName)
             : await prompts.input({
                 message: 'Project name:',
                 default: scan.projectName,
             });
-        // Determine if workspace or single project
+        // Determine if workspace or single project (auto-detect when --from-scan)
         let isWorkspace = options.workspace;
         if (!isWorkspace && (scan.structure.type.startsWith('monorepo') || scan.structure.type === 'hybrid')) {
-            if (nonInteractive) {
+            if (nonInteractive || options.fromScan) {
                 isWorkspace = true; // Default to workspace for monorepos
             }
             else {
@@ -271,25 +304,25 @@ exports.initCommand = new commander_1.Command('init')
         // Generate initial config (v2 format)
         const generator = new config_generator_1.ConfigGenerator();
         const generated = generator.generate(scan);
-        // Convert to v3 format
-        const v3Config = convertV2ToV3(generated.config, scan);
+        // Convert to v4 format (declarative-first architecture)
+        const v4Config = convertV2ToV4(generated.config, scan);
         // Update project name
-        v3Config.project.name = projectName;
-        // Ask about profiles
+        v4Config.project.name = projectName;
+        // Ask about profiles (skip prompt when using --from-scan)
         let createProfiles = true;
-        if (!nonInteractive) {
+        if (!nonInteractive && !options.fromScan) {
             createProfiles = await prompts.confirm({
                 message: 'Create predefined profiles for common scenarios?',
                 default: true,
             });
         }
         if (createProfiles) {
-            v3Config.profiles = nonInteractive
-                ? createDefaultProfilesSync(scan, v3Config)
-                : await createDefaultProfiles(scan, v3Config);
+            v4Config.profiles = (nonInteractive || options.fromScan)
+                ? createDefaultProfilesSync(scan, v4Config)
+                : await createDefaultProfiles(scan, v4Config);
         }
-        // Get server size
-        const serverSize = nonInteractive
+        // Get server size (use defaults when --from-scan)
+        const serverSize = (nonInteractive || options.fromScan)
             ? generated.config.system.size
             : await prompts.select({
                 message: 'Default server size:',
@@ -301,13 +334,95 @@ exports.initCommand = new commander_1.Command('init')
                 ],
                 default: generated.config.system.size,
             });
-        if (!v3Config.defaults) {
-            v3Config.defaults = {};
+        if (!v4Config.defaults) {
+            v4Config.defaults = {};
         }
-        v3Config.defaults.size = serverSize;
+        v4Config.defaults.size = serverSize;
         // Git repository setup - different handling for multi-repo vs single-repo
+        // When using --from-scan, skip git selection and use what's in detected.yaml
         const isMultiRepo = isMultiRepoStructure;
-        if (isMultiRepo) {
+        if (options.fromScan) {
+            // When using --from-scan, extract git repos from detected.yaml apps
+            const detectedPath = path_1.default.join(process.cwd(), '.genbox', 'detected.yaml');
+            let detectedConfig = null;
+            try {
+                const content = fs_1.default.readFileSync(detectedPath, 'utf8');
+                detectedConfig = yaml.load(content);
+            }
+            catch { }
+            // Check for per-app git repos first (multi-repo workspace)
+            const appsWithGit = detectedConfig
+                ? Object.entries(detectedConfig.apps).filter(([, app]) => app.git)
+                : [];
+            if (appsWithGit.length > 0) {
+                // Multi-repo: use per-app git repos
+                console.log('');
+                console.log(chalk_1.default.blue('=== Git Repositories (from detected.yaml) ==='));
+                console.log(chalk_1.default.dim(`Found ${appsWithGit.length} repositories`));
+                v4Config.repos = {};
+                let hasHttpsRepos = false;
+                for (const [appName, app] of appsWithGit) {
+                    const git = app.git;
+                    v4Config.repos[appName] = {
+                        url: git.remote,
+                        path: `/home/dev/${projectName}/${app.path}`,
+                        branch: git.branch !== 'main' && git.branch !== 'master' ? git.branch : undefined,
+                        auth: git.type === 'ssh' ? 'ssh' : 'token',
+                    };
+                    console.log(`  ${chalk_1.default.cyan(appName)}: ${git.remote}`);
+                    if (git.type === 'https') {
+                        hasHttpsRepos = true;
+                    }
+                }
+                // Prompt for GIT_TOKEN if any HTTPS repos are found
+                if (hasHttpsRepos && !nonInteractive) {
+                    console.log('');
+                    console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
+                    console.log('');
+                    console.log(chalk_1.default.dim('  To create a token:'));
+                    console.log(chalk_1.default.dim('  1. Go to https://github.com/settings/tokens'));
+                    console.log(chalk_1.default.dim('  2. Click "Generate new token" → "Classic"'));
+                    console.log(chalk_1.default.dim('  3. Select scope: "repo" (Full control of private repositories)'));
+                    console.log(chalk_1.default.dim('  4. Generate and copy the token'));
+                    console.log('');
+                    const gitToken = await prompts.password({
+                        message: 'GitHub Personal Access Token (leave empty to skip):',
+                    });
+                    if (gitToken) {
+                        envVarsToAdd['GIT_TOKEN'] = gitToken;
+                        console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
+                    }
+                    else {
+                        console.log(chalk_1.default.dim('  Skipped - add GIT_TOKEN to .env.genbox later if needed'));
+                    }
+                }
+            }
+            else if (scan.git) {
+                // Single repo or monorepo with root git
+                const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
+                v4Config.repos = {
+                    [repoName]: {
+                        url: scan.git.remote,
+                        path: `/home/dev/${projectName}`,
+                        auth: scan.git.type === 'ssh' ? 'ssh' : 'token',
+                    },
+                };
+                console.log(chalk_1.default.dim(`  Git:        Using ${repoName} from detected.yaml`));
+                // Prompt for GIT_TOKEN if HTTPS
+                if (scan.git.type === 'https' && !nonInteractive) {
+                    console.log('');
+                    console.log(chalk_1.default.yellow('Private repositories require a GitHub token for cloning.'));
+                    const gitToken = await prompts.password({
+                        message: 'GitHub Personal Access Token (leave empty to skip):',
+                    });
+                    if (gitToken) {
+                        envVarsToAdd['GIT_TOKEN'] = gitToken;
+                        console.log(chalk_1.default.green('✓ GIT_TOKEN will be added to .env.genbox'));
+                    }
+                }
+            }
+        }
+        else if (isMultiRepo) {
             // Multi-repo workspace: detect git repos in app directories
             const appGitRepos = detectAppGitRepos(scan.apps, process.cwd());
             if (appGitRepos.length > 0 && !nonInteractive) {
@@ -324,11 +439,11 @@ exports.initCommand = new commander_1.Command('init')
                     choices: repoChoices,
                 });
                 if (selectedRepos.length > 0) {
-                    v3Config.repos = {};
+                    v4Config.repos = {};
                     let hasHttpsRepos = false;
                     for (const repoName of selectedRepos) {
                         const repo = appGitRepos.find(r => r.appName === repoName);
-                        v3Config.repos[repo.appName] = {
+                        v4Config.repos[repo.appName] = {
                             url: repo.remote,
                             path: `/home/dev/${projectName}/${repo.appPath}`,
                             branch: repo.branch !== 'main' && repo.branch !== 'master' ? repo.branch : undefined,
@@ -364,9 +479,9 @@ exports.initCommand = new commander_1.Command('init')
             }
             else if (appGitRepos.length > 0) {
                 // Non-interactive: include all repos
-                v3Config.repos = {};
+                v4Config.repos = {};
                 for (const repo of appGitRepos) {
-                    v3Config.repos[repo.appName] = {
+                    v4Config.repos[repo.appName] = {
                         url: repo.remote,
                         path: `/home/dev/${projectName}/${repo.appPath}`,
                         auth: repo.type === 'ssh' ? 'ssh' : 'token',
@@ -378,7 +493,7 @@ exports.initCommand = new commander_1.Command('init')
             // Single repo or monorepo with root git
             if (nonInteractive) {
                 const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
-                v3Config.repos = {
+                v4Config.repos = {
                     [repoName]: {
                         url: scan.git.remote,
                         path: `/home/dev/${repoName}`,
@@ -389,10 +504,7 @@ exports.initCommand = new commander_1.Command('init')
             else {
                 const gitConfig = await setupGitAuth(scan.git, projectName);
                 if (gitConfig.repos) {
-                    v3Config.repos = gitConfig.repos;
-                }
-                if (gitConfig.git_auth) {
-                    v3Config.git_auth = gitConfig.git_auth;
+                    v4Config.repos = gitConfig.repos;
                 }
             }
         }
@@ -415,7 +527,7 @@ exports.initCommand = new commander_1.Command('init')
                     },
                 });
                 const repoName = path_1.default.basename(repoUrl, '.git');
-                v3Config.repos = {
+                v4Config.repos = {
                     [repoName]: {
                         url: repoUrl,
                         path: `/home/dev/${repoName}`,
@@ -424,15 +536,16 @@ exports.initCommand = new commander_1.Command('init')
                 };
             }
         }
-        // Environment configuration (skip in non-interactive mode)
+        // Environment configuration (skip only in non-interactive mode)
+        // For --from-scan, we still want to prompt for environments since they're required for genbox to work
         if (!nonInteractive) {
-            const envConfig = await setupEnvironments(scan, v3Config, isMultiRepo);
+            const envConfig = await setupEnvironments(scan, v4Config, isMultiRepo);
             if (envConfig) {
-                v3Config.environments = envConfig;
+                v4Config.environments = envConfig;
             }
         }
-        // Script selection - always show multi-select UI (skip in non-interactive mode)
-        if (!nonInteractive) {
+        // Script selection - always show multi-select UI (skip in non-interactive mode and --from-scan)
+        if (!nonInteractive && !options.fromScan) {
             // Scan for scripts
             const scriptsSpinner = (0, ora_1.default)('Scanning for scripts...').start();
             const fullScan = await scanner.scan(process.cwd(), { exclude, skipScripts: false });
@@ -463,7 +576,7 @@ exports.initCommand = new commander_1.Command('init')
                     choices: scriptChoices,
                 });
                 if (selectedScripts.length > 0) {
-                    v3Config.scripts = fullScan.scripts
+                    v4Config.scripts = fullScan.scripts
                         .filter(s => selectedScripts.includes(s.path))
                         .map(s => ({
                         name: s.name,
@@ -477,7 +590,7 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // Save configuration
-        const yamlContent = yaml.dump(v3Config, {
+        const yamlContent = yaml.dump(v4Config, {
             lineWidth: 120,
             noRefs: true,
             quotingType: '"',
@@ -487,11 +600,10 @@ exports.initCommand = new commander_1.Command('init')
         // Add API URLs from environments to envVarsToAdd
         // Always add LOCAL_API_URL for local development
         envVarsToAdd['LOCAL_API_URL'] = 'http://localhost:3050';
-        if (v3Config.environments) {
-            for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
-                const apiUrl = envConfig.api?.api ||
-                    envConfig.api?.url ||
-                    envConfig.api?.gateway;
+        if (v4Config.environments) {
+            for (const [envName, envConfig] of Object.entries(v4Config.environments)) {
+                // v4 format: urls.api contains the API URL
+                const apiUrl = envConfig.urls?.api || envConfig.urls?.gateway;
                 if (apiUrl) {
                     const varName = `${envName.toUpperCase()}_API_URL`;
                     envVarsToAdd[varName] = apiUrl;
@@ -499,7 +611,7 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // Generate .env.genbox
-        await setupEnvFile(projectName, v3Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting);
+        await setupEnvFile(projectName, v4Config, nonInteractive, scan, isMultiRepo, envVarsToAdd, overwriteExisting);
         // Show warnings
         if (generated.warnings.length > 0) {
             console.log('');
@@ -509,16 +621,15 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // Show API URL guidance if environments are configured
-        if (v3Config.environments && Object.keys(v3Config.environments).length > 0) {
+        if (v4Config.environments && Object.keys(v4Config.environments).length > 0) {
             console.log('');
             console.log(chalk_1.default.blue('=== API URL Configuration ==='));
             console.log(chalk_1.default.dim('The following API URLs were added to .env.genbox:'));
             console.log('');
             console.log(chalk_1.default.dim('  LOCAL_API_URL=http://localhost:3050'));
-            for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
-                const apiUrl = envConfig.api?.api ||
-                    envConfig.api?.url ||
-                    envConfig.api?.gateway;
+            for (const [envName, envConfig] of Object.entries(v4Config.environments)) {
+                // v4 format: urls.api contains the API URL
+                const apiUrl = envConfig.urls?.api || envConfig.urls?.gateway;
                 if (apiUrl) {
                     const varName = `${envName.toUpperCase()}_API_URL`;
                     console.log(chalk_1.default.dim(`  ${varName}=${apiUrl}`));
@@ -531,9 +642,9 @@ exports.initCommand = new commander_1.Command('init')
             console.log(chalk_1.default.cyan('    NEXT_PUBLIC_API_URL=${API_URL}'));
             console.log('');
             console.log(chalk_1.default.dim('  At create time, ${API_URL} expands based on profile:'));
-            console.log(chalk_1.default.dim('    • connect_to: staging → uses STAGING_API_URL'));
-            console.log(chalk_1.default.dim('    • connect_to: production → uses PRODUCTION_API_URL'));
-            console.log(chalk_1.default.dim('    • local/no connect_to → uses LOCAL_API_URL'));
+            console.log(chalk_1.default.dim('    • default_connection: staging → uses STAGING_API_URL'));
+            console.log(chalk_1.default.dim('    • default_connection: production → uses PRODUCTION_API_URL'));
+            console.log(chalk_1.default.dim('    • local/no default_connection → uses LOCAL_API_URL'));
         }
         // Next steps
         console.log('');
@@ -566,13 +677,13 @@ function createProfilesFromScan(scan) {
     const frontendApps = scan.apps.filter(a => a.type === 'frontend');
     const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
     const hasApi = scan.apps.some(a => a.name === 'api' || a.type === 'backend');
-    // Quick UI profiles for each frontend
+    // Quick UI profiles for each frontend (v4: use default_connection instead of connect_to)
     for (const frontend of frontendApps.slice(0, 3)) {
         profiles[`${frontend.name}-quick`] = {
             description: `${frontend.name} only, connected to staging`,
             size: 'small',
             apps: [frontend.name],
-            connect_to: 'staging',
+            default_connection: 'staging',
         };
     }
     // Full local development
@@ -599,13 +710,13 @@ function createProfilesFromScan(scan) {
             },
         };
     }
-    // All frontends + staging
+    // All frontends + staging (v4: use default_connection)
     if (frontendApps.length > 1) {
         profiles['frontends-staging'] = {
             description: 'All frontends with staging backend',
             size: 'medium',
             apps: frontendApps.map(a => a.name),
-            connect_to: 'staging',
+            default_connection: 'staging',
         };
     }
     // Full stack
@@ -639,14 +750,12 @@ async function setupGitAuth(gitInfo, projectName) {
         default: 'token',
     });
     let repoUrl = gitInfo.remote;
-    let git_auth;
     if (authMethod === 'token') {
         // Convert SSH to HTTPS if needed
         if (gitInfo.type === 'ssh') {
             repoUrl = (0, scan_1.sshToHttps)(gitInfo.remote);
             console.log(chalk_1.default.dim(`  Will use HTTPS: ${repoUrl}`));
         }
-        git_auth = { method: 'token' };
         // Show token setup instructions
         console.log('');
         console.log(chalk_1.default.yellow('  Add your token to .env.genbox:'));
@@ -677,7 +786,6 @@ async function setupGitAuth(gitInfo, projectName) {
                 });
             }
         }
-        git_auth = { method: 'ssh', ssh_key_path: sshKeyPath };
         console.log('');
         console.log(chalk_1.default.yellow('  Add your SSH key to .env.genbox:'));
         console.log(chalk_1.default.white(`    GIT_SSH_KEY="$(cat ${sshKeyPath})"`));
@@ -691,11 +799,10 @@ async function setupGitAuth(gitInfo, projectName) {
                 auth: authMethod === 'public' ? undefined : authMethod,
             },
         },
-        git_auth,
     };
 }
 /**
- * Setup staging/production environments
+ * Setup staging/production environments (v4 format)
  */
 async function setupEnvironments(scan, config, isMultiRepo = false) {
     const setupEnvs = await prompts.confirm({
@@ -716,22 +823,23 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
         const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
         if (backendApps.length > 0) {
             console.log(chalk_1.default.dim('Configure staging API URLs for each backend service:'));
-            const stagingApi = {};
+            const urls = {};
             for (const app of backendApps) {
                 const url = await prompts.input({
                     message: `  ${app.name} staging URL (leave empty to skip):`,
                     default: '',
                 });
                 if (url) {
-                    stagingApi[app.name] = url;
+                    urls[app.name] = url;
                 }
             }
-            if (Object.keys(stagingApi).length > 0) {
+            if (Object.keys(urls).length > 0) {
+                // Add database URLs
+                urls['mongodb'] = '${STAGING_MONGODB_URL}';
+                urls['redis'] = '${STAGING_REDIS_URL}';
                 environments.staging = {
                     description: 'Staging environment',
-                    api: stagingApi,
-                    mongodb: { url: '${STAGING_MONGODB_URL}' },
-                    redis: { url: '${STAGING_REDIS_URL}' },
+                    urls,
                 };
             }
         }
@@ -744,9 +852,11 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             if (stagingApiUrl) {
                 environments.staging = {
                     description: 'Staging environment',
-                    api: { gateway: stagingApiUrl },
-                    mongodb: { url: '${STAGING_MONGODB_URL}' },
-                    redis: { url: '${STAGING_REDIS_URL}' },
+                    urls: {
+                        api: stagingApiUrl,
+                        mongodb: '${STAGING_MONGODB_URL}',
+                        redis: '${STAGING_REDIS_URL}',
+                    },
                 };
             }
         }
@@ -760,9 +870,11 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
         if (stagingApiUrl) {
             environments.staging = {
                 description: 'Staging environment',
-                api: { gateway: stagingApiUrl },
-                mongodb: { url: '${STAGING_MONGODB_URL}' },
-                redis: { url: '${STAGING_REDIS_URL}' },
+                urls: {
+                    api: stagingApiUrl,
+                    mongodb: '${STAGING_MONGODB_URL}',
+                    redis: '${STAGING_REDIS_URL}',
+                },
             };
         }
     }
@@ -775,23 +887,24 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
             if (backendApps.length > 0) {
                 console.log(chalk_1.default.dim('Configure production API URLs for each backend service:'));
-                const prodApi = {};
+                const prodUrls = {};
                 for (const app of backendApps) {
                     const url = await prompts.input({
                         message: `  ${app.name} production URL:`,
                         default: '',
                     });
                     if (url) {
-                        prodApi[app.name] = url;
+                        prodUrls[app.name] = url;
                     }
                 }
-                if (Object.keys(prodApi).length > 0) {
+                if (Object.keys(prodUrls).length > 0) {
+                    prodUrls['mongodb'] = '${PROD_MONGODB_URL}';
                     environments.production = {
                         description: 'Production (use with caution)',
-                        api: prodApi,
-                        mongodb: {
-                            url: '${PROD_MONGODB_URL}',
+                        urls: prodUrls,
+                        safety: {
                             read_only: true,
+                            require_confirmation: true,
                         },
                     };
                 }
@@ -805,10 +918,13 @@ async function setupEnvironments(scan, config, isMultiRepo = false) {
             if (prodApiUrl) {
                 environments.production = {
                     description: 'Production (use with caution)',
-                    api: { gateway: prodApiUrl },
-                    mongodb: {
-                        url: '${PROD_MONGODB_URL}',
+                    urls: {
+                        api: prodApiUrl,
+                        mongodb: '${PROD_MONGODB_URL}',
+                    },
+                    safety: {
                         read_only: true,
+                        require_confirmation: true,
                     },
                 };
             }
@@ -1031,10 +1147,10 @@ function generateEnvTemplate(projectName, config) {
     return lines.join('\n');
 }
 /**
- * Convert GenboxConfigV2 to GenboxConfigV3 format
+ * Convert GenboxConfigV2 to GenboxConfigV4 format
  */
-function convertV2ToV3(v2Config, scan) {
-    // Convert services to apps
+function convertV2ToV4(v2Config, scan) {
+    // Convert services to apps (v4 format)
     const apps = {};
     for (const [name, service] of Object.entries(v2Config.services || {})) {
         const appConfig = {
@@ -1046,10 +1162,13 @@ function convertV2ToV3(v2Config, scan) {
         if (service.framework) {
             appConfig.framework = service.framework;
         }
-        // Only add requires if there are dependencies
+        // Convert requires to connects_to (v4 format)
         if (service.dependsOn?.length) {
-            appConfig.requires = service.dependsOn.reduce((acc, dep) => {
-                acc[dep] = 'required';
+            appConfig.connects_to = service.dependsOn.reduce((acc, dep) => {
+                acc[dep] = {
+                    mode: 'local',
+                    required: true,
+                };
                 return acc;
             }, {});
         }
@@ -1070,11 +1189,11 @@ function convertV2ToV3(v2Config, scan) {
         }
         apps[name] = appConfig;
     }
-    // Convert infrastructure
-    const infrastructure = {};
+    // Convert infrastructure to provides (v4 format)
+    const provides = {};
     if (v2Config.infrastructure?.databases) {
         for (const db of v2Config.infrastructure.databases) {
-            infrastructure[db.container || db.type] = {
+            provides[db.container || db.type] = {
                 type: 'database',
                 image: `${db.type}:latest`,
                 port: db.port,
@@ -1083,7 +1202,7 @@ function convertV2ToV3(v2Config, scan) {
     }
     if (v2Config.infrastructure?.caches) {
         for (const cache of v2Config.infrastructure.caches) {
-            infrastructure[cache.container || cache.type] = {
+            provides[cache.container || cache.type] = {
                 type: 'cache',
                 image: `${cache.type}:latest`,
                 port: cache.port,
@@ -1092,15 +1211,15 @@ function convertV2ToV3(v2Config, scan) {
     }
     if (v2Config.infrastructure?.queues) {
         for (const queue of v2Config.infrastructure.queues) {
-            infrastructure[queue.container || queue.type] = {
+            provides[queue.container || queue.type] = {
                 type: 'queue',
                 image: `${queue.type}:latest`,
                 port: queue.port,
-                management_port: queue.managementPort,
+                additional_ports: queue.managementPort ? { management: queue.managementPort } : undefined,
             };
         }
     }
-    // Convert repos
+    // Convert repos (v4 format)
     const repos = {};
     for (const [name, repo] of Object.entries(v2Config.repos || {})) {
         repos[name] = {
@@ -1110,18 +1229,25 @@ function convertV2ToV3(v2Config, scan) {
             auth: repo.auth,
         };
     }
-    // Build v3 config
-    const v3Config = {
-        version: '3.0',
+    // Map structure type to v4
+    const structureMap = {
+        'single-app': 'single-app',
+        'monorepo-pnpm': 'monorepo',
+        'monorepo-yarn': 'monorepo',
+        'monorepo-npm': 'monorepo',
+        'microservices': 'microservices',
+        'hybrid': 'hybrid',
+    };
+    // Build v4 config
+    const v4Config = {
+        version: 4,
         project: {
             name: v2Config.project.name,
-            structure: v2Config.project.structure === 'single-app' ? 'single-app' :
-                v2Config.project.structure.startsWith('monorepo') ? 'monorepo' :
-                    v2Config.project.structure,
+            structure: structureMap[v2Config.project.structure] || 'single-app',
             description: v2Config.project.description,
         },
         apps,
-        infrastructure: Object.keys(infrastructure).length > 0 ? infrastructure : undefined,
+        provides: Object.keys(provides).length > 0 ? provides : undefined,
         repos: Object.keys(repos).length > 0 ? repos : undefined,
         defaults: {
             size: v2Config.system.size,
@@ -1131,6 +1257,135 @@ function convertV2ToV3(v2Config, scan) {
             post_start: v2Config.hooks.postStart,
             pre_start: v2Config.hooks.preStart,
         } : undefined,
+        strict: {
+            enabled: true,
+            allow_detect: true,
+            warnings_as_errors: false,
+        },
+    };
+    return v4Config;
+}
+/**
+ * Convert DetectedConfig (from detected.yaml) to ProjectScan format
+ * This allows --from-scan to use the same code paths as fresh scanning
+ */
+function convertDetectedToScan(detected) {
+    // Convert structure type
+    const structureTypeMap = {
+        'single-app': 'single-app',
+        'monorepo': 'monorepo-pnpm',
+        'workspace': 'hybrid',
+        'microservices': 'microservices',
+        'hybrid': 'hybrid',
+    };
+    // Convert apps
+    const apps = [];
+    for (const [name, app] of Object.entries(detected.apps || {})) {
+        // Map detected type to scanner type
+        const typeMap = {
+            'frontend': 'frontend',
+            'backend': 'backend',
+            'worker': 'worker',
+            'gateway': 'gateway',
+            'library': 'library',
+        };
+        apps.push({
+            name,
+            path: app.path,
+            type: typeMap[app.type || 'library'] || 'library',
+            framework: app.framework,
+            port: app.port,
+            dependencies: app.dependencies,
+            scripts: app.commands ? {
+                dev: app.commands.dev || '',
+                build: app.commands.build || '',
+                start: app.commands.start || '',
+            } : {},
+        });
+    }
+    // Convert runtimes
+    const runtimes = detected.runtimes.map(r => ({
+        language: r.language,
+        version: r.version,
+        versionSource: r.version_source,
+        packageManager: r.package_manager,
+        lockfile: r.lockfile,
+    }));
+    // Convert infrastructure to compose analysis
+    let compose = null;
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        compose = {
+            files: ['docker-compose.yml'],
+            applications: [],
+            databases: detected.infrastructure
+                .filter(i => i.type === 'database')
+                .map(i => ({
+                name: i.name,
+                image: i.image,
+                ports: [{ host: i.port, container: i.port }],
+                environment: {},
+                dependsOn: [],
+                volumes: [],
+            })),
+            caches: detected.infrastructure
+                .filter(i => i.type === 'cache')
+                .map(i => ({
+                name: i.name,
+                image: i.image,
+                ports: [{ host: i.port, container: i.port }],
+                environment: {},
+                dependsOn: [],
+                volumes: [],
+            })),
+            queues: detected.infrastructure
+                .filter(i => i.type === 'queue')
+                .map(i => ({
+                name: i.name,
+                image: i.image,
+                ports: [{ host: i.port, container: i.port }],
+                environment: {},
+                dependsOn: [],
+                volumes: [],
+            })),
+            infrastructure: [],
+            portMap: new Map(),
+            dependencyGraph: new Map(),
+        };
+    }
+    // Convert git
+    const git = detected.git ? {
+        remote: detected.git.remote || '',
+        type: detected.git.type || 'https',
+        provider: (detected.git.provider || 'other'),
+        branch: detected.git.branch || 'main',
+    } : undefined;
+    // Convert scripts
+    const scripts = (detected.scripts || []).map(s => ({
+        name: s.name,
+        path: s.path,
+        stage: s.stage,
+        isExecutable: s.executable,
+    }));
+    return {
+        projectName: path_1.default.basename(detected._meta.scanned_root),
+        root: detected._meta.scanned_root,
+        structure: {
+            type: structureTypeMap[detected.structure.type] || 'single-app',
+            confidence: detected.structure.confidence,
+            indicators: detected.structure.indicators,
+        },
+        runtimes,
+        frameworks: [], // Not stored in detected.yaml
+        compose,
+        apps,
+        envAnalysis: {
+            required: [],
+            optional: [],
+            secrets: [],
+            references: [],
+            sources: [],
+        },
+        git,
+        scripts,
     };
-    return v3Config;
 }