ante-erp-cli 1.11.30 → 1.11.31

package/bin/ante-cli.js

@@ -241,10 +241,13 @@ dbCmd
 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('--postgres', 'Expose only PostgreSQL')
+  .option('--redis', 'Expose only Redis')
+  .option('--mongodb', 'Expose only MongoDB')
   .option('--all', 'Expose all databases (default)', true)
+  .option('--postgres-port <port>', 'Custom host port for PostgreSQL (default: random)')
+  .option('--redis-port <port>', 'Custom host port for Redis (default: random)')
+  .option('--mongodb-port <port>', 'Custom host port for MongoDB (default: random)')
   .option('--force', 'Skip confirmation prompts')
   .option('--no-restart', 'Don\'t restart services automatically')
   .action(exposeDbPorts);

package/package.json

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

package/src/commands/database-ports.js

@@ -169,11 +169,14 @@ export async function exposeDbPorts(options) {
     );
 
     // Add port bindings
-    spinner.start('Adding port bindings...');
-    const { exposed } = await exposeDatabasePorts(composeFile, {
+    spinner.start('Finding available ports and adding bindings...');
+    const { exposed, portMappings } = await exposeDatabasePorts(composeFile, {
       postgres: databases.includes('postgres'),
       redis: databases.includes('redis'),
       mongodb: databases.includes('mongodb'),
+      postgresPort: options.postgresPort ? parseInt(options.postgresPort) : null,
+      redisPort: options.redisPort ? parseInt(options.redisPort) : null,
+      mongodbPort: options.mongodbPort ? parseInt(options.mongodbPort) : null,
     });
     spinner.succeed(chalk.green('Port bindings added'));
 
@@ -195,10 +198,26 @@ export async function exposeDbPorts(options) {
     console.log(chalk.green.bold('✓ Database ports exposed!'));
     console.log();
 
+    // Display assigned ports
+    console.log(chalk.cyan.bold('Assigned Ports:'));
+    Object.entries(portMappings).forEach(([db, mapping]) => {
+      const dbInfo = {
+        postgres: 'PostgreSQL',
+        redis: 'Redis',
+        mongodb: 'MongoDB',
+      };
+      console.log(
+        chalk.cyan(
+          `  ${dbInfo[db]}: Host Port ${chalk.bold(mapping.hostPort)} → Container Port ${mapping.containerPort}`
+        )
+      );
+    });
+    console.log();
+
     // Display connection strings
     const serverIP = getServerIP();
     const credentials = getCredentials(installDir);
-    const examples = getConnectionExamples(exposed, serverIP, credentials);
+    const examples = getConnectionExamples(portMappings, serverIP, credentials);
     console.log(chalk.cyan.bold('Connection strings:'));
     Object.values(examples).forEach((ex) => {
       console.log(chalk.cyan(`  ${ex.name}: ${ex.example}`));
@@ -206,7 +225,7 @@ export async function exposeDbPorts(options) {
     console.log();
 
     // Display firewall configuration guide
-    const rules = getFirewallRules(exposed);
+    const rules = getFirewallRules(portMappings);
     console.log(chalk.yellow.bold('💡 Configure firewall for security:'));
     rules.forEach((rule) => {
       console.log(chalk.yellow(`  ${rule}`));
@@ -250,7 +269,9 @@ export async function secureDbPorts(options) {
     console.log(chalk.cyan('Currently exposed database ports:'));
     exposedDbs.forEach((db) => {
       console.log(
-        chalk.cyan(`  • ${status[db].name}: ${status[db].port}`)
+        chalk.cyan(
+          `  • ${status[db].name}: ${status[db].mapping} (Host: ${status[db].hostPort})`
+        )
       );
     });
     console.log();
@@ -332,12 +353,14 @@ export async function dbPortStatus() {
 
     let anyExposed = false;
 
-    Object.entries(status).forEach(([db, info]) => {
+    Object.entries(status).forEach(([_db, info]) => {
       const statusIcon = info.exposed ? chalk.yellow('🔓') : chalk.green('🔒');
       const statusText = info.exposed
         ? chalk.yellow('EXPOSED')
         : chalk.green('SECURED');
-      const portText = info.exposed ? chalk.cyan(`Port: ${info.port}`) : '';
+      const portText = info.exposed
+        ? chalk.cyan(`Port Mapping: ${info.mapping} (Host: ${info.hostPort})`)
+        : '';
 
       console.log(
         `${statusIcon} ${chalk.bold(info.name)}: ${statusText} ${portText}`

package/src/utils/database-ports.js

@@ -1,7 +1,57 @@
 import fs from 'fs/promises';
 import yaml from 'js-yaml';
-import path from 'path';
-import chalk from 'chalk';
+import net from 'net';
+
+/**
+ * Check if a port is available
+ * @param {number} port - Port number to check
+ * @returns {Promise<boolean>} True if port is available
+ */
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+
+    server.listen(port, '0.0.0.0');
+  });
+}
+
+/**
+ * Find an available port within a range
+ * @param {number} preferredPort - Preferred port number (optional)
+ * @param {number} rangeStart - Start of port range (default: 49152)
+ * @param {number} rangeEnd - End of port range (default: 65535)
+ * @param {number} maxAttempts - Maximum number of attempts (default: 100)
+ * @returns {Promise<number>} Available port number
+ */
+async function findAvailablePort(preferredPort = null, rangeStart = 49152, rangeEnd = 65535, maxAttempts = 100) {
+  // If preferred port is provided and available, use it
+  if (preferredPort && await isPortAvailable(preferredPort)) {
+    return preferredPort;
+  }
+
+  // Try to find a random available port
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const randomPort = Math.floor(Math.random() * (rangeEnd - rangeStart + 1)) + rangeStart;
+    if (await isPortAvailable(randomPort)) {
+      return randomPort;
+    }
+  }
+
+  throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
+}
 
 /**
  * Database port configurations
@@ -10,20 +60,23 @@ const DATABASE_PORTS = {
   postgres: {
     name: 'PostgreSQL',
     service: 'postgres',
-    port: '5432:5432',
-    connectionExample: (host, password) => `postgresql://ante:${password}@${host}:5432/ante_db`,
+    containerPort: 5432,
+    defaultHostPort: 5432,
+    connectionExample: (host, hostPort, password) => `postgresql://ante:${password}@${host}:${hostPort}/ante_db`,
   },
   redis: {
     name: 'Redis',
     service: 'redis',
-    port: '6379:6379',
-    connectionExample: (host, password) => `redis://${host}:6379 (password: ${password})`,
+    containerPort: 6379,
+    defaultHostPort: 6379,
+    connectionExample: (host, hostPort, password) => `redis://${host}:${hostPort} (password: ${password})`,
   },
   mongodb: {
     name: 'MongoDB',
     service: 'mongodb',
-    port: '27017:27017',
-    connectionExample: (host, password) => `mongodb://ante:${password}@${host}:27017/ante`,
+    containerPort: 27017,
+    defaultHostPort: 27017,
+    connectionExample: (host, hostPort, password) => `mongodb://ante:${password}@${host}:${hostPort}/ante`,
   },
 };
 
@@ -69,10 +122,18 @@ async function writeComposeFile(composeFile, doc) {
  * Add port bindings to database services
  * @param {string} composeFile - Path to docker-compose.yml
  * @param {Object} options - Port exposure options
- * @returns {Promise<Object>} Result object with exposed services
+ * @returns {Promise<Object>} Result object with exposed services and their ports
  */
 export async function exposeDatabasePorts(composeFile, options = {}) {
-  const { postgres = true, redis = true, mongodb = true } = options;
+  const {
+    postgres = true,
+    redis = true,
+    mongodb = true,
+    postgresPort = null,
+    redisPort = null,
+    mongodbPort = null,
+  } = options;
+
   const doc = await readComposeFile(composeFile);
 
   if (!doc.services) {
@@ -80,6 +141,7 @@ export async function exposeDatabasePorts(composeFile, options = {}) {
   }
 
   const exposed = [];
+  const portMappings = {};
 
   // Add PostgreSQL port binding
   if (postgres && doc.services.postgres) {
@@ -88,10 +150,16 @@ export async function exposeDatabasePorts(composeFile, options = {}) {
     }
     // Remove existing port binding if any
     doc.services.postgres.ports = doc.services.postgres.ports.filter(
-      (p) => !p.toString().includes('5432')
+      (p) => !p.toString().includes(DATABASE_PORTS.postgres.containerPort.toString())
     );
-    doc.services.postgres.ports.push(DATABASE_PORTS.postgres.port);
+
+    // Find available port
+    const hostPort = await findAvailablePort(postgresPort);
+    const portMapping = `${hostPort}:${DATABASE_PORTS.postgres.containerPort}`;
+
+    doc.services.postgres.ports.push(portMapping);
     exposed.push('postgres');
+    portMappings.postgres = { hostPort, containerPort: DATABASE_PORTS.postgres.containerPort };
   }
 
   // Add Redis port binding
@@ -101,10 +169,16 @@ export async function exposeDatabasePorts(composeFile, options = {}) {
     }
     // Remove existing port binding if any
     doc.services.redis.ports = doc.services.redis.ports.filter(
-      (p) => !p.toString().includes('6379')
+      (p) => !p.toString().includes(DATABASE_PORTS.redis.containerPort.toString())
     );
-    doc.services.redis.ports.push(DATABASE_PORTS.redis.port);
+
+    // Find available port
+    const hostPort = await findAvailablePort(redisPort);
+    const portMapping = `${hostPort}:${DATABASE_PORTS.redis.containerPort}`;
+
+    doc.services.redis.ports.push(portMapping);
     exposed.push('redis');
+    portMappings.redis = { hostPort, containerPort: DATABASE_PORTS.redis.containerPort };
   }
 
   // Add MongoDB port binding
@@ -114,15 +188,21 @@ export async function exposeDatabasePorts(composeFile, options = {}) {
     }
     // Remove existing port binding if any
     doc.services.mongodb.ports = doc.services.mongodb.ports.filter(
-      (p) => !p.toString().includes('27017')
+      (p) => !p.toString().includes(DATABASE_PORTS.mongodb.containerPort.toString())
     );
-    doc.services.mongodb.ports.push(DATABASE_PORTS.mongodb.port);
+
+    // Find available port
+    const hostPort = await findAvailablePort(mongodbPort);
+    const portMapping = `${hostPort}:${DATABASE_PORTS.mongodb.containerPort}`;
+
+    doc.services.mongodb.ports.push(portMapping);
     exposed.push('mongodb');
+    portMappings.mongodb = { hostPort, containerPort: DATABASE_PORTS.mongodb.containerPort };
   }
 
   await writeComposeFile(composeFile, doc);
 
-  return { exposed, doc };
+  return { exposed, portMappings, doc };
 }
 
 /**
@@ -180,7 +260,7 @@ export async function secureDatabasePorts(composeFile) {
 /**
  * Get current port exposure status for database services
  * @param {string} composeFile - Path to docker-compose.yml
- * @returns {Promise<Object>} Status object
+ * @returns {Promise<Object>} Status object with actual port mappings
  */
 export async function getDatabasePortStatus(composeFile) {
   try {
@@ -194,38 +274,77 @@ export async function getDatabasePortStatus(composeFile) {
 
     // Check PostgreSQL
     if (doc.services.postgres) {
-      const hasPort = doc.services.postgres.ports?.some((p) =>
-        p.toString().includes('5432')
+      const portBinding = doc.services.postgres.ports?.find((p) =>
+        p.toString().includes(`:${DATABASE_PORTS.postgres.containerPort}`)
       );
-      status.postgres = {
-        name: DATABASE_PORTS.postgres.name,
-        exposed: hasPort,
-        port: hasPort ? '5432' : null,
-      };
+      if (portBinding) {
+        const [hostPort, containerPort] = portBinding.toString().split(':');
+        status.postgres = {
+          name: DATABASE_PORTS.postgres.name,
+          exposed: true,
+          hostPort: parseInt(hostPort),
+          containerPort: parseInt(containerPort),
+          mapping: portBinding.toString(),
+        };
+      } else {
+        status.postgres = {
+          name: DATABASE_PORTS.postgres.name,
+          exposed: false,
+          hostPort: null,
+          containerPort: DATABASE_PORTS.postgres.containerPort,
+          mapping: null,
+        };
+      }
     }
 
     // Check Redis
     if (doc.services.redis) {
-      const hasPort = doc.services.redis.ports?.some((p) =>
-        p.toString().includes('6379')
+      const portBinding = doc.services.redis.ports?.find((p) =>
+        p.toString().includes(`:${DATABASE_PORTS.redis.containerPort}`)
       );
-      status.redis = {
-        name: DATABASE_PORTS.redis.name,
-        exposed: hasPort,
-        port: hasPort ? '6379' : null,
-      };
+      if (portBinding) {
+        const [hostPort, containerPort] = portBinding.toString().split(':');
+        status.redis = {
+          name: DATABASE_PORTS.redis.name,
+          exposed: true,
+          hostPort: parseInt(hostPort),
+          containerPort: parseInt(containerPort),
+          mapping: portBinding.toString(),
+        };
+      } else {
+        status.redis = {
+          name: DATABASE_PORTS.redis.name,
+          exposed: false,
+          hostPort: null,
+          containerPort: DATABASE_PORTS.redis.containerPort,
+          mapping: null,
+        };
+      }
     }
 
     // Check MongoDB
     if (doc.services.mongodb) {
-      const hasPort = doc.services.mongodb.ports?.some((p) =>
-        p.toString().includes('27017')
+      const portBinding = doc.services.mongodb.ports?.find((p) =>
+        p.toString().includes(`:${DATABASE_PORTS.mongodb.containerPort}`)
       );
-      status.mongodb = {
-        name: DATABASE_PORTS.mongodb.name,
-        exposed: hasPort,
-        port: hasPort ? '27017' : null,
-      };
+      if (portBinding) {
+        const [hostPort, containerPort] = portBinding.toString().split(':');
+        status.mongodb = {
+          name: DATABASE_PORTS.mongodb.name,
+          exposed: true,
+          hostPort: parseInt(hostPort),
+          containerPort: parseInt(containerPort),
+          mapping: portBinding.toString(),
+        };
+      } else {
+        status.mongodb = {
+          name: DATABASE_PORTS.mongodb.name,
+          exposed: false,
+          hostPort: null,
+          containerPort: DATABASE_PORTS.mongodb.containerPort,
+          mapping: null,
+        };
+      }
     }
 
     return status;
@@ -236,20 +355,23 @@ export async function getDatabasePortStatus(composeFile) {
 
 /**
  * Get connection examples for exposed databases
- * @param {Array<string>} exposed - List of exposed database services
+ * @param {Object} portMappings - Port mappings object from exposeDatabasePorts
  * @param {string} host - Server hostname or IP
  * @param {Object} credentials - Database credentials { postgres, redis, mongodb }
- * @returns {Object} Connection examples
+ * @returns {Object} Connection examples with actual host ports
  */
-export function getConnectionExamples(exposed, host = 'SERVER_IP', credentials = {}) {
+export function getConnectionExamples(portMappings, host = 'SERVER_IP', credentials = {}) {
   const examples = {};
 
-  exposed.forEach((db) => {
+  Object.keys(portMappings).forEach((db) => {
     if (DATABASE_PORTS[db]) {
       const password = credentials[db] || 'PASSWORD';
+      const { hostPort } = portMappings[db];
       examples[db] = {
         name: DATABASE_PORTS[db].name,
-        example: DATABASE_PORTS[db].connectionExample(host, password),
+        hostPort,
+        containerPort: portMappings[db].containerPort,
+        example: DATABASE_PORTS[db].connectionExample(host, hostPort, password),
       };
     }
   });
@@ -259,16 +381,16 @@ export function getConnectionExamples(exposed, host = 'SERVER_IP', credentials =
 
 /**
  * Get firewall rules for database ports
- * @param {Array<string>} exposed - List of exposed database services
- * @returns {Array<string>} UFW command examples
+ * @param {Object} portMappings - Port mappings object from exposeDatabasePorts
+ * @returns {Array<string>} UFW command examples with actual host ports
  */
-export function getFirewallRules(exposed) {
+export function getFirewallRules(portMappings) {
   const rules = [];
 
-  exposed.forEach((db) => {
+  Object.keys(portMappings).forEach((db) => {
     if (DATABASE_PORTS[db]) {
-      const port = DATABASE_PORTS[db].port.split(':')[0];
-      rules.push(`ufw allow from YOUR_IP to any port ${port}`);
+      const { hostPort } = portMappings[db];
+      rules.push(`ufw allow from YOUR_IP to any port ${hostPort}`);
     }
   });