shadowx-fca 8.0.0

package/src/getPinnedMessages.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getPinnedMessages(threadID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+
+        api.getThreadInfo(threadID)
+            .then(function (threadInfo) {
+                var pinnedIDs = threadInfo.pinnedMessageIDs || [];
+
+                if (pinnedIDs.length === 0) {
+                    return cb(null, []);
+                }
+
+                var fetches = pinnedIDs.map(function (msgID) {
+                    return api.getMessage(threadID, msgID).catch(function () {
+                        return { messageID: msgID, body: null, senderID: null };
+                    });
+                });
+
+                return Promise.all(fetches).then(function (messages) {
+                    cb(null, messages);
+                });
+            })
+            .catch(function (err) {
+                cb(err);
+            });
+
+        return promise;
+    };
+};

package/src/getPostInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getPostInfo(postID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "CometFeedStoryQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "5025565174182042",
+            variables: JSON.stringify({ storyID: String(postID), feedLocation: "PERMALINK", privacySelectorRenderLocation: "COMET_STREAM" })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData && resData.data && resData.data.node); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getProfileInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getProfileInfo(userID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "ProfileCometHeaderQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "4288341514541020",
+            variables: JSON.stringify({ userID: String(userID), scale: 3 })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData && resData.data && resData.data.user); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getPublicData.js

@@ -0,0 +1,25 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getPublicData(userIDOrUrl, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var isUrl = typeof userIDOrUrl === "string" && userIDOrUrl.includes("facebook.com");
+        var url = isUrl ? userIDOrUrl : ("https://www.facebook.com/profile.php?id=" + userIDOrUrl);
+        defaultFuncs.get(url, ctx.jar, {})
+            .then(res => {
+                var body = res.body || "";
+                var nameMatch = body.match(/"name":"([^"]+)"/);
+                var idMatch = body.match(/"userID":"(\d+)"/);
+                var vanityMatch = body.match(/"vanity":"([^"]+)"/);
+                var thumbMatch = body.match(/"uri":"(https:\/\/[^"]+profile[^"]+)"/);
+                cb(null, {
+                    name: nameMatch && nameMatch[1],
+                    userID: idMatch && idMatch[1],
+                    vanity: vanityMatch && vanityMatch[1],
+                    thumbSrc: thumbMatch && thumbMatch[1]
+                });
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getRegion.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getRegion() {
+    return ctx?.region;
+  };
+};

package/src/getRepInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getRepInfo(callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "MessengerRepInfoQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "6193148430750882",
+            variables: JSON.stringify({ userID: ctx.userID })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData && resData.data); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getStickerPacks.js

@@ -0,0 +1,25 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getStickerPacks(callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "ComposerStickerPackQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "4022506321100228",
+            variables: JSON.stringify({ scale: 3 })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var packs = (resData.data && resData.data.viewer && resData.data.viewer.sticker_packs && resData.data.viewer.sticker_packs.nodes) || [];
+                cb(null, packs.map(p => ({
+                    id: p.id,
+                    name: p.name,
+                    coverSticker: p.cover_sticker && p.cover_sticker.image && p.cover_sticker.image.uri
+                })));
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getStickers.js

@@ -0,0 +1,39 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getStickers(query, stickerPackID, callback) {
+        if (typeof stickerPackID === "function") { callback = stickerPackID; stickerPackID = null; }
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var form = {
+            fb_api_req_friendly_name: "ComposerStickersSearchRoot",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "5566756003355488",
+            variables: JSON.stringify({
+                query: query || "",
+                stickerPackID: stickerPackID || null,
+                scale: 3
+            })
+        };
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var packs = (resData.data && resData.data.sticker_search && resData.data.sticker_search.groups) || [];
+                var stickers = [];
+                packs.forEach(pack => {
+                    (pack.stickers && pack.stickers.nodes || []).forEach(s => {
+                        stickers.push({
+                            id: s.id,
+                            label: s.label,
+                            stickerPackID: s.pack && s.pack.id,
+                            spriteImage: s.sprite_image && s.sprite_image.uri,
+                            image: s.image && s.image.uri
+                        });
+                    });
+                });
+                cb(null, stickers);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getStoryReactions.js

@@ -0,0 +1,18 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getStoryReactions(feedbackID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var encodedID = Buffer.from("feedback:" + feedbackID).toString("base64");
+        defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, {
+            fb_api_req_friendly_name: "CometUFIReactionCountWithoutSummaryQuery",
+            fb_api_caller_class: "RelayModern",
+            doc_id: "6148258561870311",
+            variables: JSON.stringify({ feedbackID: encodedID })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, resData && resData.data && resData.data.feedback); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getThreadHistory.js

@@ -0,0 +1,45 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getThreadHistory(threadID, amount, timestamp, callback) {
+        if (typeof timestamp === "function") { callback = timestamp; timestamp = undefined; }
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "1498317363570230",
+                    query_params: {
+                        id: String(threadID),
+                        message_limit: amount || 20,
+                        load_messages: 1,
+                        load_read_receipts: false,
+                        before: timestamp || null
+                    }
+                }
+            })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (!Array.isArray(resData)) throw { error: "Not logged in" };
+                if (resData[resData.length - 1].error_results !== 0) throw new Error("getThreadHistory: error_results returned.");
+                var thread = resData[0].o0 && resData[0].o0.data && resData[0].o0.data.message_thread;
+                var messages = (thread && thread.messages && thread.messages.nodes) || [];
+                cb(null, messages.map(m => ({
+                    type: "message",
+                    messageID: m.message_id,
+                    senderID: m.message_sender && m.message_sender.id,
+                    body: m.message && m.message.text || "",
+                    timestamp: m.timestamp_precise,
+                    threadID: String(threadID),
+                    isUnsent: !!m.is_unsent,
+                    attachments: (m.message && m.message.blob_attachments || []).map(a => {
+                        try { return utils._formatAttachment({ blob_attachment: a }); }
+                        catch (_) { return { type: "unknown" }; }
+                    })
+                })));
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getThreadHistoryDeprecated.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadHistory(threadID, amount, timestamp, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, threadInfo) {
+        if (err) return rejectFunc(err);
+        resolveFunc(threadInfo);
+      };
+    }
+
+    if (!callback) throw { error: "getThreadHistory: need callback" };
+    var form = {
+      client: "mercury"
+    };
+
+    api.getUserInfo(threadID, function (err, res) {
+      if (err) return callback(err);
+      var key = Object.keys(res).length > 0 ? "user_ids" : "thread_fbids";
+      form["messages[" + key + "][" + threadID + "][offset]"] = 0;
+      form["messages[" + key + "][" + threadID + "][timestamp]"] = timestamp;
+      form["messages[" + key + "][" + threadID + "][limit]"] = amount;
+
+      if (ctx.globalOptions.pageID) form.request_user_id = ctx.globalOptions.pageID;
+
+      defaultFuncs
+        .post("https://www.facebook.com/ajax/mercury/thread_info.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) throw resData;
+          else if (!resData.payload) throw { error: "Could not retrieve thread history." };
+
+          // Asking for message history from a thread with no message history
+          // will return undefined for actions here
+          if (!resData.payload.actions) resData.payload.actions = [];
+
+          var userIDs = {};
+          resData.payload.actions.forEach(v => userIDs[v.author.split(":").pop()] = "");
+
+          api.getUserInfo(Object.keys(userIDs), function (err, data) {
+            if (err) return callback(err); //callback({error: "Could not retrieve user information in getThreadHistory."});
+
+            resData.payload.actions.forEach(function (v) {
+              var sender = data[v.author.split(":").pop()];
+              if (sender) v.sender_name = sender.name;
+              else v.sender_name = "Facebook User";
+              v.sender_fbid = v.author;
+              delete v.author;
+            });
+
+            callback(null, resData.payload.actions.map(utils.formatHistoryMessage));
+          });
+        })
+        .catch(function (err) {
+          log.error("getThreadHistory", err);
+          return callback(err);
+        });
+    });
+    return returnPromise;
+  };
+};

package/src/getThreadInfo.js

@@ -0,0 +1,73 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    function formatThread(data) {
+        if (data.errors) return data.errors;
+        var mt = data.message_thread;
+        if (!mt) return null;
+        var threadID = mt.thread_key.thread_fbid || mt.thread_key.other_user_id;
+        var lastM = mt.last_message;
+        var snippetID = lastM && lastM.nodes && lastM.nodes[0] && lastM.nodes[0].message_sender && lastM.nodes[0].message_sender.messaging_actor ? lastM.nodes[0].message_sender.messaging_actor.id : null;
+        var snippetText = lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+        var lastR = mt.last_read_receipt;
+        var lastReadTimestamp = lastR && lastR.nodes && lastR.nodes[0] ? lastR.nodes[0].timestamp_precise : null;
+        return {
+            threadID: String(threadID),
+            threadName: mt.name,
+            participantIDs: mt.all_participants.edges.map(d => d.node.messaging_actor.id),
+            userInfo: mt.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 && 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: mt.unread_count,
+            messageCount: mt.messages_count,
+            timestamp: mt.updated_time_precise,
+            muteUntil: mt.mute_until,
+            isGroup: !!mt.thread_key.thread_fbid,
+            isSubscribed: mt.is_viewer_subscribed,
+            isArchived: mt.has_viewer_archived,
+            folder: mt.folder,
+            canReply: mt.can_viewer_reply,
+            lastReadTimestamp,
+            snippet: snippetText,
+            snippetSenderID: snippetID,
+            adminIDs: (mt.thread_admins || []).map(a => a.id),
+            approvalMode: mt.approval_mode,
+            approvalQueue: (mt.approval_requests && mt.approval_requests.edges.map(e => e.node.requester.id)) || [],
+            image: mt.image && mt.image.uri,
+            emoji: mt.customization_info && mt.customization_info.emoji,
+            color: mt.customization_info && mt.customization_info.outgoing_bubble_color,
+            nicknames: mt.customization_info && mt.customization_info.participant_customizations
+                ? mt.customization_info.participant_customizations.reduce((acc, p) => { acc[p.participant_id] = p.nickname; return acc; }, {})
+                : {}
+        };
+    }
+
+    return function getThreadInfo(threadID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "3449967031715030",
+                    query_params: { id: String(threadID), message_limit: 0, load_messages: 0, load_read_receipts: false, before: null }
+                }
+            })
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (!Array.isArray(resData) || resData[resData.length - 1].error_results > 0) throw resData[0] && resData[0].o0 && resData[0].o0.errors;
+                cb(null, formatThread(resData[0].o0.data));
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getThreadInfoDeprecated.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadInfo(threadID, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    var form = {
+      client: "mercury"
+    };
+
+    api.getUserInfo(threadID, function (err, userRes) {
+      if (err) return callback(err);
+      var key = Object.keys(userRes).length > 0 ? "user_ids" : "thread_fbids";
+      form["threads[" + key + "][0]"] = threadID;
+
+      if (ctx.globalOptions.pageId) form.request_user_id = ctx.globalOptions.pageId;
+
+      defaultFuncs
+        .post("https://www.facebook.com/ajax/mercury/thread_info.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) throw resData;
+          else if (!resData.payload) throw { error: "Could not retrieve thread Info." };
+
+          var threadData = resData.payload.threads[0];
+          var userData = userRes[threadID];
+
+          if (threadData == null) throw { error: "ThreadData is null" };
+
+          threadData.name = userData != null && userData.name != null ? userData.name : threadData.name;
+          threadData.image_src = userData != null && userData.thumbSrc != null ? userData.thumbSrc : threadData.image_src;
+          callback(null, utils.formatThread(threadData));
+        })
+        .catch(function (err) {
+          log.error("getThreadInfo", err);
+          return callback(err);
+        });
+    });
+    return returnPromise;
+  };
+};

package/src/getThreadList.js

@@ -0,0 +1,76 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getThreadList(limit, timestamp, tags, callback) {
+        if (!callback && (utils.getType(tags) === "Function" || utils.getType(tags) === "AsyncFunction")) {
+            callback = tags;
+            tags = ["INBOX"];
+        }
+        if (typeof timestamp === "function") { callback = timestamp; timestamp = null; tags = ["INBOX"]; }
+        if (!tags || !Array.isArray(tags)) tags = ["INBOX"];
+        if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) {
+            throw { error: "getThreadList: limit must be a positive integer" };
+        }
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, {
+            av: ctx.i_userID || ctx.userID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "3426149104143726",
+                    query_params: {
+                        limit: limit + (timestamp ? 1 : 0),
+                        before: timestamp,
+                        tags: tags,
+                        includeDeliveryReceipts: true,
+                        includeSeqID: false
+                    }
+                }
+            }),
+            batch_name: "MessengerGraphQLThreadlistFetcher"
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(function (resData) {
+                if (!Array.isArray(resData)) throw { error: "Not logged in" };
+                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 };
+                }
+                var nodes = resData[0].o0.data.viewer.message_threads.nodes || [];
+                if (timestamp) nodes.shift();
+                cb(null, nodes.map(function (t) {
+                    var lastM = t.last_message && t.last_message.nodes && t.last_message.nodes[0];
+                    var lastR = t.last_read_receipt && t.last_read_receipt.nodes && t.last_read_receipt.nodes[0];
+                    return {
+                        threadID: String(t.thread_key.thread_fbid || t.thread_key.other_user_id),
+                        threadName: t.name,
+                        unreadCount: t.unread_count,
+                        messageCount: t.messages_count,
+                        timestamp: t.updated_time_precise,
+                        muteUntil: t.mute_until,
+                        isGroup: t.thread_type === "GROUP",
+                        isArchived: t.has_viewer_archived,
+                        isSubscribed: t.is_viewer_subscribed,
+                        canReply: t.cannot_reply_reason == null,
+                        folder: t.folder,
+                        image: t.image && t.image.uri,
+                        emoji: t.customization_info ? t.customization_info.emoji : null,
+                        color: t.customization_info && t.customization_info.outgoing_bubble_color
+                            ? t.customization_info.outgoing_bubble_color.slice(2) : null,
+                        adminIDs: (t.thread_admins || []).map(function (a) { return a.id; }),
+                        approvalMode: Boolean(t.approval_mode),
+                        participantIDs: (t.all_participants && t.all_participants.edges || []).map(function (e) {
+                            return e.node.messaging_actor.id;
+                        }),
+                        snippet: lastM ? lastM.snippet : null,
+                        snippetSender: lastM && lastM.message_sender && lastM.message_sender.messaging_actor
+                            ? utils.formatID(String(lastM.message_sender.messaging_actor.id)) : null,
+                        lastMessageTimestamp: lastM ? lastM.timestamp_precise : null,
+                        lastReadTimestamp: lastR ? lastR.timestamp_precise : null,
+                        threadType: t.thread_type === "GROUP" ? 2 : 1
+                    };
+                }));
+            })
+            .catch(function (err) { cb(err); });
+        return promise;
+    };
+};

package/src/getThreadListDeprecated.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadList(start, end, type, callback) {
+    if (utils.getType(callback) === "Undefined") {
+      if (utils.getType(end) !== "Number") throw { error: "Please pass a number as a second argument." };
+      else if (utils.getType(type) === "Function" || utils.getType(type) === "AsyncFunction") {
+        callback = type;
+        type = "inbox"; //default to inbox
+      }
+      else if (utils.getType(type) !== "String") throw { error: "Please pass a String as a third argument. Your options are: inbox, pending, and archived" };
+      else throw { error: "getThreadList: need callback" };
+    }
+
+    if (type === "archived") type = "action:archived";
+    else if (type !== "inbox" && type !== "pending" && type !== "other") throw { error: "type can only be one of the following: inbox, pending, archived, other" };
+
+
+    if (end <= start) end = start + 20;
+
+    var form = {
+      client: "mercury"
+    };
+
+    form[type + "[offset]"] = start;
+    form[type + "[limit]"] = end - start;
+
+    if (ctx.globalOptions.pageID) form.request_user_id = ctx.globalOptions.pageID;
+
+    defaultFuncs
+      .post("https://www.facebook.com/ajax/mercury/threadlist_info.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error) throw resData;
+        log.verbose("getThreadList", JSON.stringify(resData.payload.threads));
+        return callback(null, (resData.payload.threads || []).map(utils.formatThread));
+      })
+      .catch(function (err) {
+        log.error("getThreadList", err);
+        return callback(err);
+      });
+  };
+};

package/src/getThreadPictures.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadPictures(threadID, offset, limit, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    var form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php", ctx.jar, form)
+      .then(utils.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(utils.parseAndCheckLogin(ctx, defaultFuncs))
+              .then(function (resData) {
+                if (resData.error) throw resData;
+                // the response is pretty messy
+                var queryThreadID = resData.jsmods.require[0][3][1].query_metadata.query_path[0].message_thread;
+                var imageData = resData.jsmods.require[0][3][1].query_results[queryThreadID].message_images.edges[0].node.image2;
+                return imageData;
+              });
+          })
+        );
+      })
+      .then(resData => callback(null, resData))
+      .catch(function (err) {
+        log.error("Error in getThreadPictures", err);
+        callback(err);
+      });
+    return returnPromise;
+  };
+};