fca-neokex-fix 1.0.1

package/src/apis/getThreadHistory.js

@@ -0,0 +1,239 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+/**
+ * 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": {
+
+
+                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>>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    /**
+     * 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/apis/getThreadInfo.js

@@ -0,0 +1,257 @@
+
+"use strict";
+
+const 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.
+ * @throws {Error} If Facebook returns a GraphQL error
+ */
+function formatThreadGraphQLResponse(data) {
+  // Check for GraphQL errors and throw with details instead of silently returning null
+  if (data.errors) {
+    const details = data.errors.map(e => e.message || e).join(', ');
+    const error = new Error(`GraphQL error in getThreadInfo: ${details}`);
+    Object.assign(error, {
+      details: details,
+      fullErrors: data.errors
+    });
+    utils.error("formatThreadGraphQLResponse", error);
+    throw error;
+  }
+  
+  const messageThread = data.message_thread;
+  if (!messageThread) {
+    const error = new Error("No message_thread in GraphQL response - thread may not exist or access may be restricted");
+    Object.assign(error, {
+      details: "The GraphQL query returned successfully but contained no message_thread data"
+    });
+    utils.error("formatThreadGraphQLResponse", error);
+    throw error;
+  }
+
+  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>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * 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];
+            
+            // Check for error_results and throw instead of silently continuing
+            if (res.error_results) {
+                const error = new Error(`Facebook returned error_results for thread query: ${res.error_results} errors`);
+                Object.assign(error, {
+                    error_count: res.error_results,
+                    thread_index: i
+                });
+                utils.error("getThreadInfo", error);
+                throw error;
+            }
+            
+            const oKey = Object.keys(res)[0];
+            const responseData = res[oKey];
+            
+            // Check for errors in the response object
+            if (responseData.errors || responseData.error_results) {
+                const details = responseData.errors 
+                    ? JSON.stringify(responseData.errors) 
+                    : `error_results: ${responseData.error_results}`;
+                const error = new Error(`GraphQL error in thread response: ${details}`);
+                Object.assign(error, {
+                    details: details,
+                    thread_index: i,
+                    fullErrors: responseData.errors
+                });
+                utils.error("getThreadInfo", error);
+                throw error;
+            }
+            
+            const threadInfo = formatThreadGraphQLResponse(responseData.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;
+    }
+  };
+};