genbox 1.0.3 → 1.0.5

package/dist/config-loader.js

@@ -0,0 +1,529 @@
+"use strict";
+/**
+ * Multi-Level Configuration Loader
+ *
+ * Resolution order (highest priority first):
+ * 1. CLI flags
+ * 2. User profiles (~/.genbox/profiles.yaml)
+ * 3. Project config (./genbox.yaml)
+ * 4. Workspace config (../genbox.yaml)
+ * 5. User defaults (~/.genbox/config.json)
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configLoader = exports.ConfigLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const os = __importStar(require("os"));
+const CONFIG_FILENAME = 'genbox.yaml';
+const ENV_FILENAME = '.env.genbox';
+const USER_CONFIG_DIR = path.join(os.homedir(), '.genbox');
+const USER_CONFIG_FILE = path.join(USER_CONFIG_DIR, 'config.json');
+const USER_PROFILES_FILE = path.join(USER_CONFIG_DIR, 'profiles.yaml');
+class ConfigLoader {
+    /**
+     * Load configuration from all levels
+     */
+    async load(cwd = process.cwd()) {
+        const sources = [];
+        const warnings = [];
+        // 1. Find and load workspace config (parent directories)
+        const workspaceConfig = this.findWorkspaceConfig(cwd);
+        if (workspaceConfig) {
+            sources.push(workspaceConfig);
+        }
+        // 2. Load project config (current directory or git root)
+        const projectConfig = this.loadProjectConfig(cwd);
+        if (projectConfig) {
+            sources.push(projectConfig);
+        }
+        // 3. Load user config
+        const userConfig = this.loadUserConfig();
+        // Determine if this is a workspace setup
+        const isWorkspace = workspaceConfig !== null &&
+            (projectConfig === null || workspaceConfig.path !== projectConfig.path);
+        // Merge configurations
+        const mergedConfig = this.mergeConfigs(sources, userConfig);
+        // Validate
+        const validation = this.validate(mergedConfig);
+        if (!validation.valid) {
+            warnings.push(...validation.errors.map(e => e.message));
+        }
+        warnings.push(...validation.warnings.map(w => w.message));
+        // Determine root directory
+        const root = workspaceConfig?.path
+            ? path.dirname(workspaceConfig.path)
+            : projectConfig?.path
+                ? path.dirname(projectConfig.path)
+                : cwd;
+        return {
+            found: sources.length > 0,
+            config: sources.length > 0 ? mergedConfig : null,
+            sources,
+            warnings,
+            isWorkspace,
+            root,
+        };
+    }
+    /**
+     * Find workspace config by searching parent directories
+     */
+    findWorkspaceConfig(startDir) {
+        let currentDir = path.resolve(startDir);
+        const root = path.parse(currentDir).root;
+        // Go up to 5 levels max
+        for (let i = 0; i < 5; i++) {
+            const parentDir = path.dirname(currentDir);
+            // Stop at filesystem root
+            if (parentDir === currentDir || parentDir === root) {
+                break;
+            }
+            const configPath = path.join(parentDir, CONFIG_FILENAME);
+            if (fs.existsSync(configPath)) {
+                try {
+                    const content = fs.readFileSync(configPath, 'utf8');
+                    const config = yaml.load(content);
+                    // Check if it's a workspace config (has structure: 'workspace' or multiple repos)
+                    if (config.project?.structure === 'workspace' || config.repos) {
+                        return {
+                            type: 'workspace',
+                            path: configPath,
+                            config,
+                        };
+                    }
+                }
+                catch (err) {
+                    console.warn(`Warning: Could not parse ${configPath}:`, err);
+                }
+            }
+            currentDir = parentDir;
+        }
+        return null;
+    }
+    /**
+     * Load project config from current directory
+     */
+    loadProjectConfig(cwd) {
+        const configPath = path.join(cwd, CONFIG_FILENAME);
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const config = yaml.load(content);
+            return {
+                type: 'project',
+                path: configPath,
+                config,
+            };
+        }
+        catch (err) {
+            console.warn(`Warning: Could not parse ${configPath}:`, err);
+            return null;
+        }
+    }
+    /**
+     * Load user configuration
+     */
+    loadUserConfig() {
+        if (!fs.existsSync(USER_CONFIG_FILE)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(USER_CONFIG_FILE, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            console.warn('Warning: Could not parse user config:', err);
+            return null;
+        }
+    }
+    /**
+     * Load user profiles
+     */
+    loadUserProfiles() {
+        if (!fs.existsSync(USER_PROFILES_FILE)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(USER_PROFILES_FILE, 'utf8');
+            return yaml.load(content);
+        }
+        catch (err) {
+            console.warn('Warning: Could not parse user profiles:', err);
+            return null;
+        }
+    }
+    /**
+     * Merge configurations from all sources
+     */
+    mergeConfigs(sources, userConfig) {
+        // Start with default structure
+        const merged = {
+            version: '3.0',
+            project: {
+                name: 'unnamed',
+                structure: 'single-app',
+            },
+            apps: {},
+        };
+        // Merge sources in order (workspace first, then project)
+        for (const source of sources) {
+            this.deepMerge(merged, source.config);
+        }
+        // Apply user defaults
+        if (userConfig?.defaults) {
+            if (!merged.defaults) {
+                merged.defaults = {};
+            }
+            if (userConfig.defaults.size && !merged.defaults.size) {
+                merged.defaults.size = userConfig.defaults.size;
+            }
+            if (userConfig.defaults.db_source && !merged.defaults.database?.source) {
+                if (!merged.defaults.database) {
+                    merged.defaults.database = { mode: 'copy' };
+                }
+                merged.defaults.database.source = userConfig.defaults.db_source;
+            }
+        }
+        return merged;
+    }
+    /**
+     * Deep merge objects
+     */
+    deepMerge(target, source) {
+        for (const key of Object.keys(source)) {
+            const sourceValue = source[key];
+            const targetValue = target[key];
+            if (sourceValue === undefined)
+                continue;
+            if (typeof sourceValue === 'object' &&
+                sourceValue !== null &&
+                !Array.isArray(sourceValue) &&
+                typeof targetValue === 'object' &&
+                targetValue !== null &&
+                !Array.isArray(targetValue)) {
+                this.deepMerge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = sourceValue;
+            }
+        }
+    }
+    /**
+     * Validate configuration
+     */
+    validate(config) {
+        const errors = [];
+        const warnings = [];
+        // Required fields
+        if (!config.project?.name) {
+            errors.push({
+                path: 'project.name',
+                message: 'Project name is required',
+                severity: 'error',
+            });
+        }
+        if (!config.apps || Object.keys(config.apps).length === 0) {
+            warnings.push({
+                path: 'apps',
+                message: 'No apps defined in configuration',
+                severity: 'warning',
+            });
+        }
+        // Validate apps
+        for (const [name, app] of Object.entries(config.apps || {})) {
+            if (!app.path) {
+                errors.push({
+                    path: `apps.${name}.path`,
+                    message: `App '${name}' is missing required 'path' field`,
+                    severity: 'error',
+                });
+            }
+            if (!app.type) {
+                warnings.push({
+                    path: `apps.${name}.type`,
+                    message: `App '${name}' is missing 'type' field, defaulting to 'backend'`,
+                    severity: 'warning',
+                });
+            }
+            // Validate dependencies reference existing apps/infrastructure
+            if (app.requires) {
+                for (const dep of Object.keys(app.requires)) {
+                    const isApp = config.apps?.[dep];
+                    const isInfra = config.infrastructure?.[dep];
+                    if (!isApp && !isInfra) {
+                        warnings.push({
+                            path: `apps.${name}.requires.${dep}`,
+                            message: `App '${name}' requires '${dep}' which is not defined`,
+                            severity: 'warning',
+                        });
+                    }
+                }
+            }
+        }
+        // Validate profiles
+        for (const [name, profile] of Object.entries(config.profiles || {})) {
+            // Check apps exist
+            for (const appName of profile.apps || []) {
+                if (!config.apps?.[appName]) {
+                    errors.push({
+                        path: `profiles.${name}.apps`,
+                        message: `Profile '${name}' references undefined app '${appName}'`,
+                        severity: 'error',
+                    });
+                }
+            }
+            // Check extends
+            if (profile.extends && !config.profiles?.[profile.extends]) {
+                errors.push({
+                    path: `profiles.${name}.extends`,
+                    message: `Profile '${name}' extends undefined profile '${profile.extends}'`,
+                    severity: 'error',
+                });
+            }
+            // Check connect_to
+            if (profile.connect_to && !config.environments?.[profile.connect_to]) {
+                warnings.push({
+                    path: `profiles.${name}.connect_to`,
+                    message: `Profile '${name}' connects to undefined environment '${profile.connect_to}'`,
+                    severity: 'warning',
+                });
+            }
+        }
+        // Validate environments
+        for (const [name, env] of Object.entries(config.environments || {})) {
+            // Check for unresolved variable references
+            const checkValue = (value, path) => {
+                if (typeof value === 'string' && value.includes('${')) {
+                    const match = value.match(/\$\{([^}]+)\}/);
+                    if (match) {
+                        warnings.push({
+                            path,
+                            message: `Environment '${name}' has variable reference '${match[1]}' - ensure it's defined in .env.genbox`,
+                            severity: 'warning',
+                        });
+                    }
+                }
+            };
+            if (env.mongodb?.url)
+                checkValue(env.mongodb.url, `environments.${name}.mongodb.url`);
+            if (env.redis?.url)
+                checkValue(env.redis.url, `environments.${name}.redis.url`);
+            if (env.rabbitmq?.url)
+                checkValue(env.rabbitmq.url, `environments.${name}.rabbitmq.url`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Get a specific profile, resolving extends
+     */
+    getProfile(config, profileName) {
+        const profile = config.profiles?.[profileName];
+        if (!profile) {
+            // Check user profiles
+            const userProfiles = this.loadUserProfiles();
+            if (userProfiles?.profiles?.[profileName]) {
+                return this.resolveProfile(config, userProfiles.profiles[profileName], userProfiles);
+            }
+            return null;
+        }
+        return this.resolveProfile(config, profile);
+    }
+    /**
+     * Resolve profile inheritance (extends)
+     */
+    resolveProfile(config, profile, userProfiles) {
+        if (!profile.extends) {
+            return profile;
+        }
+        // Find parent profile
+        let parent = config.profiles?.[profile.extends];
+        if (!parent && userProfiles) {
+            parent = userProfiles.profiles?.[profile.extends];
+        }
+        if (!parent) {
+            console.warn(`Warning: Profile extends '${profile.extends}' which doesn't exist`);
+            return profile;
+        }
+        // Resolve parent first (recursive)
+        const resolvedParent = this.resolveProfile(config, parent, userProfiles);
+        // Merge parent into child
+        return {
+            ...resolvedParent,
+            ...profile,
+            // Arrays are replaced, not merged
+            apps: profile.apps || resolvedParent.apps,
+            // Objects are merged
+            infrastructure: {
+                ...resolvedParent.infrastructure,
+                ...profile.infrastructure,
+            },
+            env: {
+                ...resolvedParent.env,
+                ...profile.env,
+            },
+        };
+    }
+    /**
+     * List all available profiles
+     */
+    listProfiles(config) {
+        const profiles = [];
+        // Project profiles
+        for (const [name, profile] of Object.entries(config.profiles || {})) {
+            const resolved = this.getProfile(config, name);
+            profiles.push({
+                name,
+                description: profile.description,
+                source: 'project',
+                apps: resolved?.apps || [],
+                size: resolved?.size,
+            });
+        }
+        // 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,
+                });
+            }
+        }
+        return profiles;
+    }
+    /**
+     * Save user profile
+     */
+    saveUserProfile(name, profile) {
+        // Ensure directory exists
+        if (!fs.existsSync(USER_CONFIG_DIR)) {
+            fs.mkdirSync(USER_CONFIG_DIR, { recursive: true });
+        }
+        // Load existing profiles
+        let profiles = { profiles: {} };
+        if (fs.existsSync(USER_PROFILES_FILE)) {
+            try {
+                const content = fs.readFileSync(USER_PROFILES_FILE, 'utf8');
+                profiles = yaml.load(content);
+            }
+            catch { }
+        }
+        // Add/update profile
+        profiles.profiles[name] = profile;
+        // Save
+        const content = yaml.dump(profiles, { lineWidth: 120 });
+        fs.writeFileSync(USER_PROFILES_FILE, content);
+    }
+    /**
+     * Load environment variables from .env.genbox files
+     */
+    loadEnvVars(root) {
+        const vars = {};
+        // Load from multiple locations
+        const envPaths = [
+            path.join(root, ENV_FILENAME),
+            path.join(path.dirname(root), ENV_FILENAME), // Workspace level
+        ];
+        for (const envPath of envPaths) {
+            if (fs.existsSync(envPath)) {
+                const content = fs.readFileSync(envPath, 'utf8');
+                const parsed = this.parseEnvFile(content);
+                Object.assign(vars, parsed);
+            }
+        }
+        return vars;
+    }
+    /**
+     * Parse .env file content
+     */
+    parseEnvFile(content) {
+        const vars = {};
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+            if (match) {
+                let [, key, value] = match;
+                // Remove quotes
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                vars[key] = value;
+            }
+        }
+        return vars;
+    }
+    /**
+     * Resolve variable references in a string
+     */
+    resolveVariables(value, vars) {
+        return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+            return vars[varName] || match;
+        });
+    }
+    /**
+     * Check if a config file exists
+     */
+    hasConfig(cwd = process.cwd()) {
+        return fs.existsSync(path.join(cwd, CONFIG_FILENAME));
+    }
+    /**
+     * Get the config file path
+     */
+    getConfigPath(cwd = process.cwd()) {
+        return path.join(cwd, CONFIG_FILENAME);
+    }
+}
+exports.ConfigLoader = ConfigLoader;
+// Export singleton instance
+exports.configLoader = new ConfigLoader();

package/dist/index.js

@@ -22,6 +22,8 @@ const status_1 = require("./commands/status");
 const forward_1 = require("./commands/forward");
 const restore_db_1 = require("./commands/restore-db");
 const help_1 = require("./commands/help");
+const profiles_1 = require("./commands/profiles");
+const db_sync_1 = require("./commands/db-sync");
 program
     .addCommand(init_1.initCommand)
     .addCommand(create_1.createCommand)
@@ -35,5 +37,7 @@ program
     .addCommand(status_1.statusCommand)
     .addCommand(forward_1.forwardCommand)
     .addCommand(restore_db_1.restoreDbCommand)
-    .addCommand(help_1.helpCommand);
+    .addCommand(help_1.helpCommand)
+    .addCommand(profiles_1.profilesCommand)
+    .addCommand(db_sync_1.dbSyncCommand);
 program.parse(process.argv);