fca-phantom 1.0.0

package/phantom/dispatch/setMessageReactionMqtt.js

@@ -0,0 +1,248 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const REACTION_CACHE   = new Map();
+const REACTION_HISTORY = [];
+const MAX_HISTORY      = 300;
+
+const VALID_REACTIONS = new Set([
+  '❤️', '❤', '😆', '😮', '😢', '😠', '😡', '😍', '😂', '😭',
+  '👍', '👎', '🎉', '💯', '🔥', '🤔', '🥰', '🙏', '🤣', '😊',
+  '🥺', '💀', '😎', '🤯', '😴', '🤮', '💔', '🫶', '🤝', '💪',
+  '🙌', '👀', '🫠', '🤡', '💩', '👻', '🤖', '🔪', '🐒', '🦊',
+  '🐱', '🎁', '💋', '😲', '👏', '',
+]);
+
+const MULTI_REACT_DELAY_MS = 250;
+
+async function retryOp(fn, retries = 3, base = 400) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      const isTransient = /network|timeout|ECONNRESET|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() * 200));
+    }
+  }
+}
+
+function mqttPublishReaction(ctx, reaction, messageID, threadID) {
+  return new Promise((resolve, reject) => {
+    ctx.wsReqNumber  = (ctx.wsReqNumber  || 0) + 1;
+    ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+    const reqID       = ctx.wsReqNumber;
+    const taskPayload = {
+      thread_key:       String(threadID),
+      timestamp_ms:     Date.now(),
+      message_id:       String(messageID),
+      reaction:         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()),
+        tasks: [{
+          failure_count: null,
+          label:         '29',
+          payload:       JSON.stringify(taskPayload),
+          queue_name:    JSON.stringify(['reaction', String(messageID)]),
+          task_id:       ctx.wsTaskNumber,
+        }],
+        version_id: '7158486590867448',
+      }),
+      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, method: 'mqtt_ack', requestID: reqID });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        resolve({ success: true, method: 'mqtt_noack', requestID: reqID });
+      }
+    }, 10000);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function httpSetReaction(defaultFuncs, ctx, reaction, messageID, threadID) {
+  const form = {
+    message_id:  String(messageID),
+    thread_fbid: String(threadID),
+    reaction:    reaction || '',
+    viewer_fbid: ctx.userID,
+  };
+
+  const res = await defaultFuncs.post(
+    'https://www.facebook.com/reactions/setmessagereaction',
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && res.error) throw res;
+  return { success: true, method: 'http', messageID: String(messageID), threadID: String(threadID), reaction };
+}
+
+function recordHistory(op) {
+  REACTION_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (REACTION_HISTORY.length > MAX_HISTORY) REACTION_HISTORY.length = MAX_HISTORY;
+}
+
+async function sendOneEmoji(defaultFuncs, ctx, emoji, messageID, threadID, opts) {
+  const { preferMqtt, fallbackHttp } = opts;
+
+  if (preferMqtt && ctx.mqttClient) {
+    try {
+      return await retryOp(() => mqttPublishReaction(ctx, emoji, messageID, threadID));
+    } catch (mqttErr) {
+      utils.warn('setMessageReactionMqtt', `MQTT failed for "${emoji}", trying HTTP: ${mqttErr.message}`);
+      if (fallbackHttp) {
+        return await retryOp(() => httpSetReaction(defaultFuncs, ctx, emoji, messageID, threadID));
+      }
+      throw mqttErr;
+    }
+  } else if (fallbackHttp) {
+    return await retryOp(() => httpSetReaction(defaultFuncs, ctx, emoji, messageID, threadID));
+  } else {
+    throw new Error('setMessageReactionMqtt: MQTT not connected and HTTP fallback disabled');
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const setMessageReactionMqtt = async function setMessageReactionMqtt(reaction, messageID, threadID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+
+    const {
+      skipCache    = false,
+      preferMqtt   = true,
+      validate     = true,
+      fallbackHttp = true,
+      delayMs      = MULTI_REACT_DELAY_MS,
+    } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+
+    if (typeof callback !== 'function') {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (!messageID) throw new Error('setMessageReactionMqtt: messageID is required');
+      if (!threadID)  throw new Error('setMessageReactionMqtt: threadID is required');
+
+      const reactions = Array.isArray(reaction) ? reaction : [reaction];
+
+      if (validate) {
+        for (const r of reactions) {
+          if (r !== '' && r !== null && !VALID_REACTIONS.has(r)) {
+            utils.warn('setMessageReactionMqtt', `Emoji "${r}" is non-standard but will be attempted`);
+          }
+        }
+      }
+
+      const cacheKey = `react_${messageID}_${ctx.userID}`;
+      if (!skipCache && reactions.length === 1) {
+        const cached = REACTION_CACHE.get(cacheKey);
+        if (cached && cached.reaction === reactions[0] && (Date.now() - cached.ts < 3000)) {
+          return callback(null, { success: true, fromCache: true, reaction: reactions[0], messageID: String(messageID) });
+        }
+      }
+
+      await globalShield.addSmartDelay();
+
+      const opts   = { preferMqtt, fallbackHttp };
+      const results = [];
+
+      for (let i = 0; i < reactions.length; i++) {
+        const emoji  = reactions[i];
+        const result = await sendOneEmoji(defaultFuncs, ctx, emoji, messageID, threadID, opts);
+        results.push({ ...result, reaction: emoji });
+
+        recordHistory({ reaction: emoji, messageID: String(messageID), threadID: String(threadID), method: result.method });
+        utils.log('setMessageReactionMqtt', `Reacted "${emoji}" on message ${messageID}`);
+
+        if (i < reactions.length - 1) {
+          await new Promise(r => setTimeout(r, delayMs + Math.random() * 100));
+        }
+      }
+
+      const lastReaction = reactions[reactions.length - 1];
+      REACTION_CACHE.set(cacheKey, { reaction: lastReaction, ts: Date.now() });
+
+      const out = reactions.length === 1
+        ? { ...results[0], messageID: String(messageID), threadID: String(threadID) }
+        : { success: true, results, messageID: String(messageID), threadID: String(threadID), count: results.length };
+
+      callback(null, out);
+
+    } catch (err) {
+      utils.error('setMessageReactionMqtt', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  setMessageReactionMqtt.batch = async function batchReact(reactions, threadID, options = {}) {
+    const results = [];
+    const errors  = [];
+    for (const { reaction, messageID } of reactions) {
+      try {
+        const r = await setMessageReactionMqtt(reaction, messageID, threadID, options);
+        results.push(r);
+      } catch (err) {
+        errors.push({ messageID, error: err.message });
+      }
+      await new Promise(r => setTimeout(r, 150 + Math.random() * 100));
+    }
+    return { success: errors.length === 0, results, errors };
+  };
+
+  setMessageReactionMqtt.remove = function removeReaction(messageID, threadID, options, callback) {
+    return setMessageReactionMqtt('', messageID, threadID, options, callback);
+  };
+
+  setMessageReactionMqtt.getHistory      = (limit = 50) => REACTION_HISTORY.slice(0, limit);
+  setMessageReactionMqtt.getValidReactions = () => Array.from(VALID_REACTIONS).filter(r => r !== '');
+
+  return setMessageReactionMqtt;
+};

package/phantom/dispatch/setThreadTheme.js

@@ -0,0 +1,330 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const THEME_CACHE = new Map();
+const THEME_CACHE_TTL = 10 * 60 * 1000;
+const THEME_HISTORY = [];
+const MAX_HISTORY = 200;
+
+const COLOR_PALETTE = {
+  blue: '196241301102133',
+  purple: '370940413392601',
+  green: '169463077092846',
+  pink: '230032715012014',
+  orange: '175615189761153',
+  red: '2136751179887052',
+  yellow: '2058653964378557',
+  teal: '417639218648241',
+  black: '539927563794799',
+  white: '2873642392710980',
+  default: '196241301102133'
+};
+
+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 transient = /network|timeout|ECONNRESET|ETIMEDOUT|5\d\d|429/i.test(String(err?.message || err));
+      if (!transient) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+async function fetchBootloader(defaultFuncs, ctx) {
+  const now = Date.now();
+  const params = 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(),
+    fb_dtsg_ag: ctx.fb_dtsg,
+    jazoest: ctx.jazoest,
+    __spin_r: '1027396270',
+    __spin_b: 'trunk',
+    __spin_t: now
+  });
+  await defaultFuncs.get(`https://www.facebook.com/ajax/bootloader-endpoint/?${params}`, ctx.jar)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+}
+
+async function fetchAvailableThemes(defaultFuncs, ctx) {
+  const cacheKey = 'available_themes';
+  const cached = THEME_CACHE.get(cacheKey);
+  if (cached && Date.now() - cached.ts < THEME_CACHE_TTL) return cached.data;
+
+  const now = Date.now();
+  const form = {
+    av: ctx.userID,
+    __user: ctx.userID,
+    __a: 1,
+    __req: utils.getSignatureID(),
+    __hs: '20352.HYP:comet_pkg.2.1...0',
+    dpr: 1,
+    fb_dtsg: ctx.fb_dtsg,
+    jazoest: ctx.jazoest,
+    lsd: ctx.fb_dtsg,
+    __spin_r: '1027396270',
+    __spin_b: 'trunk',
+    __spin_t: now,
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MWPThreadThemeQuery_AllThemesQuery',
+    variables: JSON.stringify({ version: 'default' }),
+    server_timestamps: true,
+    doc_id: '24474714052117636'
+  };
+
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  const themes = res?.data?.messenger_thread_themes || [];
+  THEME_CACHE.set(cacheKey, { data: themes, ts: Date.now() });
+  return themes;
+}
+
+async function resolveThemeID(themeData, availableThemes) {
+  if (typeof themeData === 'string') {
+    const s = themeData.trim();
+    if (/^[0-9]+$/.test(s)) return { id: s, emoji: '👍' };
+
+    const found = availableThemes.find(t =>
+      t.accessibility_label && t.accessibility_label.toLowerCase().includes(s.toLowerCase())
+    );
+    if (found) return { id: found.id, emoji: found.default_emoji || '👍' };
+
+    const paletteID = COLOR_PALETTE[s.toLowerCase()];
+    if (paletteID) return { id: paletteID, emoji: '👍' };
+
+    return { id: COLOR_PALETTE.default, emoji: '👍' };
+  } else if (typeof themeData === 'object' && themeData !== null) {
+    return {
+      id: themeData.themeId || themeData.theme_id || themeData.id || COLOR_PALETTE.default,
+      emoji: themeData.emoji || themeData.customEmoji || '👍'
+    };
+  }
+  return { id: COLOR_PALETTE.default, emoji: '👍' };
+}
+
+async function legacySetTheme(defaultFuncs, ctx, threadID, themeId) {
+  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: themeId,
+            thread_id: threadID
+          }
+        }
+      }
+    })
+  };
+
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphqlbatch/', ctx.jar, legacyBody)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && !res[0]?.o0?.errors) return { success: true, method: 'legacy', themeId };
+  throw new Error('Legacy theme set failed: ' + JSON.stringify(res?.[0]?.o0?.errors));
+}
+
+async function graphqlSetTheme(defaultFuncs, ctx, threadID, themeId, emoji) {
+  const now = Date.now();
+  const form = {
+    av: ctx.userID,
+    __user: ctx.userID,
+    __a: 1,
+    __req: utils.getSignatureID(),
+    fb_dtsg: ctx.fb_dtsg,
+    jazoest: ctx.jazoest,
+    lsd: ctx.fb_dtsg,
+    __spin_r: '1027396270',
+    __spin_b: 'trunk',
+    __spin_t: now,
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MessengerThreadThemeUpdateMutation',
+    variables: JSON.stringify({
+      input: {
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.floor(Math.random() * 10000)),
+        source: 'SETTINGS',
+        thread_id: threadID.toString(),
+        theme_id: themeId.toString(),
+        custom_emoji: emoji
+      }
+    }),
+    server_timestamps: true,
+    doc_id: '9734829906576883'
+  };
+
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res?.errors?.length) throw new Error('GraphQL theme error: ' + JSON.stringify(res.errors));
+  if (res?.data?.messenger_thread_theme_update?.errors?.length) {
+    throw new Error('Theme update error: ' + JSON.stringify(res.data.messenger_thread_theme_update.errors));
+  }
+
+  return { success: true, method: 'graphql', themeId };
+}
+
+async function mqttSetTheme(ctx, threadID, themeId) {
+  if (!ctx.mqttClient) throw new Error('MQTT not connected');
+
+  const tasks = [
+    { label: 1013, queue: ['ai_generated_theme', String(threadID)] },
+    { label: 1037, queue: ['msgr_custom_thread_theme', String(threadID)] },
+    { label: 1028, queue: ['thread_theme_writer', String(threadID)] },
+    { label: 43, queue: 'thread_theme', extra: { source: null, payload: null } }
+  ];
+
+  const results = [];
+  for (const { label, queue, extra } of tasks) {
+    ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+    ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+    const msg = {
+      app_id: '772021112871879',
+      payload: JSON.stringify({
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [{
+          failure_count: null,
+          label: String(label),
+          payload: JSON.stringify({ thread_key: threadID, theme_fbid: themeId, sync_group: 1, ...(extra || {}) }),
+          queue_name: typeof queue === 'string' ? queue : JSON.stringify(queue),
+          task_id: ctx.wsTaskNumber
+        }],
+        version_id: '24227364673632991'
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3
+    };
+
+    await new Promise((resolve, reject) => {
+      ctx.mqttClient.publish('/ls_req', JSON.stringify(msg), { qos: 1, retain: false }, (err) => {
+        if (err) reject(err); else resolve();
+      });
+    });
+    results.push({ label, queue });
+  }
+
+  return { success: true, method: 'mqtt', themeId, tasks: results.length };
+}
+
+function recordHistory(op) {
+  THEME_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (THEME_HISTORY.length > MAX_HISTORY) THEME_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setThreadTheme(threadID, themeData, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const {
+      preferMqtt = !!ctx.mqttClient,
+      preferLegacy = true,
+      skipBootloader = true,
+      fetchThemes = true
+    } = options;
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== 'function') {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!threadID) return callback({ error: 'setThreadTheme: threadID is required' });
+
+    (async () => {
+      try {
+        const now = Date.now();
+
+        if (!skipBootloader) {
+          try { await retryOp(() => fetchBootloader(defaultFuncs, ctx)); } catch (_) {}
+        }
+
+        let availableThemes = [];
+        if (fetchThemes) {
+          try { availableThemes = await retryOp(() => fetchAvailableThemes(defaultFuncs, ctx)); } catch (_) {}
+        }
+
+        const { id: chosenThemeId, emoji: chosenEmoji } = await resolveThemeID(themeData, availableThemes);
+
+        await globalShield.addSmartDelay();
+
+        let result;
+
+        if (preferMqtt && ctx.mqttClient) {
+          try {
+            result = await retryOp(() => mqttSetTheme(ctx, threadID, chosenThemeId));
+          } catch (mqttErr) {
+            utils.warn('setThreadTheme', 'MQTT failed, using HTTP:', mqttErr.message);
+            if (preferLegacy) {
+              try { result = await retryOp(() => legacySetTheme(defaultFuncs, ctx, threadID, chosenThemeId)); }
+              catch (_) { result = await retryOp(() => graphqlSetTheme(defaultFuncs, ctx, threadID, chosenThemeId, chosenEmoji)); }
+            } else {
+              result = await retryOp(() => graphqlSetTheme(defaultFuncs, ctx, threadID, chosenThemeId, chosenEmoji));
+            }
+          }
+        } else if (preferLegacy) {
+          try { result = await retryOp(() => legacySetTheme(defaultFuncs, ctx, threadID, chosenThemeId)); }
+          catch (legacyErr) {
+            utils.warn('setThreadTheme', 'Legacy failed, using GraphQL:', legacyErr.message);
+            result = await retryOp(() => graphqlSetTheme(defaultFuncs, ctx, threadID, chosenThemeId, chosenEmoji));
+          }
+        } else {
+          result = await retryOp(() => graphqlSetTheme(defaultFuncs, ctx, threadID, chosenThemeId, chosenEmoji));
+        }
+
+        const themeList = availableThemes.length
+          ? availableThemes.map(t => ({ id: t.id, name: t.accessibility_label, description: t.description }))
+          : null;
+
+        const finalResult = {
+          threadID: String(threadID),
+          themeId: chosenThemeId,
+          customEmoji: chosenEmoji,
+          method: result.method,
+          success: true,
+          timestamp: now,
+          availableThemes: themeList
+        };
+
+        THEME_CACHE.set(`thread_theme_${threadID}`, { result: finalResult, ts: Date.now() });
+        recordHistory({ threadID: String(threadID), themeId: chosenThemeId, method: result.method });
+        utils.log('setThreadTheme', `Set theme ${chosenThemeId} on thread ${threadID} via ${result.method}`);
+
+        callback(null, finalResult);
+      } catch (err) {
+        utils.error('setThreadTheme', err);
+        callback(err);
+      }
+    })();
+
+    return promise;
+  };
+
+  Object.assign(module.exports, {
+    getColorPalette: () => ({ ...COLOR_PALETTE }),
+    getHistory: (limit = 30) => THEME_HISTORY.slice(0, limit),
+    clearCache: () => { THEME_CACHE.clear(); return { success: true }; }
+  });
+};