bb-fca 2.0.0

package/src/deltas/apis/posting/story.ts

@@ -0,0 +1,207 @@
+import utils = require('../../../utils');
+import { URL } from 'url';
+
+/**
+ * @namespace api.story
+ * @description A collection of functions for interacting with Facebook Stories.
+ * @license Ex-it
+ * @author Jonell Magallanes, ChoruOfficial
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * (Internal) Extracts the Story ID from a Facebook story URL.
+   * @param {string} url The Facebook story URL.
+   * @returns {string|null} The extracted Story ID or null if not found.
+   */
+  function getStoryIDFromURL(url) {
+    try {
+      const urlObject = new URL(url);
+      const pathParts = urlObject.pathname.split('/');
+      const storiesIndex = pathParts.indexOf('stories');
+      if (storiesIndex !== -1 && pathParts.length > storiesIndex + 2) {
+        return pathParts[storiesIndex + 2];
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * (Internal) The core function to send a reply or reaction to a story.
+   * @param {string} storyIdOrUrl The ID or URL of the story.
+   * @param {string} message The text message or emoji reaction.
+   * @param {boolean} isReaction True if the reply is a lightweight reaction.
+   * @returns {Promise<object>} The server's response.
+   */
+  async function sendStoryReply(storyIdOrUrl, message, isReaction) {
+    try {
+      const allowedReactions = ['❤️', '👍', '🤗', '😆', '😡', '😢', '😮'];
+
+      if (!storyIdOrUrl) throw new Error('Story ID or URL is required.');
+      if (!message) throw new Error('A message or reaction is required.');
+
+      let storyID = getStoryIDFromURL(storyIdOrUrl);
+      if (!storyID) storyID = storyIdOrUrl;
+
+      const variables: any = {
+        input: {
+          attribution_id_v2:
+            'StoriesCometSuspenseRoot.react,comet.stories.viewer,via_cold_start',
+          message: message,
+          story_id: storyID,
+          story_reply_type: isReaction ? 'LIGHT_WEIGHT' : 'TEXT',
+          actor_id: ctx.userID,
+          client_mutation_id: Math.floor(Math.random() * 10 + 1).toString(),
+        },
+      };
+
+      if (isReaction) {
+        if (!allowedReactions.includes(message)) {
+          throw new Error(
+            `Invalid reaction. Please use one of: ${allowedReactions.join(
+              ' ',
+            )}`,
+          );
+        }
+        variables.input.lightweight_reaction_actions = {
+          offsets: [0],
+          reaction: message,
+        };
+      }
+
+      const form = {
+        av: ctx.userID,
+        __user: ctx.userID,
+        __a: '1',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        fb_api_caller_class: 'RelayModern',
+        fb_api_req_friendly_name: 'useStoriesSendReplyMutation',
+        variables: JSON.stringify(variables),
+        doc_id: '9697491553691692',
+      };
+
+      const res = await defaultFuncs.post(
+        'https://www.facebook.com/api/graphql/',
+        ctx.jar,
+        form,
+        {},
+      );
+      if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+
+      const storyReplyData = res.data?.data?.direct_message_reply;
+      if (!storyReplyData)
+        throw new Error(
+          "Could not find 'direct_message_reply' in the response data.",
+        );
+
+      return { success: true, result: storyReplyData };
+    } catch (err) {
+      console.error('Error in story reply API:', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Creates a new text-based story.
+   * @param {string} message The text content of the story.
+   * @param {string} [fontName="classic"] The name of the font to use. Options: `headline`, `classic`, `casual`, `fancy`.
+   * @param {string} [backgroundName="blue"] The name of the background to use. Options: `orange`, `blue`, `green`, `modern`.
+   * @returns {Promise<{success: boolean, storyID: string}>} A promise that resolves with the new story's ID.
+   */
+  async function create(
+    message,
+    fontName = 'classic',
+    backgroundName = 'blue',
+  ) {
+    const fontMap = {
+      headline: '1919119914775364',
+      classic: '516266749248495',
+      casual: '516266749248495',
+      fancy: '1790435664339626',
+    };
+    const bgMap = {
+      orange: '2163607613910521',
+      blue: '401372137331149',
+      green: '367314917184744',
+      modern: '554617635055752',
+    };
+
+    const fontId = fontMap[fontName.toLowerCase()] || fontMap.classic;
+    const bgId = bgMap[backgroundName.toLowerCase()] || bgMap.blue;
+
+    const variables = {
+      input: {
+        audiences: [{ stories: { self: { target_id: ctx.userID } } }],
+        audiences_is_complete: true,
+        logging: { composer_session_id: 'createStoriesText-' + Date.now() },
+        navigation_data: {
+          attribution_id_v2: 'StoriesCreateRoot.react,comet.stories.create',
+        },
+        source: 'WWW',
+        message: { ranges: [], text: message },
+        text_format_metadata: { inspirations_custom_font_id: fontId },
+        text_format_preset_id: bgId,
+        tracking: [null],
+        actor_id: ctx.userID,
+        client_mutation_id: '2',
+      },
+    };
+
+    const form = {
+      __a: '1',
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'StoriesCreateMutation',
+      variables: JSON.stringify(variables),
+      doc_id: '24226878183562473',
+    };
+
+    try {
+      const res = await defaultFuncs.post(
+        'https://www.facebook.com/api/graphql/',
+        ctx.jar,
+        form,
+        {},
+      );
+      if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+
+      const storyNode =
+        res.data?.data?.story_create?.viewer?.actor?.story_bucket?.nodes[0]
+          ?.first_story_to_show;
+      if (!storyNode || !storyNode.id)
+        throw new Error('Could not find the storyCardID in the response.');
+
+      return { success: true, storyID: storyNode.id };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  return {
+    /**
+     * Creates a new text-based story.
+     * @param {string} message The text content of the story.
+     * @param {string} [fontName="classic"] The font to use (`headline`, `classic`, `fancy`).
+     * @param {string} [backgroundName="blue"] The background to use (`orange`, `blue`, `green`, `modern`).
+     * @returns {Promise<{success: boolean, storyID: string}>}
+     */
+    create,
+    /**
+     * Reacts to a story with a specific emoji.
+     * @param {string} storyIdOrUrl The ID or full URL of the story to react to.
+     * @param {string} reaction The emoji to react with. Must be one of: ❤️, 👍, 🤗, 😆, 😡, 😢, 😮.
+     * @returns {Promise<{success: boolean, result: object}>}
+     */
+    react: (storyIdOrUrl, reaction) =>
+      sendStoryReply(storyIdOrUrl, reaction, true),
+    /**
+     * Sends a text message reply to a story.
+     * @param {string} storyIdOrUrl The ID or full URL of the story to reply to.
+     * @param {string} message The text message to send.
+     * @returns {Promise<{success: boolean, result: object}>}
+     */
+    msg: (storyIdOrUrl, message) =>
+      sendStoryReply(storyIdOrUrl, message, false),
+  };
+}

package/src/deltas/apis/threads/getThreadHistory.ts

@@ -0,0 +1,237 @@
+import utils = require("../../../utils");
+
+// @ChoruOfficial
+/**
+ * Formats a single attachment object from a GraphQL response.
+ * @param {Object} attachment The raw attachment object.
+ * @returns {Object} A formatted attachment object.
+ */
+function formatAttachmentsGraphQLResponse(attachment) {
+    switch (attachment.__typename) {
+        case "MessageImage":
+            return {
+                type: "photo",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                thumbnailUrl: attachment.thumbnail.uri,
+                previewUrl: attachment.preview.uri,
+                previewWidth: attachment.preview.width,
+                previewHeight: attachment.preview.height,
+                largePreviewUrl: attachment.large_preview.uri,
+                largePreviewHeight: attachment.large_preview.height,
+                largePreviewWidth: attachment.large_preview.width,
+                url: attachment.large_preview.uri,
+                width: attachment.original_dimensions.x,
+                height: attachment.original_dimensions.y,
+                name: attachment.filename
+            };
+        case "MessageAnimatedImage":
+            return {
+                type: "animated_image",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                previewUrl: attachment.preview_image.uri,
+                previewWidth: attachment.preview_image.width,
+                previewHeight: attachment.preview_image.height,
+                url: attachment.animated_image.uri,
+                width: attachment.animated_image.width,
+                height: attachment.animated_image.height,
+                name: attachment.filename,
+                facebookUrl: attachment.animated_image.uri,
+            };
+        case "MessageVideo":
+            return {
+                type: "video",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                duration: attachment.playable_duration_in_ms,
+                thumbnailUrl: attachment.large_image.uri,
+                previewUrl: attachment.large_image.uri,
+                previewWidth: attachment.large_image.width,
+                previewHeight: attachment.large_image.height,
+                url: attachment.playable_url,
+                width: attachment.original_dimensions.x,
+                height: attachment.original_dimensions.y,
+                videoType: attachment.video_type.toLowerCase(),
+            };
+        case "MessageFile":
+            return {
+                type: "file",
+                ID: attachment.message_file_fbid,
+                filename: attachment.filename,
+                url: attachment.url,
+                isMalicious: attachment.is_malicious,
+                contentType: attachment.content_type,
+                name: attachment.filename,
+            };
+        case "MessageAudio":
+            return {
+                type: "audio",
+                ID: attachment.url_shimhash,
+                filename: attachment.filename,
+                duration: attachment.playable_duration_in_ms,
+                audioType: attachment.audio_type,
+                url: attachment.playable_url,
+                isVoiceMail: attachment.is_voicemail,
+            };
+        default:
+            return {
+                type: "unknown",
+                error: "Don't know about attachment type " + attachment.__typename,
+            };
+    }
+}
+
+/**
+ * Formats a share (extensible) attachment from a GraphQL response.
+ * @param {Object} attachment The raw extensible attachment object.
+ * @returns {Object} A formatted share attachment object.
+ */
+function formatExtensibleAttachment(attachment) {
+    if (attachment.story_attachment) {
+        return {
+            type: "share",
+            ID: attachment.legacy_attachment_id,
+            url: attachment.story_attachment.url,
+            title: attachment.story_attachment.title_with_entities.text,
+            description: attachment.story_attachment.description && attachment.story_attachment.description.text,
+            source: attachment.story_attachment.source == null ? null : attachment.story_attachment.source.text,
+            image: attachment.story_attachment.media?.image?.uri,
+            width: attachment.story_attachment.media?.image?.width,
+            height: attachment.story_attachment.media?.image?.height,
+            playable: attachment.story_attachment.media?.is_playable,
+            duration: attachment.story_attachment.media?.playable_duration_in_ms,
+            playableUrl: attachment.story_attachment.media?.playable_url,
+            subattachments: attachment.story_attachment.subattachments,
+            properties: attachment.story_attachment.properties.reduce((obj, cur) => {
+                obj[cur.key] = cur.value.text;
+                return obj;
+            }, {}),
+        };
+    }
+    return { type: "unknown", error: "Don't know what to do with extensible_attachment." };
+}
+
+/**
+ * Formats the response from a GraphQL message history query.
+ * @param {Object} data The raw GraphQL response data.
+ * @returns {Array<Object>} An array of formatted message objects.
+ */
+function formatMessagesGraphQLResponse(data) {
+    const messageThread = data.o0.data.message_thread;
+    if (!messageThread) return [];
+
+    const threadID = messageThread.thread_key.thread_fbid ? messageThread.thread_key.thread_fbid : messageThread.thread_key.other_user_id;
+
+    return messageThread.messages.nodes.map(d => {
+        switch (d.__typename) {
+            case "UserMessage":
+                const mentions = {};
+                if (d.message?.ranges) {
+                    d.message.ranges.forEach(e => {
+                        mentions[e.entity.id] = d.message.text.substring(e.offset, e.offset + e.length);
+                    });
+                }
+                return {
+                    type: "message",
+                    attachments: d.sticker ? [{
+                        type: "sticker",
+                        ID: d.sticker.id,
+                        url: d.sticker.url,
+                        packID: d.sticker.pack?.id,
+                        frameCount: d.sticker.frame_count,
+                        frameRate: d.sticker.frame_rate,
+                        framesPerRow: d.sticker.frames_per_row,
+                        framesPerCol: d.sticker.frames_per_col,
+                        stickerID: d.sticker.id,
+                    }] : (d.blob_attachments || []).map(formatAttachmentsGraphQLResponse).concat(d.extensible_attachment ? [formatExtensibleAttachment(d.extensible_attachment)] : []),
+                    body: d.message?.text || "",
+                    isGroup: messageThread.thread_type === "GROUP",
+                    messageID: d.message_id,
+                    senderID: d.message_sender.id,
+                    threadID: threadID,
+                    timestamp: d.timestamp_precise,
+                    mentions: mentions,
+                    isUnread: d.unread,
+                    messageReactions: d.message_reactions?.map(r => ({ reaction: r.reaction, userID: r.user.id })) || [],
+                };
+            case "ThreadNameMessage":
+            case "ThreadImageMessage":
+            case "ParticipantLeftMessage":
+            case "ParticipantsAddedMessage":
+            case "GenericAdminTextMessage": {
+                // This is the fix. We are now formatting the event directly
+                // instead of calling the incompatible `formatDeltaEvent`.
+                return {
+                    type: "event",
+                    messageID: d.message_id,
+                    threadID: threadID,
+                    isGroup: messageThread.thread_type === "GROUP",
+                    senderID: d.message_sender.id,
+                    author: d.message_sender.id,
+                    timestamp: d.timestamp_precise,
+                    snippet: d.snippet,
+                    logMessageType: utils.getAdminTextMessageType(d.extensible_message_admin_text_type || d.__typename),
+                    logMessageData: d.extensible_message_admin_text || d,
+                };
+            }
+            default:
+                return { type: "unknown", error: "Unknown message type " + d.__typename, raw: d };
+        }
+    });
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(threadID: string, amount: number, timestamp: number | null): Promise<Array<Object>>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+    /**
+     * Retrieves the message history for a specific thread.
+     * @param {string} threadID The ID of the thread to fetch history from.
+     * @param {number} amount The number of messages to retrieve.
+     * @param {number | null} timestamp The timestamp to start fetching messages before.
+     * @returns {Promise<Array<Object>>} A promise that resolves with an array of formatted message objects.
+     */
+    return async function getThreadHistory(threadID, amount, timestamp) {
+        if (!threadID || !amount) {
+            throw new Error("getThreadHistory: threadID and amount are required.");
+        }
+
+        const form = {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "1498317363570230",
+                    query_params: {
+                        id: threadID,
+                        message_limit: amount,
+                        load_messages: 1,
+                        load_read_receipts: false,
+                        before: timestamp || null,
+                    },
+                },
+            }),
+        };
+
+        try {
+            const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form);
+            const parsedData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(resData);
+
+            if (parsedData.error || (Array.isArray(parsedData) && parsedData[parsedData.length - 1].error_results !== 0)) {
+                throw parsedData;
+            }
+            
+            if (!Array.isArray(parsedData) || !parsedData[0] || !parsedData[0].o0 || !parsedData[0].o0.data) {
+                throw { error: "getThreadHistory: Malformed response from GraphQL.", res: parsedData };
+            }
+
+            return formatMessagesGraphQLResponse(parsedData[0]);
+        } catch (err) {
+            utils.error("getThreadHistory", err);
+            throw err;
+        }
+    };
+};

package/src/deltas/apis/threads/getThreadInfo.ts

@@ -0,0 +1,210 @@
+// @ChoruOfficial
+"use strict";
+
+import utils = require("../../../utils");
+
+/**
+ * Formats an event reminder object from a GraphQL response.
+ * @param {Object} reminder The raw event reminder object.
+ * @returns {Object} A formatted event reminder object.
+ */
+function formatEventReminders(reminder) {
+  return {
+    reminderID: reminder.id,
+    eventCreatorID: reminder.lightweight_event_creator.id,
+    time: reminder.time,
+    eventType: reminder.lightweight_event_type.toLowerCase(),
+    locationName: reminder.location_name,
+    locationCoordinates: reminder.location_coordinates,
+    locationPage: reminder.location_page,
+    eventStatus: reminder.lightweight_event_status.toLowerCase(),
+    note: reminder.note,
+    repeatMode: reminder.repeat_mode.toLowerCase(),
+    eventTitle: reminder.event_title,
+    triggerMessage: reminder.trigger_message,
+    secondsToNotifyBefore: reminder.seconds_to_notify_before,
+    allowsRsvp: reminder.allows_rsvp,
+    relatedEvent: reminder.related_event,
+    members: reminder.event_reminder_members.edges.map(function (member) {
+      return {
+        memberID: member.node.id,
+        state: member.guest_list_state.toLowerCase(),
+      };
+    }),
+  };
+}
+
+/**
+ * Formats a thread object from a GraphQL response.
+ * @param {Object} data The raw GraphQL data for a thread.
+ * @returns {Object | null} A formatted thread object or null if data is invalid.
+ */
+function formatThreadGraphQLResponse(data) {
+  if (data.errors) return null;
+  const messageThread = data.message_thread;
+  if (!messageThread) return null;
+
+  const threadID = messageThread.thread_key.thread_fbid
+    ? messageThread.thread_key.thread_fbid
+    : messageThread.thread_key.other_user_id;
+
+  const lastM = messageThread.last_message;
+  const snippetID =
+    lastM?.nodes?.[0]?.message_sender?.messaging_actor?.id || null;
+  const snippetText = lastM?.nodes?.[0]?.snippet || null;
+  const lastR = messageThread.last_read_receipt;
+  const lastReadTimestamp = lastR?.nodes?.[0]?.timestamp_precise || null;
+
+  return {
+    threadID: threadID,
+    threadName: messageThread.name,
+    participantIDs: messageThread.all_participants.edges.map(
+      (d) => d.node.messaging_actor.id,
+    ),
+    userInfo: messageThread.all_participants.edges.map((d) => ({
+      id: d.node.messaging_actor.id,
+      name: d.node.messaging_actor.name,
+      firstName: d.node.messaging_actor.short_name,
+      vanity: d.node.messaging_actor.username,
+      url: d.node.messaging_actor.url,
+      thumbSrc: d.node.messaging_actor.big_image_src.uri,
+      profileUrl: d.node.messaging_actor.big_image_src.uri,
+      gender: d.node.messaging_actor.gender,
+      type: d.node.messaging_actor.__typename,
+      isFriend: d.node.messaging_actor.is_viewer_friend,
+      isBirthday: !!d.node.messaging_actor.is_birthday,
+    })),
+    unreadCount: messageThread.unread_count,
+    messageCount: messageThread.messages_count,
+    timestamp: messageThread.updated_time_precise,
+    muteUntil: messageThread.mute_until,
+    isGroup: messageThread.thread_type == "GROUP",
+    isSubscribed: messageThread.is_viewer_subscribed,
+    isArchived: messageThread.has_viewer_archived,
+    folder: messageThread.folder,
+    cannotReplyReason: messageThread.cannot_reply_reason,
+    eventReminders: messageThread.event_reminders
+      ? messageThread.event_reminders.nodes.map(formatEventReminders)
+      : null,
+    emoji: messageThread.customization_info
+      ? messageThread.customization_info.emoji
+      : null,
+    color:
+      messageThread.customization_info &&
+      messageThread.customization_info.outgoing_bubble_color
+        ? messageThread.customization_info.outgoing_bubble_color.slice(2)
+        : null,
+    threadTheme: messageThread.thread_theme,
+    nicknames:
+      messageThread.customization_info &&
+      messageThread.customization_info.participant_customizations
+        ? messageThread.customization_info.participant_customizations.reduce(
+            function (res, val) {
+              if (val.nickname) res[val.participant_id] = val.nickname;
+              return res;
+            },
+            {},
+          )
+        : {},
+    adminIDs: messageThread.thread_admins,
+    approvalMode: Boolean(messageThread.approval_mode),
+    approvalQueue: messageThread.group_approval_queue.nodes.map((a) => ({
+      inviterID: a.inviter.id,
+      requesterID: a.requester.id,
+      timestamp: a.request_timestamp,
+      request_source: a.request_source,
+    })),
+    reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
+    mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
+    isPinProtected: messageThread.is_pin_protected,
+    relatedPageThread: messageThread.related_page_thread,
+    name: messageThread.name,
+    snippet: snippetText,
+    snippetSender: snippetID,
+    snippetAttachments: [],
+    serverTimestamp: messageThread.updated_time_precise,
+    imageSrc: messageThread.image ? messageThread.image.uri : null,
+    isCanonicalUser: messageThread.is_canonical_neo_user,
+    isCanonical: messageThread.thread_type != "GROUP",
+    recipientsLoadable: true,
+    hasEmailParticipant: false,
+    readOnly: false,
+    canReply: messageThread.cannot_reply_reason == null,
+    lastMessageTimestamp: messageThread.last_message
+      ? messageThread.last_message.timestamp_precise
+      : null,
+    lastMessageType: "message",
+    lastReadTimestamp: lastReadTimestamp,
+    threadType: messageThread.thread_type == "GROUP" ? 2 : 1,
+    inviteLink: {
+      enable: messageThread.joinable_mode
+        ? messageThread.joinable_mode.mode == 1
+        : false,
+      link: messageThread.joinable_mode
+        ? messageThread.joinable_mode.link
+        : null,
+    },
+  };
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(threadID: string | string[]): Promise<Object>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Retrieves information about one or more threads.
+   * @param {string|string[]} threadID A single thread ID or an array of thread IDs.
+   * @returns {Promise<Object>} A promise that resolves with an object of thread info, or a single thread object if one ID was passed.
+   */
+  return async function getThreadInfo(threadID) {
+    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
+    
+    let form = {};
+    threadIDs.forEach((t, i) => {
+      form["o" + i] = {
+        doc_id: "3449967031715030",
+        query_params: {
+          id: t,
+          message_limit: 0,
+          load_messages: false,
+          load_read_receipts: false,
+          before: null,
+        },
+      };
+    });
+
+    form = {
+      queries: JSON.stringify(form),
+      batch_name: "MessengerGraphQLThreadFetcher",
+    };
+
+    try {
+        const resData = await defaultFuncs
+            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (resData.error) {
+            throw resData;
+        }
+
+        const threadInfos = {};
+        for (let i = resData.length - 2; i >= 0; i--) {
+            const res = resData[i];
+            if (res.error_results) continue;
+            
+            const threadInfo = formatThreadGraphQLResponse(res[Object.keys(res)[0]].data);
+            if (threadInfo) {
+                threadInfos[threadInfo.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
+            }
+        }
+
+        return Array.isArray(threadID) ? threadInfos : Object.values(threadInfos)[0] || null;
+    } catch (err) {
+        utils.error("getThreadInfo", err);
+        throw err;
+    }
+  };
+};