@lazyneoaz/metachat 1.0.0

package/src/apis/removeUserFromGroup.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function removeUserFromGroup(userID, threadID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(threadID) !== "Number" && utils.getType(threadID) !== "String") {
+        throw new Error("threadID should be of type Number or String");
+      }
+      if (utils.getType(userID) !== "Number" && utils.getType(userID) !== "String") {
+        throw new Error("userID should be of type Number or String");
+      }
+
+      if (ctx.mqttClient) {
+        const reqID = ++ctx.wsReqNumber;
+        const taskID = ++ctx.wsTaskNumber;
+
+        const payload = {
+          epoch_id: utils.generateOfflineThreadingID(),
+          tasks: [
+            {
+              failure_count: null,
+              label: '140',
+              payload: JSON.stringify({
+                thread_id: threadID,
+                contact_id: userID,
+                sync_group: 1
+              }),
+              queue_name: 'remove_participant_v2',
+              task_id: taskID
+            }
+          ],
+          version_id: '8798795233522156'
+        };
+
+        const form = JSON.stringify({
+          app_id: "2220391788200892",
+          payload: JSON.stringify(payload),
+          request_id: reqID,
+          type: 3
+        });
+
+        let responseHandled = false;
+        const handleRes = (topic, message) => {
+          if (topic !== "/ls_resp" || responseHandled) return;
+          let jsonMsg;
+          try {
+            jsonMsg = JSON.parse(message.toString());
+            jsonMsg.payload = JSON.parse(jsonMsg.payload);
+          } catch {
+            return;
+          }
+          if (jsonMsg.request_id !== reqID) return;
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(null, { success: true });
+          resolveFunc({ success: true });
+        };
+
+        const timeout = setTimeout(() => {
+          if (!responseHandled) {
+            responseHandled = true;
+            ctx.mqttClient.removeListener("message", handleRes);
+            const err = new Error("MQTT request timeout");
+            callback(err);
+            rejectFunc(err);
+          }
+        }, 30000);
+
+        ctx.mqttClient.on("message", handleRes);
+        ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+          if (err && !responseHandled) {
+            responseHandled = true;
+            clearTimeout(timeout);
+            ctx.mqttClient.removeListener("message", handleRes);
+            callback(err);
+            rejectFunc(err);
+          }
+        });
+      } else {
+        const form = {
+          uid: userID,
+          tid: threadID
+        };
+
+        const res = await defaultFuncs.post("https://www.facebook.com/chat/remove_participants", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (!res || res.error) {
+          throw res || new Error("Remove from group failed");
+        }
+
+        callback(null, { success: true });
+      }
+    } catch (err) {
+      utils.error("removeUserFromGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/resolvePhotoUrl.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @module resolvePhotoUrl
+ * @description Fetches the direct URL of a Facebook photo using its photo ID.
+ * @param {Object} defaultFuncs - An object containing default request functions.
+ * @param {Object} api - Facebook API object (unused here but kept for compatibility).
+ * @param {Object} ctx - Context object containing cookies (jar) and other session info.
+ * @returns {Function} resolvePhotoUrl - A function that takes a photo ID and optional callback, and returns a Promise resolving to the photo URL.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+/**
+* @function resolvePhotoUrl
+* @param {string} photoID - The ID of the Facebook photo to resolve.
+* @param {Function} [callback] - Optional Node-style callback function `(err, photoUrl)`.
+* @returns {Promise<string>} A Promise that resolves to the direct photo URL.
+*/
+return function resolvePhotoUrl(photoID, callback) {
+let resolveFunc = function () {};
+let rejectFunc = function () {};
+const returnPromise = new Promise(function (resolve, reject) {
+resolveFunc = resolve;
+rejectFunc = reject;
+});
+
+if (!callback) {
+callback = function (err, photoUrl) {
+if (err) {
+return rejectFunc(err);
+}
+resolveFunc(photoUrl);
+};
+}
+
+defaultFuncs
+.get("https://www.facebook.com/mercury/attachments/photo", ctx.jar, {
+photo_id: photoID,
+})
+.then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+.then((resData) => {
+if (resData.error) {
+throw resData;
+}
+
+const photoUrl = resData.jsmods.require[0][3][0];
+
+return callback(null, photoUrl);
+})
+.catch((err) => {
+utils.error("resolvePhotoUrl", err);
+return callback(err);
+});
+
+return returnPromise;
+};
+};

package/src/apis/scheduler.js

@@ -0,0 +1,129 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const scheduledMessages = new Map();
+  let nextId = 1;
+
+  function toTimestamp(when) {
+    if (when instanceof Date) return when.getTime();
+    if (typeof when === "number") return when;
+    if (typeof when === "string") return new Date(when).getTime();
+    return NaN;
+  }
+
+  function scheduleMessage(message, threadID, when, options) {
+    options = options || {};
+    const timestamp = toTimestamp(when);
+    if (isNaN(timestamp)) throw new Error("Invalid 'when'. Must be Date, number (ms timestamp), or ISO string.");
+    const now = Date.now();
+    if (timestamp <= now) throw new Error("Scheduled time must be in the future.");
+
+    const id = `scheduled_${nextId++}_${now}`;
+    const delay = timestamp - now;
+
+    const scheduled = {
+      id,
+      message,
+      threadID,
+      timestamp,
+      createdAt: now,
+      options: {
+        replyMessageID: options.replyMessageID || null,
+        callback: options.callback || null,
+      },
+      cancelled: false,
+      timeout: null,
+    };
+
+    scheduled.timeout = setTimeout(() => {
+      if (scheduled.cancelled) return;
+      const sendFn = api.sendMessage || api.sendMessageMqtt;
+      if (!sendFn) return;
+      Promise.resolve(
+        sendFn(message, threadID, scheduled.options.callback || (() => {}), scheduled.options.replyMessageID)
+      ).then(() => {
+        scheduledMessages.delete(id);
+      }).catch(() => {
+        scheduledMessages.delete(id);
+      });
+    }, delay);
+
+    scheduledMessages.set(id, scheduled);
+    return id;
+  }
+
+  function cancelScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return false;
+    clearTimeout(s.timeout);
+    s.cancelled = true;
+    scheduledMessages.delete(id);
+    return true;
+  }
+
+  function getScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return null;
+    return {
+      id: s.id,
+      message: s.message,
+      threadID: s.threadID,
+      timestamp: s.timestamp,
+      createdAt: s.createdAt,
+      options: { ...s.options },
+      timeUntilSend: s.timestamp - Date.now(),
+    };
+  }
+
+  function listScheduledMessages() {
+    const now = Date.now();
+    return Array.from(scheduledMessages.values())
+      .filter(s => !s.cancelled)
+      .map(s => ({
+        id: s.id,
+        message: s.message,
+        threadID: s.threadID,
+        timestamp: s.timestamp,
+        createdAt: s.createdAt,
+        options: { ...s.options },
+        timeUntilSend: s.timestamp - now,
+      }))
+      .sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  function cancelAllScheduledMessages() {
+    let count = 0;
+    for (const id of Array.from(scheduledMessages.keys())) {
+      if (cancelScheduledMessage(id)) count++;
+    }
+    return count;
+  }
+
+  function getScheduledCount() {
+    return scheduledMessages.size;
+  }
+
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [id, s] of scheduledMessages.entries()) {
+      if (s.cancelled || s.timestamp < now) scheduledMessages.delete(id);
+    }
+  }, 5 * 60 * 1000);
+
+  function destroy() {
+    clearInterval(cleanupInterval);
+    return cancelAllScheduledMessages();
+  }
+
+  ctx._scheduler = { destroy };
+
+  return {
+    scheduleMessage,
+    cancelScheduledMessage,
+    getScheduledMessage,
+    listScheduledMessages,
+    cancelAllScheduledMessages,
+    getScheduledCount,
+    destroy,
+  };
+};

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;
+  };
+};