@eryxenx/fca 1.0.0

package/src/api/messaging/editMessage.js

@@ -0,0 +1,105 @@
+"use strict";
+
+function generateOfflineThreadingId() {
+  const now = Date.now();
+  const rand = Math.floor(Math.random() * 4294967295);
+  return String((BigInt(now) << BigInt(22)) | BigInt(rand & 0x3FFFFF));
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function editMessage(text, messageID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!messageID || !text) {
+      callback({ error: "messageID and text are required." });
+      return returnPromise;
+    }
+
+    const threadID = api.e2ee && typeof api.e2ee.getThreadIdForMessage === "function"
+      ? api.e2ee.getThreadIdForMessage(messageID) : null;
+    const isE2EEDM = threadID && ctx.threadTypes && ctx.threadTypes[String(threadID)] === 'dm' &&
+      api.e2ee && typeof api.e2ee.isConnected === "function" && api.e2ee.isConnected();
+    const isE2EEGroup = threadID && typeof api.e2ee?.isKnownE2EEGroup === "function" && api.e2ee.isKnownE2EEGroup(String(threadID)) &&
+      api.e2ee && typeof api.e2ee.isConnected === "function" && api.e2ee.isConnected();
+    const isE2EEThread = isE2EEDM || isE2EEGroup;
+
+    if (isE2EEThread) {
+      api.e2ee.editMessage(String(threadID), messageID, text)
+        .then((result) => callback(undefined, result))
+        .catch((err) => callback(err));
+      return returnPromise;
+    }
+
+    if (!ctx.mqttClient) {
+      callback({ error: "Not connected to MQTT" });
+      return returnPromise;
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const reqID = ctx.wsReqNumber;
+
+    const context = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingId()),
+        tasks: [{
+          failure_count: null,
+          label: "742",
+          payload: JSON.stringify({
+            message_id: messageID,
+            text: text,
+          }),
+          queue_name: "edit_message",
+          task_id: ctx.wsTaskNumber,
+        }],
+        version_id: "6903494529735864",
+      }),
+      request_id: reqID,
+      type: 3
+    };
+
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(context), { qos: 1, retain: false });
+
+    const timeout = setTimeout(() => {
+      ctx.mqttClient.removeListener("message", handleRes);
+      resolveFunc({ messageID, body: text });
+    }, 5000);
+
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp") return;
+      try {
+        let jsonMsg = JSON.parse(message.toString());
+        if (!jsonMsg.payload) return;
+        jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        if (jsonMsg.request_id != reqID) return;
+
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+
+        callback(undefined, { messageID, body: text });
+      } catch (e) {
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+        callback(undefined, { messageID, body: text });
+      }
+    };
+
+    ctx.mqttClient.on("message", handleRes);
+    return returnPromise;
+  };
+};

package/src/api/messaging/forwardAttachment.js

@@ -0,0 +1,57 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function forwardMessage(threadID, forwardedMsgID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    if (!ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      callback?.(err);
+      rejectFunc(err);
+      return returnPromise;
+    }
+    let count_req = 0
+    const payload = {
+      epoch_id: generateOfflineThreadingID(),
+      tasks: [
+        {
+          failure_count: null,
+          label: "46",
+          payload: JSON.stringify({
+            thread_id: threadID,
+            otid: generateOfflineThreadingID(),
+            source: 65544,
+            send_type: 5,
+            sync_group: 1,
+            mark_thread_read: 0,
+            forwarded_msg_id: forwardedMsgID,
+            strip_forwarded_msg_caption: 0,
+            initiating_source: 1
+          }),
+          queue_name: threadID,
+          task_id: Math.floor(Math.random() * 1001)
+        }
+      ],
+      version_id: "8768858626531631"
+    };
+    const form = JSON.stringify({
+      app_id: "772021112871879",
+      payload: JSON.stringify(payload),
+      "request_id": ++count_req,
+      "type": 3
+    });
+    ctx.mqttClient.publish("/ls_req", form);
+    return returnPromise;
+  };
+};

package/src/api/messaging/forwardMessage.js

@@ -0,0 +1,134 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+
+/**
+ * Forward a message to one or multiple threads.
+ * @param {string} messageID - The ID of the message to forward.
+ * @param {string|string[]} threadID - Thread ID or array of thread IDs to forward to.
+ * @param {function} [callback] - Optional callback(err, results).
+ * @returns {Promise}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function forwardMessage(messageID, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!messageID || !threadID) {
+      const err = { error: "messageID and threadID are required." };
+      callback(err);
+      return returnPromise;
+    }
+
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      const err = { error: "Not connected to MQTT. Please try again later." };
+      callback(err);
+      return returnPromise;
+    }
+
+    // Support forwarding to multiple threads
+    const targets = Array.isArray(threadID) ? threadID : [threadID];
+
+    const results = [];
+    const errors = [];
+
+    for (const tid of targets) {
+      try {
+        await new Promise((res, rej) => {
+          const reqID = ++ctx.wsReqNumber;
+          const taskID = ++ctx.wsTaskNumber;
+
+          const taskPayload = {
+            thread_id: String(tid),
+            otid: generateOfflineThreadingID(),
+            source: 65544,
+            send_type: 5,
+            sync_group: 1,
+            mark_thread_read: 0,
+            forwarded_msg_id: String(messageID),
+            strip_forwarded_msg_caption: 0,
+            initiating_source: 1
+          };
+
+          const content = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify({
+              data_trace_id: null,
+              epoch_id: String((BigInt(Date.now()) << 22n)),
+              tasks: [
+                {
+                  failure_count: null,
+                  label: "46",
+                  payload: JSON.stringify(taskPayload),
+                  queue_name: String(tid),
+                  task_id: taskID
+                }
+              ],
+              version_id: "6903494529735864"
+            }),
+            request_id: reqID,
+            type: 3
+          };
+
+          try {
+            ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false });
+          } catch (err) {
+            errors.push({ threadID: tid, error: err.message || String(err) });
+            return res(); // continue to next thread
+          }
+
+          const timeout = setTimeout(() => {
+            ctx.mqttClient.removeListener("message", handleRes);
+            errors.push({ threadID: tid, error: "forwardMessage timed out." });
+            res();
+          }, 15000);
+
+          const handleRes = (topic, message) => {
+            if (topic !== "/ls_resp") return;
+            try {
+              let jsonMsg = JSON.parse(message.toString());
+              if (!jsonMsg.payload) return;
+              jsonMsg.payload = JSON.parse(jsonMsg.payload);
+              if (jsonMsg.request_id !== reqID) return;
+
+              clearTimeout(timeout);
+              ctx.mqttClient.removeListener("message", handleRes);
+
+              results.push({ threadID: tid, messageID: String(messageID) });
+              res();
+            } catch (err) {
+              clearTimeout(timeout);
+              ctx.mqttClient.removeListener("message", handleRes);
+              errors.push({ threadID: tid, error: err.message || String(err) });
+              res();
+            }
+          };
+
+          ctx.mqttClient.on("message", handleRes);
+        });
+      } catch (err) {
+        errors.push({ threadID: tid, error: err.message || String(err) });
+      }
+    }
+
+    const finalResult = { success: results, failed: errors };
+
+    if (errors.length > 0 && results.length === 0) {
+      callback({ error: "All forwards failed.", details: errors });
+    } else {
+      callback(null, finalResult);
+    }
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/getEmojiUrl.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const util = require("util");
+
+module.exports = function() {
+  return function getEmojiUrl(c, size, pixelRatio) {
+    /*
+		 Resolves Facebook Messenger emoji image asset URL for an emoji character.
+		 Supported sizes are 32, 64, and 128.
+		 Supported pixel ratios are '1.0' and '1.5' (possibly more; haven't tested)
+		 */
+    const baseUrl = "https://static.xx.fbcdn.net/images/emoji.php/v8/z%s/%s";
+    pixelRatio = pixelRatio || "1.0";
+
+    const ending = util.format(
+      "%s/%s/%s.png",
+      pixelRatio,
+      size,
+      c.codePointAt(0).toString(16)
+    );
+    let base = 317426846;
+    for (let i = 0; i < ending.length; i++) {
+      base = (base << 5) - base + ending.charCodeAt(i);
+    }
+
+    const hashed = (base & 255).toString(16);
+    return util.format(baseUrl, hashed, ending);
+  };
+};

package/src/api/messaging/getFriendsList.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { formatID } = require("../../utils/format");
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const GENDERS = {
+  0: "unknown",
+  1: "female_singular",
+  2: "male_singular",
+  3: "female_singular_guess",
+  4: "male_singular_guess",
+  5: "mixed",
+  6: "neuter_singular",
+  7: "unknown_singular",
+  8: "female_plural",
+  9: "male_plural",
+  10: "neuter_plural",
+  11: "unknown_plural"
+};
+
+function formatData(obj) {
+  return Object.keys(obj).map(function(key) {
+    const user = obj[key];
+    return {
+      alternateName: user.alternateName,
+      firstName: user.firstName,
+      gender: GENDERS[user.gender],
+      userID: formatID(user.id.toString()),
+      isFriend: user.is_friend != null && user.is_friend ? true : false,
+      fullName: user.name,
+      profilePicture: user.thumbSrc,
+      type: user.type,
+      profileUrl: user.uri,
+      vanity: user.vanity,
+      isBirthday: !!user.is_birthday
+    };
+  });
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getFriendsList(callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    defaultFuncs
+      .postFormData(
+        "https://www.facebook.com/chat/user_info_all",
+        ctx.jar,
+        {},
+        { viewer: ctx.userID }
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (!resData) {
+          throw { error: "getFriendsList returned empty object." };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        callback(null, formatData(resData.payload));
+      })
+      .catch(function(err) {
+        log.error("getFriendsList", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};