@cexy/hoonfca 1.0.7 → 2.0.2

package/src/apis/sendMessageMqtt.js

@@ -0,0 +1,249 @@
+"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 uploadAttachment(attachments, callback) {
+    callback = callback || function () {};
+    var uploads = [];
+    try {
+      for (var i = 0; i < attachments.length; i++) {
+        if (!utils.isReadableStream(attachments[i])) {
+          throw { error: "Attachment should be a readable stream and not " + utils.getType(attachments[i]) + "." };
+        }
+        
+        if (i > 0) {
+          await globalAntiSuspension.addSmartDelay();
+        }
+        
+        var 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);
+      }
+      callback(null, uploads);
+    } catch (err) {
+      utils.error("uploadAttachment", err);
+      return callback(err);
+    }
+  }
+
+  function getSendPayload(threadID, msg, otid) {
+    const isString = typeof msg === 'string';
+    const body = isString ? msg : msg.body || "";
+    otid = otid.toString() || utils.generateOfflineThreadingID().toString();
+    let payload = {
+      thread_id: threadID.toString(),
+      otid,
+      source: 0,
+      send_type: 1,
+      sync_group: 1,
+      text: body,
+      initiating_source: 1,
+      skip_url_preview_gen: 0,
+    };
+    if (typeof msg === 'object') {
+      if (msg.sticker) {
+        payload.send_type = 2;
+        payload.sticker_id = msg.sticker;
+        payload.text = null;
+      }
+      if (msg.attachment) {
+        payload.send_type = 3;
+        payload.attachment_fbids = Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment];
+      }
+    }
+    return payload;
+  }
+
+  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, reqID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient || typeof ctx.mqttClient.on !== "function" || typeof ctx.mqttClient.publish !== "function") {
+        const err = new Error("MQTT client is not initialized");
+        utils.error("sendMessageMqtt", err);
+        callback && callback(err);
+        return reject(err);
+      }
+
+      if (typeof ctx.mqttClient.setMaxListeners === "function") {
+        ctx.mqttClient.setMaxListeners(0);
+      }
+
+      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 result = { messageID, threadID };
+        cleanup();
+        callback && callback(undefined, result);
+        resolve(result);
+      };
+      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);
+    });
+  }
+
+  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 threadID === "function") {
+      throw new Error("Pass a threadID as a second argument.");
+    }
+
+    if (!callback && typeof replyToMessage === "function") {
+      callback = replyToMessage;
+      replyToMessage = null;
+    }
+
+    // Apply anti-suspension throttling and volume checks before every MQTT send
+    try {
+      await globalAntiSuspension.prepareBeforeMessage(String(threadID), typeof msg === 'string' ? msg : (msg.body || ''));
+    } catch (suspErr) {
+      utils.warn("sendMessageMqtt", "Anti-suspension check raised:", suspErr && suspErr.message ? suspErr.message : suspErr);
+    }
+
+    const timestamp = Date.now();
+    const otid = utils.generateOfflineThreadingID();
+    const epoch_id = utils.generateOfflineThreadingID();
+    const payload = getSendPayload(threadID, msg, otid);
+
+    const tasks = [{
+      label: "46",
+      payload,
+      queue_name: threadID.toString(),
+      task_id: 0,
+      failure_count: null,
+    }, {
+      label: "21",
+      payload: {
+        thread_id: threadID.toString(),
+        last_read_watermark_ts: timestamp,
+        sync_group: 1,
+      },
+      queue_name: threadID.toString(),
+      task_id: 1,
+      failure_count: null,
+    }];
+
+    if (replyToMessage) {
+      tasks[0].payload.reply_metadata = {
+        reply_source_id: replyToMessage,
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+
+    const request_id = ++ctx.wsReqNumber;
+    const form = {
+      app_id: "2220391788200892",
+      payload: {
+        tasks,
+        epoch_id,
+        version_id: "6120284488008082",
+        data_trace_id: null,
+      },
+      request_id,
+      type: 3,
+    };
+
+    if (msg.attachment) {
+      try {
+        ctx._lastThreadHint = threadID;
+        const files = await new Promise((resolve, reject) => {
+          uploadAttachment(
+            Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment],
+            (err, files) => {
+              if (err) return reject(err);
+              return resolve(files);
+            }
+          );
+        });
+        form.payload.tasks[0].payload.attachment_fbids = files.map(file => Object.values(file)[0]);
+      } catch (err) {
+        utils.error("Attachment upload failed:", err);
+        throw err;
+      }
+    }
+
+    form.payload.tasks.forEach(task => {
+      task.payload = JSON.stringify(task.payload);
+    });
+    form.payload = JSON.stringify(form.payload);
+    
+    return publishWithAck(form, request_id, callback);
+  };
+};

package/src/apis/sendTypingIndicator.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    /**
+     * Thread-type cache so we only look up group status once per thread.
+     * Shared with sendMessage via ctx.threadTypeCache.
+     */
+    function getThreadCache() {
+        if (!ctx.threadTypeCache) ctx.threadTypeCache = Object.create(null);
+        return ctx.threadTypeCache;
+    }
+
+    /**
+     * Reliably determines whether a thread is a group by querying the API
+     * and caching the result. Falls back to string-length heuristic only on error.
+     */
+    async function isGroupThread(threadID) {
+        const tid = threadID.toString();
+        const cache = getThreadCache();
+        if (Object.prototype.hasOwnProperty.call(cache, tid)) return !!cache[tid];
+        try {
+            const info = await api.getThreadInfo(tid);
+            cache[tid] = !!info.isGroup;
+            return !!info.isGroup;
+        } catch (_) {
+            const fallback = tid.length >= 16;
+            cache[tid] = fallback;
+            return fallback;
+        }
+    }
+
+    /**
+     * Sends a typing indicator to a specific thread.
+     * @param {boolean} sendTyping - True to show typing indicator, false to hide.
+     * @param {string} threadID - The ID of the thread to send the typing indicator to.
+     * @param {Function} [callback] - An optional callback function.
+     * @returns {Promise<void>}
+     */
+    return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
+        if (!ctx.mqttClient) {
+            const err = new Error("You can only use sendTypingIndicator after you start listening.");
+            if (callback) callback(err);
+            else throw err;
+            return;
+        }
+
+        let count_req = 0;
+
+        let isGroup;
+        try {
+            isGroup = await isGroupThread(threadID);
+        } catch (_) {
+            isGroup = threadID.toString().length >= 16;
+        }
+
+        const wsContent = {
+            app_id: 2220391788200892,
+            payload: JSON.stringify({
+                label: 3,
+                payload: JSON.stringify({
+                    thread_key: threadID.toString(),
+                    is_group_thread: +isGroup,
+                    is_typing: +sendTyping,
+                    attribution: 0
+                }),
+                version: 5849951561777440
+            }),
+            request_id: ++count_req,
+            type: 4
+        };
+
+        // Wrap publish in a timeout so a stale MQTT connection never hangs this call.
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("sendTypingIndicator: MQTT publish timed out")), 8000);
+            ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => {
+                clearTimeout(timer);
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+
+        if (callback) callback();
+    };
+};

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/setThreadTheme.js

@@ -0,0 +1,260 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setThreadTheme(threadID, themeData, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!threadID) {
+      return callback({ error: "threadID is required" });
+    }
+
+    (async function worker() {
+      try {
+        const now = Date.now();
+
+        // Try to fetch bootloader
+        try {
+          const bootParams = new URLSearchParams({
+            modules: "LSUpdateThreadTheme,LSUpdateThreadCustomEmoji,LSUpdateThreadThemePayloadCacheKey",
+            __aaid: 0,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            __hs: "20352.HYP:comet_pkg.2.1...0",
+            dpr: 1,
+            __ccg: "EXCELLENT",
+            __rev: "1027396270",
+            __s: utils.getSignatureID(),
+            __hsi: "7552524636527201016",
+            __comet_req: 15,
+            fb_dtsg_ag: ctx.fb_dtsg,
+            jazoest: ctx.jazoest,
+            __spin_r: "1027396270",
+            __spin_b: "trunk",
+            __spin_t: now,
+            __crn: "comet.fbweb.MWInboxHomeRoute"
+          });
+
+          await defaultFuncs.get(
+            "https://www.facebook.com/ajax/bootloader-endpoint/?" + bootParams.toString(),
+            ctx.jar
+          ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        } catch (bootErr) {
+          log.warn("setThreadTheme", "bootloader fetch failed, continuing");
+        }
+
+        let availableThemes = [];
+        try {
+          const themeQueryForm = {
+            av: ctx.userID,
+            __aaid: 0,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            __hs: "20352.HYP:comet_pkg.2.1...0",
+            dpr: 1,
+            __ccg: "EXCELLENT",
+            __rev: "1027396270",
+            __s: utils.getSignatureID(),
+            __hsi: "7552524636527201016",
+            __comet_req: 15,
+            fb_dtsg: ctx.fb_dtsg,
+            jazoest: ctx.jazoest,
+            lsd: ctx.fb_dtsg,
+            __spin_r: "1027396270",
+            __spin_b: "trunk",
+            __spin_t: now,
+            __crn: "comet.fbweb.MWInboxHomeRoute",
+            qpl_active_flow_ids: "25308101",
+            fb_api_caller_class: "RelayModern",
+            fb_api_req_friendly_name: "MWPThreadThemeQuery_AllThemesQuery",
+            variables: JSON.stringify({ version: "default" }),
+            server_timestamps: true,
+            doc_id: "24474714052117636"
+          };
+
+          const themeRes = await defaultFuncs
+            .post("https://www.facebook.com/api/graphql/", ctx.jar, themeQueryForm)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+          if (themeRes && themeRes.data && themeRes.data.messenger_thread_themes) {
+            availableThemes = themeRes.data.messenger_thread_themes;
+          }
+        } catch (fetchErr) {
+          log.warn("setThreadTheme", "Could not fetch available themes, proceeding without list");
+        }
+
+        let chosenThemeId = null;
+        let chosenEmoji = "👍";
+
+        if (typeof themeData === "string") {
+          const s = themeData.trim();
+
+          if (/^[0-9]+$/.test(s)) {
+            chosenThemeId = s;
+          } else {
+            const found = (availableThemes || []).find(function (t) {
+              return (
+                t.accessibility_label &&
+                t.accessibility_label.toLowerCase().includes(s.toLowerCase())
+              );
+            });
+            if (found) {
+              chosenThemeId = found.id;
+            } else {
+              const palette = {
+                blue: "196241301102133",
+                purple: "370940413392601",
+                green: "169463077092846",
+                pink: "230032715012014",
+                orange: "175615189761153",
+                red: "2136751179887052",
+                yellow: "2058653964378557",
+                teal: "417639218648241",
+                black: "539927563794799",
+                white: "2873642392710980",
+                default: "196241301102133"
+              };
+              chosenThemeId = palette[s.toLowerCase()] || palette.default;
+            }
+          }
+        } else if (typeof themeData === "object" && themeData !== null) {
+          chosenThemeId = themeData.themeId || themeData.theme_id || themeData.id || null;
+          chosenEmoji = themeData.emoji || themeData.customEmoji || chosenEmoji;
+        }
+
+        if (!chosenThemeId) {
+          chosenThemeId = "196241301102133";
+        }
+
+        // Try legacy approach first
+        try {
+          const legacyBody = {
+            dpr: 1,
+            queries: JSON.stringify({
+              o0: {
+                doc_id: "1727493033983591",
+                query_params: {
+                  data: {
+                    actor_id: ctx.userID,
+                    client_mutation_id: "0",
+                    source: "SETTINGS",
+                    theme_id: chosenThemeId,
+                    thread_id: threadID
+                  }
+                }
+              }
+            })
+          };
+
+          const legacyResp = await defaultFuncs
+            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, legacyBody)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+          if (legacyResp && !legacyResp[0]?.o0?.errors) {
+            return callback(null, {
+              threadID: threadID,
+              themeId: chosenThemeId,
+              customEmoji: chosenEmoji,
+              timestamp: now,
+              success: true,
+              method: "legacy",
+              availableThemes: availableThemes.length > 0
+                ? availableThemes.map(function (t) {
+                    return { id: t.id, name: t.accessibility_label, description: t.description };
+                  })
+                : null
+            });
+          }
+        } catch (legacyErr) {
+          log.warn("setThreadTheme", "Legacy approach failed; falling back to GraphQL mutation");
+        }
+
+        // Fall back to GraphQL mutation
+        const mutationBody = {
+          av: ctx.userID,
+          __aaid: 0,
+          __user: ctx.userID,
+          __a: 1,
+          __req: utils.getSignatureID(),
+          __hs: "20352.HYP:comet_pkg.2.1...0",
+          dpr: 1,
+          __ccg: "EXCELLENT",
+          __rev: "1027396270",
+          __s: utils.getSignatureID(),
+          __hsi: "7552524636527201016",
+          __comet_req: 15,
+          fb_dtsg: ctx.fb_dtsg,
+          jazoest: ctx.jazoest,
+          lsd: ctx.fb_dtsg,
+          __spin_r: "1027396270",
+          __spin_b: "trunk",
+          __spin_t: now,
+          __crn: "comet.fbweb.MWInboxHomeRoute",
+          fb_api_caller_class: "RelayModern",
+          fb_api_req_friendly_name: "MessengerThreadThemeUpdateMutation",
+          variables: JSON.stringify({
+            input: {
+              actor_id: ctx.userID,
+              client_mutation_id: Math.floor(Math.random() * 10000).toString(),
+              source: "SETTINGS",
+              thread_id: threadID.toString(),
+              theme_id: chosenThemeId.toString(),
+              custom_emoji: chosenEmoji
+            }
+          }),
+          server_timestamps: true,
+          doc_id: "9734829906576883"
+        };
+
+        const gqlResult = await defaultFuncs
+          .post("https://www.facebook.com/api/graphql/", ctx.jar, mutationBody)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (gqlResult && gqlResult.errors && gqlResult.errors.length > 0) {
+          throw new Error("GraphQL Error: " + JSON.stringify(gqlResult.errors));
+        }
+
+        if (gqlResult && gqlResult.data && gqlResult.data.messenger_thread_theme_update) {
+          const updatePayload = gqlResult.data.messenger_thread_theme_update;
+          if (updatePayload.errors && updatePayload.errors.length > 0) {
+            throw new Error("Theme Update Error: " + JSON.stringify(updatePayload.errors));
+          }
+        }
+
+        return callback(null, {
+          threadID: threadID,
+          themeId: chosenThemeId,
+          customEmoji: chosenEmoji,
+          timestamp: now,
+          success: true,
+          method: "graphql",
+          availableThemes: availableThemes.length > 0
+            ? availableThemes.map(function (t) {
+                return { id: t.id, name: t.accessibility_label, description: t.description };
+              })
+            : null
+        });
+      } catch (err) {
+        log.error("setThreadTheme", err);
+        return callback(err);
+      }
+    })();
+
+    return promise;
+  };
+};