chatbot-fca 0.0.2

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,232 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+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,
+		// @TODO verify this
+		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()
+			};
+		})
+	};
+}
+
+function formatThreadGraphQLResponse(data) {
+	if (data.errors)
+		return data.errors;
+	const messageThread = data.message_thread;
+	if (!messageThread)
+		return null;
+	const threadID = messageThread.thread_key.thread_fbid
+		? messageThread.thread_key.thread_fbid
+		: messageThread.thread_key.other_user_id;
+
+	// Remove me
+	const lastM = messageThread.last_message;
+	const 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;
+	const snippetText =
+		lastM && lastM.nodes && lastM.nodes[0] ? lastM.nodes[0].snippet : null;
+	const lastR = messageThread.last_read_receipt;
+	const lastReadTimestamp =
+		lastR && lastR.nodes && lastR.nodes[0] && lastR.nodes[0].timestamp_precise
+			? 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 //not sure?
+		})),
+		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 // @Undocumented
+		})),
+
+		// @Undocumented
+		reactionsMuteMode: messageThread.reactions_mute_mode.toLowerCase(),
+		mentionsMuteMode: messageThread.mentions_mute_mode.toLowerCase(),
+		isPinProtected: messageThread.is_pin_protected,
+		relatedPageThread: messageThread.related_page_thread,
+
+		// @Legacy
+		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,
+
+		// update in Wed, 13 Jul 2022 19:41:12 +0700
+		inviteLink: {
+			enable: messageThread.joinable_mode ? messageThread.joinable_mode.mode == 1 : false,
+			link: messageThread.joinable_mode ? messageThread.joinable_mode.link : null
+		}
+	};
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return function getThreadInfoGraphQL(threadID, callback) {
+		let resolveFunc = function () { };
+		let rejectFunc = function () { };
+		const returnPromise = new Promise(function (resolve, reject) {
+			resolveFunc = resolve;
+			rejectFunc = reject;
+		});
+
+		if (utils.getType(callback) != "Function" && utils.getType(callback) != "AsyncFunction") {
+			callback = function (err, data) {
+				if (err) {
+					return rejectFunc(err);
+				}
+				resolveFunc(data);
+			};
+		}
+
+		if (utils.getType(threadID) !== "Array") {
+			threadID = [threadID];
+		}
+
+		let form = {};
+		// `queries` has to be a string. I couldn't tell from the dev console. This
+		// took me a really long time to figure out. I deserve a cookie for this.
+		threadID.map(function (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"
+		};
+
+		defaultFuncs
+			.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+			.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+			.then(function (resData) {
+
+				if (resData.error) {
+					throw resData;
+				}
+				// This returns us an array of things. The last one is the success /
+				// failure one.
+				// @TODO What do we do in this case?
+				// if (resData[resData.length - 1].error_results !== 0) {
+				// 	throw resData[0].o0.errors[0];
+				// }
+				// if (!resData[0].o0.data.message_thread) {
+				// 	throw new Error("can't find this thread");
+				// }
+				const threadInfos = {};
+				for (let i = resData.length - 2; i >= 0; i--) {
+					const threadInfo = formatThreadGraphQLResponse(resData[i][Object.keys(resData[i])[0]].data);
+					threadInfos[threadInfo?.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
+				}
+				if (Object.values(threadInfos).length == 1) {
+					callback(null, Object.values(threadInfos)[0]);
+				}
+				else {
+					callback(null, threadInfos);
+				}
+			})
+			.catch(function (err) {
+				log.error("getThreadInfoGraphQL", err);
+				return callback(err);
+			});
+
+		return returnPromise;
+	};
+};

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,213 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+function createProfileUrl(url, username, id) {
+  if (url) return url;
+  return "https://www.facebook.com/" + (username || utils.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: utils.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: utils.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: utils.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: utils.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 ? utils.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),
+      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",
+      // rtc_call_data: t.rtc_call_data, // TODO: format and document this
+      // isPinProtected: t.is_pin_protected, // feature from future? always false (2018-04-04)
+      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"
+      // it is not userID nor any other ID known to me...
+      // can somebody inspect it? where is it used?
+      // probably Messenger Day uses it
+      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
+      // isCanonicalUser: t.is_canonical_neo_user, // is it always false?
+      // TODO: how about putting snippet in another object? current implementation does not handle every possibile message type etc.
+      snippet: lastMessageNode ? lastMessageNode.snippet : null,
+      snippetAttachments: lastMessageNode ? lastMessageNode.extensible_attachment : null, // TODO: not sure if it works
+      snippetSender: lastMessageNode ? utils.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, // timestamp in miliseconds
+      cannotReplyReason: t.cannot_reply_reason, // TODO: inspect possible values
+      approvalMode: Boolean(t.approval_mode),
+
+      // @Legacy
+      participantIDs: formatParticipants(t.all_participants).map(participant => participant.userID),
+      threadType: t.thread_type === "GROUP" ? 2 : 1 // "GROUP" or "ONE_TO_ONE"
+    };
+  });
+}
+
+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 = [""];
+    }
+    if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) throw { error: "getThreadList: limit must be a positive integer" };
+
+    if (utils.getType(timestamp) !== "Null" && (utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))) throw { error: "getThreadList: timestamp must be an integer or null" };
+
+    if (utils.getType(tags) === "String") tags = [tags];
+    if (utils.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 (utils.getType(callback) !== "Function" && utils.getType(callback) !== "AsyncFunction") {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const form = {
+      "av": ctx.globalOptions.pageID,
+      "queries": JSON.stringify({
+        "o0": {
+          // This doc_id was valid on 2020-07-20
+          "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(utils.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 };
+
+        // When we ask for threads using timestamp from the previous request,
+        // we are getting the last thread repeated as the first thread in this response.
+        // .shift() gets rid of it
+        // It is also the reason for increasing limit by 1 when timestamp is set
+        // this way user asks for 10 threads, we are asking for 11,
+        // but after removing the duplicated one, it is again 10
+        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/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;
+  };
+};