@lazyneoaz/metachat 1.0.0

package/src/apis/sendMessageMqtt.js

@@ -0,0 +1,271 @@
+"use strict";
+
+const utils = require('../utils');
+const { globalAntiSuspension } = require('../utils/antiSuspension');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  function detectAttachmentType(attachment) {
+    const p = attachment.path || "";
+    const ext = p.toLowerCase().split(".").pop();
+    const audio = ["mp3", "wav", "aac", "m4a", "ogg", "opus", "flac"];
+    const video = ["mp4", "mov", "avi", "mkv", "webm", "wmv", "flv"];
+    const image = ["jpg", "jpeg", "png", "gif", "bmp", "webp", "svg"];
+    if (audio.includes(ext)) return { voice_clip: "true" };
+    if (video.includes(ext)) return { video: "true" };
+    if (image.includes(ext)) return { image: "true" };
+    return { file: "true" };
+  }
+
+  async function uploadAttachments(attachments) {
+    const uploads = [];
+    for (let i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw new Error("Attachment should be a readable stream and not " + utils.getType(attachments[i]) + ".");
+      }
+      if (i > 0) {
+        await globalAntiSuspension.addSmartDelay();
+      }
+      const form = {
+        upload_1024: attachments[i],
+        ...detectAttachmentType(attachments[i]),
+      };
+      const upload = await defaultFuncs
+        .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {}, { ...ctx, requestThreadID: String(ctx._lastThreadHint || "") })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(resData => {
+          if (resData.error) throw resData;
+          return resData.payload.metadata[0];
+        });
+      uploads.push(upload);
+    }
+    return uploads;
+  }
+
+  function buildMentionData(msg, baseBody) {
+    if (!Array.isArray(msg.mentions) || msg.mentions.length === 0) return null;
+    const ids = [], offsets = [], lengths = [], types = [];
+    let cursor = 0;
+    for (const mention of msg.mentions) {
+      const rawTag = String(mention.tag || "");
+      const displayName = rawTag.replace(/^@+/, "");
+      const start = Number.isInteger(mention.fromIndex) ? mention.fromIndex : cursor;
+      let index = baseBody.indexOf(rawTag, start);
+      let adjustment = 0;
+      if (index === -1) {
+        index = baseBody.indexOf(displayName, start);
+      } else {
+        adjustment = rawTag.length - displayName.length;
+      }
+      if (index < 0) { index = 0; adjustment = 0; }
+      const offset = index + adjustment;
+      ids.push(String(mention.id || 0));
+      offsets.push(offset);
+      lengths.push(displayName.length);
+      types.push("p");
+      cursor = offset + displayName.length;
+    }
+    return {
+      mention_ids: ids.join(","),
+      mention_offsets: offsets.join(","),
+      mention_lengths: lengths.join(","),
+      mention_types: types.join(","),
+    };
+  }
+
+  function hasLinks(text) {
+    return /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(text);
+  }
+
+  function extractIdsFromPayload(payload) {
+    let messageID = null;
+    let threadID = null;
+    function walk(n) {
+      if (!Array.isArray(n)) return;
+      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, reqID) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient || typeof ctx.mqttClient.on !== "function" || typeof ctx.mqttClient.publish !== "function") {
+        return reject(new Error("MQTT client is not initialized"));
+      }
+      if (typeof ctx.mqttClient.setMaxListeners === "function") {
+        ctx.mqttClient.setMaxListeners(0);
+      }
+      let settled = false;
+      let timer;
+      const cleanup = () => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        ctx.mqttClient.removeListener("message", onMessage);
+      };
+      const onMessage = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let parsed;
+        try {
+          parsed = JSON.parse(message.toString());
+          if (typeof parsed.payload === "string") parsed.payload = JSON.parse(parsed.payload);
+        } catch { return; }
+        if (parsed.request_id !== reqID) return;
+        const { threadID, messageID } = extractIdsFromPayload(parsed.payload);
+        cleanup();
+        resolve({ messageID, threadID });
+      };
+      ctx.mqttClient.on("message", onMessage);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+        if (err) { cleanup(); reject(err); }
+      });
+      timer = setTimeout(() => {
+        if (settled) return;
+        cleanup();
+        reject({ error: "Timeout waiting for ACK" });
+      }, 15000);
+    });
+  }
+
+  return async (msg, threadID, replyToMessage, callback) => {
+    if (typeof msg !== "string" && typeof msg !== "object") {
+      throw new Error("Message should be of type string or object, not " + utils.getType(msg) + ".");
+    }
+    if (typeof threadID !== "string" && typeof threadID !== "number") {
+      throw new Error("threadID must be a string or number.");
+    }
+    if (!callback && typeof replyToMessage === "function") {
+      callback = replyToMessage;
+      replyToMessage = null;
+    }
+
+    try {
+      await globalAntiSuspension.prepareBeforeMessage(String(threadID), typeof msg === "string" ? msg : (msg.body || ""));
+    } catch (_) {}
+
+    const normalized = typeof msg === "string" ? { body: msg } : msg;
+    const baseBody = normalized.body != null ? String(normalized.body) : "";
+    const epoch = (BigInt(Date.now()) << 22n).toString();
+    const requestId = Math.floor(100 + Math.random() * 900);
+    const otid = utils.generateOfflineThreadingID();
+
+    const payload0 = {
+      thread_id: String(threadID),
+      otid: otid.toString(),
+      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 } }),
+    };
+
+    if (normalized.mentions && Array.isArray(normalized.mentions) && normalized.mentions.length > 0) {
+      const mentionData = buildMentionData(normalized, baseBody);
+      if (mentionData) payload0.mention_data = mentionData;
+    }
+
+    if (normalized.sticker) {
+      payload0.send_type = 2;
+      payload0.sticker_id = normalized.sticker;
+      payload0.text = null;
+    }
+
+    if (normalized.emoji) {
+      payload0.send_type = 1;
+      payload0.text = normalized.emoji;
+      const sizeMap = { small: 1, medium: 2, large: 3 };
+      const emojiSize = normalized.emojiSize;
+      payload0.hot_emoji_size = (typeof emojiSize === "number" ? Math.min(3, Math.max(1, emojiSize)) : sizeMap[emojiSize]) || 1;
+    }
+
+    if (normalized.location && normalized.location.latitude != null && normalized.location.longitude != null) {
+      payload0.send_type = 1;
+      payload0.location_data = {
+        coordinates: { latitude: normalized.location.latitude, longitude: normalized.location.longitude },
+        is_current_location: Boolean(normalized.location.current),
+        is_live_location: Boolean(normalized.location.live),
+      };
+    }
+
+    if (normalized.effect) {
+      const effectTag = String(normalized.effect).toUpperCase().replace(/[\s\-]+/g, "_");
+      payload0.lightweight_action_attached = {
+        message_id: otid.toString(),
+        messaging_tag: "fb.messaging.effects." + effectTag,
+      };
+    }
+
+    if (replyToMessage || normalized.replyToMessage) {
+      const replyId = replyToMessage || normalized.replyToMessage;
+      payload0.reply_metadata = {
+        reply_source_id: replyId,
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+
+    if (normalized.attachment) {
+      payload0.send_type = 3;
+      if (payload0.text === "") payload0.text = null;
+      const list = Array.isArray(normalized.attachment) ? normalized.attachment : [normalized.attachment];
+      ctx._lastThreadHint = threadID;
+      const files = await uploadAttachments(list.filter(a => utils.isReadableStream(a)));
+      payload0.attachment_fbids = files.map(f => String(Object.values(f)[0]));
+    }
+
+    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: requestId,
+      type: 3,
+    };
+
+    content.payload.tasks = content.payload.tasks.map(t => ({ ...t, payload: JSON.stringify(t.payload) }));
+    content.payload = JSON.stringify(content.payload);
+
+    try {
+      const result = await publishWithAck(content, requestId);
+      if (callback) callback(undefined, result);
+      return result;
+    } catch (err) {
+      if (callback) callback(err);
+      throw err;
+    }
+  };
+};

package/src/apis/sendTypingIndicator.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function sendTypingIndicator(sendTyping, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(true);
+      };
+    }
+
+    if (!ctx.mqttClient || typeof ctx.mqttClient.publish !== "function") {
+      const err = new Error("You can only use sendTypingIndicator after you start listening.");
+      callback(err);
+      return returnPromise;
+    }
+
+    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
+    if (!threadIDs.length) {
+      const err = new Error("threadID is required");
+      callback(err);
+      return returnPromise;
+    }
+
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+
+    function buildPayload(tid) {
+      const isGroup = String(tid).length >= 16 ? 1 : 0;
+      return {
+        app_id: "772021112871879",
+        payload: JSON.stringify({
+          label: "3",
+          payload: JSON.stringify({
+            thread_key: Number.parseInt(String(tid), 10),
+            is_group_thread: isGroup,
+            is_typing: sendTyping ? 1 : 0,
+            attribution: 0,
+            sync_group: 1,
+            thread_type: isGroup ? 2 : 1,
+          }),
+          version: "8965252033599983",
+        }),
+        request_id: ++ctx.wsReqNumber,
+        type: 4,
+      };
+    }
+
+    const publishes = threadIDs.map(tid =>
+      new Promise((resolve, reject) => {
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(buildPayload(tid)), { qos: 1 }, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      })
+    );
+
+    Promise.all(publishes)
+      .then(() => callback(null, true))
+      .catch(err => {
+        utils.error("sendTypingIndicator", err);
+        callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/apis/setMessageReaction.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async (reaction, messageID) => {
+    if (!reaction) throw new Error("Please enter a valid emoji.");
+    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, {
+      doc_id: "1491398900900362",
+      variables: JSON.stringify({
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction
+      }
+    }),
+      dpr: 1
+    });
+    const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+    if (!resData) {
+      throw new Error("setMessageReactionLegacy returned empty object.");
+    }
+  };
+};

package/src/apis/setMessageReactionMqtt.js

@@ -0,0 +1,61 @@
+
+'use strict';
+
+const utils = require('../utils');
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: Date.now(),
+      message_id: messageID,
+      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: ctx.wsTaskNumber
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: '7158486590867448',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    /*if (isCallable(callback)) {
+      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    }*/
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/apis/setPostReaction.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Adds or removes a reaction on a Facebook post (not a Messenger message).
+ *
+ * For reacting to Messenger messages use api.setMessageReaction() instead.
+ *
+ * @param {string}          postID    The Facebook post/object ID.
+ * @param {string|number}   type      Reaction type:
+ *   - Named:  "like" | "heart" | "love" | "haha" | "wow" | "sad" | "angry" | "unlike"
+ *   - Numeric: 0=unlike, 1=like, 2=heart, 4=haha, 3=wow, 7=sad, 8=angry, 16=love
+ * @param {Function}        [callback]
+ * @returns {Promise}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  const REACTION_MAP = {
+    unlike: 0,
+    like:   1,
+    heart:  2,
+    love:   16,
+    haha:   4,
+    wow:    3,
+    sad:    7,
+    angry:  8,
+  };
+
+  return function setPostReaction(postID, type, callback) {
+    let reactionType = type;
+    let cb = callback;
+
+    // Allow omitting type to default to "unlike"
+    if (!cb && (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction")) {
+      cb = type;
+      reactionType = 0;
+    }
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+    if (!cb) {
+      cb = (err, data) => { if (err) return rejectFunc(err); resolveFunc(data); };
+    }
+
+    if (!postID) return cb(new Error("postID is required"));
+
+    // Resolve named type
+    if (utils.getType(reactionType) === "String") {
+      const key = String(reactionType).toLowerCase();
+      if (key in REACTION_MAP) {
+        reactionType = REACTION_MAP[key];
+      } else {
+        return cb(new Error(`Unknown reaction type "${type}". Valid types: ${Object.keys(REACTION_MAP).join(", ")}`));
+      }
+    }
+
+    if (typeof reactionType !== "number") {
+      return cb(new Error("setPostReaction: reaction type must be a string or number"));
+    }
+
+    const feedbackID = Buffer.from(`feedback:${postID}`).toString("base64");
+
+    const form = {
+      av:     ctx.userID,
+      __user: ctx.userID,
+      __a:    1,
+      __req:  utils.getSignatureID(),
+      fb_dtsg:  ctx.fb_dtsg,
+      lsd:      ctx.lsd || ctx.fb_dtsg,
+      jazoest:  ctx.jazoest,
+      fb_api_caller_class:      "RelayModern",
+      fb_api_req_friendly_name: "CometUFIFeedbackReactMutation",
+      doc_id:    "4769042373179384",
+      variables: JSON.stringify({
+        input: {
+          actor_id:              ctx.userID,
+          feedback_id:           feedbackID,
+          feedback_reaction:     reactionType,
+          feedback_source:       "OBJECT",
+          is_tracking_encrypted: true,
+          tracking:              [],
+          session_id:            utils.getSignatureID() + "-" + Date.now(),
+          client_mutation_id:    Math.floor(Math.random() * 20).toString(),
+        },
+        useDefaultActor: false,
+        scale: 3,
+      }),
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData;
+
+        const fbReact = resData && resData.data && resData.data.feedback_react;
+        const result = {
+          postID,
+          reactionType,
+          success: true,
+          reaction_count: fbReact && fbReact.feedback
+            ? fbReact.feedback.reaction_count
+            : null,
+        };
+
+        cb(null, result);
+      })
+      .catch((err) => {
+        utils.error("setPostReaction", err.message || err);
+        cb(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};