@dongdev/fca-unofficial 2.0.24 → 2.0.25

package/CHANGELOG.md

@@ -107,3 +107,6 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v2.0.23 - 2025-10-11
 - Hotfix / auto bump
+
+## v2.0.24 - 2025-10-11
+- Hotfix / auto bump

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "2.0.24",
+  "version": "2.0.25",
   "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
   "main": "index.js",
   "scripts": {

package/src/api/messaging/getThemePictures.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThemePictures(id, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (
+        getType(callback) == "Function" ||
+        getType(callback) == "AsyncFunction"
+      ) {
+        callback = callback;
+      } else {
+        callback = function (err, data) {
+          if (err) {
+            return rejectFunc(err);
+          }
+          resolveFunc(data);
+        };
+      }
+    }
+
+    if (getType(id) != "String") {
+      id = "";
+    }
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWPThreadThemeProviderQuery",
+      doc_id: "9734829906576883",
+      server_timestamps: true,
+      variables: JSON.stringify({
+        id
+      }),
+      av: ctx.userID
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+
+        return callback(null, resData);
+      })
+      .catch(function (err) {
+        log.error("getThemePictures", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/removeUserFromGroup.js

@@ -1,6 +1,7 @@
 "use strict";
 
-const { parseAndCheckLogin, getType } = require("../../utils/format");
+const { getType } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
 const log = require("npmlog");
 
 module.exports = function (defaultFuncs, api, ctx) {

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

@@ -80,23 +80,30 @@ module.exports = function createListenMqtt(deps) {
     const mqttClient = ctx.mqttClient;
     global.mqttClient = mqttClient;
 
-
     mqttClient.on("error", function (err) {
       const msg = String(err && err.message ? err.message : err || "");
-
-      if ((ctx._ending || ctx._cycling) && isEndingLikeError(msg)) {
+      if ((ctx._ending || ctx._cycling) && /No subscription existed|client disconnecting/i.test(msg)) {
         logger(`mqtt expected during shutdown: ${msg}`, "info");
         return;
       }
+
+      if (/Not logged in|Not logged in.|blocked the login|401|403/i.test(msg)) {
+        try { mqttClient.end(true); } catch (_) { }
+        return emitAuth(ctx, api, globalCallback,
+          /blocked/i.test(msg) ? "login_blocked" : "not_logged_in",
+          msg
+        );
+      }
       logger(`mqtt error: ${msg}`, "error");
       try { mqttClient.end(true); } catch (_) { }
       if (ctx._ending || ctx._cycling) return;
 
       if (ctx.globalOptions.autoReconnect) {
-        scheduleReconnect();
+        const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
+        logger(`mqtt autoReconnect listenMqtt() in ${d}ms`, "warn");
+        setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), d);
       } else {
-
-        globalCallback({ type: "stop_listen", error: msg || "Connection refused: Server unavailable" }, null);
+        globalCallback({ type: "stop_listen", error: msg || "Connection refused" }, null);
       }
     });
 

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

@@ -0,0 +1,22 @@
+"use strict";
+module.exports = function createEmitAuth({ logger }) {
+  return function emitAuth(ctx, api, globalCallback, reason, detail) {
+    try { if (ctx._autoCycleTimer) clearInterval(ctx._autoCycleTimer); } catch (_) { }
+    try { ctx._ending = true; } catch (_) { }
+    try { if (ctx.mqttClient) ctx.mqttClient.end(true); } catch (_) { }
+    ctx.mqttClient = undefined;
+    ctx.loggedIn = false;
+
+    const msg = detail || reason;
+    logger(`auth change -> ${reason}: ${msg}`, "error");
+
+    if (typeof globalCallback === "function") {
+      globalCallback({
+        type: "account_inactive",
+        reason,
+        error: msg,
+        timestamp: Date.now()
+      }, null);
+    }
+  };
+};

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

@@ -2,24 +2,38 @@
 const { getType } = require("../../../utils/format");
 const { parseAndCheckLogin } = require("../../../utils/client");
 module.exports = function createGetSeqID(deps) {
-  const { listenMqtt } = deps;
+  const { listenMqtt, logger, emitAuth } = 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);
-    });
+    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" };
+        if (!Array.isArray(resData) || !resData.length) return;
+        const lastRes = resData[resData.length - 1];
+        if (lastRes && lastRes.successful_results === 0) return;
+
+        const syncSeqId = resData[0]?.o0?.data?.viewer?.message_threads?.sync_sequence_id;
+        if (syncSeqId) {
+          ctx.lastSeqId = syncSeqId;
+          logger("mqtt getSeqID ok -> listenMqtt()", "info");
+          listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        } else {
+          throw { error: "getSeqId: no sync_sequence_id found." };
+        }
+      })
+      .catch(err => {
+        const msg = (err && err.error) || (err && err.message) || String(err || "");
+        if (/Not logged in/i.test(msg)) {
+          return emitAuth(ctx, api, globalCallback, "not_logged_in", msg);
+        }
+        if (/blocked the login/i.test(msg)) {
+          return emitAuth(ctx, api, globalCallback, "login_blocked", msg);
+        }
+        logger(`getSeqID error: ${msg}`, "error");
+        return emitAuth(ctx, api, globalCallback, "auth_error", msg);
+      });
   };
 };

package/src/api/socket/listenMqtt.js

@@ -12,9 +12,11 @@ const createListenMqtt = require("./core/connectMqtt");
 const createGetSeqID = require("./core/getSeqID");
 const markDelivery = require("./core/markDelivery");
 const getTaskResponseData = require("./core/getTaskResponseData");
+const createEmitAuth = require("./core/emitAuth");
 const parseDelta = createParseDelta({ markDelivery, parseAndCheckLogin });
 const listenMqtt = createListenMqtt({ WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData, logger });
 const getSeqIDFactory = createGetSeqID({ parseAndCheckLogin, listenMqtt, logger });
+const emitAuth = createEmitAuth({ logger });
 
 const MQTT_DEFAULTS = { cycleMs: 60 * 60 * 1000, reconnectDelayMs: 2000, autoReconnect: true, reconnectAfterStop: false };
 function mqttConf(ctx, overrides) {
@@ -26,6 +28,33 @@ function mqttConf(ctx, overrides) {
 module.exports = function (defaultFuncs, api, ctx, opts) {
   const identity = function () { };
   let globalCallback = identity;
+
+  function installPostGuard() {
+    if (ctx._postGuarded) return defaultFuncs.post;
+    const rawPost = defaultFuncs.post && defaultFuncs.post.bind(defaultFuncs);
+    if (!rawPost) return defaultFuncs.post;
+
+    function postSafe(...args) {
+      return rawPost(...args).catch(err => {
+        const msg = (err && err.error) || (err && err.message) || String(err || "");
+        if (/Not logged in|blocked the login/i.test(msg)) {
+          emitAuth(
+            ctx,
+            api,
+            globalCallback,
+            /blocked/i.test(msg) ? "login_blocked" : "not_logged_in",
+            msg
+          );
+        }
+        throw err;
+      });
+    }
+    defaultFuncs.post = postSafe;
+    ctx._postGuarded = true;
+    logger("postSafe guard installed for defaultFuncs.post", "info");
+    return postSafe;
+  }
+
   let conf = mqttConf(ctx, opts);
 
   function getSeqIDWrapper() {
@@ -34,7 +63,10 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
       queries: JSON.stringify({
         o0: {
           doc_id: "3336396659757871",
-          query_params: { limit: 1, before: null, tags: ["INBOX"], includeDeliveryReceipts: false, includeSeqID: true }
+          query_params: {
+            limit: 1, before: null, tags: ["INBOX"],
+            includeDeliveryReceipts: false, includeSeqID: true
+          }
         }
       })
     };
@@ -85,7 +117,7 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   }
 
   function forceCycle() {
-    if (ctx._cycling) return;           // đừng cycle chồng
+    if (ctx._cycling) return;
     ctx._cycling = true;
     ctx._ending = true;
     logger("mqtt force cycle begin", "warn");
@@ -119,12 +151,16 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
     }
 
     const msgEmitter = new MessageEmitter();
+
     globalCallback = callback || function (error, message) {
       if (error) { logger("mqtt emit error", "error"); return msgEmitter.emit("error", error); }
       msgEmitter.emit("message", message);
     };
 
     conf = mqttConf(ctx, conf);
+
+    installPostGuard();
+
     if (!ctx.firstListen) ctx.lastSeqId = null;
     ctx.syncToken = undefined;
     ctx.t_mqttCalled = false;

package/src/api/threads/getThreadInfo.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const fs = require("fs");
 const path = require("path");
 const logger = require("../../../func/logger");
@@ -122,6 +120,8 @@ let isProcessingQueue = false;
 const processingThreads = new Set();
 const queuedThreads = new Set();
 const cooldown = new Map();
+const inflight = new Map();
+let loopStarted = false;
 
 module.exports = function (defaultFuncs, api, ctx) {
   const getMultiInfo = async function (threadIDs) {
@@ -204,6 +204,17 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
   }
 
+  async function createOrUpdateThread(id, data) {
+    const existing = await get(id);
+    if (existing) {
+      await update(id, { data });
+      return "update";
+    } else {
+      await create(id, { data });
+      return "create";
+    }
+  }
+
   async function fetchThreadInfo(tID, isNew) {
     try {
       const response = await getMultiInfo([tID]);
@@ -214,13 +225,8 @@ module.exports = function (defaultFuncs, api, ctx) {
       }
       const threadInfo = response.Data[0];
       await upsertUsersFromThreadInfo(threadInfo);
-      if (isNew) {
-        await create(tID, { data: threadInfo });
-        logger(`Success create data thread: ${tID}`, "info");
-      } else {
-        await update(tID, { data: threadInfo });
-        logger(`Success update data thread: ${tID}`, "info");
-      }
+      const op = await createOrUpdateThread(tID, threadInfo);
+      logger(`${op === "create" ? "Success create data thread" : "Success update data thread"}: ${tID}`, "info");
     } catch (err) {
       cooldown.set(tID, Date.now() + 5 * 60 * 1000);
       logger(`fetchThreadInfo error ${tID}: ${err?.message || err}`, "error");
@@ -242,7 +248,6 @@ module.exports = function (defaultFuncs, api, ctx) {
         const lastUpdated = new Date(result.updatedAt).getTime();
         if ((now - lastUpdated) / (1000 * 60) > 10 && !queuedThreads.has(t)) {
           queuedThreads.add(t);
-          logger(`ThreadID ${t} queued for refresh`, "info");
           queue.push(() => fetchThreadInfo(t, false));
         }
       }
@@ -265,10 +270,13 @@ module.exports = function (defaultFuncs, api, ctx) {
     isProcessingQueue = false;
   }
 
-  setInterval(() => {
-    checkAndUpdateThreads();
-    processQueue();
-  }, 10000);
+  if (!loopStarted) {
+    loopStarted = true;
+    setInterval(() => {
+      checkAndUpdateThreads();
+      processQueue();
+    }, 10000);
+  }
 
   return async function getThreadInfoGraphQL(threadID, callback) {
     let resolveFunc = function () { };
@@ -284,25 +292,89 @@ module.exports = function (defaultFuncs, api, ctx) {
       };
     }
     if (getType(threadID) !== "Array") threadID = [threadID];
+    const tid = String(threadID[0]);
     try {
-      const cached = await get(threadID[0]);
+      const cd = cooldown.get(tid);
+      if (cd && Date.now() < cd) {
+        const cachedCd = await get(tid);
+        if (cachedCd?.data && isValidThread(cachedCd.data)) {
+          await upsertUsersFromThreadInfo(cachedCd.data);
+          callback(null, cachedCd.data);
+          return returnPromise;
+        }
+        const stub = {
+          threadID: tid,
+          threadName: null,
+          participantIDs: [],
+          userInfo: [],
+          unreadCount: 0,
+          messageCount: 0,
+          timestamp: null,
+          muteUntil: null,
+          isGroup: false,
+          isSubscribed: false,
+          isArchived: false,
+          folder: null,
+          cannotReplyReason: null,
+          eventReminders: [],
+          emoji: null,
+          color: null,
+          threadTheme: null,
+          nicknames: {},
+          adminIDs: [],
+          approvalMode: false,
+          approvalQueue: [],
+          reactionsMuteMode: "",
+          mentionsMuteMode: "",
+          isPinProtected: false,
+          relatedPageThread: null,
+          name: null,
+          snippet: null,
+          snippetSender: null,
+          snippetAttachments: [],
+          serverTimestamp: null,
+          imageSrc: null,
+          isCanonicalUser: false,
+          isCanonical: true,
+          recipientsLoadable: false,
+          hasEmailParticipant: false,
+          readOnly: false,
+          canReply: false,
+          lastMessageTimestamp: null,
+          lastMessageType: "message",
+          lastReadTimestamp: null,
+          threadType: 1,
+          inviteLink: { enable: false, link: null },
+          __status: "cooldown",
+        };
+        await createOrUpdateThread(tid, stub);
+        callback(null, stub);
+        return returnPromise;
+      }
+
+      const cached = await get(tid);
       if (cached?.data && isValidThread(cached.data)) {
         await upsertUsersFromThreadInfo(cached.data);
         callback(null, cached.data);
         return returnPromise;
       }
-      if (!processingThreads.has(threadID[0])) {
-        processingThreads.add(threadID[0]);
-        logger(`Created new thread data: ${threadID[0]}`, "info");
-        const response = await getMultiInfo(threadID);
+
+      if (inflight.has(tid)) {
+        inflight.get(tid).then(data => callback(null, data)).catch(err => callback(err));
+        return returnPromise;
+      }
+
+      const p = (async () => {
+        processingThreads.add(tid);
+        const response = await getMultiInfo([tid]);
         if (response.Success && response.Data && isValidThread(response.Data[0])) {
           const data = response.Data[0];
           await upsertUsersFromThreadInfo(data);
-          await create(threadID[0], { data });
-          callback(null, data);
+          await createOrUpdateThread(tid, data);
+          return data;
         } else {
           const stub = {
-            threadID: threadID[0],
+            threadID: tid,
             threadName: null,
             participantIDs: [],
             userInfo: [],
@@ -346,11 +418,18 @@ module.exports = function (defaultFuncs, api, ctx) {
             inviteLink: { enable: false, link: null },
             __status: "unavailable",
           };
-          cooldown.set(threadID[0], Date.now() + 5 * 60 * 1000);
-          callback(null, stub);
+          cooldown.set(tid, Date.now() + 5 * 60 * 1000);
+          await createOrUpdateThread(tid, stub);
+          return stub;
         }
-        processingThreads.delete(threadID[0]);
-      }
+      })()
+        .finally(() => {
+          processingThreads.delete(tid);
+          inflight.delete(tid);
+        });
+
+      inflight.set(tid, p);
+      p.then(data => callback(null, data)).catch(err => callback(err));
     } catch (err) {
       callback(err);
     }