fca-phantom 1.0.0

package/phantom/dispatch/setThreadThemeMqtt.js

@@ -0,0 +1,207 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const THEME_MQTT_HISTORY = [];
+const MAX_HISTORY = 200;
+const DEDUP = new Map();
+const DEDUP_TTL = 2000;
+
+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 transient = /network|timeout|ECONNRESET|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() * 200));
+    }
+  }
+}
+
+const TASK_DEFINITIONS = [
+  { label: 1013, queue: (tid) => ['ai_generated_theme', String(tid)] },
+  { label: 1037, queue: (tid) => ['msgr_custom_thread_theme', String(tid)] },
+  { label: 1028, queue: (tid) => ['thread_theme_writer', String(tid)] },
+  { label: 43, queue: () => 'thread_theme', extra: { source: null, payload: null } }
+];
+
+function buildThemeTask(ctx, threadID, themeFBID, taskDef, baseTaskNumber) {
+  const { label, queue, extra = {} } = taskDef;
+  const queueName = typeof queue === 'function' ? queue(threadID) : queue;
+
+  return {
+    failure_count: null,
+    label: String(label),
+    payload: JSON.stringify({
+      thread_key: threadID,
+      theme_fbid: themeFBID,
+      sync_group: 1,
+      ...extra
+    }),
+    queue_name: typeof queueName === 'string' ? queueName : JSON.stringify(queueName),
+    task_id: baseTaskNumber
+  };
+}
+
+function buildThemeMessage(ctx, threadID, themeFBID, taskDef) {
+  ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+  ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+  const task = buildThemeTask(ctx, threadID, themeFBID, taskDef, ctx.wsTaskNumber);
+
+  return {
+    app_id: '772021112871879',
+    payload: JSON.stringify({
+      epoch_id: parseInt(utils.generateOfflineThreadingID()),
+      tasks: [task],
+      version_id: '24227364673632991'
+    }),
+    request_id: ctx.wsReqNumber,
+    type: 3
+  };
+}
+
+function publishMessage(ctx, msg) {
+  return new Promise((resolve, reject) => {
+    ctx.mqttClient.publish(
+      '/ls_req',
+      JSON.stringify(msg),
+      { qos: 1, retain: false },
+      (err) => { if (err) reject(err); else resolve({ success: true, request_id: msg.request_id }); }
+    );
+  });
+}
+
+function publishMessageWithAck(ctx, msg) {
+  return new Promise((resolve, reject) => {
+    const reqID = msg.request_id;
+    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, request_id: reqID, acked: true });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        resolve({ success: true, request_id: reqID, acked: false });
+      }
+    }, 8000);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(msg), { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+function recordHistory(op) {
+  THEME_MQTT_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (THEME_MQTT_HISTORY.length > MAX_HISTORY) THEME_MQTT_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const setThreadThemeMqtt = async function setThreadThemeMqtt(threadID, themeFBID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const { useAck = false, dedup = true, addDelay = true } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const done = (err, data) => {
+      if (typeof callback === 'function') callback(err, data);
+      if (err) rejectFunc(err);
+      else resolveFunc(data);
+    };
+
+    try {
+      if (!ctx.mqttClient) throw new Error('setThreadThemeMqtt: MQTT not connected');
+      if (!threadID) throw new Error('setThreadThemeMqtt: threadID is required');
+      if (!themeFBID) throw new Error('setThreadThemeMqtt: themeFBID is required');
+
+      const dedupKey = `theme_${threadID}_${themeFBID}`;
+      if (dedup) {
+        const last = DEDUP.get(dedupKey);
+        if (last && Date.now() - last < DEDUP_TTL) {
+          return done(null, { success: true, skipped: true, reason: 'dedup', threadID: String(threadID), themeFBID: String(themeFBID) });
+        }
+        DEDUP.set(dedupKey, Date.now());
+      }
+
+      if (addDelay) await globalShield.addSmartDelay();
+
+      const publish = useAck ? publishMessageWithAck : publishMessage;
+      const results = [];
+
+      for (const taskDef of TASK_DEFINITIONS) {
+        const msg = buildThemeMessage(ctx, threadID, themeFBID, taskDef);
+        try {
+          const r = await retryOp(() => publish(ctx, msg));
+          results.push({ ...r, label: taskDef.label });
+        } catch (err) {
+          utils.warn('setThreadThemeMqtt', `Task label ${taskDef.label} failed:`, err.message);
+          results.push({ success: false, label: taskDef.label, error: err.message });
+        }
+      }
+
+      const successCount = results.filter(r => r.success).length;
+      const result = {
+        success: successCount > 0,
+        threadID: String(threadID),
+        themeFBID: String(themeFBID),
+        tasksPublished: successCount,
+        tasksFailed: results.length - successCount,
+        results,
+        timestamp: Date.now()
+      };
+
+      recordHistory({ threadID: String(threadID), themeFBID: String(themeFBID), successCount });
+      utils.log('setThreadThemeMqtt', `Set theme ${themeFBID} on thread ${threadID} (${successCount}/${results.length} tasks succeeded)`);
+
+      done(null, result);
+    } catch (err) {
+      utils.error('setThreadThemeMqtt', err);
+      done(err);
+    }
+
+    return returnPromise;
+  };
+
+  setThreadThemeMqtt.batch = async function batchSetTheme(items, options = {}) {
+    const results = [];
+    const errors = [];
+    for (const { threadID, themeFBID } of items) {
+      try {
+        const r = await setThreadThemeMqtt(threadID, themeFBID, options);
+        results.push(r);
+      } catch (err) {
+        errors.push({ threadID, themeFBID, error: err.message });
+      }
+      await new Promise(r => setTimeout(r, 200 + Math.random() * 100));
+    }
+    return { success: errors.length === 0, results, errors, timestamp: Date.now() };
+  };
+
+  setThreadThemeMqtt.getHistory = (limit = 30) => THEME_MQTT_HISTORY.slice(0, limit);
+  setThreadThemeMqtt.clearDedup = () => { DEDUP.clear(); return { success: true }; };
+
+  return setThreadThemeMqtt;
+};

package/phantom/dispatch/share.js

@@ -0,0 +1,200 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const PREVIEW_CACHE = new Map();
+const PREVIEW_CACHE_TTL = 15 * 60 * 1000;
+const SHARE_HISTORY = [];
+const MAX_HISTORY = 200;
+const INFLIGHT_PREVIEWS = new Map();
+
+const FALLBACK_DOC_IDS = [
+  '28939050904374351',
+  '9553764061351979',
+  '6419764884719809'
+];
+
+async function retryOp(fn, retries = 4, base = 600) {
+  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));
+    }
+  }
+}
+
+function formatPreviewResult(data) {
+  if (data.errors) throw data.errors[0];
+  const previewData = data.data?.xma_preview_data;
+  if (!previewData) throw { error: 'Could not generate a preview for this post.' };
+
+  return {
+    postID: previewData.post_id,
+    header: previewData.header_title,
+    subtitle: previewData.subtitle_text,
+    title: previewData.title_text,
+    previewImage: previewData.preview_url,
+    favicon: previewData.favicon_url,
+    headerImage: previewData.header_image_url,
+    timestamp: Date.now()
+  };
+}
+
+function isPersistedQueryError(resData) {
+  if (!resData?.errors) return false;
+  return resData.errors.some(e => {
+    const msg = (e.message || '').toLowerCase();
+    return msg.includes('persistedquerynotfound') ||
+      (msg.includes('document') && msg.includes('not found')) ||
+      msg.includes('persisted query');
+  });
+}
+
+async function tryFetchPreview(defaultFuncs, ctx, postID, docId) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'CometXMAProxyShareablePreviewQuery',
+    variables: JSON.stringify({ shareable_id: postID.toString(), scale: 3 }),
+    doc_id: docId
+  };
+
+  const resData = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (isPersistedQueryError(resData)) {
+    throw Object.assign(new Error(`doc_id "${docId}" expired or not found`), { isExpiredDocId: true });
+  }
+
+  return formatPreviewResult(resData);
+}
+
+function recordHistory(op) {
+  SHARE_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (SHARE_HISTORY.length > MAX_HISTORY) SHARE_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const getPostPreview = async function getPostPreview(postID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+
+    const {
+      skipCache = false,
+      tryFallbackDocIds = true,
+      timeout = 15000
+    } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const cb = (err, data) => {
+      if (callback) callback(err, data);
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (!postID) {
+      cb({ error: 'share: A postID is required to generate a preview.' });
+      return returnPromise;
+    }
+
+    const pid = postID.toString();
+    const cacheKey = `preview_${pid}`;
+
+    if (!skipCache) {
+      const cached = PREVIEW_CACHE.get(cacheKey);
+      if (cached && Date.now() - cached.ts < PREVIEW_CACHE_TTL) {
+        cb(null, { ...cached.result, fromCache: true });
+        return returnPromise;
+      }
+    }
+
+    if (INFLIGHT_PREVIEWS.has(pid)) {
+      try {
+        const r = await INFLIGHT_PREVIEWS.get(pid);
+        cb(null, r);
+      } catch (err) { cb(err); }
+      return returnPromise;
+    }
+
+    const promise = (async () => {
+      const docIds = [
+        ctx.options?.sharePreviewDocId,
+        ...FALLBACK_DOC_IDS
+      ].filter(Boolean);
+
+      let lastErr;
+
+      for (const docId of docIds) {
+        try {
+          await globalShield.addSmartDelay();
+          const result = await retryOp(() => tryFetchPreview(defaultFuncs, ctx, pid, docId));
+          PREVIEW_CACHE.set(cacheKey, { result, ts: Date.now() });
+          recordHistory({ postID: pid, docId, success: true });
+          utils.log('share', `Preview fetched for post ${pid} using doc_id ${docId}`);
+          return { ...result, docIdUsed: docId };
+        } catch (err) {
+          lastErr = err;
+          if (err.isExpiredDocId) {
+            utils.warn('share', `doc_id "${docId}" expired, trying next`);
+            if (!tryFallbackDocIds) break;
+          } else {
+            utils.warn('share', `Preview fetch failed with doc_id "${docId}":`, err.message || err);
+            if (!tryFallbackDocIds) break;
+          }
+        }
+      }
+
+      throw Object.assign(lastErr || new Error('All doc_ids exhausted'), {
+        hint: 'Update ctx.options.sharePreviewDocId with current value from Messenger traffic (CometXMAProxyShareablePreviewQuery)',
+        triedDocIds: docIds
+      });
+    })();
+
+    INFLIGHT_PREVIEWS.set(pid, promise);
+
+    try {
+      const r = await promise;
+      cb(null, r);
+    } catch (err) {
+      utils.error('share', err);
+      cb(err);
+    } finally {
+      INFLIGHT_PREVIEWS.delete(pid);
+    }
+
+    return returnPromise;
+  };
+
+  getPostPreview.batch = async function batchPreviews(postIDs, options = {}) {
+    const results = [];
+    const errors = [];
+    for (const postID of postIDs) {
+      try {
+        const r = await getPostPreview(postID, options);
+        results.push(r);
+      } catch (err) {
+        errors.push({ postID, error: err.message || String(err) });
+      }
+    }
+    return { success: errors.length === 0, results, errors, timestamp: Date.now() };
+  };
+
+  getPostPreview.clearCache = (postID) => {
+    if (postID) PREVIEW_CACHE.delete(`preview_${postID}`);
+    else PREVIEW_CACHE.clear();
+    return { success: true };
+  };
+
+  getPostPreview.getHistory = (limit = 30) => SHARE_HISTORY.slice(0, limit);
+  getPostPreview.updateDocId = (docId) => { if (!ctx.options) ctx.options = {}; ctx.options.sharePreviewDocId = docId; };
+
+  return getPostPreview;
+};

package/phantom/dispatch/shareContact.js

@@ -0,0 +1,216 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const SHARE_HISTORY = [];
+const MAX_HISTORY = 200;
+const DEDUP_MAP = new Map();
+const DEDUP_TTL = 3000;
+
+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 transient = /network|timeout|ECONNRESET|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() * 200));
+    }
+  }
+}
+
+function mqttShareContact(ctx, text, senderID, threadID) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error('MQTT not connected'));
+
+    ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+    ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+    const reqID = ctx.wsReqNumber;
+    const taskID = ctx.wsTaskNumber;
+
+    const queryPayload = {
+      contact_id: String(senderID),
+      sync_group: 1,
+      text: text || '',
+      thread_id: String(threadID)
+    };
+
+    const context = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        tasks: [{
+          failure_count: null,
+          label: '359',
+          payload: JSON.stringify(queryPayload),
+          queue_name: 'messenger_contact_sharing',
+          task_id: taskID
+        }],
+        epoch_id: utils.generateOfflineThreadingID(),
+        version_id: '7214102258676893'
+      }),
+      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', senderID: String(senderID), threadID: String(threadID), requestID: reqID });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        resolve({ success: true, method: 'mqtt_noack', senderID: String(senderID), threadID: String(threadID), requestID: reqID });
+      }
+    }, 12000);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function graphqlShareContact(defaultFuncs, ctx, text, senderID, threadID) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MessengerShareContactMutation',
+    variables: JSON.stringify({
+      input: {
+        contact_id: String(senderID),
+        thread_fbid: String(threadID),
+        text: text || '',
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000))
+      }
+    }),
+    doc_id: '6219437738097867'
+  };
+
+  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, method: 'graphql', senderID: String(senderID), threadID: String(threadID) };
+}
+
+function recordHistory(op) {
+  SHARE_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (SHARE_HISTORY.length > MAX_HISTORY) SHARE_HISTORY.length = MAX_HISTORY;
+}
+
+function isDuplicate(senderID, threadID) {
+  const key = `${senderID}|${threadID}`;
+  const last = DEDUP_MAP.get(key);
+  if (last && Date.now() - last < DEDUP_TTL) return true;
+  DEDUP_MAP.set(key, Date.now());
+  return false;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const shareContact = async function shareContact(text, senderID, threadOrThreads, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const {
+      preferMqtt = true,
+      useGraphQL = false,
+      dedup = true,
+      addDelay = true
+    } = 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 (!senderID) throw new Error('shareContact: senderID is required');
+
+      const threadIDs = Array.isArray(threadOrThreads)
+        ? threadOrThreads.map(String)
+        : [String(threadOrThreads)];
+
+      if (threadIDs.length === 0) throw new Error('shareContact: at least one threadID is required');
+
+      if (addDelay) await globalShield.addSmartDelay();
+
+      const results = [];
+      const errors = [];
+
+      for (const tid of threadIDs) {
+        if (dedup && isDuplicate(String(senderID), tid)) {
+          results.push({ skipped: true, reason: 'dedup', senderID: String(senderID), threadID: tid });
+          continue;
+        }
+
+        try {
+          let result;
+
+          if (useGraphQL) {
+            result = await retryOp(() => graphqlShareContact(defaultFuncs, ctx, text, senderID, tid));
+          } else if (preferMqtt && ctx.mqttClient) {
+            try {
+              result = await retryOp(() => mqttShareContact(ctx, text, senderID, tid));
+            } catch (mqttErr) {
+              utils.warn('shareContact', `MQTT failed for thread ${tid}, trying GraphQL:`, mqttErr.message);
+              result = await retryOp(() => graphqlShareContact(defaultFuncs, ctx, text, senderID, tid));
+            }
+          } else {
+            result = await retryOp(() => graphqlShareContact(defaultFuncs, ctx, text, senderID, tid));
+          }
+
+          results.push(result);
+          recordHistory({ senderID: String(senderID), threadID: tid, text, method: result.method });
+
+          if (threadIDs.length > 1) await new Promise(r => setTimeout(r, 200 + Math.random() * 150));
+        } catch (err) {
+          errors.push({ threadID: tid, error: err.message || String(err) });
+        }
+      }
+
+      const isSingle = threadIDs.length === 1;
+      const finalResult = isSingle && 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(`shareContact: all ${threadIDs.length} sends failed — ${errors[0]?.error}`));
+      }
+
+      utils.log('shareContact', `Shared contact ${senderID} to ${results.length} thread(s)`);
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('shareContact', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  shareContact.getHistory = (limit = 50) => SHARE_HISTORY.slice(0, limit);
+  shareContact.clearDedup = () => { DEDUP_MAP.clear(); return { success: true }; };
+
+  return shareContact;
+};