surya-sahil-fca 1.0.0

package/src/api/messaging/sendMessage.js

@@ -0,0 +1,272 @@
+/**
+ * Create by surya-sahil (Surya Sahil)
+ * Don't change credit
+ * Send a message using MQTT.
+ * @param {string} text - The text of the message to send.
+ * @param {string} threadID - The ID of the thread to send the message to.
+ * @param {string} [msgReplace] - Optional. The message ID of the message to replace.
+ * @param {Array<Buffer|Stream>} [attachments] - Optional. The attachments to send with the message.
+ * @param {function} [callback] - Optional. The callback function to call when the message is sent.
+ * @returns {Promise<object>} A promise that resolves with the bodies of the sent message.
+ */
+
+"use strict";
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+const { isReadableStream } = require("../../utils/constants");
+const { generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const hasLinks = s => typeof s === "string" && /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(s);
+  const emojiSizes = { small: 1, medium: 2, large: 3 };
+
+  async function uploadAttachment(streams) {
+    const uploads = streams.map(stream => {
+      if (!isReadableStream(stream)) throw { error: "Attachment should be a readable stream and not " + getType(stream) + "." };
+      const form = { farr: stream };
+      return defaultFuncs
+        .postFormData("https://www.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+        .then(parseAndCheckLogin(ctx, defaultFuncs))
+        .then(resData => {
+          if (resData.error) throw resData;
+          return resData.payload.metadata[0];
+        });
+    });
+    return Promise.all(uploads);
+  }
+
+  function extractIdsFromPayload(payload) {
+    let messageID = null;
+    let threadID = null;
+    function walk(n) {
+      if (Array.isArray(n)) {
+        if (n[0] === 5 && (n[1] === "replaceOptimsiticMessage" || n[1] === "replaceOptimisticMessage")) {
+          messageID = String(n[3]);
+        }
+        if (n[0] === 5 && n[1] === "writeCTAIdToThreadsTable") {
+          const a = n[2];
+          if (Array.isArray(a) && a[0] === 19) threadID = String(a[1]);
+        }
+        for (const x of n) walk(x);
+      }
+    }
+    walk(payload?.step);
+    return { threadID, messageID };
+  }
+
+  function publishWithAck(content, text, reqID, callback) {
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const cleanup = () => {
+        if (done) return;
+        done = true;
+        ctx.mqttClient.removeListener("message", handleRes);
+      };
+      const handleRes = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        const { threadID, messageID } = extractIdsFromPayload(jsonMsg.payload);
+        const bodies = { body: text || null, messageID, threadID };
+        cleanup();
+        callback && callback(undefined, bodies);
+        resolve(bodies);
+      };
+      ctx.mqttClient.on("message", handleRes);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, err => {
+        if (err) {
+          cleanup();
+          callback && callback(err);
+          reject(err);
+        }
+      });
+      setTimeout(() => {
+        if (done) return;
+        cleanup();
+        const err = { error: "Timeout waiting for ACK" };
+        callback && callback(err);
+        reject(err);
+      }, 15000);
+    });
+  }
+
+  function buildMentionData(msg, baseBody) {
+    if (!msg.mentions || !Array.isArray(msg.mentions) || !msg.mentions.length) return null;
+    const base = typeof baseBody === "string" ? baseBody : "";
+    const ids = [];
+    const offsets = [];
+    const lengths = [];
+    const types = [];
+    let cursor = 0;
+    for (const m of msg.mentions) {
+      const raw = String(m.tag || "");
+      const name = raw.replace(/^@+/, "");
+      const start = Number.isInteger(m.fromIndex) ? m.fromIndex : cursor;
+      let idx = base.indexOf(raw, start);
+      let adj = 0;
+      if (idx === -1) {
+        idx = base.indexOf(name, start);
+        adj = 0;
+      } else {
+        adj = raw.length - name.length;
+      }
+      if (idx < 0) {
+        idx = 0;
+        adj = 0;
+      }
+      const off = idx + adj;
+      ids.push(String(m.id || 0));
+      offsets.push(off);
+      lengths.push(name.length);
+      types.push("p");
+      cursor = off + name.length;
+    }
+    return {
+      mention_ids: ids.join(","),
+      mention_offsets: offsets.join(","),
+      mention_lengths: lengths.join(","),
+      mention_types: types.join(",")
+    };
+  }
+
+  function coerceMsg(x) {
+    if (x == null) return { body: "" };
+    if (typeof x === "string") return { body: x };
+    if (typeof x === "object") return x;
+    return { body: String(x) };
+  }
+
+  return async function sendMessageMqtt(msg, threadID, callback, replyToMessage) {
+    if (typeof threadID === "function") return threadID({ error: "Pass a threadID as a second argument." });
+    if (typeof callback === "string" && !replyToMessage) {
+      replyToMessage = callback;
+      callback = () => { };
+    }
+    if (typeof callback !== "function") callback = () => { };
+    if (!threadID) {
+      const err = { error: "threadID is required" };
+      callback(err);
+      throw err;
+    }
+
+    const m = coerceMsg(msg);
+    const baseBody = m.body != null ? String(m.body) : "";
+    const reqID = Math.floor(100 + Math.random() * 900);
+    const epoch = (BigInt(Date.now()) << 22n).toString();
+
+    const payload0 = {
+      thread_id: String(threadID),
+      otid: generateOfflineThreadingID(),
+      source: 2097153,
+      send_type: 1,
+      sync_group: 1,
+      mark_thread_read: 1,
+      text: baseBody === "" ? null : baseBody,
+      initiating_source: 0,
+      skip_url_preview_gen: 0,
+      text_has_links: hasLinks(baseBody) ? 1 : 0,
+      multitab_env: 0,
+      metadata_dataclass: JSON.stringify({ media_accessibility_metadata: { alt_text: null } })
+    };
+
+    const mentionData = buildMentionData(m, baseBody);
+    if (mentionData) payload0.mention_data = mentionData;
+
+    if (m.sticker) {
+      payload0.send_type = 2;
+      payload0.sticker_id = m.sticker;
+    }
+
+    if (m.emoji) {
+      const size = !isNaN(m.emojiSize) ? Number(m.emojiSize) : emojiSizes[m.emojiSize || "small"] || 1;
+      payload0.send_type = 1;
+      payload0.text = m.emoji;
+      payload0.hot_emoji_size = Math.min(3, Math.max(1, size));
+    }
+
+    if (m.location && m.location.latitude != null && m.location.longitude != null) {
+      payload0.send_type = 1;
+      payload0.location_data = {
+        coordinates: { latitude: m.location.latitude, longitude: m.location.longitude },
+        is_current_location: !!m.location.current,
+        is_live_location: !!m.location.live
+      };
+    }
+
+    if (replyToMessage) {
+      payload0.reply_metadata = { reply_source_id: replyToMessage, reply_source_type: 1, reply_type: 0 };
+    }
+
+    if (m.attachment) {
+      payload0.send_type = 3;
+      if (payload0.text === "") payload0.text = null;
+      payload0.attachment_fbids = [];
+      let list = m.attachment;
+      if (getType(list) !== "Array") list = [list];
+      const idsFromPairs = [];
+      const streams = [];
+      for (const it of list) {
+        if (Array.isArray(it) && typeof it[0] === "string") {
+          idsFromPairs.push(String(it[1]));
+        } else if (isReadableStream(it)) {
+          streams.push(it);
+        }
+      }
+      if (idsFromPairs.length) payload0.attachment_fbids.push(...idsFromPairs);
+      if (streams.length) {
+        try {
+          const files = await uploadAttachment(streams);
+          for (const file of files) {
+            const key = Object.keys(file)[0];
+            payload0.attachment_fbids.push(file[key]);
+          }
+        } catch (err) {
+          log.error("uploadAttachment", err);
+          callback(err);
+          throw err;
+        }
+      }
+    }
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: {
+        tasks: [
+          {
+            label: "46",
+            payload: payload0,
+            queue_name: String(threadID),
+            task_id: 400,
+            failure_count: null
+          },
+          {
+            label: "21",
+            payload: {
+              thread_id: String(threadID),
+              last_read_watermark_ts: Date.now(),
+              sync_group: 1
+            },
+            queue_name: String(threadID),
+            task_id: 401,
+            failure_count: null
+          }
+        ],
+        epoch_id: epoch,
+        version_id: "24804310205905615",
+        data_trace_id: "#" + Buffer.from(String(Math.random())).toString("base64").replace(/=+$/g, "")
+      },
+      request_id: reqID,
+      type: 3
+    };
+    content.payload.tasks.forEach(t => (t.payload = JSON.stringify(t.payload)));
+    content.payload = JSON.stringify(content.payload);
+    return publishWithAck(content, baseBody, reqID, callback);
+  };
+};

package/src/api/messaging/sendTypingIndicator.js

@@ -0,0 +1,67 @@
+"use strict";
+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 = {};
+    }
+    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"));
+    }
+    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);
+      }
+    });
+    callback(null, true);
+    return returnPromise;
+  };
+};

package/src/api/messaging/setMessageReaction.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const logger = require("../../../func/logger");
+const { generateOfflineThreadingID, getCurrentTimestamp } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReaction(reaction, messageID, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      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);
+        }
+      });
+    });
+  };
+};

package/src/api/messaging/setTitle.js

@@ -0,0 +1,119 @@
+"use strict";
+
+const { getType, generateOfflineThreadingID, generateTimestampRelative, generateThreadingID, getCurrentTimestamp } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function setTitleNoMqtt(newTitle, threadID, callback) {
+    if (!callback && (getType(threadID) === "Function" || getType(threadID) === "AsyncFunction")) throw { error: "please pass a threadID as a second argument." };
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    var messageAndOTID = generateOfflineThreadingID();
+    var form = {
+      client: "mercury",
+      action_type: "ma-type:log-message",
+      author: "fbid:" + ctx.userID,
+      author_email: "",
+      coordinates: "",
+      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_spoof_warning: false,
+      source: "source:chat:web",
+      "source_tags[0]": "source:chat",
+      status: "0",
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: generateThreadingID(ctx.clientID),
+      manual_retry_cnt: "0",
+      thread_fbid: threadID,
+      thread_name: newTitle,
+      thread_id: threadID,
+      log_message_type: "log:thread-name"
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/set_thread_name/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error && resData.error === 1545012) throw { error: "Cannot change chat title: Not member of chat." };
+        if (resData.error && resData.error === 1545003) throw { error: "Cannot set title of single-user chat." };
+        if (resData.error) throw resData;
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("setTitle", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+  function setTitleMqtt(newTitle, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+        data
+      };
+    }
+    let count_req = 0
+    var form = JSON.stringify({
+      "app_id": "2220391788200892",
+      "payload": JSON.stringify({
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: '32',
+            payload: JSON.stringify({
+              "thread_key": threadID,
+              "thread_name": newTitle,
+              "sync_group": 1
+            }),
+            queue_name: threadID,
+            task_id: Math.random() * 1001 << 0
+          }
+        ],
+        version_id: '8798795233522156'
+      }),
+      "request_id": ++count_req,
+      "type": 3
+    });
+    mqttClient.publish('/ls_req', form);
+    return returnPromise;
+  };
+  return function setTitle(newTitle, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        setTitleMqtt(newTitle, threadID, callback);
+      } catch (e) {
+        setTitleNoMqtt(newTitle, threadID, callback);
+      }
+    } else {
+      setTitleNoMqtt(newTitle, threadID, callback);
+    }
+  };
+};