@dongdev/fca-unofficial 3.0.11 → 3.0.15

package/CHANGELOG.md

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

package/module/loginHelper.js

@@ -284,14 +284,31 @@ async function setJarCookies(j, appstate) {
     const cookieName = c.name || c.key;
     const cookieValue = c.value;
     if (!cookieName || cookieValue === undefined) continue;
-    const dom = (c.domain || ".facebook.com").replace(/^\./, "");
-    const path = c.path || "/";
-    const base1 = `https://${dom}${path}`;
-    const base2 = `https://www.${dom}${path}`;
-    const domain = c.domain || ".facebook.com";
-    const str = `${cookieName}=${cookieValue}; Domain=${domain}; Path=${path};`;
-    tasks.push(j.setCookie(str, base1));
-    tasks.push(j.setCookie(str, base2));
+
+    const cookieDomain = c.domain || ".facebook.com";
+    const cookiePath = c.path || "/";
+    const dom = cookieDomain.replace(/^\./, "");
+
+    // Format expires if provided
+    let expiresStr = "";
+    if (c.expires) {
+      const expiresDate = typeof c.expires === "number" ? new Date(c.expires) : new Date(c.expires);
+      expiresStr = `; expires=${expiresDate.toUTCString()}`;
+    }
+
+    // Build cookie string
+    const str = `${cookieName}=${cookieValue}${expiresStr}; Domain=${cookieDomain}; Path=${cookiePath};`;
+
+    // Set cookie for both http and https, with and without www
+    const base1 = `http://${dom}${cookiePath}`;
+    const base2 = `https://${dom}${cookiePath}`;
+    const base3 = `http://www.${dom}${cookiePath}`;
+    const base4 = `https://www.${dom}${cookiePath}`;
+
+    tasks.push(j.setCookie(str, base1).catch(() => { }));
+    tasks.push(j.setCookie(str, base2).catch(() => { }));
+    tasks.push(j.setCookie(str, base3).catch(() => { }));
+    tasks.push(j.setCookie(str, base4).catch(() => { }));
   }
   await Promise.all(tasks);
 }
@@ -577,23 +594,47 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
     (async () => {
       try {
         if (appState) {
-          if (typeof appState === "string") {
+          // Check and convert cookie to appState format
+          if (Array.isArray(appState) && appState.some(c => c.name)) {
+            // Convert name to key if needed
+            appState = appState.map(c => {
+              if (c.name && !c.key) {
+                c.key = c.name;
+                delete c.name;
+              }
+              return c;
+            });
+          } else if (typeof appState === "string") {
+            // Try to parse as JSON first
             let parsed = appState;
             try {
               parsed = JSON.parse(appState);
             } catch { }
+
             if (Array.isArray(parsed)) {
-              // Use setJarCookies to properly handle individual cookie domains/paths
-              await setJarCookies(jar, parsed);
-            } else if (typeof parsed === "string") {
-              const pairs = normalizeCookieHeaderString(parsed);
-              if (!pairs.length) throw new Error("Empty appState cookie header");
-              setJarFromPairs(jar, pairs, domain);
+              // Already parsed as array, use it
+              appState = parsed;
             } else {
-              throw new Error("Invalid appState format");
+              // Parse string cookie format (key=value; key2=value2)
+              const arrayAppState = [];
+              appState.split(';').forEach(c => {
+                const [key, value] = c.split('=');
+                if (key && value) {
+                  arrayAppState.push({
+                    key: key.trim(),
+                    value: value.trim(),
+                    domain: ".facebook.com",
+                    path: "/",
+                    expires: new Date().getTime() + 1000 * 60 * 60 * 24 * 365
+                  });
+                }
+              });
+              appState = arrayAppState;
             }
-          } else if (Array.isArray(appState)) {
-            // Use setJarCookies to properly handle individual cookie domains/paths
+          }
+
+          // Set cookies into jar with individual domain/path
+          if (Array.isArray(appState)) {
             await setJarCookies(jar, appState);
           } else {
             throw new Error("Invalid appState format");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "3.0.11",
+  "version": "3.0.15",
   "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/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;