fca-phantom 1.0.0

package/phantom/dispatch/gcmember.js

@@ -0,0 +1,138 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function retryOp(fn, retries = 3, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 200));
+    }
+  }
+}
+
+async function mqttGcMember(ctx, action, users, threadID) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error("MQTT not connected"));
+
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    let queryPayload, query;
+    if (action === "add") {
+      queryPayload = {
+        thread_key: parseInt(threadID),
+        contact_ids: users.map(id => parseInt(id)),
+        sync_group: 1
+      };
+      query = {
+        failure_count: null,
+        label: "23",
+        payload: JSON.stringify(queryPayload),
+        queue_name: threadID,
+        task_id: taskID
+      };
+    } else {
+      queryPayload = { thread_id: threadID, contact_id: users[0], sync_group: 1 };
+      query = {
+        failure_count: null,
+        label: "140",
+        payload: JSON.stringify(queryPayload),
+        queue_name: "remove_participant_v2",
+        task_id: taskID
+      };
+    }
+
+    const context = JSON.stringify({
+      app_id: ctx.appID || "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: "24631415369801570"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    ctx.mqttClient.publish("/ls_req", context, { qos: 1, retain: false }, (err) => {
+      if (err) return reject(err);
+      resolve({
+        type: "gc_member_update",
+        threadID,
+        userIDs: users,
+        action,
+        senderID: ctx.userID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+        method: "mqtt"
+      });
+    });
+  });
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function gcmember(action, userIDs, threadID, callback) {
+    let _callback;
+    if (typeof threadID === "function") { _callback = threadID; threadID = null; }
+    else if (typeof callback === "function") { _callback = callback; }
+
+    let resolvePromise, rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+
+    if (typeof _callback !== "function") {
+      _callback = (err, data) => {
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      };
+    }
+
+    try {
+      const validActions = ["add", "remove"];
+      action = String(action || "").toLowerCase();
+
+      if (!validActions.includes(action))
+        return _callback(null, { type: "error_gc", error: `Invalid action. Must be: ${validActions.join(", ")}` });
+      if (!userIDs || (Array.isArray(userIDs) && userIDs.length === 0))
+        return _callback(null, { type: "error_gc", error: "userIDs is required" });
+      if (!threadID)
+        return _callback(null, { type: "error_gc", error: "threadID is required" });
+      if (!ctx.mqttClient)
+        return _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
+
+      const users = Array.isArray(userIDs) ? userIDs.map(String) : [String(userIDs)];
+
+      let threadInfo;
+      try { threadInfo = await api.getThreadInfo(threadID); } catch {}
+
+      if (threadInfo) {
+        if (threadInfo.isGroup === false)
+          return _callback(null, { type: "error_gc", error: "Only for group chats" });
+
+        const currentMembers = threadInfo.participantIDs || [];
+
+        if (action === "add") {
+          const alreadyIn = users.filter(id => currentMembers.includes(id));
+          if (alreadyIn.length === users.length)
+            return _callback(null, { type: "error_gc", error: "All specified users are already in the group" });
+          const toAdd = users.filter(id => !currentMembers.includes(id));
+          const result = await retryOp(() => mqttGcMember(ctx, "add", toAdd, String(threadID)));
+          return _callback(null, result);
+        } else {
+          const userToRemove = users[0];
+          if (!currentMembers.includes(userToRemove))
+            return _callback(null, { type: "error_gc", error: `User ${userToRemove} not in group` });
+        }
+      }
+
+      const result = await retryOp(() => mqttGcMember(ctx, action, users, String(threadID)));
+      _callback(null, result);
+    } catch (err) {
+      _callback(null, { type: "error_gc", error: err.message || "Unknown error" });
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/gcname.js

@@ -0,0 +1,131 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function retryOp(fn, retries = 3, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 200));
+    }
+  }
+}
+
+async function mqttSetName(ctx, newName, threadID, initiatorID) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error("MQTT not connected"));
+
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const context = JSON.stringify({
+      app_id: ctx.appID || "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [{
+          failure_count: null,
+          label: "32",
+          payload: JSON.stringify({
+            thread_key: String(threadID),
+            thread_name: newName,
+            sync_group: 1
+          }),
+          queue_name: String(threadID),
+          task_id: taskID
+        }],
+        version_id: "24631415369801570"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    ctx.mqttClient.publish("/ls_req", context, { qos: 1, retain: false }, (err) => {
+      if (err) return reject(new Error(`MQTT publish failed: ${err.message}`));
+      resolve({
+        type: "thread_name_update",
+        threadID,
+        newName,
+        senderID: initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+        method: "mqtt"
+      });
+    });
+  });
+}
+
+async function httpSetName(defaultFuncs, ctx, newName, threadID) {
+  const form = {
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "MessengerUpdateThreadNameMutation",
+    doc_id: "4648919335181350",
+    variables: JSON.stringify({
+      input: {
+        thread_id: String(threadID),
+        name: newName,
+        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 { type: "thread_name_update", threadID, newName, method: "http", timestamp: Date.now() };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return function gcname(newName, threadID, callback, initiatorID) {
+    let _callback, _initiatorID;
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const cbType = utils.getType(callback);
+    if (cbType === "Function" || cbType === "AsyncFunction") {
+      _callback = callback;
+      _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+      _callback = threadID;
+      threadID = null;
+      _initiatorID = callback;
+    } else if (cbType === "String") {
+      _initiatorID = callback;
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+    threadID = threadID || ctx.threadID;
+
+    const finalCb = (err, data) => {
+      if (typeof _callback === "function") _callback(err, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    };
+
+    if (!threadID) return finalCb(new Error("gcname: threadID is required")), returnPromise;
+    if (typeof newName !== "string") return finalCb(new Error("gcname: newName must be a string")), returnPromise;
+
+    (async () => {
+      try {
+        let result;
+        if (ctx.mqttClient) {
+          try {
+            result = await retryOp(() => mqttSetName(ctx, newName, String(threadID), _initiatorID));
+          } catch (mqttErr) {
+            utils.warn("gcname", "MQTT failed, using HTTP:", mqttErr.message);
+            result = await retryOp(() => httpSetName(defaultFuncs, ctx, newName, threadID));
+          }
+        } else {
+          result = await retryOp(() => httpSetName(defaultFuncs, ctx, newName, threadID));
+        }
+        finalCb(null, result);
+      } catch (err) {
+        utils.error("gcname", err);
+        finalCb(err);
+      }
+    })();
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/gcrule.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function retryOp(fn, retries = 3, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 200));
+    }
+  }
+}
+
+async function mqttSetAdmin(ctx, userID, threadID, isAdmin) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error("MQTT not connected"));
+
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const context = JSON.stringify({
+      app_id: ctx.appID || "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [{
+          failure_count: null,
+          label: "25",
+          payload: JSON.stringify({
+            thread_key: parseInt(threadID),
+            contact_id: parseInt(userID),
+            is_admin: isAdmin ? 1 : 0
+          }),
+          queue_name: "admin_status",
+          task_id: taskID
+        }],
+        version_id: "24631415369801570"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    ctx.mqttClient.publish("/ls_req", context, { qos: 1, retain: false }, (err) => {
+      if (err) return reject(err);
+      resolve({
+        type: "gc_rule_update",
+        threadID,
+        userID,
+        action: isAdmin ? "admin" : "unadmin",
+        senderID: ctx.userID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+        method: "mqtt"
+      });
+    });
+  });
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function gcrule(action, userID, threadID, callback) {
+    let _callback;
+    if (typeof threadID === "function") { _callback = threadID; threadID = null; }
+    else if (typeof callback === "function") { _callback = callback; }
+
+    let resolvePromise, rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+
+    if (typeof _callback !== "function") {
+      _callback = (err, data) => {
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      };
+    }
+
+    try {
+      const validActions = ["admin", "unadmin"];
+      action = String(action || "").toLowerCase();
+
+      if (!validActions.includes(action))
+        return _callback(null, { type: "error_gc_rule", error: `Invalid action. Must be: ${validActions.join(", ")}` });
+      if (!userID) return _callback(null, { type: "error_gc_rule", error: "userID is required" });
+      if (!threadID) return _callback(null, { type: "error_gc_rule", error: "threadID is required" });
+      if (!ctx.mqttClient) return _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" });
+
+      let threadInfo;
+      try { threadInfo = await api.getThreadInfo(threadID); } catch {}
+
+      if (threadInfo) {
+        if (threadInfo.isGroup === false)
+          return _callback(null, { type: "error_gc_rule", error: "Only for group chats" });
+
+        const adminIDs = threadInfo.adminIDs || [];
+        const isCurrentlyAdmin = adminIDs.some(a => String(a.id) === String(userID));
+
+        if (action === "admin" && isCurrentlyAdmin)
+          return _callback(null, { type: "error_gc_rule", error: "User is already an admin" });
+        if (action === "unadmin" && !isCurrentlyAdmin)
+          return _callback(null, { type: "error_gc_rule", error: "User is not an admin" });
+      }
+
+      const result = await retryOp(() => mqttSetAdmin(ctx, String(userID), String(threadID), action === "admin"));
+      _callback(null, result);
+    } catch (err) {
+      _callback(null, { type: "error_gc_rule", error: err.message || "Unknown error" });
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/getAccess.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const utils = require("../datastore/models/matrix/tools");
+
+async function retryOp(fn, retries = 3, base = 800) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      if (err && err.continue) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getAccess(authCode, callback) {
+    const BASE_URL = "https://business.facebook.com/";
+    const REFERER = BASE_URL + "security/twofactor/reauth/?twofac_next=" + encodeURIComponent(BASE_URL + "content_management") + "&type=avoid_bypass&app_id=0&save_device=0";
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof authCode === "function") { callback = authCode; authCode = ""; }
+
+    const cb = (err, token) => {
+      if (typeof callback === "function") callback(err, token);
+      if (err) rejectFunc(err); else resolveFunc(token);
+    };
+
+    if (ctx.access_token) {
+      cb(null, ctx.access_token);
+      return returnPromise;
+    }
+
+    (async () => {
+      try {
+        const pageRes = await retryOp(() =>
+          utils.get(BASE_URL + "content_management", ctx.jar, null, ctx.globalOptions, null, {
+            noRef: true,
+            Origin: BASE_URL
+          })
+        );
+
+        const html = pageRes.body;
+        const lsd = utils.getFrom(html, '[\"LSD\",[],{\"token\":\"', '\"}');
+        if (!lsd) throw new Error("getAccess: could not extract LSD token");
+
+        function submitCode(code) {
+          let pResolve, pReject;
+          const p = new Promise((res, rej) => { pResolve = res; pReject = rej; });
+
+          if (typeof code !== "string" || code.length !== 6 || isNaN(code)) {
+            const contErr = { error: "submitCode", lerror: "code must be a 6-digit string", continue: submitCode };
+            pReject(contErr);
+            cb(contErr);
+            return p;
+          }
+
+          defaultFuncs.post(
+            BASE_URL + "security/twofactor/reauth/enter/",
+            ctx.jar,
+            { approvals_code: code, save_device: true, lsd },
+            ctx.globalOptions, null,
+            { Referer: REFERER, Origin: BASE_URL }
+          ).then(res => {
+            const body = res.body || "";
+            let payload;
+            try { payload = JSON.parse(body.split(";").pop() || "{}").payload; } catch {}
+            if (payload && !payload.codeConfirmed) {
+              throw { error: "submitCode", lerror: payload.message, continue: submitCode };
+            }
+          }).then(() =>
+            retryOp(() => utils.get(BASE_URL + "content_management", ctx.jar, null, ctx.globalOptions, null, { noRef: true }))
+          ).then(res => {
+            const pageHtml = res.body;
+            const tokenMatch = /"accessToken":"(\S+)","clientID":/g.exec(pageHtml);
+            if (!tokenMatch) throw { error: "token-undefined", htmlData: pageHtml.substring(0, 500) };
+            ctx.access_token = tokenMatch[1];
+            pResolve(tokenMatch[1]);
+            cb(null, tokenMatch[1]);
+          }).catch(err => {
+            utils.error("getAccess.submitCode", err.error || err);
+            pReject(err);
+            cb(err);
+          });
+
+          return p;
+        }
+
+        const code = String(authCode || "");
+        if (code.length === 6 && !isNaN(code)) {
+          await submitCode(code);
+        } else if (typeof callback === "function") {
+          cb({ error: "submitCode", continue: submitCode });
+        } else {
+          throw { error: "getAccess: provide a 6-digit auth code or a callback for interactive entry" };
+        }
+      } catch (err) {
+        utils.error("getAccess", typeof callback === "function" ? (err.error || err) : err);
+        cb(err);
+      }
+    })();
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/getBotInfo.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+const BOT_INFO_CACHE = new Map();
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return function getBotInfo(netData) {
+    if (!netData || !Array.isArray(netData)) {
+      utils.error("getBotInfo", "netData must be a valid array");
+      return null;
+    }
+
+    const cacheKey = `botinfo_${ctx.userID}`;
+    const cached = BOT_INFO_CACHE.get(cacheKey);
+    if (cached && (Date.now() - cached.ts < 10 * 60 * 1000)) return cached.info;
+
+    const findConfig = (key) => {
+      for (const scriptData of netData) {
+        if (!scriptData.require) continue;
+        for (const req of scriptData.require) {
+          if (Array.isArray(req)) {
+            if (req[0] === key && req[2]) return req[2];
+            if (req[3] && req[3][0]?.__bbox?.define) {
+              for (const def of req[3][0].__bbox.define) {
+                if (Array.isArray(def) && def[0]?.endsWith(key) && def[2]) return def[2];
+              }
+            }
+          }
+        }
+      }
+      return null;
+    };
+
+    const findMultiConfig = (...keys) => {
+      for (const key of keys) {
+        const result = findConfig(key);
+        if (result) return result;
+      }
+      return null;
+    };
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const dtsgInitialData = findMultiConfig("DTSGInitialData", "DTSGInitData");
+    const lsdData = findConfig("LSD");
+    const mqttData = findConfig("MqttWebDeviceID");
+    const siteData = findConfig("SiteData");
+    const cryptoData = findConfig("CryptoConfig");
+
+    if (!currentUserData || !dtsgInitialData) {
+      utils.error("getBotInfo", "Critical data missing (CurrentUserInitialData or DTSGInitialData)");
+      return null;
+    }
+
+    const botInfo = {
+      name: currentUserData.NAME,
+      firstName: currentUserData.SHORT_NAME,
+      uid: currentUserData.USER_ID,
+      appID: currentUserData.APP_ID,
+      isBusiness: !!currentUserData.IS_BUSINESS_PERSON_ACCOUNT,
+      isPageAdmin: !!currentUserData.IS_PAGES_CREATOR,
+      locale: currentUserData.LOCALE || "en_US",
+      dtsgToken: dtsgInitialData.token,
+      dtsgAsyncToken: dtsgInitialData.async_get_token,
+      lsdToken: lsdData?.token,
+      mqttDeviceID: mqttData?.clientID,
+      siteRevision: siteData?.client_revision,
+      spinT: siteData?.spin_t,
+      cryptoKey: cryptoData?.key,
+      timestamp: Date.now(),
+
+      getCtx: (key) => ctx[key],
+      getOptions: (key) => ctx.globalOptions?.[key],
+      getRegion: () => ctx.region,
+      getRaw: (key) => findConfig(key)
+    };
+
+    BOT_INFO_CACHE.set(cacheKey, { info: botInfo, ts: Date.now() });
+    return botInfo;
+  };
+};

package/phantom/dispatch/getBotInitialData.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+const INIT_DATA_CACHE = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+
+async function retryOp(fn, retries = 3, base = 700) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+function parseInitialData(html) {
+  const extractors = [
+    { regex: /"CurrentUserInitialData",\[\],\{(.*?)\},(.*?)\]/, parse: (m) => JSON.parse(`{${m[1]}}`) },
+    { regex: /\"USER_ID\":\"(\d+)\"/, parse: (m) => ({ USER_ID: m[1] }) }
+  ];
+
+  for (const { regex, parse } of extractors) {
+    const match = html.match(regex);
+    if (match) {
+      try { return parse(match); } catch {}
+    }
+  }
+
+  const jsonBlobs = [];
+  const jsonRegex = /\{[^{}]*"USER_ID"[^{}]*\}/g;
+  let m;
+  while ((m = jsonRegex.exec(html)) !== null) {
+    try { jsonBlobs.push(JSON.parse(m[0])); } catch {}
+  }
+  return jsonBlobs[0] || null;
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function getBotInitialData(callback) {
+    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 cacheKey = `botInitialData_${ctx.userID}`;
+      const cached = INIT_DATA_CACHE.get(cacheKey);
+      if (cached && (Date.now() - cached.ts < CACHE_TTL)) {
+        return callback(null, cached.data);
+      }
+
+      utils.log("getBotInitialData: Fetching account info...");
+
+      const urls = [
+        `https://www.facebook.com/profile.php?id=${ctx.userID}`,
+        `https://www.facebook.com/me`
+      ];
+
+      let html = null;
+      for (const url of urls) {
+        try {
+          await new Promise((res, rej) => {
+            api.httpGet(url, null, { customUserAgent: utils.windowsUserAgent }, (err, data) => {
+              if (err) return rej(err);
+              html = data;
+              res();
+            }, true);
+          });
+          if (html) break;
+        } catch {}
+      }
+
+      if (!html) throw new Error("getBotInitialData: failed to fetch profile page");
+
+      const parsed = parseInitialData(html);
+      if (!parsed) {
+        return callback(null, { error: "Could not parse initial data. Rate-limited or session expired." });
+      }
+
+      const result = {
+        ...parsed,
+        name: parsed.NAME,
+        uid: parsed.USER_ID,
+        firstName: parsed.SHORT_NAME,
+        isBusiness: !!parsed.IS_BUSINESS_PERSON_ACCOUNT,
+        locale: parsed.LOCALE,
+        fetchedAt: Date.now()
+      };
+      delete result.NAME;
+      delete result.USER_ID;
+
+      INIT_DATA_CACHE.set(cacheKey, { data: result, ts: Date.now() });
+      callback(null, result);
+    } catch (err) {
+      utils.error("getBotInitialData", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};