shadowx-fca 2.5.0 → 2.7.0

package/src/sendMessage.js

@@ -1,7 +1,10 @@
 "use strict";
-
+// shadowx-fca — sendMessage (MQTT Version)
+// Supports: BOTH DM/E2EE Inbox AND Group Threads
+// Supports: Both callback style and Promise/await style
 
 const utils = require('../utils');
+const log = require('npmlog');
 
 const allowedProperties = {
   attachment : true,
@@ -14,10 +17,18 @@ const allowedProperties = {
   location   : true,
 };
 
-
-
 module.exports = (defaultFuncs, api, ctx) => {
 
+  let variance = 0;
+  const epoch_id = () => Math.floor(Date.now() * (4194304 + (variance = (variance + 0.1) % 5)));
+  
+  const emojiSizes = {
+    small: 1,
+    medium: 2,
+    large: 3,
+  };
+
+  // Upload attachments
   async function uploadAttachment(attachments) {
     const uploads = [];
     for (const att of attachments) {
@@ -30,45 +41,54 @@ module.exports = (defaultFuncs, api, ctx) => {
         { upload_1024: att, voice_clip: "true" },
         {}
       ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      
       if (res.error) throw new Error("Upload failed: " + JSON.stringify(res));
       uploads.push(res.payload.metadata[0]);
     }
     return uploads;
   }
 
+  // Get URL share params
   async function getUrl(url) {
     const res = 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 (!res || res.error || !res.payload) throw new Error("URL attachment failed: " + JSON.stringify(res));
-    return res.payload;
+    
+    if (!res || res.error || !res.payload) {
+      throw new Error("URL attachment failed: " + JSON.stringify(res));
+    }
+    return res.payload.share_data.share_params;
   }
 
-  async function sendContent(form, threadID, messageAndOTID) {
+  // Send via HTTP Mercury (Fallback for Groups only)
+  async function sendHttp(form, threadID, messageAndOTID, isSingleUser) {
     const tid = String(threadID);
 
     if (Array.isArray(threadID)) {
       threadID.forEach((id, idx) => { form[`specific_to_list[${idx}]`] = "fbid:" + id; });
       form[`specific_to_list[${threadID.length}]`] = "fbid:" + ctx.userID;
       form["client_thread_id"] = "root:" + messageAndOTID;
-      utils.log("sendMessage", "Creating new group with users: " + threadID.join(', '));
     } else {
-      // Group thread — works for any digit length (15, 16, 17, 18, 19...)
-      form["thread_fbid"] = tid;
-      utils.log("sendMessage", "Sending to group thread: " + tid);
+      if (isSingleUser) {
+        form["specific_to_list[0]"] = "fbid:" + threadID;
+        form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+        form["other_user_fbid"] = threadID;
+      } else {
+        form["thread_fbid"] = tid;
+      }
     }
 
     if (ctx.globalOptions.pageID) {
-      form["author"]                         = "fbid:" + ctx.globalOptions.pageID;
-      form["specific_to_list[1]"]            = "fbid:" + ctx.globalOptions.pageID;
-      form["creator_info[creatorID]"]        = ctx.userID;
-      form["creator_info[creatorType]"]      = "direct_admin";
-      form["creator_info[labelType]"]        = "sent_message";
-      form["creator_info[pageID]"]           = ctx.globalOptions.pageID;
-      form["request_user_id"]               = ctx.globalOptions.pageID;
-      form["creator_info[profileURI]"]       = "https://www.facebook.com/profile.php?id=" + ctx.userID;
+      form["author"] = "fbid:" + ctx.globalOptions.pageID;
+      form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
+      form["creator_info[creatorID]"] = ctx.userID;
+      form["creator_info[creatorType]"] = "direct_admin";
+      form["creator_info[labelType]"] = "sent_message";
+      form["creator_info[pageID]"] = ctx.globalOptions.pageID;
+      form["request_user_id"] = ctx.globalOptions.pageID;
+      form["creator_info[profileURI]"] = "https://www.facebook.com/profile.php?id=" + ctx.userID;
     }
 
     const resData = await defaultFuncs
@@ -78,49 +98,145 @@ module.exports = (defaultFuncs, api, ctx) => {
     if (!resData) throw new Error("Send message failed — no response.");
     if (resData.error) {
       if (resData.error === 1545012) {
-        utils.warn("sendMessage", "Error 1545012: You may not be a member of thread " + tid);
+        throw new Error(`Cannot send message to thread ${tid}: Bot is not part of this conversation`);
       }
       throw new Error("Send message error: " + JSON.stringify(resData));
     }
 
     return resData.payload.actions.reduce((p, v) => ({
-      threadID  : v.thread_fbid,
-      messageID : v.message_id,
-      timestamp : v.timestamp,
+      threadID: v.thread_fbid,
+      messageID: v.message_id,
+      timestamp: v.timestamp,
     }), null);
   }
 
-  /**
-   * Send a message to a Facebook group thread.
-   *
-   * Supports both callback and Promise/await style:
-   *
-   *   api.sendMessage("Hello!", threadID, callback)          // callback style
-   *   await api.sendMessage("Hello!", threadID)              // promise style
-   *   api.sendMessage("Reply!", threadID, msgID, callback)   // reply + callback
-   *   await api.sendMessage("Reply!", threadID, msgID)       // reply + promise
-   *
-   * @param {string|object}   msg              — text string or {body, sticker, attachment, url, emoji, mentions, location}
-   * @param {string|Array}    threadID         — group thread ID (any length) or array of userIDs to create new group
-   * @param {string|Function} [replyOrCallback]— optional: message ID to reply to, OR callback function(err, info)
-   * @param {Function}        [callback]       — optional: callback(err, info) when replyToMessage is provided
-   */
-  return (msg, threadID, replyOrCallback, callbackArg) => {
-
-    // ── Resolve replyToMessage vs callback ───────────────────────
+  // Send via MQTT (Works for BOTH DM and Group!)
+  function sendMqtt(payload, threadID, replyToMessage, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        return reject(new Error('Not connected to MQTT. Call listenMqtt first.'));
+      }
+
+      const timestamp = Date.now();
+      const epoch = timestamp << 22;
+      const otid = epoch + Math.floor(Math.random() * 4194304);
+
+      const tasks = [
+        {
+          label: "46",
+          payload: {
+            thread_id: String(threadID),
+            otid: String(otid),
+            source: 0,
+            send_type: 1,
+            sync_group: 1,
+            text: payload.text || "",
+            initiating_source: 1,
+            skip_url_preview_gen: 0
+          },
+          queue_name: String(threadID),
+          task_id: 0,
+          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: 1,
+          failure_count: null
+        }
+      ];
+
+      // Add reply metadata if replying
+      if (replyToMessage) {
+        tasks[0].payload.reply_metadata = {
+          reply_source_id: String(replyToMessage),
+          reply_source_type: 1,
+          reply_type: 0
+        };
+      }
+
+      // Add emoji size if present
+      if (payload.hot_emoji_size) {
+        tasks[0].payload.hot_emoji_size = payload.hot_emoji_size;
+      }
+
+      // Add sticker if present
+      if (payload.sticker_id) {
+        tasks[0].payload.send_type = 2;
+        tasks[0].payload.sticker_id = payload.sticker_id;
+      }
+
+      // Add attachments if present
+      if (payload.attachment_fbids && payload.attachment_fbids.length > 0) {
+        tasks[0].payload.send_type = 3;
+        tasks[0].payload.attachment_fbids = payload.attachment_fbids;
+      }
+
+      // Add mentions if present
+      if (payload.mention_data) {
+        tasks[0].payload.mention_data = payload.mention_data;
+      }
+
+      // Add location if present
+      if (payload.location_data) {
+        tasks[0].payload.location_data = payload.location_data;
+      }
+
+      const mqttForm = {
+        app_id: ctx.appID || "2220391788200892",
+        payload: {
+          tasks: tasks,
+          epoch_id: epoch_id(),
+          version_id: "6120284488008082",
+          data_trace_id: null
+        },
+        request_id: 1,
+        type: 3
+      };
+
+      // Stringify all task payloads
+      mqttForm.payload.tasks.forEach(task => {
+        task.payload = JSON.stringify(task.payload);
+      });
+      mqttForm.payload = JSON.stringify(mqttForm.payload);
+
+      log.info("sendMessage", `Sending via MQTT to ${threadID}`);
+
+      ctx.mqttClient.publish('/ls_req', JSON.stringify(mqttForm), { qos: 1, retain: false }, (err) => {
+        if (err) {
+          log.error("sendMessage", `MQTT publish failed: ${err.message || err}`);
+          reject(new Error(`MQTT publish failed: ${err.message || err}`));
+        } else {
+          const result = {
+            threadID: String(threadID),
+            messageID: String(otid),
+            timestamp: timestamp
+          };
+          if (callback) callback(null, result);
+          resolve(result);
+        }
+      });
+    });
+  }
+
+  // Main send function
+  return async function sendMessage(msg, threadID, replyOrCallback, callbackArg) {
     let replyToMessage = null;
-    let callback       = null;
+    let callback = null;
 
+    // Parse arguments
     if (typeof replyOrCallback === 'function') {
-      // sendMessage(msg, threadID, callback)
       callback = replyOrCallback;
-    } else if (typeof replyOrCallback === 'string') {
-      // sendMessage(msg, threadID, replyMsgID)  or  sendMessage(msg, threadID, replyMsgID, callback)
-      replyToMessage = replyOrCallback;
+    } else if (typeof replyOrCallback === 'string' || typeof replyOrCallback === 'number') {
+      replyToMessage = String(replyOrCallback);
       if (typeof callbackArg === 'function') callback = callbackArg;
     }
 
-    // ── Core send logic (async) ──────────────────────────────────
     const doSend = async () => {
       const msgType = utils.getType(msg);
       if (msgType !== "String" && msgType !== "Object") {
@@ -133,100 +249,159 @@ module.exports = (defaultFuncs, api, ctx) => {
         throw new Error("Disallowed message properties: " + disallowed.join(", "));
       }
 
-      const messageAndOTID = utils.generateOfflineThreadingID();
-      const 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 }),
+      // Detect if DM or Group
+      const threadIDStr = String(threadID);
+      const isSingleUser = !Array.isArray(threadID) && 
+        (threadIDStr.length === 15 || !threadIDStr.match(/^\d{16,}$/));
+
+      // Build MQTT payload
+      const mqttPayload = {
+        text: msg.body || ""
       };
 
+      // Handle mentions
+      if (msg.mentions && msg.mentions.length > 0) {
+        const arrayIds = [];
+        const arrayOffsets = [];
+        const arrayLengths = [];
+        const mention_types = [];
+
+        for (const mention of msg.mentions) {
+          const { tag, id, fromIndex } = mention;
+          if (typeof tag !== "string") throw new Error("Mention tags must be strings.");
+          
+          const offset = msg.body.indexOf(tag, fromIndex || 0);
+          if (offset < 0) log.warn("sendMessage", `Mention "${tag}" not found in body.`);
+          
+          arrayIds.push(id || 0);
+          arrayOffsets.push(offset);
+          arrayLengths.push(tag.length);
+          mention_types.push("p");
+        }
+
+        mqttPayload.mention_data = {
+          mention_ids: arrayIds.join(","),
+          mention_offsets: arrayOffsets.join(","),
+          mention_lengths: arrayLengths.join(","),
+          mention_types: mention_types.join(",")
+        };
+      }
+
+      // Handle emoji
+      if (msg.emoji) {
+        let emojiSize = msg.emojiSize || "medium";
+        if (!["small", "medium", "large"].includes(emojiSize)) {
+          throw new Error("emojiSize must be small, medium, or large.");
+        }
+        mqttPayload.text = msg.emoji;
+        mqttPayload.hot_emoji_size = emojiSizes[emojiSize];
+      }
+
+      // Handle sticker
+      if (msg.sticker) {
+        mqttPayload.sticker_id = String(msg.sticker);
+      }
+
+      // Handle location
       if (msg.location) {
         if (!msg.location.latitude || !msg.location.longitude) {
           throw new Error("location 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;
+        mqttPayload.location_data = {
+          coordinates: {
+            latitude: msg.location.latitude,
+            longitude: msg.location.longitude
+          },
+          is_current_location: !!msg.location.current,
+          is_live_location: !!msg.location.live
+        };
       }
 
-      if (msg.sticker) form["sticker_id"] = msg.sticker;
-
+      // Handle attachments
       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];
+        if (utils.getType(msg.attachment) !== "Array") {
+          msg.attachment = [msg.attachment];
+        }
         const files = await uploadAttachment(msg.attachment);
-        files.forEach(file => {
-          const type = Object.keys(file)[0];
-          form[type + "s"].push(file[type]);
+        mqttPayload.attachment_fbids = files.map(file => {
+          const key = Object.keys(file)[0];
+          return file[key];
         });
       }
 
+      // Handle URL
       if (msg.url) {
-        form["shareable_attachment[share_type]"]   = "100";
-        form["shareable_attachment[share_params]"] = await getUrl(msg.url);
-      }
-
-      if (msg.emoji) {
-        if (!msg.emojiSize) msg.emojiSize = "medium";
-        if (!["small","medium","large"].includes(msg.emojiSize)) {
-          throw new Error("emojiSize must be small, medium, or large.");
+        try {
+          const params = await getUrl(msg.url);
+          // For MQTT, we just append URL to text
+          mqttPayload.text = mqttPayload.text ? mqttPayload.text + " " + msg.url : msg.url;
+        } catch (err) {
+          log.warn("sendMessage", "URL attachment failed, sending as text link");
+          mqttPayload.text = mqttPayload.text ? mqttPayload.text + " " + msg.url : msg.url;
         }
-        if (!form.body) throw new Error("body must not be empty when using emoji.");
-        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 { tag, id, fromIndex } = msg.mentions[i];
-          if (typeof tag !== "string") throw new Error("Mention tags must be strings.");
-          const offset = msg.body.indexOf(tag, fromIndex || 0);
-          if (offset < 0) utils.warn("sendMessage", `Mention "${tag}" not found in body.`);
-          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 || 0;
-          form[`profile_xmd[${i}][type]`]          = "p";
+      // Try MQTT first (works for both DM and Group)
+      try {
+        return await sendMqtt(mqttPayload, threadID, replyToMessage, callback);
+      } catch (mqttErr) {
+        log.warn("sendMessage", "MQTT send failed: " + mqttErr.message);
+        
+        // Fallback to HTTP for groups only
+        if (!isSingleUser && !Array.isArray(threadID)) {
+          log.info("sendMessage", "Falling back to HTTP for group message");
+          
+          const messageAndOTID = utils.generateOfflineThreadingID();
+          const httpForm = {
+            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",
+            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.sticker) httpForm["sticker_id"] = msg.sticker;
+          
+          return await sendHttp(httpForm, threadID, messageAndOTID, isSingleUser);
+        } else {
+          throw new Error("DM/E2EE messages require MQTT. Make sure listenMqtt is called first.");
         }
       }
-
-      return sendContent(form, threadID, messageAndOTID);
     };
 
-    // ── Return Promise OR call callback ──────────────────────────
+    // Execute and handle callback/promise
     if (callback) {
-      doSend().then(info => callback(null, info)).catch(err => callback(err));
+      doSend()
+        .then(info => callback(null, info))
+        .catch(err => callback(err));
+      return undefined;
     } else {
       return doSend();
     }
   };
-};
+};