nexus-fca 2.1.2 → 2.1.5

package/CHANGELOG.md

@@ -1,13 +1,53 @@
 # Changelog
 
-## [2.1.2] - Unreleased - CONTINUOUS IDLE RECOVERY
+## [2.1.5] - 2025-08-28 - PendingEdits & ACK Metrics
+### Added
+- PendingEdits buffer with cap (default 200) + TTL (5m) + resend attempts (2) + ACK timeout (12s).
+- Automatic edit resend watchdog with safe limits and metrics (editResends, editFailed, pendingEditsDropped, pendingEditsExpired).
+- API: `api.setEditOptions({ maxPendingEdits, editTTLms, ackTimeoutMs, maxResendAttempts })`.
+- Edit ACK integration: pending edit removed on ACK receipt.
+- Health metrics: p95AckLatencyMs, editResends, editFailed.
+
+### Improved
+- Safer edit pipeline: prevents uncontrolled retries, bounds memory, tracks expirations.
+- Enhanced HealthMetrics with percentile latency sample retention (50-sample window).
+
+### Notes
+- Durable outbound queue & metrics exporter planned next.
+
+---
+
+## [2.1.4] - Adaptive Backoff & Core Metrics
+### Added
+- Adaptive reconnect backoff with jitter (caps at 5 minutes) for safer, stealthier recovery loops.
+- Lazy preflight session validation (skips heavy validation if a recent successful connect occurred) toggle via `api.enableLazyPreflight()`.
+- Health metrics collector (uptime, idle time, reconnect counts, failures, message/ack counters, synthetic keepalives) accessible with `api.getHealthMetrics()` and included in `api.healthCheck()`.
+- Randomized synthetic keepalive interval (55-75s) to reduce detection patterns.
+- Backoff configuration hook: `api.setBackoffOptions()`.
+
+### Improved
+- Reduced noisy session validation on every `listenMqtt` invocation unless needed.
+- More structured error classification feeding metrics (`session_invalid`, `timeout_no_t_ms`, `mqtt_error`, `message_parse`, `not_logged_in`).
+
+### Planned (Next)
+- ACK tracking refinement & resend logic.
+- Pending edits buffer with TTL and cap.
+- Durable outbound queue & health exporter.
+
+---
+
+## [2.1.2] - 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
+- 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/README.md

@@ -1,4 +1,7 @@
-# Nexus-FCA v2.1.0
+# Nexus-FCA v2.1.5
+
+<!-- 2.1.5 Highlights (PendingEdits & ACK Metrics) -->
+> New in 2.1.5: PendingEdits buffer (cap + TTL + safe resend), edit ACK watchdog, p95 ACK latency & edit resend/failure metrics, configurable via `api.setEditOptions()`.
 
 <p align="center">
   <!-- Preview image wrapped in link (corrected ibb.co domain) -->

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,8 +235,21 @@ function buildAPI(globalOptions, html, jar) {
     firstListen: true,
     fb_dtsg,
     wsReqNumber: 0,
-    wsTaskNumber: 0
+    wsTaskNumber: 0,
+    // Provide safety module reference to lower layers (listenMqtt)
+    globalSafety,
+    // Pending edit tracking (Stage 2)
+    pendingEdits: new Map()
   };
+  // Default edit / resend safety settings
+  if(!globalOptions.editSettings){
+    globalOptions.editSettings = {
+      maxPendingEdits: 200,
+      editTTLms: 5*60*1000,
+      ackTimeoutMs: 12000,
+      maxResendAttempts: 2
+    };
+  }
   const api = {
     setOptions: setOptions.bind(null, globalOptions),
     getAppState: function getAppState() {
@@ -222,14 +262,18 @@ function buildAPI(globalOptions, html, jar) {
       );
     },
     healthCheck: function(callback) {
-      // Simple health check: returns status and safeMode info
       callback(null, {
         status: 'ok',
         safeMode,
         time: new Date().toISOString(),
-        userID: ctx.userID || null
+        userID: ctx.userID || null,
+        metrics: ctx.health ? ctx.health.snapshot() : null
       });
     },
+    getHealthMetrics: function(){ return ctx.health ? ctx.health.snapshot() : null; },
+    enableLazyPreflight(enable=true){ ctx.globalOptions.disablePreflight = !enable; },
+    setBackoffOptions(opts={}){ ctx.globalOptions.backoff = Object.assign(ctx.globalOptions.backoff||{}, opts); },
+    setEditOptions(opts={}){ Object.assign(ctx.globalOptions.editSettings, opts); }
   };
   const defaultFuncs = utils.makeDefaults(html, i_userID || userID, ctx);
   require("fs")
@@ -269,6 +313,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 +461,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 +1003,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 +1119,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/health/HealthMetrics.js

@@ -0,0 +1,100 @@
+"use strict";
+// Lightweight health & metrics tracker for Nexus-FCA (extended Stage 2)
+class HealthMetrics {
+  constructor() {
+    const now = Date.now();
+    this.uptimeStart = now;
+    this.lastConnectTs = 0;
+    this.lastDisconnectTs = 0;
+    this.lastMessageTs = 0;
+    this.lastErrorTs = 0;
+    this.lastErrorType = null;
+    this.reconnects = 0;
+    this.consecutiveFailures = 0;
+    this.messagesReceived = 0;
+    this.syntheticKeepAlives = 0;
+    this.acksReceived = 0;
+    this.pendingEdits = 0;
+    this.pendingEditMap = new Map(); // messageID -> { ts, text, attempts }
+    this.pendingEditsDropped = 0;     // dropped due to cap
+    this.pendingEditsExpired = 0;     // expired via TTL sweep
+    this.outboundQueueDepth = 0;
+    this.outboundQueueDropped = 0;
+    this.lastAckLatencyMs = null;
+    this.avgAckLatencyMs = null;
+    this._ackLatencySamples = [];
+    this.p95AckLatencyMs = null;
+    this.editResends = 0;
+    this.editFailed = 0;
+  }
+  onConnect() { this.lastConnectTs = Date.now(); this.consecutiveFailures = 0; }
+  onDisconnect() { this.lastDisconnectTs = Date.now(); }
+  onMessage() { this.messagesReceived++; this.lastMessageTs = Date.now(); }
+  onSynthetic() { this.syntheticKeepAlives++; }
+  onAck(latencyMs){
+    this.acksReceived++;
+    if(typeof latencyMs === 'number'){
+      this.lastAckLatencyMs = latencyMs;
+      if(this.avgAckLatencyMs == null) this.avgAckLatencyMs = latencyMs; else this.avgAckLatencyMs = Math.round(this.avgAckLatencyMs*0.8 + latencyMs*0.2);
+      // track distribution (cap list length for memory safety)
+      this._ackLatencySamples.push(latencyMs);
+      if(this._ackLatencySamples.length > 50) this._ackLatencySamples.shift();
+      this._recalcP95();
+    }
+  }
+  _recalcP95(){
+    if(!this._ackLatencySamples.length){ this.p95AckLatencyMs = null; return; }
+    const sorted = [...this._ackLatencySamples].sort((a,b)=>a-b);
+    const idx = Math.min(sorted.length-1, Math.floor(sorted.length*0.95));
+    this.p95AckLatencyMs = sorted[idx];
+  }
+  onError(type){ this.lastErrorTs = Date.now(); this.lastErrorType = type || 'unknown'; }
+  onReconnectScheduled(delay){ this.reconnects++; this.currentBackoffDelay = delay; if(delay > (this.maxObservedBackoff||0)) this.maxObservedBackoff = delay; }
+  trackOutbound(depth){ this.outboundQueueDepth = depth; }
+  incOutboundDropped(){ this.outboundQueueDropped++; }
+  addPendingEdit(mid, text){ this.pendingEditMap.set(mid, { ts: Date.now(), text, attempts: 0 }); this.pendingEdits = this.pendingEditMap.size; }
+  markEditResent(mid){ const rec = this.pendingEditMap.get(mid); if(rec){ rec.attempts++; this.editResends++; } }
+  markEditFailed(mid){ if(this.pendingEditMap.delete(mid)) { this.pendingEdits = this.pendingEditMap.size; this.editFailed++; } }
+  removePendingEdit(mid){ if(this.pendingEditMap.delete(mid)) this.pendingEdits = this.pendingEditMap.size; }
+  incPendingEditDropped(){ this.pendingEditsDropped++; }
+  incPendingEditExpired(n=1){ this.pendingEditsExpired += n; }
+  sweepPendingEdits(ttlMs){
+    const now = Date.now();
+    let expired = 0;
+    for(const [mid, val] of this.pendingEditMap.entries()){
+      if(now - val.ts > ttlMs){ this.pendingEditMap.delete(mid); expired++; }
+    }
+    if(expired) { this.incPendingEditExpired(expired); }
+    this.pendingEdits = this.pendingEditMap.size;
+  }
+  snapshot(){
+    const now = Date.now();
+    const idleMs = now - (this.lastMessageTs || this.lastConnectTs || now);
+    return {
+      uptimeMs: now - this.uptimeStart,
+      idleMs,
+      reconnects: this.reconnects,
+      consecutiveFailures: this.consecutiveFailures,
+      lastErrorType: this.lastErrorType,
+      lastErrorAgoMs: this.lastErrorTs ? now - this.lastErrorTs : null,
+      currentBackoffDelay: this.currentBackoffDelay||0,
+      maxObservedBackoff: this.maxObservedBackoff||0,
+      messagesReceived: this.messagesReceived,
+      syntheticKeepAlives: this.syntheticKeepAlives,
+      acksReceived: this.acksReceived,
+      lastAckLatencyMs: this.lastAckLatencyMs,
+      avgAckLatencyMs: this.avgAckLatencyMs,
+      p95AckLatencyMs: this.p95AckLatencyMs,
+      pendingEdits: this.pendingEdits,
+      pendingEditsDropped: this.pendingEditsDropped,
+      pendingEditsExpired: this.pendingEditsExpired,
+      editResends: this.editResends,
+      editFailed: this.editFailed,
+      outboundQueueDepth: this.outboundQueueDepth,
+      outboundQueueDropped: this.outboundQueueDropped,
+      healthy: this.isHealthy(idleMs)
+    };
+  }
+  isHealthy(idleMs){ if (this.consecutiveFailures >= 10) return false; if (this.messagesReceived < 5 && idleMs > 5*60*1000) return false; return true; }
+}
+module.exports = { HealthMetrics };

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.5",
   "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/editMessage.js

@@ -1,57 +1,81 @@
 // Nexus-FCA: Advanced and Safe Facebook Chat API
-// editMessage.js - Edit a sent message via MQTT
+// editMessage.js - Edit a sent message via MQTT with PendingEdits buffer & safe resend
 
 const { generateOfflineThreadingID } = require('../utils');
 
-function canBeCalled(func) {
-  try {
-    Reflect.apply(func, null, []);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
 module.exports = function (defaultFuncs, api, ctx) {
   return function editMessage(text, messageID, callback) {
+    callback = callback || function(){};
     if (!ctx.mqttClient) {
-      throw new Error('Not connected to MQTT');
+      return callback(new Error('Not connected to MQTT'));
+    }
+    if(!messageID || typeof text !== 'string') {
+      return callback(new Error('Invalid arguments for editMessage'));
+    }
+    // Safety: manage pending edits buffer with cap & TTL
+    const settings = ctx.globalOptions.editSettings || { maxPendingEdits:200, editTTLms:300000, ackTimeoutMs:12000, maxResendAttempts:2 };
+    // Drop oldest if capacity reached
+    if(ctx.pendingEdits.size >= settings.maxPendingEdits){
+      const firstKey = ctx.pendingEdits.keys().next().value;
+      if(firstKey){ ctx.pendingEdits.delete(firstKey); if(ctx.health) ctx.health.incPendingEditDropped(); }
     }
+    const now = Date.now();
+    ctx.pendingEdits.set(messageID, { text, ts: now, attempts: 0 });
+    if(ctx.health) ctx.health.addPendingEdit(messageID, text);
 
     ctx.wsReqNumber += 1;
     ctx.wsTaskNumber += 1;
 
-    const queryPayload = {
-      message_id: messageID,
-      text: text
-    };
-
-    const query = {
-      failure_count: null,
-      label: '742',
-      payload: JSON.stringify(queryPayload),
-      queue_name: 'edit_message',
-      task_id: ctx.wsTaskNumber
-    };
-
-    const context = {
-      app_id: '2220391788200892',
-      payload: JSON.stringify({
-        data_trace_id: null,
-        epoch_id: parseInt(generateOfflineThreadingID()),
-        tasks: [query],
-        version_id: '6903494529735864'
-      }),
-      request_id: ctx.wsReqNumber,
-      type: 3
-    };
-
-    // if (canBeCalled(callback)) {
-    //   ctx.reqCallbacks[ctx.wsReqNumber] = callback;
-    // }
+    const queryPayload = { message_id: messageID, text };    
+    const query = { failure_count: null, label: '742', payload: JSON.stringify(queryPayload), queue_name: 'edit_message', task_id: ctx.wsTaskNumber };
+    const context = { app_id: '2220391788200892', payload: JSON.stringify({ data_trace_id: null, epoch_id: parseInt(generateOfflineThreadingID()), tasks: [query], version_id: '6903494529735864' }), request_id: ctx.wsReqNumber, type: 3 };
 
-    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {
-      qos: 1, retain: false
-    });
+    try {
+      ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos:1, retain:false }, (err)=>{
+        if(err){
+          if(ctx.health) ctx.health.onError('edit_publish_fail');
+          return callback(err);
+        }
+        // Schedule ACK / resend watchdog
+        scheduleEditAckWatch(messageID, settings, ctx, api, callback);
+        callback(null, { queued:true, messageID });
+      });
+    } catch (e) {
+      if(ctx.health) ctx.health.onError('edit_exception');
+      return callback(e);
+    }
   };
 };
+
+function scheduleEditAckWatch(messageID, settings, ctx, api, originalCb){
+  if(!settings || !ctx) return;
+  const { ackTimeoutMs=12000, maxResendAttempts=2, editTTLms=300000 } = settings;
+  setTimeout(()=>{
+    const rec = ctx.pendingEdits.get(messageID);
+    if(!rec) return; // already acked or removed
+    const age = Date.now() - rec.ts;
+    if(age > editTTLms){
+      ctx.pendingEdits.delete(messageID);
+      if(ctx.health){ ctx.health.removePendingEdit(messageID); ctx.health.incPendingEditExpired(); }
+      return;
+    }
+    if(rec.attempts >= maxResendAttempts){
+      ctx.pendingEdits.delete(messageID);
+      if(ctx.health) ctx.health.markEditFailed(messageID);
+      return;
+    }
+    // Resend
+    try {
+      rec.attempts++;
+      if(ctx.health) ctx.health.markEditResent(messageID);
+      const queryPayload = { message_id: messageID, text: rec.text };
+      const resend = { failure_count:null, label:'742', payload: JSON.stringify(queryPayload), queue_name:'edit_message', task_id: ++ctx.wsTaskNumber };
+      const context = { app_id: '2220391788200892', payload: JSON.stringify({ data_trace_id:null, epoch_id: parseInt(generateOfflineThreadingID()), tasks:[resend], version_id:'6903494529735864' }), request_id: ++ctx.wsReqNumber, type:3 };
+      ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos:1, retain:false });
+      // Chain another watch if still pending
+      scheduleEditAckWatch(messageID, settings, ctx, api, originalCb);
+    } catch(e){
+      if(ctx.health) ctx.health.onError('edit_resend_exception');
+    }
+  }, ackTimeoutMs);
+}

package/src/listenMqtt.js

@@ -11,6 +11,7 @@ var identity = function () {};
 var form = {};
 var getSeqID = function () {};
 const logger = require("../lib/logger.js");
+const { HealthMetrics } = require("../lib/health/HealthMetrics");
 
 // Enhanced imports
 const MqttManager = require("../lib/mqtt/MqttManager");
@@ -38,6 +39,43 @@ const topics = [
   "/webrtc_response",
 ];
 let WebSocket_Global;
+// Adaptive backoff state (per-process singleton like) - tie to ctx
+function getBackoffState(ctx){
+  if(!ctx._adaptiveReconnect){
+    ctx._adaptiveReconnect = {
+      base: 1000,          // 1s
+      max: 5 * 60 * 1000,  // 5m
+      factor: 2,
+      jitter: 0.25,        // 25% random
+      current: 0,
+      lastResetTs: 0
+    };
+  }
+  return ctx._adaptiveReconnect;
+}
+function computeNextDelay(state){
+  if(!state.current) state.current = state.base;
+  else state.current = Math.min(state.max, state.current * state.factor);
+  // jitter
+  const rand = (Math.random() * 2 - 1) * state.jitter; // -j..+j
+  const delay = Math.max(500, Math.round(state.current * (1 + rand)));
+  return delay;
+}
+function resetBackoff(state){
+  state.current = 0;
+  state.lastResetTs = Date.now();
+}
+// Build lazy preflight gating
+function shouldRunPreflight(ctx){
+  if(ctx.globalOptions.disablePreflight) return false;
+  // If we connected successfully within last 10 minutes, skip heavy preflight to reduce surface.
+  const now = Date.now();
+  const metrics = ctx.health;
+  if(metrics && metrics.lastConnectTs && (now - metrics.lastConnectTs) < 10*60*1000){
+    return false;
+  }
+  return true;
+}
 function buildProxy() {
   const Proxy = new Transform({
     objectMode: false,
@@ -128,20 +166,23 @@ function buildStream(options, WebSocket, Proxy) {
   return Stream;
 }
 function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
-  // Improved preflight with option to disable
-  if (!ctx.globalOptions.disablePreflight) {
+  // Attach health metrics container lazily
+  if(!ctx.health) ctx.health = new (require('../lib/health/HealthMetrics').HealthMetrics)();
+  const backoff = getBackoffState(ctx);
+  const runPreflight = shouldRunPreflight(ctx);
+  if (runPreflight) {
     (async () => {
       try {
-        await utils.validateSession(ctx, defaultFuncs, { retries: 2, delayMs: 1000 });
+        await utils.validateSession(ctx, defaultFuncs, { retries: 1, delayMs: 1000 });
       } catch (e) {
-        // Suppress first failure; only emit if still bad after short grace period
         setTimeout(() => {
           utils.validateSession(ctx, defaultFuncs, { retries: 0 }).catch(err2 => {
             log.error("listenMqtt", "Session invalid after retry: Not logged in.");
             ctx.loggedIn = false;
+            ctx.health.onError('session_invalid');
             globalCallback({ type: "not_logged_in", error: "Session invalid (post-retry)." });
           });
-        }, 2000);
+        }, 1500);
       }
     })();
   }
@@ -170,6 +211,7 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
     p: null,
     php_override: ""
   };
+  // jitter user agent keep consistent
   const cookies = ctx.jar.getCookies("https://www.facebook.com").join("; ");
   let host;
   if (ctx.mqttEndpoint) {
@@ -233,33 +275,41 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
   const mqttClient = ctx.mqttClient;
   global.mqttClient = mqttClient;
   mqttClient.on('error', function (err) {
-    log.error("listenMqtt", err);
-    mqttClient.end();
-    // classify redirect/login errors surfaced through upstream logic
     const errMsg = (err && (err.error || err.message || "")).toString();
+    ctx.health.onError(errMsg.includes('not logged in') ? 'not_logged_in' : 'mqtt_error');
+    log.error("listenMqtt", errMsg);
+    try { mqttClient.end(true); } catch(_){ }
     if (/not logged in|login_redirect|html_login_page/i.test(errMsg)) {
       ctx.loggedIn = false;
       return globalCallback({ type: "not_logged_in", error: errMsg });
     }
     if (ctx.globalOptions.autoReconnect) {
-      listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
     } else {
       utils.checkLiveCookie(ctx, defaultFuncs)
-        .then(res => {
-          globalCallback({
-            type: "stop_listen",
-            error: "Connection refused: Server unavailable"
-          }, null);
-        })
-        .catch(err => {
-          globalCallback({
-            type: "account_inactive",
-            error: "Maybe your account is blocked by facebook, please login and check at https://facebook.com"
-          }, null);
-        });
+        .then(() => globalCallback({ type: "stop_listen", error: "Connection refused: Server unavailable" }))
+        .catch(() => globalCallback({ type: "account_inactive", error: "Maybe your account is blocked by facebook, please login and check at https://facebook.com" }));
+    }
+  });
+  // Ensure reconnection also triggers on unexpected close without prior error
+  mqttClient.on('close', function () {
+    ctx.health.onDisconnect();
+    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.loggedIn) return;
+    if (ctx.globalOptions.autoReconnect) {
+      scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
     }
   });
   mqttClient.on("connect", function () {
+    resetBackoff(backoff);
+    ctx.health.onConnect();
+    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;
@@ -295,9 +345,11 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
       JSON.stringify({ make_user_available_when_in_foreground: true }),
       { qos: 1 }
     );
+    // Replace fixed rTimeout reconnect with health-driven logic
     const rTimeout = setTimeout(function () {
+      ctx.health.onError('timeout_no_t_ms');
       mqttClient.end();
-      listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback);
     }, 5000);
     ctx.tmsWait = function () {
       clearTimeout(rTimeout);
@@ -311,14 +363,35 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
     };
   });
   mqttClient.on("message", function (topic, message, _packet) {
+    ctx.health.onMessage();
+    if (ctx.globalSafety) { try { ctx.globalSafety.recordEvent(); } catch(_) {} }
     try {
       let jsonMessage = Buffer.isBuffer(message)
         ? Buffer.from(message).toString()
         : message;
-      try {
-        jsonMessage = JSON.parse(jsonMessage);
-      } catch (e) {
-        jsonMessage = {};
+      try { jsonMessage = JSON.parse(jsonMessage); } catch (e) { jsonMessage = {}; }
+      // ACK tracking: detect send acknowledgements with latency hint if present
+      if (jsonMessage?.message_ack) {
+        const ack = jsonMessage.message_ack;
+        const mid = ack.message_id || ack.mid;
+        if(mid && ctx._pendingOutbound && ctx._pendingOutbound.has(mid)){
+          const started = ctx._pendingOutbound.get(mid);
+            ctx._pendingOutbound.delete(mid);
+            const latency = Date.now() - started;
+            ctx.health.onAck(latency);
+        } else {
+          ctx.health.onAck();
+        }
+        // If this ACK corresponds to an edit, clear from pendingEdits
+        if(mid && ctx.pendingEdits && ctx.pendingEdits.has(mid)){
+          ctx.pendingEdits.delete(mid);
+          if(ctx.health) ctx.health.removePendingEdit(mid);
+        }
+      }
+      if (jsonMessage?.type === 'ack') { ctx.health.onAck(); }
+      // lightweight ack detection heuristic
+      if (jsonMessage?.type === 'ack' || jsonMessage?.message_ack) {
+        ctx.health.onAck();
       }
       if (jsonMessage.type === "jewel_requests_add") {
         globalCallback(null, {
@@ -333,53 +406,15 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
           timestamp: Date.now().toString(),
         });
       } else if (topic === "/t_ms") {
-        if (ctx.tmsWait && typeof ctx.tmsWait == "function") {
-          ctx.tmsWait();
-        }
-        if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) {
-          ctx.lastSeqId = jsonMessage.firstDeltaSeqId;
-          ctx.syncToken = jsonMessage.syncToken;
-        }
-        if (jsonMessage.lastIssuedSeqId) {
-          ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
-        }
-        for (const i in jsonMessage.deltas) {
-          const delta = jsonMessage.deltas[i];
-          parseDelta(defaultFuncs, api, ctx, globalCallback, {
-            delta: delta,
-          });
-        }
-      } else if (
-        topic === "/thread_typing" ||
-        topic === "/orca_typing_notifications"
-      ) {
-        const typ = {
-          type: "typ",
-          isTyping: !!jsonMessage.state,
-          from: jsonMessage.sender_fbid.toString(),
-          threadID: utils.formatID(
-            (jsonMessage.thread || jsonMessage.sender_fbid).toString()
-          ),
-        };
-        (function () {
-          globalCallback(null, typ);
-        })();
+        if (ctx.tmsWait && typeof ctx.tmsWait == "function") { ctx.tmsWait(); }
+        if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) { ctx.lastSeqId = jsonMessage.firstDeltaSeqId; ctx.syncToken = jsonMessage.syncToken; }
+        if (jsonMessage.lastIssuedSeqId) { ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId); }
+        for (const i in jsonMessage.deltas) { const delta = jsonMessage.deltas[i]; parseDelta(defaultFuncs, api, ctx, globalCallback, { delta: delta, }); }
+      } else if ( topic === "/thread_typing" || topic === "/orca_typing_notifications" ) {
+        const typ = { type: "typ", isTyping: !!jsonMessage.state, from: jsonMessage.sender_fbid.toString(), threadID: utils.formatID( (jsonMessage.thread || jsonMessage.sender_fbid).toString() ), };
+        (function () { globalCallback(null, typ); })();
       } else if (topic === "/orca_presence") {
-        if (!ctx.globalOptions.updatePresence) {
-          for (const i in jsonMessage.list) {
-            const data = jsonMessage.list[i];
-            const userID = data["u"];
-            const presence = {
-              type: "presence",
-              userID: userID.toString(),
-              timestamp: data["l"] * 1000,
-              statuses: data["p"],
-            };
-            (function () {
-              globalCallback(null, presence);
-            })();
-          }
-        }
+        if (!ctx.globalOptions.updatePresence) { for (const i in jsonMessage.list) { const data = jsonMessage.list[i]; const userID = data["u"]; const presence = { type: "presence", userID: userID.toString(), timestamp: data["l"] * 1000, statuses: data["p"], }; (function () { globalCallback(null, presence); })(); } }
       } else if (topic == "/ls_resp") {
         const parsedPayload = JSON.parse(jsonMessage.payload);
         const reqID = jsonMessage.request_id;
@@ -387,25 +422,35 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
           const taskData = ctx["tasks"].get(reqID);
           const { type: taskType, callback: taskCallback } = taskData;
           const taskRespData = getTaskResponseData(taskType, parsedPayload);
-          if (taskRespData == null) {
-            taskCallback("error", null);
-          } else {
-            taskCallback(null, {
-              type: taskType,
-              reqID: reqID,
-              ...taskRespData,
-            });
-          }
+          if (taskRespData == null) { taskCallback("error", null); } else { taskCallback(null, { type: taskType, reqID: reqID, ...taskRespData, }); }
         }
       }
     } catch (ex) {
+      ctx.health.onError('message_parse');
       console.error("Message parsing error:", ex);
       if (ex.stack) console.error(ex.stack);
       return;
     }
   });
-  mqttClient.on("close", function () {});
-  mqttClient.on("disconnect", () => {});
+  mqttClient.on("close", function () { ctx.health.onDisconnect(); if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
+  mqttClient.on("disconnect", () => { ctx.health.onDisconnect(); if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
+  // Synthetic keepalive with randomized cadence (55-75s) to appear human and keep state alive
+  if (!ctx._syntheticKeepAliveInterval) {
+    ctx._syntheticKeepAliveInterval = setInterval(() => {
+      if (!ctx.mqttClient || !ctx.mqttClient.connected) return;
+      if (ctx.globalSafety) {
+        const idle = Date.now() - ctx.globalSafety._lastEventTs;
+        if (idle > 65 * 1000) { ctx.globalSafety.recordEvent(); ctx.health.onSynthetic(); }
+      }
+    }, 55000 + Math.floor(Math.random()*20000));
+  }
+}
+function scheduleAdaptiveReconnect(defaultFuncs, api, ctx, globalCallback){
+  const state = getBackoffState(ctx);
+  const delay = computeNextDelay(state);
+  ctx.health.onReconnectScheduled(delay);
+  log.warn('listenMqtt', `Reconnecting in ${delay} ms (adaptive backoff)`);
+  setTimeout(()=>listenMqtt(defaultFuncs, api, ctx, globalCallback), delay);
 }
 function getTaskResponseData(taskType, payload) {
   try {

package/src/sendMessageMqtt.js

@@ -205,14 +205,26 @@ module.exports = function (defaultFuncs, api, ctx) {
 			task.payload = JSON.stringify(task.payload);
 		});
 		form.payload = JSON.stringify(form.payload);
-		console.log(global.jsonStringifyColor(form, null, 2));
+		try { console.log(global.jsonStringifyColor(form, null, 2)); } catch (_) { }
+
+		// Stage 2: outbound tracking for ACK latency
+		if (!ctx._pendingOutbound) ctx._pendingOutbound = new Map();
+		let midCandidate = null;
+		try {
+			const parsed = JSON.parse(form.payload);
+			const firstTask = parsed.tasks && parsed.tasks[0] && JSON.parse(parsed.tasks[0].payload);
+			if (firstTask && firstTask.otid) midCandidate = String(firstTask.otid);
+		} catch (_) { }
+		if (midCandidate) {
+			ctx._pendingOutbound.set(midCandidate, Date.now());
+			if (ctx.health) ctx.health.trackOutbound(ctx._pendingOutbound.size);
+		}
 
 		return mqttClient.publish("/ls_req", JSON.stringify(form), function (err, data) {
 			if (err) {
-				console.error('Error publishing message: ', err);
+				if (ctx.health) ctx.health.onError('publish_fail');
 				callback(err);
 			} else {
-				console.log('Message published successfully with data: ', data);
 				callback(null, data);
 			}
 		});