@eryxenx/fca 1.0.0

package/src/api/messaging/changeNickname.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+const log = require("../../../func/logAdapter");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeNickname(nickname, threadID, participantID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      if (!threadID || !participantID) {
+        const err = new Error("Missing required parameters");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "44",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_id: participantID,
+              nickname: nickname || "",
+              sync_group: 1
+            }),
+            queue_name: "thread_participant_nickname",
+            task_id: taskID
+          }
+        ],
+        version_id: "8798795233522156"
+      };
+      const request = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      };
+      const onResponse = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", onResponse);
+        callback?.(null, { success: true, response: jsonMsg.payload });
+        return resolve({ success: true, response: jsonMsg.payload });
+      };
+      ctx.mqttClient.on("message", onResponse);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(request), { qos: 1, retain: false }, (err) => {
+        if (err) {
+          ctx.mqttClient.removeListener("message", onResponse);
+          log.error("changeNicknameMqtt", err);
+          callback?.(err);
+          return reject(err);
+        }
+      });
+    });
+  };
+};

package/src/api/messaging/changeThreadColor.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+module.exports = (defaultFuncs, api, ctx) => {
+  return async (color, threadID, callback) => {
+    let reqID = ++ctx.wsReqNumber;
+    let resolveFunc = () => { };
+    let rejectFunc = () => { };
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const content = {
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [
+          {
+            failure_count: null,
+            label: "43",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              theme_fbid: color,
+              source: null,
+              sync_group: 1,
+              payload: null
+            }),
+            queue_name: "thread_theme",
+            task_id: ++ctx.wsTaskNumber
+          }
+        ],
+        version_id: "8798795233522156"
+      }),
+      request_id: reqID,
+      type: 3
+    };
+
+    ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+      qos: 1,
+      retain: false
+    });
+
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp") return;
+      let jsonMsg;
+      try {
+        jsonMsg = JSON.parse(message.toString());
+        jsonMsg.payload = JSON.parse(jsonMsg.payload);
+      } catch (err) {
+        return;
+      }
+      if (jsonMsg.request_id !== reqID) return;
+      ctx.mqttClient.removeListener("message", handleRes);
+      try {
+        const msgID = jsonMsg.payload.step[1][2][2][1][2];
+        const msgReplace = jsonMsg.payload.step[1][2][2][1][4];
+        const bodies = {
+          body: msgReplace,
+          messageID: msgID
+        };
+        return callback(null, bodies);
+      } catch (err) {
+        return callback(null, { success: true });
+      }
+    };
+
+    ctx.mqttClient.on("message", handleRes);
+    return returnPromise;
+  };
+};

package/src/api/messaging/changeThreadEmoji.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function (defaultFuncs, api, ctx) {
+  function changeThreadEmojiNoMqtt(emoji, threadID, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc();
+      };
+    }
+    var form = {
+      emoji_choice: emoji,
+      thread_or_other_fbid: threadID,
+    };
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg",
+        ctx.jar,
+        form,
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error === 1357031) {
+          throw {
+            error:
+              "Trying to change emoji of a chat that doesn't exist. Have at least one message in the thread before trying to change the emoji.",
+          };
+        }
+        if (resData.error) {
+          throw resData;
+        }
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("changeThreadEmoji", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+  function changeThreadEmojiMqtt(emoji, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = ++ctx.wsReqNumber;
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    const done = (err, data) => {
+      if (err) {
+        if (callback) callback(err);
+        return rejectFunc(err);
+      }
+      if (callback) callback(null, data);
+      resolveFunc(data);
+    };
+    var form = JSON.stringify({
+      "app_id": "2220391788200892",
+      "payload": JSON.stringify({
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: '100003',
+            payload: JSON.stringify({
+              "thread_key": threadID,
+              "custom_emoji": emoji,
+              "avatar_sticker_instruction_key_id": null,
+              "sync_group": 1
+            }),
+            queue_name: 'thread_quick_reaction',
+            task_id: Math.random() * 1001 << 0
+          }
+        ],
+        version_id: '8798795233522156'
+      }),
+      "request_id": reqID,
+      "type": 3
+    });
+    ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+      if (err) return done(err);
+      done(null, { success: true });
+    });
+    return returnPromise;
+  };
+  return function changeThreadEmoji(emoji, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        return changeThreadEmojiMqtt(emoji, threadID, callback);
+      } catch (e) {
+        return changeThreadEmojiNoMqtt(emoji, threadID, callback);
+      }
+    } else {
+      return changeThreadEmojiNoMqtt(emoji, threadID, callback);
+    }
+  };
+};

package/src/api/messaging/createNewGroup.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function createNewGroup(participantIDs, groupTitle, callback) {
+    if (getType(groupTitle) == "Function") {
+      callback = groupTitle;
+      groupTitle = null;
+    }
+
+    if (getType(participantIDs) !== "Array") {
+      throw { error: "createNewGroup: participantIDs should be an array." };
+    }
+
+    if (participantIDs.length < 2) {
+      throw {
+        error: "createNewGroup: participantIDs should have at least 2 IDs."
+      };
+    }
+
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, threadID) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(threadID);
+      };
+    }
+
+    const pids = [];
+    for (const n in participantIDs) {
+      pids.push({
+        fbid: participantIDs[n]
+      });
+    }
+    pids.push({ fbid: ctx.i_userID || ctx.userID });
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MessengerGroupCreateMutation",
+      av: ctx.i_userID || ctx.userID,
+      //This doc_id is valid as of January 11th, 2020
+      doc_id: "577041672419534",
+      variables: JSON.stringify({
+        input: {
+          entry_point: "jewel_new_group",
+          actor_id: ctx.i_userID || ctx.userID,
+          participants: pids,
+          client_mutation_id: Math.round(Math.random() * 1024).toString(),
+          thread_settings: {
+            name: groupTitle,
+            joinable_mode: "PRIVATE",
+            thread_image_fbid: null
+          }
+        }
+      })
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+        return callback(
+          null,
+          resData.data.messenger_group_thread_create.thread.thread_key
+            .thread_fbid
+        );
+      })
+      .catch(function(err) {
+        log.error("createNewGroup", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/createPoll.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function createPoll(threadID, questionText, options) {
+    let count_req = 0;
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        return reject(new Error("Not connected to MQTT"));
+      }
+      const payload = {
+        epoch_id: generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "163",
+            payload: JSON.stringify({
+              question_text: questionText,
+              thread_key: threadID,
+              options: options,
+              sync_group: 1,
+            }),
+            queue_name: "poll_creation",
+            task_id: Math.floor(Math.random() * 1001),
+          },
+        ],
+        version_id: "34195258046739157",
+      };
+
+      const form = JSON.stringify({
+        app_id: "2220391788200892",
+        payload: JSON.stringify(payload),
+        request_id: ++count_req,
+        type: 3,
+      });
+
+      try {
+        ctx.mqttClient.publish("/ls_req", form);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  };
+};

package/src/api/messaging/createThemeAI.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { getType } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function createThemeAI(prompt, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (getType(prompt) !== "String") {
+      return callback({ error: "Invalid prompt. Please provide a string." });
+    }
+
+    if (!prompt || prompt.trim().length === 0) {
+      return callback({ error: "Prompt cannot be empty." });
+    }
+
+    const form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+      doc_id: "23873748445608673",
+      variables: JSON.stringify({
+        input: {
+          client_mutation_id: Math.round(Math.random() * 19).toString(),
+          actor_id: ctx.userID,
+          bypass_cache: true,
+          caller: "MESSENGER",
+          num_themes: 1,
+          prompt: prompt.trim()
+        }
+      }),
+      server_timestamps: true
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+
+        if (!resData.data || !resData.data.xfb_generate_ai_themes_from_prompt) {
+          throw {
+            error: "Invalid response from Facebook API",
+            res: resData
+          };
+        }
+
+        const themes = resData.data.xfb_generate_ai_themes_from_prompt.themes;
+        if (!themes || !Array.isArray(themes) || themes.length === 0) {
+          throw {
+            error: "No themes generated",
+            res: resData
+          };
+        }
+
+        const theme = themes[0];
+        if (!theme || !theme.id || !theme.background_asset) {
+          throw {
+            error: "Invalid theme data",
+            res: resData
+          };
+        }
+
+        callback(null, {
+          id: theme.id,
+          accessibility_label: theme.accessibility_label || null,
+          background_asset: {
+            id: theme.background_asset.id,
+            image: {
+              url: theme.background_asset.image?.uri || null
+            }
+          }
+        });
+      })
+      .catch(function (err) {
+        log.error("createThemeAI", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/deleteMessage.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { getType, generateOfflineThreadingID } = require("../../utils/format");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function deleteMessage(messageOrMessages, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function (err) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc();
+      };
+    }
+
+    if (getType(messageOrMessages) !== "Array") {
+      messageOrMessages = [messageOrMessages];
+    }
+
+    if (!ctx || !ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      callback(err);
+      return rejectFunc(err);
+    }
+
+    const epochId = String(generateOfflineThreadingID());
+    if (typeof ctx.wsTaskNumber !== "number") ctx.wsTaskNumber = 0;
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+
+    const tasks = messageOrMessages.map((threadID) => {
+      const threadKey = String(threadID);
+      const taskPayload = `{"thread_key":${threadKey},"remove_type":0,"sync_group":1}`;
+      return {
+        failure_count: null,
+        label: "146",
+        payload: taskPayload,
+        queue_name: threadKey,
+        task_id: ++ctx.wsTaskNumber,
+      };
+    });
+
+    const payload = `{"epoch_id":${epochId},"tasks":${JSON.stringify(
+      tasks,
+    )},"version_id":"25909428212080747"}`;
+
+    const reqID = ++ctx.wsReqNumber;
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload,
+      request_id: reqID,
+      type: 3,
+    });
+
+    let timer = null;
+
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      try {
+        ctx.mqttClient?.removeListener("message", handleRes);
+      } catch (e) {
+        // ignore
+      }
+    };
+
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp") return;
+      let msg;
+      try {
+        msg = JSON.parse(message.toString());
+      } catch {
+        return;
+      }
+      if (msg.request_id !== reqID) return;
+      cleanup();
+      try {
+        msg.payload =
+          typeof msg.payload === "string"
+            ? JSON.parse(msg.payload)
+            : msg.payload;
+      } catch {}
+      callback(null, { success: true, response: msg.payload });
+      resolveFunc({ success: true, response: msg.payload });
+    };
+
+    try {
+      ctx.mqttClient.on("message", handleRes);
+    } catch (err) {
+      cleanup();
+      log.error("deleteMessage", err);
+      callback(err);
+      rejectFunc(err);
+      return returnPromise;
+    }
+
+    timer = setTimeout(() => {
+      const err = new Error("MQTT response timeout");
+      cleanup();
+      log.error("deleteMessage", err);
+      callback(err);
+      rejectFunc(err);
+    }, 20000);
+
+    try {
+      ctx.mqttClient.publish(
+        "/ls_req",
+        form,
+        { qos: 1, retain: false },
+        (err) => {
+          if (err) {
+            cleanup();
+            log.error("deleteMessage", err);
+            callback(err);
+            rejectFunc(err);
+          }
+        },
+      );
+    } catch (err) {
+      cleanup();
+      log.error("deleteMessage", err);
+      callback(err);
+      rejectFunc(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/deleteThread.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const log = require("../../../func/logAdapter");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function deleteThread(threadOrThreads, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (!callback) {
+      callback = function(err) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc();
+      };
+    }
+
+    const form = {
+      client: "mercury"
+    };
+
+    if (getType(threadOrThreads) !== "Array") {
+      threadOrThreads = [threadOrThreads];
+    }
+
+    for (let i = 0; i < threadOrThreads.length; i++) {
+      form["ids[" + i + "]"] = threadOrThreads[i];
+    }
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/mercury/delete_thread.php",
+        ctx.jar,
+        form
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        return callback();
+      })
+      .catch(function(err) {
+        log.error("deleteThread", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};