@lazyneoaz/nkxchat 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/nkxchat",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "commonjs",
   "types": "src/types/index.d.ts",
   "description": "Advanced Facebook Chat API client for building Messenger bots — real-time messaging, thread management, MQTT, and session stability.",
@@ -39,6 +39,7 @@
     "nkxchat"
   ],
   "dependencies": {
+    "@dongdev/fca-unofficial": "^4.0.3",
     "axios": "^1.13.5",
     "axios-cookiejar-support": "^4.0.7",
     "bluebird": "^3.7.2",

package/src/apis/listenMqtt.js

@@ -593,9 +593,72 @@ function mqttConf(ctx, overrides) {
     return ctx._mqttOpt;
 }
 
+function createMiddlewareSystem() {
+    const stack = [];
+    let nextId = 0;
+    function use(nameOrFn, fn) {
+        let name, middlewareFn;
+        if (typeof nameOrFn === "string" && typeof fn === "function") {
+            name = nameOrFn; middlewareFn = fn;
+        } else if (typeof nameOrFn === "function") {
+            middlewareFn = nameOrFn; name = `middleware_${nextId++}`;
+        } else throw new Error("Middleware must be a function or (name, function)");
+        const entry = { name, fn: middlewareFn, enabled: true };
+        stack.push(entry);
+        return function remove() {
+            const i = stack.indexOf(entry);
+            if (i !== -1) stack.splice(i, 1);
+        };
+    }
+    function remove(identifier) {
+        const i = typeof identifier === "string"
+            ? stack.findIndex(e => e.name === identifier)
+            : stack.findIndex(e => e.fn === identifier);
+        if (i !== -1) { stack.splice(i, 1); return true; }
+        return false;
+    }
+    function clear() { stack.length = 0; }
+    function list() { return stack.filter(e => e.enabled).map(e => e.name); }
+    function setEnabled(name, enabled) {
+        const e = stack.find(e => e.name === name);
+        if (e) { e.enabled = enabled; return true; }
+        return false;
+    }
+    function process(event, finalCallback) {
+        const active = stack.filter(e => e.enabled);
+        if (!active.length) return finalCallback(null, event);
+        let idx = 0;
+        function next(err) {
+            if (err && err !== false && err !== null) return finalCallback(err, null);
+            if (err === false || err === null) return finalCallback(null, null);
+            if (idx >= active.length) return finalCallback(null, event);
+            const mw = active[idx++];
+            try {
+                const r = mw.fn(event, next);
+                if (r && typeof r.then === "function") r.then(() => next()).catch(e => next(e));
+                else if (r === false || r === null) finalCallback(null, null);
+            } catch (e) { next(e); }
+        }
+        next();
+    }
+    function wrapCallback(callback) {
+        return function(err, event) {
+            if (err) return callback(err, null);
+            if (!event) return callback(null, null);
+            process(event, (mwErr, processed) => {
+                if (mwErr) return callback(mwErr, null);
+                if (processed === null) return;
+                callback(null, processed);
+            });
+        };
+    }
+    return { use, remove, clear, list, setEnabled, process, wrapCallback, get count() { return stack.filter(e => e.enabled).length; } };
+}
+
 module.exports = (defaultFuncs, api, ctx, opts) => {
     const identity = () => {};
     let globalCallback = identity;
+    if (!ctx._middleware) ctx._middleware = createMiddlewareSystem();
 
     function emitAuthError(reason, detail) {
         try { if (ctx._autoCycleTimer) clearTimeout(ctx._autoCycleTimer); } catch (_) { }
@@ -930,7 +993,7 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
 
         const msgEmitter = new MessageEmitter();
 
-        globalCallback = callback || function(error, message) {
+        const baseCallback = callback || function(error, message) {
             if (error) { 
                 utils.error("MQTT", "Emit error");
                 return msgEmitter.emit("error", error); 
@@ -941,6 +1004,12 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             msgEmitter.emit("message", message);
         };
 
+        globalCallback = ctx._middleware && ctx._middleware.count
+            ? ctx._middleware.wrapCallback(baseCallback)
+            : baseCallback;
+
+        ctx._emitter = msgEmitter;
+
         ctx._listeningActive = true;
         ctx._lastListenCallback = callback || null;
 
@@ -990,6 +1059,24 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
 
         api.stopListening = msgEmitter.stopListening;
         api.stopListeningAsync = msgEmitter.stopListeningAsync;
+
+        api.useMiddleware = function(nameOrFn, fn) {
+            const remove = ctx._middleware.use(nameOrFn, fn);
+            globalCallback = ctx._middleware.wrapCallback(baseCallback || identity);
+            return remove;
+        };
+        api.removeMiddleware = function(identifier) {
+            const ok = ctx._middleware.remove(identifier);
+            if (!ctx._middleware.count) globalCallback = baseCallback || identity;
+            return ok;
+        };
+        api.clearMiddleware = function() {
+            ctx._middleware.clear();
+            globalCallback = baseCallback || identity;
+        };
+        api.listMiddleware = function() { return ctx._middleware.list(); };
+        api.setMiddlewareEnabled = function(name, enabled) { return ctx._middleware.setEnabled(name, enabled); };
+
         return msgEmitter;
     };
 };

package/src/apis/scheduler.js

@@ -0,0 +1,129 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const scheduledMessages = new Map();
+  let nextId = 1;
+
+  function toTimestamp(when) {
+    if (when instanceof Date) return when.getTime();
+    if (typeof when === "number") return when;
+    if (typeof when === "string") return new Date(when).getTime();
+    return NaN;
+  }
+
+  function scheduleMessage(message, threadID, when, options) {
+    options = options || {};
+    const timestamp = toTimestamp(when);
+    if (isNaN(timestamp)) throw new Error("Invalid 'when'. Must be Date, number (ms timestamp), or ISO string.");
+    const now = Date.now();
+    if (timestamp <= now) throw new Error("Scheduled time must be in the future.");
+
+    const id = `scheduled_${nextId++}_${now}`;
+    const delay = timestamp - now;
+
+    const scheduled = {
+      id,
+      message,
+      threadID,
+      timestamp,
+      createdAt: now,
+      options: {
+        replyMessageID: options.replyMessageID || null,
+        callback: options.callback || null,
+      },
+      cancelled: false,
+      timeout: null,
+    };
+
+    scheduled.timeout = setTimeout(() => {
+      if (scheduled.cancelled) return;
+      const sendFn = api.sendMessage || api.sendMessageMqtt;
+      if (!sendFn) return;
+      Promise.resolve(
+        sendFn(message, threadID, scheduled.options.callback || (() => {}), scheduled.options.replyMessageID)
+      ).then(() => {
+        scheduledMessages.delete(id);
+      }).catch(() => {
+        scheduledMessages.delete(id);
+      });
+    }, delay);
+
+    scheduledMessages.set(id, scheduled);
+    return id;
+  }
+
+  function cancelScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return false;
+    clearTimeout(s.timeout);
+    s.cancelled = true;
+    scheduledMessages.delete(id);
+    return true;
+  }
+
+  function getScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return null;
+    return {
+      id: s.id,
+      message: s.message,
+      threadID: s.threadID,
+      timestamp: s.timestamp,
+      createdAt: s.createdAt,
+      options: { ...s.options },
+      timeUntilSend: s.timestamp - Date.now(),
+    };
+  }
+
+  function listScheduledMessages() {
+    const now = Date.now();
+    return Array.from(scheduledMessages.values())
+      .filter(s => !s.cancelled)
+      .map(s => ({
+        id: s.id,
+        message: s.message,
+        threadID: s.threadID,
+        timestamp: s.timestamp,
+        createdAt: s.createdAt,
+        options: { ...s.options },
+        timeUntilSend: s.timestamp - now,
+      }))
+      .sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  function cancelAllScheduledMessages() {
+    let count = 0;
+    for (const id of Array.from(scheduledMessages.keys())) {
+      if (cancelScheduledMessage(id)) count++;
+    }
+    return count;
+  }
+
+  function getScheduledCount() {
+    return scheduledMessages.size;
+  }
+
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [id, s] of scheduledMessages.entries()) {
+      if (s.cancelled || s.timestamp < now) scheduledMessages.delete(id);
+    }
+  }, 5 * 60 * 1000);
+
+  function destroy() {
+    clearInterval(cleanupInterval);
+    return cancelAllScheduledMessages();
+  }
+
+  ctx._scheduler = { destroy };
+
+  return {
+    scheduleMessage,
+    cancelScheduledMessage,
+    getScheduledMessage,
+    listScheduledMessages,
+    cancelAllScheduledMessages,
+    getScheduledCount,
+    destroy,
+  };
+};

package/src/apis/sendMessage.js

@@ -13,38 +13,26 @@ const allowedProperties = {
   mentions: true,
   location: true,
   effect: true,
+  replyToMessage: true,
 };
 
 module.exports = (defaultFuncs, api, ctx) => {
-  function getThreadCache() {
-    if (!ctx.threadTypeCache) ctx.threadTypeCache = Object.create(null);
-    return ctx.threadTypeCache;
-  }
-
-  async function isGroupThread(threadID, explicitIsGroup) {
-    if (utils.getType(explicitIsGroup) === "Boolean") return !!explicitIsGroup;
-    const tid = threadID.toString();
-    const cache = getThreadCache();
-    if (Object.prototype.hasOwnProperty.call(cache, tid)) return !!cache[tid];
-    try {
-      const info = await api.getThreadInfo(tid);
-      cache[tid] = !!info.isGroup;
-      return !!info.isGroup;
-    } catch (_) {
-      const fallback = tid.length >= 16;
-      cache[tid] = fallback;
-      return fallback;
-    }
+  async function getUrl(url) {
+    const resData = await defaultFuncs.post(
+      "https://www.facebook.com/message_share_attachment/fromURI/",
+      ctx.jar,
+      { image_height: 960, image_width: 960, uri: url }
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData || resData.error || !resData.payload) throw new Error("Invalid url");
+    return resData.payload.share_data.share_params;
   }
 
   function detectAttachmentType(attachment) {
-    const path = attachment.path || '';
-    const ext = path.toLowerCase().split('.').pop();
-
+    const p = attachment.path || '';
+    const ext = p.toLowerCase().split('.').pop();
     const audioTypes = ['mp3', 'wav', 'aac', 'm4a', 'ogg', 'opus', 'flac'];
     const videoTypes = ['mp4', 'mov', 'avi', 'mkv', 'webm', 'wmv', 'flv'];
     const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg'];
-
     if (audioTypes.includes(ext)) return { voice_clip: "true" };
     if (videoTypes.includes(ext)) return { video: "true" };
     if (imageTypes.includes(ext)) return { image: "true" };
@@ -63,7 +51,6 @@ module.exports = (defaultFuncs, api, ctx) => {
       {},
       { ...ctx, requestThreadID: threadIDHint }
     ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-
     if (oksir.error) throw new Error(JSON.stringify(oksir));
     return oksir.payload.metadata[0];
   }
@@ -82,24 +69,122 @@ module.exports = (defaultFuncs, api, ctx) => {
     return uploads;
   }
 
-  async function getUrl(url) {
-    const resData = await defaultFuncs.post(
-      "https://www.facebook.com/message_share_attachment/fromURI/",
-      ctx.jar,
-      { image_height: 960, image_width: 960, uri: url }
-    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-    if (!resData || resData.error || !resData.payload) throw new Error("Invalid url");
-    return resData.payload.share_data.share_params;
+  function getThreadCache() {
+    if (!ctx.threadTypeCache) ctx.threadTypeCache = Object.create(null);
+    return ctx.threadTypeCache;
   }
 
-  async function sendContent(form, threadID, isSingleUser, messageAndOTID) {
-    if (utils.getType(threadID) === "Array") {
-      for (let i = 0; i < threadID.length; i++) {
-        form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
+  async function isGroupThread(threadID, explicitIsGroup) {
+    if (utils.getType(explicitIsGroup) === "Boolean") return !!explicitIsGroup;
+    const tid = threadID.toString();
+    const cache = getThreadCache();
+    if (Object.prototype.hasOwnProperty.call(cache, tid)) return !!cache[tid];
+    try {
+      const info = await api.getThreadInfo(tid);
+      cache[tid] = !!info.isGroup;
+      return !!info.isGroup;
+    } catch (_) {
+      const fallback = tid.length >= 16;
+      cache[tid] = fallback;
+      return fallback;
+    }
+  }
+
+  async function sendViaHttp(msg, threadID, replyToMessage, isGroup) {
+    const isSingleUser = !(await isGroupThread(threadID, isGroup));
+    let messageAndOTID = utils.generateOfflineThreadingID();
+    let form = {
+      client: "mercury",
+      action_type: "ma-type:user-generated-message",
+      author: "fbid:" + ctx.userID,
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_filtered_content_bh: false,
+      is_filtered_content_account: false,
+      is_filtered_content_quasar: false,
+      is_filtered_content_invalid_app: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      ...(msg.body && { body: msg.body }),
+      html_body: false,
+      ui_push_phase: "V3",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      "ephemeral_ttl_mode:": "0",
+      manual_retry_cnt: "0",
+      has_attachment: !!(msg.attachment || msg.url || msg.sticker),
+      signatureID: utils.getSignatureID(),
+      ...(replyToMessage && { replied_to_message_id: replyToMessage })
+    };
+
+    if (msg.location) {
+      if (!msg.location.latitude || !msg.location.longitude) throw new Error("location property needs both latitude and longitude");
+      form["location_attachment[coordinates][latitude]"] = msg.location.latitude;
+      form["location_attachment[coordinates][longitude]"] = msg.location.longitude;
+      form["location_attachment[is_current_location]"] = !!msg.location.current;
+    }
+    if (msg.sticker) form["sticker_id"] = msg.sticker;
+    if (msg.effect) {
+      const effectTag = String(msg.effect).toUpperCase().replace(/[\s\-]+/g, '_');
+      form.has_lightweight_action = true;
+      form['lightweight_action_attached[message_id]'] = messageAndOTID;
+      form['lightweight_action_attached[messaging_tag]'] = 'fb.messaging.effects.' + effectTag;
+    }
+    if (msg.attachment) {
+      form.image_ids = [];
+      form.gif_ids = [];
+      form.file_ids = [];
+      form.video_ids = [];
+      form.audio_ids = [];
+      if (utils.getType(msg.attachment) !== "Array") msg.attachment = [msg.attachment];
+      const files = await uploadAttachment(msg.attachment, threadID);
+      files.forEach(file => {
+        const type = Object.keys(file)[0];
+        form["" + type + "s"].push(file[type]);
+      });
+    }
+    if (msg.url) {
+      form["shareable_attachment[share_type]"] = "100";
+      const params = await getUrl(msg.url);
+      form["shareable_attachment[share_params]"] = params;
+    }
+    if (msg.emoji) {
+      if (!msg.emojiSize) msg.emojiSize = "medium";
+      if (msg.emojiSize !== "small" && msg.emojiSize !== "medium" && msg.emojiSize !== "large") throw new Error("emojiSize property is invalid");
+      if (form.body && form.body !== "") throw new Error("body is not empty");
+      form.body = msg.emoji;
+      form["tags[0]"] = "hot_emoji_size:" + msg.emojiSize;
+    }
+    if (msg.mentions) {
+      for (let i = 0; i < msg.mentions.length; i++) {
+        const mention = msg.mentions[i];
+        const tag = mention.tag;
+        if (typeof tag !== "string") throw new Error("Mention tags must be strings.");
+        const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+        if (offset < 0) utils.warn("handleMention", 'Mention for "' + tag + '" not found in message string.');
+        const id = mention.id || 0;
+        const emptyChar = '\u200E';
+        form["body"] = emptyChar + msg.body;
+        form["profile_xmd[" + i + "][offset]"] = offset + 1;
+        form["profile_xmd[" + i + "][length]"] = tag.length;
+        form["profile_xmd[" + i + "][id]"] = id;
+        form["profile_xmd[" + i + "][type]"] = "p";
       }
+    }
+
+    if (utils.getType(threadID) === "Array") {
+      for (let i = 0; i < threadID.length; i++) form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
       form["specific_to_list[" + threadID.length + "]"] = "fbid:" + ctx.userID;
       form["client_thread_id"] = "root:" + messageAndOTID;
-      utils.log("sendMessage", "Sending message to multiple users: " + threadID);
     } else {
       if (isSingleUser) {
         form["specific_to_list[0]"] = "fbid:" + threadID;
@@ -110,7 +195,6 @@ module.exports = (defaultFuncs, api, ctx) => {
         form["thread_fbid"] = threadID;
       }
     }
-
     if (ctx.globalOptions.pageID) {
       form["author"] = "fbid:" + ctx.globalOptions.pageID;
       form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
@@ -131,14 +215,10 @@ module.exports = (defaultFuncs, api, ctx) => {
 
     if (!resData) throw new Error("Send message failed.");
     if (resData.error) {
-      if (resData.error === 1545012) {
-        utils.warn("sendMessage", "Got error 1545012. This might mean that you're not part of the conversation " + threadID);
-      }
-      // Check for suspension signals in error
+      if (resData.error === 1545012) utils.warn("sendMessage", "Got error 1545012. This might mean that you're not part of the conversation " + threadID);
       globalAntiSuspension.detectSuspensionSignal(String(resData.error) + ' ' + JSON.stringify(resData));
       throw new Error(JSON.stringify(resData));
     }
-
     const messageInfo = resData.payload.actions.reduce((p, v) => {
       return { threadID: v.thread_fbid, messageID: v.message_id, timestamp: v.timestamp } || p;
     }, null);
@@ -182,11 +262,11 @@ module.exports = (defaultFuncs, api, ctx) => {
       return callback(new Error("MessageID should be of type string and not " + threadIDType + "."));
     }
 
-    if (!ctx.validator.isValidMessage(msg)) {
+    if (ctx.validator && !ctx.validator.isValidMessage(msg)) {
       return callback(new Error("Invalid message content"));
     }
     const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
-    if (!ctx.validator.validateIDArray(threadIDs, ctx.validator.isValidThreadID)) {
+    if (ctx.validator && !ctx.validator.validateIDArray(threadIDs, ctx.validator.isValidThreadID)) {
       return callback(new Error("Invalid thread ID(s)"));
     }
 
@@ -198,122 +278,18 @@ module.exports = (defaultFuncs, api, ctx) => {
     }
 
     try {
-      let messageAndOTID = utils.generateOfflineThreadingID();
-      let form = {
-        client: "mercury",
-        action_type: "ma-type:user-generated-message",
-        author: "fbid:" + ctx.userID,
-        timestamp: Date.now(),
-        timestamp_absolute: "Today",
-        timestamp_relative: utils.generateTimestampRelative(),
-        timestamp_time_passed: "0",
-        is_unread: false,
-        is_cleared: false,
-        is_forward: false,
-        is_filtered_content: false,
-        is_filtered_content_bh: false,
-        is_filtered_content_account: false,
-        is_filtered_content_quasar: false,
-        is_filtered_content_invalid_app: false,
-        is_spoof_warning: false,
-        source: "source:chat:web",
-        "source_tags[0]": "source:chat",
-        ...(msg.body && { body: msg.body }),
-        html_body: false,
-        ui_push_phase: "V3",
-        status: "0",
-        offline_threading_id: messageAndOTID,
-        message_id: messageAndOTID,
-        threading_id: utils.generateThreadingID(ctx.clientID),
-        "ephemeral_ttl_mode:": "0",
-        manual_retry_cnt: "0",
-        has_attachment: !!(msg.attachment || msg.url || msg.sticker),
-        signatureID: utils.getSignatureID(),
-        ...(replyToMessage && { replied_to_message_id: replyToMessage })
-      };
-
-      if (msg.location) {
-        if (!msg.location.latitude || !msg.location.longitude) {
-          return callback(new Error("location property needs both latitude and longitude"));
-        }
-        form["location_attachment[coordinates][latitude]"] = msg.location.latitude;
-        form["location_attachment[coordinates][longitude]"] = msg.location.longitude;
-        form["location_attachment[is_current_location]"] = !!msg.location.current;
-      }
-      if (msg.sticker) form["sticker_id"] = msg.sticker;
-      if (msg.effect) {
-        const effectTag = String(msg.effect).toUpperCase().replace(/[\s\-]+/g, '_');
-        const messagingTag = 'fb.messaging.effects.' + effectTag;
-        form.has_lightweight_action = true;
-        form['lightweight_action_attached[message_id]']    = messageAndOTID;
-        form['lightweight_action_attached[messaging_tag]'] = messagingTag;
-      }
-      if (msg.attachment) {
-        form.image_ids = [];
-        form.gif_ids = [];
-        form.file_ids = [];
-        form.video_ids = [];
-        form.audio_ids = [];
-        if (utils.getType(msg.attachment) !== "Array") msg.attachment = [msg.attachment];
-        const files = await uploadAttachment(msg.attachment, threadID);
-        files.forEach(file => {
-          const type = Object.keys(file)[0];
-          form["" + type + "s"].push(file[type]);
-        });
-      }
-      if (msg.url) {
-        form["shareable_attachment[share_type]"] = "100";
-        const params = await getUrl(msg.url);
-        form["shareable_attachment[share_params]"] = params;
-      }
-      if (msg.emoji) {
-        if (!msg.emojiSize) msg.emojiSize = "medium";
-        if (msg.emojiSize !== "small" && msg.emojiSize !== "medium" && msg.emojiSize !== "large") {
-          return callback(new Error("emojiSize property is invalid"));
-        }
-        if (form.body && form.body !== "") return callback(new Error("body is not empty"));
-        form.body = msg.emoji;
-        form["tags[0]"] = "hot_emoji_size:" + msg.emojiSize;
-      }
-      if (msg.mentions) {
-        for (let i = 0; i < msg.mentions.length; i++) {
-          const mention = msg.mentions[i];
-          const tag = mention.tag;
-          if (typeof tag !== "string") return callback(new Error("Mention tags must be strings."));
-          const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
-          if (offset < 0) utils.warn("handleMention", 'Mention for "' + tag + '" not found in message string.');
-          if (!mention.id) utils.warn("handleMention", "Mention id should be non-null.");
-          const id = mention.id || 0;
-          const emptyChar = '\u200E';
-          form["body"] = emptyChar + msg.body;
-          form["profile_xmd[" + i + "][offset]"] = offset + 1;
-          form["profile_xmd[" + i + "][length]"] = tag.length;
-          form["profile_xmd[" + i + "][id]"] = id;
-          form["profile_xmd[" + i + "][type]"] = "p";
-        }
-      }
-
-      const isSingleUser = !(await isGroupThread(threadID, isGroup));
+      await globalAntiSuspension.prepareBeforeMessage(String(Array.isArray(threadID) ? threadID[0] : threadID), msg.body || '');
 
-      // ── Optimised anti-suspension send flow ───────────────────────────────
-      // Step 1: enforce thread throttle (single delay — no stacking).
-      await globalAntiSuspension.prepareBeforeMessage(threadID, msg.body || '');
-
-      // Step 2: start typing indicator BEFORE the typing delay so the delay
-      // is "hidden" inside the visible typing indicator — zero extra latency.
       let typingStarted = false;
       let typingTimeout;
-      const shouldSimulateTyping = ctx.globalOptions && ctx.globalOptions.simulateTyping && api.sendTypingIndicator;
+      const shouldSimulateTyping = ctx.globalOptions && ctx.globalOptions.simulateTyping && api.sendTypingIndicator && ctx.mqttClient && ctx.mqttClient.connected;
       if (shouldSimulateTyping) {
         try {
           await api.sendTypingIndicator(true, threadID);
           typingStarted = true;
-
-          // Typing delay runs while the indicator is already showing.
           const msgLen = (msg.body || '').length;
           const typingMs = await globalAntiSuspension.simulateTyping(threadID, msgLen);
           await new Promise(resolve => setTimeout(resolve, typingMs));
-
           typingTimeout = setTimeout(() => {
             if (typingStarted) {
               try { api.sendTypingIndicator(false, threadID); } catch (_) {}
@@ -323,21 +299,33 @@ module.exports = (defaultFuncs, api, ctx) => {
         } catch (_) {}
       }
 
-      // Step 3: send.
       try {
-        const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
+        let result;
+        const mqttReady = ctx.mqttClient && ctx.mqttClient.connected;
+        const isMultiRecipient = Array.isArray(threadID);
+
+        if (mqttReady && !isMultiRecipient && api.sendMessageMqtt) {
+          result = await api.sendMessageMqtt(msg, threadID, replyToMessage);
+        } else {
+          result = await sendViaHttp(msg, threadID, replyToMessage, isGroup);
+        }
         callback(null, result);
-      } catch (primaryErr) {
-        // Fallback to MQTT for group threads or when HTTP send fails.
-        if (api.sendMessageMqtt) {
+      } catch (sendErr) {
+        const mqttReady = ctx.mqttClient && ctx.mqttClient.connected;
+        if (mqttReady && !Array.isArray(threadID) && api.sendMessageMqtt) {
           try {
             const mqttRes = await api.sendMessageMqtt(msg, threadID, replyToMessage);
             callback(null, mqttRes);
-          } catch (fallbackErr) {
-            callback(primaryErr);
+          } catch (_mqttErr) {
+            callback(sendErr);
           }
         } else {
-          callback(primaryErr);
+          try {
+            const httpRes = await sendViaHttp(msg, threadID, replyToMessage, isGroup);
+            callback(null, httpRes);
+          } catch (_httpErr) {
+            callback(sendErr);
+          }
         }
       } finally {
         if (typingTimeout) clearTimeout(typingTimeout);

package/src/apis/sendMessageMqtt.js

@@ -16,240 +16,256 @@ module.exports = (defaultFuncs, api, ctx) => {
     return { file: "true" };
   }
 
-  async function uploadAttachment(attachments, callback) {
-    callback = callback || function () {};
-    var uploads = [];
-    try {
-      for (var i = 0; i < attachments.length; i++) {
-        if (!utils.isReadableStream(attachments[i])) {
-          throw { error: "Attachment should be a readable stream and not " + utils.getType(attachments[i]) + "." };
-        }
-        
-        if (i > 0) {
-          await globalAntiSuspension.addSmartDelay();
-        }
-        
-        var form = {
-          upload_1024: attachments[i],
-          ...detectAttachmentType(attachments[i]),
-        };
-        
-        const upload = await defaultFuncs
-          .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {}, { ...ctx, requestThreadID: String(ctx._lastThreadHint || "") })
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-          .then(resData => {
-            if (resData.error) throw resData;
-            return resData.payload.metadata[0];
-          });
-        
-        uploads.push(upload);
+  async function uploadAttachments(attachments) {
+    const uploads = [];
+    for (let i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw new Error("Attachment should be a readable stream and not " + utils.getType(attachments[i]) + ".");
       }
-      callback(null, uploads);
-    } catch (err) {
-      utils.error("uploadAttachment", err);
-      return callback(err);
+      if (i > 0) {
+        await globalAntiSuspension.addSmartDelay();
+      }
+      const form = {
+        upload_1024: attachments[i],
+        ...detectAttachmentType(attachments[i]),
+      };
+      const upload = await defaultFuncs
+        .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {}, { ...ctx, requestThreadID: String(ctx._lastThreadHint || "") })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(resData => {
+          if (resData.error) throw resData;
+          return resData.payload.metadata[0];
+        });
+      uploads.push(upload);
     }
+    return uploads;
   }
 
-  function getSendPayload(threadID, msg, otid) {
-    const isString = typeof msg === 'string';
-    const body = isString ? msg : msg.body || "";
-    otid = otid.toString() || utils.generateOfflineThreadingID().toString();
-    let payload = {
-      thread_id: threadID.toString(),
-      otid,
-      source: 0,
-      send_type: 1,
-      sync_group: 1,
-      text: body,
-      initiating_source: 1,
-      skip_url_preview_gen: 0,
-    };
-    if (typeof msg === 'object') {
-      if (msg.sticker) {
-        payload.send_type = 2;
-        payload.sticker_id = msg.sticker;
-        payload.text = null;
-      }
-      if (msg.attachment) {
-        payload.send_type = 3;
-        payload.attachment_fbids = Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment];
-      }
-      if (msg.effect) {
-        const effectTag = String(msg.effect).toUpperCase().replace(/[\s\-]+/g, '_');
-        payload.lightweight_action_attached = {
-          messaging_tag: 'fb.messaging.effects.' + effectTag,
-        };
+  function buildMentionData(msg, baseBody) {
+    if (!Array.isArray(msg.mentions) || msg.mentions.length === 0) return null;
+    const ids = [], offsets = [], lengths = [], types = [];
+    let cursor = 0;
+    for (const mention of msg.mentions) {
+      const rawTag = String(mention.tag || "");
+      const displayName = rawTag.replace(/^@+/, "");
+      const start = Number.isInteger(mention.fromIndex) ? mention.fromIndex : cursor;
+      let index = baseBody.indexOf(rawTag, start);
+      let adjustment = 0;
+      if (index === -1) {
+        index = baseBody.indexOf(displayName, start);
+      } else {
+        adjustment = rawTag.length - displayName.length;
       }
+      if (index < 0) { index = 0; adjustment = 0; }
+      const offset = index + adjustment;
+      ids.push(String(mention.id || 0));
+      offsets.push(offset);
+      lengths.push(displayName.length);
+      types.push("p");
+      cursor = offset + displayName.length;
     }
-    return payload;
+    return {
+      mention_ids: ids.join(","),
+      mention_offsets: offsets.join(","),
+      mention_lengths: lengths.join(","),
+      mention_types: types.join(","),
+    };
+  }
+
+  function hasLinks(text) {
+    return /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(text);
   }
 
   function extractIdsFromPayload(payload) {
     let messageID = null;
     let threadID = null;
     function walk(n) {
-      if (Array.isArray(n)) {
-        if (n[0] === 5 && (n[1] === "replaceOptimsiticMessage" || n[1] === "replaceOptimisticMessage")) {
-          messageID = String(n[3]);
-        }
-        if (n[0] === 5 && n[1] === "writeCTAIdToThreadsTable") {
-          const a = n[2];
-          if (Array.isArray(a) && a[0] === 19) threadID = String(a[1]);
-        }
-        for (const x of n) walk(x);
+      if (!Array.isArray(n)) return;
+      if (n[0] === 5 && (n[1] === "replaceOptimsiticMessage" || n[1] === "replaceOptimisticMessage")) {
+        messageID = String(n[3]);
+      }
+      if (n[0] === 5 && n[1] === "writeCTAIdToThreadsTable") {
+        const a = n[2];
+        if (Array.isArray(a) && a[0] === 19) threadID = String(a[1]);
       }
+      for (const x of n) walk(x);
     }
     walk(payload?.step);
     return { threadID, messageID };
   }
 
-  function publishWithAck(content, reqID, callback) {
+  function publishWithAck(content, reqID) {
     return new Promise((resolve, reject) => {
       if (!ctx.mqttClient || typeof ctx.mqttClient.on !== "function" || typeof ctx.mqttClient.publish !== "function") {
-        const err = new Error("MQTT client is not initialized");
-        utils.error("sendMessageMqtt", err);
-        callback && callback(err);
-        return reject(err);
+        return reject(new Error("MQTT client is not initialized"));
       }
-
       if (typeof ctx.mqttClient.setMaxListeners === "function") {
         ctx.mqttClient.setMaxListeners(0);
       }
-
-      let done = false;
+      let settled = false;
+      let timer;
       const cleanup = () => {
-        if (done) return;
-        done = true;
-        ctx.mqttClient.removeListener("message", handleRes);
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        ctx.mqttClient.removeListener("message", onMessage);
       };
-      const handleRes = (topic, message) => {
+      const onMessage = (topic, message) => {
         if (topic !== "/ls_resp") return;
-        let jsonMsg;
+        let parsed;
         try {
-          jsonMsg = JSON.parse(message.toString());
-          jsonMsg.payload = JSON.parse(jsonMsg.payload);
-        } catch {
-          return;
-        }
-        if (jsonMsg.request_id !== reqID) return;
-        const { threadID, messageID } = extractIdsFromPayload(jsonMsg.payload);
-        const result = { messageID, threadID };
+          parsed = JSON.parse(message.toString());
+          if (typeof parsed.payload === "string") parsed.payload = JSON.parse(parsed.payload);
+        } catch { return; }
+        if (parsed.request_id !== reqID) return;
+        const { threadID, messageID } = extractIdsFromPayload(parsed.payload);
         cleanup();
-        callback && callback(undefined, result);
-        resolve(result);
+        resolve({ messageID, threadID });
       };
-      ctx.mqttClient.on("message", handleRes);
-      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, err => {
-        if (err) {
-          cleanup();
-          callback && callback(err);
-          reject(err);
-        }
+      ctx.mqttClient.on("message", onMessage);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+        if (err) { cleanup(); reject(err); }
       });
-      setTimeout(() => {
-        if (done) return;
+      timer = setTimeout(() => {
+        if (settled) return;
         cleanup();
-        const err = { error: "Timeout waiting for ACK" };
-        callback && callback(err);
-        reject(err);
+        reject({ error: "Timeout waiting for ACK" });
       }, 15000);
     });
   }
 
   return async (msg, threadID, replyToMessage, callback) => {
-    if (typeof msg !== 'string' && typeof msg !== 'object') {
+    if (typeof msg !== "string" && typeof msg !== "object") {
       throw new Error("Message should be of type string or object, not " + utils.getType(msg) + ".");
     }
-
-    if (typeof threadID !== 'string' && typeof threadID !== 'number') {
+    if (typeof threadID !== "string" && typeof threadID !== "number") {
       throw new Error("threadID must be a string or number.");
     }
-
-    if (!callback && typeof threadID === "function") {
-      throw new Error("Pass a threadID as a second argument.");
-    }
-
     if (!callback && typeof replyToMessage === "function") {
       callback = replyToMessage;
       replyToMessage = null;
     }
 
-    // Apply anti-suspension throttling and volume checks before every MQTT send
     try {
-      await globalAntiSuspension.prepareBeforeMessage(String(threadID), typeof msg === 'string' ? msg : (msg.body || ''));
-    } catch (suspErr) {
-      utils.warn("sendMessageMqtt", "Anti-suspension check raised:", suspErr && suspErr.message ? suspErr.message : suspErr);
-    }
+      await globalAntiSuspension.prepareBeforeMessage(String(threadID), typeof msg === "string" ? msg : (msg.body || ""));
+    } catch (_) {}
 
-    const timestamp = Date.now();
+    const normalized = typeof msg === "string" ? { body: msg } : msg;
+    const baseBody = normalized.body != null ? String(normalized.body) : "";
+    const epoch = (BigInt(Date.now()) << 22n).toString();
+    const requestId = Math.floor(100 + Math.random() * 900);
     const otid = utils.generateOfflineThreadingID();
-    const epoch_id = utils.generateOfflineThreadingID();
-    const payload = getSendPayload(threadID, msg, otid);
-
-    const tasks = [{
-      label: "46",
-      payload,
-      queue_name: threadID.toString(),
-      task_id: 0,
-      failure_count: null,
-    }, {
-      label: "21",
-      payload: {
-        thread_id: threadID.toString(),
-        last_read_watermark_ts: timestamp,
-        sync_group: 1,
-      },
-      queue_name: threadID.toString(),
-      task_id: 1,
-      failure_count: null,
-    }];
-
-    if (replyToMessage) {
-      tasks[0].payload.reply_metadata = {
-        reply_source_id: replyToMessage,
+
+    const payload0 = {
+      thread_id: String(threadID),
+      otid: otid.toString(),
+      source: 2097153,
+      send_type: 1,
+      sync_group: 1,
+      mark_thread_read: 1,
+      text: baseBody === "" ? null : baseBody,
+      initiating_source: 0,
+      skip_url_preview_gen: 0,
+      text_has_links: hasLinks(baseBody) ? 1 : 0,
+      multitab_env: 0,
+      metadata_dataclass: JSON.stringify({ media_accessibility_metadata: { alt_text: null } }),
+    };
+
+    if (normalized.mentions && Array.isArray(normalized.mentions) && normalized.mentions.length > 0) {
+      const mentionData = buildMentionData(normalized, baseBody);
+      if (mentionData) payload0.mention_data = mentionData;
+    }
+
+    if (normalized.sticker) {
+      payload0.send_type = 2;
+      payload0.sticker_id = normalized.sticker;
+      payload0.text = null;
+    }
+
+    if (normalized.emoji) {
+      payload0.send_type = 1;
+      payload0.text = normalized.emoji;
+      const sizeMap = { small: 1, medium: 2, large: 3 };
+      const emojiSize = normalized.emojiSize;
+      payload0.hot_emoji_size = (typeof emojiSize === "number" ? Math.min(3, Math.max(1, emojiSize)) : sizeMap[emojiSize]) || 1;
+    }
+
+    if (normalized.location && normalized.location.latitude != null && normalized.location.longitude != null) {
+      payload0.send_type = 1;
+      payload0.location_data = {
+        coordinates: { latitude: normalized.location.latitude, longitude: normalized.location.longitude },
+        is_current_location: Boolean(normalized.location.current),
+        is_live_location: Boolean(normalized.location.live),
+      };
+    }
+
+    if (normalized.effect) {
+      const effectTag = String(normalized.effect).toUpperCase().replace(/[\s\-]+/g, "_");
+      payload0.lightweight_action_attached = {
+        message_id: otid.toString(),
+        messaging_tag: "fb.messaging.effects." + effectTag,
+      };
+    }
+
+    if (replyToMessage || normalized.replyToMessage) {
+      const replyId = replyToMessage || normalized.replyToMessage;
+      payload0.reply_metadata = {
+        reply_source_id: replyId,
         reply_source_type: 1,
         reply_type: 0,
       };
     }
 
-    const request_id = ++ctx.wsReqNumber;
-    const form = {
+    if (normalized.attachment) {
+      payload0.send_type = 3;
+      if (payload0.text === "") payload0.text = null;
+      const list = Array.isArray(normalized.attachment) ? normalized.attachment : [normalized.attachment];
+      ctx._lastThreadHint = threadID;
+      const files = await uploadAttachments(list.filter(a => utils.isReadableStream(a)));
+      payload0.attachment_fbids = files.map(f => String(Object.values(f)[0]));
+    }
+
+    const content = {
       app_id: "2220391788200892",
       payload: {
-        tasks,
-        epoch_id,
-        version_id: "6120284488008082",
-        data_trace_id: null,
+        tasks: [
+          {
+            label: "46",
+            payload: payload0,
+            queue_name: String(threadID),
+            task_id: 400,
+            failure_count: null,
+          },
+          {
+            label: "21",
+            payload: {
+              thread_id: String(threadID),
+              last_read_watermark_ts: Date.now(),
+              sync_group: 1,
+            },
+            queue_name: String(threadID),
+            task_id: 401,
+            failure_count: null,
+          },
+        ],
+        epoch_id: epoch,
+        version_id: "24804310205905615",
+        data_trace_id: `#${Buffer.from(String(Math.random())).toString("base64").replace(/=+$/g, "")}`,
       },
-      request_id,
+      request_id: requestId,
       type: 3,
     };
 
-    if (msg.attachment) {
-      try {
-        ctx._lastThreadHint = threadID;
-        const files = await new Promise((resolve, reject) => {
-          uploadAttachment(
-            Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment],
-            (err, files) => {
-              if (err) return reject(err);
-              return resolve(files);
-            }
-          );
-        });
-        form.payload.tasks[0].payload.attachment_fbids = files.map(file => Object.values(file)[0]);
-      } catch (err) {
-        utils.error("Attachment upload failed:", err);
-        throw err;
-      }
-    }
+    content.payload.tasks = content.payload.tasks.map(t => ({ ...t, payload: JSON.stringify(t.payload) }));
+    content.payload = JSON.stringify(content.payload);
 
-    form.payload.tasks.forEach(task => {
-      task.payload = JSON.stringify(task.payload);
-    });
-    form.payload = JSON.stringify(form.payload);
-    
-    return publishWithAck(form, request_id, callback);
+    try {
+      const result = await publishWithAck(content, requestId);
+      if (callback) callback(undefined, result);
+      return result;
+    } catch (err) {
+      if (callback) callback(err);
+      throw err;
+    }
   };
 };

package/src/apis/sendTypingIndicator.js

@@ -2,39 +2,73 @@
 
 const utils = require('../utils');
 
-/**
- * @param {Object} defaultFuncs
- * @param {Object} api
- * @param {Object} ctx
- */
 module.exports = function (defaultFuncs, api, ctx) {
-	/**
-	 * Sends a typing indicator to a specific thread.
-	 * @param {boolean} sendTyping - True to show typing indicator, false to hide.
-	 * @param {string} threadID - The ID of the thread to send the typing indicator to.
-	 * @param {Function} [callback] - An optional callback function.
-	 * @returns {Promise<void>}
-	 */
-	return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
-		let count_req = 0;
-		const wsContent = {
-			app_id: 2220391788200892,
-			payload: JSON.stringify({
-				label: 3,
-				payload: JSON.stringify({
-					thread_key: threadID.toString(),
-					is_group_thread: +(threadID.toString().length >= 16),
-					is_typing: +sendTyping,
-					attribution: 0
-				}),
-				version: 5849951561777440
-			}),
-			request_id: ++count_req,
-			type: 4
-		};
-		await new Promise((resolve, reject) => ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => err ? reject(err) : resolve()));
-		if (callback) {
-			callback();
-		}
-	};
+  return function sendTypingIndicator(sendTyping, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(true);
+      };
+    }
+
+    if (!ctx.mqttClient || typeof ctx.mqttClient.publish !== "function") {
+      const err = new Error("You can only use sendTypingIndicator after you start listening.");
+      callback(err);
+      return returnPromise;
+    }
+
+    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
+    if (!threadIDs.length) {
+      const err = new Error("threadID is required");
+      callback(err);
+      return returnPromise;
+    }
+
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+
+    function buildPayload(tid) {
+      const isGroup = String(tid).length >= 16 ? 1 : 0;
+      return {
+        app_id: "772021112871879",
+        payload: JSON.stringify({
+          label: "3",
+          payload: JSON.stringify({
+            thread_key: Number.parseInt(String(tid), 10),
+            is_group_thread: isGroup,
+            is_typing: sendTyping ? 1 : 0,
+            attribution: 0,
+            sync_group: 1,
+            thread_type: isGroup ? 2 : 1,
+          }),
+          version: "8965252033599983",
+        }),
+        request_id: ++ctx.wsReqNumber,
+        type: 4,
+      };
+    }
+
+    const publishes = threadIDs.map(tid =>
+      new Promise((resolve, reject) => {
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(buildPayload(tid)), { qos: 1 }, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      })
+    );
+
+    Promise.all(publishes)
+      .then(() => callback(null, true))
+      .catch(err => {
+        utils.error("sendTypingIndicator", err);
+        callback(err);
+      });
+
+    return returnPromise;
+  };
 };