@lazyneoaz/nkxchat 1.0.3 → 1.0.4

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