fca-neokex-fix 1.0.1

package/src/apis/searchForThread.js

@@ -0,0 +1,154 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function searchForThread(searchQuery, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    // Store original callback if provided
+    const originalCallback = callback;
+    
+    // Always use a wrapped callback that settles the promise
+    callback = (err, result) => {
+      if (originalCallback) {
+        originalCallback(err, result);
+      }
+      if (err) return rejectFunc(err);
+      resolveFunc(result);
+    };
+
+    if (!searchQuery || typeof searchQuery !== 'string') {
+      const error = { error: "searchForThread: searchQuery parameter must be a non-empty string" };
+      utils.error("searchForThread", error);
+      callback(error);
+      return returnPromise;
+    }
+
+    try {
+      // Strategy 1: Use GraphQL-based getThreadList and filter locally
+      // This bypasses checkpoint issues entirely
+      utils.log("searchForThread", "Using GraphQL-based search (bypasses checkpoints)");
+      
+      try {
+        // Use getThreadList to fetch threads from INBOX
+        // This ensures consistent behavior and avoids tag parameter issues
+        const threads = await api.getThreadList(100, null, ["INBOX"]);
+        
+        if (!threads || threads.length === 0) {
+          utils.warn("searchForThread", "No threads available in INBOX, trying legacy method");
+          throw new Error("No threads available from GraphQL");
+        }
+
+        utils.log("searchForThread", `Retrieved ${threads.length} threads from GraphQL`);
+
+        // Filter threads by search query (case-insensitive, partial match)
+        const searchLower = searchQuery.toLowerCase().trim();
+        const matchedThreads = threads.filter(thread => {
+          // Search in thread name
+          if (thread.threadName && thread.threadName.toLowerCase().includes(searchLower)) {
+            return true;
+          }
+          
+          // Search in thread ID (exact or partial match)
+          if (thread.threadID && thread.threadID.toString().includes(searchQuery)) {
+            return true;
+          }
+          
+          // Search in participant names
+          if (thread.userInfo && Array.isArray(thread.userInfo)) {
+            return thread.userInfo.some(user => 
+              user.name && user.name.toLowerCase().includes(searchLower)
+            );
+          }
+          
+          return false;
+        });
+
+        if (matchedThreads.length === 0) {
+          callback({ 
+            error: `Could not find thread matching "${searchQuery}".`,
+            details: "No threads match your search query. Try a different search term."
+          });
+          return returnPromise;
+        }
+
+        utils.log("searchForThread", `Found ${matchedThreads.length} matching thread(s) using GraphQL method`);
+        callback(null, matchedThreads);
+        return returnPromise;
+        
+      } catch (graphqlError) {
+        utils.warn("searchForThread", "GraphQL method failed, falling back to legacy AJAX endpoint");
+        utils.error("searchForThread GraphQL error", graphqlError);
+        
+        // Strategy 2: Fallback to legacy AJAX endpoint (may trigger checkpoints)
+        const form = {
+          client: "web_messenger",
+          query: searchQuery,
+          offset: 0,
+          limit: 21,
+          index: "fbid"
+        };
+
+        const res = await defaultFuncs.post(
+          "https://www.facebook.com/ajax/mercury/search_threads.php",
+          ctx.jar,
+          form
+        ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (!res) {
+          const error = { 
+            error: "Account checkpoint required - searchForThread is restricted until verification",
+            details: "Please verify your account on facebook.com. This function requires additional permissions.",
+            errorCode: 1357004,
+            errorType: 'CHECKPOINT'
+          };
+          callback(error);
+          return returnPromise;
+        }
+
+        if (res.error) {
+          throw res;
+        }
+
+        // Support both legacy payload.threads (object map) and newer payload.mercury_payload.threads (array)
+        let threadsData = res.payload?.mercury_payload?.threads || res.payload?.threads;
+        
+        if (!threadsData) {
+          callback({ 
+            error: `Could not find thread "${searchQuery}".`,
+            details: "The thread may not exist or access may be restricted."
+          });
+          return returnPromise;
+        }
+
+        // Convert legacy object format to array if needed
+        if (!Array.isArray(threadsData)) {
+          threadsData = Object.values(threadsData);
+        }
+
+        const threads = threadsData.map(utils.formatThread);
+        utils.log("searchForThread", `Found ${threads.length} thread(s) using legacy AJAX method`);
+        callback(null, threads);
+      }
+    } catch (err) {
+      // Enhanced error handling for checkpoint errors
+      if (err.errorCode === 1357004 || err.errorType === 'CHECKPOINT') {
+        err.error = "Account checkpoint required - searchForThread is restricted until verification";
+        err.friendlyMessage = "Your account requires verification on facebook.com before using search features";
+      } else if (err.error && typeof err.error === 'string' && err.error.includes('checkpoint')) {
+        err.friendlyMessage = "Account checkpoint required - searchForThread is restricted until verification";
+      }
+      
+      utils.error("searchForThread", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/sendMessage.js

@@ -0,0 +1,281 @@
+"use strict";
+
+const utils = require('../utils');
+
+const allowedProperties = {
+  attachment: true,
+  url: true,
+  sticker: true,
+  emoji: true,
+  emojiSize: true,
+  body: true,
+  mentions: true,
+  location: true,
+};
+
+module.exports = (defaultFuncs, api, ctx) => {
+  function detectAttachmentType(attachment) {
+    const path = attachment.path || '';
+    const ext = path.toLowerCase().split('.').pop();
+    
+    const audioTypes = ['mp3', 'wav', 'aac', 'm4a', 'ogg', 'opus', 'flac'];
+    const videoTypes = ['mp4', 'mov', 'avi', 'mkv', 'webm', 'wmv', 'flv'];
+    const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg'];
+    
+    if (audioTypes.includes(ext)) {
+      return { voice_clip: "true" };
+    } else if (videoTypes.includes(ext)) {
+      return { video: "true" };
+    } else if (imageTypes.includes(ext)) {
+      return { image: "true" };
+    }
+    
+    return { file: "true" };
+  }
+
+  async function uploadSingleAttachment(attachment) {
+    if (!utils.isReadableStream(attachment)) {
+      throw new Error("Attachment should be a readable stream and not " + utils.getType(attachment) + ".");
+    }
+    
+    const uploadType = detectAttachmentType(attachment);
+    const oksir = await defaultFuncs.postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, {
+      upload_1024: attachment,
+      ...uploadType
+    }, {}).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    
+    if (oksir.error) {
+      throw new Error(JSON.stringify(oksir));
+    }
+    return oksir.payload.metadata[0];
+  }
+
+  async function uploadAttachment(attachments) {
+    const CONCURRENT_UPLOADS = 3;
+    
+    const uploadPromises = [];
+    const uploads = [];
+    
+    for (let i = 0; i < attachments.length; i += CONCURRENT_UPLOADS) {
+      const batch = attachments.slice(i, i + CONCURRENT_UPLOADS);
+      const batchPromises = batch.map(attachment => uploadSingleAttachment(attachment));
+      const batchResults = await Promise.all(batchPromises);
+      uploads.push(...batchResults);
+    }
+    
+    return uploads;
+  }
+
+  async function getUrl(url) {
+    const resData = await defaultFuncs.post("https://www.facebook.com/message_share_attachment/fromURI/", ctx.jar, {
+      image_height: 960,
+      image_width: 960,
+      uri: url
+    }).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData || resData.error || !resData.payload){
+        throw new Error("Invalid url");
+    }
+    return resData.payload.share_data.share_params;
+  }
+
+  async function sendContent(form, threadID, isSingleUser, messageAndOTID, callback) {
+    if (utils.getType(threadID) === "Array") {
+      for (var i = 0; i < threadID.length; i++) {
+        form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
+      }
+      form["specific_to_list[" + threadID.length + "]"] = "fbid:" + ctx.userID;
+      form["client_thread_id"] = "root:" + messageAndOTID;
+      utils.log("sendMessage", "Sending message to multiple users: " + threadID);
+    } else {
+      if (isSingleUser) {
+        form["specific_to_list[0]"] = "fbid:" + threadID;
+        form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+        form["other_user_fbid"] = threadID;
+      } else {
+        form["thread_fbid"] = threadID;
+      }
+    }
+
+    if (ctx.globalOptions.pageID) {
+      form["author"] = "fbid:" + ctx.globalOptions.pageID;
+      form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
+      form["creator_info[creatorID]"] = ctx.userID;
+      form["creator_info[creatorType]"] = "direct_admin";
+      form["creator_info[labelType]"] = "sent_message";
+      form["creator_info[pageID]"] = ctx.globalOptions.pageID;
+      form["request_user_id"] = ctx.globalOptions.pageID;
+      form["creator_info[profileURI]"] =
+        "https://www.facebook.com/profile.php?id=" + ctx.userID;
+    }
+
+    const resData = await defaultFuncs.post("https://www.facebook.com/messaging/send/", ctx.jar, form).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!resData) {
+      throw new Error("Send message failed.");
+    }
+    if (resData.error) {
+      if (resData.error === 1545012) {
+        utils.warn("sendMessage", "Got error 1545012. This might mean that you're not part of the conversation " + threadID);
+      }
+      throw new Error(JSON.stringify(resData));
+    }
+    const messageInfo = resData.payload.actions.reduce((p, v) => {
+        return { threadID: v.thread_fbid, messageID: v.message_id, timestamp: v.timestamp } || p;
+    }, null);
+    return messageInfo;
+  }
+
+  return async (msg, threadID, callback, replyToMessage, isGroup) => {
+    if (!callback && (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction")) {
+      throw new Error("Pass a threadID as a second argument.");
+    }
+    if (!replyToMessage && utils.getType(callback) === "String") {
+      replyToMessage = callback;
+      callback = undefined;
+    }
+
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    let returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    let msgType = utils.getType(msg);
+    let threadIDType = utils.getType(threadID);
+    let messageIDType = utils.getType(replyToMessage);
+    if (msgType !== "String" && msgType !== "Object") {
+      return callback(new Error("Message should be of type string or object and not " + msgType + "."));
+    }
+    if (threadIDType !== "Array" && threadIDType !== "Number" && threadIDType !== "String") {
+      return callback(new Error("ThreadID should be of type number, string, or array and not " + threadIDType + "."));
+    }
+    if (replyToMessage && messageIDType !== 'String') {
+      return callback(new Error("MessageID should be of type string and not " + threadIDType + "."));
+    }
+    if (msgType === "String") {
+      msg = { body: msg };
+    }
+    let disallowedProperties = Object.keys(msg).filter(prop => !allowedProperties[prop]);
+    if (disallowedProperties.length > 0) {
+      return callback(new Error("Dissallowed props: `" + disallowedProperties.join(", ") + "`"));
+    }
+
+    try {
+      let messageAndOTID = utils.generateOfflineThreadingID();
+      let form = {
+        client: "mercury",
+        action_type: "ma-type:user-generated-message",
+        author: "fbid:" + ctx.userID,
+        timestamp: Date.now(),
+        timestamp_absolute: "Today",
+        timestamp_relative: utils.generateTimestampRelative(),
+        timestamp_time_passed: "0",
+        is_unread: false,
+        is_cleared: false,
+        is_forward: false,
+        is_filtered_content: false,
+        is_filtered_content_bh: false,
+        is_filtered_content_account: false,
+        is_filtered_content_quasar: false,
+        is_filtered_content_invalid_app: false,
+        is_spoof_warning: false,
+        source: "source:chat:web",
+        "source_tags[0]": "source:chat",
+        ...(msg.body && {
+            body: msg.body
+        }),
+        html_body: false,
+        ui_push_phase: "V3",
+        status: "0",
+        offline_threading_id: messageAndOTID,
+        message_id: messageAndOTID,
+        threading_id: utils.generateThreadingID(ctx.clientID),
+        "ephemeral_ttl_mode:": "0",
+        manual_retry_cnt: "0",
+        has_attachment: !!(msg.attachment || msg.url || msg.sticker),
+        signatureID: utils.getSignatureID(),
+        ...(replyToMessage && {
+            replied_to_message_id: replyToMessage
+        })
+      };
+
+      if (msg.location) {
+        if (!msg.location.latitude || !msg.location.longitude) {
+          return callback(new Error("location property needs both latitude and longitude"));
+        }
+        form["location_attachment[coordinates][latitude]"] = msg.location.latitude;
+        form["location_attachment[coordinates][longitude]"] = msg.location.longitude;
+        form["location_attachment[is_current_location]"] = !!msg.location.current;
+      }
+      if (msg.sticker) {
+        form["sticker_id"] = msg.sticker;
+      }
+      if (msg.attachment) {
+        form.image_ids = [];
+        form.gif_ids = [];
+        form.file_ids = [];
+        form.video_ids = [];
+        form.audio_ids = [];
+        if (utils.getType(msg.attachment) !== "Array") {
+          msg.attachment = [msg.attachment];
+        }
+        const files = await uploadAttachment(msg.attachment);
+        files.forEach(file => {
+            const type = Object.keys(file)[0];
+            form["" + type + "s"].push(file[type]);
+        }); 
+      }
+      if (msg.url) {
+        form["shareable_attachment[share_type]"] = "100";
+        const params = await getUrl(msg.url);
+        form["shareable_attachment[share_params]"] = params;
+      }
+      if (msg.emoji) {
+        if (!msg.emojiSize) {
+          msg.emojiSize = "medium";
+        }
+        if (msg.emojiSize !== "small" && msg.emojiSize !== "medium" && msg.emojiSize !== "large") {
+          return callback(new Error("emojiSize property is invalid"));
+        }
+        if (form.body && form.body !== "") {
+          return callback(new Error("body is not empty"));
+        }
+        form.body = msg.emoji;
+        form["tags[0]"] = "hot_emoji_size:" + msg.emojiSize;
+      } 
+      if (msg.mentions) {
+        for (let i = 0; i < msg.mentions.length; i++) {
+          const mention = msg.mentions[i];
+          const tag = mention.tag;
+          if (typeof tag !== "string") {
+            return callback(new Error("Mention tags must be strings."));
+          }
+          const offset = msg.body.indexOf(tag, mention.fromIndex || 0);
+          if (offset < 0) utils.warn("handleMention", 'Mention for "' + tag + '" not found in message string.');
+          if (!mention.id) utils.warn("handleMention", "Mention id should be non-null.");
+          const id = mention.id || 0;
+          const emptyChar = '\u200E';
+          form["body"] = emptyChar + msg.body;
+          form["profile_xmd[" + i + "][offset]"] = offset + 1;
+          form["profile_xmd[" + i + "][length]"] = tag.length;
+          form["profile_xmd[" + i + "][id]"] = id;
+          form["profile_xmd[" + i + "][type]"] = "p";
+        }
+      }
+
+      const isSingleUser = (utils.getType(isGroup) !== "Boolean") ? (threadID.toString().length <= 15) : !isGroup;
+      const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
+      callback(null, result);
+    } catch (err) {
+      callback(err);
+    }
+    return returnPromise;
+  };
+};

package/src/apis/sendMessageMqtt.js

@@ -0,0 +1,188 @@
+"use strict";
+
+const utils = require('../utils');
+const delay = async ms => await new Promise(res => setTimeout(res, ms));
+
+module.exports = (defaultFuncs, api, ctx) => {
+  /**
+   * Uploads an attachment to Facebook's servers.
+   * @param {Array<Stream>} attachments An array of readable streams.
+   * @param {Function} callback The callback function.
+   */
+  function uploadAttachment(attachments, callback) {
+    callback = callback || function () {};
+    var uploads = [];
+    for (var i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw { error: "Attachment should be a readable stream and not " + utils.getType(attachments[i]) + "." };
+      }
+      var form = {
+        upload_1024: attachments[i],
+        voice_clip: "true",
+      };
+      uploads.push(
+        defaultFuncs
+          .postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, form, {})
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then(resData => {
+            if (resData.error) throw resData;
+            return resData.payload.metadata[0];
+          }),
+      );
+    }
+    Promise.all(uploads)
+      .then(resData => callback(null, resData))
+      .catch(err => {
+        utils.error("uploadAttachment", err);
+        return callback(err);
+      });
+  }
+
+  function getSendPayload(threadID, msg, otid) {
+    const isString = typeof msg === 'string';
+    const body = isString ? msg : msg.body || "";
+    otid = otid.toString() || utils.generateOfflineThreadingID().toString();
+    let payload = {
+      thread_id: threadID.toString(),
+      otid,
+      source: 0,
+      send_type: 1,
+      sync_group: 1,
+      text: body,
+      initiating_source: 1,
+      skip_url_preview_gen: 0,
+    };
+    if (typeof msg === 'object') {
+      if (msg.sticker) {
+        payload.send_type = 2;
+        payload.sticker_id = msg.sticker;
+        payload.text = null;
+      }
+      if (msg.attachment) {
+        payload.send_type = 3;
+        payload.attachment_fbids = Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment];
+      }
+    }
+    return payload;
+  }
+
+  /**
+   * Sends a message to a thread via MQTT with optional sequential editing.
+   * @param {object|string} msg The message to send. Can be a string or an object.
+   * @param {string} msg.body The main text of the message.
+   * @param {*} [msg.attachment] An attachment to send.
+   * @param {*} [msg.sticker] A sticker to send.
+   * @param {*} [msg.emoji] An emoji to send.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} [replyToMessage] The ID of the message to reply to.
+   */
+
+  return async (msg, threadID, replyToMessage, callback) => {
+
+    if (typeof msg !== 'string' && typeof msg !== 'object') {
+      throw new Error("Message should be of type string or object, not " + utils.getType(msg) + ".");
+    }
+
+    if (typeof threadID !== 'string' && typeof threadID !== 'number') {
+      throw new Error("threadID must be a string or number.");
+    }
+
+    if (!callback && typeof threadID === "function") {
+      throw new Error("Pass a threadID as a second argument.");
+    }
+
+    if (!callback && typeof replyToMessage === "function") {
+      callback = replyToMessage;
+      replyToMessage = null;
+    }
+
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    let returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const timestamp = Date.now();
+    const otid = utils.generateOfflineThreadingID();
+    const epoch_id = utils.generateOfflineThreadingID();
+    const payload = getSendPayload(threadID, msg, otid);
+
+    const tasks = [{
+      label: "46",
+      payload,
+      queue_name: threadID.toString(),
+      task_id: 0,
+      failure_count: null,
+    }, {
+      label: "21",
+      payload: {
+        thread_id: threadID.toString(),
+        last_read_watermark_ts: timestamp,
+        sync_group: 1,
+      },
+      queue_name: threadID.toString(),
+      task_id: 1,
+      failure_count: null,
+    }];
+
+    if (replyToMessage) {
+      tasks[0].payload.reply_metadata = {
+        reply_source_id: replyToMessage,
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+
+    const form = {
+      app_id: "2220391788200892",
+      payload: {
+        tasks,
+        epoch_id,
+        version_id: "6120284488008082",
+        data_trace_id: null,
+      },
+      request_id: 1,
+      type: 3,
+    };
+
+    if (msg.attachment) {
+      try {
+        const files = await new Promise((resolve, reject) => {
+          uploadAttachment(
+            Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment],
+            (err, files) => {
+              if (err) return reject(err);
+              return resolve(files);
+            }
+          );
+        });
+        form.payload.tasks[0].payload.attachment_fbids = files.map(file => Object.values(file)[0]);
+      } catch (err) {
+        utils.error("Attachment upload failed:", err);
+        throw err;
+      }
+    }
+
+    form.payload.tasks.forEach(task => {
+      task.payload = JSON.stringify(task.payload);
+    });
+    form.payload = JSON.stringify(form.payload);
+    await ctx.mqttClient.publish("/ls_req", JSON.stringify(form), {
+        qos: 1,
+        retain: false
+    });
+    callback(null, {
+        threadID,
+        type: replyToMessage ? "message_reply" : "message"
+    });
+    return returnPromise;
+  };
+};

package/src/apis/sendTypingIndicator.js

@@ -0,0 +1,41 @@
+
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+	/**
+	 * Sends a typing indicator to a specific thread.
+	 * @param {boolean} sendTyping - True to show typing indicator, false to hide.
+	 * @param {string} threadID - The ID of the thread to send the typing indicator to.
+	 * @param {Function} [callback] - An optional callback function.
+	 * @returns {Promise<void>}
+	 */
+	return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
+		let count_req = 0;
+		const wsContent = {
+			app_id: 2220391788200892,
+			payload: JSON.stringify({
+				label: 3,
+				payload: JSON.stringify({
+					thread_key: threadID.toString(),
+					is_group_thread: +(threadID.toString().length >= 16),
+					is_typing: +sendTyping,
+					attribution: 0
+				}),
+				version: 5849951561777440
+			}),
+			request_id: ++count_req,
+			type: 4
+		};
+		await new Promise((resolve, reject) => ctx.mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => err ? reject(err) : resolve()));
+		if (callback) {
+			callback();
+		}
+	};
+};

package/src/apis/setMessageReaction.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async (reaction, messageID) => {
+    if (!reaction) throw new Error("Please enter a valid emoji.");
+    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, {
+      doc_id: "1491398900900362",
+      variables: JSON.stringify({
+      data: {
+        client_mutation_id: ctx.clientMutationId++,
+        actor_id: ctx.userID,
+        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
+        message_id: messageID,
+        reaction
+      }
+    }),
+      dpr: 1
+    });
+    const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+    if (!resData) {
+      throw new Error("setMessageReactionLegacy returned empty object.");
+    }
+  };
+};