fca-phantom 1.0.0

package/phantom/dispatch/sendMessageMqtt.js

@@ -0,0 +1,249 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+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 globalShield.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 globalShield.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/phantom/dispatch/sendTypingIndicator.js

@@ -0,0 +1,206 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const TYPING_STATE = new Map();
+const DEBOUNCE_TIMERS = new Map();
+const AUTO_STOP_TIMERS = new Map();
+const TYPING_METRICS = { sent: 0, errors: 0, debounced: 0 };
+const RATE_LIMIT = new Map();
+const RATE_LIMIT_TTL = 1000;
+const RATE_LIMIT_MAX = 3;
+
+function getThreadCache(ctx) {
+  if (!ctx.threadTypeCache) ctx.threadTypeCache = Object.create(null);
+  return ctx.threadTypeCache;
+}
+
+async function isGroupThread(ctx, api, threadID) {
+  const tid = String(threadID);
+  const cache = getThreadCache(ctx);
+  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;
+  }
+}
+
+function isRateLimited(threadID) {
+  const now = Date.now();
+  const key = String(threadID);
+  const entry = RATE_LIMIT.get(key);
+  if (!entry || now - entry.windowStart > RATE_LIMIT_TTL) {
+    RATE_LIMIT.set(key, { count: 1, windowStart: now });
+    return false;
+  }
+  if (entry.count >= RATE_LIMIT_MAX) return true;
+  entry.count++;
+  return false;
+}
+
+async function publishTyping(ctx, isGroup, threadID, sendTyping) {
+  const wsContent = {
+    app_id: 2220391788200892,
+    payload: JSON.stringify({
+      label: 3,
+      payload: JSON.stringify({
+        thread_key: String(threadID),
+        is_group_thread: +isGroup,
+        is_typing: +sendTyping,
+        attribution: 0
+      }),
+      version: 5849951561777440
+    }),
+    request_id: ++ctx.wsReqNumber,
+    type: 4
+  };
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('sendTypingIndicator: MQTT publish timed out')), 8000);
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), { qos: 1 }, (err) => {
+      clearTimeout(timer);
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  async function sendTypingIndicatorCore(sendTyping, threadID) {
+    if (!ctx.mqttClient) throw new Error('sendTypingIndicator: MQTT not connected (start listening first)');
+
+    const tid = String(threadID);
+    const currentState = TYPING_STATE.get(tid);
+    if (currentState === sendTyping) {
+      TYPING_METRICS.debounced++;
+      return { skipped: true, reason: 'state_unchanged', threadID: tid };
+    }
+
+    if (isRateLimited(tid)) {
+      TYPING_METRICS.debounced++;
+      return { skipped: true, reason: 'rate_limited', threadID: tid };
+    }
+
+    let isGroup;
+    try {
+      isGroup = await isGroupThread(ctx, api, tid);
+    } catch (_) {
+      isGroup = tid.length >= 16;
+    }
+
+    await publishTyping(ctx, isGroup, tid, sendTyping);
+
+    TYPING_STATE.set(tid, sendTyping);
+    TYPING_METRICS.sent++;
+    utils.log('sendTypingIndicator', `Thread ${tid}: ${sendTyping ? 'start' : 'stop'} typing`);
+    return { success: true, threadID: tid, isTyping: sendTyping, isGroup };
+  }
+
+  return async function sendTypingIndicator(sendTyping, threadID, callback) {
+    const {
+      debounce = 0,
+      autoStop = null,
+      force = false
+    } = typeof callback === 'object' && callback !== null && !Array.isArray(callback)
+      ? (callback = undefined, arguments[2])
+      : {};
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const done = (err, data) => {
+      if (callback) callback(err, data);
+      if (err) rejectFunc(err);
+      else resolveFunc(data);
+    };
+
+    if (sendTyping !== true && sendTyping !== false) {
+      done(new Error('sendTypingIndicator: first argument must be boolean'));
+      return returnPromise;
+    }
+
+    const tid = String(threadID);
+
+    if (debounce > 0 && !force) {
+      if (DEBOUNCE_TIMERS.has(tid)) {
+        clearTimeout(DEBOUNCE_TIMERS.get(tid));
+        TYPING_METRICS.debounced++;
+      }
+      DEBOUNCE_TIMERS.set(tid, setTimeout(async () => {
+        DEBOUNCE_TIMERS.delete(tid);
+        try {
+          const result = await sendTypingIndicatorCore(sendTyping, tid);
+          done(null, result);
+        } catch (err) {
+          TYPING_METRICS.errors++;
+          utils.error('sendTypingIndicator', err);
+          done(err);
+        }
+      }, debounce));
+      return returnPromise;
+    }
+
+    try {
+      if (AUTO_STOP_TIMERS.has(tid)) {
+        clearTimeout(AUTO_STOP_TIMERS.get(tid));
+        AUTO_STOP_TIMERS.delete(tid);
+      }
+
+      const result = await sendTypingIndicatorCore(sendTyping, tid);
+
+      if (sendTyping && autoStop && typeof autoStop === 'number' && autoStop > 0) {
+        const stopTimer = setTimeout(async () => {
+          AUTO_STOP_TIMERS.delete(tid);
+          try { await sendTypingIndicatorCore(false, tid); } catch (_) {}
+        }, autoStop);
+        AUTO_STOP_TIMERS.set(tid, stopTimer);
+      }
+
+      if (!sendTyping) {
+        TYPING_STATE.delete(tid);
+      }
+
+      done(null, result);
+    } catch (err) {
+      TYPING_METRICS.errors++;
+      utils.error('sendTypingIndicator', err);
+      done(err);
+    }
+
+    return returnPromise;
+  };
+
+  Object.assign(module.exports, {
+    getMetrics: () => ({ ...TYPING_METRICS }),
+    getTypingThreads: () => Array.from(TYPING_STATE.entries()).filter(([, v]) => v).map(([k]) => k),
+    stopAllTyping: async () => {
+      const threads = Array.from(TYPING_STATE.entries()).filter(([, v]) => v).map(([k]) => k);
+      for (const tid of threads) {
+        try {
+          if (ctx.mqttClient) {
+            const isGroup = tid.length >= 16;
+            await publishTyping(ctx, isGroup, tid, false);
+            TYPING_STATE.set(tid, false);
+          }
+        } catch (_) {}
+      }
+      return { stopped: threads };
+    },
+    clearAllTimers: () => {
+      for (const t of DEBOUNCE_TIMERS.values()) clearTimeout(t);
+      for (const t of AUTO_STOP_TIMERS.values()) clearTimeout(t);
+      DEBOUNCE_TIMERS.clear();
+      AUTO_STOP_TIMERS.clear();
+    }
+  });
+};

package/phantom/dispatch/setMessageReaction.js

@@ -0,0 +1,188 @@
+"use strict";
+
+/**
+ * setMessageReaction — Multi-Emoji Message Reaction Handler for Phantom SDK
+ *
+ * Strategy:
+ *  1. MQTT path (setMessageReactionMqtt) — preferred, low-latency
+ *  2. GraphQL webgraphql/mutation fallback — when MQTT unavailable or fails
+ *  3. Batch support: pass arrays of messageIDs
+ *  4. Multi-emoji support: pass array of emoji strings as `reaction`
+ *  5. Retry with exponential backoff on transient failures
+ *  6. Full callback + Promise dual API
+ *
+ * @param {string|string[]} reaction   Single emoji, array of emojis, or "" to remove all.
+ * @param {string|string[]} messageID  Message ID or array of message IDs
+ * @param {string}          [threadID] Thread ID (needed for MQTT path)
+ * @param {object}          [options]  { retries, preferMqtt, delayMs }
+ * @param {Function}        [callback] Node-style (err, result)
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+const VALID_REACTIONS = new Set([
+  '😍', '😆', '😮', '😢', '😠', '😡', '😲', '😂', '😭',
+  '👍', '👎', '❤️', '🎉', '👏', '🔥', '🤔', '💯', '🥰',
+  '🙏', '🤣', '😊', '🥺', '💀', '😎', '🤯', '😴', '🤮',
+  '🔪', '🐒', '🦊', '🐱', '🎁', '💋', '💔', '❤', '🫶',
+  '🤝', '💪', '🙌', '👀', '🫠', '🤡', '💩', '👻', '🤖',
+  '',
+]);
+
+const MULTI_REACT_DELAY_MS = 250;
+
+async function graphqlReaction(defaultFuncs, ctx, reaction, messageID, retries, baseMs) {
+  const action = reaction === '' ? 'REMOVE_REACTION' : 'ADD_REACTION';
+  let lastErr;
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const defData = await defaultFuncs.postFormData(
+        "https://www.facebook.com/webgraphql/mutation/",
+        ctx.jar,
+        {},
+        {
+          doc_id:    "1491398900900362",
+          variables: JSON.stringify({
+            data: {
+              client_mutation_id: String(ctx.clientMutationId != null ? ctx.clientMutationId++ : Math.floor(Math.random() * 1e9)),
+              actor_id:           ctx.userID,
+              action,
+              message_id:         messageID,
+              reaction,
+            }
+          }),
+          dpr: 1,
+        }
+      );
+
+      const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+      if (!resData) throw new Error("setMessageReaction: GraphQL returned empty object");
+      if (resData.error) throw new Error(JSON.stringify(resData.error));
+      return resData;
+    } catch (err) {
+      lastErr = err;
+      if (attempt >= retries || /fatal|auth|checkpoint/i.test(err.message)) throw err;
+      const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 200;
+      utils.warn("setMessageReaction", `Retry ${attempt}/${retries} for ${messageID} in ${Math.round(wait)}ms`);
+      await new Promise(r => setTimeout(r, wait));
+    }
+  }
+  throw lastErr;
+}
+
+function mqttReaction(ctx, reaction, messageID, threadID) {
+  if (!ctx.mqttClient) throw new Error("setMessageReaction: MQTT client not available");
+
+  ctx.wsReqNumber  = (ctx.wsReqNumber  || 0) + 1;
+  ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+  const taskPayload = {
+    thread_key:       threadID.toString(),
+    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 content = {
+    app_id:     '2220391788200892',
+    payload:    JSON.stringify({
+      data_trace_id: null,
+      epoch_id:      parseInt(utils.generateOfflineThreadingID ? utils.generateOfflineThreadingID() : Date.now()),
+      tasks:         [{
+        failure_count: null,
+        label:         '29',
+        payload:       JSON.stringify(taskPayload),
+        queue_name:    JSON.stringify(['reaction', messageID]),
+        task_id:       ctx.wsTaskNumber,
+      }],
+      version_id: '7158486590867448',
+    }),
+    request_id: ctx.wsReqNumber,
+    type:       3,
+  };
+
+  return new Promise((resolve, reject) => {
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, err => {
+      if (err) reject(new Error(`MQTT publish failed: ${err.message}`));
+      else resolve({ success: true, method: 'mqtt', messageID, reaction });
+    });
+  });
+}
+
+async function sendSingleReaction(defaultFuncs, ctx, reaction, msgId, threadID, options) {
+  const retries = options.retries || 3;
+  const baseMs  = 500;
+  const useMqtt = options.preferMqtt !== false && ctx.mqttClient && !!threadID;
+
+  if (useMqtt) {
+    try {
+      return await mqttReaction(ctx, reaction, msgId, threadID);
+    } catch (mqttErr) {
+      utils.warn("setMessageReaction", `MQTT failed for ${msgId} — falling back to GraphQL: ${mqttErr.message}`);
+    }
+  }
+  return await graphqlReaction(defaultFuncs, ctx, reaction, msgId, retries, baseMs);
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  return async function setMessageReaction(reaction, messageID, threadID, options, callback) {
+    if (typeof threadID === 'object' && !Array.isArray(threadID)) { options = threadID; threadID = null; }
+    if (typeof threadID === 'function') { callback = threadID; threadID = null; options = {}; }
+    if (typeof options  === 'function') { callback = options;  options  = {}; }
+    options = options || {};
+
+    if (reaction === undefined || reaction === null) {
+      throw new Error("setMessageReaction: reaction is required (emoji, array of emojis, or '' to remove)");
+    }
+
+    const reactions  = Array.isArray(reaction)   ? reaction   : [reaction];
+    const ids        = Array.isArray(messageID)   ? messageID  : [messageID];
+    const delayMs    = options.delayMs ?? MULTI_REACT_DELAY_MS;
+    const results    = [];
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+
+    function done(err, data) {
+      if (callback) return err ? callback(err) : callback(null, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    }
+
+    try {
+      for (const msgId of ids) {
+        const msgResults = [];
+
+        for (let i = 0; i < reactions.length; i++) {
+          const r = reactions[i];
+
+          if (r !== '' && !VALID_REACTIONS.has(r)) {
+            utils.warn("setMessageReaction", `Emoji "${r}" is non-standard but will be attempted`);
+          }
+
+          const res = await sendSingleReaction(defaultFuncs, ctx, r, msgId, threadID, options);
+          msgResults.push(res);
+
+          if (i < reactions.length - 1) {
+            await new Promise(rr => setTimeout(rr, delayMs + Math.random() * 100));
+          }
+        }
+
+        results.push(reactions.length === 1 ? msgResults[0] : msgResults);
+      }
+
+      const out = ids.length === 1 ? results[0] : results;
+      done(null, out);
+    } catch (err) {
+      utils.error("setMessageReaction", err.message || err);
+      done(err);
+    }
+
+    return promise;
+  };
+};