ante-erp-cli 1.11.69 → 1.11.70

package/bin/ante-cli.js

@@ -332,6 +332,7 @@ program
   .option('--pos <url>', 'POS App domain/URL (non-interactive mode)')
   .option('--mlm <url>', 'MLM App domain/URL (non-interactive mode)')
   .option('--backend-mlm <url>', 'Backend MLM API domain/URL (non-interactive mode)')
+  .option('--frontend-core-mobile <url>', 'Frontend Core Mobile domain/URL (non-interactive mode)')
   .option('--detect', 'Auto-detect public IP address')
   .option('--ssl, --enable-ssl', 'Enable SSL certificate (Let\'s Encrypt)')
   .option('--cloudflare-ssl', 'Enable Cloudflare SSL mode (self-signed cert for Full mode)')

package/package.json

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

package/src/commands/install.js

@@ -79,6 +79,7 @@ function showSuccess(installDir, credentials, config) {
   const frontendUrl = config.frontendDomain || 'http://localhost:8080';
   const apiUrl = config.apiDomain || 'http://localhost:3001';
   const frontendCoreUrl = config.frontendCoreDomain || 'http://localhost:8085';
+  const frontendCoreMobileUrl = config.frontendCoreMobileDomain || 'http://localhost:8086';
   const backendCoreUrl = config.backendCoreDomain || 'http://localhost:4002';
   const gateAppUrl = config.gateAppDomain || 'http://localhost:8081';
   const guardianAppUrl = config.guardianAppDomain || 'http://localhost:8082';
@@ -89,7 +90,8 @@ function showSuccess(installDir, credentials, config) {
   let accessInfo = chalk.white('Access Information:') + '\n' +
     chalk.gray('━'.repeat(40)) + '\n' +
     chalk.cyan('Frontend Main: ') + chalk.white(frontendUrl) + '\n' +
-    chalk.cyan('Frontend Core: ') + chalk.white(frontendCoreUrl) + '\n';
+    chalk.cyan('Frontend Core: ') + chalk.white(frontendCoreUrl) + '\n' +
+    chalk.cyan('Frontend Core Mobile: ') + chalk.white(frontendCoreMobileUrl) + '\n';
 
   if (config.installGate) {
     accessInfo += chalk.cyan('Gate App:      ') + chalk.white(gateAppUrl) + '\n';
@@ -325,6 +327,7 @@ export async function install(options) {
     const backendMlmPort = 4001;
     const backendCorePort = 4002;
     const frontendCorePort = 8085;
+    const frontendCoreMobilePort = 8086;
     const gateAppPort = 8081;
     const guardianAppPort = 8082;
     const facialWebPort = 8083;
@@ -339,6 +342,7 @@ export async function install(options) {
       mlmApiDomain: buildURL(host, backendMlmPort),
       backendCoreDomain: buildURL(host, backendCorePort),
       frontendCoreDomain: buildURL(host, frontendCorePort),
+      frontendCoreMobileDomain: buildURL(host, frontendCoreMobilePort),
       gateAppDomain: buildURL(host, gateAppPort),
       guardianAppDomain: buildURL(host, guardianAppPort),
       facialAppDomain: buildURL(host, facialWebPort),
@@ -349,6 +353,7 @@ export async function install(options) {
       backendMlmPort,
       backendCorePort,
       frontendCorePort,
+      frontendCoreMobilePort,
       gateAppPort,
       guardianAppPort,
       facialWebPort,
@@ -360,7 +365,7 @@ export async function install(options) {
       installFacial: true,
       installPos: true,
       installMlm: true,
-      frontends: ['main', 'gate', 'guardian', 'facial', 'pos', 'mlm', 'core']
+      frontends: ['main', 'gate', 'guardian', 'facial', 'pos', 'mlm', 'core', 'core-mobile']
     };
 
     console.log(chalk.green(`✓ ${formatStepTitle(stepNetworkDetect, totalSteps, `Network detected: ${host}`)}\n`));
@@ -370,6 +375,7 @@ export async function install(options) {
     console.log(chalk.cyan('  Directory:'), chalk.white(config.installDir));
     console.log(chalk.cyan('  Frontend Main:'), chalk.white(config.frontendDomain));
     console.log(chalk.cyan('  Frontend Core:'), chalk.white(config.frontendCoreDomain));
+    console.log(chalk.cyan('  Frontend Core Mobile:'), chalk.white(config.frontendCoreMobileDomain));
     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));
@@ -456,6 +462,7 @@ export async function install(options) {
             backendMlmPort: config.backendMlmPort,
             backendCorePort: config.backendCorePort,
             frontendCorePort: config.frontendCorePort,
+            frontendCoreMobilePort: config.frontendCoreMobilePort,
             gateAppPort: config.gateAppPort,
             guardianAppPort: config.guardianAppPort,
             facialWebPort: config.facialWebPort,
@@ -479,6 +486,7 @@ export async function install(options) {
             backendMlmPort: config.backendMlmPort,
             backendCorePort: config.backendCorePort,
             frontendCorePort: config.frontendCorePort,
+            frontendCoreMobilePort: config.frontendCoreMobilePort,
             gateAppPort: config.gateAppPort,
             guardianAppPort: config.guardianAppPort,
             facialWebPort: config.facialWebPort,
@@ -491,6 +499,7 @@ export async function install(options) {
             mlmAppUrl: config.mlmAppDomain,
             mlmApiUrl: config.mlmApiDomain,
             frontendCoreUrl: config.frontendCoreDomain,
+            frontendCoreMobileUrl: config.frontendCoreMobileDomain,
             backendCoreUrl: config.backendCoreDomain,
             companyId: config.companyId,
             installGate: config.installGate,

package/src/commands/regenerate-compose.js

@@ -76,6 +76,7 @@ export async function regenerateCompose() {
     console.log(chalk.gray(`  Frontend Main:  ${installed.hasMain ? '✓ Installed' : '✗ Not installed'}`));
     console.log(chalk.gray(`  Backend Core:   ✓ Always Included`));
     console.log(chalk.gray(`  Frontend Core:  ✓ Always Included`));
+    console.log(chalk.gray(`  Frontend Core Mobile: ✓ Always Included`));
     console.log(chalk.gray(`  Gate App:       ${installed.hasGateApp ? '✓ Installed' : '✗ Not installed'}`));
     console.log(chalk.gray(`  Guardian App:   ${installed.hasGuardianApp ? '✓ Installed' : '✗ Not installed'}`));
     console.log(chalk.gray(`  Facial Web:     ${installed.hasFacialWeb ? '✓ Installed' : '✗ Not installed'}`));
@@ -91,6 +92,7 @@ export async function regenerateCompose() {
     const backendMlmPort = parseInt(envConfig.BACKEND_MLM_PORT) || 4001;
     const backendCorePort = parseInt(envConfig.BACKEND_CORE_PORT) || 4002;
     const frontendCorePort = parseInt(envConfig.FRONTEND_CORE_PORT) || 8085;
+    const frontendCoreMobilePort = parseInt(envConfig.FRONTEND_CORE_MOBILE_PORT) || 8086;
     const gateAppPort = parseInt(envConfig.GATE_APP_PORT) || 8081;
     const guardianAppPort = parseInt(envConfig.GUARDIAN_APP_PORT) || 8082;
     const facialWebPort = parseInt(envConfig.FACIAL_WEB_PORT) || 8083;
@@ -103,6 +105,7 @@ export async function regenerateCompose() {
     console.log(chalk.gray(`  Backend:        ${backendPort}`));
     console.log(chalk.gray(`  Backend Core:   ${backendCorePort}`));
     console.log(chalk.gray(`  Frontend Core:  ${frontendCorePort}`));
+    console.log(chalk.gray(`  Frontend Core Mobile: ${frontendCoreMobilePort}`));
     if (installed.hasGateApp) {
       console.log(chalk.gray(`  Gate App:       ${gateAppPort}`));
     }
@@ -137,6 +140,7 @@ export async function regenerateCompose() {
       backendMlmPort,
       backendCorePort,
       frontendCorePort,
+      frontendCoreMobilePort,
       gateAppPort,
       guardianAppPort,
       facialWebPort,

package/src/commands/set-domain.js

@@ -97,9 +97,9 @@ function getEnvValue(envPath, key) {
 }
 
 /**
- * Check if gate-app, guardian-app, facial-web, pos-app, mlm-app, backend-mlm, frontend-core, or backend-core is installed by checking docker-compose.yml
+ * Check if gate-app, guardian-app, facial-web, pos-app, mlm-app, backend-mlm, frontend-core, frontend-core-mobile, or backend-core is installed by checking docker-compose.yml
  * @param {string} composeFile - Path to docker-compose.yml
- * @returns {{hasGateApp: boolean, hasGuardianApp: boolean, hasFacialWeb: boolean, hasPosApp: boolean, hasMlmApp: boolean, hasBackendMlm: boolean, hasFrontendCore: boolean, hasBackendCore: boolean}}
+ * @returns {{hasGateApp: boolean, hasGuardianApp: boolean, hasFacialWeb: boolean, hasPosApp: boolean, hasMlmApp: boolean, hasBackendMlm: boolean, hasFrontendCore: boolean, hasFrontendCoreMobile: boolean, hasBackendCore: boolean}}
  */
 function detectInstalledApps(composeFile) {
   try {
@@ -112,10 +112,11 @@ function detectInstalledApps(composeFile) {
       hasMlmApp: composeContent.includes('mlm-app:') || composeContent.includes('container_name: ante-mlm'),
       hasBackendMlm: composeContent.includes('backend-mlm:') || composeContent.includes('container_name: ante-backend-mlm'),
       hasFrontendCore: composeContent.includes('frontend-core:') || composeContent.includes('container_name: ante-frontend-core'),
+      hasFrontendCoreMobile: composeContent.includes('frontend-core-mobile:') || composeContent.includes('container_name: ante-frontend-core-mobile'),
       hasBackendCore: composeContent.includes('backend-core:') || composeContent.includes('container_name: ante-backend-core')
     };
   } catch {
-    return { hasGateApp: false, hasGuardianApp: false, hasFacialWeb: false, hasPosApp: false, hasMlmApp: false, hasBackendMlm: false, hasFrontendCore: false, hasBackendCore: false };
+    return { hasGateApp: false, hasGuardianApp: false, hasFacialWeb: false, hasPosApp: false, hasMlmApp: false, hasBackendMlm: false, hasFrontendCore: false, hasFrontendCoreMobile: true, hasBackendCore: false };
   }
 }
 
@@ -174,10 +175,10 @@ export async function setDomain(options) {
       console.log(); // Add spacing
     }
 
-    let frontendUrl, apiUrl, gateAppUrl, guardianAppUrl, facialWebUrl, posAppUrl, mlmAppUrl, backendMlmUrl, frontendCoreUrl, backendCoreUrl;
+    let frontendUrl, apiUrl, gateAppUrl, guardianAppUrl, facialWebUrl, posAppUrl, mlmAppUrl, backendMlmUrl, frontendCoreUrl, frontendCoreMobileUrl, backendCoreUrl;
 
     // Detect which apps are installed
-    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasBackendCore } = detectInstalledApps(composeFile);
+    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasFrontendCoreMobile, hasBackendCore } = detectInstalledApps(composeFile);
 
     if (options.interactive !== false) {
       // Show current values
@@ -190,6 +191,7 @@ export async function setDomain(options) {
       const currentClientAppUrl = getEnvValue(envPath, 'MLM_APP_URL');
       const currentBackendClientUrl = getEnvValue(envPath, 'MLM_API_URL');
       const currentFrontendCoreUrl = getEnvValue(envPath, 'FRONTEND_CORE_URL');
+      const currentFrontendCoreMobileUrl = getEnvValue(envPath, 'FRONTEND_CORE_MOBILE_URL');
       const currentBackendCoreUrl = getEnvValue(envPath, 'BACKEND_CORE_URL');
 
       if (currentFrontendUrl) {
@@ -216,6 +218,9 @@ export async function setDomain(options) {
       if (currentFrontendCoreUrl) {
         console.log(chalk.gray(`Current Frontend Core URL: ${currentFrontendCoreUrl}`));
       }
+      if (currentFrontendCoreMobileUrl) {
+        console.log(chalk.gray(`Current Frontend Core Mobile URL: ${currentFrontendCoreMobileUrl}`));
+      }
       if (currentBackendCoreUrl) {
         console.log(chalk.gray(`Current Backend Core API URL: ${currentBackendCoreUrl}`));
       }
@@ -507,6 +512,7 @@ export async function setDomain(options) {
           if (hasMlmApp) mlmAppUrl = `https://${subdomain}-mlm.ante.ph`;
           if (hasBackendMlm) backendMlmUrl = `https://${subdomain}-api-mlm.ante.ph`;
           if (hasFrontendCore) frontendCoreUrl = `https://${subdomain}-core.ante.ph`;
+          if (hasFrontendCoreMobile) frontendCoreMobileUrl = `https://${subdomain}-mobile.ante.ph`;
           if (hasBackendCore) backendCoreUrl = `https://${subdomain}-api-core.ante.ph`;
 
           // Display generated domains for confirmation
@@ -520,6 +526,7 @@ export async function setDomain(options) {
           if (hasMlmApp) console.log(chalk.gray(`  MLM App:      ${mlmAppUrl}`));
           if (hasBackendMlm) console.log(chalk.gray(`  Backend-MLM:  ${backendMlmUrl}`));
           if (hasFrontendCore) console.log(chalk.gray(`  Frontend Core:   ${frontendCoreUrl}`));
+          if (hasFrontendCoreMobile) console.log(chalk.gray(`  Frontend Core Mobile: ${frontendCoreMobileUrl}`));
           if (hasBackendCore) console.log(chalk.gray(`  Backend Core:    ${backendCoreUrl}`));
           console.log('');
 
@@ -618,6 +625,16 @@ export async function setDomain(options) {
             });
           }
 
+          if (hasFrontendCoreMobile) {
+            domainPrompts.push({
+              type: 'input',
+              name: 'frontendCoreMobileUrl',
+              message: 'Frontend Core Mobile URL:\n  Examples: https://staging-mobile.ante.ph or http://143.198.91.153:8086\n  Enter URL',
+              default: currentFrontendCoreMobileUrl || 'http://localhost:8086',
+              validate: validateUrl
+            });
+          }
+
           if (hasBackendCore) {
             domainPrompts.push({
               type: 'input',
@@ -648,6 +665,7 @@ export async function setDomain(options) {
           if (hasMlmApp) mlmAppUrl = sanitizeUrl(answers.mlmAppUrl);
           if (hasBackendMlm) backendMlmUrl = sanitizeUrl(answers.backendMlmUrl);
           if (hasFrontendCore) frontendCoreUrl = sanitizeUrl(answers.frontendCoreUrl);
+          if (hasFrontendCoreMobile) frontendCoreMobileUrl = sanitizeUrl(answers.frontendCoreMobileUrl);
           if (hasBackendCore) backendCoreUrl = sanitizeUrl(answers.backendCoreUrl);
         }
       }
@@ -745,6 +763,17 @@ export async function setDomain(options) {
         }
       }
 
+      if (hasFrontendCoreMobile) {
+        frontendCoreMobileUrl = options.frontendCoreMobile ? sanitizeUrl(options.frontendCoreMobile) : getEnvValue(envPath, 'FRONTEND_CORE_MOBILE_URL');
+        if (frontendCoreMobileUrl) {
+          const validation = validateUrl(frontendCoreMobileUrl);
+          if (validation !== true) {
+            console.log(chalk.red(`Error: Invalid Frontend Core Mobile URL - ${validation}`));
+            process.exit(1);
+          }
+        }
+      }
+
       // Show what will be configured in non-interactive mode
       console.log(chalk.cyan('\n📋 Non-interactive mode configuration:\n'));
       console.log(chalk.gray(`  Frontend:     ${frontendUrl}`));
@@ -755,6 +784,7 @@ export async function setDomain(options) {
       if (hasPosApp && posAppUrl) console.log(chalk.gray(`  POS App:      ${posAppUrl}`));
       if (hasMlmApp && mlmAppUrl) console.log(chalk.gray(`  MLM App:   ${mlmAppUrl}`));
       if (hasBackendMlm && backendMlmUrl) console.log(chalk.gray(`  Backend-MLM: ${backendMlmUrl}`));
+      if (hasFrontendCoreMobile && frontendCoreMobileUrl) console.log(chalk.gray(`  Frontend Core Mobile: ${frontendCoreMobileUrl}`));
       console.log('');
     }
 
@@ -795,6 +825,10 @@ export async function setDomain(options) {
       envUpdates.FRONTEND_CORE_URL = frontendCoreUrl;
     }
 
+    if (hasFrontendCoreMobile && frontendCoreMobileUrl) {
+      envUpdates.FRONTEND_CORE_MOBILE_URL = frontendCoreMobileUrl;
+    }
+
     if (hasBackendCore && backendCoreUrl) {
       envUpdates.BACKEND_CORE_URL = backendCoreUrl;
     }
@@ -862,6 +896,11 @@ export async function setDomain(options) {
           nginxConfig.frontendCorePort = 8085;
         }
 
+        if (hasFrontendCoreMobile && frontendCoreMobileUrl) {
+          nginxConfig.frontendCoreMobileDomain = frontendCoreMobileUrl;
+          nginxConfig.frontendCoreMobilePort = 8086;
+        }
+
         if (hasBackendCore && backendCoreUrl) {
           nginxConfig.backendCoreDomain = backendCoreUrl;
           nginxConfig.backendCorePort = 4002;
@@ -985,6 +1024,12 @@ export async function setDomain(options) {
                 domains.push(frontendCoreDomain);
               }
             }
+            if (hasFrontendCoreMobile && frontendCoreMobileUrl && frontendCoreMobileUrl.startsWith('https://')) {
+              const frontendCoreMobileDomain = extractDomain(frontendCoreMobileUrl);
+              if (frontendCoreMobileDomain !== 'localhost' && !frontendCoreMobileDomain.match(/^\d+\.\d+\.\d+\.\d+$/) && !domains.includes(frontendCoreMobileDomain)) {
+                domains.push(frontendCoreMobileDomain);
+              }
+            }
             if (hasBackendCore && backendCoreUrl && backendCoreUrl.startsWith('https://')) {
               const backendCoreDomain = extractDomain(backendCoreUrl);
               if (backendCoreDomain !== 'localhost' && !backendCoreDomain.match(/^\d+\.\d+\.\d+\.\d+$/) && !domains.includes(backendCoreDomain)) {
@@ -1087,6 +1132,11 @@ export async function setDomain(options) {
                 sslNginxConfig.frontendCorePort = 8085;
               }
 
+              if (hasFrontendCoreMobile && frontendCoreMobileUrl) {
+                sslNginxConfig.frontendCoreMobileDomain = frontendCoreMobileUrl;
+                sslNginxConfig.frontendCoreMobilePort = 8086;
+              }
+
               if (hasBackendCore && backendCoreUrl) {
                 sslNginxConfig.backendCoreDomain = backendCoreUrl;
                 sslNginxConfig.backendCorePort = 4002;
@@ -1255,6 +1305,9 @@ export async function setDomain(options) {
     if (hasFrontendCore && frontendCoreUrl) {
       console.log(chalk.cyan('Frontend Core: '), chalk.white(frontendCoreUrl));
     }
+    if (hasFrontendCoreMobile && frontendCoreMobileUrl) {
+      console.log(chalk.cyan('Frontend Core Mobile: '), chalk.white(frontendCoreMobileUrl));
+    }
     if (hasBackendCore && backendCoreUrl) {
       console.log(chalk.cyan('Backend Core:  '), chalk.white(backendCoreUrl));
     }
@@ -1278,6 +1331,9 @@ export async function setDomain(options) {
     if (hasFrontendCore && frontendCoreUrl) {
       console.log(chalk.white(`   Frontend Core: ${frontendCoreUrl}`));
     }
+    if (hasFrontendCoreMobile && frontendCoreMobileUrl) {
+      console.log(chalk.white(`   Frontend Core Mobile: ${frontendCoreMobileUrl}`));
+    }
     if (hasBackendCore && backendCoreUrl) {
       console.log(chalk.white(`   Backend Core:  ${backendCoreUrl}`));
     }

package/src/commands/ssl-enable.js

@@ -48,7 +48,7 @@ function getEnvValue(envPath, key) {
 /**
  * Check if optional apps are installed by checking docker-compose.yml
  * @param {string} composeFile - Path to docker-compose.yml
- * @returns {{hasGateApp: boolean, hasGuardianApp: boolean, hasFacialWeb: boolean, hasPosApp: boolean, hasMlmApp: boolean, hasBackendMlm: boolean, hasFrontendCore: boolean, hasBackendCore: boolean}}
+ * @returns {{hasGateApp: boolean, hasGuardianApp: boolean, hasFacialWeb: boolean, hasPosApp: boolean, hasMlmApp: boolean, hasBackendMlm: boolean, hasFrontendCore: boolean, hasFrontendCoreMobile: boolean, hasBackendCore: boolean}}
  */
 function detectInstalledApps(composeFile) {
   try {
@@ -61,10 +61,11 @@ function detectInstalledApps(composeFile) {
       hasMlmApp: composeContent.includes('mlm-app:') || composeContent.includes('container_name: ante-mlm'),
       hasBackendMlm: composeContent.includes('backend-mlm:') || composeContent.includes('container_name: ante-backend-mlm'),
       hasFrontendCore: composeContent.includes('frontend-core:') || composeContent.includes('container_name: ante-frontend-core'),
+      hasFrontendCoreMobile: composeContent.includes('frontend-core-mobile:') || composeContent.includes('container_name: ante-frontend-core-mobile'),
       hasBackendCore: composeContent.includes('backend-core:') || composeContent.includes('container_name: ante-backend-core')
     };
   } catch {
-    return { hasGateApp: false, hasGuardianApp: false, hasFacialWeb: false, hasPosApp: false, hasMlmApp: false, hasBackendMlm: false, hasFrontendCore: true, hasBackendCore: true };
+    return { hasGateApp: false, hasGuardianApp: false, hasFacialWeb: false, hasPosApp: false, hasMlmApp: false, hasBackendMlm: false, hasFrontendCore: true, hasFrontendCoreMobile: true, hasBackendCore: true };
   }
 }
 
@@ -92,7 +93,7 @@ export async function sslEnable(options) {
     console.log(chalk.gray(`Installation: ${installDir}\n`));
 
     // Detect which apps are installed
-    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasBackendCore } = detectInstalledApps(composeFile);
+    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasFrontendCoreMobile, hasBackendCore } = detectInstalledApps(composeFile);
 
     // Read current configuration
     const frontendUrl = getEnvValue(envPath, 'FRONTEND_URL');
@@ -104,6 +105,7 @@ export async function sslEnable(options) {
     const mlmAppUrl = hasMlmApp ? getEnvValue(envPath, 'MLM_APP_URL') : '';
     const backendMlmUrl = hasBackendMlm ? getEnvValue(envPath, 'MLM_API_URL') : '';
     const frontendCoreUrl = hasFrontendCore ? getEnvValue(envPath, 'FRONTEND_CORE_URL') : '';
+    const frontendCoreMobileUrl = hasFrontendCoreMobile ? getEnvValue(envPath, 'FRONTEND_CORE_MOBILE_URL') : '';
     const backendCoreUrl = hasBackendCore ? getEnvValue(envPath, 'BACKEND_CORE_URL') : '';
 
     if (!frontendUrl || !apiUrl) {
@@ -126,12 +128,14 @@ export async function sslEnable(options) {
                      (!mlmAppUrl || mlmAppUrl.startsWith('https://')) &&
                      (!backendMlmUrl || backendMlmUrl.startsWith('https://')) &&
                      (!frontendCoreUrl || frontendCoreUrl.startsWith('https://')) &&
+                     (!frontendCoreMobileUrl || frontendCoreMobileUrl.startsWith('https://')) &&
                      (!backendCoreUrl || backendCoreUrl.startsWith('https://'));
 
     if (allHttps) {
       console.log(chalk.yellow('⚠  Domains are already configured with HTTPS:\n'));
       console.log(chalk.gray(`   Frontend: ${frontendUrl}`));
       if (frontendCoreUrl) console.log(chalk.gray(`   Frontend Core: ${frontendCoreUrl}`));
+      if (frontendCoreMobileUrl) console.log(chalk.gray(`   Frontend Core Mobile: ${frontendCoreMobileUrl}`));
       if (gateAppUrl) console.log(chalk.gray(`   Gate App: ${gateAppUrl}`));
       if (guardianAppUrl) console.log(chalk.gray(`   Guardian: ${guardianAppUrl}`));
       if (facialWebUrl) console.log(chalk.gray(`   Facial Web: ${facialWebUrl}`));
@@ -205,6 +209,14 @@ export async function sslEnable(options) {
         }
       }
 
+      if (frontendCoreMobileUrl) {
+        const frontendCoreMobileDomain = extractDomain(frontendCoreMobileUrl);
+        const frontendCoreMobileStatus = await checkSSLStatus(frontendCoreMobileDomain);
+        if (frontendCoreMobileStatus.installed) {
+          console.log(chalk.green(`✓ Frontend Core Mobile SSL: Valid (expires in ${frontendCoreMobileStatus.daysUntilExpiry} days)`));
+        }
+      }
+
       if (backendCoreUrl) {
         const backendCoreDomain = extractDomain(backendCoreUrl);
         const backendCoreStatus = await checkSSLStatus(backendCoreDomain);
@@ -243,6 +255,7 @@ export async function sslEnable(options) {
     console.log(chalk.cyan('Current Configuration:'));
     console.log(chalk.gray(`   Frontend: ${frontendUrl}`));
     if (frontendCoreUrl) console.log(chalk.gray(`   Frontend Core: ${frontendCoreUrl}`));
+    if (frontendCoreMobileUrl) console.log(chalk.gray(`   Frontend Core Mobile: ${frontendCoreMobileUrl}`));
     if (gateAppUrl) console.log(chalk.gray(`   Gate App: ${gateAppUrl}`));
     if (guardianAppUrl) console.log(chalk.gray(`   Guardian: ${guardianAppUrl}`));
     if (facialWebUrl) console.log(chalk.gray(`   Facial Web: ${facialWebUrl}`));
@@ -348,6 +361,18 @@ export async function sslEnable(options) {
       }
     }
 
+    if (frontendCoreMobileUrl) {
+      const frontendCoreMobileDomain = extractDomain(frontendCoreMobileUrl);
+      if (frontendCoreMobileDomain !== 'localhost' && !frontendCoreMobileDomain.match(/^\d+\.\d+\.\d+\.\d+$/) && !domains.find(d => d.domain === frontendCoreMobileDomain)) {
+        domains.push({
+          name: 'Frontend Core Mobile',
+          domain: frontendCoreMobileDomain,
+          port: frontendCoreMobileUrl.match(/:(\d+)/) ? frontendCoreMobileUrl.match(/:(\d+)/)[1] : 8086,
+          url: frontendCoreMobileUrl
+        });
+      }
+    }
+
     if (backendCoreUrl) {
       const backendCoreDomain = extractDomain(backendCoreUrl);
       if (backendCoreDomain !== 'localhost' && !backendCoreDomain.match(/^\d+\.\d+\.\d+\.\d+$/) && !domains.find(d => d.domain === backendCoreDomain)) {
@@ -528,6 +553,11 @@ export async function sslEnable(options) {
         sslConfig.frontendCorePort = frontendCoreUrl.match(/:(\d+)/) ? parseInt(frontendCoreUrl.match(/:(\d+)/)[1]) : 8085;
       }
 
+      if (frontendCoreMobileUrl) {
+        sslConfig.frontendCoreMobileDomain = frontendCoreMobileUrl;
+        sslConfig.frontendCoreMobilePort = frontendCoreMobileUrl.match(/:(\d+)/) ? parseInt(frontendCoreMobileUrl.match(/:(\d+)/)[1]) : 8086;
+      }
+
       if (backendCoreUrl) {
         sslConfig.backendCoreDomain = backendCoreUrl;
         sslConfig.backendCorePort = backendCoreUrl.match(/:(\d+)/) ? parseInt(backendCoreUrl.match(/:(\d+)/)[1]) : 4002;
@@ -619,7 +649,7 @@ export async function sslStatus() {
     const composeFile = join(installDir, 'docker-compose.yml');
 
     // Detect which apps are installed
-    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasBackendCore } = detectInstalledApps(composeFile);
+    const { hasGateApp, hasGuardianApp, hasFacialWeb, hasPosApp, hasMlmApp, hasBackendMlm, hasFrontendCore, hasFrontendCoreMobile, hasBackendCore } = detectInstalledApps(composeFile);
 
     const frontendUrl = getEnvValue(envPath, 'FRONTEND_URL');
     const apiUrl = getEnvValue(envPath, 'API_URL');
@@ -630,6 +660,7 @@ export async function sslStatus() {
     const mlmAppUrl = hasMlmApp ? getEnvValue(envPath, 'MLM_APP_URL') : '';
     const backendMlmUrl = hasBackendMlm ? getEnvValue(envPath, 'MLM_API_URL') : '';
     const frontendCoreUrl = hasFrontendCore ? getEnvValue(envPath, 'FRONTEND_CORE_URL') : '';
+    const frontendCoreMobileUrl = hasFrontendCoreMobile ? getEnvValue(envPath, 'FRONTEND_CORE_MOBILE_URL') : '';
     const backendCoreUrl = hasBackendCore ? getEnvValue(envPath, 'BACKEND_CORE_URL') : '';
 
     if (!frontendUrl || !apiUrl) {
@@ -679,6 +710,11 @@ export async function sslStatus() {
       domains.push({ name: 'Frontend Core', domain: frontendCoreDomain, url: frontendCoreUrl });
     }
 
+    if (frontendCoreMobileUrl) {
+      const frontendCoreMobileDomain = extractDomain(frontendCoreMobileUrl);
+      domains.push({ name: 'Frontend Core Mobile', domain: frontendCoreMobileDomain, url: frontendCoreMobileUrl });
+    }
+
     if (backendCoreUrl) {
       const backendCoreDomain = extractDomain(backendCoreUrl);
       domains.push({ name: 'Backend Core', domain: backendCoreDomain, url: backendCoreUrl });

package/src/commands/update.js

@@ -84,6 +84,7 @@ function updateDockerCompose(composeFile, envFile, newServices) {
     backendMlmPort: parseInt(envConfig.BACKEND_MLM_PORT) || 4001,
     backendCorePort: parseInt(envConfig.BACKEND_CORE_PORT) || 4002,
     frontendCorePort: parseInt(envConfig.FRONTEND_CORE_PORT) || 8085,
+    frontendCoreMobilePort: parseInt(envConfig.FRONTEND_CORE_MOBILE_PORT) || 8086,
     gateAppPort: parseInt(envConfig.GATE_APP_PORT) || 8081,
     guardianAppPort: parseInt(envConfig.GUARDIAN_APP_PORT) || 8082,
     facialWebPort: parseInt(envConfig.FACIAL_WEB_PORT) || 8083,
@@ -351,6 +352,7 @@ function refreshDockerCompose(composeFile, envFile) {
     backendMlmPort: parseInt(envConfig.BACKEND_MLM_PORT) || 4001,
     backendCorePort: parseInt(envConfig.BACKEND_CORE_PORT) || 4002,
     frontendCorePort: parseInt(envConfig.FRONTEND_CORE_PORT) || 8085,
+    frontendCoreMobilePort: parseInt(envConfig.FRONTEND_CORE_MOBILE_PORT) || 8086,
     gateAppPort: parseInt(envConfig.GATE_APP_PORT) || 8081,
     guardianAppPort: parseInt(envConfig.GUARDIAN_APP_PORT) || 8082,
     facialWebPort: parseInt(envConfig.FACIAL_WEB_PORT) || 8083,
@@ -402,6 +404,7 @@ function getRequiredPorts(composeFile, envFile) {
   ports.push(parseInt(envConfig.FRONTEND_PORT) || 8080); // Frontend
   ports.push(parseInt(envConfig.BACKEND_CORE_PORT) || 4002); // Backend Core (always included)
   ports.push(parseInt(envConfig.FRONTEND_CORE_PORT) || 8085); // Frontend Core (always included)
+  ports.push(parseInt(envConfig.FRONTEND_CORE_MOBILE_PORT) || 8086); // Frontend Core Mobile (always included)
 
   // Optional services - only add if installed
   if (installed.hasGateApp) {

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

@@ -10,6 +10,7 @@ export function generateDockerCompose(options = {}) {
     backendMlmPort = 4001,
     backendCorePort = 4002,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     gateAppPort = 8081,
     guardianAppPort = 8082,
     facialWebPort = 8083,
@@ -258,6 +259,34 @@ services:
       options:
         max-size: "10m"
         max-file: "3"
+
+  # ANTE Frontend Core Mobile - React Mobile Application
+  frontend-core-mobile:
+    image: ghcr.io/gtplusnet/ante-self-hosted-frontend-core-mobile:\${IMAGE_TAG:-latest}
+    container_name: ante-frontend-core-mobile
+    restart: unless-stopped
+    depends_on:
+      backend-core:
+        condition: service_healthy
+    environment:
+      - VITE_API_URL=\${BACKEND_CORE_URL:-http://localhost:${backendCorePort}}
+      - VITE_APP_NAME=ANTE Frontend Core Mobile
+      - VITE_APP_VERSION=\${VERSION:-1.0.0}
+    ports:
+      - "${frontendCoreMobilePort}:8086"
+    networks:
+      - ante-network
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8086/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
 ${installGate ? `
   # ANTE Gate App
   gate-app:

package/src/templates/env.js

@@ -14,6 +14,7 @@ export function generateEnv(credentials, options = {}) {
     backendMlmPort = 4001,
     backendCorePort = 4002,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     gateAppPort = 8081,
     guardianAppPort = 8082,
     facialWebPort = 8083,
@@ -26,6 +27,7 @@ export function generateEnv(credentials, options = {}) {
     mlmAppUrl = 'http://localhost:9005',
     mlmApiUrl = 'http://localhost:4001',
     frontendCoreUrl = 'http://localhost:8085',
+    frontendCoreMobileUrl = 'http://localhost:8086',
     backendCoreUrl = 'http://localhost:4002',
     companyId = 1,
     installGate = false,
@@ -80,6 +82,7 @@ FRONTEND_PORT=${frontendPort}
 BACKEND_PORT=${backendPort}
 BACKEND_CORE_PORT=${backendCorePort}
 FRONTEND_CORE_PORT=${frontendCorePort}
+FRONTEND_CORE_MOBILE_PORT=${frontendCoreMobilePort}
 ${installMlm ? `BACKEND_MLM_PORT=${backendMlmPort}` : '# BACKEND_MLM_PORT=4001'}
 ${installGate ? `GATE_APP_PORT=${gateAppPort}` : '# GATE_APP_PORT=8081'}
 ${installGuardian ? `GUARDIAN_APP_PORT=${guardianAppPort}` : '# GUARDIAN_APP_PORT=8082'}
@@ -92,6 +95,7 @@ ${installMlm ? `MLM_APP_PORT=${mlmAppPort}` : '# MLM_APP_PORT=9005'}
 # CORE SERVICES CONFIGURATION (Always Included)
 # ------------------------------------------------------------------------------
 FRONTEND_CORE_URL=${frontendCoreUrl}
+FRONTEND_CORE_MOBILE_URL=${frontendCoreMobileUrl}
 BACKEND_CORE_URL=${backendCoreUrl}
 CORE_API_URL=${backendCoreUrl}
 

package/src/utils/nginx.js

@@ -55,6 +55,7 @@ export async function installNginx(spinner) {
  * @param {string} [config.mlmAppDomain] - MLM app domain (optional)
  * @param {string} [config.backendMlmDomain] - Backend MLM API domain (optional)
  * @param {string} [config.frontendCoreDomain] - Frontend Core app domain (optional)
+ * @param {string} [config.frontendCoreMobileDomain] - Frontend Core Mobile app domain (optional)
  * @param {string} [config.backendCoreDomain] - Backend Core API domain (optional)
  * @param {number} config.frontendPort - Frontend Docker port (default: 8080)
  * @param {number} config.apiPort - API Docker port (default: 3001)
@@ -65,6 +66,7 @@ export async function installNginx(spinner) {
  * @param {number} [config.mlmAppPort] - MLM app Docker port (default: 9005)
  * @param {number} [config.backendMlmPort] - Backend MLM API Docker port (default: 4001)
  * @param {number} [config.frontendCorePort] - Frontend Core Docker port (default: 8085)
+ * @param {number} [config.frontendCoreMobilePort] - Frontend Core Mobile Docker port (default: 8086)
  * @param {number} [config.backendCorePort] - Backend Core API Docker port (default: 4002)
  * @param {boolean} config.ssl - Enable SSL configuration with Let's Encrypt (default: false)
  * @param {boolean} config.cloudflareSsl - Enable Cloudflare SSL mode with self-signed certs (default: false)
@@ -81,6 +83,7 @@ export function generateNginxConfig(config) {
     mlmAppDomain,
     backendMlmDomain,
     frontendCoreDomain,
+    frontendCoreMobileDomain,
     backendCoreDomain,
     frontendPort = 8080,
     apiPort = 3001,
@@ -91,6 +94,7 @@ export function generateNginxConfig(config) {
     mlmAppPort = 9005,
     backendMlmPort = 4001,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     backendCorePort = 4002,
     ssl = false,
     cloudflareSsl = false,
@@ -107,6 +111,7 @@ export function generateNginxConfig(config) {
   const mlmAppHost = mlmAppDomain ? mlmAppDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '') : null;
   const backendMlmHost = backendMlmDomain ? backendMlmDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '') : null;
   const frontendCoreHost = frontendCoreDomain ? frontendCoreDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '') : null;
+  const frontendCoreMobileHost = frontendCoreMobileDomain ? frontendCoreMobileDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '') : null;
   const backendCoreHost = backendCoreDomain ? backendCoreDomain.replace(/^https?:\/\//, '').replace(/:\d+$/, '') : null;
 
   // Cloudflare SSL mode - uses self-signed certs for Cloudflare "Full" mode
@@ -121,6 +126,7 @@ export function generateNginxConfig(config) {
       mlmAppHost,
       backendMlmHost,
       frontendCoreHost,
+      frontendCoreMobileHost,
       backendCoreHost,
       frontendPort,
       apiPort,
@@ -131,6 +137,7 @@ export function generateNginxConfig(config) {
       mlmAppPort,
       backendMlmPort,
       frontendCorePort,
+      frontendCoreMobilePort,
       backendCorePort
     });
   }
@@ -147,6 +154,7 @@ export function generateNginxConfig(config) {
       mlmAppHost,
       backendMlmHost,
       frontendCoreHost,
+      frontendCoreMobileHost,
       backendCoreHost,
       frontendPort,
       apiPort,
@@ -157,6 +165,7 @@ export function generateNginxConfig(config) {
       mlmAppPort,
       backendMlmPort,
       frontendCorePort,
+      frontendCoreMobilePort,
       backendCorePort,
       domainsWithCerts
     });
@@ -454,6 +463,47 @@ server {
         proxy_read_timeout 60s;
     }
 }
+` : ''}${frontendCoreMobileHost ? `
+# ANTE Frontend Core Mobile Configuration
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${frontendCoreMobileHost};
+
+    # 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;
+
+    # Disable caching for config.js to ensure runtime config is always fresh
+    location = /config.js {
+        proxy_pass http://localhost:${frontendCoreMobilePort}/config.js;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0" always;
+        add_header Pragma "no-cache" always;
+        add_header Expires "0" always;
+    }
+
+    location / {
+        proxy_pass http://localhost:${frontendCoreMobilePort};
+        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;
+    }
+}
 ` : ''}${backendCoreHost ? `
 # ANTE Backend Core API Configuration
 server {
@@ -510,6 +560,7 @@ function generateCloudflareNginxConfig(config) {
     mlmAppHost,
     backendMlmHost,
     frontendCoreHost,
+    frontendCoreMobileHost,
     backendCoreHost,
     frontendPort,
     apiPort,
@@ -520,6 +571,7 @@ function generateCloudflareNginxConfig(config) {
     mlmAppPort = 9005,
     backendMlmPort = 4001,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     backendCorePort = 4002
   } = config;
 
@@ -873,6 +925,53 @@ server {
         proxy_read_timeout 60s;
     }
 }
+` : ''}${frontendCoreMobileHost ? `
+# ANTE Frontend Core Mobile Configuration (Cloudflare SSL)
+server {
+    listen 80;
+    listen 443 ssl;
+    listen [::]:80;
+    listen [::]:443 ssl;
+    server_name ${frontendCoreMobileHost};
+
+    # SSL Certificate (self-signed for Cloudflare Full mode)
+    ssl_certificate ${sslCert};
+    ssl_certificate_key ${sslKey};
+
+    # 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;
+
+    # Disable caching for config.js to ensure runtime config is always fresh
+    location = /config.js {
+        proxy_pass http://localhost:${frontendCoreMobilePort}/config.js;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0" always;
+        add_header Pragma "no-cache" always;
+        add_header Expires "0" always;
+    }
+
+    location / {
+        proxy_pass http://localhost:${frontendCoreMobilePort};
+        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;
+    }
+}
 ` : ''}${backendCoreHost ? `
 # ANTE Backend Core API Configuration (Cloudflare SSL)
 server {
@@ -963,6 +1062,7 @@ export async function generateCloudflareCert() {
  * @param {string} [config.mlmAppHost] - MLM app hostname (optional)
  * @param {string} [config.backendMlmHost] - Backend MLM API hostname (optional)
  * @param {string} [config.frontendCoreHost] - Frontend Core hostname (optional)
+ * @param {string} [config.frontendCoreMobileHost] - Frontend Core Mobile hostname (optional)
  * @param {string} [config.backendCoreHost] - Backend Core API hostname (optional)
  * @param {number} config.frontendPort - Frontend port
  * @param {number} config.apiPort - API port
@@ -973,6 +1073,7 @@ export async function generateCloudflareCert() {
  * @param {number} [config.mlmAppPort] - MLM app port (default: 9005)
  * @param {number} [config.backendMlmPort] - Backend MLM API port (default: 4001)
  * @param {number} [config.frontendCorePort] - Frontend Core port (default: 8085)
+ * @param {number} [config.frontendCoreMobilePort] - Frontend Core Mobile port (default: 8086)
  * @param {number} [config.backendCorePort] - Backend Core API port (default: 4002)
  * @param {string[]} [config.domainsWithCerts] - List of domains that have valid SSL certificates
  * @returns {string} NGINX configuration with SSL
@@ -988,6 +1089,7 @@ function generateSslNginxConfig(config) {
     mlmAppHost,
     backendMlmHost,
     frontendCoreHost,
+    frontendCoreMobileHost,
     backendCoreHost,
     frontendPort,
     apiPort,
@@ -998,6 +1100,7 @@ function generateSslNginxConfig(config) {
     mlmAppPort = 9005,
     backendMlmPort = 4001,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     backendCorePort = 4002,
     domainsWithCerts = []
   } = config;
@@ -1479,6 +1582,121 @@ server {
     }
   }
 
+  if (frontendCoreMobileHost) {
+    // Frontend Core Mobile has special config.js caching rules
+    if (hasCert(frontendCoreMobileHost)) {
+      config_output += `
+# ANTE Frontend Core Mobile Configuration (HTTPS)
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    http2 on;
+    server_name ${frontendCoreMobileHost};
+
+    # SSL Certificate paths
+    ssl_certificate /etc/letsencrypt/live/${frontendCoreMobileHost}/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/${frontendCoreMobileHost}/privkey.pem;
+
+    # SSL Configuration
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+    ssl_prefer_server_ciphers on;
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_timeout 10m;
+
+    # Security headers
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+    add_header X-Frame-Options SAMEORIGIN always;
+    add_header X-Content-Type-Options nosniff always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    # 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;
+
+    # Disable caching for config.js to ensure runtime config is always fresh
+    location = /config.js {
+        proxy_pass http://localhost:${frontendCoreMobilePort}/config.js;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0" always;
+        add_header Pragma "no-cache" always;
+        add_header Expires "0" always;
+    }
+
+    location / {
+        proxy_pass http://localhost:${frontendCoreMobilePort};
+        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;
+    }
+}
+
+# HTTP to HTTPS redirect for ${frontendCoreMobileHost}
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${frontendCoreMobileHost};
+    return 301 https://$server_name$request_uri;
+}`;
+    } else {
+      config_output += `
+# ANTE Frontend Core Mobile Configuration (HTTP only - SSL cert not available)
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${frontendCoreMobileHost};
+
+    # 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;
+
+    # Disable caching for config.js to ensure runtime config is always fresh
+    location = /config.js {
+        proxy_pass http://localhost:${frontendCoreMobilePort}/config.js;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0" always;
+        add_header Pragma "no-cache" always;
+        add_header Expires "0" always;
+    }
+
+    location / {
+        proxy_pass http://localhost:${frontendCoreMobilePort};
+        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;
+    }
+}`;
+    }
+  }
+
   if (backendCoreHost) {
     config_output += generateServerBlock(backendCoreHost, backendCorePort, 'ANTE Backend Core API');
   }
@@ -1599,6 +1817,9 @@ export async function configureNginx(config) {
     if (config.frontendCoreDomain) {
       console.log(chalk.gray(`   Frontend Core: ${config.frontendCoreDomain} → localhost:${config.frontendCorePort || 8085}`));
     }
+    if (config.frontendCoreMobileDomain) {
+      console.log(chalk.gray(`   Frontend Core Mobile: ${config.frontendCoreMobileDomain} → localhost:${config.frontendCoreMobilePort || 8086}`));
+    }
     if (config.backendCoreDomain) {
       console.log(chalk.gray(`   Backend Core API: ${config.backendCoreDomain} → localhost:${config.backendCorePort || 4002}`));
     }

package/src/utils/ssl.js

@@ -142,6 +142,7 @@ export async function obtainSSLCertificate(config) {
  * @param {string} [config.mlmAppDomain] - MLM App domain URL (optional)
  * @param {string} [config.backendMlmDomain] - Backend MLM API domain URL (optional)
  * @param {string} [config.frontendCoreDomain] - Frontend Core domain URL (optional)
+ * @param {string} [config.frontendCoreMobileDomain] - Frontend Core Mobile domain URL (optional)
  * @param {string} [config.backendCoreDomain] - Backend Core API domain URL (optional)
  * @param {number} [config.frontendPort=8080] - Frontend port
  * @param {number} [config.apiPort=3001] - API port
@@ -152,6 +153,7 @@ export async function obtainSSLCertificate(config) {
  * @param {number} [config.mlmAppPort=9005] - MLM App port
  * @param {number} [config.backendMlmPort=4001] - Backend MLM API port
  * @param {number} [config.frontendCorePort=8085] - Frontend Core port
+ * @param {number} [config.frontendCoreMobilePort=8086] - Frontend Core Mobile port
  * @param {number} [config.backendCorePort=4002] - Backend Core API port
  * @param {string[]} [config.domainsWithCerts=[]] - List of domains that have valid SSL certificates
  * @returns {Promise<void>}
@@ -167,6 +169,7 @@ export async function updateNginxForSSL(config) {
     mlmAppDomain,
     backendMlmDomain,
     frontendCoreDomain,
+    frontendCoreMobileDomain,
     backendCoreDomain,
     frontendPort = 8080,
     apiPort = 3001,
@@ -177,6 +180,7 @@ export async function updateNginxForSSL(config) {
     mlmAppPort = 9005,
     backendMlmPort = 4001,
     frontendCorePort = 8085,
+    frontendCoreMobilePort = 8086,
     backendCorePort = 4002,
     domainsWithCerts = []
   } = config;
@@ -208,6 +212,7 @@ export async function updateNginxForSSL(config) {
       mlmAppDomain,
       backendMlmDomain,
       frontendCoreDomain,
+      frontendCoreMobileDomain,
       backendCoreDomain,
       frontendPort,
       apiPort,
@@ -218,6 +223,7 @@ export async function updateNginxForSSL(config) {
       mlmAppPort,
       backendMlmPort,
       frontendCorePort,
+      frontendCoreMobilePort,
       backendCorePort,
       ssl: true,
       domainsWithCerts

package/src/utils/validation.js

@@ -229,7 +229,7 @@ export async function checkPort(port) {
  */
 function detectPortsFromEnv(installDir = './ante-erp') {
   // Default ports now include core services (always included)
-  const defaultPorts = [8080, 3001, 4001, 4002, 8085];
+  const defaultPorts = [8080, 3001, 4001, 4002, 8085, 8086];
 
   try {
     const envPath = join(installDir, '.env');
@@ -277,6 +277,15 @@ function detectPortsFromEnv(installDir = './ante-erp') {
       }
     }
 
+    // Check for FRONTEND_CORE_MOBILE_PORT (in case it's customized)
+    const frontendCoreMobilePortMatch = envContent.match(/^FRONTEND_CORE_MOBILE_PORT=(\d+)/m);
+    if (frontendCoreMobilePortMatch) {
+      const frontendCoreMobilePort = parseInt(frontendCoreMobilePortMatch[1]);
+      if (!ports.includes(frontendCoreMobilePort)) {
+        ports.push(frontendCoreMobilePort);
+      }
+    }
+
     return ports;
   } catch (error) {
     return defaultPorts;