genbox 1.0.65 → 1.0.67

package/dist/commands/db-sync.js

@@ -147,7 +147,34 @@ exports.dbSyncCommand
                     if (snapshotChoice === 'existing') {
                         snapshotId = existingSnapshot._id;
                         snapshotS3Key = existingSnapshot.s3Key;
-                        console.log(chalk_1.default.green(`  ✓ Using existing snapshot`));
+                        // Download the existing snapshot from S3
+                        const downloadSpinner = (0, ora_1.default)('Downloading existing snapshot...').start();
+                        try {
+                            const downloadUrlResponse = await (0, api_1.getSnapshotDownloadUrl)(snapshotId);
+                            const downloadResult = await (0, db_utils_1.downloadSnapshotFromS3)(downloadUrlResponse.downloadUrl, {
+                                onProgress: (msg) => downloadSpinner.text = msg,
+                            });
+                            if (!downloadResult.success) {
+                                downloadSpinner.fail(chalk_1.default.red('Failed to download snapshot'));
+                                console.log(chalk_1.default.dim(`  Error: ${downloadResult.error}`));
+                                console.log(chalk_1.default.dim('  Creating fresh snapshot instead...'));
+                                // Reset to create fresh
+                                snapshotId = undefined;
+                                snapshotS3Key = undefined;
+                            }
+                            else {
+                                downloadSpinner.succeed(chalk_1.default.green('Snapshot downloaded'));
+                                localDumpPath = downloadResult.dumpPath;
+                            }
+                        }
+                        catch (error) {
+                            downloadSpinner.fail(chalk_1.default.red('Failed to download snapshot'));
+                            console.log(chalk_1.default.dim(`  Error: ${error.message}`));
+                            console.log(chalk_1.default.dim('  Creating fresh snapshot instead...'));
+                            // Reset to create fresh
+                            snapshotId = undefined;
+                            snapshotS3Key = undefined;
+                        }
                     }
                 }
             }
@@ -200,10 +227,7 @@ exports.dbSyncCommand
                     uploadSpinner.succeed(chalk_1.default.green('Database snapshot uploaded'));
                     snapshotId = snapshotResult.snapshotId;
                     snapshotS3Key = snapshotResult.s3Key;
-                    // Only cleanup if we created the dump (not user-provided)
-                    if (!options.dump) {
-                        (0, db_utils_1.cleanupDump)(localDumpPath);
-                    }
+                    // Don't cleanup yet - we still need the file for SCP to genbox
                 }
                 else {
                     uploadSpinner.fail(chalk_1.default.red('Database snapshot upload failed'));
@@ -215,29 +239,57 @@ exports.dbSyncCommand
                 }
             }
         }
-        // Trigger restore on genbox
-        if (!snapshotId || !snapshotS3Key) {
-            console.log(chalk_1.default.red('No snapshot available to restore'));
+        // Restore directly via SCP/SSH (user's own SSH key, more reliable than API async job)
+        if (!localDumpPath) {
+            console.log(chalk_1.default.red('No dump file available to restore'));
             return;
         }
-        const restoreSpinner = (0, ora_1.default)('Restoring database on genbox...').start();
+        const ipAddress = genbox.ipAddress;
+        if (!ipAddress) {
+            console.log(chalk_1.default.red('Genbox has no IP address'));
+            return;
+        }
+        const restoreSpinner = (0, ora_1.default)('Uploading dump to genbox...').start();
         try {
-            await (0, api_1.fetchApi)(`/genboxes/${genboxId}/db/restore`, {
-                method: 'POST',
-                body: JSON.stringify({
-                    snapshotId,
-                    s3Key: snapshotS3Key,
-                }),
+            // SCP dump file to genbox
+            const uploadResult = await (0, db_utils_1.uploadDumpToGenbox)(localDumpPath, ipAddress, {
+                onProgress: (msg) => restoreSpinner.text = msg,
             });
+            if (!uploadResult.success) {
+                restoreSpinner.fail(chalk_1.default.red('Upload failed'));
+                console.error(chalk_1.default.red(`  Error: ${uploadResult.error}`));
+                if (localDumpPath && !options.dump) {
+                    (0, db_utils_1.cleanupDump)(localDumpPath);
+                }
+                return;
+            }
+            restoreSpinner.text = 'Restoring database...';
+            // SSH to run mongorestore with dynamic port detection
+            const restoreResult = await (0, db_utils_1.runRemoteMongoRestoreDynamic)(ipAddress, {
+                onProgress: (msg) => restoreSpinner.text = msg,
+            });
+            if (!restoreResult.success) {
+                restoreSpinner.fail(chalk_1.default.red('Restore failed'));
+                console.error(chalk_1.default.red(`  Error: ${restoreResult.error}`));
+                if (localDumpPath && !options.dump) {
+                    (0, db_utils_1.cleanupDump)(localDumpPath);
+                }
+                return;
+            }
             restoreSpinner.succeed(chalk_1.default.green('Database sync completed!'));
             console.log('');
             console.log(chalk_1.default.dim(`  Database has been restored from ${source} snapshot.`));
+            // Cleanup local dump file now that we're done
+            if (localDumpPath && !options.dump) {
+                (0, db_utils_1.cleanupDump)(localDumpPath);
+            }
         }
         catch (error) {
             restoreSpinner.fail(chalk_1.default.red('Database restore failed'));
             console.error(chalk_1.default.red(`  Error: ${error.message}`));
-            if (error instanceof api_1.AuthenticationError) {
-                console.log(chalk_1.default.yellow('\nRun: genbox login'));
+            // Cleanup on error too
+            if (localDumpPath && !options.dump) {
+                (0, db_utils_1.cleanupDump)(localDumpPath);
             }
         }
     }

package/dist/commands/rebuild.js

@@ -562,9 +562,10 @@ exports.rebuildCommand = new commander_1.Command('rebuild')
         // For branch: CLI options override, then stored newBranch (if it was created), then stored branch
         const effectiveBranch = options.branch || storedNewBranch || storedBranch;
         // For new branch creation: use CLI options OR stored values (to re-create branch if first attempt failed)
-        // If storedNewBranch exists with storedSourceBranch, the branch may not have been created yet
-        const effectiveNewBranch = newBranchName || (storedNewBranch && storedSourceBranch ? storedNewBranch : undefined);
-        const effectiveSourceBranch = options.fromBranch || (storedNewBranch && storedSourceBranch ? storedSourceBranch : undefined);
+        // If storedNewBranch exists, we need to re-create it - default sourceBranch to 'main' if not stored
+        const defaultSourceBranch = config.defaults?.branch || 'main';
+        const effectiveNewBranch = newBranchName || storedNewBranch;
+        const effectiveSourceBranch = options.fromBranch || (storedNewBranch ? (storedSourceBranch || defaultSourceBranch) : undefined);
         // For database: use CLI option, or stored database config (convert 'snapshot' to 'copy')
         const storedDbMode = genbox.database?.mode === 'snapshot' ? 'copy' : genbox.database?.mode;
         const effectiveDbMode = options.db || storedDbMode;

package/dist/db-utils.js

@@ -47,9 +47,11 @@ exports.getMongoDumpInstallInstructions = getMongoDumpInstallInstructions;
 exports.runLocalMongoDump = runLocalMongoDump;
 exports.uploadDumpToGenbox = uploadDumpToGenbox;
 exports.runRemoteMongoRestore = runRemoteMongoRestore;
+exports.runRemoteMongoRestoreDynamic = runRemoteMongoRestoreDynamic;
 exports.cleanupDump = cleanupDump;
 exports.formatBytes = formatBytes;
 exports.waitForSshAccess = waitForSshAccess;
+exports.downloadSnapshotFromS3 = downloadSnapshotFromS3;
 exports.uploadDumpToS3 = uploadDumpToS3;
 exports.createAndUploadSnapshot = createAndUploadSnapshot;
 const child_process_1 = require("child_process");
@@ -276,6 +278,94 @@ async function runRemoteMongoRestore(ipAddress, dbName, options = {}) {
         });
     });
 }
+/**
+ * Run mongorestore on genbox via SSH with dynamic port detection
+ * This version doesn't hardcode container names or ports - it detects them dynamically
+ */
+async function runRemoteMongoRestoreDynamic(ipAddress, options = {}) {
+    return new Promise((resolve) => {
+        options.onProgress?.('Detecting MongoDB and restoring database...');
+        // The restore command - detects MongoDB port dynamically
+        const restoreCmd = `
+set -e
+
+# Detect MongoDB port from running docker containers
+# Different projects use different port mappings (e.g., 27037, 27117, etc.)
+MONGO_PORT=$(docker ps --format '{{.Ports}}' | grep -oP '\\d+(?=->27017)' | head -1)
+
+if [ -z "$MONGO_PORT" ]; then
+  echo "ERROR: Could not detect MongoDB port from running containers"
+  docker ps
+  exit 1
+fi
+
+echo "MongoDB detected on port: $MONGO_PORT"
+
+# Wait for MongoDB to be responsive
+for i in {1..30}; do
+  if mongosh --quiet --host localhost --port $MONGO_PORT --eval "db.runCommand({ping:1})" 2>/dev/null; then
+    echo "MongoDB is ready"
+    break
+  fi
+  if [ $i -eq 30 ]; then
+    echo "ERROR: MongoDB not responding after 30 attempts"
+    exit 1
+  fi
+  echo "Waiting for MongoDB... ($i/30)"
+  sleep 2
+done
+
+# Restore the database from the uploaded dump
+if [ -f /home/dev/.db-dump.gz ]; then
+  echo "Restoring database..."
+  # The dump is a raw mongodump --archive file (gzipped), not a tar archive
+  # Don't use --db flag with --archive as it causes issues
+  mongorestore --host localhost:$MONGO_PORT --drop --gzip --archive=/home/dev/.db-dump.gz
+  rm -f /home/dev/.db-dump.gz
+  echo "Database restored successfully"
+else
+  echo "Error: Dump file not found at /home/dev/.db-dump.gz"
+  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;
+            // Report progress
+            if (line.includes('MongoDB detected') || line.includes('Restoring') || line.includes('restored') || line.includes('Waiting')) {
+                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
  */
@@ -324,6 +414,36 @@ async function waitForSshAccess(ipAddress, maxWaitSeconds = 300, onProgress) {
     }
     return false;
 }
+/**
+ * Download a snapshot from S3 using pre-signed URL
+ */
+async function downloadSnapshotFromS3(downloadUrl, options = {}) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'genbox-dbdump-'));
+    const dumpPath = path.join(tempDir, 'dump.gz');
+    options.onProgress?.('Downloading snapshot from cloud...');
+    try {
+        const response = await fetch(downloadUrl);
+        if (!response.ok) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            return {
+                success: false,
+                error: `Download failed: ${response.status} ${response.statusText}`,
+            };
+        }
+        const buffer = await response.arrayBuffer();
+        fs.writeFileSync(dumpPath, Buffer.from(buffer));
+        const stats = fs.statSync(dumpPath);
+        options.onProgress?.(`Downloaded snapshot (${formatBytes(stats.size)})`);
+        return { success: true, dumpPath };
+    }
+    catch (error) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        return {
+            success: false,
+            error: `Download failed: ${error.message}`,
+        };
+    }
+}
 /**
  * Upload dump file to S3 using pre-signed URL
  */

package/package.json

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