nexus-fca 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [2.1.2] - Unreleased - CONTINUOUS IDLE RECOVERY
+### 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
+
+### Improved
+- Faster recovery from silent idle states (previously required >5 min or external trigger)
+- Reduced chance of appearing online but unresponsive after short inactivity
+
+---
+
+## [2.1.1] - 2025-08-27 - ADVANCED SESSION STABILITY
+### 🛠 Added
+- Adaptive safe session refresh interval (dynamic based on risk level)
+- Heartbeat + watchdog timers to detect stale MQTT connections early
+- Progressive backoff with jitter for MQTT reconnect attempts
+- Layered post-refresh health checks (1s / 10s / 30s) to catch silent drops
+- Abortable refresh with timeout safeguard (25s) to prevent hangs
+- Automatic reconnection trigger if no events within thresholds (2m soft, 15m hard)
+- `destroy()` method to cleanup timers/listeners (prevents memory leaks)
+
+### 🔄 Changed
+- Safe refresh now records in‑flight ID and supersedes outdated checks
+- Reconnect logic centralized in `_reconnectMqttWithBackoff`
+
+### ✅ Improved
+- Stability after long runtimes / multiple token refresh cycles
+- Reduced risk of listener not resuming after refresh
+
+---
+
 ## [2.1.0] - 2025-08-20 - SESSION RELIABILITY & PROMISE LOGIN
 ### 🚀 Highlights
 Stability-focused release improving long‑running bot sessions, reducing false `not_logged_in` events, and modernizing the login flow.

package/index.js

@@ -239,6 +239,26 @@ function buildAPI(globalOptions, html, jar) {
       api[v.replace(".js", "")] = require("./src/" + v)(defaultFuncs, api, ctx);
     });
   api.listen = api.listenMqtt;
+  // Safety wrapper: ensure every inbound MQTT event updates safety lastEvent timestamp
+  if (!api._safetyWrappedListen) {
+    const _origListen = api.listenMqtt;
+    api.listenMqtt = function(callback) {
+      const wrapped = (err, evt) => {
+        if (!err && evt) {
+          try { globalSafety.recordEvent(); } catch(_) {}
+        }
+        if (typeof callback === 'function') callback(err, evt);
+      };
+      const emitter = _origListen(wrapped);
+      // Redundant defensive hooks
+      try {
+        emitter.on('message', () => globalSafety.recordEvent());
+        emitter.on('error', () => globalSafety.recordEvent());
+      } catch(_) {}
+      return emitter;
+    };
+    api._safetyWrappedListen = true;
+  }
   setInterval(async () => {
     api
       .refreshFb_dtsg()

package/lib/safety/FacebookSafety.js

@@ -53,6 +53,22 @@ class FacebookSafety {
             riskLevel: 'low'
         };
 
+        // Track last incoming event time to detect stale / dead connections
+        this._lastEventTs = Date.now();
+        this._reconnecting = false;
+        this._activeListenerStop = null; // store stop function from listenMqtt if we attach
+        this._safeRefreshInterval = null; // guard for multiple intervals
+        this._safeRefreshTimer = null; // for dynamic timeout pattern
+        // New stability / heartbeat fields
+        this._heartbeatTimer = null;
+        this._watchdogTimer = null;
+        this._backoff = { attempt: 0, next: 0 };
+        this._destroyed = false;
+        this._postRefreshChecks = [];
+        this._inFlightRefreshId = 0;
+        // New: probing guard to avoid overlapping soft-stale probes
+        this._probing = false;
+
         this.initSafety();
     }
 
@@ -220,14 +236,29 @@ class FacebookSafety {
      * Setup safe token refresh intervals
      */
     setupSafeRefresh() {
-        // Refresh tokens every 45 minutes with randomization
-        const baseInterval = 45 * 60 * 1000; // 45 minutes
-        const randomVariation = Math.random() * 10 * 60 * 1000; // ±10 minutes
-        const interval = baseInterval + randomVariation;
-
-        setInterval(() => {
-            this.refreshSafeSession();
-        }, interval);
+        // Replace previous interval/timer to avoid stacking
+        if (this._safeRefreshInterval) {
+            clearInterval(this._safeRefreshInterval);
+            this._safeRefreshInterval = null;
+        }
+        if (this._safeRefreshTimer) {
+            clearTimeout(this._safeRefreshTimer);
+            this._safeRefreshTimer = null;
+        }
+        // Use recursive timeout with randomization each cycle (more human-like)
+        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;
+            this._safeRefreshTimer = setTimeout(async () => {
+                await this.refreshSafeSession();
+                schedule();
+            }, Math.max(10 * 60 * 1000, interval)); // never below 10 min
+        };
+        schedule();
     }
 
     /**
@@ -265,18 +296,138 @@ class FacebookSafety {
         if (isError) {
             this.sessionMetrics.errorCount++;
         }
+        this._lastEventTs = Date.now();
+    }
+
+    // Expose a method for external caller (e.g., main listener) to update last event timestamp
+    recordEvent() {
+        this._lastEventTs = Date.now();
+    }
+
+    // Internal helper to ensure MQTT connection stays alive / auto-recover if dead after refresh
+    async _ensureMqttAlive() {
+        if (!this.api || this._destroyed) return;
+        try {
+            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
+            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(_) {}
+                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
+            }
+        } catch (_) { /* swallow */ }
+    }
+
+    // Progressive backoff + jitter reconnect
+    async _reconnectMqttWithBackoff(reason) {
+        if (this._reconnecting || this._destroyed) return;
+        this._reconnecting = true;
+        try {
+            const now = Date.now();
+            if (now < this._backoff.next) {
+                return; // respect backoff window
+            }
+            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;
+            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.api && typeof this.api.listenMqtt === 'function' && !this._destroyed) {
+                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 });
+            }
+            // Reset backoff on success detection soon after
+            setTimeout(() => {
+                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;
+        }
+    }
+
+    // Heartbeat ping & watchdog
+    _startHeartbeat() {
+        if (this._heartbeatTimer) clearInterval(this._heartbeatTimer);
+        if (this._watchdogTimer) clearInterval(this._watchdogTimer);
+        if (this._destroyed) return;
+        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();
+                    this.safetyEmit('heartbeat', { ts: Date.now() });
+                }
+            } catch (_) {}
+        }, 60 * 1000 + Math.random() * 5000); // 60s ±5s
+        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();
+            }
+            if (idle > 15 * 60 * 1000) { // 15 min -> force reconnect attempt ignoring backoff
+                this._backoff.attempt = 0; // reset to allow immediate
+                this._ensureMqttAlive();
+            }
+        }, 30 * 1000); // watchdog every 30s
     }
 
     /**
      * Start safety monitoring for session
      */
-    startMonitoring(ctx, api) {
+    startMonitoring(ctx, api) { // added persistence of ctx/api so refresh can use them
         if (!ctx || !api) return;
-
-        // Monitor for account issues
-        setInterval(() => {
+        this.ctx = ctx; // persist for later safe refresh
+        this.api = api;
+        if (this._monitorInterval) clearInterval(this._monitorInterval);
+        this._monitorInterval = setInterval(() => {
             this.checkAccountHealth(ctx, api);
-        }, 30000); // Check every 30 seconds
+        }, 30000);
+        // Attach lightweight hook if api emits events to update lastEventTs externally if user wires it
+        this.recordEvent();
+        this._startHeartbeat();
     }
 
     /**
@@ -290,7 +441,7 @@ class FacebookSafety {
                 const userCookie = cookies.find(c => c.key === 'c_user');
                 
                 if (!userCookie) {
-                    this.emit('accountIssue', {
+                    this.safetyEmit('accountIssue', {
                         type: 'session_expired',
                         message: 'User session cookie missing'
                     });
@@ -301,7 +452,7 @@ class FacebookSafety {
             
             const safetyCheck = this.checkErrorSafety(error);
             if (!safetyCheck.safe) {
-                this.emit('accountIssue', {
+                this.safetyEmit('accountIssue', {
                     type: safetyCheck.danger,
                     message: error.message,
                     recommendation: safetyCheck.recommendation
@@ -314,8 +465,85 @@ class FacebookSafety {
      * Refresh session safely
      */
     async refreshSafeSession() {
-        // Implement safe session refresh logic
-        console.log('🔄 Performing safe session refresh...');
+        // Improved safe session refresh implementation
+        if (this._refreshing) return; // prevent concurrent refreshes
+        this._refreshing = true;
+        const refreshId = ++this._inFlightRefreshId;
+        const startedAt = Date.now();
+        let preMqttConnected = this.ctx && this.ctx.mqttClient && this.ctx.mqttClient.connected;
+        let preLastEvent = this._lastEventTs;
+        try {
+            console.log('🔄 Performing safe session refresh...');
+            if (!this.api || typeof this.api.refreshFb_dtsg !== 'function') {
+                console.log('⚠️ Safe refresh skipped: api.refreshFb_dtsg not available');
+                return;
+            }
+            // Abort protection if takes too long (network hang)
+            const timeoutMs = 25 * 1000;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            let res;
+            try {
+                res = await this.api.refreshFb_dtsg({ signal: controller.signal });
+            } finally { clearTimeout(timeout); }
+            this.sessionMetrics.errorCount = Math.max(0, this.sessionMetrics.errorCount - 1);
+            this.sessionMetrics.lastActivity = Date.now();
+            this.safetyEmit('safeRefresh', {
+                ok: true,
+                fb_dtsg: this.ctx && this.ctx.fb_dtsg,
+                jazoest: this.ctx && this.ctx.jazoest,
+                durationMs: Date.now() - startedAt,
+                message: 'Session tokens refreshed'
+            });
+            // Immediate MQTT health ensure
+            await this._ensureMqttAlive();
+            // Schedule layered post-refresh checks (1s, 10s, 30s) to catch silent drops
+            const checksAt = [1000, 10000, 30000];
+            checksAt.forEach(delay => {
+                const handle = setTimeout(() => {
+                    if (this._destroyed) return;
+                    if (refreshId !== this._inFlightRefreshId) return; // newer refresh superseded
+                    this._ensureMqttAlive();
+                }, delay);
+                this._postRefreshChecks.push(handle);
+            });
+            // If previously connected and now no events for >1 min after refresh -> reconnect
+            setTimeout(() => {
+                if (this._destroyed) return;
+                if (preMqttConnected && Date.now() - Math.max(this._lastEventTs, preLastEvent) > 60 * 1000) {
+                    this._backoff.attempt = 0; // reset backoff for immediate action
+                    this._ensureMqttAlive();
+                }
+            }, 60 * 1000);
+        } catch (e) {
+            this.recordRequest(true);
+            this.safetyEmit('safeRefresh', {
+                ok: false,
+                error: e.message,
+                durationMs: Date.now() - startedAt
+            });
+            if (this.sessionMetrics.errorCount > 3) {
+                this.sessionMetrics.riskLevel = 'high';
+            }
+            // Force reconnection attempt if refresh failed & potential token invalidation
+            this._backoff.attempt = 0;
+            await this._ensureMqttAlive();
+        } finally {
+            this._refreshing = false;
+        }
+    }
+
+    // Cleanup / destroy resources (to prevent dangling timers)
+    destroy() {
+        this._destroyed = true;
+        const timers = [this._safeRefreshInterval, this._safeRefreshTimer, this._heartbeatTimer, this._watchdogTimer];
+        timers.forEach(t => t && clearTimeout(t));
+        if (this._activeListenerStop) {
+            try { this._activeListenerStop(); } catch (_) {}
+            this._activeListenerStop = null;
+        }
+        this._postRefreshChecks.forEach(h => clearTimeout(h));
+        this._postRefreshChecks = [];
     }
 
     /**
@@ -351,7 +579,7 @@ class FacebookSafety {
     /**
      * Emit safety events
      */
-    emit(event, data) {
+    safetyEmit(event, data) {
         if (typeof this.onSafetyEvent === 'function') {
             this.onSafetyEvent(event, data);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-fca",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "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": {