@dongdev/fca-unofficial 2.0.13 → 2.0.15

package/CHANGELOG.md

@@ -74,3 +74,9 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v2.0.12 - 2025-10-07
 - Hotfix / auto bump
+
+## v2.0.13 - 2025-10-07
+- Hotfix / auto bump
+
+## v2.0.14 - 2025-10-07
+- Hotfix / auto bump

package/module/loginHelper.js

@@ -543,7 +543,8 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
           clientID: ((Math.random() * 2147483648) | 0).toString(16),
           clientId: getFrom(html, '["MqttWebDeviceID",[],{"clientID":"', '"}') || "",
           wsReqNumber: 0,
-          wsTaskNumber: 0
+          wsTaskNumber: 0,
+          tasks: new Map()
         };
         ctx.performAutoLogin = async () => {
           try {

package/package.json

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

package/src/api/messaging/sendTypingIndicator.js

@@ -1,110 +1,67 @@
 "use strict";
-
-const log = require("npmlog");
-const { getType } = require("../../utils/format");
-const { parseAndCheckLogin } = require("../../utils/client");
-module.exports = function(defaultFuncs, api, ctx) {
-  function makeTypingIndicator(typ, threadID, callback, isGroup) {
-    const form = {
-      typ: +typ,
-      to: "",
-      source: "mercury-chat",
-      thread: threadID
-    };
-
-    // Check if thread is a single person chat or a group chat
-    // More info on this is in api.sendMessage
-    if (getType(isGroup) == "Boolean") {
-      if (!isGroup) {
-        form.to = threadID;
-      }
-      defaultFuncs
-        .post("https://www.facebook.com/ajax/messaging/typ.php", ctx.jar, form)
-        .then(parseAndCheckLogin(ctx, defaultFuncs))
-        .then(function(resData) {
-          if (resData.error) {
-            throw resData;
-          }
-
-          return callback();
-        })
-        .catch(function(err) {
-          log.error("sendTypingIndicator", err);
-          if (getType(err) == "Object" && err.error === "Not logged in") {
-            ctx.loggedIn = false;
-          }
-          return callback(err);
-        });
-    } else {
-      api.getUserInfo(threadID, function(err, res) {
-        if (err) {
-          return callback(err);
-        }
-
-        // If id is single person chat
-        if (Object.keys(res).length > 0) {
-          form.to = threadID;
-        }
-
-        defaultFuncs
-          .post(
-            "https://www.facebook.com/ajax/messaging/typ.php",
-            ctx.jar,
-            form
-          )
-          .then(parseAndCheckLogin(ctx, defaultFuncs))
-          .then(function(resData) {
-            if (resData.error) {
-              throw resData;
-            }
-
-            return callback();
-          })
-          .catch(function(err) {
-            log.error("sendTypingIndicator", err);
-            if (
-              getType(err) == "Object" &&
-              err.error === "Not logged in."
-            ) {
-              ctx.loggedIn = false;
-            }
-            return callback(err);
-          });
-      });
+const { getType } = require("../../utils/format.js");
+module.exports = function (defaultFuncs, api, ctx) {
+  return function sendTyping(threadID, isTyping, options, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (getType(options) == "Function" || getType(options) == "AsyncFunction") {
+      callback = options;
+      options = {};
     }
-  }
-
-  return function sendTypingIndicator(threadID, callback, isGroup) {
-    if (
-      getType(callback) !== "Function" &&
-      getType(callback) !== "AsyncFunction"
-    ) {
-      if (callback) {
-        log.warn(
-          "sendTypingIndicator",
-          "callback is not a function - ignoring."
-        );
-      }
-      callback = () => {};
+    options = options || {};
+    if (!callback || getType(callback) != "Function" && getType(callback) != "AsyncFunction") {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    if (!threadID) {
+      return callback(new Error("threadID is required"));
     }
-
-    makeTypingIndicator(true, threadID, callback, isGroup);
-
-    return function end(cb) {
-      if (
-        getType(cb) !== "Function" &&
-        getType(cb) !== "AsyncFunction"
-      ) {
-        if (cb) {
-          log.warn(
-            "sendTypingIndicator",
-            "callback is not a function - ignoring."
-          );
-        }
-        cb = () => {};
+    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
+    threadIDs.forEach(tid => {
+      var isGroupThread = getType(tid) === "Array" ? 0 : 1;
+      var threadType = isGroupThread ? 2 : 1;
+      var duration = options.duration || 10000;
+      var autoStop = options.autoStop !== false;
+      var attribution = options.type || 0;
+      const publishTypingStatus = (isTypingStatus) => {
+        ctx.mqttClient.publish('/ls_req',
+          JSON.stringify({
+            app_id: "772021112871879",
+            payload: JSON.stringify({
+              label: "3",
+              payload: JSON.stringify({
+                "thread_key": parseInt(tid),
+                "is_group_thread": isGroupThread,
+                "is_typing": isTypingStatus ? 1 : 0,
+                "attribution": attribution,
+                "sync_group": 1,
+                "thread_type": threadType
+              }),
+              version: "8965252033599983"
+            }),
+            request_id: ++ctx.req_ID,
+            type: 4
+          }),
+          {
+            qos: 1,
+            retain: false,
+          }
+        );
+      };
+      publishTypingStatus(isTyping);
+      if (isTyping && autoStop) {
+        setTimeout(() => {
+          publishTypingStatus(false);
+        }, duration);
       }
-
-      makeTypingIndicator(false, threadID, cb, isGroup);
-    };
+    });
+    callback(null, true);
+    return returnPromise;
   };
 };

package/src/api/messaging/setMessageReaction.js

@@ -1,105 +1,76 @@
 "use strict";
 
-const log = require("npmlog");
+const logger = require("../../../func/logger");
 const { generateOfflineThreadingID, getCurrentTimestamp } = require("../../utils/format");
-const { parseAndCheckLogin } = require("../../utils/client");
 
 module.exports = function (defaultFuncs, api, ctx) {
-  function setMessageReactionNoMqtt(reaction, messageID, threadID, callback) {
-    let resolveFunc = function () { };
-    let rejectFunc = function () { };
-    const returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-    if (!callback) {
-      callback = function (err) {
-        if (err) return rejectFunc(err);
-        resolveFunc();
-      };
-    }
-    const variables = {
-      data: {
-        client_mutation_id: ctx.clientMutationId++,
-        actor_id: ctx.userID,
-        action: reaction === "" ? "REMOVE_REACTION" : "ADD_REACTION",
-        message_id: messageID,
-        reaction: reaction
-      }
-    };
-    const qs = {
-      doc_id: "1491398900900362",
-      variables: JSON.stringify(variables),
-      dpr: 1
-    };
-    defaultFuncs
-      .postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, qs)
-      .then(parseAndCheckLogin(ctx.jar, defaultFuncs))
-      .then(function (resData) {
-        if (!resData) throw { error: "setReaction returned empty object." };
-        if (resData.error) throw resData;
-        callback(null);
-      })
-      .catch(function (err) {
-        log.error("setReaction", err);
-        return callback(err);
-      });
-    return returnPromise;
-  }
-
-  function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
-    if (!ctx.mqttClient) return setMessageReactionNoMqtt(reaction, messageID, callback);
+  return function setMessageReaction(reaction, messageID, threadID, callback) {
     return new Promise((resolve, reject) => {
-      try {
-        ctx.wsReqNumber += 1;
-        const taskNumber = ++ctx.wsTaskNumber;
-        const taskPayload = {
-          thread_key: threadID,
-          timestamp_ms: getCurrentTimestamp(),
-          message_id: messageID,
-          reaction: reaction,
-          actor_id: ctx.userID,
-          reaction_style: null,
-          sync_group: 1,
-          send_attribution: Math.random() < 0.5 ? 65537 : 524289
-        };
-        const task = {
-          failure_count: null,
-          label: "29",
-          payload: JSON.stringify(taskPayload),
-          queue_name: JSON.stringify(["reaction", messageID]),
-          task_id: taskNumber
-        };
-        const content = {
-          app_id: "2220391788200892",
-          payload: JSON.stringify({
-            data_trace_id: null,
-            epoch_id: parseInt(generateOfflineThreadingID()),
-            tasks: [task],
-            version_id: "7158486590867448"
-          }),
-          request_id: ctx.wsReqNumber,
-          type: 3
-        };
-        const internalCb = (err) => {
-          if (typeof callback === "function") callback(err);
-          if (err) return reject(err);
-          return resolve();
-        };
-        ctx.tasks.set(taskNumber, { type: "set_message_reaction", callback: internalCb });
-        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false });
-        if (typeof callback !== "function") resolve();
-      } catch (e) {
-        if (typeof callback === "function") callback(e);
-        reject(e);
+      if (!ctx.mqttClient) {
+        const err = new Error("MQTT client not connected");
+        if (typeof callback === 'function') callback(err);
+        return reject(err);
+      }
+      if (!reaction || !messageID || !threadID) {
+        const err = new Error("Missing required parameters");
+        if (typeof callback === 'function') callback(err);
+        return reject(err);
       }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const taskPayload = {
+        thread_key: threadID,
+        timestamp_ms: getCurrentTimestamp(),
+        message_id: messageID,
+        reaction: reaction,
+        actor_id: ctx.userID,
+        reaction_style: null,
+        sync_group: 1,
+        send_attribution: 65537,
+        dataclass_params: null,
+        attachment_fbid: null
+      };
+      const task = {
+        failure_count: null,
+        label: "29",
+        payload: JSON.stringify(taskPayload),
+        queue_name: JSON.stringify(["reaction", messageID]),
+        task_id: taskID,
+      };
+      const mqttForm = {
+        app_id: "772021112871879",
+        payload: JSON.stringify({
+          data_trace_id: null,
+          epoch_id: parseInt(generateOfflineThreadingID()),
+          tasks: [task],
+          version_id: "25376272951962053"
+        }),
+        request_id: reqID,
+        type: 3
+      };
+      const handleResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let json;
+        try {
+          json = JSON.parse(message.toString());
+          json.payload = JSON.parse(json.payload);
+        } catch {
+          return;
+        }
+        if (json.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", handleResponse);
+        if (typeof callback === 'function') callback(null, { success: true });
+        return resolve({ success: true });
+      };
+      ctx.mqttClient.on("message", handleResponse);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(mqttForm), { qos: 1, retain: false }, (err) => {
+        if (err) {
+          ctx.mqttClient.removeListener("message", handleResponse);
+          logger("setMessageReaction" + err, "error");
+          if (typeof callback === 'function') callback(err);
+          return reject(err);
+        }
+      });
     });
-  }
-
-  return function setMessageReaction(reaction, messageID, threadID, callback) {
-    if (ctx.mqttClient) {
-      return setMessageReactionMqtt(reaction, messageID, threadID, callback);
-    }
-    return setMessageReactionNoMqtt(reaction, messageID, threadID, callback);
   };
 };

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

@@ -81,9 +81,10 @@ module.exports = function createListenMqtt(deps) {
         return;
       }
       logger(`MQTT error: ${msg}`, "error");
-      mqttClient.end();
-      logger("MQTT autoReconnect listenMqtt() in 2000ms", "warn");
-      setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), 2000);
+      // mqttClient.end();
+      // logger("MQTT autoReconnect listenMqtt() in 2000ms", "warn");
+      // setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), 2000);
+      process.exit(1);
     });
     mqttClient.on("connect", function () {
       if (process.env.OnStatus === undefined) {