ante-erp-cli 1.9.7 → 1.9.8

package/bin/ante-cli.js

@@ -32,6 +32,7 @@ import { doctor } from '../src/commands/doctor.js';
 import { uninstall } from '../src/commands/uninstall.js';
 import { migrate, seed, shell, optimize, reset as dbReset, info } from '../src/commands/database.js';
 import { cloneDb } from '../src/commands/clone-db.js';
+import { cloneMongodb } from '../src/commands/clone-mongodb.js';
 import { setDomain } from '../src/commands/set-domain.js';
 import { sslEnable, sslStatus } from '../src/commands/ssl-enable.js';
 import { regenerateCompose } from '../src/commands/regenerate-compose.js';
@@ -47,6 +48,10 @@ program
   .option('--preset <type>', 'Installation preset (minimal, standard, enterprise)', 'standard')
   .option('--no-interactive', 'Non-interactive mode with defaults')
   .option('--skip-checks', 'Skip system requirements check')
+  .option('--with-facial', 'Install Facial Recognition Web app')
+  .option('--with-gate', 'Install Gate App')
+  .option('--with-guardian', 'Install Guardian App')
+  .option('--with-all-frontends', 'Install all frontend applications')
   .action(install);
 
 // Update & Maintenance
@@ -152,6 +157,14 @@ dbCmd
   .option('--no-prisma', 'Skip Prisma operations')
   .action(cloneDb);
 
+dbCmd
+  .command('clone-mongodb <mongodb-url>')
+  .description('Clone remote MongoDB database to local')
+  .option('--skip-dump', 'Use existing backup directory')
+  .option('--backup-dir <path>', 'Path to existing backup directory')
+  .option('--force', 'Skip confirmation prompts')
+  .action(cloneMongodb);
+
 // Status & Monitoring
 program
   .command('status')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ante-erp-cli",
-  "version": "1.9.7",
+  "version": "1.9.8",
   "description": "Comprehensive CLI tool for managing ANTE ERP self-hosted installations",
   "type": "module",
   "bin": {

package/src/commands/clone-mongodb.js

@@ -0,0 +1,290 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { join } from 'path';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { stat } from 'fs/promises';
+import { getInstallDir } from '../utils/config.js';
+import {
+  parseMongoUrl,
+  buildMongoUrl,
+  testConnection,
+  dumpDatabase,
+  restoreDatabase,
+  verifyDataRestored
+} from '../utils/mongodb.js';
+
+/**
+ * Build MONGODB_URI for installed ANTE instance
+ * @param {string} installDir - Installation directory
+ * @returns {string} MONGODB_URI for local MongoDB
+ */
+function readMongoDbUri(installDir) {
+  const envFile = join(installDir, '.env');
+
+  if (!existsSync(envFile)) {
+    throw new Error(
+      '.env file not found. This command is for installed ANTE instances only.\n' +
+      'For development environments, use the appropriate script.'
+    );
+  }
+
+  const envContent = readFileSync(envFile, 'utf-8');
+
+  // Try to find MONGODB_URI or MONGODB_URL
+  let match = envContent.match(/^MONGODB_URI=(.+)$/m);
+  if (!match) {
+    match = envContent.match(/^MONGODB_URL=(.+)$/m);
+  }
+
+  if (!match) {
+    throw new Error('MONGODB_URI or MONGODB_URL not found in .env file');
+  }
+
+  const mongoUri = match[1].trim();
+
+  // Validate it looks like a MongoDB URI
+  if (!mongoUri.startsWith('mongodb://') && !mongoUri.startsWith('mongodb+srv://')) {
+    throw new Error('Invalid MongoDB URI format in .env file');
+  }
+
+  return mongoUri;
+}
+
+/**
+ * Clone remote MongoDB database to local database
+ * @param {string} sourceUrl - Source MongoDB URL
+ * @param {Object} options - Command options
+ */
+export async function cloneMongodb(sourceUrl, options = {}) {
+  try {
+    console.log('');
+    console.log(chalk.blue('╔════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.blue('║          ANTE CLI - Clone MongoDB Database                ║'));
+    console.log(chalk.blue('╚════════════════════════════════════════════════════════════╝'));
+    console.log('');
+
+    // Get ANTE installation directory
+    const installDir = getInstallDir();
+    const backupDir = join(installDir, 'backups', 'mongodb');
+    const composeFile = join(installDir, 'docker-compose.yml');
+
+    // Step 1: Parse source database URL
+    console.log(chalk.yellow('Step 1/5: Parsing source database URL...'));
+    let sourceInfo;
+    try {
+      sourceInfo = parseMongoUrl(sourceUrl);
+      console.log(chalk.green('✓ Source URL parsed successfully'));
+      console.log(chalk.gray(`  Host: ${sourceInfo.host}${sourceInfo.port ? ':' + sourceInfo.port : ' (SRV)'}`));
+      console.log(chalk.gray(`  Database: ${sourceInfo.database}`));
+      console.log(chalk.gray(`  User: ${sourceInfo.user || '(none)'}`));
+      if (sourceInfo.authDatabase && sourceInfo.authDatabase !== sourceInfo.database) {
+        console.log(chalk.gray(`  Auth Database: ${sourceInfo.authDatabase}`));
+      }
+      console.log('');
+    } catch (error) {
+      throw new Error(`Failed to parse source URL: ${error.message}`);
+    }
+
+    // Step 2: Parse local database URL
+    console.log(chalk.yellow('Step 2/5: Reading local database configuration...'));
+    const localMongoUri = readMongoDbUri(installDir);
+    if (!localMongoUri) {
+      throw new Error('.env file not found or MONGODB_URI not set');
+    }
+
+    let localInfo;
+    try {
+      localInfo = parseMongoUrl(localMongoUri);
+      console.log(chalk.green('✓ Local database configuration loaded'));
+      console.log(chalk.gray(`  Host: ${localInfo.host}${localInfo.port ? ':' + localInfo.port : ' (SRV)'}`));
+      console.log(chalk.gray(`  Database: ${localInfo.database}`));
+      console.log(chalk.gray(`  User: ${localInfo.user || '(none)'}`));
+      console.log('');
+    } catch (error) {
+      throw new Error(`Failed to parse local MONGODB_URI: ${error.message}`);
+    }
+
+    // Step 3: Test connections
+    console.log(chalk.yellow('Step 3/5: Testing database connections...'));
+
+    // Test source connection
+    const sourceSpinner = ora('Testing source database connection...').start();
+    const sourceTest = await testConnection(sourceInfo);
+    if (!sourceTest.success) {
+      sourceSpinner.fail(chalk.red('Source database connection failed'));
+      throw new Error(`Cannot connect to source database: ${sourceTest.error}`);
+    }
+    sourceSpinner.succeed(chalk.green('Source database connection successful'));
+
+    // Test local connection (use Docker Compose for installed ANTE)
+    const localSpinner = ora('Testing local database connection...').start();
+    const localTest = await testConnection(localInfo, composeFile);
+    if (!localTest.success) {
+      localSpinner.fail(chalk.red('Local database connection failed'));
+      throw new Error(`Cannot connect to local database: ${localTest.error}`);
+    }
+    localSpinner.succeed(chalk.green('Local database connection successful'));
+    console.log('');
+
+    // Step 4: Confirmation
+    if (!options.force) {
+      console.log(chalk.yellow('⚠️  WARNING: This will DROP and REPLACE your local database collections!'));
+      console.log(chalk.yellow('⚠️  All existing local data will be LOST!'));
+      console.log('');
+      console.log(chalk.blue('Configuration Summary:'));
+      console.log(chalk.gray('┌─ Source Database:'));
+      console.log(chalk.gray(`│  Host: ${sourceInfo.host}${sourceInfo.port ? ':' + sourceInfo.port : ' (SRV)'}`));
+      console.log(chalk.gray(`│  Database: ${sourceInfo.database}`));
+      console.log(chalk.gray('│'));
+      console.log(chalk.gray('└─ Target Database (Local):'));
+      console.log(chalk.gray(`   Host: ${localInfo.host}${localInfo.port ? ':' + localInfo.port : ' (SRV)'}`));
+      console.log(chalk.gray(`   Database: ${localInfo.database}`));
+      console.log('');
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Do you want to continue?',
+          default: false
+        }
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.gray('\nClone cancelled by user.'));
+        return;
+      }
+      console.log('');
+    }
+
+    // Step 5: Dump source database (if not skipped)
+    let dumpDirectory;
+    if (options.skipDump && options.backupDir) {
+      console.log(chalk.yellow('Step 4/5: Using existing backup directory...'));
+      dumpDirectory = options.backupDir;
+
+      if (!existsSync(dumpDirectory)) {
+        throw new Error(`Backup directory not found: ${dumpDirectory}`);
+      }
+
+      // Verify backup contains database folder with BSON files
+      const dbDumpDir = join(dumpDirectory, sourceInfo.database);
+      if (!existsSync(dbDumpDir)) {
+        throw new Error(`Database dump folder not found: ${dbDumpDir}`);
+      }
+
+      const files = readdirSync(dbDumpDir);
+      const bsonFiles = files.filter(f => f.endsWith('.bson'));
+
+      if (bsonFiles.length === 0) {
+        throw new Error(`No BSON files found in backup directory: ${dbDumpDir}`);
+      }
+
+      // Calculate total size
+      let totalSize = 0;
+      for (const file of files) {
+        const filePath = join(dbDumpDir, file);
+        const stats = await stat(filePath);
+        totalSize += stats.size;
+      }
+
+      const sizeInMB = (totalSize / (1024 * 1024)).toFixed(2);
+      const size = sizeInMB >= 1 ? `${sizeInMB} MB` : `${(totalSize / 1024).toFixed(2)} KB`;
+
+      console.log(chalk.green('✓ Using existing backup'));
+      console.log(chalk.gray(`  Directory: ${dumpDirectory}`));
+      console.log(chalk.gray(`  Collections: ${bsonFiles.length}`));
+      console.log(chalk.gray(`  Size: ${size}`));
+      console.log('');
+    } else {
+      console.log(chalk.yellow('Step 4/5: Dumping source database...'));
+      console.log(chalk.gray('This may take several minutes depending on database size...'));
+      console.log('');
+
+      const timestamp = new Date().toISOString().split('.')[0].replace(/:/g, '-').replace('T', '_');
+      dumpDirectory = join(backupDir, `clone-backup-${timestamp}`);
+
+      const dumpSpinner = ora('Creating database dump...').start();
+      const dumpResult = await dumpDatabase(sourceInfo, dumpDirectory);
+
+      if (!dumpResult.success) {
+        dumpSpinner.fail(chalk.red('Database dump failed'));
+        throw new Error(dumpResult.error);
+      }
+
+      dumpSpinner.succeed(chalk.green('Database dump completed'));
+      console.log(chalk.gray(`  Directory: ${dumpResult.dir}`));
+      console.log(chalk.gray(`  Collections: ${dumpResult.collections}`));
+      console.log(chalk.gray(`  Size: ${dumpResult.size}`));
+      console.log('');
+    }
+
+    // Step 6: Restore to local database
+    console.log(chalk.yellow('Step 5/5: Restoring to local database...'));
+    console.log(chalk.gray('This may take several minutes...'));
+    console.log('');
+
+    const restoreSpinner = ora('Restoring database (collections will be dropped and recreated)...').start();
+    const restoreResult = await restoreDatabase(dumpDirectory, localInfo, true, composeFile);
+
+    if (!restoreResult.success) {
+      restoreSpinner.fail(chalk.red('Database restore failed'));
+      throw new Error(restoreResult.error);
+    }
+
+    restoreSpinner.succeed(chalk.green('Database restore completed'));
+    console.log('');
+
+    // Step 6A: Verify data was restored
+    const verifySpinner = ora('Verifying data restoration...').start();
+    const verifyResult = await verifyDataRestored(localInfo, composeFile);
+
+    if (!verifyResult.success) {
+      verifySpinner.fail(chalk.red('Data verification failed'));
+      console.log(chalk.yellow('  Warning: Could not verify data restoration'));
+    } else {
+      verifySpinner.succeed(chalk.green(`Verified: ${verifyResult.collectionCount} collections, ${verifyResult.totalDocuments.toLocaleString()} documents restored`));
+
+      // Warn if no data was restored
+      if (verifyResult.totalDocuments === 0) {
+        console.log(chalk.red('\n⚠️  WARNING: No documents were restored!'));
+        console.log(chalk.yellow('  Possible causes:'));
+        console.log(chalk.gray('  - Source database was empty'));
+        console.log(chalk.gray('  - Authentication issues prevented data restore'));
+        console.log(chalk.gray('  - Permission issues with target database'));
+        console.log(chalk.gray('  - Data restore errors were silently ignored\n'));
+      }
+    }
+    console.log('');
+
+    // Final summary
+    console.log(chalk.green('╔════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.green('║          Database Clone Completed Successfully!           ║'));
+    console.log(chalk.green('╚════════════════════════════════════════════════════════════╝'));
+    console.log('');
+    console.log(chalk.blue('Summary:'));
+    console.log(chalk.gray(`  ✓ Source database dumped to: ${dumpDirectory}`));
+    console.log(chalk.gray(`  ✓ Restored to local database: ${localInfo.database}`));
+
+    // Show data restoration summary
+    if (verifyResult && verifyResult.success) {
+      if (verifyResult.totalDocuments > 0) {
+        console.log(chalk.green(`  ✓ Data restored: ${verifyResult.totalDocuments.toLocaleString()} documents across ${verifyResult.collectionCount} collections`));
+      } else {
+        console.log(chalk.red(`  ✗ No data restored (${verifyResult.collectionCount} collections created but empty)`));
+      }
+    }
+
+    console.log('');
+    console.log(chalk.cyan('Your local MongoDB database is now cloned from the source!'));
+    console.log(chalk.gray('You can start your services with: ante start'));
+    console.log('');
+
+  } catch (error) {
+    console.log('');
+    console.error(chalk.red('✗ MongoDB clone failed:'), error.message);
+    console.log('');
+    process.exit(1);
+  }
+}

package/src/commands/install.js

@@ -483,6 +483,18 @@ export async function install(options) {
         apiDomain = buildURL(manualConfig.hostIp, 3001);
       }
 
+      // Determine which frontends to install based on flags
+      const installAllFrontends = options.withAllFrontends;
+      const installGate = installAllFrontends || options.withGate;
+      const installGuardian = installAllFrontends || options.withGuardian;
+      const installFacial = installAllFrontends || options.withFacial;
+
+      // Build frontends array
+      const frontends = ['main'];
+      if (installGate) frontends.push('gate');
+      if (installGuardian) frontends.push('guardian');
+      if (installFacial) frontends.push('facial');
+
       config = {
         installDir: options.dir,
         preset: options.preset || 'standard',
@@ -492,12 +504,15 @@ export async function install(options) {
         apiPort: 3001,
         gateAppPort: 8081,
         guardianAppPort: 8082,
+        facialWebPort: 8083,
         gateAppDomain: buildURL(detectedIP || 'localhost', 8081),
         guardianAppDomain: buildURL(detectedIP || 'localhost', 8082),
+        facialAppDomain: buildURL(detectedIP || 'localhost', 8083),
         companyId: 1,
-        installGate: false,
-        installGuardian: false,
-        frontends: ['main']
+        installGate,
+        installGuardian,
+        installFacial,
+        frontends
       };
     }
 

package/src/utils/mongodb.js

@@ -0,0 +1,463 @@
+import { execa } from 'execa';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { stat } from 'fs/promises';
+
+/**
+ * Parse MongoDB connection URL
+ * @param {string} url - MongoDB connection URL (e.g., mongodb://user:pass@host:port/db or mongodb+srv://...)
+ * @returns {Object} Connection info { user, password, host, port, database, authDatabase, isSrv }
+ */
+export function parseMongoUrl(url) {
+  try {
+    // Check if it's an SRV connection string
+    const isSrv = url.startsWith('mongodb+srv://');
+
+    // Remove protocol prefix (mongodb://, mongodb+srv://)
+    const withoutProtocol = url.replace(/^mongodb(\+srv)?:\/\//, '');
+
+    // Extract components using regex
+    const userMatch = withoutProtocol.match(/^([^:]+):/);
+    const passwordMatch = withoutProtocol.match(/:([^@]+)@/);
+    const hostMatch = withoutProtocol.match(/@([^:/]+)/);
+    const portMatch = withoutProtocol.match(/:(\d+)\//);
+    const databaseMatch = withoutProtocol.match(/\/([^?]+)/);
+    const authDatabaseMatch = withoutProtocol.match(/[?&]authSource=([^&]+)/);
+
+    // Extract values
+    const user = userMatch ? userMatch[1] : null;
+    const password = passwordMatch ? passwordMatch[1] : null;
+    const host = hostMatch ? hostMatch[1] : null;
+    const port = portMatch ? portMatch[1] : (isSrv ? null : '27017'); // SRV doesn't use explicit port
+    const database = databaseMatch ? databaseMatch[1].split('?')[0] : null; // Remove query params
+    const authDatabase = authDatabaseMatch ? authDatabaseMatch[1] : (database || 'admin');
+
+    // Validate required fields
+    if (!host || !database) {
+      throw new Error('Invalid MongoDB URL format. Expected: mongodb://[user:password@]host[:port]/database or mongodb+srv://...');
+    }
+
+    return {
+      user,
+      password,
+      host,
+      port,
+      database,
+      authDatabase,
+      isSrv
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse MongoDB URL: ${error.message}`);
+  }
+}
+
+/**
+ * Build MongoDB connection string from connection info
+ * @param {Object} connectionInfo - Connection details from parseMongoUrl
+ * @returns {string} MongoDB connection string
+ */
+export function buildMongoUrl(connectionInfo) {
+  const { user, password, host, port, database, authDatabase, isSrv } = connectionInfo;
+
+  const protocol = isSrv ? 'mongodb+srv://' : 'mongodb://';
+  const auth = user && password ? `${user}:${password}@` : '';
+  const portPart = port && !isSrv ? `:${port}` : '';
+  const authDbPart = authDatabase && authDatabase !== database ? `?authSource=${authDatabase}` : '';
+
+  return `${protocol}${auth}${host}${portPart}/${database}${authDbPart}`;
+}
+
+/**
+ * Test MongoDB connection using Docker
+ * @param {Object} connectionInfo - Connection details from parseMongoUrl
+ * @param {string} composeFile - Optional path to docker-compose.yml for Docker Compose network access
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function testConnection(connectionInfo, composeFile = null) {
+  try {
+    const mongoUrl = buildMongoUrl(connectionInfo);
+
+    // If composeFile provided, use Docker Compose exec (for local database in Docker network)
+    if (composeFile) {
+      await execa('docker', [
+        'compose',
+        '-f', composeFile,
+        'exec',
+        '-T',
+        'mongo',
+        'mongosh',
+        mongoUrl,
+        '--quiet',
+        '--eval', 'db.adminCommand("ping")'
+      ], {
+        timeout: 10000 // 10 second timeout
+      });
+
+      return { success: true };
+    }
+
+    // Standalone Docker for remote databases
+    let testUrl = mongoUrl;
+    const dockerArgs = ['run', '--rm'];
+
+    // Handle localhost connections
+    if (connectionInfo.host === 'localhost' || connectionInfo.host === '127.0.0.1') {
+      const protocol = connectionInfo.isSrv ? 'mongodb+srv://' : 'mongodb://';
+      const auth = connectionInfo.user && connectionInfo.password ?
+        `${connectionInfo.user}:${connectionInfo.password}@` : '';
+      const portPart = connectionInfo.port && !connectionInfo.isSrv ? `:${connectionInfo.port}` : '';
+      const authDbPart = connectionInfo.authDatabase && connectionInfo.authDatabase !== connectionInfo.database ?
+        `?authSource=${connectionInfo.authDatabase}` : '';
+
+      testUrl = `${protocol}${auth}host.docker.internal${portPart}/${connectionInfo.database}${authDbPart}`;
+      dockerArgs.push('--add-host=host.docker.internal:host-gateway');
+    }
+
+    dockerArgs.push(
+      'mongo:latest',
+      'mongosh',
+      testUrl,
+      '--quiet',
+      '--eval', 'db.adminCommand("ping")'
+    );
+
+    // Use Docker to test connection
+    await execa('docker', dockerArgs, {
+      timeout: 10000 // 10 second timeout
+    });
+
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || 'Connection failed'
+    };
+  }
+}
+
+/**
+ * Dump MongoDB database to directory using Docker
+ * @param {Object} connectionInfo - Connection details
+ * @param {string} outputDir - Absolute path to output directory
+ * @returns {Promise<{success: boolean, dir: string, size: string, collections: number, error?: string}>}
+ */
+export async function dumpDatabase(connectionInfo, outputDir) {
+  try {
+    const { user, password, host, port, database, authDatabase, isSrv } = connectionInfo;
+
+    // Ensure backup directory exists
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Convert to absolute path for Docker volume mount
+    const absoluteOutputDir = resolve(outputDir);
+
+    // Build mongodump arguments
+    const dumpArgs = ['run', '--rm', '-v', `${absoluteOutputDir}:/backups`, 'mongo:latest', 'mongodump'];
+
+    // Build connection URI
+    let dumpHost = host;
+    if (host === 'localhost' || host === '127.0.0.1') {
+      dumpHost = 'host.docker.internal';
+      dumpArgs.splice(1, 0, '--add-host=host.docker.internal:host-gateway');
+    }
+
+    // Add connection parameters
+    if (isSrv) {
+      // For SRV connections, use --uri
+      const protocol = 'mongodb+srv://';
+      const auth = user && password ? `${user}:${password}@` : '';
+      const authDbPart = authDatabase && authDatabase !== database ? `?authSource=${authDatabase}` : '';
+      const uri = `${protocol}${auth}${dumpHost}/${database}${authDbPart}`;
+      dumpArgs.push('--uri', uri);
+    } else {
+      // For standard connections, use individual parameters
+      dumpArgs.push('--host', dumpHost);
+      if (port) dumpArgs.push('--port', port);
+      if (user) dumpArgs.push('--username', user);
+      if (password) dumpArgs.push('--password', password);
+      if (authDatabase) dumpArgs.push('--authenticationDatabase', authDatabase);
+      dumpArgs.push('--db', database);
+    }
+
+    // Output directory
+    dumpArgs.push('--out', '/backups');
+
+    // Execute mongodump
+    await execa('docker', dumpArgs, {
+      timeout: 600000 // 10 minute timeout
+    });
+
+    // Verify dump directory was created and has content
+    const dumpDbDir = join(outputDir, database);
+    if (!existsSync(dumpDbDir)) {
+      throw new Error('Dump directory was not created');
+    }
+
+    // Count collections (BSON files)
+    const files = readdirSync(dumpDbDir);
+    const bsonFiles = files.filter(f => f.endsWith('.bson'));
+    const collections = bsonFiles.length;
+
+    if (collections === 0) {
+      throw new Error('No collections were dumped. Database might be empty or connection failed.');
+    }
+
+    // Calculate total size
+    let totalSize = 0;
+    for (const file of files) {
+      const filePath = join(dumpDbDir, file);
+      const stats = await stat(filePath);
+      totalSize += stats.size;
+    }
+
+    // Get size in human-readable format
+    const sizeInMB = (totalSize / (1024 * 1024)).toFixed(2);
+    const size = sizeInMB >= 1 ? `${sizeInMB} MB` : `${(totalSize / 1024).toFixed(2)} KB`;
+
+    return {
+      success: true,
+      dir: outputDir,
+      size,
+      collections
+    };
+  } catch (error) {
+    return {
+      success: false,
+      dir: outputDir,
+      size: '0 KB',
+      collections: 0,
+      error: error.message || 'Dump failed'
+    };
+  }
+}
+
+/**
+ * Restore MongoDB database from dump directory using Docker
+ * @param {string} dumpDir - Path to dump directory (contains database folder with .bson files)
+ * @param {Object} connectionInfo - Target database connection details
+ * @param {boolean} dropBeforeRestore - Whether to drop collections before restore (default: true)
+ * @param {string} composeFile - Optional path to docker-compose.yml for Docker Compose network access
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function restoreDatabase(dumpDir, connectionInfo, dropBeforeRestore = true, composeFile = null) {
+  try {
+    const { user, password, host, port, database, authDatabase, isSrv } = connectionInfo;
+
+    // Verify dump directory exists
+    const dumpDbDir = join(dumpDir, database);
+    if (!existsSync(dumpDbDir)) {
+      throw new Error(`Dump directory not found: ${dumpDbDir}`);
+    }
+
+    // Verify BSON files exist
+    const files = readdirSync(dumpDbDir);
+    const bsonFiles = files.filter(f => f.endsWith('.bson'));
+    if (bsonFiles.length === 0) {
+      throw new Error(`No BSON files found in dump directory: ${dumpDbDir}`);
+    }
+
+    // If using Docker Compose (for local database in Docker network)
+    if (composeFile) {
+      // Copy dump directory into mongo container
+      const containerDumpDir = `/tmp/mongodump_${Date.now()}`;
+      await execa('docker', [
+        'cp',
+        dumpDir,
+        `ante-mongo:${containerDumpDir}`
+      ], {
+        timeout: 120000 // 2 minute timeout for large files
+      });
+
+      try {
+        // Build mongorestore command
+        const restoreArgs = [
+          'compose',
+          '-f', composeFile,
+          'exec',
+          '-T',
+          'mongo',
+          'mongorestore'
+        ];
+
+        // Add connection parameters
+        if (user) restoreArgs.push('--username', user);
+        if (password) restoreArgs.push('--password', password);
+        if (authDatabase) restoreArgs.push('--authenticationDatabase', authDatabase);
+        restoreArgs.push('--db', database);
+
+        // Drop collections before restore if requested
+        if (dropBeforeRestore) {
+          restoreArgs.push('--drop');
+        }
+
+        // Add dump directory path
+        restoreArgs.push(`${containerDumpDir}/${database}`);
+
+        // Restore from inside the container
+        await execa('docker', restoreArgs, {
+          timeout: 600000, // 10 minute timeout
+          reject: false    // Don't reject on non-zero exit (mongorestore might have warnings)
+        });
+      } finally {
+        // Clean up: Remove dump directory from container
+        try {
+          await execa('docker', [
+            'compose',
+            '-f', composeFile,
+            'exec',
+            '-T',
+            'mongo',
+            'rm',
+            '-rf',
+            containerDumpDir
+          ], {
+            timeout: 10000,
+            reject: false
+          });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+
+      return { success: true };
+    }
+
+    // Standalone Docker for remote databases
+    const absoluteDumpDir = resolve(dumpDir);
+    const restoreArgs = ['run', '--rm', '-v', `${absoluteDumpDir}:/backups`, 'mongo:latest', 'mongorestore'];
+
+    // Build connection URI or parameters
+    let restoreHost = host;
+    if (host === 'localhost' || host === '127.0.0.1') {
+      restoreHost = 'host.docker.internal';
+      restoreArgs.splice(1, 0, '--add-host=host.docker.internal:host-gateway');
+    }
+
+    // Add connection parameters
+    if (isSrv) {
+      // For SRV connections, use --uri
+      const protocol = 'mongodb+srv://';
+      const auth = user && password ? `${user}:${password}@` : '';
+      const authDbPart = authDatabase && authDatabase !== database ? `?authSource=${authDatabase}` : '';
+      const uri = `${protocol}${auth}${restoreHost}/${database}${authDbPart}`;
+      restoreArgs.push('--uri', uri);
+    } else {
+      // For standard connections, use individual parameters
+      restoreArgs.push('--host', restoreHost);
+      if (port) restoreArgs.push('--port', port);
+      if (user) restoreArgs.push('--username', user);
+      if (password) restoreArgs.push('--password', password);
+      if (authDatabase) restoreArgs.push('--authenticationDatabase', authDatabase);
+      restoreArgs.push('--db', database);
+    }
+
+    // Drop collections before restore if requested
+    if (dropBeforeRestore) {
+      restoreArgs.push('--drop');
+    }
+
+    // Add dump directory path
+    restoreArgs.push(`/backups/${database}`);
+
+    // Execute mongorestore
+    await execa('docker', restoreArgs, {
+      timeout: 600000, // 10 minute timeout
+      reject: false    // Don't reject on non-zero exit (mongorestore might have warnings)
+    });
+
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || 'Restore failed'
+    };
+  }
+}
+
+/**
+ * Verify data was restored by counting collections and documents
+ * @param {Object} connectionInfo - Connection details
+ * @param {string} composeFile - Optional path to docker-compose.yml
+ * @returns {Promise<{success: boolean, collectionCount: number, totalDocuments: number, error?: string}>}
+ */
+export async function verifyDataRestored(connectionInfo, composeFile = null) {
+  try {
+    const mongoUrl = buildMongoUrl(connectionInfo);
+
+    // JavaScript to execute in MongoDB
+    const verifyScript = `
+      const collections = db.getCollectionNames();
+      let totalDocs = 0;
+      for (const coll of collections) {
+        totalDocs += db.getCollection(coll).countDocuments();
+      }
+      print(JSON.stringify({ collections: collections.length, documents: totalDocs }));
+    `;
+
+    let result;
+
+    if (composeFile) {
+      // Use Docker Compose exec
+      result = await execa('docker', [
+        'compose',
+        '-f', composeFile,
+        'exec',
+        '-T',
+        'mongo',
+        'mongosh',
+        mongoUrl,
+        '--quiet',
+        '--eval', verifyScript
+      ], {
+        timeout: 30000 // 30 second timeout
+      });
+    } else {
+      // Standalone Docker
+      let testUrl = mongoUrl;
+      const dockerArgs = ['run', '--rm'];
+
+      if (connectionInfo.host === 'localhost' || connectionInfo.host === '127.0.0.1') {
+        const protocol = connectionInfo.isSrv ? 'mongodb+srv://' : 'mongodb://';
+        const auth = connectionInfo.user && connectionInfo.password ?
+          `${connectionInfo.user}:${connectionInfo.password}@` : '';
+        const portPart = connectionInfo.port && !connectionInfo.isSrv ? `:${connectionInfo.port}` : '';
+        const authDbPart = connectionInfo.authDatabase && connectionInfo.authDatabase !== connectionInfo.database ?
+          `?authSource=${connectionInfo.authDatabase}` : '';
+
+        testUrl = `${protocol}${auth}host.docker.internal${portPart}/${connectionInfo.database}${authDbPart}`;
+        dockerArgs.push('--add-host=host.docker.internal:host-gateway');
+      }
+
+      dockerArgs.push(
+        'mongo:latest',
+        'mongosh',
+        testUrl,
+        '--quiet',
+        '--eval', verifyScript
+      );
+
+      result = await execa('docker', dockerArgs, {
+        timeout: 30000 // 30 second timeout
+      });
+    }
+
+    // Parse output
+    const output = result.stdout.trim();
+    const stats = JSON.parse(output);
+
+    return {
+      success: true,
+      collectionCount: stats.collections,
+      totalDocuments: stats.documents
+    };
+  } catch (error) {
+    return {
+      success: false,
+      collectionCount: 0,
+      totalDocuments: 0,
+      error: error.message || 'Failed to verify data'
+    };
+  }
+}