ante-erp-cli 1.6.2 → 1.6.3

package/package.json

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

package/src/commands/install.js

@@ -14,6 +14,7 @@ import { pullImages, startServices, waitForServiceHealthy } from '../utils/docke
 import { generateDockerCompose } from '../templates/docker-compose.yml.js';
 import { generateEnv } from '../templates/env.js';
 import { detectPublicIPWithFeedback, buildURL, isValidIPv4, isValidDomain } from '../utils/network.js';
+import { configureNginx, requiresNginx } from '../utils/nginx.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -273,6 +274,7 @@ export async function install(options) {
           name: 'frontendPort',
           message: 'Frontend port:',
           default: 8080,
+          when: (answers) => answers.networkType !== 'domain',
           validate: (input) => {
             if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
             return true;
@@ -283,6 +285,7 @@ export async function install(options) {
           name: 'apiPort',
           message: 'API port:',
           default: 3001,
+          when: (answers) => answers.networkType !== 'domain',
           validate: (input) => {
             if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
             return true;
@@ -292,36 +295,48 @@ export async function install(options) {
 
       // Build URLs based on configuration
       let frontendUrl, apiUrl;
+      const frontendPort = networkConfig.frontendPort || 8080;
+      const apiPort = networkConfig.apiPort || 3001;
+
       if (networkConfig.networkType === 'localhost') {
-        frontendUrl = buildURL('localhost', networkConfig.frontendPort);
-        apiUrl = buildURL('localhost', networkConfig.apiPort);
+        frontendUrl = buildURL('localhost', frontendPort);
+        apiUrl = buildURL('localhost', apiPort);
       } else if (networkConfig.networkType === 'ip') {
-        frontendUrl = buildURL(networkConfig.publicIP, networkConfig.frontendPort);
-        apiUrl = buildURL(networkConfig.publicIP, networkConfig.apiPort);
+        frontendUrl = buildURL(networkConfig.publicIP, frontendPort);
+        apiUrl = buildURL(networkConfig.publicIP, apiPort);
       } else {
-        // Domain - assume standard ports with potential reverse proxy
+        // Domain - use standard HTTP/HTTPS ports (NGINX will handle reverse proxy)
         const isHttps = await inquirer.prompt([{
           type: 'confirm',
           name: 'useHttps',
-          message: 'Is SSL/TLS configured for this domain?',
+          message: 'Is SSL/TLS configured for this domain (e.g., via Cloudflare)?',
           default: true
         }]);
 
-        if (isHttps.useHttps) {
-          frontendUrl = `https://${networkConfig.domainName}`;
-          apiUrl = `https://api.${networkConfig.domainName}`;
-        } else {
-          frontendUrl = buildURL(networkConfig.domainName, networkConfig.frontendPort);
-          apiUrl = buildURL(networkConfig.domainName, networkConfig.apiPort);
-        }
+        // Ask for API subdomain
+        const apiSubdomain = await inquirer.prompt([{
+          type: 'input',
+          name: 'subdomain',
+          message: 'API subdomain (e.g., "api" for api.example.com):',
+          default: 'api',
+          validate: (input) => {
+            if (!input) return 'Subdomain is required';
+            if (!/^[a-z0-9-]+$/.test(input)) return 'Invalid subdomain format';
+            return true;
+          }
+        }]);
+
+        const protocol = isHttps.useHttps ? 'https' : 'http';
+        frontendUrl = `${protocol}://${networkConfig.domainName}`;
+        apiUrl = `${protocol}://${apiSubdomain.subdomain}.${networkConfig.domainName}`;
       }
 
       config = {
         ...baseConfig,
         frontendDomain: frontendUrl,
         apiDomain: apiUrl,
-        frontendPort: networkConfig.frontendPort,
-        apiPort: networkConfig.apiPort
+        frontendPort,
+        apiPort
       };
     } else {
       // Non-interactive mode - use options or defaults with IP detection
@@ -554,7 +569,24 @@ Support: support@ante.ph
     });
     
     await tasks.run();
-    
+
+    // Configure NGINX if needed (for domains or HTTPS)
+    if (requiresNginx(config.frontendDomain || 'http://localhost:8080', config.apiDomain || 'http://localhost:3001')) {
+      console.log(chalk.gray('\n🔧 Setting up reverse proxy...\n'));
+
+      try {
+        await configureNginx({
+          frontendDomain: config.frontendDomain || 'http://localhost:8080',
+          apiDomain: config.apiDomain || 'http://localhost:3001',
+          frontendPort: config.frontendPort || 8080,
+          apiPort: config.apiPort || 3001
+        });
+      } catch (error) {
+        console.log(chalk.yellow('\n⚠  NGINX configuration failed:', error.message));
+        console.log(chalk.gray('You may need to configure reverse proxy manually\n'));
+      }
+    }
+
     // Save installation configuration
     const installConfig = {
       installPath: config.installDir,

package/src/commands/set-domain.js

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { execa } from 'execa';
 import { getInstallDir } from '../utils/config.js';
 import { detectPublicIPWithFeedback, buildURL, isValidIPv4 } from '../utils/network.js';
+import { configureNginx, requiresNginx } from '../utils/nginx.js';
 
 /**
  * Validate URL format
@@ -239,15 +240,33 @@ export async function setDomain(options) {
 
     console.log(chalk.green('✓ Configuration updated'));
 
-    // Restart frontend container
-    console.log(chalk.gray('\n🔄 Restarting frontend container...\n'));
+    // Configure NGINX if needed (for domains or HTTPS)
+    if (requiresNginx(frontendUrl, apiUrl)) {
+      console.log(chalk.gray('\n🔧 Setting up reverse proxy...\n'));
+
+      try {
+        await configureNginx({
+          frontendDomain: frontendUrl,
+          apiDomain: apiUrl,
+          frontendPort: 8080,
+          apiPort: 3001
+        });
+      } catch (error) {
+        console.log(chalk.yellow('\n⚠  NGINX configuration failed:', error.message));
+        console.log(chalk.gray('You may need to configure reverse proxy manually\n'));
+      }
+    }
+
+    // Restart containers to apply new environment variables
+    console.log(chalk.gray('\n🔄 Restarting containers...\n'));
 
     try {
-      await execa('docker', ['compose', '-f', composeFile, 'restart', 'frontend']);
-      console.log(chalk.green('✓ Frontend restarted successfully'));
+      await execa('docker', ['compose', '-f', composeFile, 'down'], { cwd: installDir });
+      await execa('docker', ['compose', '-f', composeFile, 'up', '-d'], { cwd: installDir });
+      console.log(chalk.green('✓ Containers restarted successfully'));
     } catch (error) {
-      console.log(chalk.yellow('⚠  Could not restart frontend automatically'));
-      console.log(chalk.gray('Run: ante restart frontend'));
+      console.log(chalk.yellow('⚠  Could not restart containers automatically'));
+      console.log(chalk.gray('Run: docker compose down && docker compose up -d'));
     }
 
     // Show summary

package/src/utils/nginx.js

@@ -0,0 +1,258 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execa } from 'execa';
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Check if NGINX is installed
+ * @returns {Promise<boolean>} True if NGINX is installed
+ */
+export async function isNginxInstalled() {
+  try {
+    await execa('which', ['nginx']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install NGINX on Ubuntu/Debian
+ * @param {Object} spinner - Ora spinner instance
+ * @returns {Promise<void>}
+ */
+export async function installNginx(spinner) {
+  try {
+    spinner.text = 'Installing NGINX...';
+
+    // Update package list
+    await execa('apt-get', ['update', '-qq'], { stdio: 'pipe' });
+
+    // Install NGINX
+    await execa('apt-get', ['install', '-y', '-qq', 'nginx'], { stdio: 'pipe' });
+
+    // Enable NGINX to start on boot
+    await execa('systemctl', ['enable', 'nginx'], { stdio: 'pipe' });
+
+    spinner.succeed('NGINX installed successfully');
+    return true;
+  } catch (error) {
+    spinner.fail('Failed to install NGINX');
+    throw new Error(`NGINX installation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Generate NGINX configuration for ANTE
+ * @param {Object} config - Configuration object
+ * @param {string} config.frontendDomain - Frontend domain (e.g., ante.example.com)
+ * @param {string} config.apiDomain - API domain (e.g., api.ante.example.com)
+ * @param {number} config.frontendPort - Frontend Docker port (default: 8080)
+ * @param {number} config.apiPort - API Docker port (default: 3001)
+ * @returns {string} NGINX configuration content
+ */
+export function generateNginxConfig(config) {
+  const { frontendDomain, apiDomain, frontendPort = 8080, apiPort = 3001 } = config;
+
+  // Extract domain without protocol
+  const frontendHost = frontendDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '');
+  const apiHost = apiDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '');
+
+  return `# ANTE Frontend Configuration
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${frontendHost};
+
+    # Increase buffer sizes for large headers
+    client_header_buffer_size 16k;
+    large_client_header_buffers 4 16k;
+
+    # Increase body size for file uploads
+    client_max_body_size 100M;
+
+    location / {
+        proxy_pass http://localhost:${frontendPort};
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+
+        # Timeout settings
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+}
+
+# ANTE API Configuration
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${apiHost};
+
+    # Increase buffer sizes for large headers
+    client_header_buffer_size 16k;
+    large_client_header_buffers 4 16k;
+
+    # Increase body size for file uploads
+    client_max_body_size 100M;
+
+    location / {
+        proxy_pass http://localhost:${apiPort};
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+
+        # Timeout settings
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+
+        # WebSocket support
+        proxy_set_header X-Forwarded-Host $host;
+        proxy_set_header X-Forwarded-Server $host;
+    }
+}
+`;
+}
+
+/**
+ * Configure NGINX for ANTE domains
+ * @param {Object} config - Configuration object
+ * @param {string} config.frontendDomain - Frontend domain
+ * @param {string} config.apiDomain - API domain
+ * @param {number} [config.frontendPort=8080] - Frontend Docker port
+ * @param {number} [config.apiPort=3001] - API Docker port
+ * @returns {Promise<void>}
+ */
+export async function configureNginx(config) {
+  const spinner = ora('Configuring NGINX reverse proxy...').start();
+
+  try {
+    // Check if NGINX is installed
+    const nginxInstalled = await isNginxInstalled();
+
+    if (!nginxInstalled) {
+      spinner.text = 'NGINX not found, installing...';
+      await installNginx(spinner);
+      spinner.start('Configuring NGINX reverse proxy...');
+    }
+
+    // Ensure sites-enabled directory exists
+    const sitesEnabledDir = '/etc/nginx/sites-enabled';
+    if (!existsSync(sitesEnabledDir)) {
+      mkdirSync(sitesEnabledDir, { recursive: true });
+    }
+
+    // Generate NGINX configuration
+    const nginxConfig = generateNginxConfig(config);
+
+    // Write configuration to sites-enabled (direct, not using sites-available)
+    const configPath = join(sitesEnabledDir, 'ante');
+    writeFileSync(configPath, nginxConfig);
+
+    spinner.text = 'Testing NGINX configuration...';
+
+    // Test NGINX configuration
+    try {
+      await execa('nginx', ['-t'], { stdio: 'pipe' });
+    } catch (error) {
+      spinner.fail('NGINX configuration test failed');
+      throw new Error(`Invalid NGINX configuration: ${error.message}`);
+    }
+
+    spinner.text = 'Reloading NGINX...';
+
+    // Reload NGINX to apply changes
+    try {
+      await execa('systemctl', ['reload', 'nginx'], { stdio: 'pipe' });
+    } catch {
+      // If reload fails, try restart
+      await execa('systemctl', ['restart', 'nginx'], { stdio: 'pipe' });
+    }
+
+    // Verify NGINX is running
+    const { stdout } = await execa('systemctl', ['is-active', 'nginx'], { stdio: 'pipe' });
+    if (stdout.trim() !== 'active') {
+      throw new Error('NGINX failed to start');
+    }
+
+    spinner.succeed('NGINX configured successfully');
+
+    // Show helpful information
+    console.log(chalk.gray('\n📝 NGINX Configuration:'));
+    console.log(chalk.gray(`   Config file: ${configPath}`));
+    console.log(chalk.gray(`   Frontend: ${config.frontendDomain} → localhost:${config.frontendPort || 8080}`));
+    console.log(chalk.gray(`   API: ${config.apiDomain} → localhost:${config.apiPort || 3001}`));
+
+  } catch (error) {
+    spinner.fail('Failed to configure NGINX');
+    throw error;
+  }
+}
+
+/**
+ * Remove ANTE NGINX configuration
+ * @returns {Promise<void>}
+ */
+export async function removeNginxConfig() {
+  const spinner = ora('Removing NGINX configuration...').start();
+
+  try {
+    const configPath = '/etc/nginx/sites-enabled/ante';
+
+    if (existsSync(configPath)) {
+      await execa('rm', [configPath]);
+
+      // Reload NGINX
+      try {
+        await execa('systemctl', ['reload', 'nginx'], { stdio: 'pipe' });
+      } catch {
+        // Ignore if NGINX is not running
+      }
+
+      spinner.succeed('NGINX configuration removed');
+    } else {
+      spinner.info('No NGINX configuration found');
+    }
+  } catch (error) {
+    spinner.fail('Failed to remove NGINX configuration');
+    throw error;
+  }
+}
+
+/**
+ * Check if domains require NGINX (i.e., using HTTPS or standard HTTP without port)
+ * @param {string} frontendUrl - Frontend URL
+ * @param {string} apiUrl - API URL
+ * @returns {boolean} True if NGINX is required
+ */
+export function requiresNginx(frontendUrl, apiUrl) {
+  // NGINX required if:
+  // 1. Using HTTPS
+  // 2. Using HTTP without explicit port (implies port 80)
+  // 3. Using a domain name (not IP address)
+
+  const frontendUsesHttps = frontendUrl.startsWith('https://');
+  const apiUsesHttps = apiUrl.startsWith('https://');
+
+  const frontendNoPort = !frontendUrl.match(/:\d+$/);
+  const apiNoPort = !apiUrl.match(/:\d+$/);
+
+  const frontendIsDomain = !frontendUrl.match(/https?:\/\/\d+\.\d+\.\d+\.\d+/);
+  const apiIsDomain = !apiUrl.match(/https?:\/\/\d+\.\d+\.\d+\.\d+/);
+
+  return (frontendUsesHttps || apiUsesHttps) ||
+         ((frontendNoPort || apiNoPort) && (frontendIsDomain || apiIsDomain));
+}