fca-phantom 1.0.0

package/phantom/dispatch/changeAdminStatus.js

@@ -0,0 +1,142 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+async function retryOp(fn, retries = 3, base = 600) {
+  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));
+    }
+  }
+}
+
+async function mqttChangeAdmin(ctx, threadID, adminIDs, adminStatus) {
+  return new Promise((resolve, reject) => {
+    const isAdmin = adminStatus ? 1 : 0;
+    const epochID = utils.generateOfflineThreadingID();
+    const reqID = ++ctx.wsReqNumber;
+
+    const tasks = adminIDs.map((id, idx) => ({
+      failure_count: null,
+      label: "25",
+      payload: JSON.stringify({ thread_key: threadID, contact_id: id, is_admin: isAdmin }),
+      queue_name: "admin_status",
+      task_id: ++ctx.wsTaskNumber
+    }));
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({ epoch_id: epochID, tasks, version_id: "8798795233522156" }),
+      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, adminIDs, adminStatus, method: "mqtt" });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(new Error("MQTT timeout for changeAdminStatus"));
+      }
+    }, 25000);
+
+    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 httpChangeAdmin(defaultFuncs, ctx, threadID, adminIDs, adminStatus) {
+  const tasks = adminIDs.map((id, idx) => ({
+    label: "25",
+    payload: JSON.stringify({ thread_key: threadID, contact_id: id, is_admin: adminStatus ? 1 : 0 }),
+    queue_name: "admin_status",
+    task_id: idx + 1,
+    failure_count: null
+  }));
+
+  const form = {
+    fb_dtsg: ctx.fb_dtsg,
+    request_id: 1,
+    type: 3,
+    payload: JSON.stringify({
+      version_id: "3816854585040595",
+      tasks,
+      epoch_id: utils.generateOfflineThreadingID(),
+      data_trace_id: null
+    }),
+    app_id: "772021112871879"
+  };
+
+  await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  return { success: true, adminIDs, adminStatus, method: "http" };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeAdminStatus(threadID, adminID, adminStatus, 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 {
+      if (typeof threadID !== "string" && typeof threadID !== "number")
+        throw new Error("changeAdminStatus: threadID must be a string or number");
+      if (typeof adminStatus !== "boolean")
+        throw new Error("changeAdminStatus: adminStatus must be true or false");
+
+      const adminIDs = Array.isArray(adminID) ? adminID.map(String) : [String(adminID)];
+      if (adminIDs.length === 0) throw new Error("changeAdminStatus: no adminID provided");
+
+      await globalShield.addSmartDelay();
+
+      let result;
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttChangeAdmin(ctx, threadID, adminIDs, adminStatus));
+        } catch (mqttErr) {
+          utils.warn("changeAdminStatus", "MQTT failed, using HTTP:", mqttErr.message);
+          result = await retryOp(() => httpChangeAdmin(defaultFuncs, ctx, threadID, adminIDs, adminStatus));
+        }
+      } else {
+        result = await retryOp(() => httpChangeAdmin(defaultFuncs, ctx, threadID, adminIDs, adminStatus));
+      }
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeAdminStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeArchivedStatus.js

@@ -0,0 +1,135 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const CACHE = new Map();
+const CACHE_TTL = 2 * 60 * 1000;
+
+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 httpArchive(defaultFuncs, ctx, threadIDs, archive) {
+  const form = { should_archive: archive };
+  threadIDs.forEach(id => { form[`thread_fbids[${id}]`] = true; });
+
+  const res = await defaultFuncs.post(
+    "https://www.facebook.com/ajax/mercury/change_archived_status.php",
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && res.error) throw res;
+  return { success: true, archivedThreads: threadIDs, archived: archive };
+}
+
+async function mqttArchive(ctx, threadIDs, archive) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error("MQTT not connected"));
+
+    const reqID = ++ctx.wsReqNumber;
+    const tasks = threadIDs.map((id) => ({
+      failure_count: null,
+      label: archive ? "57" : "58",
+      payload: JSON.stringify({ thread_key: id, sync_group: 1 }),
+      queue_name: "archive_thread",
+      task_id: ++ctx.wsTaskNumber
+    }));
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks,
+        version_id: "8798795233522156"
+      }),
+      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, archivedThreads: threadIDs, archived: archive, method: "mqtt" });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(new Error("MQTT timeout for changeArchivedStatus"));
+      }
+    }, 20000);
+
+    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);
+      }
+    });
+  });
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeArchivedStatus(threadIDs, archive, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof archive === "function") { callback = archive; archive = true; }
+    if (typeof callback !== "function") {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (typeof archive !== "boolean") throw new Error("changeArchivedStatus: archive must be a boolean");
+
+      const ids = Array.isArray(threadIDs) ? threadIDs.map(String) : [String(threadIDs)];
+      if (ids.length === 0) throw new Error("changeArchivedStatus: no threadIDs provided");
+
+      await globalShield.addSmartDelay();
+
+      let result;
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttArchive(ctx, ids, archive));
+        } catch (mqttErr) {
+          utils.warn("changeArchivedStatus", "MQTT failed, using HTTP:", mqttErr.message);
+          result = await retryOp(() => httpArchive(defaultFuncs, ctx, ids, archive));
+        }
+      } else {
+        result = await retryOp(() => httpArchive(defaultFuncs, ctx, ids, archive));
+      }
+
+      ids.forEach(id => CACHE.delete(`archive_${id}`));
+      CACHE.set(`archive_batch_${ids.join("_")}`, { val: result, ts: Date.now() });
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeArchivedStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeAvatar.js

@@ -0,0 +1,123 @@
+"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;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+async function fetchImageStream(url) {
+  const https = require('https');
+  const http = require('http');
+  const { PassThrough } = require('stream');
+
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith('https') ? https : http;
+    mod.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        fetchImageStream(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to fetch image: HTTP ${res.statusCode}`));
+        return;
+      }
+      const pt = new PassThrough();
+      pt.path = url.split('?')[0].split('/').pop() || 'avatar.jpg';
+      res.pipe(pt);
+      resolve(pt);
+    }).on('error', reject);
+  });
+}
+
+async function uploadProfileImage(api, botID, imageStream) {
+  const raw = await api.httpPostFormData(
+    `https://www.facebook.com/profile/picture/upload/?profile_id=${botID}&photo_source=57&av=${botID}`,
+    { file: imageStream }
+  );
+  return JSON.parse(raw.split("for (;;);")[1]);
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeAvatar(link, caption, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof caption === "function") { callback = caption; caption = ""; }
+    if (typeof callback !== "function") {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (!link || typeof link !== "string") throw new Error("changeAvatar: link must be a non-empty string");
+      if (typeof caption !== "string") caption = "";
+
+      const imageStream = await retryOp(() => fetchImageStream(link));
+
+      const uploadData = await retryOp(() => uploadProfileImage(api, ctx.userID, imageStream));
+
+      if (uploadData.error) {
+        throw new Error(`Upload failed: ${JSON.stringify(uploadData.error)}`);
+      }
+
+      const fbid = uploadData.payload?.fbid;
+      if (!fbid) throw new Error("changeAvatar: could not get fbid from upload response");
+
+      const form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "ProfileCometProfilePictureSetMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "5066134240065849",
+        variables: JSON.stringify({
+          input: {
+            caption: caption || "",
+            existing_photo_id: fbid,
+            expiration_time: null,
+            profile_id: ctx.userID,
+            profile_pic_method: "EXISTING",
+            profile_pic_source: "TIMELINE",
+            scaled_crop_rect: { height: 1, width: 1, x: 0, y: 0 },
+            skip_cropping: true,
+            actor_id: ctx.userID,
+            client_mutation_id: String(Math.round(Math.random() * 19))
+          },
+          isPage: false,
+          isProfile: true,
+          scale: 3
+        })
+      };
+
+      const resData = await retryOp(() =>
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      );
+
+      if (resData.error) throw resData;
+
+      const result = {
+        success: true,
+        fbid,
+        caption,
+        timestamp: Date.now()
+      };
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeAvatar", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeBio.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+const BIO_CACHE = new Map();
+const BIO_CACHE_TTL = 10 * 60 * 1000;
+
+async function retryOp(fn, retries = 3, base = 600) {
+  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));
+    }
+  }
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeBio(bio, publish, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof publish === "function") { callback = publish; publish = false; }
+    if (typeof callback !== "function") {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      const actorID = ctx.i_userID || ctx.userID;
+      if (!actorID) throw new Error("changeBio: no userID in context");
+
+      if (typeof bio !== "string") bio = "";
+      if (typeof publish !== "boolean") publish = false;
+
+      const MAX_BIO_LEN = 101;
+      if (bio.length > MAX_BIO_LEN) {
+        utils.warn("changeBio", `Bio is longer than ${MAX_BIO_LEN} characters, it may be truncated by Facebook.`);
+      }
+
+      const form = {
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "ProfileCometSetBioMutation",
+        doc_id: "2725043627607610",
+        variables: JSON.stringify({
+          input: {
+            bio,
+            publish_bio_feed_story: publish,
+            actor_id: actorID,
+            client_mutation_id: String(Math.round(Math.random() * 1024))
+          },
+          hasProfileTileViewID: false,
+          profileTileViewID: null,
+          scale: 1
+        }),
+        av: actorID
+      };
+
+      const res = await retryOp(() =>
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      );
+
+      if (res.errors) throw res;
+
+      BIO_CACHE.set(actorID, { bio, ts: Date.now() });
+
+      callback(null, {
+        success: true,
+        bio,
+        published: publish,
+        actorID,
+        timestamp: Date.now()
+      });
+    } catch (err) {
+      utils.error("changeBio", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeBlockedStatus.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const BLOCKED_CACHE = new Map();
+const CACHE_TTL = 3 * 60 * 1000;
+
+async function retryOp(fn, retries = 3, base = 600) {
+  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() * 250));
+    }
+  }
+}
+
+async function getBlockStatusViaGraphQL(defaultFuncs, ctx, userID) {
+  const form = {
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "ProfileCometFriendshipStatusQuery",
+    doc_id: "6985929504808743",
+    variables: JSON.stringify({ userID })
+  };
+  const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  return res?.data?.user?.friendship_status || null;
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeBlockedStatus(userID, block, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof block === "function") { callback = block; block = true; }
+    if (typeof callback !== "function") {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!userID) throw new Error("changeBlockedStatus: userID is required");
+      if (typeof block !== "boolean") throw new Error("changeBlockedStatus: block must be a boolean");
+
+      const userIDs = Array.isArray(userID) ? userID.map(String) : [String(userID)];
+
+      await globalShield.addSmartDelay();
+
+      const results = await Promise.all(userIDs.map(async uid => {
+        const cacheKey = `blocked_${uid}`;
+        const cached = BLOCKED_CACHE.get(cacheKey);
+        if (cached && (Date.now() - cached.ts < CACHE_TTL) && cached.blocked === block) {
+          return { userID: uid, blocked: block, cached: true };
+        }
+
+        const form = { fbid: uid, block };
+
+        const res = await retryOp(() =>
+          defaultFuncs.post(
+            "https://www.facebook.com/ajax/profile/manage_blocking.php",
+            ctx.jar,
+            form
+          ).then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        );
+
+        if (res && res.error) throw res;
+
+        BLOCKED_CACHE.set(cacheKey, { blocked: block, ts: Date.now() });
+        return { userID: uid, blocked: block, success: true };
+      }));
+
+      const data = userIDs.length === 1 ? results[0] : { success: true, results };
+      callback(null, data);
+    } catch (err) {
+      utils.error("changeBlockedStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};