genbox 1.0.23 → 1.0.24

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

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/random-name.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Random name generator for Genbox environments
+ * Generates memorable names using adjective-noun combinations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomName = generateRandomName;
+exports.generateNameSuggestions = generateNameSuggestions;
+const adjectives = [
+    'swift', 'calm', 'bold', 'keen', 'warm',
+    'cool', 'bright', 'quick', 'smart', 'fresh',
+    'wild', 'free', 'pure', 'soft', 'sharp',
+    'kind', 'brave', 'proud', 'fair', 'wise',
+    'gold', 'silver', 'azure', 'coral', 'amber',
+    'jade', 'ruby', 'pearl', 'ivory', 'onyx',
+    'misty', 'sunny', 'windy', 'rainy', 'snowy',
+    'lucky', 'happy', 'merry', 'jolly', 'lively',
+];
+const nouns = [
+    'fox', 'owl', 'wolf', 'hawk', 'bear',
+    'deer', 'hare', 'lynx', 'seal', 'dove',
+    'oak', 'pine', 'elm', 'ash', 'birch',
+    'maple', 'cedar', 'willow', 'sage', 'fern',
+    'river', 'lake', 'creek', 'brook', 'pond',
+    'peak', 'vale', 'ridge', 'cliff', 'mesa',
+    'moon', 'star', 'sun', 'cloud', 'wind',
+    'storm', 'frost', 'dawn', 'dusk', 'wave',
+];
+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 random name suggestions
+ */
+function generateNameSuggestions(count = 3) {
+    const names = new Set();
+    while (names.size < count) {
+        names.add(generateRandomName());
+    }
+    return Array.from(names);
+}

package/package.json

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