@dongdev/fca-unofficial 3.0.31 → 4.0.1

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

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

@@ -1,377 +0,0 @@
-"use strict";
-/**
- * Parses MQTT delta payloads into normalized events: NewMessage, ClientPayload (reactions, unsend, reply), read receipts, etc.
- */
-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;
-            if (typeof ctx._updateThreadFromMessage === "function") {
-              try {
-                ctx._updateThreadFromMessage(fmtMsg);
-              } catch { }
-            }
-            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.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;
-        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.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;
-      }
-    }
-  };
-};

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

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

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