fca-phantom 1.0.0

package/phantom/dispatch/changeGroupImage.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+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));
+    }
+  }
+}
+
+async function handleUpload(defaultFuncs, ctx, image) {
+  const form = { images_only: "true", "attachment[]": image };
+  return retryOp(() =>
+    defaultFuncs.postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData.error) throw resData;
+        if (!resData.payload?.metadata?.[0]) throw new Error("changeGroupImage: empty upload payload");
+        return resData.payload.metadata[0];
+      })
+  );
+}
+
+async function mqttSetImage(ctx, threadID, imageID) {
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [{
+          failure_count: null,
+          label: "37",
+          payload: JSON.stringify({ thread_key: threadID, image_id: imageID, sync_group: 1 }),
+          queue_name: "thread_image",
+          task_id: taskID
+        }],
+        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, imageID, response: j.payload });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(new Error("MQTT timeout for changeGroupImage"));
+      }
+    }, 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 httpSetImage(defaultFuncs, ctx, threadID, imageID) {
+  const form = {
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "MessengerChangeGroupImageMutation",
+    doc_id: "5768799839818799",
+    variables: JSON.stringify({
+      input: {
+        thread_fbid: threadID,
+        image_id: imageID,
+        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 { success: true, imageID, method: "graphql" };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeGroupImage(image, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== "function") {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!threadID || (typeof threadID !== "string" && typeof threadID !== "number"))
+        throw new Error("changeGroupImage: invalid threadID");
+      if (!utils.isReadableStream(image)) throw new Error("changeGroupImage: image must be a readable stream");
+
+      const payload = await handleUpload(defaultFuncs, ctx, image);
+      const imageID = payload.image_id;
+      if (!imageID) throw new Error("changeGroupImage: upload returned no image_id");
+
+      let result;
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttSetImage(ctx, String(threadID), imageID));
+        } catch (mqttErr) {
+          utils.warn("changeGroupImage", "MQTT failed, using HTTP:", mqttErr.message);
+          result = await retryOp(() => httpSetImage(defaultFuncs, ctx, String(threadID), imageID));
+        }
+      } else {
+        result = await retryOp(() => httpSetImage(defaultFuncs, ctx, String(threadID), imageID));
+      }
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeGroupImage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeThreadColor.js

@@ -0,0 +1,172 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const COLOR_PALETTE = {
+  blue: "196241301102133",
+  purple: "370940413392601",
+  green: "169463077092846",
+  pink: "230032715012014",
+  orange: "175615189761153",
+  red: "2136751179887052",
+  yellow: "2058653964378557",
+  teal: "417639218648241",
+  black: "539927563794799",
+  white: "2873642392710980",
+  coral: "4286946214700532",
+  lime: "4286946214700540",
+  lavender: "4286946214700548",
+  aqua: "4286946214700556",
+  default: "196241301102133"
+};
+
+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));
+    }
+  }
+}
+
+function resolveColor(color) {
+  if (!color) return COLOR_PALETTE.default;
+  const s = String(color).trim();
+  if (/^\d+$/.test(s)) return s;
+  return COLOR_PALETTE[s.toLowerCase()] || s;
+}
+
+async function mqttChangeColor(ctx, threadID, colorFBID) {
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [{
+          failure_count: null,
+          label: "43",
+          payload: JSON.stringify({
+            thread_key: threadID,
+            theme_fbid: colorFBID,
+            source: null,
+            sync_group: 1,
+            payload: null
+          }),
+          queue_name: "thread_theme",
+          task_id: taskID
+        }],
+        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);
+      try {
+        const msgID = j.payload.step[1][2][2][1][2];
+        const msgReplace = j.payload.step[1][2][2][1][4];
+        resolve({ body: msgReplace, messageID: msgID, threadID, colorFBID, method: "mqtt" });
+      } catch {
+        resolve({ success: true, threadID, colorFBID, method: "mqtt" });
+      }
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(new Error("MQTT timeout for changeThreadColor"));
+      }
+    }, 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 httpChangeColor(defaultFuncs, ctx, threadID, colorFBID) {
+  const form = {
+    dpr: 1,
+    queries: JSON.stringify({
+      o0: {
+        doc_id: "1727493033983591",
+        query_params: {
+          data: {
+            actor_id: ctx.userID,
+            client_mutation_id: "0",
+            source: "SETTINGS",
+            theme_id: colorFBID,
+            thread_id: threadID
+          }
+        }
+      }
+    })
+  };
+  const res = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res?.[0]?.o0?.errors) throw new Error(JSON.stringify(res[0].o0.errors));
+  return { success: true, threadID, colorFBID, method: "http" };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeThreadColor(color, threadID, 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 (!threadID) throw new Error("changeThreadColor: threadID is required");
+      const colorFBID = resolveColor(color);
+
+      await globalShield.addSmartDelay();
+
+      let result;
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttChangeColor(ctx, threadID, colorFBID));
+        } catch (mqttErr) {
+          utils.warn("changeThreadColor", "MQTT failed, using HTTP:", mqttErr.message);
+          result = await retryOp(() => httpChangeColor(defaultFuncs, ctx, threadID, colorFBID));
+        }
+      } else {
+        result = await retryOp(() => httpChangeColor(defaultFuncs, ctx, threadID, colorFBID));
+      }
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeThreadColor", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/changeThreadEmoji.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+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 mqttChangeEmoji(ctx, emoji, threadID) {
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [{
+          failure_count: null,
+          label: "127",
+          payload: JSON.stringify({ thread_key: threadID, custom_emoji: emoji, sync_group: 1 }),
+          queue_name: "thread_emoji",
+          task_id: taskID
+        }],
+        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, emoji, threadID, method: "mqtt" });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(new Error("MQTT timeout for changeThreadEmoji"));
+      }
+    }, 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);
+      }
+    });
+  });
+}
+
+async function httpChangeEmoji(defaultFuncs, ctx, emoji, threadID) {
+  const form = {
+    emoji_choice: emoji,
+    thread_or_other_fbid: threadID
+  };
+
+  const resData = await defaultFuncs.post(
+    "https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg",
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (resData.error === 1357031) {
+    throw { error: "Thread has no messages yet. Send at least one message before changing emoji." };
+  }
+  if (resData.error) throw resData;
+
+  return { success: true, emoji, threadID, method: "http" };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeThreadEmoji(emoji, threadID, 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 (!emoji || typeof emoji !== "string") throw new Error("changeThreadEmoji: emoji must be a non-empty string");
+      if (!threadID) throw new Error("changeThreadEmoji: threadID is required");
+
+      await globalShield.addSmartDelay();
+
+      let result;
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttChangeEmoji(ctx, emoji, threadID));
+        } catch (mqttErr) {
+          utils.warn("changeThreadEmoji", "MQTT failed, using HTTP:", mqttErr.message);
+          result = await retryOp(() => httpChangeEmoji(defaultFuncs, ctx, emoji, threadID));
+        }
+      } else {
+        result = await retryOp(() => httpChangeEmoji(defaultFuncs, ctx, emoji, threadID));
+      }
+
+      callback(null, result);
+    } catch (err) {
+      utils.error("changeThreadEmoji", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/comment.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+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));
+    }
+  }
+}
+
+async function handleUpload(defaultFuncs, ctx, msg, form) {
+  if (!msg.attachments || !msg.attachments.length) return;
+
+  const uploads = msg.attachments.map(item => {
+    if (!utils.isReadableStream(item)) throw new Error("comment: attachments must be readable streams");
+    return defaultFuncs.postFormData("https://www.facebook.com/ajax/ufi/upload/", ctx.jar, {
+      profile_id: ctx.userID,
+      source: 19,
+      target_id: ctx.userID,
+      file: item
+    }).then(utils.parseAndCheckLogin(ctx, defaultFuncs)).then(res => {
+      if (res.error || !res.payload?.fbid) throw res;
+      return { media: { id: res.payload.fbid } };
+    });
+  });
+
+  const results = await Promise.all(uploads);
+  form.input.attachments.push(...results);
+}
+
+function handleURL(msg, form) {
+  if (typeof msg.url === "string") {
+    form.input.attachments.push({ link: { external: { url: msg.url } } });
+  }
+}
+
+function handleMentions(msg, form) {
+  if (!msg.mentions) return;
+  for (const { tag, id, fromIndex } of msg.mentions) {
+    if (typeof tag !== "string" || !id) continue;
+    const offset = msg.body.indexOf(tag, fromIndex || 0);
+    if (offset < 0) continue;
+    form.input.message.ranges.push({ entity: { id }, length: tag.length, offset });
+  }
+}
+
+function handleSticker(msg, form) {
+  if (msg.sticker) form.input.attachments.push({ media: { id: String(msg.sticker) } });
+}
+
+async function submitComment(defaultFuncs, ctx, form) {
+  const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "useCometUFICreateCommentMutation",
+    variables: JSON.stringify(form),
+    server_timestamps: true,
+    doc_id: 6993516810709754
+  }).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res.errors) throw res;
+
+  const edge = res.data?.comment_create?.feedback_comment_edge;
+  if (!edge) throw new Error("comment: no comment edge returned");
+
+  return {
+    id: edge.node.id,
+    url: edge.node.feedback?.url,
+    count: res.data.comment_create.feedback?.total_comment_count,
+    text: edge.node.body?.text || "",
+    timestamp: Date.now()
+  };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createCommentPost(msg, postID, replyCommentID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof replyCommentID === "function") { callback = replyCommentID; replyCommentID = null; }
+    if (typeof callback !== "function") {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (typeof msg !== "string" && typeof msg !== "object") throw new Error("comment: msg must be string or object");
+      if (!postID || typeof postID !== "string") throw new Error("comment: postID must be a string");
+
+      const msgObj = typeof msg === "string" ? { body: msg } : { ...msg };
+      msgObj.mentions = msgObj.mentions || [];
+      msgObj.attachments = msgObj.attachments || [];
+
+      const form = {
+        feedLocation: "NEWSFEED",
+        feedbackSource: 1,
+        groupID: null,
+        input: {
+          client_mutation_id: String(Math.round(Math.random() * 19)),
+          actor_id: ctx.userID,
+          attachments: [],
+          feedback_id: Buffer.from("feedback:" + postID).toString("base64"),
+          message: { ranges: [], text: msgObj.body || "" },
+          reply_comment_parent_fbid: replyCommentID || null,
+          is_tracking_encrypted: true,
+          tracking: [],
+          feedback_source: "NEWS_FEED",
+          idempotence_token: "client:" + utils.getGUID(),
+          session_id: utils.getGUID()
+        },
+        scale: 1,
+        useDefaultActor: false
+      };
+
+      await handleUpload(defaultFuncs, ctx, msgObj, form);
+      handleURL(msgObj, form);
+      handleMentions(msgObj, form);
+      handleSticker(msgObj, form);
+
+      const result = await retryOp(() => submitComment(defaultFuncs, ctx, form));
+      callback(null, result);
+    } catch (err) {
+      utils.error("comment", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};