ante-erp-cli 1.11.16 → 1.11.18

package/package.json

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

package/src/commands/install.js

@@ -1,19 +1,18 @@
 import chalk from 'chalk';
 import boxen from 'boxen';
-import inquirer from 'inquirer';
 import ora from 'ora';
 import { Listr } from 'listr2';
 import { execa } from 'execa';
-import { mkdirSync, writeFileSync, existsSync, renameSync } from 'fs';
+import { mkdirSync, writeFileSync, existsSync, renameSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { runSystemChecks, checkAndInstallDocker } from '../utils/validation.js';
 import { generateCredentials } from '../utils/password.js';
 import { saveInstallConfig, detectInstallation } from '../utils/config.js';
-import { pullImages, startServices, waitForServiceHealthy, runMigrations } from '../utils/docker.js';
+import { pullImagesSilent, startServicesSilent, waitForServiceHealthy, runMigrations } from '../utils/docker.js';
 import { generateDockerCompose } from '../templates/docker-compose.yml.js';
 import { generateEnv } from '../templates/env.js';
-import { detectPublicIPWithFeedback, buildURL, isValidIPv4, isValidDomain } from '../utils/network.js';
+import { detectPublicIPWithFeedback, buildURL } from '../utils/network.js';
 import { configureNginx, requiresNginx } from '../utils/nginx.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -42,50 +41,14 @@ function backupEnvFile(envPath) {
 }
 
 /**
- * Check for existing .env files and warn user
- * @param {string} installDir - Installation directory
- * @returns {boolean} - True if user confirms to continue
+ * Format step title with numbering
+ * @param {number} step - Current step number
+ * @param {number} total - Total number of steps
+ * @param {string} description - Step description
+ * @returns {string} Formatted title
  */
-async function checkExistingConfig(installDir) {
-  const envPath = join(installDir, '.env');
-
-  if (!existsSync(envPath)) {
-    return true; // No existing config, safe to continue
-  }
-
-  console.log(chalk.yellow('\n⚠ Existing configuration detected!'));
-  console.log(chalk.white(`  Found: ${envPath}`));
-  console.log(chalk.gray('  This file contains API URLs, credentials, and other settings.\n'));
-
-  const { action } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'action',
-      message: 'How would you like to proceed?',
-      choices: [
-        { name: 'Backup old config and create new (Recommended)', value: 'backup' },
-        { name: 'Overwrite with new configuration', value: 'overwrite' },
-        { name: 'Cancel installation', value: 'cancel' }
-      ],
-      default: 'backup'
-    }
-  ]);
-
-  if (action === 'cancel') {
-    console.log(chalk.gray('\nInstallation cancelled.\n'));
-    return false;
-  }
-
-  if (action === 'backup') {
-    const backupPath = backupEnvFile(envPath);
-    if (backupPath) {
-      console.log(chalk.green(`  ✓ Configuration backed up to: ${backupPath}\n`));
-    }
-  } else {
-    console.log(chalk.yellow('  ⚠ Existing configuration will be overwritten\n'));
-  }
-
-  return true;
+function formatStepTitle(step, total, description) {
+  return `[${step}/${total}] ${description}`;
 }
 
 /**
@@ -165,34 +128,43 @@ function showSuccess(installDir, credentials, config) {
 }
 
 /**
- * Install ANTE ERP
+ * Install ANTE ERP (Non-Interactive Mode)
  */
 export async function install(options) {
   try {
     showWelcome();
-    
+
+    console.log(chalk.bold('\n🚀 ANTE ERP Installation\n'));
+
     // Check if already installed
     const existing = detectInstallation();
     if (existing && !options.force) {
-      console.log(chalk.yellow('\n⚠  ANTE is already installed at:'), chalk.white(existing));
-      const { continueAnyway } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'continueAnyway',
-          message: 'Install anyway?',
-          default: false
-        }
-      ]);
-      
-      if (!continueAnyway) {
-        console.log(chalk.gray('\nInstallation cancelled.'));
-        return;
-      }
+      console.log(chalk.yellow('⚠ ANTE is already installed at:'), chalk.white(existing));
+      console.log(chalk.gray('Proceeding with re-installation...\n'));
     }
-    
-    // System checks
+
+    // Calculate total steps
+    let totalSteps = 10; // Base steps
+
+    // Pre-calculate step numbers
+    let currentStep = 0;
+    const stepSystemCheck = !options.skipChecks ? ++currentStep : null;
+    const stepNetworkDetect = ++currentStep;
+    const stepGenerateCredentials = ++currentStep;
+    const stepCreateDir = ++currentStep;
+    const stepGenerateConfig = ++currentStep;
+    const stepPullImages = ++currentStep;
+    const stepStartServices = ++currentStep;
+    const stepWaitServices = ++currentStep;
+    const stepInitDatabase = ++currentStep;
+    const stepRunMigrations = ++currentStep;
+
+    // Start installation
+    let stepNum = 0;
+
+    // Step: System checks
     if (!options.skipChecks) {
-      console.log(chalk.bold('\n🔍 Checking system requirements...\n'));
+      console.log(chalk.cyan(formatStepTitle(stepSystemCheck, totalSteps, 'Checking system requirements')));
 
       // Check Docker first and offer installation if needed
       const dockerResult = await checkAndInstallDocker(!options.skipDockerInstall);
@@ -203,394 +175,92 @@ export async function install(options) {
       // Update checks with Docker installation result
       checks.docker = dockerResult;
 
-      // Display check results
-      console.log(chalk.bold('System Requirements:'));
-      console.log(`${checks.docker.ok ? chalk.green('✓') : chalk.red('✗')} Docker: ${checks.docker.message}`);
+      // Display check results (compact)
+      console.log(`  ${checks.docker.ok ? chalk.green('✓') : chalk.red('✗')} Docker: ${checks.docker.message}`);
       if (checks.docker.installed) {
-        console.log(chalk.green('  ↳ Docker was installed during this setup'));
+        console.log(chalk.green('    ↳ Docker was installed during this setup'));
       }
-      console.log(`${checks.dockerCompose.ok ? chalk.green('✓') : chalk.red('✗')} Docker Compose: ${checks.dockerCompose.message}`);
-      console.log(`${checks.node.ok ? chalk.green('✓') : chalk.red('✗')} Node.js: ${checks.node.message}`);
-
-      console.log(chalk.bold('\nResources:'));
-      console.log(`${checks.diskSpace.ok ? chalk.green('✓') : chalk.red('✗')} Disk Space: ${checks.diskSpace.message}`);
-      console.log(`${checks.memory.ok ? chalk.green('✓') : chalk.red('✗')} Memory: ${checks.memory.message}`);
-      console.log(`${checks.cpu.ok ? chalk.green('✓') : chalk.yellow('⚠')} CPU: ${checks.cpu.message}`);
+      console.log(`  ${checks.dockerCompose.ok ? chalk.green('✓') : chalk.red('✗')} Docker Compose: ${checks.dockerCompose.message}`);
+      console.log(`  ${checks.node.ok ? chalk.green('✓') : chalk.red('✗')} Node.js: ${checks.node.message}`);
+      console.log(`  ${checks.diskSpace.ok ? chalk.green('✓') : chalk.red('✗')} Disk Space: ${checks.diskSpace.message}`);
 
       if (!ok || !checks.docker.ok) {
         console.log(chalk.red('\n✗ System requirements not met. Please resolve issues above.\n'));
         process.exit(1);
       }
 
-      console.log(chalk.green('\n✓ All requirements met!\n'));
-    } else {
-      console.log(chalk.yellow('\n⚠  Skipping system requirements check (--skip-checks)\n'));
+      console.log(chalk.green(`✓ ${formatStepTitle(stepSystemCheck, totalSteps, 'System requirements met')}\n`));
     }
 
-    // Detect public IP for server installations
-    console.log(chalk.bold('\n🌐 Network Configuration\n'));
-    const spinner = ora();
+    // Step: Network detection
+    console.log(chalk.cyan(formatStepTitle(stepNetworkDetect, totalSteps, 'Detecting network configuration')));
+    const spinner = ora({ text: 'Detecting public IP...', prefixText: '  ' }).start();
     const detectedIP = await detectPublicIPWithFeedback(spinner);
 
-    // Interactive prompts or use options
-    let config;
-    if (options.interactive) {
-      // Interactive mode with IP/domain configuration
-      const baseConfig = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'installDir',
-          message: 'Installation directory:',
-          default: options.dir || './ante-erp'
-        },
-        {
-          type: 'list',
-          name: 'preset',
-          message: 'Choose installation type:',
-          choices: [
-            { name: 'Minimal (Evaluation)', value: 'minimal' },
-            { name: 'Standard (Recommended)', value: 'standard' },
-            { name: 'Enterprise (Full Features)', value: 'enterprise' }
-          ],
-          default: 'standard'
-        }
-      ]);
-
-      // Frontend selection prompts
-      const frontendConfig = await inquirer.prompt([
-        {
-          type: 'checkbox',
-          name: 'frontends',
-          message: 'Which frontends do you want to install?',
-          choices: [
-            { name: 'Main Frontend (Required)', value: 'main', checked: true, disabled: true },
-            { name: 'Gate App (School/Gate attendance)', value: 'gate', checked: false },
-            { name: 'Guardian App (Parent portal)', value: 'guardian', checked: false },
-            { name: 'Facial Web (Employee face recognition)', value: 'facial', checked: false },
-            { name: 'POS App (Point of Sale)', value: 'pos', checked: false }
-          ],
-          validate: (answer) => {
-            if (answer.length < 1) {
-              return 'You must select at least one frontend (Main Frontend is required).';
-            }
-            return true;
-          }
-        },
-        {
-          type: 'number',
-          name: 'companyId',
-          message: 'Company ID (for multi-tenant apps):',
-          default: 1,
-          when: (answers) => answers.frontends.includes('gate') || answers.frontends.includes('guardian') || answers.frontends.includes('facial') || answers.frontends.includes('pos'),
-          validate: (input) => {
-            if (input < 1) return 'Company ID must be at least 1';
-            return true;
-          }
-        }
-      ]);
-
-      // Network configuration prompts
-      const networkConfig = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'networkType',
-          message: 'How will users access this installation?',
-          choices: [
-            { name: 'Local development (localhost)', value: 'localhost' },
-            { name: 'Public IP address', value: 'ip' },
-            { name: 'Domain name', value: 'domain' }
-          ],
-          default: detectedIP ? 'ip' : 'localhost'
-        },
-        {
-          type: 'input',
-          name: 'publicIP',
-          message: 'Enter the public IP address:',
-          default: detectedIP || '',
-          when: (answers) => answers.networkType === 'ip',
-          validate: (input) => {
-            if (!input) return 'IP address is required';
-            if (!isValidIPv4(input)) return 'Please enter a valid IPv4 address';
-            return true;
-          }
-        },
-        {
-          type: 'input',
-          name: 'domainName',
-          message: 'Enter your domain name (e.g., erp.example.com):',
-          when: (answers) => answers.networkType === 'domain',
-          validate: (input) => {
-            if (!input) return 'Domain name is required';
-            if (!isValidDomain(input)) return 'Please enter a valid domain name';
-            return true;
-          }
-        },
-        {
-          type: 'number',
-          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;
-          }
-        },
-        {
-          type: 'number',
-          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;
-          }
-        },
-        {
-          type: 'number',
-          name: 'gateAppPort',
-          message: 'Gate App port:',
-          default: 8081,
-          when: (answers) => answers.networkType !== 'domain' && frontendConfig.frontends.includes('gate'),
-          validate: (input) => {
-            if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
-            return true;
-          }
-        },
-        {
-          type: 'number',
-          name: 'guardianAppPort',
-          message: 'Guardian App port:',
-          default: 8082,
-          when: (answers) => answers.networkType !== 'domain' && frontendConfig.frontends.includes('guardian'),
-          validate: (input) => {
-            if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
-            return true;
-          }
-        },
-        {
-          type: 'number',
-          name: 'facialWebPort',
-          message: 'Facial Web port:',
-          default: 8083,
-          when: (answers) => answers.networkType !== 'domain' && frontendConfig.frontends.includes('facial'),
-          validate: (input) => {
-            if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
-            return true;
-          }
-        },
-        {
-          type: 'number',
-          name: 'posAppPort',
-          message: 'POS App port:',
-          default: 8084,
-          when: (answers) => answers.networkType !== 'domain' && frontendConfig.frontends.includes('pos'),
-          validate: (input) => {
-            if (input < 1 || input > 65535) return 'Port must be between 1 and 65535';
-            return true;
-          }
-        }
-      ]);
-
-      // Build URLs based on configuration
-      let frontendUrl, apiUrl, gateAppUrl, guardianAppUrl, facialWebUrl, posAppUrl;
-      const frontendPort = networkConfig.frontendPort || 8080;
-      const apiPort = networkConfig.apiPort || 3001;
-      const gateAppPort = networkConfig.gateAppPort || 8081;
-      const guardianAppPort = networkConfig.guardianAppPort || 8082;
-      const facialWebPort = networkConfig.facialWebPort || 8083;
-      const posAppPort = networkConfig.posAppPort || 8084;
-
-      if (networkConfig.networkType === 'localhost') {
-        frontendUrl = buildURL('localhost', frontendPort);
-        apiUrl = buildURL('localhost', apiPort);
-        gateAppUrl = buildURL('localhost', gateAppPort);
-        guardianAppUrl = buildURL('localhost', guardianAppPort);
-        facialWebUrl = buildURL('localhost', facialWebPort);
-        posAppUrl = buildURL('localhost', posAppPort);
-      } else if (networkConfig.networkType === 'ip') {
-        frontendUrl = buildURL(networkConfig.publicIP, frontendPort);
-        apiUrl = buildURL(networkConfig.publicIP, apiPort);
-        gateAppUrl = buildURL(networkConfig.publicIP, gateAppPort);
-        guardianAppUrl = buildURL(networkConfig.publicIP, guardianAppPort);
-        facialWebUrl = buildURL(networkConfig.publicIP, facialWebPort);
-        posAppUrl = buildURL(networkConfig.publicIP, posAppPort);
-      } else {
-        // 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 (e.g., via Cloudflare)?',
-          default: true
-        }]);
-
-        // 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}`;
-        gateAppUrl = `${protocol}://gate.${networkConfig.domainName}`;
-        guardianAppUrl = `${protocol}://guardian.${networkConfig.domainName}`;
-        facialWebUrl = `${protocol}://facial.${networkConfig.domainName}`;
-        posAppUrl = `${protocol}://pos.${networkConfig.domainName}`;
-      }
-
-      config = {
-        ...baseConfig,
-        ...frontendConfig,
-        frontendDomain: frontendUrl,
-        apiDomain: apiUrl,
-        gateAppDomain: gateAppUrl,
-        guardianAppDomain: guardianAppUrl,
-        facialAppDomain: facialWebUrl,
-        posAppDomain: posAppUrl,
-        frontendPort,
-        apiPort,
-        gateAppPort,
-        guardianAppPort,
-        facialWebPort,
-        posAppPort,
-        installGate: frontendConfig.frontends.includes('gate'),
-        installGuardian: frontendConfig.frontends.includes('guardian'),
-        installFacial: frontendConfig.frontends.includes('facial'),
-        installPos: frontendConfig.frontends.includes('pos')
-      };
-    } else {
-      // Non-interactive mode - use options or defaults with IP detection
-      let frontendDomain = options.frontendDomain;
-      let apiDomain = options.apiDomain;
-
-      // If no domains provided and IP detected, use detected IP
-      if (!frontendDomain && detectedIP) {
-        frontendDomain = buildURL(detectedIP, parseInt(options.port) || 8080);
-        console.log(chalk.cyan('  → Using detected IP for frontend:'), chalk.white(frontendDomain));
-      }
-
-      if (!apiDomain && detectedIP) {
-        apiDomain = buildURL(detectedIP, 3001);
-        console.log(chalk.cyan('  → Using detected IP for API:'), chalk.white(apiDomain));
-      }
-
-      // If still no domain and no IP detected, prompt user
-      if (!frontendDomain || !apiDomain) {
-        console.log(chalk.yellow('\n⚠  Could not auto-detect public IP address.'));
-        console.log(chalk.white('Please provide domain/IP configuration manually:\n'));
-
-        const manualConfig = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'hostIp',
-            message: 'Enter public IP address or domain:',
-            validate: (input) => {
-              if (!input) return 'IP address or domain is required';
-              if (!isValidIPv4(input) && !isValidDomain(input)) {
-                return 'Please enter a valid IP address or domain name';
-              }
-              return true;
-            }
-          }
-        ]);
-
-        frontendDomain = buildURL(manualConfig.hostIp, parseInt(options.port) || 8080);
-        apiDomain = buildURL(manualConfig.hostIp, 3001);
-      }
+    // Build configuration (non-interactive, enterprise preset with all frontends)
+    const host = detectedIP || 'localhost';
+    const frontendPort = parseInt(options.port) || 8080;
+    const apiPort = 3001;
+    const gateAppPort = 8081;
+    const guardianAppPort = 8082;
+    const facialWebPort = 8083;
+    const posAppPort = 8084;
+
+    const config = {
+      installDir: options.dir || './ante-erp',
+      preset: 'enterprise', // Always install all features
+      frontendDomain: buildURL(host, frontendPort),
+      apiDomain: buildURL(host, apiPort),
+      gateAppDomain: buildURL(host, gateAppPort),
+      guardianAppDomain: buildURL(host, guardianAppPort),
+      facialAppDomain: buildURL(host, facialWebPort),
+      posAppDomain: buildURL(host, posAppPort),
+      frontendPort,
+      apiPort,
+      gateAppPort,
+      guardianAppPort,
+      facialWebPort,
+      posAppPort,
+      companyId: 1,
+      installGate: true,      // Always install all frontends
+      installGuardian: true,
+      installFacial: true,
+      installPos: true,
+      frontends: ['main', 'gate', 'guardian', 'facial', 'pos']
+    };
 
-      // 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;
-      const installPos = installAllFrontends || options.withPos;
-
-      // Build frontends array
-      const frontends = ['main'];
-      if (installGate) frontends.push('gate');
-      if (installGuardian) frontends.push('guardian');
-      if (installFacial) frontends.push('facial');
-      if (installPos) frontends.push('pos');
-
-      config = {
-        installDir: options.dir,
-        preset: options.preset || 'standard',
-        frontendDomain,
-        apiDomain,
-        frontendPort: parseInt(options.port) || 8080,
-        apiPort: 3001,
-        gateAppPort: 8081,
-        guardianAppPort: 8082,
-        facialWebPort: 8083,
-        posAppPort: 8084,
-        gateAppDomain: buildURL(detectedIP || 'localhost', 8081),
-        guardianAppDomain: buildURL(detectedIP || 'localhost', 8082),
-        facialAppDomain: buildURL(detectedIP || 'localhost', 8083),
-        posAppDomain: buildURL(detectedIP || 'localhost', 8084),
-        companyId: 1,
-        installGate,
-        installGuardian,
-        installFacial,
-        installPos,
-        frontends
-      };
-    }
+    console.log(chalk.green(`✓ ${formatStepTitle(stepNetworkDetect, totalSteps, `Network detected: ${host}`)}\n`));
 
-    // Display configuration summary
-    console.log(chalk.bold('\n📋 Installation Configuration:\n'));
+    // Display configuration summary (compact)
+    console.log(chalk.bold('📋 Installation Configuration:\n'));
     console.log(chalk.cyan('  Directory:'), chalk.white(config.installDir));
-    console.log(chalk.cyan('  Preset:'), chalk.white(config.preset));
+    console.log(chalk.cyan('  Preset:'), chalk.white('Enterprise (All Features)'));
     console.log(chalk.cyan('  Frontend Main:'), chalk.white(config.frontendDomain));
-    if (config.installGate) {
-      console.log(chalk.cyan('  Gate App:'), chalk.white(config.gateAppDomain));
-    }
-    if (config.installGuardian) {
-      console.log(chalk.cyan('  Guardian App:'), chalk.white(config.guardianAppDomain));
-    }
-    if (config.installFacial) {
-      console.log(chalk.cyan('  Facial Web:'), chalk.white(config.facialAppDomain));
-    }
-    if (config.installPos) {
-      console.log(chalk.cyan('  POS App:'), chalk.white(config.posAppDomain));
-    }
+    console.log(chalk.cyan('  Gate App:'), chalk.white(config.gateAppDomain));
+    console.log(chalk.cyan('  Guardian App:'), chalk.white(config.guardianAppDomain));
+    console.log(chalk.cyan('  Facial Web:'), chalk.white(config.facialAppDomain));
+    console.log(chalk.cyan('  POS App:'), chalk.white(config.posAppDomain));
     console.log(chalk.cyan('  API:'), chalk.white(config.apiDomain));
-    if (config.companyId) {
-      console.log(chalk.cyan('  Company ID:'), chalk.white(config.companyId));
-    }
     console.log();
 
-    // Check for existing configuration files
-    if (!options.force) {
-      const canContinue = await checkExistingConfig(config.installDir);
-      if (!canContinue) {
-        return;
-      }
-    } else {
-      // Force mode: backup existing .env without prompting
-      const envPath = join(config.installDir, '.env');
+    // Auto-backup existing config if exists (no prompt)
+    const envPath = join(config.installDir, '.env');
+    if (existsSync(envPath)) {
       const backupPath = backupEnvFile(envPath);
       if (backupPath) {
-        console.log(chalk.yellow(`⚠ Force mode: Existing config backed up to ${backupPath}\n`));
+        console.log(chalk.yellow(`⚠ Existing config backed up: ${backupPath}\n`));
       }
     }
 
-    // Generate credentials
-    console.log(chalk.bold('\n🔐 Generating secure credentials...\n'));
+    // Step: Generate credentials
+    console.log(chalk.cyan(formatStepTitle(stepGenerateCredentials, totalSteps, 'Generating secure credentials')));
     const credentials = generateCredentials();
-    
-    // Installation tasks
+    console.log(chalk.green(`✓ ${formatStepTitle(stepGenerateCredentials, totalSteps, 'Secure credentials generated')}\n`));
+
+    // Installation tasks with Listr2
     const tasks = new Listr([
       {
-        title: 'Creating installation directory',
+        title: formatStepTitle(stepCreateDir, totalSteps, 'Creating installation directory'),
         task: () => {
           mkdirSync(config.installDir, { recursive: true });
           mkdirSync(join(config.installDir, 'backups'), { recursive: true });
@@ -598,59 +268,47 @@ export async function install(options) {
         }
       },
       {
-        title: 'Configuring server timezone',
-        task: async () => {
-          try {
-            // Set system timezone to Asia/Manila
-            await execa('timedatectl', ['set-timezone', 'Asia/Manila'], { stdio: 'pipe' });
-          } catch (error) {
-            // Non-critical: log warning but continue installation
-            console.warn('  ⚠ Could not set system timezone (may require sudo)');
-          }
-        }
-      },
-      {
-        title: 'Generating configuration files',
+        title: formatStepTitle(stepGenerateConfig, totalSteps, 'Generating configuration files'),
         task: () => {
           const dockerCompose = generateDockerCompose({
-            frontendPort: config.frontendPort || 8080,
-            backendPort: config.apiPort || 3001,
-            gateAppPort: config.gateAppPort || 8081,
-            guardianAppPort: config.guardianAppPort || 8082,
-            facialWebPort: config.facialWebPort || 8083,
-            posAppPort: config.posAppPort || 8084,
+            frontendPort: config.frontendPort,
+            backendPort: config.apiPort,
+            gateAppPort: config.gateAppPort,
+            guardianAppPort: config.guardianAppPort,
+            facialWebPort: config.facialWebPort,
+            posAppPort: config.posAppPort,
             installMain: true,
-            installGate: config.installGate || false,
-            installGuardian: config.installGuardian || false,
-            installFacial: config.installFacial || false,
-            installPos: config.installPos || false,
-            companyId: config.companyId || 1
+            installGate: config.installGate,
+            installGuardian: config.installGuardian,
+            installFacial: config.installFacial,
+            installPos: config.installPos,
+            companyId: config.companyId
           });
 
           const envContent = generateEnv(credentials, {
-            frontendUrl: config.frontendDomain || 'http://localhost:8080',
-            apiUrl: config.apiDomain || 'http://localhost:3001',
-            socketUrl: config.apiDomain || 'http://localhost:3001',
-            frontendPort: config.frontendPort || 8080,
-            backendPort: config.apiPort || 3001,
-            gateAppPort: config.gateAppPort || 8081,
-            guardianAppPort: config.guardianAppPort || 8082,
-            facialWebPort: config.facialWebPort || 8083,
-            posAppPort: config.posAppPort || 8084,
-            gateAppUrl: config.gateAppDomain || 'http://localhost:8081',
-            guardianAppUrl: config.guardianAppDomain || 'http://localhost:8082',
-            facialWebUrl: config.facialAppDomain || 'http://localhost:8083',
-            posAppUrl: config.posAppDomain || 'http://localhost:8084',
-            companyId: config.companyId || 1,
-            installGate: config.installGate || false,
-            installGuardian: config.installGuardian || false,
-            installFacial: config.installFacial || false,
-            installPos: config.installPos || false
+            frontendUrl: config.frontendDomain,
+            apiUrl: config.apiDomain,
+            socketUrl: config.apiDomain,
+            frontendPort: config.frontendPort,
+            backendPort: config.apiPort,
+            gateAppPort: config.gateAppPort,
+            guardianAppPort: config.guardianAppPort,
+            facialWebPort: config.facialWebPort,
+            posAppPort: config.posAppPort,
+            gateAppUrl: config.gateAppDomain,
+            guardianAppUrl: config.guardianAppDomain,
+            facialWebUrl: config.facialAppDomain,
+            posAppUrl: config.posAppDomain,
+            companyId: config.companyId,
+            installGate: config.installGate,
+            installGuardian: config.installGuardian,
+            installFacial: config.installFacial,
+            installPos: config.installPos
           });
-          
+
           writeFileSync(join(config.installDir, 'docker-compose.yml'), dockerCompose);
           writeFileSync(join(config.installDir, '.env'), envContent);
-          
+
           // Save credentials
           const credentialsText = `ANTE ERP Installation Credentials
 Generated: ${new Date().toISOString()}
@@ -671,9 +329,9 @@ Encryption Key:    ${credentials.encryptionKey}
 
 Access Information:
 ━━━━━━━━━━━━━━━━━━━
-Frontend:  ${config.frontendDomain || 'http://localhost:8080'}
-Backend:   ${config.apiDomain || 'http://localhost:3001'}
-WebSocket: ${config.apiDomain || 'http://localhost:3001'}
+Frontend:  ${config.frontendDomain}
+Backend:   ${config.apiDomain}
+WebSocket: ${config.apiDomain}
 
 Next Steps:
 ━━━━━━━━━━
@@ -686,50 +344,49 @@ Next Steps:
 Documentation: https://docs.ante.ph
 Support: support@ante.ph
 `;
-          
+
           writeFileSync(join(config.installDir, 'installation-credentials.txt'), credentialsText);
         }
       },
       {
-        title: 'Pulling Docker images',
+        title: formatStepTitle(stepPullImages, totalSteps, 'Pulling Docker images'),
         task: async () => {
           const composeFile = join(config.installDir, 'docker-compose.yml');
-          await pullImages(composeFile);
+          await pullImagesSilent(composeFile);
         }
       },
       {
-        title: 'Starting services',
+        title: formatStepTitle(stepStartServices, totalSteps, 'Starting services'),
         task: async () => {
           const composeFile = join(config.installDir, 'docker-compose.yml');
-          await startServices(composeFile);
+          await startServicesSilent(composeFile);
         }
       },
       {
-        title: 'Waiting for services to be ready',
+        title: formatStepTitle(stepWaitServices, totalSteps, 'Waiting for services to be ready'),
         task: async () => {
           const composeFile = join(config.installDir, 'docker-compose.yml');
-          
+
           // Wait for backend to be healthy
           const backendHealthy = await waitForServiceHealthy(composeFile, 'backend', 120);
           if (!backendHealthy) {
             throw new Error('Backend service failed to start');
           }
-          
-          // Give it a few more seconds
+
+          // Give it a few more seconds for full initialization
           await new Promise(resolve => setTimeout(resolve, 5000));
         }
       },
       {
-        title: 'Initializing database schema',
+        title: formatStepTitle(stepInitDatabase, totalSteps, 'Initializing database'),
         task: async () => {
           const composeFile = join(config.installDir, 'docker-compose.yml');
           const schemaFile = join(__dirname, '../templates/init-schema.sql');
 
           try {
-            const { readFileSync } = await import('fs');
             const schemaSQL = readFileSync(schemaFile, 'utf8');
 
-            // Execute schema SQL in postgres container using stdin
+            // Execute schema SQL in postgres container
             await execa('docker', [
               'compose',
               '-f', composeFile,
@@ -740,21 +397,12 @@ Support: support@ante.ph
               '-U', 'ante',
               '-d', 'ante_db'
             ], {
-              input: schemaSQL
+              input: schemaSQL,
+              stdout: 'pipe',
+              stderr: 'pipe'
             });
-          } catch (error) {
-            throw new Error(`Schema initialization failed: ${error.message}`);
-          }
-        }
-      },
-      {
-        title: 'Seeding initial data',
-        task: async () => {
-          const composeFile = join(config.installDir, 'docker-compose.yml');
 
-          try {
-            // Run production seed command in the backend container
-            // Uses seed:prod which compiles TypeScript and runs with node (production-safe)
+            // Run production seed command
             await execa('docker', [
               'compose',
               '-f', composeFile,
@@ -764,51 +412,52 @@ Support: support@ante.ph
               'npm',
               'run',
               'seed:prod'
-            ]);
+            ], {
+              stdout: 'pipe',
+              stderr: 'pipe'
+            });
           } catch (error) {
-            // Seeding is optional, just log warning
-            console.log(chalk.yellow('  ⚠ Seeding skipped (optional)'));
+            throw new Error(`Database initialization failed: ${error.message}`);
           }
         }
       },
       {
-        title: 'Running database migrations',
-        task: async (ctx, task) => {
+        title: formatStepTitle(stepRunMigrations, totalSteps, 'Running database migrations'),
+        task: async () => {
           const composeFile = join(config.installDir, 'docker-compose.yml');
           const result = await runMigrations(composeFile);
 
           if (!result.success) {
             throw new Error(`Migration failed:\n${result.output}`);
           }
-
-          // Show migration output if there were migrations run
-          if (result.output && result.output.trim()) {
-            task.output = result.output;
-          }
         }
       }
     ], {
+      renderer: 'default',
       rendererOptions: {
-        collapseSubtasks: false
-      }
+        collapse: false,
+        showSubtasks: false,
+        clearOutput: false,
+        showTimer: false,
+        removeEmptyLines: true
+      },
+      concurrent: false,
+      exitOnError: true
     });
-    
-    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'));
+    await tasks.run();
 
+    // Configure NGINX if needed (silent)
+    if (requiresNginx(config.frontendDomain, config.apiDomain)) {
       try {
         await configureNginx({
-          frontendDomain: config.frontendDomain || 'http://localhost:8080',
-          apiDomain: config.apiDomain || 'http://localhost:3001',
-          frontendPort: config.frontendPort || 8080,
-          apiPort: config.apiPort || 3001
+          frontendDomain: config.frontendDomain,
+          apiDomain: config.apiDomain,
+          frontendPort: config.frontendPort,
+          apiPort: config.apiPort
         });
       } 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'));
+        console.log(chalk.yellow('⚠ NGINX configuration skipped (manual setup may be required)'));
       }
     }
 
@@ -818,20 +467,14 @@ Support: support@ante.ph
       version: '1.0.0'
     };
 
-    // Only include domain if it exists
-    if (config.domain) {
-      installConfig.domain = config.domain;
-    }
-
     saveInstallConfig(installConfig);
 
     // Show success message
     showSuccess(config.installDir, credentials, config);
-    
+
   } catch (error) {
     console.error(chalk.red('\n✗ Installation failed:'), error.message);
     console.error(chalk.gray('\nFor help, visit: https://docs.ante.ph/self-hosting/troubleshooting\n'));
     process.exit(1);
   }
 }
-

package/src/utils/validation.js

@@ -300,13 +300,11 @@ export async function runSystemChecks() {
     dockerCompose: await checkDockerCompose(),
     node: checkNode(),
     diskSpace: checkDiskSpace(),
-    memory: checkMemory(),
-    cpu: checkCPU(),
     ports: await checkPorts()
   };
-  
+
   const ok = Object.values(checks).every(check => check.ok);
-  
+
   return { ok, checks };
 }