bb-fca 2.0.10 → 2.0.12

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

@@ -0,0 +1,239 @@
+// @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} messageThread The raw message_thread object from GraphQL.
+ * @returns {Object | null} A formatted thread object or null if data is invalid.
+ */
+function formatThreadGraphQLResponse(messageThread) {
+  if (!messageThread) {
+    console.log('[getPageThreadList] messageThread is undefined!');
+    return null;
+  }
+  if (!messageThread.thread_key) {
+    console.log(
+      '[getPageThreadList] thread_key missing for thread:',
+      messageThread.id,
+    );
+    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?.nodes
+      ? messageThread.event_reminders.nodes.map(formatEventReminders)
+      : null,
+    emoji: messageThread.customization_info?.emoji || null,
+    color: messageThread.customization_info?.outgoing_bubble_color
+      ? messageThread.customization_info.outgoing_bubble_color.slice(2)
+      : null,
+    threadTheme: messageThread.thread_theme,
+    nicknames: messageThread.customization_info?.participant_customizations
+      ? messageThread.customization_info.participant_customizations.reduce(
+          (res, val) => {
+            if (val.nickname) res[val.participant_id] = val.nickname;
+            return res;
+          },
+          {},
+        )
+      : {},
+    adminIDs: messageThread.thread_admins?.map((a) => a.id) || [],
+    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() || null,
+    mentionsMuteMode: messageThread.mentions_mute_mode?.toLowerCase() || null,
+    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?.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?.timestamp_precise || null,
+    lastMessageType: 'message',
+    lastReadTimestamp: lastReadTimestamp,
+    threadType: messageThread.thread_type == 'GROUP' ? 2 : 1,
+    inviteLink: {
+      enable: messageThread.joinable_mode?.mode == 1,
+      link: messageThread.joinable_mode?.link || null,
+    },
+  };
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(pageID: string, limit: number, tags: string[]): Promise<Array<Object>>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Retrieves a list of current message threads for a managed Page.
+   * @param {string} pageID - The ID of the page.
+   * @param {number} limit - The number of threads to retrieve.
+   * @param {string[]} tags - An array of tags to filter threads by (e.g., ["INBOX", "ARCHIVED"]).
+   * @returns {Promise<Object[]>} A promise that resolves with an array of formatted thread objects.
+   */
+  return async function getPageThreadList(
+    pageID: string,
+    limit: number = 20,
+    tags: string[] = ['INBOX'],
+  ) {
+    if (!pageID) {
+      throw new Error('getPageThreadList: pageID is required.');
+    }
+    if (
+      utils.getType(limit) !== 'Number' ||
+      !Number.isInteger(limit) ||
+      limit <= 0
+    ) {
+      throw new Error('getPageThreadList: limit must be a positive integer.');
+    }
+    if (utils.getType(tags) === 'String') {
+      tags = [tags] as any;
+    }
+    if (utils.getType(tags) !== 'Array') {
+      throw new Error('getPageThreadList: tags must be an array.');
+    }
+
+    const variables = {
+      limit: limit,
+      tags: tags,
+      isWorkUser: false,
+      includeDeliveryReceipts: true,
+      includeSeqID: false,
+      is_work_teamwork_not_putting_muted_in_unreads: false,
+    };
+
+    const form = {
+      av: pageID,
+      __user: ctx.userID,
+      __a: 1,
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.jazoest,
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'MessengerGraphQLThreadlistFetcher',
+      variables: JSON.stringify(variables),
+      doc_id: '3566388080113165',
+    };
+
+    try {
+      const resp = await utils
+        .post(
+          'https://www.facebook.com/api/graphql/',
+          ctx.jar,
+          form,
+          ctx.globalOptions,
+          ctx,
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resp.errors) {
+        throw new Error(JSON.stringify(resp.errors));
+      }
+
+      let nodes = resp?.data?.viewer?.message_threads?.nodes || [];
+
+      const formatted = nodes
+        .map((node, index) => {
+          try {
+            return formatThreadGraphQLResponse(node);
+          } catch (e) {
+            return null;
+          }
+        })
+        .filter(Boolean);
+
+      return formatted;
+    } catch (err) {
+      utils.error('getPageThreadList', err);
+      throw err;
+    }
+  };
+}

package/src/deltas/apis/users/getManagedPages.ts

@@ -0,0 +1,94 @@
+// @ChoruOfficial
+import utils = require('../../../utils');
+import deepdash from 'deepdash';
+import _ from 'lodash';
+deepdash(_);
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function getManagedPages(callback?: (err: any, data?: any) => void) {
+    let cb: any;
+    const returnPromise = new Promise<any>((resolve, reject) => {
+      cb = (err: any, resData: any) => {
+        if (callback) callback(err, resData);
+        if (err) return reject(err);
+        resolve(resData);
+      };
+    });
+
+    const fetchPages = async () => {
+      try {
+        const url = `https://www.facebook.com/pages/?category=your_pages&ref=bookmarks`;
+        const allJsonData = await utils.json(
+          url,
+          ctx.jar,
+          null,
+          ctx.globalOptions,
+          ctx,
+        );
+
+        if (!allJsonData || allJsonData.length === 0) {
+          throw new Error(`Could not find JSON data for managed pages.`);
+        }
+
+        const results: any[] = [];
+
+        const deepFind = (obj: any) => {
+          if (obj && typeof obj === 'object') {
+            if (!Array.isArray(obj)) {
+              if (
+                obj.profile_switcher_eligible_profiles &&
+                Array.isArray(obj.profile_switcher_eligible_profiles.nodes)
+              ) {
+                obj.profile_switcher_eligible_profiles.nodes.forEach(
+                  (node: any) => {
+                    const prof = node.profile;
+                    if (prof && prof.id && prof.name) {
+                      if (!results.find((r) => r.id === prof.id)) {
+                        results.push(prof);
+                      }
+                    }
+                  },
+                );
+              }
+              if (
+                obj.first_profiles &&
+                Array.isArray(obj.first_profiles.nodes)
+              ) {
+                obj.first_profiles.nodes.forEach((node: any) => {
+                  const prof = node.profile;
+                  if (prof && prof.id && prof.name) {
+                    if (!results.find((r) => r.id === prof.id)) {
+                      results.push(prof);
+                    }
+                  }
+                });
+              }
+              Object.values(obj).forEach(deepFind);
+            } else {
+              obj.forEach(deepFind);
+            }
+          }
+        };
+
+        deepFind(allJsonData);
+
+        // Return cleaned up objects
+        const cleanResults = results.map((prof) => ({
+          id: prof.id,
+          name: prof.name,
+          profilePicUrl: prof.profile_picture?.uri || null,
+          isProfilePlus: !!prof.is_profile_plus,
+          delegatePageId: prof.delegate_page_id || null,
+        }));
+
+        return cb(null, cleanResults);
+      } catch (err) {
+        utils.error('getManagedPages', err);
+        return cb(err);
+      }
+    };
+
+    fetchPages();
+    return returnPromise;
+  };
+}

package/src/types/index.d.ts

@@ -422,6 +422,24 @@ export interface GroupModule {
     keyword: string,
     options?: SearchGroupOptions,
   ): Promise<SearchGroupResult>;
+
+  /**
+   * Resolves a Facebook share URL to the actual group ID.
+   *
+   * Accepts various formats:
+   * - Full URL: `https://www.facebook.com/share/g/14bKqsywAfu/`
+   * - Path only: `/share/g/14bKqsywAfu/`
+   * - Short key: `14bKqsywAfu`
+   *
+   * @param shareUrl The share URL, path, or short key to resolve.
+   */
+  resolveShareUrl(
+    shareUrl: string,
+  ): Promise<{
+    groupID: string;
+    name: string | null;
+    url: string | null;
+  }>;
 }
 
 export interface MessageObject {
@@ -549,6 +567,14 @@ export interface API {
     callback?: Callback<ThreadInfo[]>,
   ): Promise<ThreadInfo[]>;
 
+  /** Get a list of threads for a managed Page. */
+  getPageThreadList(
+    pageID: string,
+    limit?: number,
+    tags?: string[],
+    callback?: Callback<ThreadInfo[]>,
+  ): Promise<ThreadInfo[]>;
+
   /** Get message history for a thread. */
   getThreadHistory(
     threadID: ThreadID,

package/src/utils/clients.ts

@@ -22,7 +22,8 @@ export function parseAndCheckLogin(ctx: any, http: any, retryCount: number = 0):
 
       await delay(retryTime);
 
-      if (data.request.headers["content-type"].split(";")[0] === "multipart/form-data") {
+      const contentType = data.request.headers && data.request.headers["content-type"];
+      if (contentType && contentType.split(";")[0] === "multipart/form-data") {
         const newData = await http.postFormData(url, ctx.jar, data.request.formData, data.request.qs, ctx.globalOptions, ctx);
         return await parseAndCheckLogin(ctx, http, retryCount)(newData);
       } else {

package/src/utils/index.ts

@@ -1,11 +1,11 @@
+import * as cheerio from "cheerio";
+import * as util from "util";
 import * as network from "./axios";
-import * as headers from "./headers";
 import * as clients from "./clients";
 import * as constants from "./constants";
 import * as formatters from "./formatters";
+import * as headers from "./headers";
 import * as userAgents from "./user-agents";
-import * as cheerio from "cheerio";
-import * as util from "util";
 
 async function json(url: string, jar: any, qs?: any, options?: any, ctx?: any, customHeader?: any): Promise<any[]> {
   try {
@@ -39,7 +39,7 @@ function makeDefaults(html: string, userID: string | number, ctx: any): any {
   function mergeWithDefaults(obj?: any): any {
     const newObj: any = { av: userID, __user: userID, __req: (reqCounter++).toString(36), __rev: revision, __a: 1, ...(ctx && { fb_dtsg: ctx.fb_dtsg, jazoest: ctx.jazoest }) };
     if (!obj) return newObj;
-    for (const prop in obj) { if (obj.hasOwnProperty(prop) && !newObj[prop]) { newObj[prop] = obj[prop]; } }
+    for (const prop in obj) { if (obj.hasOwnProperty(prop)) { newObj[prop] = obj[prop]; } }
     return newObj;
   }
   return {