bb-fca 2.0.0

package/src/deltas/apis/messaging/emoji.ts

@@ -0,0 +1,135 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * 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<any>((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: any = {
+      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/deltas/apis/messaging/gcmember.ts

@@ -0,0 +1,175 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Made by ChoruOfficial
+   * Mqtt
+   * Adds or removes members from a group chat with pre-checking.
+   *
+   * @param {"add" | "remove"} action The action to perform.
+   * @param {string|string[]} userIDs The user ID or array of user IDs.
+   * @param {string} threadID The ID of the group chat.
+   * @param {Function} [callback] Optional callback function.
+   * @returns {Promise<object>} A promise that resolves with information about the action.
+   */
+  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<any>((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+
+    if (typeof _callback != 'function') {
+      _callback = (err, data) => {
+        // Note: We will now rarely use the 'err' parameter for validation errors
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      };
+    }
+
+    try {
+      const validActions = ['add', 'remove'];
+      action = action ? action.toLowerCase() : '';
+
+      // --- ERROR CHECKS NOW RETURN AN OBJECT INSTEAD OF THROWING ---
+      if (!validActions.includes(action)) {
+        return _callback(null, {
+          type: 'error_gc',
+          error: `Invalid action. Must be one of: ${validActions.join(', ')}`,
+        });
+      }
+      if (!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 threadInfo = await api.getThreadInfo(threadID);
+      if (!threadInfo) {
+        return _callback(null, {
+          type: 'error_gc',
+          error: 'Could not retrieve thread information.',
+        });
+      }
+      if (threadInfo.isGroup === false) {
+        return _callback(null, {
+          type: 'error_gc',
+          error: 'This feature is only for group chats, not private messages.',
+        });
+      }
+
+      const currentMembers = threadInfo.participantIDs;
+      const usersToModify = Array.isArray(userIDs) ? userIDs : [userIDs];
+      let queryPayload, query;
+      let finalUsers = usersToModify;
+
+      ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+      ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+      if (action === 'add') {
+        const usersToAdd = usersToModify.filter(
+          (id) => !currentMembers.includes(id),
+        );
+        if (usersToAdd.length === 0) {
+          return _callback(null, {
+            type: 'error_gc',
+            error: 'All specified users are already in the group.',
+          });
+        }
+        finalUsers = usersToAdd;
+        queryPayload = {
+          thread_key: parseInt(threadID),
+          contact_ids: finalUsers.map((id) => parseInt(id)),
+          sync_group: 1,
+        };
+        query = {
+          label: '23',
+          payload: JSON.stringify(queryPayload),
+          queue_name: threadID,
+          task_id: ctx.wsTaskNumber,
+        };
+      } else {
+        // action is 'remove'
+        const userToRemove = usersToModify[0];
+        if (!currentMembers.includes(userToRemove)) {
+          return _callback(null, {
+            type: 'error_gc',
+            error: `User with ID ${userToRemove} is not in this group chat.`,
+          });
+        }
+        finalUsers = [userToRemove];
+        queryPayload = {
+          thread_id: threadID,
+          contact_id: userToRemove,
+          sync_group: 1,
+        };
+        query = {
+          label: '140',
+          payload: JSON.stringify(queryPayload),
+          queue_name: 'remove_participant_v2',
+          task_id: ctx.wsTaskNumber,
+        };
+      }
+
+      const context: any = {
+        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(err); // For network errors, we still reject
+
+          const gcmemberInfo = {
+            type: 'gc_member_update',
+            threadID: threadID,
+            userIDs: finalUsers,
+            action: action,
+            senderID: ctx.userID,
+            BotID: ctx.userID,
+            timestamp: Date.now(),
+          };
+          return _callback(null, gcmemberInfo);
+        },
+      );
+    } catch (err) {
+      return _callback(null, {
+        type: 'error_gc',
+        error: err.message || 'An unknown error occurred.',
+      });
+    }
+
+    return returnPromise;
+  };
+}

package/src/deltas/apis/messaging/gcname.ts

@@ -0,0 +1,136 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets the name of a group chat thread via MQTT.
+   *
+   * @param {string} newName The new name for the group chat.
+   * @param {string} threadID The ID of the group chat thread.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the group name 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 gcname(newName, threadID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise<any>((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 change the group chat name.'),
+      );
+    }
+    if (typeof newName !== 'string') {
+      return _callback(new Error('newName must be a string.'));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error('Not connected to MQTT'));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      thread_name: newName,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '32',
+      payload: JSON.stringify(queryPayload),
+      queue_name: threadID.toString(),
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context: any = {
+      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 gcname: ${err.message || err}`),
+          );
+        }
+
+        const gcnameChangeEvent = {
+          type: 'thread_name_update',
+          threadID: threadID,
+          newName: newName,
+          senderID: _initiatorID,
+          BotID: ctx.userID,
+          timestamp: Date.now(),
+        };
+        _callback(null, gcnameChangeEvent);
+      },
+    );
+
+    return returnPromise;
+  };
+}

package/src/deltas/apis/messaging/gcrule.ts

@@ -0,0 +1,152 @@
+import utils = require('../../../utils');
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Made by ChoruOfficial
+   * Mqtt
+   * Adds or removes an admin from a group chat with pre-checking.
+   *
+   * @param {"admin" | "unadmin"} action The action to perform.
+   * @param {string} userID The ID of the user to promote or demote.
+   * @param {string} threadID The ID of the group chat.
+   * @param {Function} [callback] Optional callback function.
+   * @returns {Promise<object>} A promise that resolves with information about the action.
+   */
+  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<any>((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 = action ? action.toLowerCase() : '';
+
+      if (!validActions.includes(action)) {
+        return _callback(null, {
+          type: 'error_gc_rule',
+          error: `Invalid action. Must be one of: ${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',
+        });
+
+      const threadInfo = await api.getThreadInfo(threadID);
+      if (!threadInfo) {
+        return _callback(null, {
+          type: 'error_gc_rule',
+          error: 'Could not retrieve thread information.',
+        });
+      }
+      if (threadInfo.isGroup === false) {
+        return _callback(null, {
+          type: 'error_gc_rule',
+          error: 'This feature is only for group chats.',
+        });
+      }
+
+      const adminIDs = threadInfo.adminIDs || [];
+      const isCurrentlyAdmin = adminIDs.some((admin) => admin.id === userID);
+
+      if (action === 'admin') {
+        if (isCurrentlyAdmin) {
+          return _callback(null, {
+            type: 'error_gc_rule',
+            error: `User is already an admin.`,
+          });
+        }
+      } else {
+        // action is 'unadmin'
+        if (!isCurrentlyAdmin) {
+          return _callback(null, {
+            type: 'error_gc_rule',
+            error: `User is not an admin.`,
+          });
+        }
+      }
+
+      const isAdminStatus = action === 'admin' ? 1 : 0;
+      ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+      ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+      const queryPayload = {
+        thread_key: parseInt(threadID),
+        contact_id: parseInt(userID),
+        is_admin: isAdminStatus,
+      };
+      const query = {
+        failure_count: null,
+        label: '25',
+        payload: JSON.stringify(queryPayload),
+        queue_name: 'admin_status',
+        task_id: ctx.wsTaskNumber,
+      };
+      const context: any = {
+        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(err);
+          const gcruleInfo = {
+            type: 'gc_rule_update',
+            threadID: threadID,
+            userID: userID,
+            action: action,
+            senderID: ctx.userID,
+            BotID: ctx.userID,
+            timestamp: Date.now(),
+          };
+          return _callback(null, gcruleInfo);
+        },
+      );
+    } catch (err) {
+      return _callback(null, {
+        type: 'error_gc_rule',
+        error: err.message || 'An unknown error occurred.',
+      });
+    }
+
+    return returnPromise;
+  };
+}

package/src/deltas/apis/messaging/markAsDelivered.ts

@@ -0,0 +1,47 @@
+// @ChoruOfficial
+"use strict";
+
+import utils = require("../../../utils");
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(threadID: string, messageID: string): Promise<void>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Marks a message as delivered.
+   * @param {string} threadID - The ID of the thread.
+   * @param {string} messageID - The ID of the message to mark as delivered.
+   * @returns {Promise<void>} A promise that resolves on success or rejects on error.
+   */
+  return async function markAsDelivered(threadID, messageID) {
+    if (!threadID || !messageID) {
+      const err = "Error: messageID or threadID is not defined";
+      utils.error("markAsDelivered", err);
+      throw new Error(err);
+    }
+
+    const form = {};
+    form["message_ids[0]"] = messageID;
+    form["thread_ids[" + threadID + "][0]"] = messageID;
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/delivery_receipts.php",
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData.error) {
+        throw resData;
+      }
+    } catch (err) {
+      utils.error("markAsDelivered", err);
+      throw err;
+    }
+  };
+};