@dongdev/fca-unofficial 2.0.6 → 2.0.8

package/src/api/messaging/uploadAttachment.js

@@ -1,6 +1,8 @@
-const utils = require("../../utils");
+"use strict";
 const log = require("npmlog");
-
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+const { isReadableStream } = require("../../utils/constants");
 module.exports = function(defaultFuncs, api, ctx) {
   function upload(attachments, callback) {
     callback = callback || function() {};
@@ -8,11 +10,11 @@ module.exports = function(defaultFuncs, api, ctx) {
 
     // create an array of promises
     for (let i = 0; i < attachments.length; i++) {
-      if (!utils.isReadableStream(attachments[i])) {
+      if (!isReadableStream(attachments[i])) {
         throw {
           error:
             "Attachment should be a readable stream and not " +
-            utils.getType(attachments[i]) +
+            getType(attachments[i]) +
             "."
         };
       }
@@ -30,7 +32,7 @@ module.exports = function(defaultFuncs, api, ctx) {
             form,
             {}
           )
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(parseAndCheckLogin(ctx, defaultFuncs))
           .then(function(resData) {
             if (resData.error) {
               throw resData;
@@ -57,9 +59,9 @@ module.exports = function(defaultFuncs, api, ctx) {
   return function uploadAttachment(attachments, callback) {
     if (
       !attachments &&
-      !utils.isReadableStream(attachments) &&
-      !utils.getType(attachments) === "Array" &&
-      utils.getType(attachments) === "Array" && !attachments.length
+      !isReadableStream(attachments) &&
+      !getType(attachments) === "Array" &&
+      getType(attachments) === "Array" && !attachments.length
     )
       throw { error: "Please pass an attachment or an array of attachments." };
 
@@ -79,7 +81,7 @@ module.exports = function(defaultFuncs, api, ctx) {
       };
     }
 
-    if (utils.getType(attachments) !== "Array") attachments = [attachments];
+    if (getType(attachments) !== "Array") attachments = [attachments];
 
     upload(attachments, (err, info) => {
       if (err) {

package/src/api/socket/core/connectMqtt.js

@@ -0,0 +1,180 @@
+"use strict";
+const { formatID } = require("../../../utils/format");
+module.exports = function createListenMqtt(deps) {
+  const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData, logger } = deps;
+  return function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
+    const chatOn = ctx.globalOptions.online;
+    const foreground = false;
+    const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+    const username = {
+      u: ctx.userID,
+      s: sessionID,
+      chat_on: chatOn,
+      fg: foreground,
+      d: ctx.clientId,
+      ct: "websocket",
+      aid: 219994525426954,
+      aids: null,
+      mqtt_sid: "",
+      cp: 3,
+      ecp: 10,
+      st: [],
+      pm: [],
+      dc: "",
+      no_auto_fg: true,
+      gas: null,
+      pack: [],
+      p: null,
+      php_override: ""
+    };
+    const cookies = api.getCookies();
+    let host;
+    if (ctx.mqttEndpoint) {
+      host = `${ctx.mqttEndpoint}&sid=${sessionID}&cid=${ctx.clientId}`;
+    } else if (ctx.region) {
+      host = `wss://edge-chat.facebook.com/chat?region=${ctx.region.toLowerCase()}&sid=${sessionID}&cid=${ctx.clientId}`;
+    } else {
+      host = `wss://edge-chat.facebook.com/chat?sid=${sessionID}&cid=${ctx.clientId}`;
+    }
+    const options = {
+      clientId: "mqttwsclient",
+      protocolId: "MQIsdp",
+      protocolVersion: 3,
+      username: JSON.stringify(username),
+      clean: true,
+      wsOptions: {
+        headers: {
+          Cookie: cookies,
+          Origin: "https://www.facebook.com",
+          "User-Agent": ctx.globalOptions.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+          Referer: "https://www.facebook.com/",
+          Host: "edge-chat.facebook.com",
+          Connection: "Upgrade",
+          Pragma: "no-cache",
+          "Cache-Control": "no-cache",
+          Upgrade: "websocket",
+          "Sec-WebSocket-Version": "13",
+          "Accept-Encoding": "gzip, deflate, br",
+          "Accept-Language": "vi,en;q=0.9",
+          "Sec-WebSocket-Extensions": "permessage-deflate; client_max_window_bits"
+        },
+        origin: "https://www.facebook.com",
+        protocolVersion: 13,
+        binaryType: "arraybuffer"
+      },
+      keepalive: 30,
+      reschedulePings: true,
+      reconnectPeriod: 1000,
+      connectTimeout: 5000
+    };
+    if (ctx.globalOptions.proxy !== undefined) {
+      const agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+      options.wsOptions.agent = agent;
+    }
+    ctx.mqttClient = new mqtt.Client(() => buildStream(options, new WebSocket(host, options.wsOptions), buildProxy()), options);
+    const mqttClient = ctx.mqttClient;
+    global.mqttClient = mqttClient;
+    mqttClient.on("error", function (err) {
+      logger("listenMqtt" + err, "error");
+      mqttClient.end();
+      if (ctx.globalOptions.autoReconnect) {
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      } else {
+        // utils.checkLiveCookie(ctx, defaultFuncs).then(res => {
+        //   globalCallback({ type: "stop_listen", error: "Connection refused: Server unavailable" }, null);
+        // }).catch(err => {
+        //   globalCallback({ type: "account_inactive", error: "Maybe your account is blocked by facebook, please login and check at https://facebook.com" }, null);
+        // });
+      }
+    });
+    mqttClient.on("connect", function () {
+      if (process.env.OnStatus === undefined) {
+        logger("fca-unoffcial premium", "info");
+        process.env.OnStatus = true;
+      }
+      topics.forEach(topicsub => mqttClient.subscribe(topicsub));
+      let topic;
+      const queue = { sync_api_version: 11, max_deltas_able_to_process: 100, delta_batch_size: 500, encoding: "JSON", entity_fbid: ctx.userID, initial_titan_sequence_id: ctx.lastSeqId, device_params: null };
+      if (ctx.syncToken) {
+        topic = "/messenger_sync_get_diffs";
+        queue.last_seq_id = ctx.lastSeqId;
+        queue.sync_token = ctx.syncToken;
+      } else {
+        topic = "/messenger_sync_create_queue";
+        queue.initial_titan_sequence_id = ctx.lastSeqId;
+        queue.device_params = null;
+      }
+      mqttClient.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
+      mqttClient.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
+      mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
+      const rTimeout = setTimeout(function () {
+        mqttClient.end();
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      }, 5000);
+      ctx.tmsWait = function () {
+        clearTimeout(rTimeout);
+        ctx.globalOptions.emitReady ? globalCallback({ type: "ready", error: null }) : "";
+        delete ctx.tmsWait;
+      };
+    });
+    mqttClient.on("message", function (topic, message, _packet) {
+      try {
+        let jsonMessage = Buffer.isBuffer(message) ? Buffer.from(message).toString() : message;
+        try {
+          jsonMessage = JSON.parse(jsonMessage);
+        } catch (e) {
+          jsonMessage = {};
+        }
+        if (jsonMessage.type === "jewel_requests_add") {
+          globalCallback(null, { type: "friend_request_received", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
+        } else if (jsonMessage.type === "jewel_requests_remove_old") {
+          globalCallback(null, { type: "friend_request_cancel", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
+        } else if (topic === "/t_ms") {
+          if (ctx.tmsWait && typeof ctx.tmsWait == "function") {
+            ctx.tmsWait();
+          }
+          if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) {
+            ctx.lastSeqId = jsonMessage.firstDeltaSeqId;
+            ctx.syncToken = jsonMessage.syncToken;
+          }
+          if (jsonMessage.lastIssuedSeqId) {
+            ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+          }
+          for (const i in jsonMessage.deltas) {
+            const delta = jsonMessage.deltas[i];
+            parseDelta(defaultFuncs, api, ctx, globalCallback, { delta });
+          }
+        } else if (topic === "/thread_typing" || topic === "/orca_typing_notifications") {
+          const typ = { type: "typ", isTyping: !!jsonMessage.state, from: jsonMessage.sender_fbid.toString(), threadID: formatID((jsonMessage.thread || jsonMessage.sender_fbid).toString()) };
+          globalCallback(null, typ);
+        } else if (topic === "/orca_presence") {
+          if (!ctx.globalOptions.updatePresence) {
+            for (const i in jsonMessage.list) {
+              const data = jsonMessage.list[i];
+              const userID = data["u"];
+              const presence = { type: "presence", userID: userID.toString(), timestamp: data["l"] * 1000, statuses: data["p"] };
+              globalCallback(null, presence);
+            }
+          }
+        } else if (topic == "/ls_resp") {
+          const parsedPayload = JSON.parse(jsonMessage.payload);
+          const reqID = jsonMessage.request_id;
+          if (ctx["tasks"].has(reqID)) {
+            const taskData = ctx["tasks"].get(reqID);
+            const { type: taskType, callback: taskCallback } = taskData;
+            const taskRespData = getTaskResponseData(taskType, parsedPayload);
+            if (taskRespData == null) {
+              taskCallback("error", null);
+            } else {
+              taskCallback(null, Object.assign({ type: taskType, reqID: reqID }, taskRespData));
+            }
+          }
+        }
+      } catch (ex) {
+        return;
+      }
+    });
+    mqttClient.on("close", function () {});
+    mqttClient.on("disconnect", () => {});
+  };
+};

package/src/api/socket/core/getSeqID.js

@@ -0,0 +1,25 @@
+"use strict";
+const { getType } = require("../../../utils/format");
+const { parseAndCheckLogin } = require("../../../utils/client");
+module.exports = function createGetSeqID(deps) {
+  const { listenMqtt } = deps;
+  return function getSeqID(defaultFuncs, api, ctx, globalCallback, form) {
+    ctx.t_mqttCalled = false;
+    return defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form).then(parseAndCheckLogin(ctx, defaultFuncs)).then(resData => {
+      if (getType(resData) !== "Array") throw { error: "Not logged in", res: resData };
+      if (!Array.isArray(resData) || !resData.length) return;
+      const lastRes = resData[resData.length - 1];
+      if (lastRes && lastRes.successful_results === 0) return;
+      const syncSeqId = resData[0] && resData[0].o0 && resData[0].o0.data && resData[0].o0.data.viewer && resData[0].o0.data.viewer.message_threads && resData[0].o0.data.viewer.message_threads.sync_sequence_id;
+      if (syncSeqId) {
+        ctx.lastSeqId = syncSeqId;
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      } else {
+        throw { error: "getSeqId: no sync_sequence_id found.", res: resData };
+      }
+    }).catch(err => {
+      if (getType(err) === "Object" && err.error === "Not logged in") ctx.loggedIn = false;
+      return globalCallback(err);
+    });
+  };
+};

package/src/api/socket/core/getTaskResponseData.js

@@ -0,0 +1,22 @@
+"use strict";
+module.exports = function getTaskResponseData(taskType, payload) {
+  try {
+    switch (taskType) {
+      case "send_message_mqtt":
+        return {
+          type: taskType,
+          threadID: payload.step[1][2][2][1][2],
+          messageID: payload.step[1][2][2][1][3],
+          payload: payload.step[1][2]
+        };
+      case "set_message_reaction":
+        return { mid: payload.step[1][2][2][1][4] };
+      case "edit_message":
+        return { mid: payload.step[1][2][2][1][2] };
+      default:
+        return null;
+    }
+  } catch (e) {
+    return null;
+  }
+};

package/src/api/socket/core/markDelivery.js

@@ -0,0 +1,12 @@
+"use strict";
+module.exports = function markDelivery(ctx, api, threadID, messageID) {
+  if (threadID && messageID) {
+    api.markAsDelivered(threadID, messageID, err => {
+      if (err) {} else {
+        if (ctx.globalOptions.autoMarkRead) {
+          api.markAsRead(threadID, err2 => {});
+        }
+      }
+    });
+  }
+};

package/src/api/socket/core/parseDelta.js

@@ -0,0 +1,351 @@
+"use strict";
+const { formatDeltaEvent, formatMessage, _formatAttachment, formatDeltaMessage, formatDeltaReadReceipt, formatID, getType, decodeClientPayload } = require("../../../utils/format");
+module.exports = function createParseDelta(deps) {
+  const { markDelivery, parseAndCheckLogin } = deps;
+  return function parseDelta(defaultFuncs, api, ctx, globalCallback, { delta }) {
+    if (delta.class === "NewMessage") {
+      const resolveAttachmentUrl = i => {
+        if (!delta.attachments || i === delta.attachments.length || getType(delta.attachments) !== "Array") {
+          let fmtMsg;
+          try {
+            fmtMsg = formatDeltaMessage(delta);
+          } catch (err) {
+            return;
+          }
+          if (fmtMsg) {
+            if (ctx.globalOptions.autoMarkDelivery) {
+              markDelivery(ctx, api, fmtMsg.threadID, fmtMsg.messageID);
+            }
+            if (!ctx.globalOptions.selfListen && fmtMsg.senderID === ctx.userID) return;
+            globalCallback(null, fmtMsg);
+          }
+        } else {
+          const attachment = delta.attachments[i];
+          if (attachment.mercury.attach_type === "photo") {
+            api.resolvePhotoUrl(attachment.fbid, (err, url) => {
+              if (!err) attachment.mercury.metadata.url = url;
+              resolveAttachmentUrl(i + 1);
+            });
+          } else {
+            resolveAttachmentUrl(i + 1);
+          }
+        }
+      };
+      resolveAttachmentUrl(0);
+    } else if (delta.class === "ClientPayload") {
+      const clientPayload = decodeClientPayload(delta.payload);
+      if (clientPayload && clientPayload.deltas) {
+        for (const d of clientPayload.deltas) {
+          if (d.deltaMessageReaction && !!ctx.globalOptions.listenEvents) {
+            const messageReaction = {
+              type: "message_reaction",
+              threadID: (d.deltaMessageReaction.threadKey.threadFbId ? d.deltaMessageReaction.threadKey.threadFbId : d.deltaMessageReaction.threadKey.otherUserFbId).toString(),
+              messageID: d.deltaMessageReaction.messageId,
+              reaction: d.deltaMessageReaction.reaction,
+              senderID: d.deltaMessageReaction.senderId.toString(),
+              userID: d.deltaMessageReaction.userId.toString()
+            };
+            globalCallback(null, messageReaction);
+          } else if (d.deltaRecallMessageData && !!ctx.globalOptions.listenEvents) {
+            const messageUnsend = {
+              type: "message_unsend",
+              threadID: (d.deltaRecallMessageData.threadKey.threadFbId ? d.deltaRecallMessageData.threadKey.threadFbId : d.deltaRecallMessageData.threadKey.otherUserFbId).toString(),
+              messageID: d.deltaRecallMessageData.messageID,
+              senderID: d.deltaRecallMessageData.senderID.toString(),
+              deletionTimestamp: d.deltaRecallMessageData.deletionTimestamp,
+              timestamp: d.deltaRecallMessageData.timestamp
+            };
+            globalCallback(null, messageUnsend);
+          } else if (d.deltaMessageReply) {
+            const mdata = d.deltaMessageReply.message === undefined ? [] : d.deltaMessageReply.message.data === undefined ? [] : d.deltaMessageReply.message.data.prng === undefined ? [] : JSON.parse(d.deltaMessageReply.message.data.prng);
+            const m_id = mdata.map(u => u.i);
+            const m_offset = mdata.map(u => u.o);
+            const m_length = mdata.map(u => u.l);
+            const mentions = {};
+            for (let i = 0; i < m_id.length; i++) {
+              mentions[m_id[i]] = (d.deltaMessageReply.message.body || "").substring(m_offset[i], m_offset[i] + m_length[i]);
+            }
+            const callbackToReturn = {
+              type: "message_reply",
+              threadID: (d.deltaMessageReply.message.messageMetadata.threadKey.threadFbId ? d.deltaMessageReply.message.messageMetadata.threadKey.threadFbId : d.deltaMessageReply.message.messageMetadata.threadKey.otherUserFbId).toString(),
+              messageID: d.deltaMessageReply.message.messageMetadata.messageId,
+              senderID: d.deltaMessageReply.message.messageMetadata.actorFbId.toString(),
+              attachments: (d.deltaMessageReply.message.attachments || []).map(att => {
+                const mercury = JSON.parse(att.mercuryJSON);
+                Object.assign(att, mercury);
+                return att;
+              }).map(att => {
+                let x;
+                try {
+                  x = _formatAttachment(att);
+                } catch (ex) {
+                  x = att;
+                  x.error = ex;
+                  x.type = "unknown";
+                }
+                return x;
+              }),
+              args: (d.deltaMessageReply.message.body || "").trim().split(/\s+/),
+              body: d.deltaMessageReply.message.body || "",
+              isGroup: !!d.deltaMessageReply.message.messageMetadata.threadKey.threadFbId,
+              mentions,
+              timestamp: parseInt(d.deltaMessageReply.message.messageMetadata.timestamp),
+              participantIDs: (d.deltaMessageReply.message.participants || []).map(e => e.toString())
+            };
+            if (d.deltaMessageReply.repliedToMessage) {
+              const mdata2 = d.deltaMessageReply.repliedToMessage === undefined ? [] : d.deltaMessageReply.repliedToMessage.data === undefined ? [] : d.deltaMessageReply.repliedToMessage.data.prng === undefined ? [] : JSON.parse(d.deltaMessageReply.repliedToMessage.data.prng);
+              const m_id2 = mdata2.map(u => u.i);
+              const m_offset2 = mdata2.map(u => u.o);
+              const m_length2 = mdata2.map(u => u.l);
+              const rmentions = {};
+              for (let i = 0; i < m_id2.length; i++) {
+                rmentions[m_id2[i]] = (d.deltaMessageReply.repliedToMessage.body || "").substring(m_offset2[i], m_offset2[i] + m_length2[i]);
+              }
+              callbackToReturn.messageReply = {
+                threadID: (d.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId ? d.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId : d.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.otherUserFbId).toString(),
+                messageID: d.deltaMessageReply.repliedToMessage.messageMetadata.messageId,
+                senderID: d.deltaMessageReply.repliedToMessage.messageMetadata.actorFbId.toString(),
+                attachments: d.deltaMessageReply.repliedToMessage.attachments.map(att => {
+                  let mercury;
+                  try {
+                    mercury = JSON.parse(att.mercuryJSON);
+                    Object.assign(att, mercury);
+                  } catch (ex) {
+                    mercury = {};
+                  }
+                  return att;
+                }).map(att => {
+                  let x;
+                  try {
+                    x = _formatAttachment(att);
+                  } catch (ex) {
+                    x = att;
+                    x.error = ex;
+                    x.type = "unknown";
+                  }
+                  return x;
+                }),
+                args: (d.deltaMessageReply.repliedToMessage.body || "").trim().split(/\s+/),
+                body: d.deltaMessageReply.repliedToMessage.body || "",
+                isGroup: !!d.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId,
+                mentions: rmentions,
+                timestamp: parseInt(d.deltaMessageReply.repliedToMessage.messageMetadata.timestamp),
+                participantIDs: (d.deltaMessageReply.repliedToMessage.participants || []).map(e => e.toString())
+              };
+            } else if (d.deltaMessageReply.replyToMessageId) {
+              return defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+                av: ctx.globalOptions.pageID,
+                queries: JSON.stringify({
+                  o0: {
+                    doc_id: "2848441488556444",
+                    query_params: {
+                      thread_and_message_id: {
+                        thread_id: callbackToReturn.threadID,
+                        message_id: d.deltaMessageReply.replyToMessageId.id
+                      }
+                    }
+                  }
+                })
+              }).then(parseAndCheckLogin(ctx, defaultFuncs)).then(resData => {
+                if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
+                if (resData[resData.length - 1].successful_results === 0) throw { error: "forcedFetch: there was no successful_results", res: resData };
+                const fetchData = resData[0].o0.data.message;
+                const mobj = {};
+                for (const n in fetchData.message.ranges) {
+                  mobj[fetchData.message.ranges[n].entity.id] = (fetchData.message.text || "").substr(fetchData.message.ranges[n].offset, fetchData.message.ranges[n].length);
+                }
+                callbackToReturn.messageReply = {
+                  type: "Message",
+                  threadID: callbackToReturn.threadID,
+                  messageID: fetchData.message_id,
+                  senderID: fetchData.message_sender.id.toString(),
+                  attachments: fetchData.message.blob_attachment.map(att => _formatAttachment({ blob_attachment: att })),
+                  args: (fetchData.message.text || "").trim().split(/\s+/) || [],
+                  body: fetchData.message.text || "",
+                  isGroup: callbackToReturn.isGroup,
+                  mentions: mobj,
+                  timestamp: parseInt(fetchData.timestamp_precise)
+                };
+              }).catch(err => {}).finally(() => {
+                if (ctx.globalOptions.autoMarkDelivery) {
+                  markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+                }
+                if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+                globalCallback(null, callbackToReturn);
+              });
+            } else {
+              callbackToReturn.delta = d;
+            }
+            if (ctx.globalOptions.autoMarkDelivery) {
+              markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+            }
+            if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+            globalCallback(null, callbackToReturn);
+          }
+        }
+        return;
+      }
+    }
+    switch (delta.class) {
+      case "ReadReceipt": {
+        let fmtMsg;
+        try {
+          fmtMsg = formatDeltaReadReceipt(delta);
+        } catch (err) {
+          return;
+        }
+        globalCallback(null, fmtMsg);
+        break;
+      }
+      case "AdminTextMessage": {
+        switch (delta.type) {
+          case "instant_game_dynamic_custom_update":
+          case "accept_pending_thread":
+          case "confirm_friend_request":
+          case "shared_album_delete":
+          case "shared_album_addition":
+          case "pin_messages_v2":
+          case "unpin_messages_v2":
+          case "change_thread_theme":
+          case "change_thread_nickname":
+          case "change_thread_icon":
+          case "change_thread_quick_reaction":
+          case "change_thread_admins":
+          case "group_poll":
+          case "joinable_group_link_mode_change":
+          case "magic_words":
+          case "change_thread_approval_mode":
+          case "messenger_call_log":
+          case "participant_joined_group_call":
+          case "rtc_call_log":
+          case "update_vote": {
+            let fmtMsg;
+            try {
+              fmtMsg = formatDeltaEvent(delta);
+            } catch (err) {
+              return;
+            }
+            globalCallback(null, fmtMsg);
+            break;
+          }
+        }
+        break;
+      }
+      case "ForcedFetch": {
+        if (!delta.threadKey) return;
+        const mid = delta.messageId;
+        const tid = delta.threadKey.threadFbId;
+        if (mid && tid) {
+          const form = {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+              o0: {
+                doc_id: "2848441488556444",
+                query_params: {
+                  thread_and_message_id: {
+                    thread_id: tid.toString(),
+                    message_id: mid
+                  }
+                }
+              }
+            })
+          };
+          defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form).then(parseAndCheckLogin(ctx, defaultFuncs)).then(resData => {
+            if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
+            if (resData[resData.length - 1].successful_results === 0) throw { error: "forcedFetch: there was no successful_results", res: resData };
+            const fetchData = resData[0].o0.data.message;
+            if (getType(fetchData) === "Object") {
+              switch (fetchData.__typename) {
+                case "ThreadImageMessage":
+                  if ((!ctx.globalOptions.selfListen && fetchData.message_sender.id.toString() === ctx.userID) || !ctx.loggedIn) {} else {
+                    globalCallback(null, {
+                      type: "event",
+                      threadID: formatID(tid.toString()),
+                      logMessageType: "log:thread-image",
+                      logMessageData: {
+                        image: {
+                          attachmentID: fetchData.image_with_metadata && fetchData.image_with_metadata.legacy_attachment_id,
+                          width: fetchData.image_with_metadata && fetchData.image_with_metadata.original_dimensions.x,
+                          height: fetchData.image_with_metadata && fetchData.image_with_metadata.original_dimensions.y,
+                          url: fetchData.image_with_metadata && fetchData.image_with_metadata.preview.uri
+                        }
+                      },
+                      logMessageBody: fetchData.snippet,
+                      timestamp: fetchData.timestamp_precise,
+                      author: fetchData.message_sender.id
+                    });
+                  }
+                  break;
+                case "UserMessage": {
+                  const event = {
+                    type: "message",
+                    senderID: formatID(fetchData.message_sender.id),
+                    body: fetchData.message.text || "",
+                    threadID: formatID(tid.toString()),
+                    messageID: fetchData.message_id,
+                    attachments: [
+                      {
+                        type: "share",
+                        ID: fetchData.extensible_attachment.legacy_attachment_id,
+                        url: fetchData.extensible_attachment.story_attachment.url,
+                        title: fetchData.extensible_attachment.story_attachment.title_with_entities.text,
+                        description: fetchData.extensible_attachment.story_attachment.description.text,
+                        source: fetchData.extensible_attachment.story_attachment.source,
+                        image: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).uri,
+                        width: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).width,
+                        height: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).height,
+                        playable: ((fetchData.extensible_attachment.story_attachment.media || {}).is_playable || false),
+                        duration: ((fetchData.extensible_attachment.story_attachment.media || {}).playable_duration_in_ms || 0),
+                        subattachments: fetchData.extensible_attachment.subattachments,
+                        properties: fetchData.extensible_attachment.story_attachment.properties
+                      }
+                    ],
+                    mentions: {},
+                    timestamp: parseInt(fetchData.timestamp_precise),
+                    isGroup: fetchData.message_sender.id !== tid.toString()
+                  };
+                  globalCallback(null, event);
+                  break;
+                }
+                default:
+                  break;
+              }
+            } else {
+              return;
+            }
+          }).catch(err => {});
+        }
+        break;
+      }
+      case "ThreadName":
+      case "ParticipantsAddedToGroupThread":
+      case "ParticipantLeftGroupThread": {
+        let formattedEvent;
+        try {
+          formattedEvent = formatDeltaEvent(delta);
+        } catch (err) {
+          return;
+        }
+        if (!ctx.globalOptions.selfListen && formattedEvent.author.toString() === ctx.userID) return;
+        if (!ctx.loggedIn) return;
+        globalCallback(null, formattedEvent);
+        break;
+      }
+      case "NewMessage": {
+        const hasLiveLocation = d => {
+          const attachment = d.attachments && d.attachments[0] && d.attachments[0].mercury && d.attachments[0].mercury.extensible_attachment;
+          const storyAttachment = attachment && attachment.story_attachment;
+          return storyAttachment && storyAttachment.style_list && storyAttachment.style_list.includes("message_live_location");
+        };
+        if (delta.attachments && delta.attachments.length === 1 && hasLiveLocation(delta)) {
+          delta.class = "UserLocation";
+          try {
+            const fmtMsg = formatDeltaEvent(delta);
+            globalCallback(null, fmtMsg);
+          } catch (err) {}
+        }
+        break;
+      }
+    }
+  };
+};