bb-fca 2.0.0

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

@@ -0,0 +1,286 @@
+import utils = require('../../../utils');
+// @NethWs3Dev
+
+const allowedProperties = {
+  attachment: true,
+  url: true,
+  sticker: true,
+  emoji: true,
+  emojiSize: true,
+  body: true,
+  mentions: true,
+  location: true,
+};
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  async function uploadAttachment(attachments) {
+    var uploads = [];
+    for (var i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw new Error(
+          'Attachment should be a readable stream and not ' +
+            utils.getType(attachments[i]) +
+            '.',
+        );
+      }
+      const oksir = await defaultFuncs
+        .postFormData(
+          'https://upload.facebook.com/ajax/mercury/upload.php',
+          ctx.jar,
+          {
+            upload_1024: attachments[i],
+            voice_clip: 'true',
+          },
+          {},
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      if (oksir.error) {
+        throw new Error(oksir.error);
+      }
+      uploads.push(oksir.payload.metadata[0]);
+    }
+    return uploads;
+  }
+
+  async function getUrl(url) {
+    const resData = await defaultFuncs
+      .post(
+        'https://www.facebook.com/message_share_attachment/fromURI/',
+        ctx.jar,
+        {
+          image_height: 960,
+          image_width: 960,
+          uri: url,
+        },
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData || resData.error || !resData.payload) {
+      throw new Error(resData);
+    }
+  }
+
+  async function sendContent(
+    form,
+    threadID,
+    isSingleUser,
+    messageAndOTID,
+    callback?,
+  ) {
+    // There are three cases here:
+    // 1. threadID is of type array, where we're starting a new group chat with users
+    //    specified in the array.
+    // 2. User is sending a message to a specific user.
+    // 3. No additional form params and the message goes to an existing group chat.
+    if (utils.getType(threadID) === 'Array') {
+      for (var i = 0; i < threadID.length; i++) {
+        form['specific_to_list[' + i + ']'] = 'fbid:' + threadID[i];
+      }
+      form['specific_to_list[' + threadID.length + ']'] = 'fbid:' + ctx.userID;
+      form['client_thread_id'] = 'root:' + messageAndOTID;
+      utils.log(
+        'sendMessage',
+        'Sending message to multiple users: ' + threadID,
+      );
+    } else {
+      // This means that threadID is the id of a user, and the chat
+      // is a single person chat
+      if (isSingleUser) {
+        form['specific_to_list[0]'] = 'fbid:' + threadID;
+        form['specific_to_list[1]'] = 'fbid:' + ctx.userID;
+        form['other_user_fbid'] = threadID;
+      } else {
+        form['thread_fbid'] = threadID;
+      }
+    }
+
+    if (ctx.globalOptions.pageID) {
+      form['author'] = 'fbid:' + ctx.globalOptions.pageID;
+      form['specific_to_list[1]'] = 'fbid:' + ctx.globalOptions.pageID;
+      form['creator_info[creatorID]'] = ctx.userID;
+      form['creator_info[creatorType]'] = 'direct_admin';
+      form['creator_info[labelType]'] = 'sent_message';
+      form['creator_info[pageID]'] = ctx.globalOptions.pageID;
+      form['request_user_id'] = ctx.globalOptions.pageID;
+      form['creator_info[profileURI]'] =
+        'https://www.facebook.com/profile.php?id=' + ctx.userID;
+    }
+
+    const resData = await defaultFuncs
+      .post('https://www.facebook.com/messaging/send/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData) {
+      throw new Error('Send message failed.');
+    }
+    if (resData.error) {
+      if (resData.error === 1545012) {
+        utils.warn(
+          'sendMessage',
+          "Got error 1545012. This might mean that you're not part of the conversation " +
+            threadID,
+        );
+      }
+      throw new Error(resData);
+    }
+    const messageInfo = resData.payload.actions.reduce((p, v) => {
+      return {
+        threadID: v.thread_fbid,
+        messageID: v.message_id,
+        timestamp: v.timestamp,
+      };
+    }, null);
+    return messageInfo;
+  }
+
+  return async (msg, threadID, replyToMessage, isSingleUser = false) => {
+    let msgType = utils.getType(msg);
+    let threadIDType = utils.getType(threadID);
+    let messageIDType = utils.getType(replyToMessage);
+    if (msgType !== 'String' && msgType !== 'Object')
+      throw new Error(
+        'Message should be of type string or object and not ' + msgType + '.',
+      );
+    if (
+      threadIDType !== 'Array' &&
+      threadIDType !== 'Number' &&
+      threadIDType !== 'String'
+    )
+      throw new Error(
+        'ThreadID should be of type number, string, or array and not ' +
+          threadIDType +
+          '.',
+      );
+    if (replyToMessage && messageIDType !== 'String')
+      throw new Error(
+        'MessageID should be of type string and not ' + threadIDType + '.',
+      );
+    if (msgType === 'String') {
+      msg = { body: msg };
+    }
+    let disallowedProperties = Object.keys(msg).filter(
+      (prop) => !allowedProperties[prop],
+    );
+    if (disallowedProperties.length > 0) {
+      throw new Error(
+        'Dissallowed props: `' + disallowedProperties.join(', ') + '`',
+      );
+    }
+    let messageAndOTID = utils.generateOfflineThreadingID();
+    let form: Record<string, any> = {
+      client: 'mercury',
+      action_type: 'ma-type:user-generated-message',
+      author: 'fbid:' + ctx.userID,
+      timestamp: Date.now(),
+      timestamp_absolute: 'Today',
+      timestamp_relative: utils.generateTimestampRelative(),
+      timestamp_time_passed: '0',
+      is_unread: false,
+      is_cleared: false,
+      is_forward: false,
+      is_filtered_content: false,
+      is_filtered_content_bh: false,
+      is_filtered_content_account: false,
+      is_filtered_content_quasar: false,
+      is_filtered_content_invalid_app: false,
+      is_spoof_warning: false,
+      source: 'source:chat:web',
+      'source_tags[0]': 'source:chat',
+      ...(msg.body && {
+        body: msg.body,
+      }),
+      html_body: false,
+      ui_push_phase: 'V3',
+      status: '0',
+      offline_threading_id: messageAndOTID,
+      message_id: messageAndOTID,
+      threading_id: utils.generateThreadingID(ctx.clientID),
+      'ephemeral_ttl_mode:': '0',
+      manual_retry_cnt: '0',
+      has_attachment: !!(msg.attachment || msg.url || msg.sticker),
+      signatureID: utils.getSignatureID(),
+      ...(replyToMessage && {
+        replied_to_message_id: replyToMessage,
+      }),
+    };
+
+    if (msg.location) {
+      if (!msg.location.latitude || !msg.location.longitude)
+        throw new Error('location property needs both latitude and longitude');
+      form['location_attachment[coordinates][latitude]'] =
+        msg.location.latitude;
+      form['location_attachment[coordinates][longitude]'] =
+        msg.location.longitude;
+      form['location_attachment[is_current_location]'] = !!msg.location.current;
+    }
+    if (msg.sticker) {
+      form['sticker_id'] = msg.sticker;
+    }
+    if (msg.attachment) {
+      form.image_ids = [];
+      form.gif_ids = [];
+      form.file_ids = [];
+      form.video_ids = [];
+      form.audio_ids = [];
+      if (utils.getType(msg.attachment) !== 'Array') {
+        msg.attachment = [msg.attachment];
+      }
+      const files = await uploadAttachment(msg.attachment);
+      files.forEach((file) => {
+        const type = Object.keys(file)[0];
+        form['' + type + 's'].push(file[type]);
+      });
+    }
+    if (msg.url) {
+      form['shareable_attachment[share_type]'] = '100';
+      const params = await getUrl(msg.url);
+      form['shareable_attachment[share_params]'] = params;
+    }
+    if (msg.emoji) {
+      if (!msg.emojiSize) {
+        msg.emojiSize = 'medium';
+      }
+      if (
+        msg.emojiSize !== 'small' &&
+        msg.emojiSize !== 'medium' &&
+        msg.emojiSize !== 'large'
+      ) {
+        throw new Error('emojiSize property is invalid');
+      }
+      if (!form.body) {
+        throw new Error('body is not empty');
+      }
+      form.body = msg.emoji;
+      form['tags[0]'] = 'hot_emoji_size:' + msg.emojiSize;
+    }
+    if (msg.mentions) {
+      for (let i = 0; i < msg.mentions.length; i++) {
+        const mention = msg.mentions[i];
+        const tag = mention.tag;
+        if (typeof tag !== 'string') {
+          throw new Error('Mention tags must be strings.');
+        }
+        const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+        if (offset < 0)
+          utils.warn(
+            'handleMention',
+            'Mention for "' + tag + '" not found in message string.',
+          );
+        if (!mention.id)
+          utils.warn('handleMention', 'Mention id should be non-null.');
+        const id = mention.id || 0;
+        const emptyChar = '\u200E';
+        form['body'] = emptyChar + msg.body;
+        form['profile_xmd[' + i + '][offset]'] = offset + 1;
+        form['profile_xmd[' + i + '][length]'] = tag.length;
+        form['profile_xmd[' + i + '][id]'] = id;
+        form['profile_xmd[' + i + '][type]'] = 'p';
+      }
+    }
+    const result = await sendContent(
+      form,
+      threadID,
+      isSingleUser,
+      messageAndOTID,
+    );
+    return result;
+  };
+}

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

@@ -0,0 +1,48 @@
+// @ChoruOfficial
+'use strict';
+
+import utils = require('../../../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Sends a typing indicator to a specific thread.
+   * @param {boolean} sendTyping - True to show typing indicator, false to hide.
+   * @param {string} threadID - The ID of the thread to send the typing indicator to.
+   * @param {Function} [callback] - An optional callback function.
+   * @returns {Promise<void>}
+   */
+  return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
+    let count_req = 0;
+    const wsContent = {
+      app_id: 2220391788200892,
+      payload: JSON.stringify({
+        label: 3,
+        payload: JSON.stringify({
+          thread_key: threadID.toString(),
+          is_group_thread: +(threadID.toString().length >= 16),
+          is_typing: +sendTyping,
+          attribution: 0,
+        }),
+        version: 5849951561777440,
+      }),
+      request_id: ++count_req,
+      type: 4,
+    };
+    await new Promise<void>((resolve, reject) =>
+      ctx.mqttClient.publish(
+        '/ls_req',
+        JSON.stringify(wsContent),
+        {},
+        (err, _packet) => (err ? reject(err) : resolve()),
+      ),
+    );
+    if (callback) {
+      callback();
+    }
+  };
+}

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

@@ -0,0 +1,25 @@
+import utils = require("../../../utils");
+// @NethWs3Dev
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return async (reaction, messageID) => {
+    if (!reaction) throw new Error("Please enter a valid emoji.");
+    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, {
+      doc_id: "1491398900900362",
+      variables: JSON.stringify({
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction
+      }
+    }),
+      dpr: 1
+    });
+    const resData = await utils.parseAndCheckLogin(ctx.jar, defaultFuncs)(defData);
+    if (!resData) {
+      throw new Error("setMessageReactionLegacy returned empty object.");
+    }
+  };
+};

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

@@ -0,0 +1,63 @@
+import utils = require("../../../utils");
+
+/**
+ * @module shareContact
+ * @param {Object} defaultFuncs - The default functions provided by the API.
+ * @param {Object} api - The full API object.
+ * @param {Object} ctx - The context object.
+ * @returns {function(text: string, senderID: string, threadID: string, callback: Function): void} - A function to share a contact.
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Shares a user's contact information into a specific thread via MQTT.
+   * @param {string} [text] - An optional message to send along with the contact card.
+   * @param {string} senderID - The Facebook user ID of the contact you want to share.
+   * @param {string} threadID - The ID of the thread where the contact will be shared.
+   * @param {Function} [callback] - An optional callback function to be executed.
+   */
+  return function shareContact(text, senderID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber ??= 0;
+    ctx.wsTaskNumber ??= 0;
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      contact_id: senderID,
+      sync_group: 1,
+      text: text || "",
+      thread_id: threadID
+    };
+
+    const query = {
+      failure_count: null,
+      label: '359',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'messenger_contact_sharing',
+      task_id: Math.random() * 1001 << 0,
+    };
+
+    const context: any = {
+      app_id: '2220391788200892',
+      payload: {
+        tasks: [query],
+        epoch_id: utils.generateOfflineThreadingID(),
+        version_id: '7214102258676893',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    context.payload = JSON.stringify(context.payload);
+
+    if (typeof callback === 'function') {
+      ctx.callback_Task[ctx.wsReqNumber] = { callback, type: "shareContact" };
+    }
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false });
+  };
+};

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

@@ -0,0 +1,255 @@
+/**
+ * Sticker API Module
+ * Provides access to Facebook's GraphQL-based sticker endpoints.
+ * Made by @ChoruOfficial
+ */
+
+import utils = require("../../../utils");
+/**
+ * Format the sticker pack list (store or tray)
+ * @param {object} data - Raw GraphQL response
+ * @returns {{ packs: Array<{id: string, name: string, thumbnail: string}>, page_info: object, store_id?: string }}
+ */
+function formatPackList(data) {
+    const trayPacks = data?.data?.picker_plugins?.sticker_picker?.sticker_store?.tray_packs?.edges;
+    const storePacks = data?.data?.viewer?.sticker_store?.available_packs?.edges;
+    
+    const packData = storePacks || trayPacks;
+    if (!packData || !packData.edges) return { packs: [], page_info: { has_next_page: false } };
+
+    const formattedPacks = packData.edges.map(edge => edge.node ? ({
+        id: edge.node.id,
+        name: edge.node.name,
+        thumbnail: edge.node.thumbnail_image?.uri
+    }) : null).filter(Boolean);
+
+    return {
+        packs: formattedPacks,
+        page_info: packData.page_info,
+        store_id: data?.data?.viewer?.sticker_store?.id
+    };
+}
+
+/**
+ * Format search result stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerSearchResults(data) {
+    const stickers = data?.data?.sticker_search?.sticker_results?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format sticker pack content
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerPackResults(data) {
+    const stickers = data?.data?.sticker_pack?.stickers?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format AI-generated stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatAiStickers(data) {
+    const stickers = data?.data?.xfb_trending_generated_ai_stickers?.nodes;
+    if (!stickers) return [];
+    return stickers.map(node => ({
+        type: "sticker",
+        ID: node.id,
+        url: node.url,
+        label: node.label,
+        stickerID: node.id
+    })).filter(Boolean);
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+    /**
+     * Make a GraphQL request and handle login and error checking
+     * @param {object} form - Form data for the request
+     * @returns {Promise<object>}
+     */
+    async function makeRequest(form) {
+        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        if (!resData) throw new Error("GraphQL request returned no data.");
+        if (resData.errors) {
+            utils.error("StickerAPI GraphQL Error", resData.errors[0].message);
+            throw resData.errors[0];
+        }
+        return resData;
+    }
+
+    return {
+        /**
+         * Search for stickers by keyword
+         * @param {string} query - Search term
+         * @returns {Promise<Array<Object>>}
+         */
+        search: async function(query) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerSearchResultsRootQuery',
+                variables: JSON.stringify({
+                    scale: 3,
+                    search_query: query,
+                    sticker_height: 128,
+                    sticker_width: 128,
+                    stickerInterface: "MESSAGES"
+                }),
+                doc_id: '24004987559125954'
+            };
+            const res = await makeRequest(form);
+            return formatStickerSearchResults(res);
+        },
+
+        /**
+         * List user's sticker packs
+         * @returns {Promise<Array<Object>>}
+         */
+        listPacks: async function() {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerCardQuery',
+                variables: JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+                doc_id: '10095807770482952'
+            };
+            const res = await makeRequest(form);
+            return formatPackList(res).packs;
+        },
+
+        /**
+         * Get all available sticker packs from the store (with pagination)
+         * @returns {Promise<Array<Object>>}
+         */
+        getStorePacks: async function() {
+            utils.log("Starting to fetch all sticker packs from store...");
+            let allPacks = [];
+
+            const initialForm = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStoreDialogQuery',
+                variables: JSON.stringify({}),
+                doc_id: '29237828849196584'
+            };
+            let res = await makeRequest(initialForm);
+            let { packs, page_info, store_id } = formatPackList(res);
+            allPacks.push(...packs);
+            utils.log(`Fetched first page with ${packs.length} packs.`);
+
+            while (page_info && page_info.has_next_page) {
+                utils.log("Fetching next page with cursor:", page_info.end_cursor);
+
+                const paginatedForm = {
+                    fb_api_caller_class: 'RelayModern',
+                    fb_api_req_friendly_name: 'CometStickersStorePackListPaginationQuery',
+                    variables: JSON.stringify({
+                        count: 20,
+                        cursor: page_info.end_cursor,
+                        id: store_id
+                    }),
+                    doc_id: '9898634630218439'
+                };
+                res = await makeRequest(paginatedForm);
+                let paginatedResult = formatPackList(res);
+                allPacks.push(...paginatedResult.packs);
+                page_info = paginatedResult.page_info;
+                utils.log(`Fetched ${paginatedResult.packs.length} more packs. Total now: ${allPacks.length}`);
+            }
+
+            utils.log(`Finished fetching. Total unique packs found: ${allPacks.length}`);
+            return allPacks;
+        },
+
+        /**
+         * Merge user's and store sticker packs into one list
+         * @returns {Promise<Array<Object>>}
+         */
+        listAllPacks: async function() {
+            const [myPacks, storePacks] = await Promise.all([
+                this.listPacks(),
+                this.getStorePacks()
+            ]);
+            const allPacksMap = new Map();
+            myPacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            storePacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            return Array.from(allPacksMap.values());
+        },
+
+        /**
+         * Add a sticker pack by ID
+         * @param {string} packID - The ID of the sticker pack
+         * @returns {Promise<Object>}
+         */
+        addPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStorePackMutationAddMutation',
+                variables: JSON.stringify({
+                    input: {
+                        pack_id: packID,
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.round(Math.random() * 10).toString()
+                    }
+                }),
+                doc_id: '9877489362345320'
+            };
+            const res = await makeRequest(form);
+            return res.data.sticker_pack_add.sticker_pack;
+        },
+
+        /**
+         * Get all stickers in a pack
+         * @param {string} packID - Sticker pack ID
+         * @returns {Promise<Array<Object>>}
+         */
+        getStickersInPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerPackContentRootQuery',
+                variables: JSON.stringify({ packID, stickerWidth: 128, stickerHeight: 128, scale: 3 }),
+                doc_id: '23982341384707469'
+            };
+            const res = await makeRequest(form);
+            return formatStickerPackResults(res);
+        },
+
+        /**
+         * Get trending AI-generated stickers
+         * @param {{ limit?: number }} options - Options object
+         * @returns {Promise<Array<Object>>}
+         */
+        getAiStickers: async function({ limit = 10 } = {}) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerStickerGeneratedCardQuery',
+                variables: JSON.stringify({ limit }),
+                doc_id: '24151467751156443'
+            };
+            const res = await makeRequest(form);
+            return formatAiStickers(res);
+        }
+    };
+};