stfca 1.0.2 → 1.0.3

package/src/api/messaging/unsendMessage.js

@@ -1,81 +0,0 @@
-"use strict";
-
-const { generateOfflineThreadingID } = require("../../utils/format.js");
-const log = require("npmlog");
-
-module.exports = function (defaultFuncs, api, ctx) {
-  return function unsendMessage(messageID, threadID, callback) {
-    return new Promise((resolve, reject) => {
-      if (!ctx.mqttClient) {
-        const err = new Error("Not connected to MQTT");
-        callback?.(err);
-        return reject(err);
-      }
-      const reqID = ++ctx.wsReqNumber;
-      const taskID = ++ctx.wsTaskNumber;
-      const taskPayload = {
-        message_id: messageID,
-        thread_key: threadID,
-        sync_group: 1,
-      };
-      const task = {
-        failure_count: null,
-        label: "33",
-        payload: JSON.stringify(taskPayload),
-        queue_name: "unsend_message",
-        task_id: taskID,
-      };
-      const content = {
-        app_id: "2220391788200892",
-        payload: JSON.stringify({
-          tasks: [task],
-          epoch_id: parseInt(generateOfflineThreadingID()),
-          version_id: "25393437286970779",
-        }),
-        request_id: reqID,
-        type: 3,
-      };
-      try {
-        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
-          qos: 1,
-          retain: false
-        });
-      } catch (err) {
-        log.error("unsendMessage (MQTT publish failed)", err);
-        callback?.(err);
-        return reject(err);
-      }
-      const handleRes = (topic, message) => {
-        if (topic !== "/ls_resp") return;
-        let jsonMsg;
-        try {
-          jsonMsg = JSON.parse(message.toString());
-          jsonMsg.payload = JSON.parse(jsonMsg.payload);
-        } catch (err) {
-          return;
-        }
-        if (jsonMsg.request_id !== reqID) return;
-        ctx.mqttClient.removeListener("message", handleRes);
-        try {
-          const msgID = jsonMsg.payload.step?.[1]?.[2]?.[2]?.[1]?.[2];
-          const msgReplace = jsonMsg.payload.step?.[1]?.[2]?.[2]?.[1]?.[4];
-          if (msgID && msgReplace) {
-            const bodies = {
-              body: msgReplace,
-              messageID: msgID
-            };
-            callback?.(null, bodies);
-            return resolve(bodies);
-          } else {
-            callback?.(null, { success: true });
-            return resolve({ success: true });
-          }
-        } catch (err) {
-          callback?.(null, { success: true });
-          return resolve({ success: true });
-        }
-      };
-      ctx.mqttClient.on("message", handleRes);
-    });
-  };
-};

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

@@ -1,179 +0,0 @@
-"use strict";
-const { formatID } = require("../../../utils/format");
-module.exports = function createListenMqtt(deps) {
-  const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData } = 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) {
-      const msg = String(err && err.message ? err.message : err || "");
-      if (ctx._ending && /No subscription existed/i.test(msg)) {
-        console.warn("[FCA-WARN] MQTT ignore unsubscribe error during shutdown");
-        return;
-      }
-      console.error(`[FCA-ERROR] MQTT error: ${msg}`);
-      // mqttClient.end();
-      // console.warn("[FCA-WARN] MQTT autoReconnect listenMqtt() in 2000ms");
-      // setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), 2000);
-      process.exit(1);
-    });
-    mqttClient.on("connect", function () {
-      if (process.env.OnStatus === undefined) {
-        console.log("[FCA-INFO] ST FCA connected");
-        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

@@ -1,25 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-"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

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