genbox 1.0.11 → 1.0.13

package/dist/commands/config.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Config Command
+ *
+ * Provides configuration inspection and debugging tools:
+ * - genbox config show         - Show resolved configuration
+ * - genbox config show --explain - Show where each value comes from
+ * - genbox config diff <a> <b> - Compare two profiles
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const yaml = __importStar(require("js-yaml"));
+const config_loader_1 = require("../config-loader");
+const config_explainer_1 = require("../config-explainer");
+exports.configCommand = new commander_1.Command('config')
+    .description('Inspect and debug configuration')
+    .addCommand(createShowCommand())
+    .addCommand(createDiffCommand());
+function createShowCommand() {
+    return new commander_1.Command('show')
+        .description('Show resolved configuration')
+        .argument('[path]', 'Specific config path to show (e.g., apps.web, profiles.quick)')
+        .option('--explain', 'Show where each value comes from')
+        .option('--profile <profile>', 'Show configuration for a specific profile')
+        .option('--json', 'Output as JSON')
+        .option('--yaml', 'Output as YAML (default)')
+        .action(async (configPath, options) => {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load();
+        if (!loadResult.found || !loadResult.config) {
+            console.log(chalk_1.default.red('No genbox.yaml found in current directory or parent directories'));
+            process.exit(1);
+        }
+        const config = loadResult.config;
+        if (options.explain) {
+            await showWithExplain(config, loadResult, configPath, options.profile);
+        }
+        else {
+            await showConfig(config, configPath, options);
+        }
+    });
+}
+function createDiffCommand() {
+    return new commander_1.Command('diff')
+        .description('Compare two profiles')
+        .argument('<profile1>', 'First profile name')
+        .argument('<profile2>', 'Second profile name')
+        .action(async (profile1, profile2) => {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load();
+        if (!loadResult.found || !loadResult.config) {
+            console.log(chalk_1.default.red('No genbox.yaml found'));
+            process.exit(1);
+        }
+        const config = loadResult.config;
+        const p1 = configLoader.getProfile(config, profile1);
+        const p2 = configLoader.getProfile(config, profile2);
+        if (!p1) {
+            console.log(chalk_1.default.red(`Profile '${profile1}' not found`));
+            process.exit(1);
+        }
+        if (!p2) {
+            console.log(chalk_1.default.red(`Profile '${profile2}' not found`));
+            process.exit(1);
+        }
+        showProfileDiff(profile1, p1, profile2, p2, config);
+    });
+}
+async function showConfig(config, path, options) {
+    let data = config;
+    // If profile specified, show that profile's resolved config
+    if (options.profile) {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const profile = configLoader.getProfile(config, options.profile);
+        if (!profile) {
+            console.log(chalk_1.default.red(`Profile '${options.profile}' not found`));
+            process.exit(1);
+        }
+        data = profile;
+    }
+    // Navigate to specific path if provided
+    if (path) {
+        const parts = path.split('.');
+        let current = data;
+        for (const part of parts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                console.log(chalk_1.default.red(`Path '${path}' not found in configuration`));
+                process.exit(1);
+            }
+        }
+        data = current;
+    }
+    // Output
+    if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(yaml.dump(data, { lineWidth: 120, noRefs: true }));
+    }
+}
+async function showWithExplain(config, loadResult, path, profileName) {
+    const explainer = new config_explainer_1.ConfigExplainer(loadResult);
+    console.log(chalk_1.default.bold.cyan('\n📋 Configuration Analysis\n'));
+    // Show sources
+    console.log(chalk_1.default.bold('Config Sources (priority order):'));
+    for (const source of loadResult.sources) {
+        const icon = source.type === 'workspace' ? '🏢' : source.type === 'project' ? '📁' : '👤';
+        console.log(`  ${icon} ${source.type}: ${source.path}`);
+    }
+    console.log();
+    // If path specified, show just that path
+    if (path) {
+        const explanation = explainer.explain(path, profileName);
+        printExplanation(path, explanation);
+        return;
+    }
+    // Show key configuration values with explanations
+    console.log(chalk_1.default.bold('Key Values:\n'));
+    // Project info
+    printExplanation('project.name', explainer.explain('project.name'));
+    printExplanation('project.structure', explainer.explain('project.structure'));
+    // Apps
+    if (config.apps) {
+        console.log(chalk_1.default.bold('\nApps:'));
+        for (const appName of Object.keys(config.apps)) {
+            console.log(chalk_1.default.cyan(`\n  ${appName}:`));
+            printExplanation(`  apps.${appName}.type`, explainer.explain(`apps.${appName}.type`), 4);
+            printExplanation(`  apps.${appName}.port`, explainer.explain(`apps.${appName}.port`), 4);
+            printExplanation(`  apps.${appName}.framework`, explainer.explain(`apps.${appName}.framework`), 4);
+        }
+    }
+    // Profiles
+    if (config.profiles && profileName) {
+        console.log(chalk_1.default.bold(`\nProfile '${profileName}':`));
+        printExplanation('  size', explainer.explain('size', profileName), 4);
+        printExplanation('  apps', explainer.explain('apps', profileName), 4);
+        printExplanation('  connect_to', explainer.explain('connect_to', profileName), 4);
+        printExplanation('  database.mode', explainer.explain('database.mode', profileName), 4);
+    }
+    // Defaults
+    if (config.defaults) {
+        console.log(chalk_1.default.bold('\nDefaults:'));
+        printExplanation('  defaults.size', explainer.explain('defaults.size'), 4);
+        printExplanation('  defaults.branch', explainer.explain('defaults.branch'), 4);
+    }
+    // Detection warnings
+    const warnings = explainer.getDetectionWarnings();
+    if (warnings.length > 0) {
+        console.log(chalk_1.default.bold.yellow('\n⚠️  Detection Warnings:\n'));
+        for (const warning of warnings) {
+            console.log(chalk_1.default.yellow(`  • ${warning}`));
+        }
+    }
+    console.log();
+}
+function printExplanation(path, sources, indent = 0) {
+    const pad = ' '.repeat(indent);
+    if (sources.length === 0) {
+        console.log(`${pad}${chalk_1.default.dim(path)}: ${chalk_1.default.dim('(not set)')}`);
+        return;
+    }
+    const finalSource = sources.find(s => s.used) || sources[0];
+    const valueStr = formatValue(finalSource.value);
+    console.log(`${pad}${chalk_1.default.white(path)}: ${chalk_1.default.green(valueStr)}`);
+    for (const source of sources) {
+        const icon = source.used ? chalk_1.default.green('✓') : chalk_1.default.dim('○');
+        const sourceLabel = getSourceLabel(source);
+        const value = source.value !== undefined ? formatValue(source.value) : chalk_1.default.dim('(not set)');
+        if (source.used) {
+            console.log(`${pad}  ${icon} ${sourceLabel}: ${value}`);
+            if (source.detectedFrom) {
+                console.log(`${pad}      └─ ${chalk_1.default.dim(`detected from: ${source.detectedFrom}`)}`);
+            }
+        }
+        else {
+            console.log(`${pad}  ${icon} ${chalk_1.default.dim(sourceLabel)}: ${chalk_1.default.dim(String(value))}`);
+        }
+    }
+}
+function getSourceLabel(source) {
+    switch (source.source) {
+        case 'cli':
+            return 'CLI flag';
+        case 'profile':
+            return `Profile '${source.profileName || 'unknown'}'`;
+        case 'project':
+            return 'genbox.yaml (explicit)';
+        case 'workspace':
+            return 'workspace genbox.yaml';
+        case 'detected':
+            return 'detected.yaml';
+        case 'default':
+            return 'schema default';
+        case 'inferred':
+            return 'inferred';
+        default:
+            return source.source;
+    }
+}
+function formatValue(value) {
+    if (value === undefined)
+        return '(undefined)';
+    if (value === null)
+        return '(null)';
+    if (Array.isArray(value))
+        return `[${value.join(', ')}]`;
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
+function showProfileDiff(name1, profile1, name2, profile2, config) {
+    console.log(chalk_1.default.bold.cyan(`\n📊 Comparing profiles: ${name1} vs ${name2}\n`));
+    const allKeys = new Set([
+        ...Object.keys(profile1),
+        ...Object.keys(profile2),
+    ]);
+    let hasDiff = false;
+    for (const key of allKeys) {
+        const v1 = profile1[key];
+        const v2 = profile2[key];
+        if (JSON.stringify(v1) !== JSON.stringify(v2)) {
+            hasDiff = true;
+            console.log(chalk_1.default.bold(`  ${key}:`));
+            console.log(chalk_1.default.red(`    - ${name1}: ${formatValue(v1)}`));
+            console.log(chalk_1.default.green(`    + ${name2}: ${formatValue(v2)}`));
+            console.log();
+        }
+    }
+    if (!hasDiff) {
+        console.log(chalk_1.default.dim('  No differences found'));
+    }
+}

package/dist/commands/create.js

@@ -348,6 +348,64 @@ function displayResolvedConfig(resolved) {
     console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
     console.log('');
 }
+/**
+ * Parse .env.genbox file into segregated sections
+ */
+function parseEnvGenboxSections(content) {
+    const sections = new Map();
+    let currentSection = 'GLOBAL';
+    let currentContent = [];
+    for (const line of content.split('\n')) {
+        const sectionMatch = line.match(/^# === ([^=]+) ===$/);
+        if (sectionMatch) {
+            // Save previous section
+            if (currentContent.length > 0) {
+                sections.set(currentSection, currentContent.join('\n').trim());
+            }
+            currentSection = sectionMatch[1].trim();
+            currentContent = [];
+        }
+        else if (currentSection !== 'END') {
+            currentContent.push(line);
+        }
+    }
+    // Save last section
+    if (currentContent.length > 0 && currentSection !== 'END') {
+        sections.set(currentSection, currentContent.join('\n').trim());
+    }
+    return sections;
+}
+/**
+ * Build env content for a specific app by combining GLOBAL + app-specific sections
+ */
+function buildAppEnvContent(sections, appName, apiUrl) {
+    const parts = [];
+    // Always include GLOBAL section
+    const globalSection = sections.get('GLOBAL');
+    if (globalSection) {
+        parts.push(globalSection);
+    }
+    // Include app-specific section if exists
+    const appSection = sections.get(appName);
+    if (appSection) {
+        parts.push(appSection);
+    }
+    let envContent = parts.join('\n\n');
+    // Expand ${API_URL} references
+    envContent = envContent.replace(/\$\{API_URL\}/g, apiUrl);
+    // Keep only actual env vars (filter out pure comment lines but keep var definitions)
+    envContent = envContent
+        .split('\n')
+        .filter(line => {
+        const trimmed = line.trim();
+        // Keep empty lines, lines with = (even if commented), and non-comment lines
+        return trimmed === '' || trimmed.includes('=') || !trimmed.startsWith('#');
+    })
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return envContent;
+}
 /**
  * Build API payload from resolved config
  */
@@ -368,24 +426,82 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
     }
     // Build files bundle
     const files = [];
+    // Track env files to move in setup script (staging approach to avoid blocking git clone)
+    const envFilesToMove = [];
     // Send .env.genbox content to server for each app
     const envGenboxPath = path.join(process.cwd(), '.env.genbox');
     if (fs.existsSync(envGenboxPath)) {
-        const envContent = fs.readFileSync(envGenboxPath, 'utf-8');
-        // Add env file for each app (user should have already updated URLs manually)
+        const rawEnvContent = fs.readFileSync(envGenboxPath, 'utf-8');
+        // Parse into sections
+        const sections = parseEnvGenboxSections(rawEnvContent);
+        // Parse GLOBAL section to get API URL values
+        const globalSection = sections.get('GLOBAL') || '';
+        const envVarsFromFile = {};
+        for (const line of globalSection.split('\n')) {
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+            if (match) {
+                let value = match[2].trim();
+                // Remove quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                envVarsFromFile[match[1]] = value;
+            }
+        }
+        // Determine API_URL based on profile's connect_to setting
+        const connectTo = resolved.profile ?
+            (config.profiles?.[resolved.profile]?.connect_to) : undefined;
+        let apiUrl;
+        if (connectTo) {
+            // Use the environment-specific API URL (e.g., STAGING_API_URL)
+            const envApiVarName = `${connectTo.toUpperCase()}_API_URL`;
+            apiUrl = envVarsFromFile[envApiVarName] || resolved.env['API_URL'] || 'http://localhost:3050';
+        }
+        else {
+            // Use local API URL
+            apiUrl = envVarsFromFile['LOCAL_API_URL'] || 'http://localhost:3050';
+        }
+        // Add env file for each app - filtered by selected apps only
         for (const app of resolved.apps) {
             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}`);
-            files.push({
-                path: `${repoPath}/.env`,
-                content: envContent,
-                permissions: '0644',
-            });
+            // Check if this app has microservices (sections like api/gateway, api/auth)
+            const servicesSections = Array.from(sections.keys()).filter(s => s.startsWith(`${app.name}/`));
+            if (servicesSections.length > 0) {
+                // App has microservices - create env file for each service
+                for (const serviceSectionName of servicesSections) {
+                    const serviceName = serviceSectionName.split('/')[1];
+                    // Build service-specific env content (GLOBAL + service section)
+                    const serviceEnvContent = buildAppEnvContent(sections, serviceSectionName, apiUrl);
+                    const stagingName = `${app.name}-${serviceName}.env`;
+                    const targetPath = `${repoPath}/apps/${serviceName}/.env`;
+                    files.push({
+                        path: `/home/dev/.env-staging/${stagingName}`,
+                        content: serviceEnvContent,
+                        permissions: '0644',
+                    });
+                    envFilesToMove.push({ stagingName, targetPath });
+                }
+            }
+            else {
+                // Regular app - build app-specific env content (GLOBAL + app section)
+                const appEnvContent = buildAppEnvContent(sections, app.name, apiUrl);
+                files.push({
+                    path: `/home/dev/.env-staging/${app.name}.env`,
+                    content: appEnvContent,
+                    permissions: '0644',
+                });
+                envFilesToMove.push({
+                    stagingName: `${app.name}.env`,
+                    targetPath: `${repoPath}/.env`,
+                });
+            }
         }
     }
     // Add setup script if generated
-    const setupScript = generateSetupScript(resolved, config);
+    const setupScript = generateSetupScript(resolved, config, envFilesToMove);
     if (setupScript) {
         files.push({
             path: '/home/dev/setup-genbox.sh',
@@ -431,13 +547,27 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
 /**
  * Generate setup script
  */
-function generateSetupScript(resolved, config) {
+function generateSetupScript(resolved, config, envFilesToMove = []) {
     const lines = [
         '#!/bin/bash',
         '# Generated by genbox create',
         'set -e',
         '',
     ];
+    // Move .env files from staging to their correct locations
+    // This runs after git clone has completed
+    if (envFilesToMove.length > 0) {
+        lines.push('# Move .env files from staging to app directories');
+        for (const { stagingName, targetPath } of envFilesToMove) {
+            lines.push(`if [ -f "/home/dev/.env-staging/${stagingName}" ]; then`);
+            lines.push(`  mkdir -p "$(dirname "${targetPath}")"`);
+            lines.push(`  mv "/home/dev/.env-staging/${stagingName}" "${targetPath}"`);
+            lines.push(`  echo "Moved .env to ${targetPath}"`);
+            lines.push('fi');
+        }
+        lines.push('rm -rf /home/dev/.env-staging 2>/dev/null || true');
+        lines.push('');
+    }
     // Change to project directory
     if (resolved.repos.length > 0) {
         lines.push(`cd ${resolved.repos[0].path} || exit 1`);