fca-phantom 1.0.0

package/phantom/dispatch/removeUserFromGroup.js

@@ -0,0 +1,248 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const REMOVE_HISTORY = [];
+const MAX_HISTORY = 200;
+const UNDO_STACK = [];
+const MAX_UNDO = 50;
+const INFLIGHT = new Map();
+
+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 mqttRemoveUser(ctx, userID, threadID) {
+  if (!ctx.mqttClient) throw new Error('MQTT not connected');
+
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const payload = JSON.stringify({
+      epoch_id: utils.generateOfflineThreadingID(),
+      tasks: [{
+        failure_count: null,
+        label: '140',
+        payload: JSON.stringify({
+          thread_id: String(threadID),
+          contact_id: String(userID),
+          sync_group: 1
+        }),
+        queue_name: 'remove_participant_v2',
+        task_id: taskID
+      }],
+      version_id: '8798795233522156'
+    });
+
+    const form = JSON.stringify({
+      app_id: '2220391788200892',
+      payload,
+      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', userID: String(userID), threadID: String(threadID) });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(new Error('MQTT timeout for removeUserFromGroup'));
+      }
+    }, 30000);
+
+    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 httpRemoveUser(defaultFuncs, ctx, userID, threadID) {
+  const form = { uid: String(userID), tid: String(threadID) };
+  const res = await defaultFuncs.post(
+    'https://www.facebook.com/chat/remove_participants',
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && res.error) throw res;
+  return { success: true, method: 'http', userID: String(userID), threadID: String(threadID) };
+}
+
+async function graphqlRemoveUser(defaultFuncs, ctx, userID, threadID) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MessengerRemoveParticipantMutation',
+    variables: JSON.stringify({
+      input: {
+        thread_fbid: String(threadID),
+        participant_id: String(userID),
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000))
+      }
+    }),
+    doc_id: '5476918952395415'
+  };
+
+  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(JSON.stringify(res.errors));
+  return { success: true, method: 'graphql', userID: String(userID), threadID: String(threadID) };
+}
+
+function recordHistory(op) {
+  REMOVE_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (REMOVE_HISTORY.length > MAX_HISTORY) REMOVE_HISTORY.length = MAX_HISTORY;
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+
+  const removeUserFromGroup = async function removeUserFromGroup(userOrUsers, threadID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const {
+      preferMqtt = true,
+      batchDelay = 400,
+      dryRun = false
+    } = 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 (!threadID) throw new Error('removeUserFromGroup: threadID is required');
+      const tType = utils.getType(threadID);
+      if (tType !== 'Number' && tType !== 'String') throw new Error('removeUserFromGroup: threadID must be Number or String');
+
+      const userIDs = Array.isArray(userOrUsers) ? userOrUsers.map(String) : [String(userOrUsers)];
+
+      for (const uid of userIDs) {
+        const uType = utils.getType(uid);
+        if (uType !== 'Number' && uType !== 'String') throw new Error(`removeUserFromGroup: userID "${uid}" must be Number or String`);
+      }
+
+      if (dryRun) {
+        return callback(null, { dryRun: true, wouldRemove: userIDs, threadID: String(threadID), timestamp: Date.now() });
+      }
+
+      await globalShield.addSmartDelay();
+
+      const results = [];
+      const errors = [];
+
+      for (let i = 0; i < userIDs.length; i++) {
+        const uid = userIDs[i];
+        if (i > 0) await new Promise(r => setTimeout(r, batchDelay + Math.random() * 200));
+
+        const inflightKey = `${uid}_${threadID}`;
+        if (INFLIGHT.has(inflightKey)) {
+          try {
+            const r = await INFLIGHT.get(inflightKey);
+            results.push({ ...r, fromInFlight: true });
+          } catch (err) {
+            errors.push({ userID: uid, error: err.message });
+          }
+          continue;
+        }
+
+        const promise = (async () => {
+          let result;
+
+          if (preferMqtt && ctx.mqttClient) {
+            try {
+              result = await retryOp(() => mqttRemoveUser(ctx, uid, threadID));
+            } catch (mqttErr) {
+              utils.warn('removeUserFromGroup', `MQTT failed for ${uid}, trying HTTP:`, mqttErr.message);
+              try {
+                result = await retryOp(() => httpRemoveUser(defaultFuncs, ctx, uid, threadID));
+              } catch (httpErr) {
+                utils.warn('removeUserFromGroup', `HTTP failed, trying GraphQL:`, httpErr.message);
+                result = await retryOp(() => graphqlRemoveUser(defaultFuncs, ctx, uid, threadID));
+              }
+            }
+          } else {
+            try {
+              result = await retryOp(() => httpRemoveUser(defaultFuncs, ctx, uid, threadID));
+            } catch (httpErr) {
+              utils.warn('removeUserFromGroup', `HTTP failed, trying GraphQL:`, httpErr.message);
+              result = await retryOp(() => graphqlRemoveUser(defaultFuncs, ctx, uid, threadID));
+            }
+          }
+
+          return result;
+        })();
+
+        INFLIGHT.set(inflightKey, promise);
+
+        try {
+          const result = await promise;
+          results.push({ ...result, timestamp: Date.now() });
+          recordHistory({ userID: uid, threadID: String(threadID), method: result.method });
+          UNDO_STACK.unshift({ userID: uid, threadID: String(threadID), action: 'removed', ts: Date.now() });
+          if (UNDO_STACK.length > MAX_UNDO) UNDO_STACK.length = MAX_UNDO;
+          utils.log('removeUserFromGroup', `Removed user ${uid} from thread ${threadID} via ${result.method}`);
+        } catch (err) {
+          errors.push({ userID: uid, error: err.message || String(err) });
+        } finally {
+          INFLIGHT.delete(inflightKey);
+        }
+      }
+
+      const isSingle = userIDs.length === 1;
+      const finalResult = isSingle && results.length === 1
+        ? results[0]
+        : { success: errors.length === 0, results, errors: errors.length ? errors : undefined, threadID: String(threadID), timestamp: Date.now() };
+
+      if (errors.length === userIDs.length) {
+        return callback(new Error(`removeUserFromGroup: all ${userIDs.length} remove(s) failed — ${errors[0]?.error}`));
+      }
+
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('removeUserFromGroup', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  removeUserFromGroup.getHistory = (limit = 30) => REMOVE_HISTORY.slice(0, limit);
+  removeUserFromGroup.getUndoStack = () => [...UNDO_STACK];
+
+  return removeUserFromGroup;
+};

package/phantom/dispatch/resolvePhotoUrl.js

@@ -0,0 +1,217 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const PHOTO_CACHE = new Map();
+const PHOTO_CACHE_TTL = 10 * 60 * 1000;
+const PHOTO_HISTORY = [];
+const MAX_HISTORY = 300;
+const INFLIGHT = new Map();
+
+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() * 200));
+    }
+  }
+}
+
+async function fetchPhotoUrlHttp(defaultFuncs, ctx, photoID) {
+  const resData = await defaultFuncs.get(
+    'https://www.facebook.com/mercury/attachments/photo',
+    ctx.jar,
+    { photo_id: String(photoID) }
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (resData.error) throw resData;
+
+  const photoUrl = resData.jsmods?.require?.[0]?.[3]?.[0];
+  if (!photoUrl) throw new Error(`resolvePhotoUrl: URL not found in response for photo ${photoID}`);
+  return { photoUrl, method: 'http', photoID: String(photoID), timestamp: Date.now() };
+}
+
+async function fetchPhotoUrlGraphQL(defaultFuncs, ctx, photoID) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'CometPhotoRootContentQuery',
+    variables: JSON.stringify({ photoid: String(photoID), transparentBackground: false, UFIContainerType: 'default' }),
+    doc_id: '9553764061351979'
+  };
+  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(JSON.stringify(res.errors));
+
+  const media = res?.data?.viewer?.media;
+  const url = media?.image?.uri || media?.photo_image?.uri || media?.url;
+  if (!url) throw new Error(`resolvePhotoUrl: GraphQL URL not found for photo ${photoID}`);
+  return { photoUrl: url, method: 'graphql', photoID: String(photoID), timestamp: Date.now() };
+}
+
+function recordHistory(op) {
+  PHOTO_HISTORY.unshift({ ...op, ts: Date.now() });
+  if (PHOTO_HISTORY.length > MAX_HISTORY) PHOTO_HISTORY.length = MAX_HISTORY;
+}
+
+function checkCache(photoID) {
+  const key = `photo_${photoID}`;
+  const cached = PHOTO_CACHE.get(key);
+  if (cached && Date.now() - cached.ts < PHOTO_CACHE_TTL) return cached.result;
+  return null;
+}
+
+function setCache(photoID, result) {
+  PHOTO_CACHE.set(`photo_${photoID}`, { result, ts: Date.now() });
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const resolvePhotoUrl = async function resolvePhotoUrl(photoOrPhotos, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (!options || typeof options !== 'object') options = {};
+    const {
+      skipCache = false,
+      preferGraphQL = false,
+      fallback = true,
+      metadataOnly = false
+    } = 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 {
+      const isBatch = Array.isArray(photoOrPhotos);
+      const photoIDs = isBatch ? photoOrPhotos.map(String) : [String(photoOrPhotos)];
+
+      if (photoIDs.length === 0) throw new Error('resolvePhotoUrl: at least one photoID is required');
+
+      const results = [];
+      const errors = [];
+
+      for (const photoID of photoIDs) {
+        if (!photoID || photoID === 'undefined' || photoID === 'null') {
+          errors.push({ photoID, error: 'invalid photoID' });
+          continue;
+        }
+
+        if (!skipCache) {
+          const cached = checkCache(photoID);
+          if (cached) {
+            results.push({ ...cached, fromCache: true });
+            continue;
+          }
+        }
+
+        if (INFLIGHT.has(photoID)) {
+          try {
+            const result = await INFLIGHT.get(photoID);
+            results.push({ ...result, fromInFlight: true });
+          } catch (err) {
+            errors.push({ photoID, error: err.message || String(err) });
+          }
+          continue;
+        }
+
+        const inflightPromise = (async () => {
+          let result;
+          if (preferGraphQL) {
+            try {
+              result = await retryOp(() => fetchPhotoUrlGraphQL(defaultFuncs, ctx, photoID));
+            } catch (gqlErr) {
+              if (!fallback) throw gqlErr;
+              utils.warn('resolvePhotoUrl', `GraphQL failed for ${photoID}, using HTTP:`, gqlErr.message);
+              result = await retryOp(() => fetchPhotoUrlHttp(defaultFuncs, ctx, photoID));
+            }
+          } else {
+            try {
+              result = await retryOp(() => fetchPhotoUrlHttp(defaultFuncs, ctx, photoID));
+            } catch (httpErr) {
+              if (!fallback) throw httpErr;
+              utils.warn('resolvePhotoUrl', `HTTP failed for ${photoID}, using GraphQL:`, httpErr.message);
+              result = await retryOp(() => fetchPhotoUrlGraphQL(defaultFuncs, ctx, photoID));
+            }
+          }
+          return result;
+        })();
+
+        INFLIGHT.set(photoID, inflightPromise);
+
+        try {
+          const result = await inflightPromise;
+          setCache(photoID, result);
+          recordHistory({ photoID, method: result.method, url: result.photoUrl });
+          results.push(metadataOnly ? { photoID, method: result.method, timestamp: result.timestamp } : result);
+        } catch (err) {
+          errors.push({ photoID, error: err.message || String(err) });
+        } finally {
+          INFLIGHT.delete(photoID);
+        }
+      }
+
+      if (!isBatch && results.length === 1) {
+        const r = results[0];
+        return callback(null, r.photoUrl || r);
+      }
+
+      if (!isBatch && results.length === 0 && errors.length > 0) {
+        return callback(errors[0].error instanceof Error ? errors[0].error : new Error(errors[0].error));
+      }
+
+      const finalResult = {
+        success: errors.length === 0,
+        results,
+        errors: errors.length ? errors : undefined,
+        resolvedCount: results.length,
+        timestamp: Date.now()
+      };
+
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('resolvePhotoUrl', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  resolvePhotoUrl.batch = async function batchResolve(photoIDs, options = {}) {
+    return resolvePhotoUrl(photoIDs, options);
+  };
+
+  resolvePhotoUrl.getHistory = (limit = 50) => PHOTO_HISTORY.slice(0, limit);
+
+  resolvePhotoUrl.clearCache = (photoID) => {
+    if (photoID) {
+      PHOTO_CACHE.delete(`photo_${photoID}`);
+    } else {
+      PHOTO_CACHE.clear();
+    }
+    return { success: true };
+  };
+
+  resolvePhotoUrl.getCacheStats = () => {
+    const now = Date.now();
+    let valid = 0, expired = 0;
+    for (const [, entry] of PHOTO_CACHE) {
+      if (now - entry.ts < PHOTO_CACHE_TTL) valid++;
+      else expired++;
+    }
+    return { total: PHOTO_CACHE.size, valid, expired };
+  };
+
+  return resolvePhotoUrl;
+};