genbox 1.0.48 → 1.0.50

package/dist/api.js

@@ -8,6 +8,14 @@ exports.handleApiError = handleApiError;
 exports.isAuthError = isAuthError;
 exports.fetchApi = fetchApi;
 exports.checkNameAvailability = checkNameAvailability;
+exports.syncProject = syncProject;
+exports.getProjectByName = getProjectByName;
+exports.initiateSnapshotUpload = initiateSnapshotUpload;
+exports.completeSnapshotUpload = completeSnapshotUpload;
+exports.failSnapshotUpload = failSnapshotUpload;
+exports.listProjectSnapshots = listProjectSnapshots;
+exports.getLatestSnapshot = getLatestSnapshot;
+exports.getSnapshotDownloadUrl = getSnapshotDownloadUrl;
 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';
@@ -97,3 +105,57 @@ async function fetchApi(endpoint, options = {}) {
 async function checkNameAvailability(name, workspace) {
     return fetchApi(`/genboxes/check-name?name=${encodeURIComponent(name)}&workspace=${encodeURIComponent(workspace)}`);
 }
+async function syncProject(payload) {
+    return fetchApi('/projects', {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+}
+async function getProjectByName(name) {
+    return fetchApi(`/projects/by-name/${encodeURIComponent(name)}`);
+}
+/**
+ * Initiate a snapshot upload - get pre-signed URL
+ */
+async function initiateSnapshotUpload(payload) {
+    return fetchApi('/database-snapshots/initiate-upload', {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * Complete a snapshot upload after file is uploaded to S3
+ */
+async function completeSnapshotUpload(snapshotId, payload) {
+    return fetchApi(`/database-snapshots/${snapshotId}/complete`, {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * Mark snapshot upload as failed
+ */
+async function failSnapshotUpload(snapshotId, error) {
+    await fetchApi(`/database-snapshots/${snapshotId}/fail`, {
+        method: 'POST',
+        body: JSON.stringify({ error }),
+    });
+}
+/**
+ * List snapshots for a project
+ */
+async function listProjectSnapshots(projectId) {
+    return fetchApi(`/database-snapshots/project/${projectId}`);
+}
+/**
+ * Get latest snapshot for a project by source
+ */
+async function getLatestSnapshot(projectId, source) {
+    return fetchApi(`/database-snapshots/project/${projectId}/latest?source=${source}`);
+}
+/**
+ * Get download URL for a snapshot
+ */
+async function getSnapshotDownloadUrl(snapshotId) {
+    return fetchApi(`/database-snapshots/${snapshotId}/download`);
+}

package/dist/commands/create.js

@@ -51,6 +51,7 @@ 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");
+const db_utils_1 = require("../db-utils");
 // Credits consumed per hour for each size (matches API billing.config.ts)
 const CREDITS_PER_HOUR = {
     cx22: 1,
@@ -80,6 +81,23 @@ function spawnSshConfigSetup(genboxId, name) {
     // Allow parent to exit independently
     child.unref();
 }
+const DETECTED_DIR = '.genbox';
+const PROJECT_CACHE_FILENAME = 'project.json';
+/**
+ * Load project cache from local storage
+ */
+function loadProjectCache(rootDir) {
+    const cachePath = path.join(rootDir, DETECTED_DIR, PROJECT_CACHE_FILENAME);
+    if (!fs.existsSync(cachePath))
+        return null;
+    try {
+        const content = fs.readFileSync(cachePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
 async function provisionGenbox(payload) {
     return (0, api_1.fetchApi)('/genboxes', {
         method: 'POST',
@@ -220,6 +238,8 @@ exports.createCommand = new commander_1.Command('create')
     .option('--api <mode>', 'API mode: local, staging, production')
     .option('--db <mode>', 'Database mode: none, local, copy, remote')
     .option('--db-source <source>', 'Database source: staging, production')
+    .option('--db-dump <path>', 'Use existing mongodump file instead of creating one')
+    .option('--db-copy-remote', 'Copy database on the server (requires publicly accessible DB)')
     .option('-s, --size <size>', 'Server size: small, medium, large, xl')
     .option('-b, --branch <branch>', 'Use existing git branch (skips new branch creation)')
     .option('-n, --new-branch <name>', 'Create a new branch with this name (defaults to env name)')
@@ -410,8 +430,102 @@ exports.createCommand = new commander_1.Command('create')
                 }
             }
         }
+        // Handle database copy - dump locally and upload to S3
+        let snapshotId;
+        let snapshotS3Key;
+        let localDumpPath;
+        const projectCache = loadProjectCache(process.cwd());
+        const needsLocalDbCopy = resolved.database.mode === 'copy' &&
+            resolved.database.url &&
+            !options.dbCopyRemote;
+        if (needsLocalDbCopy) {
+            // Check for user-provided dump file
+            if (options.dbDump) {
+                if (!fs.existsSync(options.dbDump)) {
+                    console.log(chalk_1.default.red(`Database dump file not found: ${options.dbDump}`));
+                    return;
+                }
+                localDumpPath = options.dbDump;
+                console.log(chalk_1.default.dim(`  Using provided dump file: ${options.dbDump}`));
+            }
+            else {
+                // Need to run mongodump locally
+                if (!(0, db_utils_1.isMongoDumpAvailable)()) {
+                    console.log(chalk_1.default.red('mongodump not found. Required for database copy.'));
+                    console.log('');
+                    console.log((0, db_utils_1.getMongoDumpInstallInstructions)());
+                    console.log('');
+                    console.log(chalk_1.default.dim('Alternatively:'));
+                    console.log(chalk_1.default.dim('  • Use --db-dump <path> to provide an existing dump file'));
+                    console.log(chalk_1.default.dim('  • Use --db-copy-remote if your database is publicly accessible'));
+                    return;
+                }
+                const dbUrl = resolved.database.url;
+                console.log('');
+                console.log(chalk_1.default.blue('=== Database Copy ==='));
+                console.log(chalk_1.default.dim(`  Source: ${resolved.database.source}`));
+                console.log(chalk_1.default.dim(`  URL: ${dbUrl.replace(/\/\/[^:]+:[^@]+@/, '//***:***@')}`));
+                const dumpSpinner = (0, ora_1.default)('Creating database dump...').start();
+                const dumpResult = await (0, db_utils_1.runLocalMongoDump)(dbUrl, {
+                    onProgress: (msg) => dumpSpinner.text = msg,
+                });
+                if (!dumpResult.success) {
+                    dumpSpinner.fail(chalk_1.default.red('Database dump failed'));
+                    console.log(chalk_1.default.red(`  ${dumpResult.error}`));
+                    console.log('');
+                    console.log(chalk_1.default.dim('You can:'));
+                    console.log(chalk_1.default.dim('  • Fix the database connection and try again'));
+                    console.log(chalk_1.default.dim('  • Use --db local to start with an empty database'));
+                    console.log(chalk_1.default.dim('  • Use --db-dump <path> to provide an existing dump'));
+                    return;
+                }
+                dumpSpinner.succeed(chalk_1.default.green(`Database dump created (${(0, db_utils_1.formatBytes)(dumpResult.sizeBytes || 0)})`));
+                localDumpPath = dumpResult.dumpPath;
+            }
+            // Upload to S3 if we have a project ID
+            if (localDumpPath && projectCache?._id) {
+                const uploadSpinner = (0, ora_1.default)('Uploading database snapshot...').start();
+                const snapshotSource = (resolved.database.source === 'staging' ? 'staging' :
+                    resolved.database.source === 'production' ? 'production' : 'local');
+                const snapshotResult = await (0, db_utils_1.createAndUploadSnapshot)(localDumpPath, projectCache._id, snapshotSource, {
+                    sourceUrl: resolved.database.url?.replace(/\/\/[^:]+:[^@]+@/, '//***:***@'),
+                    onProgress: (msg) => uploadSpinner.text = msg,
+                });
+                if (snapshotResult.success) {
+                    uploadSpinner.succeed(chalk_1.default.green('Database snapshot uploaded'));
+                    snapshotId = snapshotResult.snapshotId;
+                    snapshotS3Key = snapshotResult.s3Key;
+                    // Cleanup local dump since it's now in S3
+                    (0, db_utils_1.cleanupDump)(localDumpPath);
+                    localDumpPath = undefined;
+                }
+                else {
+                    uploadSpinner.warn(chalk_1.default.yellow(`Snapshot upload failed: ${snapshotResult.error}`));
+                    console.log(chalk_1.default.dim('  Will fall back to direct SCP upload after genbox creation'));
+                }
+            }
+        }
         // Build payload
-        const payload = buildPayload(resolved, config, publicKey, privateKeyContent, configLoader);
+        const payloadResolved = { ...resolved };
+        if (snapshotId && snapshotS3Key) {
+            // Use S3 snapshot mode
+            payloadResolved.database = {
+                ...resolved.database,
+                url: undefined,
+                mode: 'snapshot',
+                snapshotId,
+                s3Key: snapshotS3Key,
+            };
+        }
+        else if (localDumpPath) {
+            // Fall back to SCP upload mode (no project or S3 upload failed)
+            payloadResolved.database = {
+                ...resolved.database,
+                url: undefined,
+                mode: 'copy-local',
+            };
+        }
+        const payload = buildPayload(payloadResolved, config, publicKey, privateKeyContent, configLoader);
         // Create genbox
         const spinner = (0, ora_1.default)(`Creating Genbox '${name}'...`).start();
         try {
@@ -431,12 +545,69 @@ exports.createCommand = new commander_1.Command('create')
             }
             // Display results
             displayGenboxInfo(genbox, resolved);
+            // Handle database upload if we have a local dump
+            if (localDumpPath && genbox.ipAddress) {
+                console.log('');
+                console.log(chalk_1.default.blue('=== Database Restore ==='));
+                // Wait for SSH access
+                const sshSpinner = (0, ora_1.default)('Waiting for SSH access...').start();
+                const sshReady = await (0, db_utils_1.waitForSshAccess)(genbox.ipAddress, 300, (msg) => {
+                    sshSpinner.text = msg;
+                });
+                if (!sshReady) {
+                    sshSpinner.fail(chalk_1.default.yellow('SSH not ready - database will need manual restore'));
+                    console.log(chalk_1.default.dim('  Run `genbox db sync` after the server is ready'));
+                    (0, db_utils_1.cleanupDump)(localDumpPath);
+                }
+                else {
+                    sshSpinner.succeed('SSH connected');
+                    // Upload dump
+                    const uploadSpinner = (0, ora_1.default)('Uploading database dump...').start();
+                    const uploadResult = await (0, db_utils_1.uploadDumpToGenbox)(localDumpPath, genbox.ipAddress, {
+                        onProgress: (msg) => uploadSpinner.text = msg,
+                    });
+                    if (!uploadResult.success) {
+                        uploadSpinner.fail(chalk_1.default.yellow('Upload failed - database will need manual restore'));
+                        console.log(chalk_1.default.dim(`  ${uploadResult.error}`));
+                        console.log(chalk_1.default.dim('  Run `genbox db sync` after the server is ready'));
+                        (0, db_utils_1.cleanupDump)(localDumpPath);
+                    }
+                    else {
+                        uploadSpinner.succeed('Dump uploaded');
+                        // Trigger restore
+                        const restoreSpinner = (0, ora_1.default)('Restoring database...').start();
+                        const restoreResult = await (0, db_utils_1.runRemoteMongoRestore)(genbox.ipAddress, config.project.name, { onProgress: (msg) => restoreSpinner.text = msg });
+                        if (!restoreResult.success) {
+                            restoreSpinner.fail(chalk_1.default.yellow('Restore failed'));
+                            console.log(chalk_1.default.dim(`  ${restoreResult.error}`));
+                            console.log(chalk_1.default.dim('  The dump file is on the server - you can restore manually'));
+                        }
+                        else {
+                            restoreSpinner.succeed(chalk_1.default.green('Database restored successfully!'));
+                        }
+                        // Cleanup local dump
+                        (0, db_utils_1.cleanupDump)(localDumpPath);
+                    }
+                }
+            }
+            else if (localDumpPath) {
+                // No IP yet - inform user to run db sync later
+                console.log('');
+                console.log(chalk_1.default.yellow('Database dump created but IP not yet assigned.'));
+                console.log(chalk_1.default.dim('  Run `genbox db sync` once the server is ready to restore the database.'));
+                // Keep the dump file - user might want to use it
+                console.log(chalk_1.default.dim(`  Dump file: ${localDumpPath}`));
+            }
             // Inform user about server provisioning
             console.log('');
             console.log(chalk_1.default.dim('Server is provisioning. Run `genbox connect` once ready.'));
         }
         catch (error) {
             spinner.fail(chalk_1.default.red(`Failed to create Genbox: ${error.message}`));
+            // Cleanup dump on failure
+            if (localDumpPath) {
+                (0, db_utils_1.cleanupDump)(localDumpPath);
+            }
             if (error instanceof api_1.AuthenticationError) {
                 console.log('');
                 console.log(chalk_1.default.yellow('  Please authenticate first:'));
@@ -509,6 +680,16 @@ function displayResolvedConfig(resolved) {
     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})` : ''}`);
+        // Show info for database copy mode
+        if (resolved.database.mode === 'copy' && resolved.database.source) {
+            if (resolved.database.url) {
+                console.log(chalk_1.default.dim(`    Source URL: ${resolved.database.url.replace(/\/\/[^:]+:[^@]+@/, '//***:***@')}`));
+                console.log(chalk_1.default.dim(`    Database will be dumped locally and uploaded to the genbox`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`    ⚠ No database URL found in environments.${resolved.database.source}.urls.mongodb`));
+            }
+        }
     }
     if (Object.keys(resolved.env).length > 0) {
         console.log('');
@@ -843,6 +1024,8 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
     }
     // Get local git config for commits
     const gitConfig = getGitConfig();
+    // Load project cache to get project ID
+    const projectCache = loadProjectCache(process.cwd());
     return {
         name: resolved.name,
         size: resolved.size,
@@ -882,6 +1065,8 @@ function buildPayload(resolved, config, publicKey, privateKey, configLoader) {
         branch: resolved.repos[0]?.branch,
         newBranch: resolved.repos[0]?.newBranch,
         sourceBranch: resolved.repos[0]?.sourceBranch,
+        // Project reference
+        project: projectCache?._id,
     };
 }
 /**

package/dist/commands/help.js

@@ -14,6 +14,8 @@ exports.helpCommand = new commander_1.Command('help')
     console.log(chalk_1.default.bold('Genbox CLI - AI-Powered Development Environments'));
     console.log(chalk_1.default.dim('Create isolated cloud development environments on demand'));
     console.log('');
+    console.log(chalk_1.default.green('TIP:') + ' Use ' + chalk_1.default.cyan('gb') + ' as a shorthand for ' + chalk_1.default.cyan('genbox') + ' (e.g., ' + chalk_1.default.dim('gb list') + ')');
+    console.log('');
     if (command) {
         showCommandHelp(command);
     }
@@ -45,34 +47,34 @@ function showGeneralHelp() {
     console.log(chalk_1.default.bold('QUICK START'));
     console.log('');
     console.log('  1. Initialize your project:');
-    console.log(chalk_1.default.dim('     $ genbox init'));
+    console.log(chalk_1.default.dim('     $ gb init'));
     console.log('');
     console.log('  2. Create a development environment:');
-    console.log(chalk_1.default.dim('     $ genbox create feature-auth'));
+    console.log(chalk_1.default.dim('     $ gb create feature-auth'));
     console.log('');
     console.log('  3. Check progress (setup takes a few minutes):');
-    console.log(chalk_1.default.dim('     $ genbox status feature-auth'));
+    console.log(chalk_1.default.dim('     $ gb status feature-auth'));
     console.log('');
     console.log('  4. Connect and start coding:');
-    console.log(chalk_1.default.dim('     $ genbox connect feature-auth'));
+    console.log(chalk_1.default.dim('     $ gb connect feature-auth'));
     console.log('');
     console.log('  5. Clean up when done:');
-    console.log(chalk_1.default.dim('     $ genbox destroy feature-auth'));
+    console.log(chalk_1.default.dim('     $ gb destroy feature-auth'));
     console.log('');
     console.log(chalk_1.default.bold('WORKFLOW EXAMPLES'));
     console.log('');
     console.log(chalk_1.default.yellow('  Feature Development:'));
-    console.log(chalk_1.default.dim('    $ genbox create feat-new-checkout'));
-    console.log(chalk_1.default.dim('    $ genbox status feat-new-checkout   # Wait for setup'));
-    console.log(chalk_1.default.dim('    $ genbox urls feat-new-checkout     # Get service URLs'));
-    console.log(chalk_1.default.dim('    $ genbox connect feat-new-checkout  # SSH to code'));
+    console.log(chalk_1.default.dim('    $ gb create feat-new-checkout'));
+    console.log(chalk_1.default.dim('    $ gb status feat-new-checkout   # Wait for setup'));
+    console.log(chalk_1.default.dim('    $ gb urls feat-new-checkout     # Get service URLs'));
+    console.log(chalk_1.default.dim('    $ gb connect feat-new-checkout  # SSH to code'));
     console.log('');
     console.log(chalk_1.default.yellow('  Local Debugging with Port Forwarding:'));
-    console.log(chalk_1.default.dim('    $ genbox forward feat-new-checkout'));
+    console.log(chalk_1.default.dim('    $ gb forward feat-new-checkout'));
     console.log(chalk_1.default.dim('    # Now access remote services at localhost:3050, etc.'));
     console.log('');
     console.log(chalk_1.default.yellow('  Database Sync:'));
-    console.log(chalk_1.default.dim('    $ genbox restore-db feat-new-checkout'));
+    console.log(chalk_1.default.dim('    $ gb restore-db feat-new-checkout'));
     console.log(chalk_1.default.dim('    # Copies your local MongoDB to the Genbox'));
     console.log('');
     console.log(chalk_1.default.bold('CONFIGURATION FILES'));
@@ -80,12 +82,12 @@ function showGeneralHelp() {
     console.log(`  ${chalk_1.default.cyan('genbox.yaml')}       Project configuration (services, ports, repos)`);
     console.log(`  ${chalk_1.default.cyan('.env.genbox')}       Environment variables (secrets, tokens)`);
     console.log('');
-    console.log(chalk_1.default.dim('  Run `genbox init` to create these files interactively.'));
+    console.log(chalk_1.default.dim('  Run `gb init` to create these files interactively.'));
     console.log('');
     console.log(chalk_1.default.bold('MORE HELP'));
     console.log('');
     console.log('  Get help for a specific command:');
-    console.log(chalk_1.default.dim('    $ genbox help <command>'));
+    console.log(chalk_1.default.dim('    $ gb help <command>'));
     console.log('');
     console.log('  Documentation: https://genbox.dev/docs');
     console.log('  Issues: https://github.com/goodpass-co/genbox/issues');

package/dist/commands/init.js

@@ -59,12 +59,63 @@ const fs_1 = __importDefault(require("fs"));
 const yaml = __importStar(require("js-yaml"));
 const process = __importStar(require("process"));
 const scanner_1 = require("../scanner");
+const api_1 = require("../api");
+const config_store_1 = require("../config-store");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { version } = require('../../package.json');
 const CONFIG_FILENAME = 'genbox.yaml';
 const ENV_FILENAME = '.env.genbox';
 const DETECTED_DIR = '.genbox';
 const DETECTED_FILENAME = 'detected.yaml';
+const PROJECT_CACHE_FILENAME = 'project.json';
+/**
+ * Save project ID and info to local cache
+ */
+function saveProjectCache(rootDir, cache) {
+    const genboxDir = path_1.default.join(rootDir, DETECTED_DIR);
+    if (!fs_1.default.existsSync(genboxDir)) {
+        fs_1.default.mkdirSync(genboxDir, { recursive: true });
+    }
+    const cachePath = path_1.default.join(genboxDir, PROJECT_CACHE_FILENAME);
+    fs_1.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+}
+/**
+ * Load project cache from local storage
+ */
+function loadProjectCache(rootDir) {
+    const cachePath = path_1.default.join(rootDir, DETECTED_DIR, PROJECT_CACHE_FILENAME);
+    if (!fs_1.default.existsSync(cachePath))
+        return null;
+    try {
+        const content = fs_1.default.readFileSync(cachePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Convert GenboxConfig to ProjectSyncPayload
+ */
+function configToSyncPayload(config, envVars, privateKey) {
+    return {
+        name: config.project.name,
+        version: config.version,
+        project: config.project,
+        apps: config.apps,
+        provides: config.provides,
+        environments: config.environments,
+        profiles: config.profiles,
+        defaults: config.defaults,
+        repos: config.repos,
+        hooks: config.hooks,
+        scripts: config.scripts,
+        strict: config.strict,
+        git_auth: config.git_auth,
+        envVars,
+        privateKey,
+    };
+}
 // =============================================================================
 // Scan Phase
 // =============================================================================
@@ -935,15 +986,16 @@ function generateDefaultProfiles(detected, environments) {
             };
         }
     }
-    // Full local development
-    if (frontendApps.length > 0 && backendApps.length > 0) {
-        const [frontendName] = frontendApps[0];
-        profiles[`${frontendName}-full`] = {
-            description: `${frontendName} + local backend` + (remoteEnv ? ' + DB copy' : ''),
-            size: 'large',
-            apps: [frontendName, ...backendApps.map(([n]) => n)],
-            database: remoteEnv ? { mode: 'copy', source: remoteEnv } : { mode: 'local' },
-        };
+    // Full local development - only create if multiple frontends exist (otherwise full-stack covers it)
+    if (frontendApps.length > 1 && backendApps.length > 0) {
+        for (const [frontendName] of frontendApps.slice(0, 2)) {
+            profiles[`${frontendName}-full`] = {
+                description: `${frontendName} + local backend` + (remoteEnv ? ' + DB copy' : ''),
+                size: 'large',
+                apps: [frontendName, ...backendApps.map(([n]) => n)],
+                database: remoteEnv ? { mode: 'copy', source: remoteEnv } : { mode: 'local' },
+            };
+        }
     }
     // Backend development
     for (const [name] of backendApps.slice(0, 2)) {
@@ -954,11 +1006,11 @@ function generateDefaultProfiles(detected, environments) {
             database: { mode: 'local' },
         };
     }
-    // Full stack
+    // Full stack - includes all runnable apps
     if (allRunnableApps.length > 1) {
         profiles['full-stack'] = {
             description: 'Everything local' + (remoteEnv ? ' with DB copy' : ''),
-            size: 'xl',
+            size: 'large',
             apps: allRunnableApps.map(([n]) => n),
             database: remoteEnv ? { mode: 'copy', source: remoteEnv } : { mode: 'local' },
         };
@@ -1500,14 +1552,14 @@ exports.initCommand = new commander_1.Command('init')
         let detected;
         const existingDetected = loadDetectedConfig(rootDir);
         if (existingDetected && !nonInteractive) {
-            console.log(chalk_1.default.dim(`Found existing .genbox/detected.yaml (${existingDetected._meta.generated_at})`));
-            const useExisting = await prompts.confirm({
-                message: 'Use existing scan results or rescan?',
-                default: true,
+            console.log(chalk_1.default.dim(`Found cached project scan from ${existingDetected._meta.generated_at}`));
+            const rescan = await prompts.confirm({
+                message: 'Rescan the project?',
+                default: false,
             });
-            if (useExisting) {
+            if (!rescan) {
                 detected = existingDetected;
-                console.log(chalk_1.default.dim('Using existing scan results.'));
+                console.log(chalk_1.default.dim('Using cached scan results.'));
             }
             else {
                 const spinner = (0, ora_1.default)('Scanning project...').start();
@@ -1554,6 +1606,25 @@ exports.initCommand = new commander_1.Command('init')
             const envContent = generateEnvFile(settings.projectName, detected, { ...gitEnvVars, LOCAL_API_URL: 'http://localhost:3050' }, []);
             fs_1.default.writeFileSync(path_1.default.join(rootDir, ENV_FILENAME), envContent);
             console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME}`));
+            // Sync project to API if logged in
+            if (config_store_1.ConfigStore.getToken()) {
+                try {
+                    const payload = configToSyncPayload(config, { ...gitEnvVars, LOCAL_API_URL: 'http://localhost:3050' });
+                    const result = await (0, api_1.syncProject)(payload);
+                    saveProjectCache(rootDir, {
+                        _id: result._id,
+                        name: result.name,
+                        lastSyncedAt: new Date().toISOString(),
+                        action: result.action,
+                    });
+                    console.log(chalk_1.default.green(`✔ Project synced to Genbox (${result.action})`));
+                }
+                catch (error) {
+                    if (!(0, api_1.isAuthError)(error)) {
+                        console.log(chalk_1.default.yellow(`  Warning: Could not sync project - ${error.message}`));
+                    }
+                }
+            }
             return;
         }
         // =========================================
@@ -1604,6 +1675,38 @@ exports.initCommand = new commander_1.Command('init')
             }
         }
         // =========================================
+        // PHASE 8: Sync Project to API
+        // =========================================
+        if (config_store_1.ConfigStore.getToken()) {
+            const syncSpinner = (0, ora_1.default)('Syncing project to Genbox...').start();
+            try {
+                const payload = configToSyncPayload(config, allEnvVars);
+                const result = await (0, api_1.syncProject)(payload);
+                saveProjectCache(rootDir, {
+                    _id: result._id,
+                    name: result.name,
+                    lastSyncedAt: new Date().toISOString(),
+                    action: result.action,
+                });
+                syncSpinner.succeed(`Project synced to Genbox (${result.action})`);
+                if (result.changes && result.changes.length > 0) {
+                    console.log(chalk_1.default.dim(`  Changes: ${result.changes.join(', ')}`));
+                }
+            }
+            catch (error) {
+                if ((0, api_1.isAuthError)(error)) {
+                    syncSpinner.warn('Not logged in - project not synced');
+                    console.log(chalk_1.default.dim('  Run `genbox login` to sync projects to your account'));
+                }
+                else {
+                    syncSpinner.warn(`Could not sync project - ${error.message}`);
+                }
+            }
+        }
+        else {
+            console.log(chalk_1.default.dim('  Project not synced (not logged in). Run `genbox login` to sync.'));
+        }
+        // =========================================
         // Show Instructions
         // =========================================
         const hasBackend = Object.values(detected.apps).some(a => a.type === 'backend' || a.type === 'gateway');

package/dist/commands/push.js

@@ -45,6 +45,19 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const config_loader_1 = require("../config-loader");
 const api_1 = require("../api");
+const DETECTED_DIR = '.genbox';
+const PROJECT_CACHE_FILENAME = 'project.json';
+/**
+ * Save project ID and info to local cache
+ */
+function saveProjectCache(rootDir, cache) {
+    const genboxDir = path.join(rootDir, DETECTED_DIR);
+    if (!fs.existsSync(genboxDir)) {
+        fs.mkdirSync(genboxDir, { recursive: true });
+    }
+    const cachePath = path.join(genboxDir, PROJECT_CACHE_FILENAME);
+    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+}
 function getPrivateSshKey() {
     const home = os.homedir();
     const potentialKeys = [
@@ -58,6 +71,28 @@ function getPrivateSshKey() {
     }
     return undefined;
 }
+/**
+ * Convert GenboxConfig to ProjectSyncPayload
+ */
+function configToSyncPayload(config, envVars, privateKey) {
+    return {
+        name: config.project.name,
+        version: config.version,
+        project: config.project,
+        apps: config.apps,
+        provides: config.provides,
+        environments: config.environments,
+        profiles: config.profiles,
+        defaults: config.defaults,
+        repos: config.repos,
+        hooks: config.hooks,
+        scripts: config.scripts,
+        strict: config.strict,
+        git_auth: config.git_auth,
+        envVars,
+        privateKey,
+    };
+}
 function buildLegacyPayload(config, envVars) {
     return {
         name: config.project_name,
@@ -232,18 +267,26 @@ exports.pushCommand = new commander_1.Command('push')
             console.log(JSON.stringify(previewPayload, null, 2));
             return;
         }
-        // Upload to server
-        const spinner = (0, ora_1.default)('Uploading workspace configuration...').start();
+        // Upload to server using the new projects endpoint
+        const spinner = (0, ora_1.default)('Syncing project configuration...').start();
         try {
-            const result = await (0, api_1.fetchApi)('/workspaces', {
-                method: 'PUT',
-                body: JSON.stringify(payload),
+            const v4Config = config;
+            const syncPayload = configToSyncPayload(v4Config, envVars, options.includeKey ? payload.privateKey : undefined);
+            const result = await (0, api_1.syncProject)(syncPayload);
+            // Save project cache locally
+            saveProjectCache(process.cwd(), {
+                _id: result._id,
+                name: result.name,
+                lastSyncedAt: new Date().toISOString(),
+                action: result.action,
             });
-            spinner.succeed(chalk_1.default.green('Workspace configuration uploaded successfully!'));
+            spinner.succeed(chalk_1.default.green(`Project synced successfully (${result.action})!`));
+            if (result.changes && result.changes.length > 0) {
+                console.log(chalk_1.default.dim(`  Changes: ${result.changes.join(', ')}`));
+            }
             console.log('');
             console.log(chalk_1.default.dim('Your configuration is now available in the cloud.'));
             console.log(chalk_1.default.dim('Team members can run "genbox create <name>" to provision environments.'));
-            const v4Config = config;
             const profileNames = Object.keys(v4Config.profiles || {});
             if (profileNames.length > 0) {
                 console.log('');
@@ -263,11 +306,11 @@ exports.pushCommand = new commander_1.Command('push')
             }
         }
         catch (error) {
-            spinner.fail(chalk_1.default.red('Failed to upload workspace configuration'));
+            spinner.fail(chalk_1.default.red('Failed to sync project configuration'));
             console.error(chalk_1.default.red(`Error: ${error.message}`));
             if (error instanceof api_1.AuthenticationError || error.message.includes('401') || error.message.includes('Unauthorized')) {
                 console.log('');
-                console.log(chalk_1.default.yellow('You need to be logged in to push workspace configuration.'));
+                console.log(chalk_1.default.yellow('You need to be logged in to push project configuration.'));
                 console.log(chalk_1.default.dim('Run "genbox login" to authenticate.'));
             }
         }

package/dist/db-utils.js

@@ -0,0 +1,416 @@
+"use strict";
+/**
+ * Database Utilities
+ *
+ * Handles local mongodump/mongorestore operations and
+ * uploading database dumps to genboxes.
+ */
+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.isMongoDumpAvailable = isMongoDumpAvailable;
+exports.getMongoDumpInstallInstructions = getMongoDumpInstallInstructions;
+exports.runLocalMongoDump = runLocalMongoDump;
+exports.uploadDumpToGenbox = uploadDumpToGenbox;
+exports.runRemoteMongoRestore = runRemoteMongoRestore;
+exports.cleanupDump = cleanupDump;
+exports.formatBytes = formatBytes;
+exports.waitForSshAccess = waitForSshAccess;
+exports.uploadDumpToS3 = uploadDumpToS3;
+exports.createAndUploadSnapshot = createAndUploadSnapshot;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Check if mongodump is available locally
+ */
+function isMongoDumpAvailable() {
+    try {
+        (0, child_process_1.execSync)('mongodump --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get instructions for installing mongodb-database-tools
+ */
+function getMongoDumpInstallInstructions() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `Install MongoDB Database Tools:
+  ${chalk_1.default.cyan('brew tap mongodb/brew')}
+  ${chalk_1.default.cyan('brew install mongodb-database-tools')}`;
+    }
+    else if (platform === 'linux') {
+        return `Install MongoDB Database Tools:
+  ${chalk_1.default.cyan('# For Ubuntu/Debian:')}
+  ${chalk_1.default.cyan('wget -qO- https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-7.0.gpg')}
+  ${chalk_1.default.cyan('echo "deb [ signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list')}
+  ${chalk_1.default.cyan('sudo apt-get update && sudo apt-get install -y mongodb-database-tools')}`;
+    }
+    else {
+        return `Install MongoDB Database Tools from:
+  ${chalk_1.default.cyan('https://www.mongodb.com/try/download/database-tools')}`;
+    }
+}
+/**
+ * Run mongodump locally
+ */
+async function runLocalMongoDump(sourceUrl, options = {}) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'genbox-dbdump-'));
+    const dumpPath = path.join(tempDir, 'dump.gz');
+    return new Promise((resolve) => {
+        const args = [
+            `--uri=${sourceUrl}`,
+            `--archive=${dumpPath}`,
+            '--gzip',
+        ];
+        // Add collection filters
+        if (options.collections && options.collections.length > 0) {
+            for (const col of options.collections) {
+                args.push(`--collection=${col}`);
+            }
+        }
+        if (options.excludeCollections && options.excludeCollections.length > 0) {
+            for (const col of options.excludeCollections) {
+                args.push(`--excludeCollection=${col}`);
+            }
+        }
+        options.onProgress?.('Starting mongodump...');
+        const proc = (0, child_process_1.spawn)('mongodump', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            const line = data.toString();
+            stderr += line;
+            // Parse progress from mongodump output
+            if (line.includes('done dumping')) {
+                options.onProgress?.(line.trim());
+            }
+        });
+        proc.on('close', (code) => {
+            if (code === 0 && fs.existsSync(dumpPath)) {
+                const stats = fs.statSync(dumpPath);
+                resolve({
+                    success: true,
+                    dumpPath,
+                    sizeBytes: stats.size,
+                });
+            }
+            else {
+                // Cleanup on failure
+                fs.rmSync(tempDir, { recursive: true, force: true });
+                // Parse common errors
+                let errorMessage = 'mongodump failed';
+                if (stderr.includes('authentication failed')) {
+                    errorMessage = 'Authentication failed - check your database credentials';
+                }
+                else if (stderr.includes('connection refused') || stderr.includes('no reachable servers')) {
+                    errorMessage = 'Connection failed - check if the database URL is correct and accessible';
+                }
+                else if (stderr.includes('timed out')) {
+                    errorMessage = 'Connection timed out - the database may not be accessible from your network';
+                }
+                else if (stderr) {
+                    errorMessage = stderr.split('\n')[0] || errorMessage;
+                }
+                resolve({
+                    success: false,
+                    error: errorMessage,
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            resolve({
+                success: false,
+                error: `Failed to run mongodump: ${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Upload dump file to genbox via SCP
+ */
+async function uploadDumpToGenbox(dumpPath, ipAddress, options = {}) {
+    return new Promise((resolve) => {
+        const remotePath = '/home/dev/.db-dump.gz';
+        options.onProgress?.(`Uploading dump to genbox (${formatBytes(fs.statSync(dumpPath).size)})...`);
+        const proc = (0, child_process_1.spawn)('scp', [
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=30',
+            dumpPath,
+            `dev@${ipAddress}:${remotePath}`,
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                let errorMessage = 'SCP upload failed';
+                if (stderr.includes('Connection refused') || stderr.includes('Connection timed out')) {
+                    errorMessage = 'Cannot connect to genbox - it may still be provisioning';
+                }
+                else if (stderr.includes('Permission denied')) {
+                    errorMessage = 'Permission denied - SSH key may not be configured';
+                }
+                else if (stderr) {
+                    errorMessage = stderr.split('\n')[0] || errorMessage;
+                }
+                resolve({ success: false, error: errorMessage });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: `Failed to run scp: ${err.message}` });
+        });
+    });
+}
+/**
+ * Run mongorestore on genbox via SSH
+ */
+async function runRemoteMongoRestore(ipAddress, dbName, options = {}) {
+    return new Promise((resolve) => {
+        options.onProgress?.('Restoring database on genbox...');
+        // The restore command - uses the uploaded dump file
+        const restoreCmd = `
+      # Wait for MongoDB to be ready
+      for i in {1..30}; do
+        if docker exec goodpass-mongodb mongosh --quiet --eval "db.runCommand({ping:1})" 2>/dev/null; then
+          break
+        fi
+        echo "Waiting for MongoDB... ($i/30)"
+        sleep 2
+      done
+
+      # Restore the database
+      if [ -f /home/dev/.db-dump.gz ]; then
+        echo "Restoring database..."
+        mongorestore --uri="mongodb://localhost:27017" --db="${dbName}" --archive=/home/dev/.db-dump.gz --gzip --drop
+        rm -f /home/dev/.db-dump.gz
+        echo "Database restored successfully"
+      else
+        echo "Error: Dump file not found"
+        exit 1
+      fi
+    `;
+        const proc = (0, child_process_1.spawn)('ssh', [
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=30',
+            `dev@${ipAddress}`,
+            'bash', '-c', `'${restoreCmd.replace(/'/g, "'\\''")}'`,
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            const line = data.toString();
+            stdout += line;
+            if (line.includes('Restoring') || line.includes('restored')) {
+                options.onProgress?.(line.trim());
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({
+                    success: false,
+                    error: stderr || stdout || 'Restore failed',
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: `Failed to run ssh: ${err.message}` });
+        });
+    });
+}
+/**
+ * Clean up temporary dump files
+ */
+function cleanupDump(dumpPath) {
+    try {
+        const dir = path.dirname(dumpPath);
+        if (dir.includes('genbox-dbdump-')) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        else {
+            fs.rmSync(dumpPath, { force: true });
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/**
+ * Wait for genbox to be accessible via SSH
+ */
+async function waitForSshAccess(ipAddress, maxWaitSeconds = 300, onProgress) {
+    const startTime = Date.now();
+    const checkInterval = 5000; // 5 seconds
+    while (Date.now() - startTime < maxWaitSeconds * 1000) {
+        try {
+            (0, child_process_1.execSync)(`ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=5 dev@${ipAddress} echo ok`, { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            onProgress?.(`Waiting for genbox to be ready (${elapsed}s)...`);
+            await new Promise((r) => setTimeout(r, checkInterval));
+        }
+    }
+    return false;
+}
+/**
+ * Upload dump file to S3 using pre-signed URL
+ */
+async function uploadDumpToS3(dumpPath, uploadUrl, options = {}) {
+    const fileSize = fs.statSync(dumpPath).size;
+    options.onProgress?.(`Uploading snapshot to cloud (${formatBytes(fileSize)})...`, 0);
+    try {
+        // Read file as buffer
+        const fileBuffer = fs.readFileSync(dumpPath);
+        // Upload to S3 using pre-signed URL
+        const response = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/gzip',
+                'Content-Length': fileSize.toString(),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                success: false,
+                error: `Upload failed: ${response.status} ${response.statusText} - ${errorText}`,
+            };
+        }
+        options.onProgress?.('Upload complete', 100);
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Upload failed: ${error.message}`,
+        };
+    }
+}
+async function createAndUploadSnapshot(dumpPath, projectId, source, options = {}) {
+    // Import API functions dynamically to avoid circular deps
+    const { initiateSnapshotUpload, completeSnapshotUpload, failSnapshotUpload, } = await Promise.resolve().then(() => __importStar(require('./api')));
+    const fileSize = fs.statSync(dumpPath).size;
+    const snapshotName = options.name || `${source}-${new Date().toISOString().split('T')[0]}`;
+    let snapshotId;
+    try {
+        // Step 1: Initiate upload to get pre-signed URL
+        options.onProgress?.('Preparing snapshot upload...');
+        const initResult = await initiateSnapshotUpload({
+            name: snapshotName,
+            projectId,
+            source,
+            sizeBytes: fileSize,
+            contentType: 'application/gzip',
+        });
+        snapshotId = initResult.snapshotId;
+        // Step 2: Upload to S3
+        const uploadResult = await uploadDumpToS3(dumpPath, initResult.uploadUrl, {
+            onProgress: options.onProgress,
+        });
+        if (!uploadResult.success) {
+            // Mark as failed
+            await failSnapshotUpload(snapshotId, uploadResult.error || 'Upload failed');
+            return { success: false, error: uploadResult.error };
+        }
+        // Step 3: Complete the upload
+        options.onProgress?.('Finalizing snapshot...');
+        await completeSnapshotUpload(snapshotId, {
+            sizeBytes: fileSize,
+            compressedSizeBytes: fileSize, // Already gzipped
+            sourceUrl: options.sourceUrl,
+        });
+        return {
+            success: true,
+            snapshotId,
+            s3Key: initResult.s3Key,
+        };
+    }
+    catch (error) {
+        // Try to mark as failed if we have a snapshot ID
+        if (snapshotId) {
+            try {
+                await failSnapshotUpload(snapshotId, error.message);
+            }
+            catch {
+                // Ignore cleanup error
+            }
+        }
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

package/dist/index.js

@@ -8,7 +8,7 @@ const program = new commander_1.Command();
 const { version } = require('../package.json');
 program
     .name('genbox')
-    .description('Genbox CLI - AI-Powered Development Environments')
+    .description('Genbox CLI - AI-Powered Development Environments\n\nTIP: Use "gb" as a shorthand (e.g., gb list, gb create)')
     .version(version, '-v, --version', 'Output the current version');
 const create_1 = require("./commands/create");
 const list_1 = require("./commands/list");

package/dist/profile-resolver.js

@@ -321,11 +321,18 @@ class ProfileResolver {
      * Resolve database mode
      */
     async resolveDatabaseMode(config, options, profile) {
+        // Helper to get MongoDB URL for an environment
+        const getMongoUrl = (source) => {
+            const envConfig = config.environments?.[source];
+            return envConfig?.urls?.mongodb;
+        };
         // CLI flag takes precedence
         if (options.db) {
+            const source = options.dbSource || profile.database?.source || 'staging';
             return {
                 mode: options.db,
-                source: options.dbSource || profile.database?.source || 'staging',
+                source,
+                url: options.db === 'copy' ? getMongoUrl(source) : undefined,
             };
         }
         // Profile setting
@@ -333,16 +340,16 @@ class ProfileResolver {
             return {
                 mode: profile.database.mode,
                 source: profile.database.source,
+                url: profile.database.mode === 'copy' && profile.database.source
+                    ? getMongoUrl(profile.database.source)
+                    : undefined,
             };
         }
-        // If connect_to (v3) or default_connection (v4) is set, use remote
+        // If default_connection 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 = true
-                ? envConfig?.urls?.mongodb
-                : envConfig?.mongodb?.url;
+            const mongoUrl = envConfig?.urls?.mongodb;
             return {
                 mode: 'remote',
                 source: profileConnection,
@@ -354,9 +361,12 @@ class ProfileResolver {
             return await this.selectDatabaseModeInteractive(config);
         }
         // Default
+        const defaultMode = config.defaults?.database?.mode || 'local';
+        const defaultSource = config.defaults?.database?.source;
         return {
-            mode: config.defaults?.database?.mode || 'local',
-            source: config.defaults?.database?.source,
+            mode: defaultMode,
+            source: defaultSource,
+            url: defaultMode === 'copy' && defaultSource ? getMongoUrl(defaultSource) : undefined,
         };
     }
     /**
@@ -395,15 +405,14 @@ class ProfileResolver {
         }
         else if (answer.startsWith('copy-')) {
             const source = answer.replace('copy-', '');
-            return { mode: 'copy', source };
+            const envConfig = config.environments?.[source];
+            const mongoUrl = envConfig?.urls?.mongodb;
+            return { mode: 'copy', source, url: mongoUrl };
         }
         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 = true
-                ? envConfig?.urls?.mongodb
-                : envConfig?.mongodb?.url;
+            const mongoUrl = envConfig?.urls?.mongodb;
             return {
                 mode: 'remote',
                 source,

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "genbox",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {
-    "genbox": "./dist/index.js"
+    "genbox": "./dist/index.js",
+    "gb": "./dist/index.js"
   },
   "files": [
     "dist/**/*"