fca-neokex-fix 1.0.1

package/src/apis/createNewGroup.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createNewGroup(participantIDs, groupTitle, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(groupTitle) === "Function") {
+        callback = groupTitle;
+        groupTitle = null;
+      }
+
+      if (utils.getType(participantIDs) !== "Array") {
+        throw new Error("createNewGroup: participantIDs should be an array.");
+      }
+
+      if (participantIDs.length < 2) {
+        throw new Error("createNewGroup: participantIDs should have at least 2 IDs.");
+      }
+
+      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,
+        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
+            }
+          }
+        })
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      const threadID = res.data.messenger_group_thread_create.thread.thread_key.thread_fbid;
+      callback(null, threadID);
+    } catch (err) {
+      utils.error("createNewGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/createPoll.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function createPoll(threadID, questionText, options, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (!threadID || typeof threadID !== "string") {
+        throw new Error("Invalid threadID");
+      }
+
+      if (!questionText || typeof questionText !== "string") {
+        throw new Error("questionText must be a string");
+      }
+
+      if (!Array.isArray(options) || options.length < 2) {
+        throw new Error("options must be an array with at least 2 options");
+      }
+
+      const payload = {
+        epoch_id: utils.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: "8768858626531631"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: ++ctx.wsReqNumber,
+        type: 3
+      });
+
+      ctx.mqttClient.publish("/ls_req", form);
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("createPoll", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/deleteMessage.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteMessage(messageID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        message_id: messageID
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/delete_messages.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, { success: true });
+    } catch (err) {
+      utils.error("deleteMessage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/deleteThread.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteThread(threadOrThreads, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        client: "mercury"
+      };
+
+      if (utils.getType(threadOrThreads) !== "Array") {
+        threadOrThreads = [threadOrThreads];
+      }
+
+      for (let i = 0; i < threadOrThreads.length; i++) {
+        form["ids[" + i + "]"] = threadOrThreads[i];
+      }
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/delete_thread.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("deleteThread", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/editMessage.js

@@ -0,0 +1,70 @@
+"use_strict";
+/**
+* @author RFS-ADRENO
+* @rewrittenBy Isai Ivanov
+*/
+
+const utils = require('../utils');
+
+function canBeCalled(func) {
+    try {
+        Reflect.apply(func, null, []);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+* A function for editing bot's messages.
+* @param {string} text - The text with which the bot will edit its messages.
+* @param {string} messageID - The message ID of the message the bot will edit.
+* @param {Object} callback - Callback for the function.
+*/
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function editMessage(text, messageID, callback) {
+        if (!ctx.mqttClient) {
+            throw new Error('Not connected to MQTT');
+        }
+
+        ctx.wsReqNumber += 1;
+        ctx.wsTaskNumber += 1;
+
+        const queryPayload = {
+            message_id: messageID,
+            text
+        };
+
+        const query = {
+            failure_count: null,
+            label: '742',
+            payload: JSON.stringify(queryPayload),
+            queue_name: 'edit_message',
+            task_id: ctx.wsTaskNumber
+        };
+
+        const context = {
+            app_id: '2220391788200892',
+            payload: {
+                data_trace_id: null,
+                epoch_id: parseInt(utils.generateOfflineThreadingID()),
+                tasks: [query],
+                version_id: '6903494529735864'
+            },
+            request_id: ctx.wsReqNumber,
+            type: 3
+        };
+
+        context.payload = JSON.stringify(context.payload);
+
+
+
+
+
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {
+            qos: 1, retain: false
+        });
+    };
+};
+

package/src/apis/emoji.js

@@ -0,0 +1,124 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets the custom emoji for a specific Facebook thread via MQTT.
+   *
+   * @param {string} emoji The emoji character to set as the custom emoji (e.g., "👍", "❤️").
+   * @param {string} threadID The ID of the thread where the emoji will be set.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the emoji change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function emoji(emoji, threadID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        _resolvePromise = resolve;
+        _rejectPromise = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set an emoji."));
+    }
+    if (!emoji) {
+      return _callback(new Error("An emoji character is required."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      custom_emoji: emoji,
+      avatar_sticker_instruction_key_id: null,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '100003',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_quick_reaction',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        return _callback(new Error(`MQTT publish failed for emoji: ${err.message || err}`));
+      }
+      
+      const emojiChangeEvent = {
+        type: "thread_emoji_update",
+        threadID: threadID,
+        newEmoji: emoji,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, emojiChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/apis/fetchThemeData.js

@@ -0,0 +1,65 @@
+"use strict";
+
+const log = require("npmlog");
+const utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function fetchThemeData(themeID, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const done = callback || function (err, data) {
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (!themeID) {
+      done({ error: "Theme ID is a required parameter" });
+      return promise;
+    }
+
+    const payload = {
+      av: ctx.userID,
+      __user: ctx.userID,
+      __a: 1,
+      __req: utils.getSignatureID(),
+      fb_dtsg: ctx.fb_dtsg,
+      lsd: ctx.fb_dtsg,
+      jazoest: ctx.jazoest,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWPThreadThemeProviderQuery",
+      variables: JSON.stringify({ id: themeID.toString() }),
+      server_timestamps: true,
+      doc_id: "9734829906576883"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, payload)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((res) => {
+        if (res.errors) throw res.errors;
+
+        const data = res?.data?.messenger_thread_theme;
+        if (!data) throw new Error("Theme data could not be located in the response");
+
+        const output = {
+          id: data.id,
+          name: data.accessibility_label,
+          description: data.description,
+          colors: data.gradient_colors || [data.fallback_color],
+          backgroundImage: data.background_asset?.image?.uri || null
+        };
+
+        done(null, output);
+      })
+      .catch((err) => {
+        log.error("fetchThemeData", err);
+        done(err);
+      });
+
+    return promise;
+  };
+};

package/src/apis/follow.js

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * Author @YanMaglinte
+ * https://github.com/YANDEVA
+ * * Example:
+ * api.follow("100090794779367", true);
+ * jsdocs @ChoruOfficial
+ */
+ 
+/**
+ * @param {object} defaultFuncs The default functions for making API requests.
+ * @param {object} api The full API object.
+ * @param {object} ctx The context object.
+ * @returns {function(senderID: string, boolean: boolean, callback?: (err: any, data?: any) => void): void} The follow function.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Follows or unfollows a user on Facebook.
+   * @param {string} senderID The ID of the user to follow or unfollow.
+   * @param {boolean} boolean Set to `true` to follow the user, `false` to unfollow.
+   * @param {(err: any, data?: any) => void} [callback] An optional callback function.
+   */
+  return function follow(senderID, boolean, callback) {
+    let form;
+    if (boolean) {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserFollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,via_cold_start,1717249218695,723451,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            subscribee_id: senderID,
+            tracking: null,
+            actor_id: ctx.userID,
+            client_mutation_id: "1",
+          },
+          scale: 1,
+        }),
+      };
+    } else {
+      form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "CometUserUnfollowMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "25472099855769847",
+        variables: JSON.stringify({
+          action_render_location: "WWW_COMET_FRIEND_MENU",
+          input: {
+            attribution_id_v2:
+              "ProfileCometTimelineListViewRoot.react,comet.profile.timeline.list,tap_search_bar,1717294006136,602597,250100865708545,,",
+            is_tracking_encrypted: true,
+            subscribe_location: "PROFILE",
+            tracking: null,
+            unsubscribee_id: senderID,
+            actor_id: ctx.userID,
+            client_mutation_id: "10",
+          },
+          scale: 1,
+        }),
+      };
+    }
+
+    api.httpPost("https://www.facebook.com/api/graphql/", form, (err, data) => {
+      if (err) {
+        if (typeof callback === "function") {
+          callback(err);
+        }
+      } else {
+        if (typeof callback === "function") {
+          callback(null, data);
+        }
+      }
+    });
+  };
+};

package/src/apis/forwardMessage.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function forwardMessage(messageID, threadIDs, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!Array.isArray(threadIDs)) {
+        threadIDs = [threadIDs];
+      }
+
+      const form = {
+        message_id: messageID
+      };
+      
+      threadIDs.forEach(id => {
+        form[`recipient_ids[${id}]`] = id;
+      });
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/forward_message.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true, forwardedTo: threadIDs });
+    } catch (err) {
+      utils.error("forwardMessage", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};