@dongdev/fca-unofficial 2.0.12 → 2.0.14

package/src/api/messaging/sendMessage.js

@@ -304,72 +304,62 @@ module.exports = function (defaultFuncs, api, ctx) {
         resolveFunc(data);
       };
     }
-
-    try {
-      const msgType = getType(msg);
-      const threadIDType = getType(threadID);
-      const messageIDType = getType(replyToMessage);
-      if (msgType !== "String" && msgType !== "Object") return callback({ error: "Message should be of type string or object and not " + msgType + "." });
-      if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String") return callback({ error: "ThreadID should be of type number, string, or array and not " + threadIDType + "." });
-      if (replyToMessage && messageIDType !== "String") return callback({ error: "MessageID should be of type string and not " + threadIDType + "." });
-      if (msgType === "String") msg = { body: msg };
-
-      const disallowedProperties = Object.keys(msg).filter(prop => !allowedProperties[prop]);
-      if (disallowedProperties.length > 0) return callback({ error: "Disallowed props: `" + disallowedProperties.join(", ") + "`" });
-
-      const messageAndOTID = generateOfflineThreadingID();
-      const form = {
-        client: "mercury",
-        action_type: "ma-type:user-generated-message",
-        author: "fbid:" + ctx.userID,
-        timestamp: Date.now(),
-        timestamp_absolute: "Today",
-        timestamp_relative: generateTimestampRelative(),
-        timestamp_time_passed: "0",
-        is_unread: false,
-        is_cleared: false,
-        is_forward: false,
-        is_filtered_content: false,
-        is_filtered_content_bh: false,
-        is_filtered_content_account: false,
-        is_filtered_content_quasar: false,
-        is_filtered_content_invalid_app: false,
-        is_spoof_warning: false,
-        source: "source:chat:web",
-        "source_tags[0]": "source:chat",
-        body: msg.body ? msg.body.toString() : "",
-        html_body: false,
-        ui_push_phase: "V3",
-        status: "0",
-        offline_threading_id: messageAndOTID,
-        message_id: messageAndOTID,
-        threading_id: generateThreadingID(ctx.clientID),
-        ephemeral_ttl_mode: "0",
-        manual_retry_cnt: "0",
-        signatureID: getSignatureID(),
-        replied_to_message_id: replyToMessage ? replyToMessage.toString() : ""
-      };
-      applyPageAuthor(form, msg);
-      handleLocation(msg, form, callback, () =>
-        handleSticker(msg, form, callback, () =>
-          handleAttachment(msg, form, callback, () =>
-            handleUrl(msg, form, callback, () =>
-              handleEmoji(msg, form, callback, () =>
-                handleMention(msg, form, callback, () => {
-                  finalizeHasAttachment(form);
-                  send(form, threadID, messageAndOTID, callback, isGroup);
-                })
-              )
+    const msgType = getType(msg);
+    const threadIDType = getType(threadID);
+    const messageIDType = getType(replyToMessage);
+    if (msgType !== "String" && msgType !== "Object") return callback({ error: "Message should be of type string or object and not " + msgType + "." });
+    if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String") return callback({ error: "ThreadID should be of type number, string, or array and not " + threadIDType + "." });
+    if (replyToMessage && messageIDType !== "String") return callback({ error: "MessageID should be of type string and not " + threadIDType + "." });
+    if (msgType === "String") msg = { body: msg };
+    const disallowedProperties = Object.keys(msg).filter(prop => !allowedProperties[prop]);
+    if (disallowedProperties.length > 0) return callback({ error: "Disallowed props: `" + disallowedProperties.join(", ") + "`" });
+    const messageAndOTID = generateOfflineThreadingID();
+    const form = {
+      client: "mercury",
+      action_type: "ma-type:user-generated-message",
+      author: "fbid:" + ctx.userID,
+      timestamp: Date.now(),
+      timestamp_absolute: "Today",
+      timestamp_relative: generateTimestampRelative(),
+      timestamp_time_passed: "0",
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_filtered_content_bh: false,
+      is_filtered_content_account: false,
+      is_filtered_content_quasar: false,
+      is_filtered_content_invalid_app: false,
+      is_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      body: msg.body ? msg.body.toString() : "",
+      html_body: false,
+      ui_push_phase: "V3",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: generateThreadingID(ctx.clientID),
+      ephemeral_ttl_mode: "0",
+      manual_retry_cnt: "0",
+      signatureID: getSignatureID(),
+      replied_to_message_id: replyToMessage ? replyToMessage.toString() : ""
+    };
+    applyPageAuthor(form, msg);
+    handleLocation(msg, form, callback, () =>
+      handleSticker(msg, form, callback, () =>
+        handleAttachment(msg, form, callback, () =>
+          handleUrl(msg, form, callback, () =>
+            handleEmoji(msg, form, callback, () =>
+              handleMention(msg, form, callback, () => {
+                finalizeHasAttachment(form);
+                send(form, threadID, messageAndOTID, callback, isGroup);
+              })
             )
           )
         )
-      );
-    } catch (e) {
-      log.error("sendMessage", e);
-      if (getType(e) === "Object" && e.error === "Not logged in.") ctx.loggedIn = false;
-      return callback(e);
-    }
-
+      )
+    );
     return returnPromise;
   };
 

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

@@ -75,17 +75,15 @@ module.exports = function createListenMqtt(deps) {
     const mqttClient = ctx.mqttClient;
     global.mqttClient = mqttClient;
     mqttClient.on("error", function (err) {
-      logger("listenMqtt" + err, "error");
-      mqttClient.end();
-      if (ctx.globalOptions.autoReconnect) {
-        listenMqtt(defaultFuncs, api, ctx, globalCallback);
-      } else {
-        // utils.checkLiveCookie(ctx, defaultFuncs).then(res => {
-        //   globalCallback({ type: "stop_listen", error: "Connection refused: Server unavailable" }, null);
-        // }).catch(err => {
-        //   globalCallback({ type: "account_inactive", error: "Maybe your account is blocked by facebook, please login and check at https://facebook.com" }, null);
-        // });
+      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");
+        return;
       }
+      logger(`MQTT error: ${msg}`, "error");
+      mqttClient.end();
+      logger("MQTT autoReconnect listenMqtt() in 2000ms", "warn");
+      setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), 2000);
     });
     mqttClient.on("connect", function () {
       if (process.env.OnStatus === undefined) {
@@ -174,7 +172,7 @@ module.exports = function createListenMqtt(deps) {
         return;
       }
     });
-    mqttClient.on("close", function () {});
-    mqttClient.on("disconnect", () => {});
+    mqttClient.on("close", function () { });
+    mqttClient.on("disconnect", () => { });
   };
 };

package/src/api/socket/listenMqtt.js

@@ -3,7 +3,7 @@ const mqtt = require("mqtt");
 const WebSocket = require("ws");
 const HttpsProxyAgent = require("https-proxy-agent");
 const EventEmitter = require("events");
-const logger = require("../../../func/logger.js");
+const logger = require("../../../func/logger");
 const { parseAndCheckLogin } = require("../../utils/client");
 const { buildProxy, buildStream } = require("./detail/buildStream");
 const { topics } = require("./detail/constants");
@@ -14,63 +14,117 @@ const markDelivery = require("./core/markDelivery");
 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({ listenMqtt });
+const getSeqIDFactory = createGetSeqID({ parseAndCheckLogin, listenMqtt, logger });
 module.exports = function (defaultFuncs, api, ctx) {
-  const identity = function () {};
+  const identity = function () { };
   let globalCallback = identity;
   function getSeqIDWrapper() {
     const form = {
-      av: ctx.globalOptions.pageID,
+      av: ctx.userID,
       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 } }
       })
     };
-    return getSeqIDFactory(defaultFuncs, api, ctx, globalCallback, form);
+    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");
+    });
+  }
+  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;
+    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();
+        }
+      });
+    });
+  }
+  function endQuietly(next) {
+    const finish = () => {
+      ctx.mqttClient = undefined;
+      ctx.lastSeqId = null;
+      ctx.syncToken = undefined;
+      ctx.t_mqttCalled = false;
+      ctx._ending = false;
+      next && next();
+    };
+    try {
+      if (ctx.mqttClient) {
+        if (isConnected()) {
+          try { ctx.mqttClient.publish("/browser_close", "{}"); } catch (_) { }
+        }
+        ctx.mqttClient.end(true, finish);
+      } else finish();
+    } catch (_) {
+      finish();
+    }
+  }
+  function delayedReconnect() {
+    logger("MQTT reconnect in 2000ms", "info");
+    setTimeout(() => getSeqIDWrapper(), 2000);
+  }
+  function forceCycle() {
+    ctx._ending = true;
+    logger("MQTT force cycle begin", "warn");
+    unsubAll(() => {
+      endQuietly(() => {
+        delayedReconnect();
+      });
+    });
   }
   return function (callback) {
     class MessageEmitter extends EventEmitter {
       stopListening(callback2) {
-        const cb = callback2 || function () {};
+        const cb = callback2 || function () { };
+        logger("MQTT stop requested", "info");
         globalCallback = identity;
-        if (ctx.mqttClient) {
-          ctx.mqttClient.unsubscribe("/webrtc");
-          ctx.mqttClient.unsubscribe("/rtc_multi");
-          ctx.mqttClient.unsubscribe("/onevc");
-          ctx.mqttClient.publish("/browser_close", "{}");
-          ctx.mqttClient.end(false, function (...data) {
-            cb(data);
-            ctx.mqttClient = undefined;
-          });
+        if (ctx._autoCycleTimer) {
+          clearInterval(ctx._autoCycleTimer);
+          ctx._autoCycleTimer = null;
+          logger("MQTT auto-cycle cleared", "info");
         }
+        ctx._ending = true;
+        unsubAll(() => {
+          endQuietly(() => {
+            logger("MQTT stopped", "info");
+            cb();
+            delayedReconnect();
+          });
+        });
       }
       async stopListeningAsync() {
-        return new Promise(resolve => {
-          this.stopListening(resolve);
-        });
+        return new Promise(resolve => { this.stopListening(resolve); });
       }
     }
     const msgEmitter = new MessageEmitter();
     globalCallback = callback || function (error, message) {
-      if (error) {
-        return msgEmitter.emit("error", error);
-      }
+      if (error) { logger("MQTT emit error", "error"); return msgEmitter.emit("error", error); }
       msgEmitter.emit("message", message);
     };
     if (!ctx.firstListen) ctx.lastSeqId = null;
     ctx.syncToken = undefined;
     ctx.t_mqttCalled = false;
-    if (!ctx.firstListen || !ctx.lastSeqId) {
-      getSeqIDWrapper();
-    } else {
+    if (ctx._autoCycleTimer) {
+      clearInterval(ctx._autoCycleTimer);
+      ctx._autoCycleTimer = null;
+    }
+    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");
       listenMqtt(defaultFuncs, api, ctx, globalCallback);
     }
     api.stopListening = msgEmitter.stopListening;