genbox 1.0.23 → 1.0.25

package/dist/api.js

@@ -7,6 +7,7 @@ exports.AuthenticationError = void 0;
 exports.handleApiError = handleApiError;
 exports.isAuthError = isAuthError;
 exports.fetchApi = fetchApi;
+exports.checkNameAvailability = checkNameAvailability;
 const chalk_1 = __importDefault(require("chalk"));
 const config_store_1 = require("./config-store");
 const API_URL = process.env.GENBOX_API_URL || 'https://api.genbox.dev';
@@ -74,3 +75,9 @@ async function fetchApi(endpoint, options = {}) {
     }
     return response.json();
 }
+/**
+ * Check if a genbox name is available in a workspace
+ */
+async function checkNameAvailability(name, workspace) {
+    return fetchApi(`/genboxes/check-name?name=${encodeURIComponent(name)}&workspace=${encodeURIComponent(workspace)}`);
+}

package/dist/commands/create.js

@@ -50,6 +50,7 @@ const api_1 = require("../api");
 const ssh_config_1 = require("../ssh-config");
 const schema_v4_1 = require("../schema-v4");
 const child_process_1 = require("child_process");
+const random_name_1 = require("../random-name");
 /**
  * Spawn a background process to poll for IP and add SSH config
  * This runs detached so the main process can exit immediately
@@ -99,9 +100,85 @@ function getPrivateSshKey() {
     }
     return undefined;
 }
+/**
+ * Prompt user for environment name
+ */
+async function promptForName(skipPrompts) {
+    if (skipPrompts) {
+        return (0, random_name_1.generateRandomName)();
+    }
+    const suggestions = (0, random_name_1.generateNameSuggestions)(3);
+    const nameChoice = await prompts.select({
+        message: 'Environment name:',
+        choices: [
+            {
+                name: `${suggestions[0]} (random)`,
+                value: suggestions[0],
+            },
+            {
+                name: `${suggestions[1]} (random)`,
+                value: suggestions[1],
+            },
+            {
+                name: `${suggestions[2]} (random)`,
+                value: suggestions[2],
+            },
+            {
+                name: 'Enter custom name...',
+                value: '__custom__',
+            },
+        ],
+    });
+    if (nameChoice === '__custom__') {
+        const customName = await prompts.input({
+            message: 'Enter environment name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Name is required';
+                if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(value.trim())) {
+                    return 'Name must be lowercase, start/end with letter or number, and contain only letters, numbers, and hyphens';
+                }
+                return true;
+            },
+        });
+        return customName.trim();
+    }
+    return nameChoice;
+}
+/**
+ * Prompt user to select a profile
+ */
+async function promptForProfile(profiles) {
+    const profileNames = Object.keys(profiles);
+    // Build choices with profile descriptions
+    const choices = profileNames.map(name => {
+        const profile = profiles[name];
+        const apps = profile.apps ? profile.apps.join(', ') : 'default apps';
+        const description = profile.description || `Apps: ${apps}`;
+        return {
+            name: `${name} - ${chalk_1.default.dim(description)}`,
+            value: name,
+        };
+    });
+    // Add custom option
+    choices.push({
+        name: `${chalk_1.default.cyan('Custom')} - ${chalk_1.default.dim('Configure manually')}`,
+        value: '__custom__',
+    });
+    console.log(chalk_1.default.blue('=== Profile Selection ==='));
+    console.log('');
+    const selected = await prompts.select({
+        message: 'Select a profile:',
+        choices,
+    });
+    if (selected === '__custom__') {
+        return undefined; // No profile, will use default behavior
+    }
+    return selected;
+}
 exports.createCommand = new commander_1.Command('create')
     .description('Create a new Genbox environment')
-    .argument('<name>', 'Name of the Genbox')
+    .argument('[name]', 'Name of the Genbox (optional - will prompt if not provided)')
     .option('-p, --profile <profile>', 'Use a predefined profile')
     .option('-a, --apps <apps>', 'Comma-separated list of apps to include')
     .option('--add-apps <apps>', 'Add apps to the profile')
@@ -114,7 +191,7 @@ exports.createCommand = new commander_1.Command('create')
     .option('-f, --from-branch <branch>', 'Source branch to create new branch from (defaults to current/default branch)')
     .option('-y, --yes', 'Skip interactive prompts')
     .option('--dry-run', 'Show what would be created without actually creating')
-    .action(async (name, options) => {
+    .action(async (nameArg, options) => {
     try {
         // Load configuration
         const configLoader = new config_loader_1.ConfigLoader();
@@ -122,12 +199,53 @@ exports.createCommand = new commander_1.Command('create')
         const configVersion = (0, schema_v4_1.getConfigVersion)(loadResult.config);
         if (!loadResult.config || configVersion === 'unknown') {
             // Fall back to legacy v1/v2 handling
+            const name = nameArg || await promptForName(options.yes);
             await createLegacy(name, options);
             return;
         }
         // Support both v3 and v4 configs
         const config = loadResult.config;
         const profileResolver = new profile_resolver_1.ProfileResolver(configLoader);
+        // Interactive name prompt if not provided
+        let name = nameArg;
+        if (!name && !options.yes) {
+            name = await promptForName(false);
+        }
+        else if (!name && options.yes) {
+            // Auto-generate name in non-interactive mode
+            name = (0, random_name_1.generateRandomName)();
+            console.log(chalk_1.default.dim(`  Auto-generated name: ${name}`));
+        }
+        // Interactive profile selection if profiles exist and no -p option provided
+        let selectedProfile = options.profile;
+        if (!selectedProfile && !options.yes && config.profiles && Object.keys(config.profiles).length > 0) {
+            selectedProfile = await promptForProfile(config.profiles);
+        }
+        // Check if name is available in workspace, add suffix if taken
+        const workspace = config.project?.name || 'default';
+        try {
+            let { available } = await (0, api_1.checkNameAvailability)(name, workspace);
+            if (!available) {
+                // Add random suffix and retry
+                const originalName = name;
+                const suffix = Math.random().toString(36).substring(2, 6);
+                name = `${originalName}-${suffix}`;
+                // Verify the new name is available
+                const recheck = await (0, api_1.checkNameAvailability)(name, workspace);
+                if (!recheck.available) {
+                    // Extremely unlikely, but fall back to timestamp
+                    name = `${originalName}-${Date.now().toString(36)}`;
+                }
+                console.log(chalk_1.default.yellow(`  Name '${originalName}' is already in use, using '${name}' instead`));
+            }
+        }
+        catch (error) {
+            // If check fails (e.g., not logged in), continue - API will catch it on create
+            if (error instanceof api_1.AuthenticationError) {
+                throw error;
+            }
+            // Silently continue for other errors - the create API will validate
+        }
         // Validate branch options
         if (options.newBranch && !options.fromBranch) {
             console.error(chalk_1.default.red('Error: --new-branch (-n) requires --from-branch (-f) to specify the source branch'));
@@ -145,7 +263,7 @@ exports.createCommand = new commander_1.Command('create')
         // Build create options
         const createOptions = {
             name,
-            profile: options.profile,
+            profile: selectedProfile,
             apps: options.apps ? options.apps.split(',').map((a) => a.trim()) : undefined,
             addApps: options.addApps ? options.addApps.split(',').map((a) => a.trim()) : undefined,
             api: options.api,
@@ -170,7 +288,7 @@ exports.createCommand = new commander_1.Command('create')
         // Display resolved configuration
         displayResolvedConfig(resolved);
         // Ask to save as profile (if not using one already)
-        if (!options.profile && !options.yes && !options.dryRun) {
+        if (!selectedProfile && !options.yes && !options.dryRun) {
             await profileResolver.askSaveProfile(config, resolved);
         }
         // Dry run mode
@@ -302,8 +420,12 @@ function displayResolvedConfig(resolved) {
             console.log(`    • ${infra.name} (${infra.mode})`);
         }
     }
-    console.log('');
-    console.log(`  ${chalk_1.default.bold('Database:')}  ${resolved.database.mode}${resolved.database.source ? ` (from ${resolved.database.source})` : ''}`);
+    // Only show database info if there are backend apps
+    const hasBackendApps = resolved.apps.some(a => a.type === 'backend' || a.name === 'api');
+    if (hasBackendApps && resolved.database.mode !== 'none') {
+        console.log('');
+        console.log(`  ${chalk_1.default.bold('Database:')}  ${resolved.database.mode}${resolved.database.source ? ` (from ${resolved.database.source})` : ''}`);
+    }
     if (Object.keys(resolved.env).length > 0) {
         console.log('');
         console.log(`  ${chalk_1.default.bold('Environment:')}`);

package/dist/commands/init.js

@@ -1174,9 +1174,6 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                 }
             }
             if (Object.keys(urls).length > 0) {
-                // Add database URLs
-                urls['mongodb'] = '${STAGING_MONGODB_URL}';
-                urls['redis'] = '${STAGING_REDIS_URL}';
                 environments.staging = {
                     description: 'Staging environment',
                     urls,
@@ -1207,8 +1204,6 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                     description: 'Staging environment',
                     urls: {
                         api: stagingApiUrl,
-                        mongodb: '${STAGING_MONGODB_URL}',
-                        redis: '${STAGING_REDIS_URL}',
                     },
                 };
             }
@@ -1238,8 +1233,6 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                 description: 'Staging environment',
                 urls: {
                     api: stagingApiUrl,
-                    mongodb: '${STAGING_MONGODB_URL}',
-                    redis: '${STAGING_REDIS_URL}',
                 },
             };
         }
@@ -1279,7 +1272,6 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                     }
                 }
                 if (Object.keys(prodUrls).length > 0) {
-                    prodUrls['mongodb'] = '${PROD_MONGODB_URL}';
                     environments.production = {
                         description: 'Production (use with caution)',
                         urls: prodUrls,
@@ -1314,7 +1306,6 @@ async function setupEnvironments(scan, config, isMultiRepo = false, existingEnvV
                     description: 'Production (use with caution)',
                     urls: {
                         api: prodApiUrl,
-                        mongodb: '${PROD_MONGODB_URL}',
                     },
                     safety: {
                         read_only: true,

package/dist/config-loader.js

@@ -279,6 +279,10 @@ class ConfigLoader {
     }
     /**
      * Deep merge objects
+     *
+     * Special handling:
+     * - 'version' field is never overwritten (prevents v4 -> v1 downgrades)
+     * - Empty objects don't overwrite non-empty objects
      */
     deepMerge(target, source) {
         for (const key of Object.keys(source)) {
@@ -286,6 +290,21 @@ class ConfigLoader {
             const targetValue = target[key];
             if (sourceValue === undefined)
                 continue;
+            // Never overwrite version field - workspace config takes precedence
+            if (key === 'version' && targetValue !== undefined)
+                continue;
+            // Don't overwrite non-empty objects with empty objects
+            if (typeof sourceValue === 'object' &&
+                sourceValue !== null &&
+                !Array.isArray(sourceValue) &&
+                Object.keys(sourceValue).length === 0 &&
+                typeof targetValue === 'object' &&
+                targetValue !== null &&
+                !Array.isArray(targetValue) &&
+                Object.keys(targetValue).length > 0) {
+                // Skip - don't let empty {} overwrite populated object
+                continue;
+            }
             if (typeof sourceValue === 'object' &&
                 sourceValue !== null &&
                 !Array.isArray(sourceValue) &&

package/dist/profile-resolver.js

@@ -520,33 +520,37 @@ class ProfileResolver {
                 }
             }
         }
-        // Add database URL
-        if (database.mode === 'local') {
-            env['MONGODB_URI'] = `mongodb://localhost:27017/${config.project.name}`;
-        }
-        else if (database.url) {
-            env['MONGODB_URI'] = database.url;
-        }
-        // Add infrastructure URLs
-        for (const infra of infrastructure) {
-            if (infra.mode === 'local') {
-                switch (infra.type) {
-                    case 'cache':
-                        env['REDIS_URL'] = `redis://localhost:${infra.port || 6379}`;
-                        break;
-                    case 'queue':
-                        env['RABBITMQ_URL'] = `amqp://localhost:${infra.port || 5672}`;
-                        break;
-                }
+        // Only add database/infrastructure URLs if there are backend apps that need them
+        const hasBackendApps = apps.some(a => a.type === 'backend' || a.name === 'api');
+        if (hasBackendApps) {
+            // Add database URL
+            if (database.mode === 'local') {
+                env['MONGODB_URI'] = `mongodb://localhost:27017/${config.project.name}`;
             }
-            else if (infra.url) {
-                switch (infra.type) {
-                    case 'cache':
-                        env['REDIS_URL'] = infra.url;
-                        break;
-                    case 'queue':
-                        env['RABBITMQ_URL'] = infra.url;
-                        break;
+            else if (database.url) {
+                env['MONGODB_URI'] = database.url;
+            }
+            // Add infrastructure URLs
+            for (const infra of infrastructure) {
+                if (infra.mode === 'local') {
+                    switch (infra.type) {
+                        case 'cache':
+                            env['REDIS_URL'] = `redis://localhost:${infra.port || 6379}`;
+                            break;
+                        case 'queue':
+                            env['RABBITMQ_URL'] = `amqp://localhost:${infra.port || 5672}`;
+                            break;
+                    }
+                }
+                else if (infra.url) {
+                    switch (infra.type) {
+                        case 'cache':
+                            env['REDIS_URL'] = infra.url;
+                            break;
+                        case 'queue':
+                            env['RABBITMQ_URL'] = infra.url;
+                            break;
+                    }
                 }
             }
         }

package/dist/random-name.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Random name generator for Genbox environments
+ * Generates memorable names using adjective-noun combinations
+ * ~150 adjectives x ~150 nouns = ~22,500 unique combinations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOTAL_COMBINATIONS = void 0;
+exports.generateRandomName = generateRandomName;
+exports.generateNameSuggestions = generateNameSuggestions;
+const adjectives = [
+    // Colors & Shades
+    'red', 'blue', 'green', 'gold', 'silver', 'bronze', 'copper', 'amber',
+    'coral', 'ivory', 'onyx', 'jade', 'ruby', 'pearl', 'azure', 'cobalt',
+    'crimson', 'scarlet', 'violet', 'indigo', 'teal', 'cyan', 'magenta',
+    'golden', 'rusty', 'dusty', 'misty', 'frosty', 'snowy', 'icy',
+    // Weather & Nature
+    'sunny', 'windy', 'rainy', 'stormy', 'cloudy', 'foggy', 'hazy',
+    'balmy', 'breezy', 'dewy', 'humid', 'arid', 'polar', 'tropic',
+    // Temperature & Light
+    'warm', 'cool', 'cold', 'hot', 'bright', 'dim', 'dark', 'light',
+    'glowing', 'shiny', 'glossy', 'matte', 'vivid', 'pale', 'deep',
+    // Size & Shape
+    'tiny', 'small', 'big', 'giant', 'vast', 'wide', 'narrow', 'tall',
+    'short', 'long', 'round', 'flat', 'curved', 'steep', 'slim', 'broad',
+    // Speed & Movement
+    'swift', 'quick', 'fast', 'rapid', 'slow', 'steady', 'still', 'calm',
+    'wild', 'fierce', 'gentle', 'smooth', 'rough', 'bumpy', 'fluid',
+    // Character & Mood
+    'bold', 'brave', 'keen', 'wise', 'smart', 'clever', 'witty', 'sharp',
+    'kind', 'fair', 'proud', 'humble', 'noble', 'royal', 'grand', 'prime',
+    'happy', 'merry', 'jolly', 'lively', 'peppy', 'zesty', 'perky', 'chirpy',
+    'lucky', 'plucky', 'spunky', 'funky', 'groovy', 'snappy', 'zippy',
+    // Quality & State
+    'fresh', 'crisp', 'clean', 'pure', 'clear', 'free', 'open', 'safe',
+    'solid', 'stable', 'sturdy', 'strong', 'tough', 'hardy', 'robust',
+    'sleek', 'slick', 'neat', 'tidy', 'trim', 'lean', 'fit', 'agile',
+    // Time & Age
+    'new', 'young', 'early', 'late', 'ancient', 'modern', 'future', 'prime',
+    'fresh', 'ripe', 'mature', 'seasoned', 'timely', 'eternal', 'lasting',
+    // Sound & Texture
+    'silent', 'quiet', 'loud', 'sonic', 'soft', 'hard', 'dense', 'hollow',
+    'fuzzy', 'fluffy', 'silky', 'velvet', 'smooth', 'grainy', 'sandy',
+    // Taste & Smell (abstract)
+    'sweet', 'tangy', 'spicy', 'minty', 'zesty', 'savory', 'rich', 'mellow',
+    // Position & Direction
+    'upper', 'lower', 'inner', 'outer', 'central', 'polar', 'lateral',
+    'north', 'south', 'east', 'west', 'coastal', 'alpine', 'lunar', 'solar',
+];
+const nouns = [
+    // Animals - Land
+    'fox', 'wolf', 'bear', 'deer', 'elk', 'moose', 'hare', 'rabbit',
+    'lynx', 'puma', 'tiger', 'lion', 'panther', 'jaguar', 'leopard',
+    'horse', 'zebra', 'buffalo', 'bison', 'ox', 'ram', 'goat', 'sheep',
+    'badger', 'otter', 'beaver', 'marten', 'ferret', 'mink', 'stoat',
+    'squirrel', 'chipmunk', 'hedgehog', 'porcupine', 'armadillo',
+    // Animals - Birds
+    'owl', 'hawk', 'eagle', 'falcon', 'raven', 'crow', 'jay', 'finch',
+    'robin', 'sparrow', 'wren', 'lark', 'dove', 'pigeon', 'swan', 'crane',
+    'heron', 'stork', 'pelican', 'albatross', 'condor', 'vulture', 'kite',
+    'osprey', 'harrier', 'kestrel', 'merlin', 'shrike', 'oriole', 'thrush',
+    // Animals - Water
+    'seal', 'walrus', 'whale', 'dolphin', 'shark', 'orca', 'salmon', 'trout',
+    'bass', 'pike', 'perch', 'carp', 'tuna', 'marlin', 'barracuda',
+    'squid', 'octopus', 'crab', 'lobster', 'shrimp', 'oyster', 'clam',
+    // Trees & Plants
+    'oak', 'pine', 'elm', 'ash', 'birch', 'maple', 'cedar', 'spruce',
+    'willow', 'poplar', 'aspen', 'alder', 'beech', 'cherry', 'walnut',
+    'cypress', 'juniper', 'hemlock', 'sequoia', 'redwood', 'mahogany',
+    'sage', 'fern', 'moss', 'ivy', 'vine', 'reed', 'bamboo', 'palm',
+    'cactus', 'lotus', 'lily', 'rose', 'tulip', 'orchid', 'iris', 'daisy',
+    // Landforms & Geography
+    'peak', 'summit', 'ridge', 'cliff', 'bluff', 'mesa', 'butte', 'dune',
+    'vale', 'glen', 'dale', 'dell', 'gorge', 'canyon', 'ravine', 'gulch',
+    'plain', 'prairie', 'meadow', 'field', 'grove', 'forest', 'jungle',
+    'island', 'atoll', 'reef', 'cape', 'bay', 'cove', 'inlet', 'fjord',
+    // Water Bodies
+    'river', 'stream', 'creek', 'brook', 'spring', 'falls', 'rapids',
+    'lake', 'pond', 'pool', 'lagoon', 'marsh', 'swamp', 'delta', 'estuary',
+    'ocean', 'sea', 'gulf', 'strait', 'channel', 'tide', 'wave', 'surf',
+    // Sky & Space
+    'moon', 'sun', 'star', 'comet', 'meteor', 'nova', 'nebula', 'quasar',
+    'cloud', 'storm', 'rain', 'snow', 'frost', 'hail', 'mist', 'fog',
+    'wind', 'gale', 'breeze', 'gust', 'draft', 'zephyr', 'monsoon',
+    'dawn', 'dusk', 'noon', 'night', 'twilight', 'aurora', 'eclipse',
+    // Stones & Minerals
+    'stone', 'rock', 'boulder', 'pebble', 'gravel', 'sand', 'clay', 'chalk',
+    'crystal', 'gem', 'diamond', 'emerald', 'sapphire', 'topaz', 'opal',
+    'granite', 'marble', 'slate', 'quartz', 'flint', 'obsidian', 'basalt',
+    // Misc Nature
+    'flame', 'ember', 'spark', 'blaze', 'torch', 'beacon', 'flare',
+    'shadow', 'shade', 'glint', 'gleam', 'shimmer', 'glimmer', 'flash',
+    'echo', 'whisper', 'murmur', 'rustle', 'ripple', 'rumble', 'thunder',
+];
+function randomElement(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+/**
+ * Generate a random environment name
+ * Format: adjective-noun (e.g., "swift-fox", "calm-river")
+ */
+function generateRandomName() {
+    const adjective = randomElement(adjectives);
+    const noun = randomElement(nouns);
+    return `${adjective}-${noun}`;
+}
+/**
+ * Generate multiple unique random name suggestions
+ */
+function generateNameSuggestions(count = 3) {
+    const names = new Set();
+    // Prevent infinite loop if requesting more than possible combinations
+    const maxAttempts = count * 10;
+    let attempts = 0;
+    while (names.size < count && attempts < maxAttempts) {
+        names.add(generateRandomName());
+        attempts++;
+    }
+    return Array.from(names);
+}
+/**
+ * Total possible unique combinations
+ */
+exports.TOTAL_COMBINATIONS = adjectives.length * nouns.length;

package/package.json

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