@dongdev/fca-unofficial 3.0.31 → 4.0.1

package/src/api/messaging/scheduler.js

@@ -1,264 +0,0 @@
-"use strict";
-const logger = require("../../../func/logger");
-
-/**
- * Message Scheduler System
- * Allows scheduling messages to be sent at a specific time in the future
- */
-module.exports = function (defaultFuncs, api, ctx) {
-  // Initialize scheduler on first call
-  if (!ctx._scheduler) {
-    ctx._scheduler = createSchedulerInstance(api);
-  }
-
-  return ctx._scheduler;
-};
-
-function createSchedulerInstance(api) {
-  const scheduledMessages = new Map(); // Map<id, ScheduledMessage>
-  let nextId = 1;
-
-  /**
-   * Scheduled Message Object
-   * @typedef {Object} ScheduledMessage
-   * @property {string} id - Unique identifier
-   * @property {string|Object} message - Message content
-   * @property {string|string[]} threadID - Target thread ID(s)
-   * @property {number} timestamp - When to send (Unix timestamp in ms)
-   * @property {number} createdAt - When scheduled (Unix timestamp in ms)
-   * @property {Object} options - Additional options (replyMessageID, isGroup, etc.)
-   * @property {Function} callback - Optional callback when sent
-   * @property {NodeJS.Timeout} timeout - Timeout reference
-   * @property {boolean} cancelled - Whether cancelled
-   */
-
-  /**
-   * Schedule a message to be sent at a specific time
-   * @param {string|Object} message - Message content
-   * @param {string|string[]} threadID - Target thread ID(s)
-   * @param {Date|number|string} when - When to send (Date, timestamp, or ISO string)
-   * @param {Object} [options] - Additional options
-   * @param {string} [options.replyMessageID] - Message ID to reply to
-   * @param {boolean} [options.isGroup] - Whether it's a group chat
-   * @param {Function} [options.callback] - Callback when sent
-   * @returns {string} Scheduled message ID
-   */
-  function scheduleMessage(message, threadID, when, options = {}) {
-    let timestamp;
-
-    // Parse when parameter
-    if (when instanceof Date) {
-      timestamp = when.getTime();
-    } else if (typeof when === "number") {
-      timestamp = when;
-    } else if (typeof when === "string") {
-      timestamp = new Date(when).getTime();
-    } else {
-      throw new Error("Invalid 'when' parameter. Must be Date, number (timestamp), or ISO string");
-    }
-
-    // Validate timestamp
-    if (isNaN(timestamp)) {
-      throw new Error("Invalid date/time");
-    }
-
-    const now = Date.now();
-    if (timestamp <= now) {
-      throw new Error("Scheduled time must be in the future");
-    }
-
-    const id = `scheduled_${nextId++}_${Date.now()}`;
-    const delay = timestamp - now;
-
-    // Create scheduled message object
-    const scheduled = {
-      id,
-      message,
-      threadID,
-      timestamp,
-      createdAt: now,
-      options: {
-        replyMessageID: options.replyMessageID,
-        isGroup: options.isGroup,
-        callback: options.callback
-      },
-      cancelled: false
-    };
-
-    // Set timeout to send message
-    scheduled.timeout = setTimeout(() => {
-      if (scheduled.cancelled) return;
-
-      try {
-        logger(`Sending scheduled message ${id}`, "info");
-
-        // Send message
-        api.sendMessage(
-          message,
-          threadID,
-          scheduled.options.callback || (() => {}),
-          scheduled.options.replyMessageID,
-          scheduled.options.isGroup
-        ).then(() => {
-          logger(`Scheduled message ${id} sent successfully`, "info");
-          scheduledMessages.delete(id);
-        }).catch(err => {
-          logger(`Error sending scheduled message ${id}: ${err && err.message ? err.message : String(err)}`, "error");
-          if (scheduled.options.callback) {
-            scheduled.options.callback(err);
-          }
-          scheduledMessages.delete(id);
-        });
-      } catch (err) {
-        logger(`Error in scheduled message ${id}: ${err && err.message ? err.message : String(err)}`, "error");
-        scheduledMessages.delete(id);
-      }
-    }, delay);
-
-    scheduledMessages.set(id, scheduled);
-    logger(`Message scheduled: ${id} (in ${Math.round(delay / 1000)}s)`, "info");
-
-    return id;
-  }
-
-  /**
-   * Cancel a scheduled message
-   * @param {string} id - Scheduled message ID
-   * @returns {boolean} True if cancelled, false if not found
-   */
-  function cancelScheduledMessage(id) {
-    const scheduled = scheduledMessages.get(id);
-    if (!scheduled) {
-      return false;
-    }
-
-    if (scheduled.cancelled) {
-      return false; // Already cancelled
-    }
-
-    clearTimeout(scheduled.timeout);
-    scheduled.cancelled = true;
-    scheduledMessages.delete(id);
-    logger(`Scheduled message ${id} cancelled`, "info");
-    return true;
-  }
-
-  /**
-   * Get scheduled message info
-   * @param {string} id - Scheduled message ID
-   * @returns {ScheduledMessage|null} Scheduled message or null if not found
-   */
-  function getScheduledMessage(id) {
-    const scheduled = scheduledMessages.get(id);
-    if (!scheduled || scheduled.cancelled) {
-      return null;
-    }
-
-    // Return a copy without internal properties
-    return {
-      id: scheduled.id,
-      message: scheduled.message,
-      threadID: scheduled.threadID,
-      timestamp: scheduled.timestamp,
-      createdAt: scheduled.createdAt,
-      options: { ...scheduled.options },
-      timeUntilSend: scheduled.timestamp - Date.now()
-    };
-  }
-
-  /**
-   * List all scheduled messages
-   * @returns {ScheduledMessage[]} Array of scheduled messages
-   */
-  function listScheduledMessages() {
-    const now = Date.now();
-    const list = [];
-
-    for (const scheduled of scheduledMessages.values()) {
-      if (scheduled.cancelled) continue;
-
-      list.push({
-        id: scheduled.id,
-        message: scheduled.message,
-        threadID: scheduled.threadID,
-        timestamp: scheduled.timestamp,
-        createdAt: scheduled.createdAt,
-        options: { ...scheduled.options },
-        timeUntilSend: scheduled.timestamp - now
-      });
-    }
-
-    // Sort by timestamp
-    return list.sort((a, b) => a.timestamp - b.timestamp);
-  }
-
-  /**
-   * Cancel all scheduled messages
-   * @returns {number} Number of cancelled messages
-   */
-  function cancelAllScheduledMessages() {
-    let count = 0;
-    for (const id of scheduledMessages.keys()) {
-      if (cancelScheduledMessage(id)) {
-        count++;
-      }
-    }
-    logger(`Cancelled ${count} scheduled messages`, "info");
-    return count;
-  }
-
-  /**
-   * Get count of scheduled messages
-   * @returns {number} Count
-   */
-  function getScheduledCount() {
-    return scheduledMessages.size;
-  }
-
-  /**
-   * Clear expired/cancelled messages from memory
-   */
-  function cleanup() {
-    const now = Date.now();
-    let cleaned = 0;
-
-    for (const [id, scheduled] of scheduledMessages.entries()) {
-      if (scheduled.cancelled || scheduled.timestamp < now) {
-        scheduledMessages.delete(id);
-        cleaned++;
-      }
-    }
-
-    if (cleaned > 0) {
-      logger(`Cleaned up ${cleaned} scheduled messages`, "info");
-    }
-  }
-
-  // Auto cleanup every 5 minutes
-  const cleanupInterval = setInterval(cleanup, 5 * 60 * 1000);
-
-  /**
-   * Destroy scheduler and cleanup all resources
-   * @returns {number} Number of cancelled messages
-   */
-  function destroy() {
-    clearInterval(cleanupInterval);
-    const count = cancelAllScheduledMessages();
-    logger("Scheduler destroyed and all resources cleaned up", "info");
-    return count;
-  }
-
-  // Return scheduler API
-  return {
-    scheduleMessage,
-    cancelScheduledMessage,
-    getScheduledMessage,
-    listScheduledMessages,
-    cancelAllScheduledMessages,
-    getScheduledCount,
-    cleanup,
-    destroy,
-    // Cleanup interval reference for manual cleanup if needed
-    _cleanupInterval: cleanupInterval
-  };
-}

package/src/api/messaging/searchForThread.js

@@ -1,53 +0,0 @@
-"use strict";
-
-const { parseAndCheckLogin } = require("../../utils/client");
-const { formatThread } = require("../../utils/format");
-module.exports = function(defaultFuncs, api, ctx) {
-  return function searchForThread(name, callback) {
-    let resolveFunc = function() {};
-    let rejectFunc = function() {};
-    const returnPromise = new Promise(function(resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-
-    if (!callback) {
-      callback = function(err, friendList) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(friendList);
-      };
-    }
-
-    const tmpForm = {
-      client: "web_messenger",
-      query: name,
-      offset: 0,
-      limit: 21,
-      index: "fbid"
-    };
-
-    defaultFuncs
-      .post(
-        "https://www.facebook.com/ajax/mercury/search_threads.php",
-        ctx.jar,
-        tmpForm
-      )
-      .then(parseAndCheckLogin(ctx, defaultFuncs))
-      .then(function(resData) {
-        if (resData.error) {
-          throw resData;
-        }
-        if (!resData.payload.mercury_payload.threads) {
-          return callback({ error: "Could not find thread `" + name + "`." });
-        }
-        return callback(
-          null,
-          resData.payload.mercury_payload.threads.map(formatThread)
-        );
-      });
-
-    return returnPromise;
-  };
-};

package/src/api/messaging/sendMessage.js

@@ -1,270 +0,0 @@
-/**
- * Create by Donix-VN (DongDev)
- * Don't change credit
- * Send a message using MQTT.
- * @param {string} text - The text of the message to send.
- * @param {string} threadID - The ID of the thread to send the message to.
- * @param {string} [msgReplace] - Optional. The message ID of the message to replace.
- * @param {Array<Buffer|Stream>} [attachments] - Optional. The attachments to send with the message.
- * @param {function} [callback] - Optional. The callback function to call when the message is sent.
- * @returns {Promise<object>} A promise that resolves with the bodies of the sent message.
- */
-
-"use strict";
-const log = require("../../../func/logAdapter");
-const { getType } = require("../../utils/format");
-const { isReadableStream } = require("../../utils/constants");
-const { generateOfflineThreadingID } = require("../../utils/format");
-
-module.exports = function (defaultFuncs, api, ctx) {
-  const uploadAttachment = require("./uploadAttachment")(defaultFuncs, api, ctx);
-  const hasLinks = s => typeof s === "string" && /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(s);
-  const emojiSizes = { small: 1, medium: 2, large: 3 };
-
-  function extractIdsFromPayload(payload) {
-    let messageID = null;
-    let threadID = null;
-    function walk(n) {
-      if (Array.isArray(n)) {
-        if (n[0] === 5 && (n[1] === "replaceOptimsiticMessage" || n[1] === "replaceOptimisticMessage")) {
-          messageID = String(n[3]);
-        }
-        if (n[0] === 5 && n[1] === "writeCTAIdToThreadsTable") {
-          const a = n[2];
-          if (Array.isArray(a) && a[0] === 19) threadID = String(a[1]);
-        }
-        for (const x of n) walk(x);
-      }
-    }
-    walk(payload?.step);
-    return { threadID, messageID };
-  }
-
-  function publishWithAck(content, text, reqID, callback) {
-    return new Promise((resolve, reject) => {
-      // Ensure MQTT client is available before using it
-      if (!ctx.mqttClient || typeof ctx.mqttClient.on !== "function" || typeof ctx.mqttClient.publish !== "function") {
-        const err = new Error("MQTT client is not initialized");
-        log.error("sendMessageMqtt", err);
-        callback && callback(err);
-        return reject(err);
-      }
-
-      // Remove default max listeners limit to avoid MaxListenersExceededWarning
-      if (typeof ctx.mqttClient.setMaxListeners === "function") {
-        ctx.mqttClient.setMaxListeners(0);
-      }
-
-      let done = false;
-      const cleanup = () => {
-        if (done) return;
-        done = true;
-        ctx.mqttClient.removeListener("message", handleRes);
-      };
-      const handleRes = (topic, message) => {
-        if (topic !== "/ls_resp") return;
-        let jsonMsg;
-        try {
-          jsonMsg = JSON.parse(message.toString());
-          jsonMsg.payload = JSON.parse(jsonMsg.payload);
-        } catch {
-          return;
-        }
-        if (jsonMsg.request_id !== reqID) return;
-        const { threadID, messageID } = extractIdsFromPayload(jsonMsg.payload);
-        const bodies = { body: text || null, messageID, threadID };
-        cleanup();
-        callback && callback(undefined, bodies);
-        resolve(bodies);
-      };
-      ctx.mqttClient.on("message", handleRes);
-      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, err => {
-        if (err) {
-          cleanup();
-          callback && callback(err);
-          reject(err);
-        }
-      });
-      setTimeout(() => {
-        if (done) return;
-        cleanup();
-        const err = { error: "Timeout waiting for ACK" };
-        callback && callback(err);
-        reject(err);
-      }, 15000);
-    });
-  }
-
-  function buildMentionData(msg, baseBody) {
-    if (!msg.mentions || !Array.isArray(msg.mentions) || !msg.mentions.length) return null;
-    const base = typeof baseBody === "string" ? baseBody : "";
-    const ids = [];
-    const offsets = [];
-    const lengths = [];
-    const types = [];
-    let cursor = 0;
-    for (const m of msg.mentions) {
-      const raw = String(m.tag || "");
-      const name = raw.replace(/^@+/, "");
-      const start = Number.isInteger(m.fromIndex) ? m.fromIndex : cursor;
-      let idx = base.indexOf(raw, start);
-      let adj = 0;
-      if (idx === -1) {
-        idx = base.indexOf(name, start);
-        adj = 0;
-      } else {
-        adj = raw.length - name.length;
-      }
-      if (idx < 0) {
-        idx = 0;
-        adj = 0;
-      }
-      const off = idx + adj;
-      ids.push(String(m.id || 0));
-      offsets.push(off);
-      lengths.push(name.length);
-      types.push("p");
-      cursor = off + name.length;
-    }
-    return {
-      mention_ids: ids.join(","),
-      mention_offsets: offsets.join(","),
-      mention_lengths: lengths.join(","),
-      mention_types: types.join(",")
-    };
-  }
-
-  function coerceMsg(x) {
-    if (x == null) return { body: "" };
-    if (typeof x === "string") return { body: x };
-    if (typeof x === "object") return x;
-    return { body: String(x) };
-  }
-
-  return async function sendMessageMqtt(msg, threadID, callback, replyToMessage) {
-    if (typeof threadID === "function") return threadID({ error: "Pass a threadID as a second argument." });
-    if (typeof callback === "string" && !replyToMessage) {
-      replyToMessage = callback;
-      callback = () => { };
-    }
-    if (typeof callback !== "function") callback = () => { };
-    if (!threadID) {
-      const err = { error: "threadID is required" };
-      callback(err);
-      throw err;
-    }
-
-    const m = coerceMsg(msg);
-    const baseBody = m.body != null ? String(m.body) : "";
-    const reqID = Math.floor(100 + Math.random() * 900);
-    const epoch = (BigInt(Date.now()) << 22n).toString();
-
-    const payload0 = {
-      thread_id: String(threadID),
-      otid: generateOfflineThreadingID(),
-      source: 2097153,
-      send_type: 1,
-      sync_group: 1,
-      mark_thread_read: 1,
-      text: baseBody === "" ? null : baseBody,
-      initiating_source: 0,
-      skip_url_preview_gen: 0,
-      text_has_links: hasLinks(baseBody) ? 1 : 0,
-      multitab_env: 0,
-      metadata_dataclass: JSON.stringify({ media_accessibility_metadata: { alt_text: null } })
-    };
-
-    const mentionData = buildMentionData(m, baseBody);
-    if (mentionData) payload0.mention_data = mentionData;
-
-    if (m.sticker) {
-      payload0.send_type = 2;
-      payload0.sticker_id = m.sticker;
-    }
-
-    if (m.emoji) {
-      const size = !isNaN(m.emojiSize) ? Number(m.emojiSize) : emojiSizes[m.emojiSize || "small"] || 1;
-      payload0.send_type = 1;
-      payload0.text = m.emoji;
-      payload0.hot_emoji_size = Math.min(3, Math.max(1, size));
-    }
-
-    if (m.location && m.location.latitude != null && m.location.longitude != null) {
-      payload0.send_type = 1;
-      payload0.location_data = {
-        coordinates: { latitude: m.location.latitude, longitude: m.location.longitude },
-        is_current_location: !!m.location.current,
-        is_live_location: !!m.location.live
-      };
-    }
-
-    if (replyToMessage) {
-      payload0.reply_metadata = { reply_source_id: replyToMessage, reply_source_type: 1, reply_type: 0 };
-    }
-
-    if (m.attachment) {
-      payload0.send_type = 3;
-      if (payload0.text === "") payload0.text = null;
-      payload0.attachment_fbids = [];
-      let list = m.attachment;
-      if (getType(list) !== "Array") list = [list];
-      const idsFromPairs = [];
-      const streams = [];
-      for (const it of list) {
-        if (Array.isArray(it) && typeof it[0] === "string") {
-          idsFromPairs.push(String(it[1]));
-        } else if (isReadableStream(it)) {
-          streams.push(it);
-        }
-      }
-      if (idsFromPairs.length) payload0.attachment_fbids.push(...idsFromPairs);
-      if (streams.length) {
-        try {
-          const files = await uploadAttachment(streams);
-          for (const file of files) {
-            const key = Object.keys(file)[0];
-            payload0.attachment_fbids.push(file[key]);
-          }
-        } catch (err) {
-          log.error("uploadAttachment", err);
-          callback(err);
-          throw err;
-        }
-      }
-    }
-
-    const content = {
-      app_id: "2220391788200892",
-      payload: {
-        tasks: [
-          {
-            label: "46",
-            payload: payload0,
-            queue_name: String(threadID),
-            task_id: 400,
-            failure_count: null
-          },
-          {
-            label: "21",
-            payload: {
-              thread_id: String(threadID),
-              last_read_watermark_ts: Date.now(),
-              sync_group: 1
-            },
-            queue_name: String(threadID),
-            task_id: 401,
-            failure_count: null
-          }
-        ],
-        epoch_id: epoch,
-        version_id: "24804310205905615",
-        data_trace_id: "#" + Buffer.from(String(Math.random())).toString("base64").replace(/=+$/g, "")
-      },
-      request_id: reqID,
-      type: 3
-    };
-    content.payload.tasks.forEach(t => (t.payload = JSON.stringify(t.payload)));
-    content.payload = JSON.stringify(content.payload);
-    return publishWithAck(content, baseBody, reqID, callback);
-  };
-};

package/src/api/messaging/sendTypingIndicator.js

@@ -1,74 +0,0 @@
-"use strict";
-const { getType } = require("../../utils/format");
-module.exports = function (defaultFuncs, api, ctx) {
-  return function sendTyping(threadID, isTyping, options, callback) {
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-    if (getType(options) == "Function" || getType(options) == "AsyncFunction") {
-      callback = options;
-      options = {};
-    }
-    options = options || {};
-    if (!callback || getType(callback) != "Function" && getType(callback) != "AsyncFunction") {
-      callback = function (err, data) {
-        if (err) return rejectFunc(err);
-        resolveFunc(data);
-      };
-    }
-    if (!threadID) {
-      return callback(new Error("threadID is required"));
-    }
-    if (!ctx.mqttClient) {
-      const err = new Error("Not connected to MQTT");
-      callback(err);
-      rejectFunc(err);
-      return returnPromise;
-    }
-    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
-    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
-    threadIDs.forEach(tid => {
-      var isGroupThread = getType(tid) === "Array" ? 0 : 1;
-      var threadType = isGroupThread ? 2 : 1;
-      var duration = options.duration || 10000;
-      var autoStop = options.autoStop !== false;
-      var attribution = options.type || 0;
-      const publishTypingStatus = (isTypingStatus) => {
-        ctx.mqttClient.publish('/ls_req',
-          JSON.stringify({
-            app_id: "772021112871879",
-            payload: JSON.stringify({
-              label: "3",
-              payload: JSON.stringify({
-                "thread_key": parseInt(tid),
-                "is_group_thread": isGroupThread,
-                "is_typing": isTypingStatus ? 1 : 0,
-                "attribution": attribution,
-                "sync_group": 1,
-                "thread_type": threadType
-              }),
-              version: "8965252033599983"
-            }),
-            request_id: ++ctx.wsReqNumber,
-            type: 4
-          }),
-          {
-            qos: 1,
-            retain: false,
-          }
-        );
-      };
-      publishTypingStatus(isTyping);
-      if (isTyping && autoStop) {
-        setTimeout(() => {
-          publishTypingStatus(false);
-        }, duration);
-      }
-    });
-    callback(null, true);
-    return returnPromise;
-  };
-};