fca-phantom 1.0.0

package/phantom/dispatch/markAsSeen.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Marks all messages as "seen" up to a specific timestamp.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
+   * @param {Function} [callback] - The callback function.
+   * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
+   */
+  return async function markAsSeen(seen_timestamp, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (utils.getType(seen_timestamp) == "Function" || utils.getType(seen_timestamp) == "AsyncFunction") {
+      callback = seen_timestamp;
+      seen_timestamp = Date.now();
+    } else if (seen_timestamp === undefined) {
+      seen_timestamp = Date.now();
+    }
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      seen_timestamp: seen_timestamp,
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/mark_seen.php",
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData.error) {
+        throw resData;
+      }
+
+      return callback();
+    } catch (err) {
+      utils.error("markAsSeen", err);
+      if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
+        ctx.loggedIn = false;
+      }
+      return callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/mqttDeltaValue.js

@@ -0,0 +1,278 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const e2ee = require('../datastore/models/cipher/e2ee');
+
+
+function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
+  if (v.delta.class == "NewMessage") {
+
+    if (ctx.globalOptions.pageID && ctx.globalOptions.pageID != v.queue) return;
+    (function resolveAttachmentUrl(i) {
+      if (!v.delta.attachments || i == v.delta.attachments.length || utils.getType(v.delta.attachments) !== "Array") {
+        var fmtMsg;
+        try {
+          fmtMsg = utils.formatDeltaMessage(v);
+        } catch (err) {
+          return;
+        }
+        if (fmtMsg) {
+            try {
+              if (e2ee.isEnabled(ctx) && !!v.delta.threadKey.threadFbId) {
+                const dec = e2ee.decrypt(ctx, fmtMsg.threadID, fmtMsg.body);
+                if (dec !== null) fmtMsg.body = dec;
+              }
+            } catch (_) {}
+            if (ctx.globalOptions.autoMarkDelivery) {
+                api.markAsDelivered(fmtMsg.threadID, fmtMsg.messageID);
+            }
+            if (!ctx.globalOptions.selfListen && fmtMsg.senderID === ctx.userID) {
+                return;
+            }
+            return globalCallback(null, fmtMsg);
+        }
+      } else {
+         var attachment = v.delta.attachments[i];
+         if (attachment && attachment.mercury && attachment.mercury.attach_type == "photo") {
+          api.resolvePhotoUrl(attachment.fbid, (err, url) => {
+            if (!err) attachment.mercury.metadata.url = url;
+            return resolveAttachmentUrl(i + 1);
+          });
+         } else {
+            return resolveAttachmentUrl(i + 1);
+         }
+      }
+    })(0);
+  }
+
+  if (v.delta.class == "ClientPayload") {
+    var clientPayload = utils.decodeClientPayload(v.delta.payload);
+    if (clientPayload && clientPayload.deltas) {
+      for (var i in clientPayload.deltas) {
+        var delta = clientPayload.deltas[i];
+
+        if (delta.deltaMessageReaction && !!ctx.globalOptions.listenEvents) {
+            const reactionEvent = {
+              type: "message_reaction",
+              threadID: (delta.deltaMessageReaction.threadKey.threadFbId || delta.deltaMessageReaction.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaMessageReaction.messageId,
+              reaction: delta.deltaMessageReaction.reaction,
+              senderID: delta.deltaMessageReaction.userId.toString(),
+              userID: delta.deltaMessageReaction.userId.toString()
+            };
+
+            if (!ctx.globalOptions.selfListen && reactionEvent.senderID === ctx.userID) {
+              return;
+            }
+
+            globalCallback(null, reactionEvent);
+        } else if (delta.deltaRecallMessageData && !!ctx.globalOptions.listenEvents) {
+            globalCallback(null, {
+              type: "message_unsend",
+              threadID: (delta.deltaRecallMessageData.threadKey.threadFbId || delta.deltaRecallMessageData.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaRecallMessageData.messageID,
+              senderID: delta.deltaRecallMessageData.senderID.toString(),
+              deletionTimestamp: delta.deltaRecallMessageData.deletionTimestamp,
+              timestamp: delta.deltaRecallMessageData.timestamp
+            });
+        } else if (delta.deltaMessageReply) {
+          var mdata = delta.deltaMessageReply.message?.data?.prng ? JSON.parse(delta.deltaMessageReply.message.data.prng) : [];
+          var mentions = {};
+          if (mdata) {
+            mdata.forEach(m => mentions[m.i] = (delta.deltaMessageReply.message.body || "").substring(m.o, m.o + m.l));
+          }
+
+          var callbackToReturn = {
+            type: "message_reply",
+            threadID: (delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.message.messageMetadata.threadKey.otherUserFbId).toString(),
+            messageID: delta.deltaMessageReply.message.messageMetadata.messageId,
+            senderID: delta.deltaMessageReply.message.messageMetadata.actorFbId.toString(),
+            attachments: delta.deltaMessageReply.message.attachments.map(att => {
+              try {
+                var mercury = JSON.parse(att.mercuryJSON);
+                Object.assign(att, mercury);
+                return utils.formatAttachment(att);
+              } catch (ex) {
+                return { ...att, error: ex, type: "unknown" };
+              }
+            }),
+            body: (delta.deltaMessageReply.message.body || ""),
+            isGroup: !!delta.deltaMessageReply.message.messageMetadata.threadKey.threadFbId,
+            mentions: mentions,
+            timestamp: delta.deltaMessageReply.message.messageMetadata.timestamp,
+            participantIDs: (delta.deltaMessageReply.message.participants || []).map(e => e.toString())
+          };
+          try {
+            if (e2ee.isEnabled(ctx) && callbackToReturn.isGroup) {
+              const dec = e2ee.decrypt(ctx, callbackToReturn.threadID, callbackToReturn.body);
+              if (dec !== null) callbackToReturn.body = dec;
+            }
+          } catch (_) {}
+
+          if (delta.deltaMessageReply.repliedToMessage) {
+            var rmentions = {};
+            var rmdata = delta.deltaMessageReply.repliedToMessage?.data?.prng ? JSON.parse(delta.deltaMessageReply.repliedToMessage.data.prng) : [];
+            if (rmdata) {
+                rmdata.forEach(m => rmentions[m.i] = (delta.deltaMessageReply.repliedToMessage.body || "").substring(m.o, m.o + m.l));
+            }
+
+            callbackToReturn.messageReply = {
+              threadID: (delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId || delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.otherUserFbId).toString(),
+              messageID: delta.deltaMessageReply.repliedToMessage.messageMetadata.messageId,
+              senderID: delta.deltaMessageReply.repliedToMessage.messageMetadata.actorFbId.toString(),
+              attachments: delta.deltaMessageReply.repliedToMessage.attachments.map(att => {
+                 try {
+                    var mercury = JSON.parse(att.mercuryJSON);
+                    Object.assign(att, mercury);
+                    return utils.formatAttachment(att);
+                  } catch (ex) {
+                    return { ...att, error: ex, type: "unknown" };
+                  }
+              }),
+              body: delta.deltaMessageReply.repliedToMessage.body || "",
+              isGroup: !!delta.deltaMessageReply.repliedToMessage.messageMetadata.threadKey.threadFbId,
+              mentions: rmentions,
+              timestamp: delta.deltaMessageReply.repliedToMessage.messageMetadata.timestamp,
+              participantIDs: (delta.deltaMessageReply.repliedToMessage.participants || []).map(e => e.toString())
+            };
+            try {
+              if (e2ee.isEnabled(ctx) && callbackToReturn.messageReply.isGroup) {
+                const dec2 = e2ee.decrypt(ctx, callbackToReturn.messageReply.threadID, callbackToReturn.messageReply.body);
+                if (dec2 !== null) callbackToReturn.messageReply.body = dec2;
+              }
+            } catch (_) {}
+          }
+          if (ctx.globalOptions.autoMarkDelivery) api.markAsDelivered(callbackToReturn.threadID, callbackToReturn.messageID);
+          if (!ctx.globalOptions.selfListen && callbackToReturn.senderID === ctx.userID) return;
+          return globalCallback(null, callbackToReturn);
+        }
+      }
+      return;
+    }
+  }
+
+  if (v.delta.class !== "NewMessage" && !ctx.globalOptions.listenEvents) return;
+  switch (v.delta.class) {
+    case "ReadReceipt":
+      var fmtMsg;
+      try {
+        fmtMsg = utils.formatDeltaReadReceipt(v.delta);
+      } catch (err) {
+        return;
+      }
+      if (fmtMsg) globalCallback(null, fmtMsg);
+      break;
+    case "AdminTextMessage":
+      switch (v.delta.type) {
+        case "instant_game_dynamic_custom_update":
+        case "accept_pending_thread":
+        case "confirm_friend_request":
+        case "shared_album_delete":
+        case "shared_album_addition":
+        case "pin_messages_v2":
+        case "unpin_messages_v2":
+        case "change_thread_theme":
+        case "change_thread_nickname":
+        case "change_thread_icon":
+        case "change_thread_quick_reaction":
+        case "change_thread_admins":
+        case "group_poll":
+        case "joinable_group_link_mode_change":
+        case "magic_words":
+        case "change_thread_approval_mode":
+        case "messenger_call_log":
+        case "participant_joined_group_call":
+        case "rtc_call_log":
+        case "update_vote":
+          var fmtEvent;
+          try {
+            fmtEvent = utils.formatDeltaEvent(v.delta);
+          } catch (err) {
+            return;
+          }
+          if (fmtEvent) globalCallback(null, fmtEvent);
+          break;
+      }
+      break;
+    case "ThreadName":
+    case "ParticipantsAddedToGroupThread":
+    case "ParticipantLeftGroupThread":
+      var fmtEvent2;
+      try {
+        fmtEvent2 = utils.formatDeltaEvent(v.delta);
+      } catch (err) {
+        return;
+      }
+      if (!ctx.globalOptions.selfListen && fmtEvent2 && fmtEvent2.author && fmtEvent2.author.toString() === ctx.userID) return;
+      if (!ctx.loggedIn) return;
+      if (fmtEvent2) globalCallback(null, fmtEvent2);
+      break;
+    case "ForcedFetch":
+      if (!v.delta.threadKey) return;
+      var mid = v.delta.messageId;
+      var tid = v.delta.threadKey.threadFbId;
+      if (mid && tid) {
+        var form = {
+          av: ctx.globalOptions.pageID,
+          queries: JSON.stringify({
+            o0: {
+              doc_id: "2848441488556444",
+              query_params: {
+                thread_and_message_id: {
+                  thread_id: tid.toString(),
+                  message_id: mid
+                }
+              }
+            }
+          })
+        };
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(resData => {
+            if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
+            if (resData[resData.length - 1].successful_results === 0) throw { error: "forcedFetch: no successful_results" };
+            var fetchData = resData[0].o0.data.message;
+            if (utils.getType(fetchData) === "Object") {
+              if (fetchData.__typename === "UserMessage" && fetchData.extensible_attachment) {
+                var event = {
+                  type: "message",
+                  senderID: utils.formatID(fetchData.message_sender.id),
+                  body: fetchData.message.text || "",
+                  threadID: utils.formatID(tid.toString()),
+                  messageID: fetchData.message_id,
+                  attachments: [{
+                    type: "share",
+                    ID: fetchData.extensible_attachment.legacy_attachment_id,
+                    url: fetchData.extensible_attachment.story_attachment.url,
+                    title: fetchData.extensible_attachment.story_attachment.title_with_entities.text,
+                    description: fetchData.extensible_attachment.story_attachment.description ? fetchData.extensible_attachment.story_attachment.description.text : "",
+                    source: fetchData.extensible_attachment.story_attachment.source,
+                    image: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).uri,
+                    width: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).width,
+                    height: ((fetchData.extensible_attachment.story_attachment.media || {}).image || {}).height,
+                    playable: ((fetchData.extensible_attachment.story_attachment.media || {}).is_playable || false),
+                    duration: ((fetchData.extensible_attachment.story_attachment.media || {}).playable_duration_in_ms || 0)
+                  }],
+                  mentions: {},
+                  timestamp: parseInt(fetchData.timestamp_precise),
+                  isGroup: fetchData.message_sender.id !== tid.toString()
+                };
+                try {
+                  if (e2ee.isEnabled(ctx) && event.isGroup) {
+                    const dec = e2ee.decrypt(ctx, event.threadID, event.body);
+                    if (dec !== null) event.body = dec;
+                  }
+                } catch (_) {}
+                globalCallback(null, event);
+              }
+            }
+          })
+          .catch(err => {});
+      }
+      break;
+  }
+}
+
+module.exports = {
+    parseDelta
+};

package/phantom/dispatch/muteThread.js

@@ -0,0 +1,253 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const MUTE_CACHE = new Map();
+const MUTE_HISTORY = [];
+const MAX_HISTORY = 200;
+const SCHEDULED_UNMUTES = new Map();
+
+const MUTE_PRESETS = {
+  off: 0,
+  fifteenMinutes: 15 * 60,
+  oneHour: 60 * 60,
+  eightHours: 8 * 60 * 60,
+  twentyFourHours: 24 * 60 * 60,
+  oneWeek: 7 * 24 * 60 * 60,
+  forever: -1
+};
+
+async function retryOp(fn, retries = 4, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      const isTransient = /network|timeout|ECONNRESET|ETIMEDOUT|5\d\d|429/i.test(String(err?.message || err));
+      if (!isTransient) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 250));
+    }
+  }
+}
+
+async function httpMuteThread(defaultFuncs, ctx, threadID, muteSeconds) {
+  const res = await defaultFuncs.post(
+    'https://www.facebook.com/ajax/mercury/change_mute_thread.php',
+    ctx.jar,
+    { thread_fbid: String(threadID), mute_settings: muteSeconds }
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res && res.error) throw res;
+  return { success: true, threadID: String(threadID), muteSeconds, method: 'http', timestamp: Date.now() };
+}
+
+async function mqttMuteThread(ctx, threadID, muteSeconds) {
+  if (!ctx.mqttClient) throw new Error('MQTT not connected');
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const isMuting = muteSeconds !== 0;
+    const label = isMuting ? '319' : '320';
+
+    const form = JSON.stringify({
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [{
+          failure_count: null,
+          label,
+          payload: JSON.stringify({
+            thread_key: String(threadID),
+            mute_expire_time_ms: muteSeconds === -1 ? -1 : muteSeconds > 0 ? Date.now() + muteSeconds * 1000 : 0,
+            sync_group: 1
+          }),
+          queue_name: 'mute_thread',
+          task_id: taskID
+        }],
+        version_id: '8798795233522156'
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    let handled = false;
+    const onResp = (topic, message) => {
+      if (topic !== '/ls_resp' || handled) return;
+      let j;
+      try { j = JSON.parse(message.toString()); j.payload = JSON.parse(j.payload); } catch { return; }
+      if (j.request_id !== reqID) return;
+      handled = true;
+      clearTimeout(timer);
+      ctx.mqttClient.removeListener('message', onResp);
+      resolve({ success: true, threadID: String(threadID), muteSeconds, method: 'mqtt', timestamp: Date.now() });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(new Error('MQTT timeout for muteThread'));
+      }
+    }, 20000);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', form, { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function graphqlMuteThread(defaultFuncs, ctx, threadID, muteSeconds) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MessengerMuteThreadMutation',
+    doc_id: '3876984735634224',
+    variables: JSON.stringify({
+      input: {
+        thread_fbid: String(threadID),
+        mute_duration_seconds: muteSeconds,
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000))
+      }
+    })
+  };
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res?.errors) throw new Error(JSON.stringify(res.errors));
+  return { success: true, threadID: String(threadID), muteSeconds, method: 'graphql', timestamp: Date.now() };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+
+  function scheduleAutoUnmute(threadID, muteSeconds) {
+    const tid = String(threadID);
+    if (SCHEDULED_UNMUTES.has(tid)) clearTimeout(SCHEDULED_UNMUTES.get(tid));
+    if (muteSeconds > 0) {
+      const timer = setTimeout(() => {
+        MUTE_CACHE.delete(`mute_${tid}`);
+        SCHEDULED_UNMUTES.delete(tid);
+        utils.log('muteThread', `Auto-cleared mute cache for thread ${tid} after ${muteSeconds}s`);
+      }, muteSeconds * 1000 + 1000);
+      SCHEDULED_UNMUTES.set(tid, timer);
+    }
+  }
+
+  function recordHistory(op) {
+    MUTE_HISTORY.unshift({ ...op, ts: Date.now() });
+    if (MUTE_HISTORY.length > MAX_HISTORY) MUTE_HISTORY.length = MAX_HISTORY;
+  }
+
+  function resolveMuteSeconds(muteSeconds) {
+    if (typeof muteSeconds === 'string') {
+      const preset = MUTE_PRESETS[muteSeconds];
+      if (preset !== undefined) return preset;
+      const parsed = parseInt(muteSeconds, 10);
+      if (!isNaN(parsed)) return parsed;
+      throw new Error(`muteThread: unknown preset "${muteSeconds}". Use: ${Object.keys(MUTE_PRESETS).join(', ')}`);
+    }
+    if (typeof muteSeconds === 'number') return muteSeconds;
+    throw new Error(`muteThread: muteSeconds must be a number or preset string, got ${typeof muteSeconds}`);
+  }
+
+  const muteThread = async function muteThread(threadOrThreads, muteSeconds, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const { preferMqtt = true, useGraphQL = false, scheduleUnmute = true } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== 'function') {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const threadIDs = Array.isArray(threadOrThreads)
+        ? threadOrThreads.map(String)
+        : [String(threadOrThreads)];
+
+      if (threadIDs.length === 0) throw new Error('muteThread: at least one threadID is required');
+
+      const resolvedMuteSeconds = resolveMuteSeconds(muteSeconds);
+
+      if (resolvedMuteSeconds < -1) throw new Error('muteThread: muteSeconds must be >= -1 (-1 = forever, 0 = unmute)');
+
+      await globalShield.addSmartDelay();
+
+      const results = [];
+      const errors = [];
+
+      for (const tid of threadIDs) {
+        const cacheKey = `mute_${tid}`;
+        const cached = MUTE_CACHE.get(cacheKey);
+        if (cached && cached.muteSeconds === resolvedMuteSeconds && (Date.now() - cached.ts < 5000)) {
+          results.push({ threadID: tid, ...cached.result, fromCache: true });
+          continue;
+        }
+
+        try {
+          let result;
+
+          if (useGraphQL) {
+            result = await retryOp(() => graphqlMuteThread(defaultFuncs, ctx, tid, resolvedMuteSeconds));
+          } else if (preferMqtt && ctx.mqttClient) {
+            try {
+              result = await retryOp(() => mqttMuteThread(ctx, tid, resolvedMuteSeconds));
+            } catch (mqttErr) {
+              utils.warn('muteThread', `MQTT failed for ${tid}, using HTTP:`, mqttErr.message);
+              result = await retryOp(() => httpMuteThread(defaultFuncs, ctx, tid, resolvedMuteSeconds));
+            }
+          } else {
+            result = await retryOp(() => httpMuteThread(defaultFuncs, ctx, tid, resolvedMuteSeconds));
+          }
+
+          MUTE_CACHE.set(cacheKey, { result, muteSeconds: resolvedMuteSeconds, ts: Date.now() });
+
+          if (scheduleUnmute && resolvedMuteSeconds > 0) scheduleAutoUnmute(tid, resolvedMuteSeconds);
+          if (resolvedMuteSeconds === 0) {
+            MUTE_CACHE.delete(cacheKey);
+            if (SCHEDULED_UNMUTES.has(tid)) { clearTimeout(SCHEDULED_UNMUTES.get(tid)); SCHEDULED_UNMUTES.delete(tid); }
+          }
+
+          results.push(result);
+          recordHistory({ threadID: tid, muteSeconds: resolvedMuteSeconds, method: result.method });
+        } catch (err) {
+          errors.push({ threadID: tid, error: err.message || String(err) });
+        }
+      }
+
+      const isSingleThread = threadIDs.length === 1;
+      const finalResult = isSingleThread && results.length === 1
+        ? results[0]
+        : { success: errors.length === 0, results, errors: errors.length ? errors : undefined, timestamp: Date.now() };
+
+      if (errors.length === threadIDs.length) {
+        return callback(new Error(`muteThread: all ${threadIDs.length} thread(s) failed — ${errors[0]?.error}`));
+      }
+
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('muteThread', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  muteThread.presets = { ...MUTE_PRESETS };
+  muteThread.getHistory = (limit = 30) => MUTE_HISTORY.slice(0, limit);
+  muteThread.clearCache = () => { MUTE_CACHE.clear(); return { success: true }; };
+  muteThread.getPendingUnmutes = () => Array.from(SCHEDULED_UNMUTES.keys());
+
+  return muteThread;
+};