nexus-fca 3.1.1 → 3.1.3

package/README.md

@@ -2,11 +2,13 @@
   <img src="https://i.ibb.co/Sk61FGg/Dragon-Fruit-1.jpg" alt="Nexus-FCA" width="520" />
 </p>
 
-# Nexus-FCA v3.1.0 – 🏆 THE BEST, SAFEST, MOST STABLE FCA
+# Nexus-FCA v3.1.1 – 🏆 THE BEST, SAFEST, MOST STABLE FCA
 
 Modern, safe, production‑ready Messenger (Facebook Chat) API layer with **email/password + appState login**, **proxy support**, **random user agent**, adaptive session & connection resilience, proactive cookie refresh, MQTT stability enhancements, delivery reliability safeguards, memory protection, and rich runtime metrics. Promise + callback compatible, TypeScript typed, minimal friction.
 
-## 🎉 NEW in 3.1.0 - Industry Leading Features!
+## 🎉 NEW in 3.1.1 - Industry Leading Features!
+- ✅ **Smart MQTT Recovery** - Auto-refreshes Sequence ID on errors to prevent loops
+- ✅ **Proactive Lifecycle Management** - Randomized reconnects (26-60m) to mimic human behavior
 - ✅ **Email/Password Login** - Login with Facebook credentials (not just cookies!)
 - ✅ **Advanced Proxy Support** - HTTP/HTTPS/SOCKS5 proxy for all connections
 - ✅ **Random User Agent** - 14+ realistic user agents to avoid detection
@@ -139,7 +141,9 @@ await login({ appState }, { disablePreflight: true });
 ```
 
 ---
-## 🛰️ MQTT Enhancements (Since 2.1.x)
+## 🛰️ MQTT Enhancements (Since 3.1.x)
+- **Smart Recovery**: Fetches fresh Sequence ID before reconnecting on errors (prevents stale token loops)
+- **Lifecycle Management**: Proactive randomized reconnects (26-60m) to avoid long-session forced disconnects
 - Adaptive reconnect curve (caps 5m)
 - Layered post-refresh probes (1s / 10s / 30s)
 - Synthetic randomized keepalives (55–75s)

package/index.js

@@ -209,9 +209,75 @@ function buildAPI(globalOptions, html, jar) {
   if (process.env.NEXUS_REGION) {
     try { region = process.env.NEXUS_REGION.toUpperCase(); } catch(_) {}
   }
-  const tokenMatch = html.match(/DTSGInitialData.*?token":"(.*?)"/);
-  if (tokenMatch) {
-    fb_dtsg = tokenMatch[1];
+  
+  // Robust fb_dtsg extraction
+  const dtsgRegexes = [
+    /DTSGInitialData.*?token":"(.*?)"/,
+    /"DTSGInitData",\[\],{"token":"(.*?)"/,
+    /\["DTSGInitData",\[\],{"token":"(.*?)"/,
+    /name="fb_dtsg" value="(.*?)"/,
+    /name="dtsg_ag" value="(.*?)"/
+  ];
+  
+  for (const regex of dtsgRegexes) {
+    const match = html.match(regex);
+    if (match && match[1]) {
+      fb_dtsg = match[1];
+      break;
+    }
+  }
+
+  // NEW: JSON Parsing Fallback (inspired by ws3-fca)
+  if (!fb_dtsg) {
+      try {
+          const extractNetData = (html) => {
+            const allScriptsData = [];
+            const scriptRegex = /<script type="application\/json"[^>]*>(.*?)<\/script>/g;
+            let match;
+            while ((match = scriptRegex.exec(html)) !== null) {
+                try {
+                    allScriptsData.push(JSON.parse(match[1]));
+                } catch (e) { }
+            }
+            return allScriptsData;
+          };
+          
+          const netData = extractNetData(html);
+          
+          const findConfig = (key) => {
+            for (const scriptData of netData) {
+                if (scriptData.require) {
+                    for (const req of scriptData.require) {
+                        if (Array.isArray(req) && req[0] === key && req[2]) {
+                            return req[2];
+                        }
+                        if (Array.isArray(req) && req[3] && req[3][0] && req[3][0].__bbox && req[3][0].__bbox.define) {
+                            for (const def of req[3][0].__bbox.define) {
+                                if (Array.isArray(def) && def[0].endsWith(key) && def[2]) {
+                                    return def[2];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+          };
+          
+          const dtsgData = findConfig("DTSGInitialData");
+          if (dtsgData && dtsgData.token) {
+              fb_dtsg = dtsgData.token;
+              log.verbose("login", "Found fb_dtsg via JSON parsing");
+          }
+      } catch (e) {
+          log.verbose("login", "JSON parsing for fb_dtsg failed: " + e.message);
+      }
+  }
+  
+  if (!fb_dtsg) {
+      // log.warn("login", "Could not find fb_dtsg in HTML. Session might be limited.");
+  } else {
+      log.verbose("login", "Found fb_dtsg: " + fb_dtsg.substring(0, 10) + "...");
   }
 
 
@@ -585,9 +651,76 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
       return res;
     })
     .then(handleRedirect)
-    .then(res => {
+    .then(async res => {
       const html = res.body;
       const Obj = buildAPI(globalOptions, html, jar);
+      
+      // Fallback: Try mbasic.facebook.com if fb_dtsg is missing
+      if (!Obj.ctx.fb_dtsg) {
+          logger("Attempting to fetch fb_dtsg from mbasic.facebook.com...", "info");
+          try {
+              const mobileOptions = {
+                  ...globalOptions,
+                  userAgent: "Mozilla/5.0 (Linux; Android 12; SM-G973F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Mobile Safari/537.36"
+              };
+              const mRes = await utils.get("https://mbasic.facebook.com/", jar, null, mobileOptions);
+              const mHtml = mRes.body;
+              const mMatch = mHtml.match(/name="fb_dtsg" value="(.*?)"/);
+              if (mMatch && mMatch[1]) {
+                  Obj.ctx.fb_dtsg = mMatch[1];
+                  Obj.ctx.ttstamp = "2" + Obj.ctx.fb_dtsg.split("").map(c => c.charCodeAt(0)).join("");
+                  logger("Found fb_dtsg from mbasic.facebook.com", "success");
+                  
+                  // Re-create defaultFuncs with the new token
+                  Obj.defaultFuncs = utils.makeDefaults(html, Obj.ctx.userID, Obj.ctx);
+              } else {
+                   // Try one more: dtsg_ag
+                   const agMatch = mHtml.match(/name="dtsg_ag" value="(.*?)"/);
+                   if (agMatch && agMatch[1]) {
+                        Obj.ctx.fb_dtsg = agMatch[1];
+                        Obj.ctx.ttstamp = "2" + Obj.ctx.fb_dtsg.split("").map(c => c.charCodeAt(0)).join("");
+                        logger("Found fb_dtsg (ag) from mbasic.facebook.com", "success");
+                        Obj.defaultFuncs = utils.makeDefaults(html, Obj.ctx.userID, Obj.ctx);
+                   } else {
+                       logger("Failed to find fb_dtsg in mbasic response", "warn");
+                   }
+              }
+              
+              // Second Fallback: Try business.facebook.com
+              if (!Obj.ctx.fb_dtsg) {
+                  logger("Attempting to fetch fb_dtsg from business.facebook.com...", "info");
+                  try {
+                      const bRes = await utils.get("https://business.facebook.com/business_locations", jar, null, globalOptions);
+                      const bHtml = bRes.body;
+                      const bMatch = bHtml.match(/name="fb_dtsg" value="(.*?)"/) || bHtml.match(/DTSGInitialData.*?token":"(.*?)"/);
+                      if (bMatch && bMatch[1]) {
+                          Obj.ctx.fb_dtsg = bMatch[1];
+                          Obj.ctx.ttstamp = "2" + Obj.ctx.fb_dtsg.split("").map(c => c.charCodeAt(0)).join("");
+                          logger("Found fb_dtsg from business.facebook.com", "success");
+                          Obj.defaultFuncs = utils.makeDefaults(html, Obj.ctx.userID, Obj.ctx);
+                      } else {
+                          logger("Failed to find fb_dtsg in business response", "warn");
+                          // Debug: Print what we got
+                          if (bHtml.includes("login_form") || bHtml.includes("checkpoint")) {
+                              logger("Response indicates login/checkpoint page", "error");
+                          } else {
+                              logger("Response start: " + bHtml.substring(0, 200), "verbose");
+                          }
+                      }
+                  } catch (e) {
+                      logger("Failed to fetch fallback fb_dtsg from business: " + e.message, "warn");
+                  }
+              }
+
+          } catch (e) {
+              logger("Failed to fetch fallback fb_dtsg: " + e.message, "warn");
+          }
+      }
+
+      if (!Obj.ctx.fb_dtsg) {
+          log.warn("login", "Could not find fb_dtsg in HTML or fallbacks. Session might be limited.");
+      }
+
       ctx = Obj.ctx;
       api = Obj.api;
       return res;

package/lib/safety/CookieRefresher.js

@@ -101,7 +101,12 @@ class CookieRefresher {
     try {
       // 1. First do a simple fetch to keep session alive
       logger('CookieRefresher', 'Refreshing cookies to extend session...', 'info');
+      
+      // Enhanced URL list to simulate real user activity and keep session alive
       const urls = [
+        'https://www.facebook.com/',
+        'https://www.facebook.com/notifications',
+        'https://www.facebook.com/messages/t/',
         'https://www.facebook.com/me',
         'https://www.facebook.com/ajax/haste-response/?__a=1',
         'https://www.facebook.com/ajax/bootloader-endpoint/?__a=1'
@@ -110,6 +115,11 @@ class CookieRefresher {
       let success = false;
       for (const url of urls) {
         try {
+          // Add random delay between requests to simulate human browsing
+          if (success) {
+            await new Promise(resolve => setTimeout(resolve, 2000 + Math.random() * 3000));
+          }
+
           // Try multiple URLs in case some are blocked
           const res = await this.defaultFuncs.get(url, this.jar, {});
           
@@ -117,7 +127,8 @@ class CookieRefresher {
           if (res && res.headers && res.headers["set-cookie"]) {
             this.utils.saveCookies(this.jar)(res);
             success = true;
-            break;
+            // Don't break immediately, hit a few more to look like a real session
+            if (Math.random() > 0.7) break; 
           }
         } catch (err) {
           logger('CookieRefresher', `Failed to refresh with ${url}: ${err.message}`, 'debug');

package/lib/safety/FacebookSafety.js

@@ -6,7 +6,10 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
-const StealthMode = require('./StealthMode');
+// StealthMode module has been removed to avoid global human-like pauses
+// that can harm perceived stability. FacebookSafety now relies on
+// lightweight adaptive delays and backoff only.
+// const StealthMode = require('./StealthMode');
 
 class FacebookSafety {
     constructor(options = {}) {
@@ -24,14 +27,9 @@ class FacebookSafety {
             ...options
         };
 
-        // Initialize Stealth Mode
-        this.stealthMode = new StealthMode({
-            maxRequestsPerMinute: this.options.ultraLowBanMode ? 3 : 10,
-            enableRandomPauses: true,
-            pauseProbability: this.options.ultraLowBanMode ? 0.08 : 0.02,
-            minPauseMinutes: 3,
-            maxPauseMinutes: 10
-        });
+        // StealthMode has been fully removed; keep a placeholder field
+        // for backward compatibility but do not perform any throttling.
+        this.stealthMode = null;
 
         // ULTRA-SAFE user agents - Most common real browsers (Nov 2025)
         // These are the MOST COMMON UAs to blend in with real users
@@ -58,13 +56,13 @@ class FacebookSafety {
         this.regions = ['ASH', 'ATL', 'DFW', 'ORD', 'PHX', 'SJC', 'IAD'];
         this.currentRegion = this.regions[Math.floor(Math.random() * this.regions.length)];
 
-        // ULTRA-SAFE human delay patterns - Much slower to avoid detection
+        // ULTRA-SAFE human delay patterns - Relaxed for usability
         this.humanDelayPatterns = {
-            typing: { min: 1500, max: 3500 },        // Slower typing (1.5-3.5s)
-            reading: { min: 3000, max: 8000 },       // Longer reading time (3-8s)
-            thinking: { min: 5000, max: 15000 },     // Much longer thinking (5-15s)
-            browsing: { min: 2000, max: 5000 },      // Slower browsing (2-5s)
-            messageDelay: { min: 8000, max: 20000 }  // 8-20s between messages!
+            typing: { min: 500, max: 1500 },         // Normal typing (0.5-1.5s)
+            reading: { min: 1000, max: 3000 },       // Normal reading (1-3s)
+            thinking: { min: 1000, max: 4000 },      // Normal thinking (1-4s)
+            browsing: { min: 500, max: 2000 },       // Normal browsing (0.5-2s)
+            messageDelay: { min: 1000, max: 3000 }   // 1-3s between messages (much faster)
         };
 
         this.sessionMetrics = {
@@ -225,9 +223,21 @@ class FacebookSafety {
 
                 // Check cookie age (older than 30 days might be risky)
                 const oldCookies = parsed.filter(cookie => {
-                    const expires = new Date(cookie.expires || cookie.expirationDate);
-                    const age = Date.now() - expires.getTime();
-                    return age > (30 * 24 * 60 * 60 * 1000); // 30 days
+                    let expVal = cookie.expires || cookie.expirationDate;
+                    // Handle Unix timestamp in seconds (common in FB cookies)
+                    if (typeof expVal === 'number' && expVal < 10000000000) {
+                        expVal *= 1000;
+                    }
+                    const expires = new Date(expVal);
+                    // If invalid date, assume valid to be safe
+                    if (isNaN(expires.getTime())) return false;
+                    
+                    // Check if expired
+                    const timeUntilExpiry = expires.getTime() - Date.now();
+                    // If expired more than 30 days ago, it's "old"
+                    // If timeUntilExpiry is negative, it's expired.
+                    // We want to flag cookies that are LONG expired.
+                    return timeUntilExpiry < -(30 * 24 * 60 * 60 * 1000); 
                 });
 
                 if (oldCookies.length > parsed.length * 0.5) {
@@ -313,16 +323,16 @@ class FacebookSafety {
                 minMs = 2 * 60 * 60 * 1000;      // 2h
                 maxMs = 3 * 60 * 60 * 1000;      // 3h
             } else if (this.sessionMetrics.riskLevel === 'medium') {
-                // Medium risk: 3-5 hours
-                minMs = 3 * 60 * 60 * 1000;      // 3h
-                maxMs = 5 * 60 * 60 * 1000;      // 5h
+                // Medium risk: 1.5-2.5 hours
+                minMs = 1.5 * 60 * 60 * 1000;    // 1.5h
+                maxMs = 2.5 * 60 * 60 * 1000;    // 2.5h
             } else {
-                // Low risk: 4-8 hours (maximum stealth!)
-                minMs = 4 * 60 * 60 * 1000;      // 4h
-                maxMs = 8 * 60 * 60 * 1000;      // 8h
+                // Low risk: 50-90 minutes (Keep session alive!)
+                minMs = 50 * 60 * 1000;          // 50m
+                maxMs = 90 * 60 * 1000;          // 90m
             }
             const interval = minMs + Math.random() * (maxMs - minMs);
-            console.log(`🔒 Next token refresh in ${Math.floor(interval / (60 * 60 * 1000))}h ${Math.floor((interval % (60 * 60 * 1000)) / (60 * 1000))}m (ultra-safe mode)`);
+            console.log(`🔒 Next token refresh in ${Math.floor(interval / (60 * 1000))}m (keep-alive mode)`);
             const t = setTimeout(async () => {
                 await this.refreshSafeSession();
                 schedule();
@@ -637,8 +647,8 @@ class FacebookSafety {
      */
     scheduleLightPoke() {
         if (this._lightPokeTimer || this._destroyed) return;
-        const base = 6 * 60 * 60 * 1000; // 6h
-        const jitter = (Math.random()*80 - 40) * 60 * 1000; // ±40m
+        const base = 45 * 60 * 1000; // 45m (Reduced from 6h to keep session alive)
+        const jitter = (Math.random()*20 - 10) * 60 * 1000; // ±10m
         const schedule = () => {
             if (this._destroyed) return;
             const t = setTimeout(async () => {
@@ -657,7 +667,7 @@ class FacebookSafety {
                     }
                 } catch(_) {}
                 schedule();
-            }, base + (Math.random()*80 - 40) * 60 * 1000);
+            }, base + (Math.random()*20 - 10) * 60 * 1000);
             this._registerTimer(t);
             this._lightPokeTimer = t;
         };
@@ -808,10 +818,8 @@ class FacebookSafety {
     }
 
     async applyAdaptiveSendDelay(){
-        // First, check Stealth Mode limits (rate limiting & pauses)
-        if (this.stealthMode) {
-            await this.stealthMode.waitIfNeeded();
-        }
+        // StealthMode throttling has been removed; rely on lightweight
+        // adaptive delays and backoff logic elsewhere in FacebookSafety.
 
         // Then apply adaptive delay based on risk
         const d = this.computeAdaptiveSendDelay();

package/lib/safety/StealthMode.js

@@ -6,12 +6,12 @@
 class StealthMode {
     constructor(options = {}) {
         this.options = {
-            maxRequestsPerMinute: 3, // Very low limit for safety
+            maxRequestsPerMinute: 1000, // Relaxed from 30 to 1000 based on user feedback
             enableRandomPauses: true,
-            pauseProbability: 0.05, // 5% chance to take a break after each action
-            minPauseMinutes: 5,
-            maxPauseMinutes: 15,
-            dailyRequestLimit: 500, // Hard limit per day
+            pauseProbability: 0.0001, // Reduced from 1% to 0.01%
+            minPauseMinutes: 0.1,
+            maxPauseMinutes: 0.5,
+            dailyRequestLimit: 500000, // Increased from 2000 to 500k
             ...options
         };
 
@@ -99,13 +99,17 @@ class StealthMode {
         this.inPause = true;
         this.pauseUntil = Date.now() + duration;
         
-        console.log(`☕ Stealth Mode: Taking a human break for ${Math.floor(duration / 60000)} minutes...`);
+        const minutes = Math.floor(duration / 60000);
+        const seconds = Math.floor((duration % 60000) / 1000);
+        const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+        console.log(`☕ Stealth Mode: Taking a human break for ${timeStr}...`);
     }
 
     /**
      * Wait until it's safe to proceed
      */
     async waitIfNeeded() {
+        let logged = false;
         while (true) {
             const status = this.canProceed();
             if (status.allowed) {
@@ -113,7 +117,12 @@ class StealthMode {
                 return;
             }
             
-            console.log(`🛡️ Stealth Mode: Waiting ${Math.ceil(status.waitMs / 1000)}s (${status.reason})`);
+            // Only log once per wait cycle to avoid spamming console from parallel requests
+            if (!logged && status.waitMs > 2000) {
+                console.log(`🛡️ Stealth Mode: Waiting ${Math.ceil(status.waitMs / 1000)}s (${status.reason})`);
+                logged = true;
+            }
+            
             await new Promise(resolve => setTimeout(resolve, status.waitMs));
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-fca",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "Nexus-FCA 3.1 – THE BEST, SAFEST, MOST STABLE Facebook Messenger API! Email/password + appState login, proxy support (HTTP/HTTPS/SOCKS5), random user agent, proactive cookie refresh, MQTT stability, session protection, and TypeScript support.",
   "main": "index.js",
   "repository": {
@@ -15,20 +15,22 @@
     "chalk": "^4.1.2",
     "cheerio": "^1.0.0-rc.10",
     "duplexify": "^4.1.3",
+    "form-data": "^4.0.5",
     "got": "^11.8.6",
     "gradient-string": "^2.0.2",
+    "http-proxy-agent": "^7.0.2",
     "https-proxy-agent": "^7.0.5",
     "lodash": "^4.17.21",
     "mqtt": "^4.3.8",
-    "socks-proxy-agent": "^8.0.4",
     "node-cache": "^5.1.2",
     "npmlog": "^7.0.1",
-    "request": "^2.88.2",
     "semver": "^7.5.0",
     "sequelize": "^6.37.6",
+    "socks-proxy-agent": "^8.0.4",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
     "totp-generator": "^1.0.0",
+    "tough-cookie": "^6.0.0",
     "uuid": "^9.0.1",
     "ws": "^8.18.1"
   },

package/src/listenMqtt.js

@@ -39,6 +39,58 @@ const topics = [
   "/webrtc_response",
 ];
 let WebSocket_Global;
+
+function getRandomReconnectTime() {
+    const min = 26 * 60 * 1000;
+    const max = 60 * 60 * 1000;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function fetchSeqID(defaultFuncs, api, ctx, callback) {
+    const form = {
+      av: ctx.globalOptions.pageID,
+      queries: JSON.stringify({
+        o0: {
+          doc_id: "3336396659757871",
+          query_params: {
+            limit: 1,
+            before: null,
+            tags: ["INBOX"],
+            includeDeliveryReceipts: false,
+            includeSeqID: true,
+          },
+        },
+      }),
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (utils.getType(resData) !== "Array") throw { error: "Not logged in", res: resData };
+        if (resData && resData[resData.length - 1].error_results > 0)
+          throw resData[0].o0.errors;
+        if (resData[resData.length - 1].successful_results === 0)
+          throw {
+            error: "getSeqId: there was no successful_results",
+            res: resData,
+          };
+        if (resData[0].o0.data.viewer.message_threads.sync_sequence_id) {
+          ctx.lastSeqId = resData[0].o0.data.viewer.message_threads.sync_sequence_id;
+          callback(null);
+        } else
+          throw {
+            error: "getSeqId: no sync_sequence_id found.",
+            res: resData,
+          };
+      })
+      .catch((err) => {
+        log.error("getSeqId", err);
+        if (utils.getType(err) === "Object" && err.error === "Not logged in")
+          ctx.loggedIn = false;
+        callback(err);
+      });
+}
+
 // Adaptive backoff state (per-process singleton like) - tie to ctx
 function getBackoffState(ctx){
   if(!ctx._adaptiveReconnect){
@@ -163,15 +215,6 @@ function buildStream(options, WebSocket, Proxy) {
         }
       }
     }, pingMs);
-    // Extended timeout for long-running stability (5 minutes instead of 1 minute)
-    const reconnectMs = parseInt(process.env.NEXUS_MQTT_RECONNECT_TIMEOUT, 10) || 300000;
-    reconnectTimeout = setTimeout(() => {
-      if (WebSocket.readyState === WebSocket.OPEN) {
-        WebSocket.close();
-        Stream.end();
-        Stream.destroy();
-      }
-    }, reconnectMs);
   };
   WebSocket_Global = WebSocket;
   Proxy.on("close", () => {
@@ -341,7 +384,15 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
       return globalCallback({ type: "not_logged_in", error: errMsg });
     }
     if (ctx.globalOptions.autoReconnect) {
-      scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
+      // WS3-style: fetch SeqID then reconnect to ensure fresh state
+      fetchSeqID(defaultFuncs, api, ctx, (err) => {
+        if (err) {
+          log.warn("listenMqtt", "Failed to refresh SeqID on error, falling back to adaptive reconnect...");
+          scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
+        } else {
+          listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        }
+      });
     } else {
       utils.checkLiveCookie(ctx, defaultFuncs)
         .then(() => globalCallback({ type: "stop_listen", error: "Connection refused: Server unavailable" }))
@@ -351,26 +402,86 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
   // Ensure reconnection also triggers on unexpected close without prior error
   mqttClient.on('close', function () {
     ctx.health.onDisconnect();
-  if(ctx.health && typeof ctx.health.incFailure === 'function'){ ctx.health.incFailure(); }
-  log.warn('listenMqtt', `MQTT bridge socket closed after ${(Date.now()-attemptStartTs)}ms (attempt=${ctx._mqttDiag.attempts}).`);
+    if (ctx.health && typeof ctx.health.incFailure === 'function') { ctx.health.incFailure(); }
+
+    const duration = Date.now() - attemptStartTs;
+    const seconds = Math.floor(duration / 1000);
+
+    // Treat long-lived connections as normal lifecycle, keep logs calm
+    if (duration >= 30 * 60 * 1000) { // >= 30 minutes
+      log.info('listenMqtt', `MQTT connection closed after ${seconds}s (normal lifecycle). Reconnecting...`);
+    } else if (duration >= 5 * 60 * 1000) { // 5-30 minutes
+      log.info('listenMqtt', `MQTT connection closed after ${seconds}s (remote close). Reconnecting with backoff...`);
+    } else {
+      log.warn('listenMqtt', `MQTT bridge socket closed quickly after ${duration}ms (attempt=${ctx._mqttDiag.attempts}).`);
+    }
+
     if (!ctx.loggedIn) return; // avoid loops if logged out
     if (ctx.globalOptions.autoReconnect) {
       scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
     }
   });
+
   mqttClient.on('disconnect', function(){
     ctx.health.onDisconnect();
-  if(ctx.health && typeof ctx.health.incFailure === 'function'){ ctx.health.incFailure(); }
-  log.warn('listenMqtt', `MQTT bridge disconnect event after ${(Date.now()-attemptStartTs)}ms (attempt=${ctx._mqttDiag.attempts}).`);
+    if (ctx.health && typeof ctx.health.incFailure === 'function') { ctx.health.incFailure(); }
+
+    const duration = Date.now() - attemptStartTs;
+    const seconds = Math.floor(duration / 1000);
+
+    if (duration >= 30 * 60 * 1000) {
+      log.info('listenMqtt', `MQTT disconnected after ${seconds}s (normal lifecycle). Reconnecting...`);
+    } else if (duration >= 5 * 60 * 1000) {
+      log.info('listenMqtt', `MQTT disconnected after ${seconds}s (remote close). Reconnecting with backoff...`);
+    } else {
+      log.warn('listenMqtt', `MQTT bridge disconnect event after ${duration}ms (attempt=${ctx._mqttDiag.attempts}).`);
+    }
+
     if (!ctx.loggedIn) return;
     if (ctx.globalOptions.autoReconnect) {
       scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
     }
   });
+
   mqttClient.on("connect", function () {
     resetBackoff(backoff);
     backoff.consecutiveFails = 0;  // Reset consecutive failures on successful connect
+    // Reset or wrap MQTT attempt counter so long-lived sessions don't look scary
+    ctx._mqttDiag = ctx._mqttDiag || {};
+    if (typeof ctx._mqttDiag.attempts !== 'number' || ctx._mqttDiag.attempts > 100000) {
+      ctx._mqttDiag.attempts = 1;
+    } else {
+      ctx._mqttDiag.attempts++;
+    }
     ctx.health.onConnect();
+
+    // WS3-style randomized proactive reconnect (tunable window).
+    // If globalOptions override is provided, respect that; otherwise
+    // default to a slightly longer window to avoid overlapping too much
+    // with remote/NAT closes.
+    if (ctx._reconnectTimer) clearTimeout(ctx._reconnectTimer);
+    let reconnectTime = null;
+    const opts = ctx.globalOptions || {};
+    const proactiveEnabled = opts.mqttProactiveReconnectEnabled;
+
+    if (proactiveEnabled !== false) {
+      const minM = Number.isFinite(opts.mqttProactiveReconnectMinMinutes) ? opts.mqttProactiveReconnectMinMinutes : 120; // 2h
+      const maxM = Number.isFinite(opts.mqttProactiveReconnectMaxMinutes) ? opts.mqttProactiveReconnectMaxMinutes : 240; // 4h
+      const min = Math.min(minM, maxM);
+      const max = Math.max(minM, maxM);
+      const intervalMinutes = Math.floor(Math.random() * (max - min + 1)) + min;
+      reconnectTime = intervalMinutes * 60 * 1000;
+    }
+
+    if (reconnectTime) {
+      if (verboseMqtt) log.info('listenMqtt', `Scheduled proactive reconnect in ${Math.floor(reconnectTime / 60000)} minutes.`);
+      ctx._reconnectTimer = setTimeout(() => {
+        log.info('listenMqtt', `Executing proactive proactive reconnect (timer window).`);
+        if (ctx.mqttClient) ctx.mqttClient.end(true);
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      }, reconnectTime);
+    }
+
   if (verboseMqtt) {
     log.info('listenMqtt', `Nexus MQTT bridge established in ${(Date.now()-attemptStartTs)}ms (attempt=${ctx._mqttDiag.attempts}).`);
   }
@@ -1089,40 +1200,17 @@ module.exports = function (defaultFuncs, api, ctx) {
   let globalCallback = identity;
   getSeqID = function getSeqID() {
     ctx.t_mqttCalled = false;
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then((resData) => {
-        if (utils.getType(resData) !== "Array") throw { error: "Not logged in", res: resData };
-        if (resData && resData[resData.length - 1].error_results > 0)
-          throw resData[0].o0.errors;
-        if (resData[resData.length - 1].successful_results === 0)
-          throw {
-            error: "getSeqId: there was no successful_results",
-            res: resData,
-          };
-        if (resData[0].o0.data.viewer.message_threads.sync_sequence_id) {
-          ctx.lastSeqId =
-            resData[0].o0.data.viewer.message_threads.sync_sequence_id;
-          listenMqtt(defaultFuncs, api, ctx, globalCallback);
-        } else
-          throw {
-            error: "getSeqId: no sync_sequence_id found.",
-            res: resData,
-          };
-      })
-      .catch((err) => {
-        log.error("getSeqId", err);
-        if (utils.getType(err) === "Object" && err.error === "Not logged in")
-          ctx.loggedIn = false;
-        return globalCallback(err);
-      });
+    fetchSeqID(defaultFuncs, api, ctx, (err) => {
+      if (err) return globalCallback(err);
+      listenMqtt(defaultFuncs, api, ctx, globalCallback);
+    });
   };
   return function (callback) {
     class MessageEmitter extends EventEmitter {
       stopListening(callback) {
         callback = callback || (() => {});
         globalCallback = identity;
+        if (ctx._reconnectTimer) clearTimeout(ctx._reconnectTimer);
         if (ctx.mqttClient) {
           ctx.mqttClient.unsubscribe("/webrtc");
           ctx.mqttClient.unsubscribe("/rtc_multi");