genbox 1.0.14 → 1.0.16

package/dist/config-loader.js

@@ -44,10 +44,42 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configLoader = exports.ConfigLoader = void 0;
+exports.isV4 = isV4;
+exports.getProfileConnection = getProfileConnection;
+exports.getAppDependencies = getAppDependencies;
+exports.getInfrastructure = getInfrastructure;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
 const os = __importStar(require("os"));
+const schema_v4_1 = require("./schema-v4");
+// Helper to check if config is v4
+function isV4(config) {
+    return (0, schema_v4_1.getConfigVersion)(config) === 4;
+}
+// Helper to get profile connection (handles both v3 and v4)
+function getProfileConnection(profile) {
+    // v4 uses default_connection, v3 uses connect_to
+    return profile.default_connection || profile.connect_to;
+}
+// Helper to get app dependencies (handles both v3 and v4)
+function getAppDependencies(app) {
+    // v4 uses connects_to, v3 uses requires
+    if (app.connects_to) {
+        return Object.keys(app.connects_to);
+    }
+    if (app.requires) {
+        return Object.keys(app.requires);
+    }
+    return [];
+}
+// Helper to get infrastructure/provides (handles both v3 and v4)
+function getInfrastructure(config) {
+    if (isV4(config)) {
+        return config.provides;
+    }
+    return config.infrastructure;
+}
 const CONFIG_FILENAME = 'genbox.yaml';
 const ENV_FILENAME = '.env.genbox';
 const USER_CONFIG_DIR = path.join(os.homedir(), '.genbox');
@@ -189,17 +221,41 @@ class ConfigLoader {
     }
     /**
      * Merge configurations from all sources
+     * Supports both v3 and v4 config formats
      */
     mergeConfigs(sources, userConfig) {
-        // Start with default structure
-        const merged = {
-            version: '3.0',
-            project: {
-                name: 'unnamed',
-                structure: 'single-app',
-            },
-            apps: {},
-        };
+        // Detect version from first source that has it
+        let isVersion4 = false;
+        for (const source of sources) {
+            // Version can be number (v4) or string (v3)
+            if (source.config.version === 4) {
+                isVersion4 = true;
+                break;
+            }
+        }
+        // Start with appropriate default structure
+        const merged = isVersion4
+            ? {
+                version: 4,
+                project: {
+                    name: 'unnamed',
+                    structure: 'single-app',
+                },
+                apps: {},
+                strict: {
+                    enabled: true,
+                    allow_detect: true,
+                    warnings_as_errors: false,
+                },
+            }
+            : {
+                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);
@@ -244,11 +300,12 @@ class ConfigLoader {
         }
     }
     /**
-     * Validate configuration
+     * Validate configuration (supports both v3 and v4)
      */
     validate(config) {
         const errors = [];
         const warnings = [];
+        const configIsV4 = isV4(config);
         // Required fields
         if (!config.project?.name) {
             errors.push({
@@ -264,6 +321,8 @@ class ConfigLoader {
                 severity: 'warning',
             });
         }
+        // Get infrastructure (v4: provides, v3: infrastructure)
+        const infra = getInfrastructure(config);
         // Validate apps
         for (const [name, app] of Object.entries(config.apps || {})) {
             if (!app.path) {
@@ -280,18 +339,18 @@ class ConfigLoader {
                     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 dependencies (v4: connects_to, v3: requires)
+            const deps = getAppDependencies(app);
+            const depField = configIsV4 ? 'connects_to' : 'requires';
+            for (const dep of deps) {
+                const isAppDep = config.apps?.[dep];
+                const isInfraDep = infra?.[dep];
+                if (!isAppDep && !isInfraDep) {
+                    warnings.push({
+                        path: `apps.${name}.${depField}.${dep}`,
+                        message: `App '${name}' ${configIsV4 ? 'connects to' : 'requires'} '${dep}' which is not defined`,
+                        severity: 'warning',
+                    });
                 }
             }
         }
@@ -315,11 +374,13 @@ class ConfigLoader {
                     severity: 'error',
                 });
             }
-            // Check connect_to
-            if (profile.connect_to && !config.environments?.[profile.connect_to]) {
+            // Check connection (v4: default_connection, v3: connect_to)
+            const connection = getProfileConnection(profile);
+            if (connection && !config.environments?.[connection]) {
+                const connField = configIsV4 ? 'default_connection' : 'connect_to';
                 warnings.push({
-                    path: `profiles.${name}.connect_to`,
-                    message: `Profile '${name}' connects to undefined environment '${profile.connect_to}'`,
+                    path: `profiles.${name}.${connField}`,
+                    message: `Profile '${name}' connects to undefined environment '${connection}'`,
                     severity: 'warning',
                 });
             }
@@ -339,12 +400,24 @@ class ConfigLoader {
                     }
                 }
             };
-            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`);
+            // v4 uses urls object, v3 uses separate mongodb/redis/rabbitmq objects
+            if (configIsV4) {
+                const v4Env = env;
+                if (v4Env.urls) {
+                    for (const [key, url] of Object.entries(v4Env.urls)) {
+                        checkValue(url, `environments.${name}.urls.${key}`);
+                    }
+                }
+            }
+            else {
+                const v3Env = env;
+                if (v3Env.mongodb?.url)
+                    checkValue(v3Env.mongodb.url, `environments.${name}.mongodb.url`);
+                if (v3Env.redis?.url)
+                    checkValue(v3Env.redis.url, `environments.${name}.redis.url`);
+                if (v3Env.rabbitmq?.url)
+                    checkValue(v3Env.rabbitmq.url, `environments.${name}.rabbitmq.url`);
+            }
         }
         return {
             valid: errors.length === 0,
@@ -353,7 +426,7 @@ class ConfigLoader {
         };
     }
     /**
-     * Get a specific profile, resolving extends
+     * Get a specific profile, resolving extends (supports both v3 and v4)
      */
     getProfile(config, profileName) {
         const profile = config.profiles?.[profileName];
@@ -368,7 +441,7 @@ class ConfigLoader {
         return this.resolveProfile(config, profile);
     }
     /**
-     * Resolve profile inheritance (extends)
+     * Resolve profile inheritance (extends) - supports both v3 and v4
      */
     resolveProfile(config, profile, userProfiles) {
         if (!profile.extends) {
@@ -385,25 +458,40 @@ class ConfigLoader {
         }
         // Resolve parent first (recursive)
         const resolvedParent = this.resolveProfile(config, parent, userProfiles);
-        // Merge parent into child
-        return {
+        // Merge parent into child - handle both v3 and v4
+        const merged = {
             ...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,
             },
         };
+        // Handle v4 connections override
+        if (isV4(config)) {
+            const v4Profile = profile;
+            const v4Parent = resolvedParent;
+            merged.connections = {
+                ...v4Parent.connections,
+                ...v4Profile.connections,
+            };
+        }
+        else {
+            // v3 infrastructure merge
+            const v3Profile = profile;
+            const v3Parent = resolvedParent;
+            merged.infrastructure = {
+                ...v3Parent.infrastructure,
+                ...v3Profile.infrastructure,
+            };
+        }
+        return merged;
     }
     /**
-     * List all available profiles
+     * List all available profiles (supports both v3 and v4)
      */
     listProfiles(config) {
         const profiles = [];
@@ -416,6 +504,7 @@ class ConfigLoader {
                 source: 'project',
                 apps: resolved?.apps || [],
                 size: resolved?.size,
+                connection: resolved ? getProfileConnection(resolved) : undefined,
             });
         }
         // User profiles
@@ -432,6 +521,7 @@ class ConfigLoader {
                     source: 'user',
                     apps: resolved?.apps || [],
                     size: resolved?.size,
+                    connection: resolved ? getProfileConnection(resolved) : undefined,
                 });
             }
         }

package/dist/index.js

@@ -29,6 +29,7 @@ const scan_1 = require("./commands/scan");
 const resolve_1 = require("./commands/resolve");
 const validate_1 = require("./commands/validate");
 const migrate_1 = require("./commands/migrate");
+const ssh_setup_1 = require("./commands/ssh-setup");
 program
     .addCommand(init_1.initCommand)
     .addCommand(create_1.createCommand)
@@ -50,5 +51,6 @@ program
     .addCommand(resolve_1.resolveCommand)
     .addCommand(validate_1.validateCommand)
     .addCommand(migrate_1.migrateCommand)
-    .addCommand(migrate_1.deprecationsCommand);
+    .addCommand(migrate_1.deprecationsCommand)
+    .addCommand(ssh_setup_1.sshSetupCommand);
 program.parse(process.argv);

package/dist/profile-resolver.js

@@ -56,9 +56,11 @@ class ProfileResolver {
     }
     /**
      * Resolve configuration from options (CLI flags, profile, interactive)
+     * Supports both v3 and v4 configs
      */
     async resolve(config, options) {
         const warnings = [];
+        const isV4Config = (0, config_loader_1.isV4)(config);
         // Step 1: Get base profile (if specified)
         let profile = {};
         if (options.profile) {
@@ -107,13 +109,13 @@ class ProfileResolver {
             size,
             project: {
                 name: config.project.name,
-                structure: config.project.structure,
+                structure: (config.project.structure === '$detect' ? 'single-app' : config.project.structure),
             },
             apps,
             infrastructure,
             database,
             repos: this.resolveRepos(config, apps),
-            env: this.resolveEnvVars(config, apps, infrastructure, database, profile.connect_to),
+            env: this.resolveEnvVars(config, apps, infrastructure, database, (0, config_loader_1.getProfileConnection)(profile)),
             hooks: config.hooks || {},
             profile: options.profile,
             warnings,
@@ -150,8 +152,8 @@ class ProfileResolver {
         const resolvedInfra = [];
         const warnings = [];
         const processedDeps = new Set();
-        // Default environment for dependencies
-        const defaultEnv = profile.connect_to || options.api;
+        // Default environment for dependencies (v3: connect_to, v4: default_connection)
+        const defaultEnv = (0, config_loader_1.getProfileConnection)(profile) || options.api;
         for (const appName of selectedApps) {
             const appConfig = config.apps[appName];
             if (!appConfig) {
@@ -161,12 +163,13 @@ class ProfileResolver {
             const resolvedApp = await this.resolveApp(config, appName, appConfig, selectedApps, defaultEnv, options, processedDeps);
             resolvedApps.push(resolvedApp);
         }
-        // Collect infrastructure needs
+        // Collect infrastructure needs (v3: infrastructure, v4: provides)
+        const infrastructure = (0, config_loader_1.getInfrastructure)(config);
         for (const app of resolvedApps) {
             for (const [depName, depConfig] of Object.entries(app.dependencies)) {
                 if (processedDeps.has(depName))
                     continue;
-                const infraConfig = config.infrastructure?.[depName];
+                const infraConfig = infrastructure?.[depName];
                 if (infraConfig) {
                     resolvedInfra.push({
                         name: depName,
@@ -188,14 +191,19 @@ class ProfileResolver {
      */
     async resolveApp(config, appName, appConfig, selectedApps, defaultEnv, options, processedDeps) {
         const dependencies = {};
-        // Process each dependency
-        for (const [depName, requirement] of Object.entries(appConfig.requires || {})) {
-            if (requirement === 'none')
+        const infrastructure = (0, config_loader_1.getInfrastructure)(config);
+        // Process each dependency (v3: requires, v4: connects_to)
+        const appDeps = (0, config_loader_1.isV4)(config)
+            ? Object.entries(appConfig.connects_to || {})
+            : Object.entries(appConfig.requires || {});
+        for (const [depName, requirement] of appDeps) {
+            // v3 uses 'none', v4 uses { required: false }
+            if (requirement === 'none' || (typeof requirement === 'object' && !requirement.required))
                 continue;
             // Check if dependency is already in selected apps
             const isLocalApp = selectedApps.includes(depName);
             // Check if it's infrastructure
-            const isInfra = config.infrastructure?.[depName];
+            const isInfra = infrastructure?.[depName];
             if (isLocalApp) {
                 // Dependency is included locally
                 dependencies[depName] = { mode: 'local' };
@@ -210,12 +218,12 @@ class ProfileResolver {
                     url,
                 };
             }
-            else if (requirement === 'required' && !options.yes) {
+            else if ((requirement === 'required' || (typeof requirement === 'object' && requirement.required)) && !options.yes) {
                 // Prompt user for resolution
                 const resolution = await this.promptDependencyResolution(config, appName, depName, isInfra ? 'infrastructure' : 'app');
                 dependencies[depName] = resolution;
             }
-            else if (requirement === 'optional') {
+            else if (requirement === 'optional' || (typeof requirement === 'object' && !requirement.required)) {
                 // Skip optional dependencies if not explicitly included
                 continue;
             }
@@ -325,13 +333,18 @@ class ProfileResolver {
                 source: profile.database.source,
             };
         }
-        // If connect_to is set, use remote
-        if (profile.connect_to) {
-            const envConfig = config.environments?.[profile.connect_to];
+        // If connect_to (v3) or default_connection (v4) is set, use remote
+        const profileConnection = (0, config_loader_1.getProfileConnection)(profile);
+        if (profileConnection) {
+            const envConfig = config.environments?.[profileConnection];
+            // v4 uses urls.mongodb, v3 uses mongodb.url
+            const mongoUrl = (0, config_loader_1.isV4)(config)
+                ? envConfig?.urls?.mongodb
+                : envConfig?.mongodb?.url;
             return {
                 mode: 'remote',
-                source: profile.connect_to,
-                url: envConfig?.mongodb?.url,
+                source: profileConnection,
+                url: mongoUrl,
             };
         }
         // Interactive mode
@@ -385,10 +398,14 @@ class ProfileResolver {
         else if (answer.startsWith('remote-')) {
             const source = answer.replace('remote-', '');
             const envConfig = config.environments?.[source];
+            // v4 uses urls.mongodb, v3 uses mongodb.url
+            const mongoUrl = (0, config_loader_1.isV4)(config)
+                ? envConfig?.urls?.mongodb
+                : envConfig?.mongodb?.url;
             return {
                 mode: 'remote',
                 source,
-                url: envConfig?.mongodb?.url,
+                url: mongoUrl,
             };
         }
         return { mode: 'local' };

package/package.json

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