fca-neokex-fix 1.0.1

package/src/apis/getThreadList.js

@@ -0,0 +1,222 @@
+
+"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} 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 || !messageThread.thread_key) 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(
+            (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() || 'all_reactions',
+    mentionsMuteMode: messageThread.mentions_mute_mode?.toLowerCase() || 'all_mentions',
+    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?.mode == 1,
+      link: messageThread.joinable_mode?.link || null,
+    },
+  };
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(limit: number, timestamp: number | null, tags: string[]): Promise<Array<Object>>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Retrieves a list of threads.
+   * @param {number} limit - The number of threads to retrieve.
+   * @param {number|null} timestamp - A timestamp to start fetching threads before. Use null for the most recent.
+   * @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 getThreadList(limit, timestamp = null, tags = ["INBOX"]) {
+    if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) {
+      throw new Error("getThreadList: limit must be a positive integer.");
+    }
+    if (utils.getType(timestamp) !== "Null" && (utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))) {
+      throw new Error("getThreadList: timestamp must be an integer or null.");
+    }
+    if (utils.getType(tags) === "String") {
+      tags = [tags];
+    }
+    if (utils.getType(tags) !== "Array") {
+      throw new Error("getThreadList: tags must be an array.");
+    }
+
+    const form = {
+      av: ctx.i_userID || ctx.userID,
+      queries: JSON.stringify({
+        o0: {
+          doc_id: "3336396659757871",
+          query_params: {
+            limit: limit + (timestamp ? 1 : 0),
+            before: timestamp,
+            tags: tags,
+            includeDeliveryReceipts: true,
+            includeSeqID: false,
+          },
+        },
+      }),
+      batch_name: "MessengerGraphQLThreadlistFetcher",
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (!resData || !Array.isArray(resData) || resData.length === 0) {
+        throw new Error("getThreadList: Invalid response from server");
+      }
+
+      const lastResult = resData[resData.length - 1];
+      if (lastResult && lastResult.error_results && lastResult.error_results > 0) {
+        throw new Error(JSON.stringify(resData[0]?.o0?.errors || "Unknown error"));
+      }
+
+      if (lastResult && lastResult.successful_results === 0) {
+        throw new Error("getThreadList: there was no successful_results");
+      }
+
+      if (!resData[0] || !resData[0].o0 || !resData[0].o0.data) {
+        throw new Error("getThreadList: Invalid data structure in response");
+      }
+
+      let nodes = resData[0].o0.data.viewer.message_threads.nodes;
+      if (timestamp) {
+        nodes.shift();
+      }
+
+      return nodes.map(formatThreadGraphQLResponse);
+    } catch (err) {
+      utils.error("getThreadList", err);
+      throw err;
+    }
+  };
+};

package/src/apis/getThreadPictures.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function getThreadPictures(threadID, offset, limit, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (utils.getType(limit) === "Function") {
+        callback = limit;
+        limit = 50;
+      } else if (utils.getType(offset) === "Function") {
+        callback = offset;
+        offset = 0;
+        limit = 50;
+      } else {
+        callback = (err, result) => {
+          if (err) return rejectFunc(err);
+          resolveFunc(result);
+        };
+      }
+    }
+
+    offset = offset || 0;
+    limit = limit || 50;
+
+    try {
+      const form = {
+        thread_id: threadID,
+        offset: offset,
+        limit: limit
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/thread_images.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, res?.payload || res);
+    } catch (err) {
+      utils.error("getThreadPictures", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/getUserID.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const utils = require('../utils');
+
+function formatData(data) {
+  return {
+    userID: utils.formatID(data.uid.toString()),
+    photoUrl: data.photo,
+    indexRank: data.index_rank,
+    name: data.text,
+    isVerified: data.is_verified,
+    profileUrl: data.path,
+    category: data.category,
+    score: data.score,
+    type: data.type
+  };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function getUserID(name, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    if (!name || typeof name !== 'string') {
+      const error = { error: "getUserID: name parameter must be a non-empty string" };
+      utils.error("getUserID", error);
+      return callback(error);
+    }
+
+    try {
+      const form = {
+        value: name.toLowerCase(),
+        viewer: ctx.userID,
+        rsp: "search",
+        context: "search",
+        path: "/home.php",
+        request_id: ctx.clientID || utils.getGUID()
+      };
+
+      const res = await defaultFuncs.get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.error) {
+        throw res;
+      }
+
+      if (!res.payload || !res.payload.entries) {
+        const error = { 
+          error: "getUserID: No results found. This may be due to Facebook security restrictions or account checkpoint.",
+          details: "Your account may require verification. Please visit facebook.com to verify."
+        };
+        throw error;
+      }
+
+      const data = res.payload.entries;
+      
+      if (data.length === 0) {
+        utils.warn(`getUserID: No user found with name "${name}"`);
+      }
+
+      callback(null, data.map(formatData));
+    } catch (err) {
+      if (err.error && typeof err.error === 'string' && err.error.includes('checkpoint')) {
+        err.friendlyMessage = "Account checkpoint required - Please verify your account on facebook.com";
+      }
+      utils.error("getUserID", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};