@dongdev/fca-unofficial 3.0.12 → 3.0.17

package/CHANGELOG.md

@@ -164,3 +164,9 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v3.0.11 - 2025-12-05
 - Hotfix / auto bump
+
+## v3.0.12 - 2025-12-05
+- Hotfix / auto bump
+
+## v3.0.15 - 2025-12-12
+- Hotfix / auto bump

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "3.0.12",
+  "version": "3.0.17",
   "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
   "main": "index.js",
   "types": "index.d.ts",
@@ -13,8 +13,7 @@
   },
   "scripts": {
     "test": "mocha",
-    "lint": "eslint .",
-    "prepublishOnly": "npm test"
+    "lint": "eslint ."
   },
   "repository": {
     "type": "git",

package/src/api/messaging/sendMessage.js

@@ -24,9 +24,9 @@ module.exports = function (defaultFuncs, api, ctx) {
   async function uploadAttachment(streams) {
     const uploads = streams.map(stream => {
       if (!isReadableStream(stream)) throw { error: "Attachment should be a readable stream and not " + getType(stream) + "." };
-      const form = { upload_1024: stream, voice_clip: "true" };
+      const form = { farr: stream };
       return defaultFuncs
-        .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+        .postFormData("https://www.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
         .then(parseAndCheckLogin(ctx, defaultFuncs))
         .then(resData => {
           if (resData.error) throw resData;

package/src/api/messaging/uploadAttachment.js

@@ -20,14 +20,13 @@ module.exports = function(defaultFuncs, api, ctx) {
       }
 
       const form = {
-        upload_1024: attachments[i],
-        voice_clip: "true"
+        farr: attachments[i]
       };
 
       uploads.push(
         defaultFuncs
           .postFormData(
-            "https://upload.facebook.com/ajax/mercury/upload.php",
+            "https://www.facebook.com/ajax/mercury/upload.php",
             ctx.jar,
             form,
             {}

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

@@ -60,61 +60,34 @@ module.exports = function createParseDelta(deps) {
             };
             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]);
+            let callbackToReturn;
+            try {
+              const msg = d.deltaMessageReply.message;
+              if (!msg || !msg.messageMetadata) {
+                logger("parseDelta: deltaMessageReply.message or messageMetadata is missing", "warn");
+                return;
               }
-              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;
+              const mdata = msg === undefined ? [] : msg.data === undefined ? [] : msg.data.prng === undefined ? [] : JSON.parse(msg.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]] = (msg.body || "").substring(m_offset[i], m_offset[i] + m_length[i]);
+              }
+              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 {
-                    mercury = JSON.parse(att.mercuryJSON);
+                    const mercury = JSON.parse(att.mercuryJSON);
                     Object.assign(att, mercury);
                   } catch (ex) {
-                    mercury = {};
+                    // Ignore parsing errors
                   }
                   return att;
                 }).map(att => {
@@ -128,13 +101,62 @@ module.exports = function createParseDelta(deps) {
                   }
                   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())
+                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 mdata2 = repliedTo === undefined ? [] : repliedTo.data === undefined ? [] : repliedTo.data.prng === undefined ? [] : JSON.parse(repliedTo.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]] = (repliedTo.body || "").substring(m_offset2[i], m_offset2[i] + m_length2[i]);
+                }
+                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,
@@ -173,20 +195,29 @@ module.exports = function createParseDelta(deps) {
                 const errMsg = err && err.message ? err.message : String(err || "Unknown error");
                 logger(`parseDelta message_reply fetch error: ${errMsg}`, "warn");
               }).finally(() => {
-                if (ctx.globalOptions.autoMarkDelivery) {
-                  markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+                if (callbackToReturn) {
+                  if (ctx.globalOptions.autoMarkDelivery) {
+                    markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+                  }
+                  if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+                  globalCallback(null, callbackToReturn);
                 }
-                if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
-                globalCallback(null, callbackToReturn);
               });
             } else {
-              callbackToReturn.delta = d;
+              if (callbackToReturn) callbackToReturn.delta = d;
             }
-            if (ctx.globalOptions.autoMarkDelivery) {
-              markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+            } 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.autoMarkDelivery) {
+                markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
+              }
+              if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+              globalCallback(null, callbackToReturn);
             }
-            if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
-            globalCallback(null, callbackToReturn);
           }
         }
         return;