ante-erp-cli 1.9.7 → 1.9.9

package/bin/ante-cli.js

@@ -32,6 +32,8 @@ 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 { exposeDbPorts, secureDbPorts, dbPortStatus } from '../src/commands/database-ports.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 +49,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 +158,37 @@ 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);
+
+dbCmd
+  .command('expose')
+  .description('Expose database ports for external access (DEVELOPMENT ONLY)')
+  .option('--postgres', 'Expose only PostgreSQL (5432)')
+  .option('--redis', 'Expose only Redis (6379)')
+  .option('--mongodb', 'Expose only MongoDB (27017)')
+  .option('--all', 'Expose all databases (default)', true)
+  .option('--force', 'Skip confirmation prompts')
+  .option('--no-restart', 'Don\'t restart services automatically')
+  .action(exposeDbPorts);
+
+dbCmd
+  .command('secure')
+  .description('Remove database port bindings (secure databases)')
+  .option('--force', 'Skip confirmation prompts')
+  .option('--no-restart', 'Don\'t restart services automatically')
+  .action(secureDbPorts);
+
+dbCmd
+  .command('port-status')
+  .description('Show database port exposure status')
+  .action(dbPortStatus);
+
 // Status & Monitoring
 program
   .command('status')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ante-erp-cli",
-  "version": "1.9.7",
+  "version": "1.9.9",
   "description": "Comprehensive CLI tool for managing ANTE ERP self-hosted installations",
   "type": "module",
   "bin": {
@@ -42,25 +42,25 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "commander": "^12.0.0",
-    "inquirer": "^9.2.0",
-    "chalk": "^5.3.0",
-    "ora": "^8.0.0",
     "boxen": "^7.1.0",
-    "execa": "^8.0.0",
-    "listr2": "^8.0.0",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.3",
+    "commander": "^12.0.0",
     "conf": "^12.0.0",
     "dotenv": "^16.4.0",
-    "js-yaml": "^4.1.0",
-    "semver": "^7.6.0",
-    "update-notifier": "^7.0.0",
+    "execa": "^8.0.0",
+    "inquirer": "^9.2.0",
+    "js-yaml": "^4.1.1",
+    "listr2": "^8.0.0",
     "node-fetch": "^3.3.0",
-    "cli-table3": "^0.6.3",
-    "prompts": "^2.4.2"
+    "ora": "^8.0.0",
+    "prompts": "^2.4.2",
+    "semver": "^7.6.0",
+    "update-notifier": "^7.0.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "prettier": "^3.2.0",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "prettier": "^3.2.0"
   }
 }

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);
+  }
+}