ante-erp-cli 1.7.4 → 1.8.0

package/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.8.0] - 2025-11-01
+
+### Added
+- **Multi-frontend installation support** - Install Gate and Guardian apps alongside Main Frontend
+  - Interactive checkbox prompt to select which frontends to install
+  - Gate App (School/Gate attendance) - Port 8081
+  - Guardian App (Parent portal) - Port 8082
+  - Company ID configuration for multi-tenant apps
+  - Conditional service deployment in docker-compose based on selection
+  - Updated success message to display all installed frontend URLs
+
+### Changed
+- **GitHub workflow enhancements** - Build self-hosted images for all frontends
+  - Added build jobs for `ante-self-hosted-frontend-gate-app`
+  - Added build jobs for `ante-self-hosted-frontend-guardian-app`
+  - Updated notification messages to include all frontend images
+  - Path filters now trigger on gate-app and guardian-app changes
+
+- **Docker Compose template improvements**
+  - Gate and Guardian services added with proper health checks
+  - Environment variables configured for Next.js apps
+  - Port mappings: 8081:3000 (gate), 8082:3000 (guardian)
+  - Services depend on backend and start conditionally
+
+- **Environment template updates**
+  - Added gate and guardian app URL configurations
+  - Company ID for multi-tenant support
+  - Conditional port and URL variables based on selections
+
 ### Fixed
 - **Misleading success messages in `clone-db` command** - Now shows accurate operation status
   - Added result tracking for Prisma generate and migrate operations

package/package.json

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

package/src/commands/backup.js

@@ -15,7 +15,7 @@ export async function backup(options) {
     const composeFile = join(installDir, 'docker-compose.yml');
     const backupDir = join(installDir, 'backups');
     
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+    const timestamp = new Date().toISOString().split('.')[0].replace(/:/g, '-').replace('T', '_');
     const backupFile = options.output || join(backupDir, `ante-backup-${timestamp}.tar.gz`);
     
     const spinner = ora('Creating backup...').start();

package/src/commands/clone-db.js

@@ -173,8 +173,8 @@ export async function cloneDb(sourceUrl, options = {}) {
       console.log(chalk.gray('This may take several minutes depending on database size...'));
       console.log('');
 
-      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T').join('_').split('.')[0];
-      dumpFile = join(backupDir, `clone_backup_${timestamp}.dump`);
+      const timestamp = new Date().toISOString().split('.')[0].replace(/:/g, '-').replace('T', '_');
+      dumpFile = join(backupDir, `clone-backup-${timestamp}.dump`);
 
       const dumpSpinner = ora('Creating database dump...').start();
       const dumpResult = await dumpDatabase(sourceInfo, dumpFile);

package/src/commands/install.js

@@ -113,15 +113,28 @@ function showWelcome() {
 function showSuccess(installDir, credentials, config) {
   const frontendUrl = config.frontendDomain || 'http://localhost:8080';
   const apiUrl = config.apiDomain || 'http://localhost:3001';
+  const gateAppUrl = config.gateAppDomain || 'http://localhost:8081';
+  const guardianAppUrl = config.guardianAppDomain || 'http://localhost:8082';
+
+  let accessInfo = chalk.white('Access Information:') + '\n' +
+    chalk.gray('━'.repeat(40)) + '\n' +
+    chalk.cyan('Frontend Main: ') + chalk.white(frontendUrl) + '\n';
+
+  if (config.installGate) {
+    accessInfo += chalk.cyan('Gate App:      ') + chalk.white(gateAppUrl) + '\n';
+  }
+
+  if (config.installGuardian) {
+    accessInfo += chalk.cyan('Guardian App:  ') + chalk.white(guardianAppUrl) + '\n';
+  }
+
+  accessInfo += chalk.cyan('Backend:       ') + chalk.white(apiUrl) + '\n' +
+    chalk.cyan('WebSocket:     ') + chalk.white(apiUrl) + '\n\n';
 
   console.log(
     boxen(
       chalk.green.bold('✓ Installation Complete!') + '\n\n' +
-      chalk.white('Access Information:') + '\n' +
-      chalk.gray('━'.repeat(40)) + '\n' +
-      chalk.cyan('Frontend:  ') + chalk.white(frontendUrl) + '\n' +
-      chalk.cyan('Backend:   ') + chalk.white(apiUrl) + '\n' +
-      chalk.cyan('WebSocket: ') + chalk.white(apiUrl) + '\n\n' +
+      accessInfo +
       chalk.yellow('⚠  IMPORTANT:') + '\n' +
       chalk.white(`Credentials saved to:\n${installDir}/installation-credentials.txt`) + '\n' +
       chalk.gray('Save this file securely!') + '\n\n' +
@@ -233,6 +246,37 @@ export async function install(options) {
         }
       ]);
 
+      // 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 }
+          ],
+          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'),
+          validate: (input) => {
+            if (input < 1) return 'Company ID must be at least 1';
+            return true;
+          }
+        }
+      ]);
+
       // Network configuration prompts
       const networkConfig = await inquirer.prompt([
         {
@@ -290,20 +334,48 @@ export async function install(options) {
             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;
+          }
         }
       ]);
 
       // Build URLs based on configuration
-      let frontendUrl, apiUrl;
+      let frontendUrl, apiUrl, gateAppUrl, guardianAppUrl;
       const frontendPort = networkConfig.frontendPort || 8080;
       const apiPort = networkConfig.apiPort || 3001;
+      const gateAppPort = networkConfig.gateAppPort || 8081;
+      const guardianAppPort = networkConfig.guardianAppPort || 8082;
 
       if (networkConfig.networkType === 'localhost') {
         frontendUrl = buildURL('localhost', frontendPort);
         apiUrl = buildURL('localhost', apiPort);
+        gateAppUrl = buildURL('localhost', gateAppPort);
+        guardianAppUrl = buildURL('localhost', guardianAppPort);
       } 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);
       } else {
         // Domain - use standard HTTP/HTTPS ports (NGINX will handle reverse proxy)
         const isHttps = await inquirer.prompt([{
@@ -329,14 +401,23 @@ export async function install(options) {
         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}`;
       }
 
       config = {
         ...baseConfig,
+        ...frontendConfig,
         frontendDomain: frontendUrl,
         apiDomain: apiUrl,
+        gateAppDomain: gateAppUrl,
+        guardianAppDomain: guardianAppUrl,
         frontendPort,
-        apiPort
+        apiPort,
+        gateAppPort,
+        guardianAppPort,
+        installGate: frontendConfig.frontends.includes('gate'),
+        installGuardian: frontendConfig.frontends.includes('guardian')
       };
     } else {
       // Non-interactive mode - use options or defaults with IP detection
@@ -384,7 +465,15 @@ export async function install(options) {
         frontendDomain,
         apiDomain,
         frontendPort: parseInt(options.port) || 8080,
-        apiPort: 3001
+        apiPort: 3001,
+        gateAppPort: 8081,
+        guardianAppPort: 8082,
+        gateAppDomain: buildURL(detectedIP || 'localhost', 8081),
+        guardianAppDomain: buildURL(detectedIP || 'localhost', 8082),
+        companyId: 1,
+        installGate: false,
+        installGuardian: false,
+        frontends: ['main']
       };
     }
 
@@ -392,8 +481,17 @@ export async function install(options) {
     console.log(chalk.bold('\n📋 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('  Frontend:'), chalk.white(config.frontendDomain));
+    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));
+    }
     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
@@ -442,14 +540,28 @@ export async function install(options) {
         task: () => {
           const dockerCompose = generateDockerCompose({
             frontendPort: config.frontendPort || 8080,
-            backendPort: config.apiPort || 3001
+            backendPort: config.apiPort || 3001,
+            gateAppPort: config.gateAppPort || 8081,
+            guardianAppPort: config.guardianAppPort || 8082,
+            installMain: true,
+            installGate: config.installGate || false,
+            installGuardian: config.installGuardian || false,
+            companyId: config.companyId || 1
           });
 
           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
+            frontendPort: config.frontendPort || 8080,
+            backendPort: config.apiPort || 3001,
+            gateAppPort: config.gateAppPort || 8081,
+            guardianAppPort: config.guardianAppPort || 8082,
+            gateAppUrl: config.gateAppDomain || 'http://localhost:8081',
+            guardianAppUrl: config.guardianAppDomain || 'http://localhost:8082',
+            companyId: config.companyId || 1,
+            installGate: config.installGate || false,
+            installGuardian: config.installGuardian || false
           });
           
           writeFileSync(join(config.installDir, 'docker-compose.yml'), dockerCompose);

package/src/commands/update.js

@@ -46,7 +46,8 @@ export async function update(options) {
         title: 'Creating backup',
         skip: () => options.skipBackup,
         task: async () => {
-          await backup({ output: join(installDir, 'backups', `pre-update-${Date.now()}.tar.gz`) });
+          const timestamp = new Date().toISOString().split('.')[0].replace(/:/g, '-').replace('T', '_');
+          await backup({ output: join(installDir, 'backups', `pre-update-${timestamp}.tar.gz`) });
         }
       },
       {

package/src/templates/docker-compose.yml.js

@@ -6,7 +6,13 @@
 export function generateDockerCompose(options = {}) {
   const {
     frontendPort = 8080,
-    backendPort = 3001
+    backendPort = 3001,
+    gateAppPort = 8081,
+    guardianAppPort = 8082,
+    installMain = true,
+    installGate = false,
+    installGuardian = false,
+    companyId = 1
   } = options;
 
   return `# ANTE ERP - Docker Compose Configuration
@@ -153,7 +159,7 @@ services:
         max-size: "50m"
         max-file: "5"
 
-  # ANTE Frontend
+  # ANTE Frontend Main
   frontend:
     image: ghcr.io/gtplusnet/ante-self-hosted-frontend-main:latest
     container_name: ante-frontend
@@ -162,8 +168,8 @@ services:
       backend:
         condition: service_healthy
     environment:
-      - API_URL=\${API_URL:-http://localhost:3001}
-      - SOCKET_URL=\${SOCKET_URL:-http://localhost:3001}
+      - API_URL=\${API_URL:-http://localhost:${backendPort}}
+      - SOCKET_URL=\${SOCKET_URL:-http://localhost:${backendPort}}
     ports:
       - "${frontendPort}:8080"
     networks:
@@ -178,7 +184,64 @@ services:
       options:
         max-size: "10m"
         max-file: "3"
-
+${installGate ? `
+  # ANTE Gate App
+  gate-app:
+    image: ghcr.io/gtplusnet/ante-self-hosted-frontend-gate-app:latest
+    container_name: ante-gate-app
+    restart: unless-stopped
+    depends_on:
+      backend:
+        condition: service_healthy
+    environment:
+      - NEXT_PUBLIC_API_URL=\${API_URL:-http://localhost:${backendPort}}
+      - NEXT_PUBLIC_BACKEND_URL=\${API_URL:-http://localhost:${backendPort}}
+      - NEXT_PUBLIC_SOCKET_URL=\${SOCKET_URL:-ws://localhost:${backendPort}}
+      - NEXT_PUBLIC_COMPANY_ID=${companyId}
+      - NEXT_PUBLIC_APP_NAME=Ante Gate
+    ports:
+      - "${gateAppPort}:3000"
+    networks:
+      - ante-network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+` : ''}${installGuardian ? `
+  # ANTE Guardian App
+  guardian-app:
+    image: ghcr.io/gtplusnet/ante-self-hosted-frontend-guardian-app:latest
+    container_name: ante-guardian-app
+    restart: unless-stopped
+    depends_on:
+      backend:
+        condition: service_healthy
+    environment:
+      - NEXT_PUBLIC_API_URL=\${API_URL:-http://localhost:${backendPort}}
+      - NEXT_PUBLIC_SOCKET_URL=\${SOCKET_URL:-ws://localhost:${backendPort}}
+      - NEXT_PUBLIC_COMPANY_ID=${companyId}
+      - NEXT_PUBLIC_APP_NAME=Ante Guardian
+    ports:
+      - "${guardianAppPort}:3000"
+    networks:
+      - ante-network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+` : ''}
 volumes:
   postgres_data:
     driver: local

package/src/templates/env.js

@@ -11,6 +11,13 @@ export function generateEnv(credentials, options = {}) {
     socketUrl = 'http://localhost:3001', // WebSocket uses same port as backend
     frontendPort = 8080,
     backendPort = 3001,
+    gateAppPort = 8081,
+    guardianAppPort = 8082,
+    gateAppUrl = 'http://localhost:8081',
+    guardianAppUrl = 'http://localhost:8082',
+    companyId = 1,
+    installGate = false,
+    installGuardian = false,
     smtpHost = '',
     smtpPort = 587,
     smtpUsername = '',
@@ -51,9 +58,18 @@ SOCKET_URL=${socketUrl}
 # ------------------------------------------------------------------------------
 FRONTEND_PORT=${frontendPort}
 BACKEND_PORT=${backendPort}
+${installGate ? `GATE_APP_PORT=${gateAppPort}` : '# GATE_APP_PORT=8081'}
+${installGuardian ? `GUARDIAN_APP_PORT=${guardianAppPort}` : '# GUARDIAN_APP_PORT=8082'}
 # Note: WebSocket runs on the same port as backend (BACKEND_PORT)
 
+${(installGate || installGuardian) ? `# ------------------------------------------------------------------------------
+# FRONTEND APP CONFIGURATION
 # ------------------------------------------------------------------------------
+COMPANY_ID=${companyId}
+${installGate ? `GATE_APP_URL=${gateAppUrl}` : '# GATE_APP_URL=http://localhost:8081'}
+${installGuardian ? `GUARDIAN_APP_URL=${guardianAppUrl}` : '# GUARDIAN_APP_URL=http://localhost:8082'}
+
+` : ''}# ------------------------------------------------------------------------------
 # EMAIL CONFIGURATION
 # ------------------------------------------------------------------------------
 SMTP_HOST=${smtpHost}