stfca 1.0.0

package/src/api/threads/getThreadInfo.js

@@ -0,0 +1,358 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { formatID, getType } = require("../../utils/format");
+
+function formatEventReminders(reminder) {
+  return {
+    reminderID: reminder?.id,
+    eventCreatorID: reminder?.lightweight_event_creator?.id,
+    time: reminder?.time,
+    eventType: String(reminder?.lightweight_event_type || "").toLowerCase(),
+    locationName: reminder?.location_name,
+    locationCoordinates: reminder?.location_coordinates,
+    locationPage: reminder?.location_page,
+    eventStatus: String(reminder?.lightweight_event_status || "").toLowerCase(),
+    note: reminder?.note,
+    repeatMode: String(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: Array.isArray(reminder?.event_reminder_members?.edges) ? reminder.event_reminder_members.edges.map(m => ({
+      memberID: m?.node?.id,
+      state: String(m?.guest_list_state || "").toLowerCase(),
+    })) : [],
+  };
+}
+
+function formatThreadGraphQLResponse(data) {
+  if (!data) return null;
+  if (data?.errors) return null;
+  const t = data.message_thread;
+  if (!t) return null;
+  const threadID = t?.thread_key?.thread_fbid || t?.thread_key?.other_user_id || null;
+  const lastM = t?.last_message;
+  const lastNode = Array.isArray(lastM?.nodes) && lastM.nodes[0] ? lastM.nodes[0] : null;
+  const snippetID = lastNode?.message_sender?.messaging_actor?.id || null;
+  const snippetText = lastNode?.snippet || null;
+  const lastRNode = Array.isArray(t?.last_read_receipt?.nodes) && t.last_read_receipt.nodes[0] ? t.last_read_receipt.nodes[0] : null;
+  const lastReadTimestamp = lastRNode?.timestamp_precise || null;
+  const participants = Array.isArray(t?.all_participants?.edges) ? t.all_participants.edges : [];
+  const approvals = Array.isArray(t?.group_approval_queue?.nodes) ? t.group_approval_queue.nodes : [];
+  const customInfo = t?.customization_info || {};
+  const bubble = customInfo?.outgoing_bubble_color;
+  const participantCustoms = Array.isArray(customInfo?.participant_customizations) ? customInfo.participant_customizations : [];
+  const nicknames = participantCustoms.reduce((res, val) => {
+    if (val?.nickname && val?.participant_id) res[val.participant_id] = val.nickname;
+    return res;
+  }, {});
+  return {
+    threadID,
+    threadName: t?.name || null,
+    participantIDs: participants.map(d => d?.node?.messaging_actor?.id).filter(Boolean),
+    userInfo: participants.map(d => ({
+      id: d?.node?.messaging_actor?.id || null,
+      name: d?.node?.messaging_actor?.name || null,
+      firstName: d?.node?.messaging_actor?.short_name || null,
+      vanity: d?.node?.messaging_actor?.username || null,
+      url: d?.node?.messaging_actor?.url || null,
+      thumbSrc: d?.node?.messaging_actor?.big_image_src?.uri || null,
+      profileUrl: d?.node?.messaging_actor?.big_image_src?.uri || null,
+      gender: d?.node?.messaging_actor?.gender || null,
+      type: d?.node?.messaging_actor?.__typename || null,
+      isFriend: !!d?.node?.messaging_actor?.is_viewer_friend,
+      isBirthday: !!d?.node?.messaging_actor?.is_birthday,
+    })),
+    unreadCount: t?.unread_count ?? 0,
+    messageCount: t?.messages_count ?? 0,
+    timestamp: t?.updated_time_precise || null,
+    muteUntil: t?.mute_until || null,
+    isGroup: t?.thread_type === "GROUP",
+    isSubscribed: !!t?.is_viewer_subscribed,
+    isArchived: !!t?.has_viewer_archived,
+    folder: t?.folder || null,
+    cannotReplyReason: t?.cannot_reply_reason || null,
+    eventReminders: Array.isArray(t?.event_reminders?.nodes) ? t.event_reminders.nodes.map(formatEventReminders) : [],
+    emoji: customInfo?.emoji || null,
+    color: bubble ? String(bubble).slice(2) : null,
+    threadTheme: t?.thread_theme || null,
+    nicknames,
+    adminIDs: Array.isArray(t?.thread_admins) ? t.thread_admins : [],
+    approvalMode: !!t?.approval_mode,
+    approvalQueue: approvals.map(a => ({
+      inviterID: a?.inviter?.id || null,
+      requesterID: a?.requester?.id || null,
+      timestamp: a?.request_timestamp || null,
+      request_source: a?.request_source || null,
+    })),
+    reactionsMuteMode: String(t?.reactions_mute_mode || "").toLowerCase(),
+    mentionsMuteMode: String(t?.mentions_mute_mode || "").toLowerCase(),
+    isPinProtected: !!t?.is_pin_protected,
+    relatedPageThread: t?.related_page_thread || null,
+    name: t?.name || null,
+    snippet: snippetText,
+    snippetSender: snippetID,
+    snippetAttachments: [],
+    serverTimestamp: t?.updated_time_precise || null,
+    imageSrc: t?.image?.uri || null,
+    isCanonicalUser: !!t?.is_canonical_neo_user,
+    isCanonical: t?.thread_type !== "GROUP",
+    recipientsLoadable: true,
+    hasEmailParticipant: false,
+    readOnly: false,
+    canReply: t?.cannot_reply_reason == null,
+    lastMessageTimestamp: t?.last_message ? t.last_message.timestamp_precise : null,
+    lastMessageType: "message",
+    lastReadTimestamp,
+    threadType: t?.thread_type === "GROUP" ? 2 : 1,
+    inviteLink: {
+      enable: t?.joinable_mode ? t.joinable_mode.mode == 1 : false,
+      link: t?.joinable_mode ? t.joinable_mode.link : null,
+    },
+  };
+}
+
+const queue = [];
+let isProcessingQueue = false;
+const processingThreads = new Set();
+const queuedThreads = new Set();
+const cooldown = new Map();
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const getMultiInfo = async function (threadIDs) {
+    const buildQueries = () => {
+      const form = {};
+      threadIDs.forEach((x, y) => {
+        form["o" + y] = {
+          doc_id: "3449967031715030",
+          query_params: {
+            id: x,
+            message_limit: 0,
+            load_messages: false,
+            load_read_receipts: false,
+            before: null,
+          },
+        };
+      });
+      return {
+        queries: JSON.stringify(form),
+        batch_name: "MessengerGraphQLThreadFetcher",
+      };
+    };
+    const maxAttempts = 3;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const Submit = buildQueries();
+        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, Submit).then(parseAndCheckLogin(ctx, defaultFuncs));
+        if (!Array.isArray(resData) || resData.length === 0) throw new Error("EmptyGraphBatch");
+        const tail = resData[resData.length - 1];
+        if (tail?.error_results && tail.error_results !== 0) throw new Error("GraphErrorResults");
+        const body = resData.slice(0, -1).sort((a, b) => Object.keys(a)[0].localeCompare(Object.keys(b)[0]));
+        const out = [];
+        body.forEach((x, y) => out.push(formatThreadGraphQLResponse(x["o" + y]?.data)));
+        const valid = out.some(d => !!d && !!d.threadID);
+        if (!valid) throw new Error("GraphNoData");
+        return { Success: true, Data: out };
+      } catch (e) {
+        lastErr = e;
+        if (attempt < maxAttempts) await new Promise(r => setTimeout(r, 300 * attempt));
+      }
+    }
+    return { Success: false, Data: null, Error: lastErr ? String(lastErr.message || lastErr) : "Unknown" };
+  };
+
+  const dbFiles = fs.readdirSync(path.join(__dirname, "../../database")).filter(f => path.extname(f) === ".js").reduce((acc, file) => {
+    acc[path.basename(file, ".js")] = require(path.join(__dirname, "../../database", file))(api);
+    return acc;
+  }, {});
+  const { threadData, userData } = dbFiles;
+  const { create, get, update, getAll } = threadData;
+  const { update: updateUser } = userData;
+
+  function isValidThread(d) {
+    return d && d.threadID;
+  }
+
+  async function upsertUsersFromThreadInfo(info) {
+    try {
+      if (!info || !Array.isArray(info.userInfo) || info.userInfo.length === 0) return;
+      const tasks = info.userInfo.filter(u => u && u.id).map(u => {
+        const data = {
+          id: u.id,
+          name: u.name || null,
+          firstName: u.firstName || null,
+          vanity: u.vanity || null,
+          url: u.url || null,
+          thumbSrc: u.thumbSrc || null,
+          profileUrl: u.profileUrl || null,
+          gender: u.gender || null,
+          type: u.type || null,
+          isFriend: !!u.isFriend,
+          isBirthday: !!u.isBirthday,
+        };
+        return updateUser(u.id, { data });
+      });
+      await Promise.allSettled(tasks);
+    } catch (e) {
+      console.warn(`[FCA-WARN] upsertUsers error: ${e?.message || e}`);
+    }
+  }
+
+  async function fetchThreadInfo(tID, isNew) {
+    try {
+      const response = await getMultiInfo([tID]);
+      if (!response.Success || !response.Data || !isValidThread(response.Data[0])) {
+        cooldown.set(tID, Date.now() + 5 * 60 * 1000);
+        console.warn(`[FCA-WARN] GraphQL empty for ${tID}, cooldown applied`);
+        return;
+      }
+      const threadInfo = response.Data[0];
+      await upsertUsersFromThreadInfo(threadInfo);
+      if (isNew) {
+        await create(tID, { data: threadInfo });
+        console.info(`[FCA-INFO] Success create data thread: ${tID}`);
+      } else {
+        await update(tID, { data: threadInfo });
+        console.info(`[FCA-INFO] Success update data thread: ${tID}`);
+      }
+    } catch (err) {
+      cooldown.set(tID, Date.now() + 5 * 60 * 1000);
+      console.error(`[FCA-ERROR] fetchThreadInfo error ${tID}: ${err?.message || err}`);
+    } finally {
+      queuedThreads.delete(tID);
+    }
+  }
+
+  async function checkAndUpdateThreads() {
+    try {
+      const allThreads = await getAll("threadID");
+      const existingThreadIDs = new Set(allThreads.map(t => t.threadID));
+      const now = Date.now();
+      for (const t of existingThreadIDs) {
+        const cd = cooldown.get(t);
+        if (cd && now < cd) continue;
+        const result = await get(t);
+        if (!result) continue;
+        const lastUpdated = new Date(result.updatedAt).getTime();
+        if ((now - lastUpdated) / (1000 * 60) > 10 && !queuedThreads.has(t)) {
+          queuedThreads.add(t);
+          console.info(`[FCA-INFO] ThreadID ${t} queued for refresh`);
+          queue.push(() => fetchThreadInfo(t, false));
+        }
+      }
+    } catch (err) {
+      console.error(`[FCA-ERROR] checkAndUpdateThreads error: ${err?.message || err}`);
+    }
+  }
+
+  async function processQueue() {
+    if (isProcessingQueue) return;
+    isProcessingQueue = true;
+    while (queue.length > 0) {
+      const task = queue.shift();
+      try {
+        await task();
+      } catch (err) {
+        console.error(`[FCA-ERROR] Queue processing error: ${err?.message || err}`);
+      }
+    }
+    isProcessingQueue = false;
+  }
+
+  setInterval(() => {
+    checkAndUpdateThreads();
+    processQueue();
+  }, 10000);
+
+  return async function getThreadInfoGraphQL(threadID, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (getType(callback) != "Function" && getType(callback) != "AsyncFunction") {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    if (getType(threadID) !== "Array") threadID = [threadID];
+    try {
+      const cached = await get(threadID[0]);
+      if (cached?.data && isValidThread(cached.data)) {
+        await upsertUsersFromThreadInfo(cached.data);
+        callback(null, cached.data);
+        return returnPromise;
+      }
+      if (!processingThreads.has(threadID[0])) {
+        processingThreads.add(threadID[0]);
+        console.info(`[FCA-INFO] Created new thread data: ${threadID[0]}`);
+        const response = await getMultiInfo(threadID);
+        if (response.Success && response.Data && isValidThread(response.Data[0])) {
+          const data = response.Data[0];
+          await upsertUsersFromThreadInfo(data);
+          await create(threadID[0], { data });
+          callback(null, data);
+        } else {
+          const stub = {
+            threadID: threadID[0],
+            threadName: null,
+            participantIDs: [],
+            userInfo: [],
+            unreadCount: 0,
+            messageCount: 0,
+            timestamp: null,
+            muteUntil: null,
+            isGroup: false,
+            isSubscribed: false,
+            isArchived: false,
+            folder: null,
+            cannotReplyReason: null,
+            eventReminders: [],
+            emoji: null,
+            color: null,
+            threadTheme: null,
+            nicknames: {},
+            adminIDs: [],
+            approvalMode: false,
+            approvalQueue: [],
+            reactionsMuteMode: "",
+            mentionsMuteMode: "",
+            isPinProtected: false,
+            relatedPageThread: null,
+            name: null,
+            snippet: null,
+            snippetSender: null,
+            snippetAttachments: [],
+            serverTimestamp: null,
+            imageSrc: null,
+            isCanonicalUser: false,
+            isCanonical: true,
+            recipientsLoadable: false,
+            hasEmailParticipant: false,
+            readOnly: false,
+            canReply: false,
+            lastMessageTimestamp: null,
+            lastMessageType: "message",
+            lastReadTimestamp: null,
+            threadType: 1,
+            inviteLink: { enable: false, link: null },
+            __status: "unavailable",
+          };
+          cooldown.set(threadID[0], Date.now() + 5 * 60 * 1000);
+          callback(null, stub);
+        }
+        processingThreads.delete(threadID[0]);
+      }
+    } catch (err) {
+      callback(err);
+    }
+    return returnPromise;
+  };
+};

package/src/api/threads/getThreadList.js

@@ -0,0 +1,248 @@
+"use strict";
+
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { formatID, getType } = require("../../utils/format");
+function createProfileUrl(url, username, id) {
+  if (url) return url;
+  return (
+    "https://www.facebook.com/" + (username || formatID(id.toString()))
+  );
+}
+
+function formatParticipants(participants) {
+  return participants.edges.map(p => {
+    p = p.node.messaging_actor;
+    switch (p["__typename"]) {
+      case "User":
+        return {
+          accountType: p["__typename"],
+          userID: formatID(p.id.toString()), // do we need .toString()? when it is not a string?
+          name: p.name,
+          shortName: p.short_name,
+          gender: p.gender,
+          url: p.url, // how about making it profileURL
+          profilePicture: p.big_image_src.uri,
+          username: p.username || null,
+          // TODO: maybe better names for these?
+          isViewerFriend: p.is_viewer_friend, // true/false
+          isMessengerUser: p.is_messenger_user, // true/false
+          isVerified: p.is_verified, // true/false
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+          isViewerCoworker: p.is_viewer_coworker, // true/false
+          isEmployee: p.is_employee // null? when it is something other? can someone check?
+        };
+      case "Page":
+        return {
+          accountType: p["__typename"],
+          userID: formatID(p.id.toString()), // or maybe... pageID?
+          name: p.name,
+          url: p.url,
+          profilePicture: p.big_image_src.uri,
+          username: p.username || null,
+          // uhm... better names maybe?
+          acceptsMessengerUserFeedback: p.accepts_messenger_user_feedback, // true/false
+          isMessengerUser: p.is_messenger_user, // true/false
+          isVerified: p.is_verified, // true/false
+          isMessengerPlatformBot: p.is_messenger_platform_bot, // true/false
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer // true/false
+        };
+      case "ReducedMessagingActor":
+      case "UnavailableMessagingActor":
+        return {
+          accountType: p["__typename"],
+          userID: formatID(p.id.toString()),
+          name: p.name,
+          url: createProfileUrl(p.url, p.username, p.id), // in this case p.url is null all the time
+          profilePicture: p.big_image_src.uri, // in this case it is default facebook photo, we could determine gender using it
+          username: p.username || null, // maybe we could use it to generate profile URL?
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer // true/false
+        };
+      default:
+        log.warn(
+          "getThreadList",
+          "Found participant with unsupported typename. Please open an issue at https://github.com/Schmavery/facebook-chat-api/issues\n" +
+            JSON.stringify(p, null, 2)
+        );
+        return {
+          accountType: p["__typename"],
+          userID: formatID(p.id.toString()),
+          name: p.name || `[unknown ${p["__typename"]}]` // probably it will always be something... but fallback to [unknown], just in case
+        };
+    }
+  });
+}
+
+// "FF8C0077" -> "8C0077"
+function formatColor(color) {
+  if (color && color.match(/^(?:[0-9a-fA-F]{8})$/g)) return color.slice(2);
+  return color;
+}
+
+function getThreadName(t) {
+  if (t.name || t.thread_key.thread_fbid) return t.name;
+
+  for (let po of t.all_participants.edges) {
+    let p = po.node;
+    if (p.messaging_actor.id === t.thread_key.other_user_id)
+      return p.messaging_actor.name;
+  }
+}
+
+function mapNicknames(customizationInfo) {
+  return customizationInfo && customizationInfo.participant_customizations
+    ? customizationInfo.participant_customizations.map(u => {
+        return {
+          userID: u.participant_id,
+          nickname: u.nickname
+        };
+      })
+    : [];
+}
+
+function formatThreadList(data) {
+  return data.map(t => {
+    let lastMessageNode =
+      t.last_message && t.last_message.nodes && t.last_message.nodes.length > 0
+        ? t.last_message.nodes[0]
+        : null;
+    return {
+      threadID: t.thread_key
+        ? formatID(t.thread_key.thread_fbid || t.thread_key.other_user_id)
+        : null, // shall never be null
+      name: getThreadName(t),
+      unreadCount: t.unread_count,
+      messageCount: t.messages_count,
+      imageSrc: t.image ? t.image.uri : null,
+      emoji: t.customization_info ? t.customization_info.emoji : null,
+      color: formatColor(
+        t.customization_info ? t.customization_info.outgoing_bubble_color : null
+      ),
+      threadTheme: t.thread_theme,
+      nicknames: mapNicknames(t.customization_info),
+      muteUntil: t.mute_until,
+      participants: formatParticipants(t.all_participants),
+      adminIDs: t.thread_admins.map(a => a.id),
+      folder: t.folder,
+      isGroup: t.thread_type === "GROUP",
+      customizationEnabled: t.customization_enabled, // false for ONE_TO_ONE with Page or ReducedMessagingActor
+      participantAddMode: t.participant_add_mode_as_string, // "ADD" if "GROUP" and null if "ONE_TO_ONE"
+      montageThread: t.montage_thread
+        ? Buffer.from(t.montage_thread.id, "base64").toString()
+        : null, // base64 encoded string "message_thread:0000000000000000"
+      reactionsMuteMode: t.reactions_mute_mode,
+      mentionsMuteMode: t.mentions_mute_mode,
+      isArchived: t.has_viewer_archived,
+      isSubscribed: t.is_viewer_subscribed,
+      timestamp: t.updated_time_precise, // in miliseconds
+      snippet: lastMessageNode ? lastMessageNode.snippet : null,
+      snippetAttachments: lastMessageNode
+        ? lastMessageNode.extensible_attachment
+        : null, // TODO: not sure if it works
+      snippetSender: lastMessageNode
+        ? formatID(
+            (lastMessageNode.message_sender.messaging_actor.id || "").toString()
+          )
+        : null,
+      lastMessageTimestamp: lastMessageNode
+        ? lastMessageNode.timestamp_precise
+        : null, // timestamp in miliseconds
+      lastReadTimestamp:
+        t.last_read_receipt && t.last_read_receipt.nodes.length > 0
+          ? t.last_read_receipt.nodes[0]
+            ? t.last_read_receipt.nodes[0].timestamp_precise
+            : null
+          : null,
+      cannotReplyReason: t.cannot_reply_reason,
+      approvalMode: Boolean(t.approval_mode),
+      participantIDs: formatParticipants(t.all_participants).map(
+        participant => participant.userID
+      ),
+      threadType: t.thread_type === "GROUP" ? 2 : 1, // "GROUP" or "ONE_TO_ONE"
+      inviteLink: {
+        enable: t.joinable_mode ? t.joinable_mode.mode == 1 : false,
+        link: t.joinable_mode ? t.joinable_mode.link : null
+      }
+    };
+  });
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getThreadList(limit, timestamp, tags, callback) {
+    if (
+      !callback &&
+      (getType(tags) === "Function" ||
+        getType(tags) === "AsyncFunction")
+    ) {
+      callback = tags;
+      tags = [""];
+    }
+    if (
+      getType(limit) !== "Number" ||
+      !Number.isInteger(limit) ||
+      limit <= 0
+    )
+      throw { error: "getThreadList: limit must be a positive integer" };
+    if (
+      getType(timestamp) !== "Null" &&
+      (getType(timestamp) !== "Number" || !Number.isInteger(timestamp))
+    )
+      throw { error: "getThreadList: timestamp must be an integer or null" };
+    if (getType(tags) === "String") tags = [tags];
+    if (getType(tags) !== "Array")
+      throw { error: "getThreadList: tags must be an array" };
+    var resolveFunc = function() {};
+    var rejectFunc = function() {};
+    var returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (
+      getType(callback) !== "Function" &&
+      getType(callback) !== "AsyncFunction"
+    ) {
+      callback = function(err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    const form = {
+      av: 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"
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData[resData.length - 1].error_results > 0)
+          throw resData[0].o0.errors;
+        if (resData[resData.length - 1].successful_results === 0)
+          throw {
+            error: "getThreadList: there was no successful_results",
+            res: resData
+          };
+        if (timestamp) resData[0].o0.data.viewer.message_threads.nodes.shift();
+        callback(
+          null,
+          formatThreadList(resData[0].o0.data.viewer.message_threads.nodes)
+        );
+      })
+      .catch(err => {
+        log.error("getThreadList", err);
+        return callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/api/threads/getThreadPictures.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getThreadPictures(threadID, offset, limit, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    let form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+        ctx.jar,
+        form
+      )
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+        return Promise.all(
+          resData.payload.imagesData.map(function(image) {
+            form = {
+              thread_id: threadID,
+              image_id: image.fbid
+            };
+            return defaultFuncs
+              .post(
+                "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+                ctx.jar,
+                form
+              )
+              .then(parseAndCheckLogin(ctx, defaultFuncs))
+              .then(function(resData) {
+                if (resData.error) {
+                  throw resData;
+                }
+                // the response is pretty messy
+                const queryThreadID =
+                  resData.jsmods.require[0][3][1].query_metadata.query_path[0]
+                    .message_thread;
+                const imageData =
+                  resData.jsmods.require[0][3][1].query_results[queryThreadID]
+                    .message_images.edges[0].node.image2;
+                return imageData;
+              });
+          })
+        );
+      })
+      .then(function(resData) {
+        callback(null, resData);
+      })
+      .catch(function(err) {
+        log.error("Error in getThreadPictures", err);
+        callback(err);
+      });
+    return returnPromise;
+  };
+};