@dongdev/fca-unofficial 3.0.0 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
   "main": "index.js",
   "types": "index.d.ts",

package/src/api/action/enableAutoSaveAppState.js

@@ -0,0 +1,73 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const logger = require("../../../func/logger");
+
+/**
+ * Enable automatic AppState saving
+ * @param {Object} options - Options for auto-save
+ * @param {string} [options.filePath] - Path to save AppState (default: "appstate.json")
+ * @param {number} [options.interval] - Save interval in milliseconds (default: 10 minutes)
+ * @param {boolean} [options.saveOnLogin] - Save immediately on login (default: true)
+ * @returns {Function} Function to disable auto-save
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function enableAutoSaveAppState(options = {}) {
+    const filePath = options.filePath || path.join(process.cwd(), "appstate.json");
+    const interval = options.interval || 10 * 60 * 1000; // 10 minutes default
+    const saveOnLogin = options.saveOnLogin !== false; // default true
+
+    // Save function
+    function saveAppState() {
+      try {
+        const appState = api.getAppState();
+        if (!appState || !appState.appState || appState.appState.length === 0) {
+          logger("AppState is empty, skipping save", "warn");
+          return;
+        }
+
+        const data = JSON.stringify(appState, null, 2);
+        fs.writeFileSync(filePath, data, "utf8");
+        logger(`AppState saved to ${filePath}`, "info");
+      } catch (error) {
+        logger(`Error saving AppState: ${error && error.message ? error.message : String(error)}`, "error");
+      }
+    }
+
+    // Save immediately if requested
+    let immediateSaveTimer = null;
+    if (saveOnLogin) {
+      // Delay a bit to ensure login is complete
+      immediateSaveTimer = setTimeout(() => {
+        saveAppState();
+        immediateSaveTimer = null;
+      }, 2000);
+    }
+
+    // Set up interval
+    const intervalId = setInterval(saveAppState, interval);
+    logger(`Auto-save AppState enabled: ${filePath} (every ${Math.round(interval / 1000 / 60)} minutes)`, "info");
+
+    // Store interval ID for cleanup
+    if (!ctx._autoSaveInterval) {
+      ctx._autoSaveInterval = [];
+    }
+    ctx._autoSaveInterval.push(intervalId);
+
+    // Return disable function
+    return function disableAutoSaveAppState() {
+      // Clear immediate save timer if still pending
+      if (immediateSaveTimer) {
+        clearTimeout(immediateSaveTimer);
+        immediateSaveTimer = null;
+      }
+      // Clear interval
+      clearInterval(intervalId);
+      const index = ctx._autoSaveInterval ? ctx._autoSaveInterval.indexOf(intervalId) : -1;
+      if (index !== -1) {
+        ctx._autoSaveInterval.splice(index, 1);
+      }
+      logger("Auto-save AppState disabled", "info");
+    };
+  };
+};

package/src/api/messaging/scheduler.js

@@ -0,0 +1,264 @@
+"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/socket/core/connectMqtt.js

@@ -1,7 +1,5 @@
 "use strict";
 const { formatID } = require("../../../utils/format");
-const uuid = require("uuid");
-"use strict";
 module.exports = function createListenMqtt(deps) {
   const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy,
     topics, parseDelta, getTaskResponseData, logger, emitAuth
@@ -87,7 +85,11 @@ module.exports = function createListenMqtt(deps) {
       options
     );
     const mqttClient = ctx.mqttClient;
-    global.mqttClient = mqttClient;
+    // Remove global reference to prevent memory leak
+    // Only set if needed for debugging, but clear on cleanup
+    if (process.env.DEBUG_MQTT) {
+      global.mqttClient = mqttClient;
+    }
 
     mqttClient.on("error", function (err) {
       const msg = String(err && err.message ? err.message : err || "");
@@ -145,7 +147,8 @@ module.exports = function createListenMqtt(deps) {
       mqttClient.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
       mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
       const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
-      const rTimeout = setTimeout(function () {
+      let rTimeout = setTimeout(function () {
+        rTimeout = null;
         if (ctx._ending) {
           logger("mqtt t_ms timeout skipped - ending", "warn");
           return;
@@ -159,8 +162,17 @@ module.exports = function createListenMqtt(deps) {
         scheduleReconnect(d);
       }, 5000);
 
+      // Store timeout reference for cleanup
+      ctx._rTimeout = rTimeout;
+
       ctx.tmsWait = function () {
-        clearTimeout(rTimeout);
+        if (rTimeout) {
+          clearTimeout(rTimeout);
+          rTimeout = null;
+        }
+        if (ctx._rTimeout) {
+          delete ctx._rTimeout;
+        }
         if (ctx.globalOptions.emitReady) globalCallback({ type: "ready", error: null });
         delete ctx.tmsWait;
       };

package/src/api/socket/core/emitAuth.js

@@ -33,6 +33,60 @@ module.exports = function createEmitAuth({ logger }) {
     ctx.mqttClient = undefined;
     ctx.loggedIn = false;
 
+    // Clean up timeout references
+    try {
+      if (ctx._rTimeout) {
+        clearTimeout(ctx._rTimeout);
+        ctx._rTimeout = null;
+      }
+    } catch (_) { }
+
+    // Clean up tasks Map to prevent memory leak
+    try {
+      if (ctx.tasks && ctx.tasks instanceof Map) {
+        ctx.tasks.clear();
+      }
+    } catch (_) { }
+
+    // Clean up userInfo intervals
+    try {
+      if (ctx._userInfoIntervals && Array.isArray(ctx._userInfoIntervals)) {
+        ctx._userInfoIntervals.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._userInfoIntervals = [];
+      }
+    } catch (_) { }
+
+    // Clean up autoSave intervals
+    try {
+      if (ctx._autoSaveInterval && Array.isArray(ctx._autoSaveInterval)) {
+        ctx._autoSaveInterval.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._autoSaveInterval = [];
+      }
+    } catch (_) { }
+
+    // Clean up scheduler
+    try {
+      if (ctx._scheduler && typeof ctx._scheduler.destroy === "function") {
+        ctx._scheduler.destroy();
+        ctx._scheduler = undefined;
+      }
+    } catch (_) { }
+
+    // Clear global mqttClient reference if set
+    try {
+      if (global.mqttClient) {
+        delete global.mqttClient;
+      }
+    } catch (_) { }
+
     const msg = detail || reason;
     logger(`auth change -> ${reason}: ${msg}`, "error");
 

package/src/api/socket/listenMqtt.js

@@ -13,6 +13,7 @@ const createGetSeqID = require("./core/getSeqID");
 const markDelivery = require("./core/markDelivery");
 const getTaskResponseData = require("./core/getTaskResponseData");
 const createEmitAuth = require("./core/emitAuth");
+const createMiddlewareSystem = require("./middleware");
 const parseDelta = createParseDelta({ markDelivery, parseAndCheckLogin });
 // Create emitAuth first so it can be injected into both factories
 const emitAuth = createEmitAuth({ logger });
@@ -32,6 +33,12 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   const identity = function () { };
   let globalCallback = identity;
 
+  // Initialize middleware system if not already initialized
+  if (!ctx._middleware) {
+    ctx._middleware = createMiddlewareSystem();
+  }
+  const middleware = ctx._middleware;
+
   function installPostGuard() {
     if (ctx._postGuarded) return defaultFuncs.post;
     const rawPost = defaultFuncs.post && defaultFuncs.post.bind(defaultFuncs);
@@ -160,6 +167,43 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
         clearTimeout(ctx._reconnectTimer);
         ctx._reconnectTimer = null;
       }
+      if (ctx._rTimeout) {
+        clearTimeout(ctx._rTimeout);
+        ctx._rTimeout = null;
+      }
+      // Clean up tasks Map to prevent memory leak
+      if (ctx.tasks && ctx.tasks instanceof Map) {
+        ctx.tasks.clear();
+      }
+      // Clean up userInfo intervals
+      if (ctx._userInfoIntervals && Array.isArray(ctx._userInfoIntervals)) {
+        ctx._userInfoIntervals.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._userInfoIntervals = [];
+      }
+      // Clean up autoSave intervals
+      if (ctx._autoSaveInterval && Array.isArray(ctx._autoSaveInterval)) {
+        ctx._autoSaveInterval.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._autoSaveInterval = [];
+      }
+      // Clean up scheduler
+      if (ctx._scheduler && typeof ctx._scheduler.destroy === "function") {
+        try {
+          ctx._scheduler.destroy();
+        } catch (_) { }
+        ctx._scheduler = undefined;
+      }
+      // Clear global mqttClient reference if set
+      if (global.mqttClient) {
+        delete global.mqttClient;
+      }
       next && next();
     };
     try {
@@ -224,11 +268,20 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
 
     const msgEmitter = new MessageEmitter();
 
-    globalCallback = callback || function (error, message) {
+    // Original callback without middleware
+    const originalCallback = callback || function (error, message) {
       if (error) { logger("mqtt emit error", "error"); return msgEmitter.emit("error", error); }
       msgEmitter.emit("message", message);
     };
 
+    // Only wrap callback with middleware if middleware exists
+    // If no middleware, use callback directly for better performance
+    if (middleware.count > 0) {
+      globalCallback = middleware.wrapCallback(originalCallback);
+    } else {
+      globalCallback = originalCallback;
+    }
+
     conf = mqttConf(ctx, conf);
 
     installPostGuard();
@@ -253,6 +306,60 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
 
     api.stopListening = msgEmitter.stopListening;
     api.stopListeningAsync = msgEmitter.stopListeningAsync;
+
+    // Store original callback for re-wrapping when middleware is added/removed
+    let currentOriginalCallback = originalCallback;
+    let currentGlobalCallback = globalCallback;
+
+    // Function to re-wrap callback when middleware changes
+    function rewrapCallbackIfNeeded() {
+      if (!ctx.mqttClient || ctx._ending) return; // Not listening or ending
+
+      const hasMiddleware = middleware.count > 0;
+      const isWrapped = currentGlobalCallback !== currentOriginalCallback;
+
+      // If middleware exists but callback is not wrapped, wrap it
+      if (hasMiddleware && !isWrapped) {
+        currentGlobalCallback = middleware.wrapCallback(currentOriginalCallback);
+        globalCallback = currentGlobalCallback;
+        logger("Middleware added - callback re-wrapped", "info");
+      }
+      // If no middleware but callback is wrapped, unwrap it
+      else if (!hasMiddleware && isWrapped) {
+        currentGlobalCallback = currentOriginalCallback;
+        globalCallback = currentGlobalCallback;
+        logger("All middleware removed - callback unwrapped", "info");
+      }
+    }
+
+    // Expose middleware API with re-wrapping support
+    api.useMiddleware = function (middlewareFn, fn) {
+      const result = middleware.use(middlewareFn, fn);
+      rewrapCallbackIfNeeded();
+      return result;
+    };
+    api.removeMiddleware = function (identifier) {
+      const result = middleware.remove(identifier);
+      rewrapCallbackIfNeeded();
+      return result;
+    };
+    api.clearMiddleware = function () {
+      const result = middleware.clear();
+      rewrapCallbackIfNeeded();
+      return result;
+    };
+    api.listMiddleware = function () {
+      return middleware.list();
+    };
+    api.setMiddlewareEnabled = function (name, enabled) {
+      const result = middleware.setEnabled(name, enabled);
+      rewrapCallbackIfNeeded();
+      return result;
+    };
+    Object.defineProperty(api, "middlewareCount", {
+      get: function () { return middleware.count; }
+    });
+
     return msgEmitter;
   };
 };