fca-riyad 37.0.0

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

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Maps /ls_resp task types to a normalized response shape for send_message_mqtt, set_message_reaction, edit_message.
+ */
+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/parseDelta.js

@@ -0,0 +1,387 @@
+"use strict";
+const { formatDeltaEvent, formatMessage, _formatAttachment, formatDeltaMessage, formatDeltaReadReceipt, formatID, getType, decodeClientPayload, getMentionsFromDeltaMessage } = require("../../../utils/format");
+const logger = require("../../../../func/logger");
+module.exports = function createParseDelta(deps) {
+  const { 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.selfListen && fmtMsg.senderID === ctx.userID) return;
+            globalCallback(null, fmtMsg);
+          }
+        } else {
+          const attachment = delta.attachments[i];
+          if (attachment && attachment.mercury && attachment.mercury.attach_type === "photo") {
+            api.resolvePhotoUrl(attachment.fbid, (err, url) => {
+              if (!err && attachment.mercury && attachment.mercury.metadata) {
+                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.deltaMessageEdit && !!ctx.globalOptions.listenEvents) {
+            try {
+              const edit = d.deltaMessageEdit;
+              const threadKey = edit.threadKey || {};
+              const messageEdit = {
+                type: "message_edit",
+                threadID: (threadKey.threadFbId ? threadKey.threadFbId : threadKey.otherUserFbId || "").toString(),
+                messageID: edit.messageId || "",
+                senderID: (edit.senderId || "").toString(),
+                body: edit.body || "",
+                timestamp: edit.timestamp ? parseInt(edit.timestamp) : Date.now()
+              };
+              globalCallback(null, messageEdit);
+            } catch (err) {
+              logger("parseDelta: deltaMessageEdit error: " + (err && err.message ? err.message : String(err)), "warn");
+            }
+          } 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) {
+            let callbackToReturn;
+            try {
+              const msg = d.deltaMessageReply.message;
+              if (!msg || !msg.messageMetadata) {
+                logger("parseDelta: deltaMessageReply.message or messageMetadata is missing", "warn");
+                return;
+              }
+              const mentions = getMentionsFromDeltaMessage(msg);
+              const msgMetadata = msg.messageMetadata;
+              const threadKey = msgMetadata.threadKey || {};
+              callbackToReturn = {
+                type: "message_reply",
+                threadID: (threadKey.threadFbId ? threadKey.threadFbId : threadKey.otherUserFbId || "").toString(),
+                messageID: msgMetadata.messageId || "",
+                senderID: (msgMetadata.actorFbId || "").toString(),
+                attachments: (msg.attachments || []).map(att => {
+                  try {
+                    const mercury = JSON.parse(att.mercuryJSON);
+                    Object.assign(att, mercury);
+                  } catch (ex) {
+                    // Ignore parsing errors
+                  }
+                  return att;
+                }).map(att => {
+                  let x;
+                  try {
+                    x = _formatAttachment(att);
+                  } catch (ex) {
+                    x = att;
+                    x.error = ex;
+                    x.type = "unknown";
+                  }
+                  return x;
+                }),
+                args: (msg.body || "").trim().split(/\s+/),
+                body: msg.body || "",
+                isGroup: !!threadKey.threadFbId,
+                mentions,
+                timestamp: parseInt(msgMetadata.timestamp || 0),
+                participantIDs: (msg.participants || []).map(e => e.toString())
+              };
+            if (d.deltaMessageReply.repliedToMessage) {
+              try {
+                const repliedTo = d.deltaMessageReply.repliedToMessage;
+                const rmentions = getMentionsFromDeltaMessage(repliedTo);
+                const msgMetadata = repliedTo.messageMetadata;
+                if (msgMetadata && msgMetadata.threadKey) {
+                  callbackToReturn.messageReply = {
+                    threadID: (msgMetadata.threadKey.threadFbId ? msgMetadata.threadKey.threadFbId : msgMetadata.threadKey.otherUserFbId || "").toString(),
+                    messageID: msgMetadata.messageId || "",
+                    senderID: (msgMetadata.actorFbId || "").toString(),
+                    attachments: (repliedTo.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: (repliedTo.body || "").trim().split(/\s+/),
+                    body: repliedTo.body || "",
+                    isGroup: !!msgMetadata.threadKey.threadFbId,
+                    mentions: rmentions,
+                    timestamp: parseInt(msgMetadata.timestamp || 0),
+                    participantIDs: (repliedTo.participants || []).map(e => e.toString())
+                  };
+                }
+              } catch (err) {
+                const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+                logger(`parseDelta message_reply repliedToMessage error: ${errMsg}`, "warn");
+              }
+            } 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 => {
+                const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+                logger(`parseDelta message_reply fetch error: ${errMsg}`, "warn");
+              }).finally(() => {
+                if (callbackToReturn) {
+                  if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+                  globalCallback(null, callbackToReturn);
+                }
+              });
+            } else {
+              if (callbackToReturn) callbackToReturn.delta = d;
+            }
+            } catch (err) {
+              const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+              logger(`parseDelta message_reply error: ${errMsg}`, "warn");
+              return;
+            }
+            if (callbackToReturn) {
+              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 || delta.threadKey.otherUserFbId;
+        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 => {
+            const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+            logger(`parseDelta ForcedFetch error: ${errMsg}`, "warn");
+          });
+        }
+        break;
+      }
+      case "ThreadName":
+      case "ParticipantsAddedToGroupThread":
+      case "ParticipantLeftGroupThread": {
+        let formattedEvent;
+        try {
+          formattedEvent = formatDeltaEvent(delta);
+        } catch (err) {
+          return;
+        }
+        if (!ctx.globalOptions.selfListen && formattedEvent.author != null && formattedEvent.author.toString() === ctx.userID) return;
+        if (!ctx.loggedIn) return;
+        globalCallback(null, formattedEvent);
+        if (formattedEvent && formattedEvent.type === "event" && formattedEvent.threadID != null && typeof ctx._syncThreadInfoFromEvent === "function") {
+          try { ctx._syncThreadInfoFromEvent(formattedEvent); } catch { }
+        }
+        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;
+      }
+    }
+  };
+};

package/src/api/socket/detail/buildStream.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Builds a duplex stream over WebSocket for MQTT: proxy for writes, PassThrough for reads.
+ * Handles ping/pong, liveness timeout, and clean shutdown.
+ */
+const { Writable, PassThrough } = require("stream");
+const Duplexify = require("duplexify");
+
+const PING_INTERVAL_MS = 30000;
+const LIVENESS_CHECK_MS = 10000;
+const LIVENESS_MAX_IDLE_MS = 65000;
+
+function buildProxy() {
+  let target = null;
+  let ended = false;
+  const Proxy = new Writable({
+    autoDestroy: true,
+    write(chunk, enc, cb) {
+      if (ended || this.destroyed) return cb();
+      const ws = target;
+      if (ws && ws.readyState === 1) {
+        try {
+          ws.send(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), cb);
+        } catch (e) {
+          cb(e);
+        }
+      } else cb();
+    },
+    writev(chunks, cb) {
+      if (ended || this.destroyed) return cb();
+      const ws = target;
+      if (!ws || ws.readyState !== 1) return cb();
+      try {
+        for (const { chunk } of chunks) {
+          ws.send(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        cb();
+      } catch (e) {
+        cb(e);
+      }
+    },
+    final(cb) {
+      ended = true;
+      const ws = target;
+      target = null;
+      if (ws && (ws.readyState === 0 || ws.readyState === 1)) {
+        try {
+          typeof ws.terminate === "function" ? ws.terminate() : ws.close();
+        } catch { }
+      }
+      cb();
+    }
+  });
+  Proxy.setTarget = ws => {
+    if (ended) return;
+    target = ws;
+  };
+  Proxy.hardEnd = () => {
+    ended = true;
+    target = null;
+  };
+  return Proxy;
+}
+
+function buildStream(options, WebSocket, Proxy) {
+  const readable = new PassThrough();
+  const Stream = Duplexify(undefined, undefined, Object.assign({ end: false, autoDestroy: true }, options));
+  const NoopWritable = new Writable({ write(_c, _e, cb) { cb(); } });
+  let ws = WebSocket;
+  let pingTimer = null;
+  let livenessTimer = null;
+  let lastActivity = Date.now();
+  let attached = false;
+  let style = "prop";
+  let closed = false;
+
+  const toBuffer = d => {
+    if (Buffer.isBuffer(d)) return d;
+    if (d instanceof ArrayBuffer) return Buffer.from(d);
+    if (ArrayBuffer.isView(d)) return Buffer.from(d.buffer, d.byteOffset, d.byteLength);
+    return Buffer.from(String(d));
+  };
+
+  const swapToNoopWritable = () => {
+    try { Stream.setWritable(NoopWritable); } catch { }
+  };
+
+  const onOpen = () => {
+    if (closed) return;
+    Proxy.setTarget(ws);
+    Stream.setWritable(Proxy);
+    Stream.setReadable(readable);
+    Stream.emit("connect");
+    lastActivity = Date.now();
+    clearInterval(pingTimer);
+    clearInterval(livenessTimer);
+    pingTimer = setInterval(() => {
+      if (!ws || ws.readyState !== 1) return;
+      if (typeof ws.ping === "function") {
+        try { ws.ping(); } catch { }
+      } else {
+        try { ws.send("ping"); } catch { }
+      }
+    }, PING_INTERVAL_MS);
+    livenessTimer = setInterval(() => {
+      if (!ws || ws.readyState !== 1) return;
+      if (Date.now() - lastActivity > LIVENESS_MAX_IDLE_MS) {
+        try { typeof ws.terminate === "function" ? ws.terminate() : ws.close(); } catch { }
+      }
+    }, LIVENESS_CHECK_MS);
+  };
+
+  const onMessage = data => {
+    lastActivity = Date.now();
+    readable.write(toBuffer(style === "dom" && data && data.data !== undefined ? data.data : data));
+  };
+
+  const onPong = () => {
+    lastActivity = Date.now();
+  };
+
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(pingTimer);
+    clearInterval(livenessTimer);
+    pingTimer = null;
+    livenessTimer = null;
+    Proxy.hardEnd();
+    swapToNoopWritable();
+    if (ws) {
+      detach(ws);
+      try {
+        if (ws.readyState === 1) {
+          typeof ws.terminate === "function" ? ws.terminate() : ws.close();
+        }
+      } catch { }
+      ws = null;
+    }
+    readable.end();
+  };
+
+  const onError = err => {
+    cleanup();
+    Stream.destroy(err);
+  };
+
+  const onClose = () => {
+    cleanup();
+    Stream.end();
+    if (!Stream.destroyed) Stream.destroy();
+  };
+
+  const attach = w => {
+    if (attached || !w) return;
+    attached = true;
+    if (typeof w.on === "function" && typeof w.off === "function") {
+      style = "node";
+      w.on("open", onOpen);
+      w.on("message", onMessage);
+      w.on("error", onError);
+      w.on("close", onClose);
+      if (typeof w.on === "function") w.on("pong", onPong);
+    } else if (typeof w.addEventListener === "function" && typeof w.removeEventListener === "function") {
+      style = "dom";
+      w.addEventListener("open", onOpen);
+      w.addEventListener("message", onMessage);
+      w.addEventListener("error", onError);
+      w.addEventListener("close", onClose);
+    } else {
+      style = "prop";
+      w.onopen = onOpen;
+      w.onmessage = onMessage;
+      w.onerror = onError;
+      w.onclose = onClose;
+    }
+  };
+
+  const detach = w => {
+    if (!attached || !w) return;
+    attached = false;
+    if (style === "node" && typeof w.off === "function") {
+      w.off("open", onOpen);
+      w.off("message", onMessage);
+      w.off("error", onError);
+      w.off("close", onClose);
+      if (typeof w.off === "function") w.off("pong", onPong);
+    } else if (style === "dom" && typeof w.removeEventListener === "function") {
+      w.removeEventListener("open", onOpen);
+      w.removeEventListener("message", onMessage);
+      w.removeEventListener("error", onError);
+      w.removeEventListener("close", onClose);
+    } else {
+      w.onopen = null;
+      w.onmessage = null;
+      w.onerror = null;
+      w.onclose = null;
+    }
+  };
+
+  attach(ws);
+  if (ws && ws.readyState === 1) onOpen();
+
+  Stream.on("prefinish", swapToNoopWritable);
+  Stream.on("finish", cleanup);
+  Stream.on("close", cleanup);
+  Proxy.on("close", swapToNoopWritable);
+
+  return Stream;
+}
+
+module.exports = {
+  buildProxy,
+  buildStream
+};

package/src/api/socket/detail/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * MQTT topic list for Facebook Messenger real-time connection.
+ * Subscriptions are created in connectMqtt on "connect".
+ */
+module.exports = {
+  topics: [
+    "/ls_req",
+    "/ls_resp",
+    "/legacy_web",
+    "/webrtc",
+    "/rtc_multi",
+    "/onevc",
+    "/br_sr",
+    "/sr_res",
+    "/t_ms",
+    "/thread_typing",
+    "/orca_typing_notifications",
+    "/notify_disconnect",
+    "/orca_presence",
+    "/inbox",
+    "/mercury",
+    "/messaging_events",
+    "/orca_message_notifications",
+    "/pp",
+    "/webrtc_response"
+  ]
+};