nexus-fca 2.1.2 → 2.1.3

package/CHANGELOG.md

@@ -4,10 +4,14 @@
 ### Added
 - Soft-stale probing at 2 minutes idle (ping + conditional forced reconnect if no events within 5-8s)
 - Wrapper around `listenMqtt` to automatically feed events into safety heartbeat (`recordEvent`) for precise idle detection
+- Ghost connection detection (10m silent but socket connected triggers forced reconnect after probe)
+- Periodic connection recycle every ~6h ±30m to prevent long-lived silent degradation
+- Force reconnect API: `globalSafety.forceReconnect(tag)`
 
 ### Improved
 - Faster recovery from silent idle states (previously required >5 min or external trigger)
 - Reduced chance of appearing online but unresponsive after short inactivity
+- Added keepalive foreground_state publishes each heartbeat
 
 ---
 

package/index.js

@@ -10,6 +10,33 @@ const path = require('path');
 const models = require("./lib/database/models");
 const logger = require("./lib/logger");
 const { safeMode, ultraSafeMode, smartSafetyLimiter, isUserAllowed } = require('./utils'); // Enhanced safety system
+// Minimal aesthetic banner system
+let _fancyBannerPrinted = false;
+const gradient = (() => { try { return require('gradient-string'); } catch(_) { return null; } })();
+const pkgMeta = (() => { try { return require('./package.json'); } catch(_) { return { version: 'dev' }; } })();
+function printFancyStartupBanner() {
+  if (_fancyBannerPrinted) return; _fancyBannerPrinted = true;
+  const lines = [
+    '╔══════════════════════════════════════════════════════╗',
+    '║ Nexus-FCA Secure Login                               ║',
+    '║ Advanced Stable Messenger Automation API             ║',
+    '╚══════════════════════════════════════════════════════╝'
+  ];
+  if (gradient) console.log(gradient.cristal.multiline(lines.join('\n'))); else console.log(lines.join('\n'));
+}
+function printIdentityBanner(uid, name) {
+  const cleanName = name || 'Unknown';
+  const pad = (txt, len) => (txt.length < len ? txt + ' '.repeat(len - txt.length) : txt.substring(0, len));
+  const bodyLen = 54;
+  const line = (content) => `║ ${pad(content, bodyLen)} ║`;
+  const box = [
+    '╔════════════════ LOGGED IN IDENTITY ════════════════╗',
+    line(`UID : ${uid}`),
+    line(`Name: ${cleanName}`),
+    '╚════════════════════════════════════════════════════╝'
+  ];
+  if (gradient) console.log(gradient.atlas.multiline(box.join('\n'))); else console.log(box.join('\n'));
+}
 
 // Enhanced imports - All new modules
 const { NexusClient } = require('./lib/compatibility/NexusClient');
@@ -208,7 +235,9 @@ function buildAPI(globalOptions, html, jar) {
     firstListen: true,
     fb_dtsg,
     wsReqNumber: 0,
-    wsTaskNumber: 0
+    wsTaskNumber: 0,
+    // Provide safety module reference to lower layers (listenMqtt)
+    globalSafety
   };
   const api = {
     setOptions: setOptions.bind(null, globalOptions),
@@ -269,6 +298,59 @@ function buildAPI(globalOptions, html, jar) {
         console.error("An error occurred while refreshing fb_dtsg", err);
       });
   }, 1000 * 60 * 60 * 24);
+  // === Group Queue (No Cooldown, Sequential per group) ===
+  (function initGroupQueue(){
+    const groupQueues = new Map(); // threadID -> { q: [], sending: false }
+    const isGroupThread = (tid) => typeof tid === 'string' && tid.length >= 15; // simple heuristic
+    const DIRECT_FN = api.sendMessage; // original
+
+    api.enableGroupQueue = function(enable=true){
+      globalOptions.groupQueueEnabled = !!enable;
+    };
+    api.setGroupQueueCapacity = function(n){ globalOptions.groupQueueMax = n; };
+    api.enableGroupQueue(true);
+    api.setGroupQueueCapacity(100); // allow up to 100 pending per group
+
+    api._sendMessageDirect = DIRECT_FN;
+    api.sendMessage = function(message, threadID, cb){
+      if(!globalOptions.groupQueueEnabled || !isGroupThread(threadID)) {
+        return api._sendMessageDirect(message, threadID, cb);
+      }
+      let entry = groupQueues.get(threadID);
+      if(!entry){ entry = { q: [], sending: false }; groupQueues.set(threadID, entry); }
+      if(entry.q.length >= (globalOptions.groupQueueMax||100)) {
+        // drop oldest (keep newest) to avoid unbounded growth
+        entry.q.shift();
+      }
+      entry.q.push({ message, threadID, cb });
+      processQueue(threadID, entry);
+    };
+
+    function processQueue(threadID, entry){
+      if(entry.sending) return;
+      if(!entry.q.length) return;
+      entry.sending = true;
+      const { message, threadID: tid, cb } = entry.q.shift();
+      api._sendMessageDirect(message, tid, function(err, res){
+        try { if(!err) globalSafety.recordEvent(); } catch(_) {}
+        if(typeof cb === 'function') cb(err, res);
+        entry.sending = false;
+        // Immediately process next (no cooldown) to keep strict sequence
+        setImmediate(()=>processQueue(threadID, entry));
+      });
+    }
+
+    api._flushGroupQueue = function(threadID){
+      const entry = groupQueues.get(threadID);
+      if(!entry) return;
+      while(entry.q.length) {
+        const item = entry.q.shift();
+        api._sendMessageDirect(item.message, item.threadID, item.cb);
+      }
+      entry.sending = false;
+    };
+  })();
+  // === End Group Queue ===
   return {
     ctx,
     defaultFuncs,
@@ -364,12 +446,25 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
       if (!safetyStatus.safe) {
         logger(`⚠️ Login safety warning: ${safetyStatus.reason}`, 'warn');
       }
-      
       logger('✅ Session authenticated successfully', 'info');
-      
       // Initialize safety monitoring
       globalSafety.startMonitoring(ctx, api);
-      
+      // Post-login identity banner
+      try {
+        const uid = api.getCurrentUserID && api.getCurrentUserID();
+        if (api.getUserInfo && uid) {
+          api.getUserInfo(uid, (err, info) => {
+            if (!err && info) {
+              const userObj = info[uid] || info; // depending on structure
+              printIdentityBanner(uid, userObj.name || userObj.firstName || userObj.fullName);
+            } else {
+              printIdentityBanner(uid || 'N/A');
+            }
+          });
+        } else {
+          printIdentityBanner(uid || 'N/A');
+        }
+      } catch(_) { /* ignore */ }
       callback(null, api);
     })
     .catch(e => {
@@ -893,6 +988,7 @@ class IntegratedNexusLoginSystem {
 
 // Integrated Nexus Login wrapper for easy usage
 async function integratedNexusLogin(credentials = null, options = {}) {
+    printFancyStartupBanner();
     const loginSystem = new IntegratedNexusLoginSystem(options);
     
     // Professional logging system
@@ -1008,6 +1104,7 @@ async function integratedNexusLogin(credentials = null, options = {}) {
  * - Appstate only: Uses existing session directly
  */
 async function login(loginData, options = {}, callback) {
+  printFancyStartupBanner();
   // Support multiple callback signatures
   if (typeof options === 'function') {
     callback = options;

package/lib/safety/FacebookSafety.js

@@ -68,6 +68,10 @@ class FacebookSafety {
         this._inFlightRefreshId = 0;
         // New: probing guard to avoid overlapping soft-stale probes
         this._probing = false;
+        // Ghost detection guard
+        this._ghostChecking = false;
+        // Periodic recycle timer
+        this._periodicRecycleTimer = null;
 
         this.initSafety();
     }
@@ -80,6 +84,7 @@ class FacebookSafety {
 
         // Setup session monitoring
         this.setupSessionMonitoring();
+        this._schedulePeriodicRecycle();
     }
 
     /**
@@ -245,18 +250,19 @@ class FacebookSafety {
             clearTimeout(this._safeRefreshTimer);
             this._safeRefreshTimer = null;
         }
-        // Use recursive timeout with randomization each cycle (more human-like)
+        // Stealth+Resilient profile refresh policy:
+        // risk low: 50-60m, medium: 40-50m, high: 25-35m (random inside band)
         const schedule = () => {
             if (this._destroyed) return;
-            // Adaptive interval: shorter if high risk (to revalidate), longer if stable
-            const base = this.sessionMetrics.riskLevel === 'high' ? 25 : this.sessionMetrics.riskLevel === 'medium' ? 35 : 45; // minutes
-            const baseInterval = base * 60 * 1000;
-            const randomVariation = (Math.random() * 16 - 8) * 60 * 1000; // ±8 min
-            const interval = baseInterval + randomVariation;
+            let minM, maxM;
+            if (this.sessionMetrics.riskLevel === 'high') { minM = 25; maxM = 35; }
+            else if (this.sessionMetrics.riskLevel === 'medium') { minM = 40; maxM = 50; }
+            else { minM = 50; maxM = 60; }
+            const interval = (minM * 60 * 1000) + Math.random() * ((maxM - minM) * 60 * 1000);
             this._safeRefreshTimer = setTimeout(async () => {
                 await this.refreshSafeSession();
                 schedule();
-            }, Math.max(10 * 60 * 1000, interval)); // never below 10 min
+            }, interval);
         };
         schedule();
     }
@@ -311,40 +317,27 @@ class FacebookSafety {
             const now = Date.now();
             const disconnected = !this.ctx || !this.ctx.mqttClient || !this.ctx.mqttClient.connected;
             const idle = now - this._lastEventTs;
-            const softStale = idle > 2 * 60 * 1000; // >2 min no events
-            const hardStale = idle > 5 * 60 * 1000; // >5 min no events (legacy threshold)
-            const stale = hardStale; // backwards compat naming
-
-            // If totally disconnected or hard stale -> reconnect immediately
+            const softStale = idle > (2.5 * 60 * 1000); // Stealth profile: 2m30s
+            const hardStale = idle > 8 * 60 * 1000; // escalate earlier than watchdog hard (8m)
+            const stale = hardStale;
             if (disconnected || stale) {
                 await this._reconnectMqttWithBackoff(disconnected ? 'disconnected' : 'hard-stale');
                 return;
             }
-
-            // Soft-stale probing: connection claims to be open but no events for 2-5 minutes.
-            // We issue a ping and if still no events after probe window, we force a reconnect.
             if (softStale && !this._probing) {
                 this._probing = true;
                 const prevTs = this._lastEventTs;
-                try {
-                    if (this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected) {
-                        if (typeof this.ctx.mqttClient.ping === 'function') {
-                            try { this.ctx.mqttClient.ping(); } catch(_) {}
-                        }
-                    }
-                } catch(_) {}
+                try { if (this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected && typeof this.ctx.mqttClient.ping === 'function') this.ctx.mqttClient.ping(); } catch(_) {}
                 setTimeout(() => {
                     if (this._destroyed) return;
-                    // If no new events arrived since probe start, treat as latent-dead connection
                     if (this._lastEventTs <= prevTs) {
-                        // Reset backoff to allow immediate reconnect (latency sensitive)
                         this._backoff.attempt = 0;
                         this._reconnectMqttWithBackoff('soft-stale');
                     }
                     this._probing = false;
-                }, 5000 + Math.random() * 3000); // 5-8s probe window
+                }, 6000 + Math.random() * 2000); // 6-8s probe window (Stealth+Resilient)
             }
-        } catch (_) { /* swallow */ }
+        } catch(_) {}
     }
 
     // Progressive backoff + jitter reconnect
@@ -353,38 +346,47 @@ class FacebookSafety {
         this._reconnecting = true;
         try {
             const now = Date.now();
-            if (now < this._backoff.next) {
-                return; // respect backoff window
-            }
+            if (now < this._backoff.next) { return; }
             const attempt = ++this._backoff.attempt;
-            const baseDelay = Math.min(30000, 1000 * Math.pow(2, Math.min(attempt, 5))); // cap 30s
-            const jitter = Math.random() * 400;
+            // Stealth backoff: 1.2s * 1.8^n capped ~20s, add jitter 0-500ms
+            const baseDelay = Math.min(20000, 1200 * Math.pow(1.8, Math.min(attempt, 6)));
+            const jitter = Math.random() * 500;
             const delay = baseDelay + jitter;
             this._backoff.next = now + delay;
             await new Promise(r => setTimeout(r, delay));
-            // Graceful stop old listener
-            if (this._activeListenerStop && typeof this._activeListenerStop === 'function') {
-                try { this._activeListenerStop(); } catch (_) {}
-            }
+            if (this._activeListenerStop && typeof this._activeListenerStop === 'function') { try { this._activeListenerStop(); } catch(_) {} }
             if (this.api && typeof this.api.listenMqtt === 'function' && !this._destroyed) {
-                const stop = this.api.listenMqtt((err, event) => {
-                    if (!err && event) this.recordEvent();
-                });
+                const stop = this.api.listenMqtt((err, event) => { if (!err && event) this.recordEvent(); });
                 this._activeListenerStop = stop;
-                if (attempt > 1) this.safetyEmit('mqttBackoff', { attempt, delay, reason });
-                else this.safetyEmit('mqttReconnect', { success: true, reason });
+                this.safetyEmit('mqttReconnect', { success: true, reason, attempt, delay });
             }
-            // Reset backoff on success detection soon after
             setTimeout(() => {
-                if (this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected) {
-                    this._backoff.attempt = 0;
-                }
+                if (this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected) { this._backoff.attempt = 0; }
             }, 5000);
-        } catch (e) {
-            this.safetyEmit('mqttReconnect', { success: false, error: e.message });
-        } finally {
-            this._reconnecting = false;
-        }
+        } catch(e) {
+            this.safetyEmit('mqttReconnect', { success: false, error: e.message, reason });
+        } finally { this._reconnecting = false; }
+    }
+
+    // Public force reconnect (bypass backoff)
+    forceReconnect(tag = 'manual') {
+        if (this._destroyed) return;
+        this._backoff.attempt = 0;
+        return this._reconnectMqttWithBackoff('force-' + tag);
+    }
+
+    // Schedule periodic recycle (connection rejuvenation) every 6h ±30m jitter
+    _schedulePeriodicRecycle() {
+        if (this._periodicRecycleTimer) clearTimeout(this._periodicRecycleTimer);
+        if (this._destroyed) return;
+        const base = 6 * 60 * 60 * 1000; // 6h
+        const jitter = (Math.random() * 60 - 30) * 60 * 1000; // ±30m
+        const delay = base + jitter;
+        this._periodicRecycleTimer = setTimeout(() => {
+            if (this._destroyed) return;
+            this.forceReconnect('periodic');
+            this._schedulePeriodicRecycle();
+        }, delay);
     }
 
     // Heartbeat ping & watchdog
@@ -392,26 +394,38 @@ class FacebookSafety {
         if (this._heartbeatTimer) clearInterval(this._heartbeatTimer);
         if (this._watchdogTimer) clearInterval(this._watchdogTimer);
         if (this._destroyed) return;
+        // Stealth profile heartbeat: 80–100s random
         this._heartbeatTimer = setInterval(() => {
             if (this._destroyed) return;
             try {
                 if (this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected) {
                     if (this.ctx.mqttClient.ping) this.ctx.mqttClient.ping();
+                    try { this.ctx.mqttClient.publish('/foreground_state', JSON.stringify({ foreground: true })); } catch(_) {}
                     this.safetyEmit('heartbeat', { ts: Date.now() });
                 }
-            } catch (_) {}
-        }, 60 * 1000 + Math.random() * 5000); // 60s ±5s
+            } catch(_) {}
+        }, (80 + Math.random()*20) * 1000);
         this._watchdogTimer = setInterval(() => {
             if (this._destroyed) return;
             const idle = Date.now() - this._lastEventTs;
-            if (idle > 2 * 60 * 1000) { // 2 min no events -> soft check
-                this._ensureMqttAlive();
+            // Soft escalate already handled inside _ensureMqttAlive at 2m30s
+            // Ghost detection earlier: 9m
+            if (idle > 9 * 60 * 1000 && !this._ghostChecking && this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected) {
+                this._ghostChecking = true;
+                const before = this._lastEventTs;
+                try { if (this.ctx.mqttClient.ping) this.ctx.mqttClient.ping(); } catch(_) {}
+                setTimeout(() => {
+                    if (this._destroyed) return;
+                    if (this._lastEventTs <= before) { this.forceReconnect('ghost'); }
+                    setTimeout(() => { this._ghostChecking = false; }, 5 * 60 * 1000);
+                }, 6000 + Math.random()*2000);
             }
-            if (idle > 15 * 60 * 1000) { // 15 min -> force reconnect attempt ignoring backoff
-                this._backoff.attempt = 0; // reset to allow immediate
+            // Hard watchdog escalate: 12m
+            if (idle > 12 * 60 * 1000) {
+                this._backoff.attempt = 0;
                 this._ensureMqttAlive();
             }
-        }, 30 * 1000); // watchdog every 30s
+        }, 35 * 1000); // slight change to avoid pattern
     }
 
     /**
@@ -536,7 +550,7 @@ class FacebookSafety {
     // Cleanup / destroy resources (to prevent dangling timers)
     destroy() {
         this._destroyed = true;
-        const timers = [this._safeRefreshInterval, this._safeRefreshTimer, this._heartbeatTimer, this._watchdogTimer];
+        const timers = [this._safeRefreshInterval, this._safeRefreshTimer, this._heartbeatTimer, this._watchdogTimer, this._periodicRecycleTimer];
         timers.forEach(t => t && clearTimeout(t));
         if (this._activeListenerStop) {
             try { this._activeListenerStop(); } catch (_) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-fca",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "A modern, safe, and advanced Facebook Chat API for Node.js with fully integrated Nexus Login System. NPM-ready with ID/password/2FA support, ultra-low ban rate protection, and zero external dependencies.",
   "main": "index.js",
   "repository": {

package/src/listenMqtt.js

@@ -260,6 +260,7 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
     }
   });
   mqttClient.on("connect", function () {
+    if (ctx.globalSafety) { try { ctx.globalSafety.recordEvent(); } catch(_) {} }
     if (process.env.OnStatus === undefined) {
       logger("Nexus-FCA premium features works only with Nexus-Bot framework(Kidding)", "info");
       process.env.OnStatus = true;
@@ -311,6 +312,7 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
     };
   });
   mqttClient.on("message", function (topic, message, _packet) {
+    if (ctx.globalSafety) { try { ctx.globalSafety.recordEvent(); } catch(_) {} }
     try {
       let jsonMessage = Buffer.isBuffer(message)
         ? Buffer.from(message).toString()
@@ -404,8 +406,21 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
       return;
     }
   });
-  mqttClient.on("close", function () {});
-  mqttClient.on("disconnect", () => {});
+  mqttClient.on("close", function () { if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
+  mqttClient.on("disconnect", () => { if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
+  // Lightweight periodic synthetic event to prevent idle expiry if FB sends nothing
+  if (!ctx._syntheticKeepAliveInterval) {
+    ctx._syntheticKeepAliveInterval = setInterval(() => {
+      if (!ctx.mqttClient || !ctx.mqttClient.connected) return;
+      if (ctx.globalSafety) {
+        const idle = Date.now() - ctx.globalSafety._lastEventTs;
+        // Inject synthetic event every 70s if no real traffic -> keeps timers fresh
+        if (idle > 65 * 1000) {
+          ctx.globalSafety.recordEvent();
+        }
+      }
+    }, 30000);
+  }
 }
 function getTaskResponseData(taskType, payload) {
   try {