nexus-fca 2.1.0 → 2.1.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [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/lib/safety/FacebookSafety.js

@@ -53,6 +53,20 @@ 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;
+
         this.initSafety();
     }
 
@@ -220,14 +234,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 +294,107 @@ 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 disconnected = !this.ctx || !this.ctx.mqttClient || !this.ctx.mqttClient.connected;
+            const stale = Date.now() - this._lastEventTs > 5 * 60 * 1000; // >5 min no events
+            if (disconnected || stale) {
+                await this._reconnectMqttWithBackoff(disconnected ? 'disconnected' : 'stale');
+            }
+        } 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 +408,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 +419,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 +432,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 +546,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.1",
   "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": {