@eryxenx/fca 1.0.9 → 1.1.0

package/module/loginHelper.js

@@ -1341,7 +1341,8 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
         // sendMessage override with nexca version (better MQTT + HTTP fallback)
         try {
           const nexcaSendMsg = require("../src/api/socket/sendMessage")(defaultFuncs, api, ctxMain);
-          api.sendMessage = nexcaSendMsg;
+          const { wrapSendMessage } = require("../src/utils/outboundRateLimit");
+          api.sendMessage = wrapSendMessage(nexcaSendMsg, ctxMain, config);
           api.sendMessageMqtt = require("../src/api/socket/sendMessageMqtt")(defaultFuncs, api, ctxMain);
           api.OldMessage = require("../src/api/socket/OldMessage")(defaultFuncs, api, ctxMain);
           api.sendMessageDM = (msg, threadID, cb, replyTo) => api.OldMessage(msg, threadID, cb, replyTo, true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eryxenx/fca",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Facebook Chat API by EryXenX | Stable • Auto Re-login • Full E2EE Support — send messages, media, reactions & more in encrypted chats, hassle-free",
   "main": "index.js",
   "types": "index.d.ts",

package/src/utils/outboundRateLimit.js

@@ -0,0 +1,284 @@
+"use strict";
+
+const logger = require("./nexca-logger");
+
+/**
+ * Global outbound rate-limit / anti-spam layer for api.sendMessage().
+ *
+ * This module has nothing to do with hiding bot traffic from Facebook
+ * (see antiSuspension.js for that, unrelated / untouched by this file).
+ * Its only job is to stop a single thread/user from being able to make a
+ * bot fire an unbounded burst of outgoing replies, and to stop many busy
+ * threads at once from overwhelming the FCA send path.
+ *
+ * Design:
+ *  - Per-thread sliding window: at most `maxPerWindow` sends per thread
+ *    every `windowMs`. Extra sends for that thread are queued, not sent
+ *    immediately.
+ *  - Global concurrency cap: at most `maxConcurrentSends` sendMessage
+ *    calls in flight at once, across all threads.
+ *  - Bounded queue: at most `maxQueueSize` messages waiting at once. Once
+ *    full, new sends are rejected immediately (never silently grows
+ *    without bound).
+ *  - Queue TTL: a queued message that has been waiting longer than
+ *    `maxQueueWaitMs` is dropped instead of being sent very late.
+ *  - Optional short-window duplicate suppression (off by default).
+ *
+ * This wraps the *existing* sendMessage function — it never re-implements
+ * sending, never retries a failed send, and never changes what happens on
+ * success/failure. It only decides *when* the real sendMessage gets
+ * called, and calls it at most once per accepted message.
+ */
+
+const DEFAULTS = {
+  enabled: true,
+  windowMs: 10000,          // RATE_LIMIT_WINDOW
+  maxPerWindow: 3,          // MAX_MESSAGES_PER_WINDOW (per thread/user)
+  maxQueueSize: 500,        // MAX_QUEUE_SIZE (global)
+  maxConcurrentSends: 5,    // MAX_CONCURRENT_SENDS (global)
+  maxQueueWaitMs: 20000,    // drop a queued message after this long
+  queueTickMs: 300,         // how often to re-check a blocked queue
+  dedupe: {
+    enabled: false,         // opt-in: suppress identical back-to-back text
+    windowMs: 1500
+  }
+};
+
+function buildConfig(ctx, projectConfig) {
+  const fromFile = (projectConfig && projectConfig.rateLimiter) || {};
+  const fromLoginOpts = (ctx && ctx.globalOptions && ctx.globalOptions.rateLimiter) || {};
+
+  const merged = Object.assign({}, DEFAULTS, fromFile, fromLoginOpts);
+  merged.dedupe = Object.assign({}, DEFAULTS.dedupe, fromFile.dedupe, fromLoginOpts.dedupe);
+
+  // Same opt-out convention already used for antiBan in sendMessage.js:
+  // globalOptions.outboundRateLimit === false disables this layer entirely.
+  if (ctx && ctx.globalOptions && ctx.globalOptions.outboundRateLimit === false) {
+    merged.enabled = false;
+  }
+  return merged;
+}
+
+function normalizeDedupeBody(msg) {
+  // Only dedupe plain text sends. Attachments/stickers/locations etc. are
+  // left alone since "identical" is much less meaningful for them and the
+  // risk of dropping something the bot actually meant to (re)send is higher.
+  if (typeof msg === "string") return msg;
+  if (msg && typeof msg === "object" && !msg.attachment && typeof msg.body === "string") {
+    return msg.body;
+  }
+  return null;
+}
+
+class OutboundRateLimiter {
+  constructor(originalSendMessage, config) {
+    this.originalSendMessage = originalSendMessage;
+    this.config = config;
+
+    this.perThread = new Map();   // threadKey -> [timestamps]
+    this.dedupeCache = new Map(); // threadKey -> { body, at }
+    this.queue = [];              // [{ msg, threadID, replyToMessage, isSingleUser, key, settle, enqueuedAt }]
+    this.activeSends = 0;
+    this._processing = false;
+    this._retryTimer = null;
+
+    this._gcTimer = setInterval(() => this._gc(), 60000);
+    if (this._gcTimer.unref) this._gcTimer.unref();
+  }
+
+  destroy() {
+    if (this._gcTimer) clearInterval(this._gcTimer);
+    if (this._retryTimer) clearTimeout(this._retryTimer);
+  }
+
+  getStats() {
+    return {
+      queued: this.queue.length,
+      activeSends: this.activeSends,
+      trackedThreads: this.perThread.size
+    };
+  }
+
+  _gc() {
+    const now = Date.now();
+    for (const [key, timestamps] of this.perThread) {
+      while (timestamps.length && timestamps[0] <= now - this.config.windowMs) timestamps.shift();
+      if (!timestamps.length) this.perThread.delete(key);
+    }
+    for (const [key, entry] of this.dedupeCache) {
+      if (now - entry.at > this.config.dedupe.windowMs) this.dedupeCache.delete(key);
+    }
+  }
+
+  _isRateLimited(key) {
+    const timestamps = this.perThread.get(key);
+    if (!timestamps || !timestamps.length) return false;
+    const cutoff = Date.now() - this.config.windowMs;
+    while (timestamps.length && timestamps[0] <= cutoff) timestamps.shift();
+    return timestamps.length >= this.config.maxPerWindow;
+  }
+
+  _recordSend(key) {
+    let timestamps = this.perThread.get(key);
+    if (!timestamps) {
+      timestamps = [];
+      this.perThread.set(key, timestamps);
+    }
+    timestamps.push(Date.now());
+  }
+
+  _isDuplicate(key, msg) {
+    if (!this.config.dedupe.enabled) return false;
+    const body = normalizeDedupeBody(msg);
+    if (body === null) return false;
+    const last = this.dedupeCache.get(key);
+    const now = Date.now();
+    if (last && last.body === body && (now - last.at) < this.config.dedupe.windowMs) {
+      return true;
+    }
+    this.dedupeCache.set(key, { body, at: now });
+    return false;
+  }
+
+  _sweepExpired() {
+    const now = Date.now();
+    for (let i = this.queue.length - 1; i >= 0; i--) {
+      const job = this.queue[i];
+      if (now - job.enqueuedAt > this.config.maxQueueWaitMs) {
+        this.queue.splice(i, 1);
+        job.settle({ error: "sendMessage: queued message expired before it could be sent (rate-limit backlog)" });
+      }
+    }
+  }
+
+  _processQueue() {
+    if (this._processing) return;
+    this._processing = true;
+    try {
+      this._sweepExpired();
+      let i = 0;
+      while (i < this.queue.length && this.activeSends < this.config.maxConcurrentSends) {
+        const job = this.queue[i];
+        if (this._isRateLimited(job.key)) {
+          i++;
+          continue;
+        }
+        this.queue.splice(i, 1);
+        this._dispatch(job);
+      }
+    } finally {
+      this._processing = false;
+    }
+
+    if (this._retryTimer) return;
+    if (!this.queue.length) return;
+    this._retryTimer = setTimeout(() => {
+      this._retryTimer = null;
+      this._processQueue();
+    }, this.config.queueTickMs);
+    if (this._retryTimer.unref) this._retryTimer.unref();
+  }
+
+  _callOriginal(job) {
+    const original = this.originalSendMessage;
+    return new Promise((resolve, reject) => {
+      try {
+        original(job.msg, job.threadID, (err, result) => {
+          if (err) reject(err); else resolve(result);
+        }, job.replyToMessage, job.isSingleUser);
+      } catch (syncErr) {
+        reject(syncErr);
+      }
+    });
+  }
+
+  async _dispatch(job) {
+    this.activeSends++;
+    this._recordSend(job.key);
+    try {
+      const result = await this._callOriginal(job);
+      job.settle(null, result);
+    } catch (err) {
+      // No automatic retry here on purpose — a failed send stays failed,
+      // exactly like calling the un-wrapped sendMessage would behave.
+      job.settle(err);
+    } finally {
+      this.activeSends--;
+      this._processQueue();
+    }
+  }
+
+  send(msg, threadID, callback, replyToMessage, isSingleUser) {
+    if (typeof callback !== "function") callback = null;
+
+    let resolveOuter, rejectOuter;
+    const outerPromise = new Promise((res, rej) => {
+      resolveOuter = res;
+      rejectOuter = rej;
+    });
+
+    let settled = false;
+    const settle = (err, result) => {
+      if (settled) return;
+      settled = true;
+      if (callback) {
+        try {
+          callback(err || null, result);
+        } catch (cbErr) {
+          logger.warn("RateLimiter", "sendMessage callback threw: " + (cbErr && cbErr.message ? cbErr.message : cbErr));
+        }
+      }
+      if (err) rejectOuter(err); else resolveOuter(result);
+    };
+
+    const key = threadID === undefined || threadID === null ? "unknown" : String(threadID);
+
+    if (this._isDuplicate(key, msg)) {
+      settle(null, { skipped: true, reason: "duplicate" });
+      return outerPromise;
+    }
+
+    if (this.queue.length >= this.config.maxQueueSize) {
+      settle({ error: "sendMessage: outbound queue is full, message dropped" });
+      return outerPromise;
+    }
+
+    this.queue.push({
+      msg,
+      threadID,
+      replyToMessage,
+      isSingleUser,
+      key,
+      settle,
+      enqueuedAt: Date.now()
+    });
+    this._processQueue();
+
+    return outerPromise;
+  }
+}
+
+/**
+ * Wraps an existing sendMessage(msg, threadID, callback, replyToMessage,
+ * isSingleUser) function with the rate-limit/queue layer above. Same
+ * signature in, same signature out — callers (GoatBot command files, etc.)
+ * cannot tell the difference except for pacing under burst load.
+ */
+function wrapSendMessage(originalSendMessage, ctx, projectConfig) {
+  const config = buildConfig(ctx, projectConfig);
+  if (!config.enabled) return originalSendMessage;
+
+  const limiter = new OutboundRateLimiter(originalSendMessage, config);
+
+  const wrapped = function sendMessage(msg, threadID, callback, replyToMessage, isSingleUser) {
+    return limiter.send(msg, threadID, callback, replyToMessage, isSingleUser);
+  };
+
+  wrapped.getRateLimiterStats = () => limiter.getStats();
+  wrapped._rateLimiterConfig = config;
+  wrapped._rateLimiterInstance = limiter;
+
+  return wrapped;
+}
+
+module.exports = { wrapSendMessage, OutboundRateLimiter, DEFAULTS };