nexus-fca 2.1.3 → 2.1.6

package/CHANGELOG.md

@@ -1,6 +1,58 @@
 # Changelog
 
-## [2.1.2] - Unreleased - CONTINUOUS IDLE RECOVERY
+## [2.1.6] - 2025-08-31 - Memory Guard & Queue Sweeping
+### Added
+- Central lightweight memory guard sweeps: group queue pruning (idle >30m, overflow trim) and pendingEdits TTL sweeper (every 4m).
+- Health metrics extended: memoryGuardRuns, memoryGuardActions, groupQueueDroppedMessages, groupQueueExpiredQueues, groupQueuePrunedThreads, pendingEditSweeps.
+- API: `api.getMemoryMetrics()` returns focused memory-related counters.
+- Typings updated (`EditOptions`, new API methods) in `index.d.ts`.
+
+### Improved
+- Group queue now tracks `lastActive` and enforces idle purge + overflow protection with metrics.
+- Pending edits TTL enforcement separated from resend watchdog for deterministic expiry.
+
+### Notes
+- All guards are low-frequency, low-impact; no change to delivery reliability or safety – only prevention of unbounded growth.
+
+---
+
+## [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

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.d.ts

@@ -395,6 +395,11 @@ declare module 'nexus-fca' {
         setMessageReaction: (reaction: string, messageID: string, callback?: (err?: Error) => void, forceCustomReaction?: boolean) => Promise<void>,
         setMessageReactionMqtt: (reaction: string, messageID: string, threadID: string, callback?: (err?: Error) => void) => Promise<void>,
         setOptions: (options: Partial<IFCAU_Options>) => void,
+        setEditOptions: (opts: EditOptions) => void,
+        setBackoffOptions: (opts: { base?: number; max?: number; factor?: number; jitter?: number }) => void,
+        enableLazyPreflight: (enable?: boolean) => void,
+        getHealthMetrics: () => any,
+        getMemoryMetrics: () => { pendingEdits: number; pendingEditsDropped: number; pendingEditsExpired: number; outboundQueueDepth: number; groupQueueDroppedMessages: number; memoryGuardRuns: number; memoryGuardActions: number } | null,
         setTitle: (newTitle: string, threadID: string, callback?: (err?: Error) => void) => Promise<void>,
         setTheme: (themeID?: string, threadID: string, callback?: (err?: Error) => void) => Promise<void>,
         unsendMessage: (messageID: string, callback?: (err?: Error) => void) => Promise<void>,

package/index.js

@@ -237,8 +237,19 @@ function buildAPI(globalOptions, html, jar) {
     wsReqNumber: 0,
     wsTaskNumber: 0,
     // Provide safety module reference to lower layers (listenMqtt)
-    globalSafety
+    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() {
@@ -251,14 +262,31 @@ 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); },
+    getMemoryMetrics(){
+      if(!ctx.health) return null;
+      const snap = ctx.health.snapshot();
+      return {
+        pendingEdits: snap.pendingEdits,
+        pendingEditsDropped: snap.pendingEditsDropped,
+        pendingEditsExpired: snap.pendingEditsExpired,
+        outboundQueueDepth: snap.outboundQueueDepth,
+        groupQueueDroppedMessages: snap.groupQueueDroppedMessages,
+        memoryGuardRuns: snap.memoryGuardRuns,
+        memoryGuardActions: snap.memoryGuardActions
+      };
+    }
   };
   const defaultFuncs = utils.makeDefaults(html, i_userID || userID, ctx);
   require("fs")
@@ -300,7 +328,7 @@ function buildAPI(globalOptions, html, jar) {
   }, 1000 * 60 * 60 * 24);
   // === Group Queue (No Cooldown, Sequential per group) ===
   (function initGroupQueue(){
-    const groupQueues = new Map(); // threadID -> { q: [], sending: false }
+    const groupQueues = new Map(); // threadID -> { q: [], sending: false, lastActive: number }
     const isGroupThread = (tid) => typeof tid === 'string' && tid.length >= 15; // simple heuristic
     const DIRECT_FN = api.sendMessage; // original
 
@@ -310,6 +338,8 @@ function buildAPI(globalOptions, html, jar) {
     api.setGroupQueueCapacity = function(n){ globalOptions.groupQueueMax = n; };
     api.enableGroupQueue(true);
     api.setGroupQueueCapacity(100); // allow up to 100 pending per group
+    // New: group queue retention policy
+    globalOptions.groupQueueIdleMs = 30*60*1000; // 30m idle purge
 
     api._sendMessageDirect = DIRECT_FN;
     api.sendMessage = function(message, threadID, cb){
@@ -317,10 +347,12 @@ function buildAPI(globalOptions, html, jar) {
         return api._sendMessageDirect(message, threadID, cb);
       }
       let entry = groupQueues.get(threadID);
-      if(!entry){ entry = { q: [], sending: false }; groupQueues.set(threadID, entry); }
+      if(!entry){ entry = { q: [], sending: false, lastActive: Date.now() }; groupQueues.set(threadID, entry); }
+      entry.lastActive = Date.now();
       if(entry.q.length >= (globalOptions.groupQueueMax||100)) {
         // drop oldest (keep newest) to avoid unbounded growth
         entry.q.shift();
+        if(ctx.health) ctx.health.recordGroupQueuePrune(0,0,1);
       }
       entry.q.push({ message, threadID, cb });
       processQueue(threadID, entry);
@@ -349,6 +381,33 @@ function buildAPI(globalOptions, html, jar) {
       }
       entry.sending = false;
     };
+
+    // Memory guard sweeper (lightweight)
+    if(!globalOptions._groupQueueSweeper){
+      globalOptions._groupQueueSweeper = setInterval(()=>{
+        const now = Date.now();
+        let prunedThreads = 0; let expiredQueues = 0; let dropped = 0; let actions = 0;
+        for(const [tid, entry] of groupQueues.entries()){
+          // Idle purge
+            if(now - entry.lastActive > (globalOptions.groupQueueIdleMs||1800000) && !entry.sending){
+              if(entry.q.length){ dropped += entry.q.length; }
+              groupQueues.delete(tid); expiredQueues++; actions++;
+              continue;
+            }
+          // Hard cap queue length (just in case capacity changed lower)
+          const cap = globalOptions.groupQueueMax||100;
+          if(entry.q.length > cap){
+            const overflow = entry.q.length - cap;
+            entry.q.splice(0, overflow); // drop oldest overflow
+            dropped += overflow; actions++;
+          }
+        }
+        if((prunedThreads||expiredQueues||dropped) && ctx.health){
+          ctx.health.recordGroupQueuePrune(prunedThreads, expiredQueues, dropped);
+          ctx.health.recordMemoryGuardRun(actions);
+        }
+      }, 5*60*1000); // every 5 minutes
+    }
   })();
   // === End Group Queue ===
   return {

package/lib/health/HealthMetrics.js

@@ -0,0 +1,122 @@
+"use strict";
+// Lightweight health & metrics tracker for Nexus-FCA (extended Stage 2 + Memory Guard)
+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;
+    // Memory / queue guard metrics (Stage 3)
+    this.memoryGuardRuns = 0;
+    this.memoryGuardLastRun = 0;
+    this.memoryGuardActions = 0;
+    this.groupQueuePrunedThreads = 0;
+    this.groupQueueExpiredQueues = 0;
+    this.groupQueueDroppedMessages = 0;
+    this.pendingEditSweeps = 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.pendingEditSweeps++; }
+    this.pendingEdits = this.pendingEditMap.size;
+  }
+  // Memory guard helpers
+  recordMemoryGuardRun(actions=0){ this.memoryGuardRuns++; this.memoryGuardLastRun = Date.now(); this.memoryGuardActions += actions; }
+  recordGroupQueuePrune(threads, expiredQueues, droppedMsgs){
+    if(threads) this.groupQueuePrunedThreads += threads;
+    if(expiredQueues) this.groupQueueExpiredQueues += expiredQueues;
+    if(droppedMsgs) this.groupQueueDroppedMessages += droppedMsgs;
+  }
+  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,
+      memoryGuardRuns: this.memoryGuardRuns,
+      memoryGuardLastRun: this.memoryGuardLastRun,
+      memoryGuardActions: this.memoryGuardActions,
+      groupQueuePrunedThreads: this.groupQueuePrunedThreads,
+      groupQueueExpiredQueues: this.groupQueueExpiredQueues,
+      groupQueueDroppedMessages: this.groupQueueDroppedMessages,
+      pendingEditSweeps: this.pendingEditSweeps,
+      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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-fca",
-  "version": "2.1.3",
+  "version": "2.1.6",
   "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,40 @@ 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");
@@ -296,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);
@@ -312,15 +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, {
@@ -335,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;
@@ -389,39 +422,36 @@ 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 () { if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
-  mqttClient.on("disconnect", () => { if (ctx.globalSafety) { try { ctx.globalSafety._ensureMqttAlive(); } catch(_) {} } });
-  // Lightweight periodic synthetic event to prevent idle expiry if FB sends nothing
+  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;
-        // Inject synthetic event every 70s if no real traffic -> keeps timers fresh
-        if (idle > 65 * 1000) {
-          ctx.globalSafety.recordEvent();
-        }
+        if (idle > 65 * 1000) { ctx.globalSafety.recordEvent(); ctx.health.onSynthetic(); }
       }
-    }, 30000);
+    }, 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 {
     switch (taskType) {

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);
 			}
 		});