@dongdev/fca-unofficial 2.0.22 → 2.0.24

package/CHANGELOG.md

@@ -101,3 +101,9 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v2.0.21 - 2025-10-08
 - Hotfix / auto bump
+
+## v2.0.22 - 2025-10-09
+- Hotfix / auto bump
+
+## v2.0.23 - 2025-10-11
+- Hotfix / auto bump

package/package.json

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

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

@@ -1,41 +1,42 @@
 "use strict";
 const { formatID } = require("../../../utils/format");
+const uuid = require("uuid");
+"use strict";
 module.exports = function createListenMqtt(deps) {
-  const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData, logger } = deps;
+  const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy,
+    topics, parseDelta, getTaskResponseData, logger
+  } = deps;
+
   return function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
+
+    function scheduleReconnect(delayMs) {
+      const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
+      const ms = typeof delayMs === "number" ? delayMs : d;
+      if (ctx._reconnectTimer) return; // debounce
+      logger(`mqtt will reconnect in ${ms}ms`, "warn");
+      ctx._reconnectTimer = setTimeout(() => {
+        ctx._reconnectTimer = null;
+        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+      }, ms);
+    }
+    function isEndingLikeError(msg) {
+      return /No subscription existed|client disconnecting|socket hang up|ECONNRESET/i.test(msg || "");
+    }
+
     const chatOn = ctx.globalOptions.online;
-    const foreground = false;
     const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
     const username = {
-      u: ctx.userID,
-      s: sessionID,
-      chat_on: chatOn,
-      fg: foreground,
-      d: ctx.clientId,
-      ct: "websocket",
-      aid: 219994525426954,
-      aids: null,
-      mqtt_sid: "",
-      cp: 3,
-      ecp: 10,
-      st: [],
-      pm: [],
-      dc: "",
-      no_auto_fg: true,
-      gas: null,
-      pack: [],
-      p: null,
-      php_override: ""
+      u: ctx.userID, s: sessionID, chat_on: chatOn, fg: false, d: ctx.clientId,
+      ct: "websocket", aid: 219994525426954, aids: null, mqtt_sid: "",
+      cp: 3, ecp: 10, st: [], pm: [], dc: "", no_auto_fg: true, gas: null, pack: [], p: null, php_override: ""
     };
+
     const cookies = api.getCookies();
     let host;
-    if (ctx.mqttEndpoint) {
-      host = `${ctx.mqttEndpoint}&sid=${sessionID}&cid=${ctx.clientId}`;
-    } else if (ctx.region) {
-      host = `wss://edge-chat.facebook.com/chat?region=${ctx.region.toLowerCase()}&sid=${sessionID}&cid=${ctx.clientId}`;
-    } else {
-      host = `wss://edge-chat.facebook.com/chat?sid=${sessionID}&cid=${ctx.clientId}`;
-    }
+    if (ctx.mqttEndpoint) host = `${ctx.mqttEndpoint}&sid=${sessionID}&cid=${ctx.clientId}`;
+    else if (ctx.region) host = `wss://edge-chat.facebook.com/chat?region=${ctx.region.toLowerCase()}&sid=${sessionID}&cid=${ctx.clientId}`;
+    else host = `wss://edge-chat.facebook.com/chat?sid=${sessionID}&cid=${ctx.clientId}`;
+
     const options = {
       clientId: "mqttwsclient",
       protocolId: "MQIsdp",
@@ -46,7 +47,7 @@ module.exports = function createListenMqtt(deps) {
         headers: {
           Cookie: cookies,
           Origin: "https://www.facebook.com",
-          "User-Agent": ctx.globalOptions.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+          "User-Agent": ctx.globalOptions.userAgent || "Mozilla/5.0",
           Referer: "https://www.facebook.com/",
           Host: "edge-chat.facebook.com",
           Connection: "Upgrade",
@@ -64,115 +65,124 @@ module.exports = function createListenMqtt(deps) {
       },
       keepalive: 30,
       reschedulePings: true,
-      reconnectPeriod: 1000,
+      reconnectPeriod: 0,
       connectTimeout: 5000
     };
     if (ctx.globalOptions.proxy !== undefined) {
       const agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
       options.wsOptions.agent = agent;
     }
-    ctx.mqttClient = new mqtt.Client(() => buildStream(options, new WebSocket(host, options.wsOptions), buildProxy()), options);
+
+    ctx.mqttClient = new mqtt.Client(
+      () => buildStream(options, new WebSocket(host, options.wsOptions), buildProxy()),
+      options
+    );
     const mqttClient = ctx.mqttClient;
     global.mqttClient = mqttClient;
+
+
     mqttClient.on("error", function (err) {
       const msg = String(err && err.message ? err.message : err || "");
-      if (ctx._ending && /No subscription existed/i.test(msg)) {
-        logger("MQTT ignore unsubscribe error during shutdown", "warn");
+
+      if ((ctx._ending || ctx._cycling) && isEndingLikeError(msg)) {
+        logger(`mqtt expected during shutdown: ${msg}`, "info");
         return;
       }
-      logger(`MQTT error: ${msg}`, "error");
-      // mqttClient.end();
-      // logger("MQTT autoReconnect listenMqtt() in 2000ms", "warn");
-      // setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), 2000);
-      process.exit(1);
+      logger(`mqtt error: ${msg}`, "error");
+      try { mqttClient.end(true); } catch (_) { }
+      if (ctx._ending || ctx._cycling) return;
+
+      if (ctx.globalOptions.autoReconnect) {
+        scheduleReconnect();
+      } else {
+
+        globalCallback({ type: "stop_listen", error: msg || "Connection refused: Server unavailable" }, null);
+      }
     });
+
     mqttClient.on("connect", function () {
       if (process.env.OnStatus === undefined) {
         logger("fca-unoffcial premium", "info");
         process.env.OnStatus = true;
       }
-      topics.forEach(topicsub => mqttClient.subscribe(topicsub));
-      let topic;
-      const queue = { sync_api_version: 11, max_deltas_able_to_process: 100, delta_batch_size: 500, encoding: "JSON", entity_fbid: ctx.userID, initial_titan_sequence_id: ctx.lastSeqId, device_params: null };
-      if (ctx.syncToken) {
-        topic = "/messenger_sync_get_diffs";
-        queue.last_seq_id = ctx.lastSeqId;
-        queue.sync_token = ctx.syncToken;
-      } else {
-        topic = "/messenger_sync_create_queue";
-        queue.initial_titan_sequence_id = ctx.lastSeqId;
-        queue.device_params = null;
-      }
+      ctx._cycling = false;
+
+      topics.forEach(t => mqttClient.subscribe(t));
+
+
+      const queue = {
+        sync_api_version: 11, max_deltas_able_to_process: 100, delta_batch_size: 500,
+        encoding: "JSON", entity_fbid: ctx.userID, initial_titan_sequence_id: ctx.lastSeqId, device_params: null
+      };
+      const topic = ctx.syncToken ? "/messenger_sync_get_diffs" : "/messenger_sync_create_queue";
+      if (ctx.syncToken) { queue.last_seq_id = ctx.lastSeqId; queue.sync_token = ctx.syncToken; }
       mqttClient.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
       mqttClient.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
       mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
+      const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
       const rTimeout = setTimeout(function () {
-        mqttClient.end();
-        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        logger(`mqtt t_ms timeout, cycling in ${d}ms`, "warn");
+        try { mqttClient.end(true); } catch (_) { }
+        scheduleReconnect(d);
       }, 5000);
+
       ctx.tmsWait = function () {
         clearTimeout(rTimeout);
-        ctx.globalOptions.emitReady ? globalCallback({ type: "ready", error: null }) : "";
+        if (ctx.globalOptions.emitReady) globalCallback({ type: "ready", error: null });
         delete ctx.tmsWait;
       };
     });
-    mqttClient.on("message", function (topic, message, _packet) {
+
+    mqttClient.on("message", function (topic, message) {
       try {
         let jsonMessage = Buffer.isBuffer(message) ? Buffer.from(message).toString() : message;
-        try {
-          jsonMessage = JSON.parse(jsonMessage);
-        } catch (e) {
-          jsonMessage = {};
-        }
+        try { jsonMessage = JSON.parse(jsonMessage); } catch (_) { jsonMessage = {}; }
+
         if (jsonMessage.type === "jewel_requests_add") {
           globalCallback(null, { type: "friend_request_received", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
         } else if (jsonMessage.type === "jewel_requests_remove_old") {
           globalCallback(null, { type: "friend_request_cancel", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
         } else if (topic === "/t_ms") {
-          if (ctx.tmsWait && typeof ctx.tmsWait == "function") {
-            ctx.tmsWait();
-          }
+          if (ctx.tmsWait && typeof ctx.tmsWait == "function") ctx.tmsWait();
           if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) {
             ctx.lastSeqId = jsonMessage.firstDeltaSeqId;
             ctx.syncToken = jsonMessage.syncToken;
           }
-          if (jsonMessage.lastIssuedSeqId) {
-            ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
-          }
-          for (const i in jsonMessage.deltas) {
-            const delta = jsonMessage.deltas[i];
-            parseDelta(defaultFuncs, api, ctx, globalCallback, { delta });
+          if (jsonMessage.lastIssuedSeqId) ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+          for (const dlt of (jsonMessage.deltas || [])) {
+            parseDelta(defaultFuncs, api, ctx, globalCallback, { delta: dlt });
           }
         } else if (topic === "/thread_typing" || topic === "/orca_typing_notifications") {
-          const typ = { type: "typ", isTyping: !!jsonMessage.state, from: jsonMessage.sender_fbid.toString(), threadID: formatID((jsonMessage.thread || jsonMessage.sender_fbid).toString()) };
+          const typ = {
+            type: "typ",
+            isTyping: !!jsonMessage.state,
+            from: jsonMessage.sender_fbid.toString(),
+            threadID: formatID((jsonMessage.thread || jsonMessage.sender_fbid).toString())
+          };
           globalCallback(null, typ);
         } else if (topic === "/orca_presence") {
           if (!ctx.globalOptions.updatePresence) {
-            for (const i in jsonMessage.list) {
-              const data = jsonMessage.list[i];
-              const userID = data["u"];
-              const presence = { type: "presence", userID: userID.toString(), timestamp: data["l"] * 1000, statuses: data["p"] };
+            for (const data of (jsonMessage.list || [])) {
+              const presence = { type: "presence", userID: String(data.u), timestamp: data.l * 1000, statuses: data.p };
               globalCallback(null, presence);
             }
           }
-        } else if (topic == "/ls_resp") {
+        } else if (topic === "/ls_resp") {
           const parsedPayload = JSON.parse(jsonMessage.payload);
           const reqID = jsonMessage.request_id;
           if (ctx["tasks"].has(reqID)) {
             const taskData = ctx["tasks"].get(reqID);
             const { type: taskType, callback: taskCallback } = taskData;
             const taskRespData = getTaskResponseData(taskType, parsedPayload);
-            if (taskRespData == null) {
-              taskCallback("error", null);
-            } else {
-              taskCallback(null, Object.assign({ type: taskType, reqID: reqID }, taskRespData));
-            }
+            if (taskRespData == null) taskCallback("error", null);
+            else taskCallback(null, Object.assign({ type: taskType, reqID }, taskRespData));
           }
         }
       } catch (ex) {
-        return;
+        logger(`mqtt message parse error: ${ex && ex.message ? ex.message : ex}`, "error");
       }
     });
+
     mqttClient.on("close", function () { });
     mqttClient.on("disconnect", () => { });
   };

package/src/api/socket/listenMqtt.js

@@ -15,44 +15,54 @@ const getTaskResponseData = require("./core/getTaskResponseData");
 const parseDelta = createParseDelta({ markDelivery, parseAndCheckLogin });
 const listenMqtt = createListenMqtt({ WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData, logger });
 const getSeqIDFactory = createGetSeqID({ parseAndCheckLogin, listenMqtt, logger });
-module.exports = function (defaultFuncs, api, ctx) {
+
+const MQTT_DEFAULTS = { cycleMs: 60 * 60 * 1000, reconnectDelayMs: 2000, autoReconnect: true, reconnectAfterStop: false };
+function mqttConf(ctx, overrides) {
+  ctx._mqttOpt = Object.assign({}, MQTT_DEFAULTS, ctx._mqttOpt || {}, overrides || {});
+  if (typeof ctx._mqttOpt.autoReconnect === "boolean") ctx.globalOptions.autoReconnect = ctx._mqttOpt.autoReconnect;
+  return ctx._mqttOpt;
+}
+
+module.exports = function (defaultFuncs, api, ctx, opts) {
   const identity = function () { };
   let globalCallback = identity;
+  let conf = mqttConf(ctx, opts);
+
   function getSeqIDWrapper() {
     const form = {
-      av: ctx.userID,
+      av: ctx.globalOptions.pageID,
       queries: JSON.stringify({
-        o0: { doc_id: "3336396659757871", query_params: { limit: 1, before: null, tags: ["INBOX"], includeDeliveryReceipts: false, includeSeqID: true } }
+        o0: {
+          doc_id: "3336396659757871",
+          query_params: { limit: 1, before: null, tags: ["INBOX"], includeDeliveryReceipts: false, includeSeqID: true }
+        }
       })
     };
-    logger("MQTT getSeqID call", "info");
-    return getSeqIDFactory(defaultFuncs, api, ctx, globalCallback, form).then(() => {
-      logger("MQTT getSeqID done", "info");
-    }).catch(e => {
-      logger(`MQTT getSeqID error: ${e && e.message ? e.message : e}`, "error");
-    });
+    logger("mqtt getSeqID call", "info");
+    return getSeqIDFactory(defaultFuncs, api, ctx, globalCallback, form)
+      .then(() => { logger("mqtt getSeqID done", "info"); ctx._cycling = false; })
+      .catch(e => { logger(`mqtt getSeqID error: ${e && e.message ? e.message : e}`, "error"); });
   }
+
   function isConnected() {
     return !!(ctx.mqttClient && ctx.mqttClient.connected);
   }
+
   function unsubAll(cb) {
     if (!isConnected()) return cb && cb();
     let pending = topics.length;
     if (!pending) return cb && cb();
-    let done = false;
+    let fired = false;
     topics.forEach(t => {
-      ctx.mqttClient.unsubscribe(t, err => {
-        const msg = String(err && err.message ? err.message : err || "");
-        if (msg && /No subscription existed/i.test(msg)) err = null;
-        if (--pending === 0 && !done) {
-          done = true;
-          cb && cb();
-        }
+      ctx.mqttClient.unsubscribe(t, () => {
+        if (--pending === 0 && !fired) { fired = true; cb && cb(); }
       });
     });
   }
+
   function endQuietly(next) {
     const finish = () => {
+      try { ctx.mqttClient && ctx.mqttClient.removeAllListeners(); } catch (_) { }
       ctx.mqttClient = undefined;
       ctx.lastSeqId = null;
       ctx.syncToken = undefined;
@@ -62,71 +72,77 @@ module.exports = function (defaultFuncs, api, ctx) {
     };
     try {
       if (ctx.mqttClient) {
-        if (isConnected()) {
-          try { ctx.mqttClient.publish("/browser_close", "{}"); } catch (_) { }
-        }
+        if (isConnected()) { try { ctx.mqttClient.publish("/browser_close", "{}"); } catch (_) { } }
         ctx.mqttClient.end(true, finish);
       } else finish();
-    } catch (_) {
-      finish();
-    }
+    } catch (_) { finish(); }
   }
+
   function delayedReconnect() {
-    logger("MQTT reconnect in 2000ms", "info");
-    setTimeout(() => getSeqIDWrapper(), 2000);
+    const d = conf.reconnectDelayMs;
+    logger(`mqtt reconnect in ${d}ms`, "info");
+    setTimeout(() => getSeqIDWrapper(), d);
   }
+
   function forceCycle() {
+    if (ctx._cycling) return;           // đừng cycle chồng
+    ctx._cycling = true;
     ctx._ending = true;
-    logger("MQTT force cycle begin", "warn");
-    unsubAll(() => {
-      endQuietly(() => {
-        delayedReconnect();
-      });
-    });
+    logger("mqtt force cycle begin", "warn");
+    unsubAll(() => endQuietly(() => delayedReconnect()));
   }
+
   return function (callback) {
     class MessageEmitter extends EventEmitter {
       stopListening(callback2) {
         const cb = callback2 || function () { };
-        logger("MQTT stop requested", "info");
+        logger("mqtt stop requested", "info");
         globalCallback = identity;
+
         if (ctx._autoCycleTimer) {
           clearInterval(ctx._autoCycleTimer);
           ctx._autoCycleTimer = null;
-          logger("MQTT auto-cycle cleared", "info");
+          logger("mqtt auto-cycle cleared", "info");
         }
+
         ctx._ending = true;
-        unsubAll(() => {
-          endQuietly(() => {
-            logger("MQTT stopped", "info");
-            cb();
-            delayedReconnect();
-          });
-        });
+        unsubAll(() => endQuietly(() => {
+          logger("mqtt stopped", "info");
+          cb();
+          conf = mqttConf(ctx, conf);
+          if (conf.reconnectAfterStop) delayedReconnect();
+        }));
       }
       async stopListeningAsync() {
         return new Promise(resolve => { this.stopListening(resolve); });
       }
     }
+
     const msgEmitter = new MessageEmitter();
     globalCallback = callback || function (error, message) {
-      if (error) { logger("MQTT emit error", "error"); return msgEmitter.emit("error", error); }
+      if (error) { logger("mqtt emit error", "error"); return msgEmitter.emit("error", error); }
       msgEmitter.emit("message", message);
     };
+
+    conf = mqttConf(ctx, conf);
     if (!ctx.firstListen) ctx.lastSeqId = null;
     ctx.syncToken = undefined;
     ctx.t_mqttCalled = false;
-    if (ctx._autoCycleTimer) {
-      clearInterval(ctx._autoCycleTimer);
-      ctx._autoCycleTimer = null;
+
+    if (ctx._autoCycleTimer) { clearInterval(ctx._autoCycleTimer); ctx._autoCycleTimer = null; }
+    if (conf.cycleMs && conf.cycleMs > 0) {
+      ctx._autoCycleTimer = setInterval(forceCycle, conf.cycleMs);
+      logger(`mqtt auto-cycle enabled ${conf.cycleMs}ms`, "info");
+    } else {
+      logger("mqtt auto-cycle disabled", "info");
     }
-    ctx._autoCycleTimer = setInterval(forceCycle, 60 * 60 * 1000);
-    logger("MQTT auto-cycle enabled 3600000ms", "info");
+
     if (!ctx.firstListen || !ctx.lastSeqId) getSeqIDWrapper();
     else {
-      logger("MQTT starting listenMqtt", "info");
+      logger("mqtt starting listenMqtt", "info");
       listenMqtt(defaultFuncs, api, ctx, globalCallback);
     }
+
     api.stopListening = msgEmitter.stopListening;
     api.stopListeningAsync = msgEmitter.stopListeningAsync;
     return msgEmitter;