@eryxenx/fca 1.1.0 → 1.1.2

package/index.js

@@ -5,6 +5,7 @@ const { createFcaClient } = require("./src/app/createFcaClient");
 const { MessengerBot, createMessengerBot } = require("./src/app/MessengerBot");
 const { MessengerContext } = require("./src/app/MessengerContext");
 const { attachThreadInfoRealtimeSync, applyThreadInfoRealtimeEvent } = require("./src/app/threadInfoRealtimeSync");
+const humanizer = require("./src/utils/humanizer");
 
 // CommonJS default export — the login function (classic FCA / GoatBot compatible)
 module.exports = login;
@@ -20,3 +21,9 @@ module.exports.createMessengerBot = createMessengerBot;
 module.exports.MessengerContext = MessengerContext;
 module.exports.attachThreadInfoRealtimeSync = attachThreadInfoRealtimeSync;
 module.exports.applyThreadInfoRealtimeEvent = applyThreadInfoRealtimeEvent;
+
+// Command anti-spam / humanizer
+module.exports.CommandHumanizer = humanizer.CommandHumanizer;
+module.exports.createCommandHumanizer = humanizer.createCommandHumanizer;
+module.exports.createHumanizerMiddleware = humanizer.createHumanizerMiddleware;
+module.exports.humanizer = humanizer;

package/module/login.js

@@ -98,7 +98,8 @@ function login(loginData, options, callback) {
     autoReconnect: true,
     online: true,
     emitReady: false,
-    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+    humanize: undefined
   };
   setOptions(globalOptions, options);
   let prCallback = null;

package/module/loginHelper.js

@@ -1341,8 +1341,7 @@ 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);
-          const { wrapSendMessage } = require("../src/utils/outboundRateLimit");
-          api.sendMessage = wrapSendMessage(nexcaSendMsg, ctxMain, config);
+          api.sendMessage = nexcaSendMsg;
           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/module/options.js

@@ -24,6 +24,10 @@ function setOptions(globalOptions, options) {
         globalOptions.userAgent = options.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
         break;
       }
+      case "humanize": {
+        globalOptions.humanize = options.humanize;
+        break;
+      }
       case "proxy": {
         if (typeof options.proxy !== "string") {
           delete globalOptions.proxy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eryxenx/fca",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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/api/socket/listenE2EE.js

@@ -64,6 +64,16 @@ module.exports = function (defaultFuncs, api, ctx) {
                 if (!ctx.globalOptions.selfListen && event.senderID === ctx.userID) return;
 
                 event.isE2EE = true;
+
+                if (ctx._middleware && ctx._middleware.count > 0) {
+                    ctx._middleware.process(event, function (middlewareErr, processedEvent) {
+                        if (middlewareErr) return globalCallback(middlewareErr, null);
+                        if (processedEvent === null) return;
+                        globalCallback(null, processedEvent);
+                    });
+                    return;
+                }
+
                 globalCallback(null, event);
             });
 

package/src/api/socket/listenMqtt.js

@@ -17,6 +17,7 @@ const createGetSeqID = require("./core/getSeqID");
 const getTaskResponseData = require("./core/getTaskResponseData");
 const createEmitAuth = require("./core/emitAuth");
 const createMiddlewareSystem = require("./middleware");
+const { createCommandHumanizer, createHumanizerMiddleware } = require("../../utils/humanizer");
 
 // Auto-cycle is OFF by default now: a real browser keeps one MQTT socket
 // open for hours. Cycling every exactly-3600.000s (full unsubscribe,
@@ -50,6 +51,24 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   }
   const middleware = ctx._middleware;
 
+  if (!ctx._humanizer) {
+    ctx._humanizer = createCommandHumanizer(ctx.globalOptions.humanize);
+  }
+  if (!ctx._humanizerMiddlewareInstalled) {
+    const humanizeEnabled = ctx.globalOptions.humanize === undefined ||
+      (ctx.globalOptions.humanize && ctx.globalOptions.humanize.enabled !== false);
+    if (humanizeEnabled) {
+      try {
+        middleware.use("humanizer", createHumanizerMiddleware(ctx._humanizer, logger));
+        ctx._humanizerMiddlewareInstalled = true;
+        logger("Humanizer middleware installed (command anti-spam active)", "info");
+      } catch (e) {
+        logger(`Humanizer middleware install failed (non-fatal): ${e && e.message ? e.message : String(e)}`, "warn");
+      }
+    }
+  }
+  api.getHumanizer = () => ctx._humanizer || null;
+
   function installPostGuard() {
     if (ctx._postGuarded) return defaultFuncs.post;
     const rawPost = defaultFuncs.post && defaultFuncs.post.bind(defaultFuncs);

package/src/utils/humanizer.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const DEFAULT_OPTIONS = Object.freeze({
+  enabled: true,
+  reactDelayMs: [2000, 3000],
+  cooldownMs: 5500,
+  resetMs: 10000,
+  maxPerMinute: 20,
+  commands: ["/", "!", "."],
+  perThread: true
+});
+
+function isCommandLike(body, prefixes) {
+  if (typeof body !== "string") return false;
+  const text = body.trim();
+  if (!text || !Array.isArray(prefixes) || !prefixes.length) return false;
+  return prefixes.some(p => typeof p === "string" && p.length > 0 && text.startsWith(p));
+}
+
+function isNoPrefixAdminCommand(event) {
+  try {
+    const GoatBot = typeof global !== "undefined" ? global.GoatBot : undefined;
+    if (!GoatBot || !GoatBot.config || !GoatBot.commands) return false;
+
+    const cfg = GoatBot.config;
+    if (!cfg.noPrefix || cfg.noPrefix.enable !== true) return false;
+    if (!Array.isArray(cfg.adminBot) || !cfg.adminBot.includes(event.senderID)) return false;
+
+    const body = typeof event.body === "string" ? event.body.trim() : "";
+    if (!body) return false;
+
+    const possibleCmd = body.split(/ +/)[0].toLowerCase();
+    if (GoatBot.commands.has(possibleCmd)) return true;
+
+    const alias = GoatBot.aliases && GoatBot.aliases.get(possibleCmd);
+    return Boolean(alias && GoatBot.commands.has(alias));
+  } catch {
+    return false;
+  }
+}
+
+function randomBetween(min, max) {
+  if (Array.isArray(min)) {
+    const pair = min;
+    min = pair[0];
+    max = pair[1];
+  }
+  min = Number(min) || 0;
+  max = Number(max) || min;
+  if (max < min) { const t = min; min = max; max = t; }
+  return min + Math.floor(Math.random() * (max - min + 1));
+}
+
+class CommandHumanizer {
+  constructor(options) {
+    this.setOptions(options);
+    this._threads = new Map();
+    this._global = { windowStart: 0, count: 0, accepted: 0, dropped: 0 };
+    this._eventCount = 0;
+  }
+
+  setOptions(options) {
+    const o = options || {};
+    this.enabled = o.enabled !== false;
+    this.reactDelayMs = o.reactDelayMs || DEFAULT_OPTIONS.reactDelayMs;
+    this.cooldownMs = typeof o.cooldownMs === "number" ? o.cooldownMs : DEFAULT_OPTIONS.cooldownMs;
+    this.resetMs = typeof o.resetMs === "number" ? o.resetMs : DEFAULT_OPTIONS.resetMs;
+    this.maxPerMinute = typeof o.maxPerMinute === "number" ? o.maxPerMinute : DEFAULT_OPTIONS.maxPerMinute;
+    this.prefixes = o.commands || o.prefixes || DEFAULT_OPTIONS.commands;
+    this.perThread = o.perThread !== false;
+    if (o.matcher !== undefined) {
+      this.matcher = typeof o.matcher === "function" ? o.matcher : null;
+    } else if (this.matcher === undefined) {
+      this.matcher = null;
+    }
+  }
+
+  setMatcher(fn) {
+    this.matcher = typeof fn === "function" ? fn : null;
+  }
+
+  isCommand(event) {
+    if (!event) return false;
+    if (isCommandLike(event.body, this.prefixes)) return true;
+    if (typeof this.matcher === "function") {
+      try {
+        if (this.matcher(event)) return true;
+      } catch {
+        // ignore matcher errors, fall through to built-in detection
+      }
+    }
+    return isNoPrefixAdminCommand(event);
+  }
+
+  _keyFor(event) {
+    return this.perThread && event.threadID ? String(event.threadID) : "_global";
+  }
+
+  _globalAllowed() {
+    const now = Date.now();
+    if (now - this._global.windowStart >= 60000) {
+      this._global.windowStart = now;
+      this._global.count = 0;
+    }
+    if (this._global.count >= this.maxPerMinute) return false;
+    this._global.count++;
+    return true;
+  }
+
+  shouldProcess(event) {
+    this._eventCount++;
+    if (!this.enabled) return { ok: true, delayMs: 0 };
+
+    const key = this._keyFor(event);
+    const now = Date.now();
+
+    let st = this._threads.get(key);
+    if (!st) {
+      st = { acceptedAt: 0, coolUntil: 0, lastCmdAt: 0, accepted: 0, dropped: 0 };
+      this._threads.set(key, st);
+    }
+
+    if (st.lastCmdAt > 0 && (now - st.lastCmdAt >= this.resetMs)) {
+      st.acceptedAt = 0;
+      st.coolUntil = 0;
+    }
+    st.lastCmdAt = now;
+
+    if (st.coolUntil > 0 && now < st.coolUntil) {
+      st.dropped++;
+      this._global.dropped++;
+      return { ok: false, delayMs: 0, reason: "cooldown" };
+    }
+
+    if (this.maxPerMinute > 0 && !this._globalAllowed()) {
+      st.dropped++;
+      this._global.dropped++;
+      return { ok: false, delayMs: 0, reason: "global-cap" };
+    }
+
+    st.acceptedAt = now;
+    st.coolUntil = now + this.cooldownMs;
+    st.accepted++;
+    this._global.accepted++;
+    return { ok: true, delayMs: randomBetween(this.reactDelayMs) };
+  }
+
+  reset(key) {
+    if (key === undefined) { this._threads.clear(); return; }
+    this._threads.delete(String(key));
+  }
+
+  stats() {
+    const threads = [];
+    this._threads.forEach((st, k) => threads.push({ threadID: k, ...st }));
+    return {
+      enabled: this.enabled,
+      global: { ...this._global },
+      eventCount: this._eventCount,
+      threads
+    };
+  }
+}
+
+function createCommandHumanizer(options) {
+  return new CommandHumanizer(options);
+}
+
+function createHumanizerMiddleware(humanizer, logger) {
+  const log = typeof logger === "function"
+    ? (msg, level) => logger(msg, level || "info")
+    : () => {};
+
+  return function commandHumanizerMiddleware(event, next) {
+    if (!humanizer.isCommand(event)) { next(); return; }
+
+    const decision = humanizer.shouldProcess(event);
+
+    if (!decision.ok) {
+      const snippet = typeof event.body === "string" ? event.body.slice(0, 40) : String(event.body || "");
+      log(`Humanizer: dropped command "${snippet}" (${decision.reason})`, "warn");
+      next(false);
+      return;
+    }
+
+    const delay = Math.max(0, decision.delayMs || 0);
+    if (delay <= 0) { next(); return; }
+
+    setTimeout(() => next(), delay);
+  };
+}
+
+module.exports = {
+  CommandHumanizer,
+  createCommandHumanizer,
+  createHumanizerMiddleware,
+  randomBetween,
+  isCommandLike,
+  isNoPrefixAdminCommand,
+  DEFAULT_OPTIONS
+};

package/src/utils/outboundRateLimit.js

@@ -1,284 +0,0 @@
-"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 };