@lazyneoaz/testfca 1.0.0

package/src/apis/listenSpeed.js

@@ -0,0 +1,179 @@
+"use strict";
+
+const utils = require('../utils'); 
+const mqtt = require('mqtt');
+const websocket = require('websocket-stream');
+const HttpsProxyAgent = require('https-proxy-agent');
+const EventEmitter = require('events');
+
+function connectLightspeed(ctx, globalCallback) {
+    let client;
+    let isStopped = false;
+    const guard = (label, fn) => (...args) => {
+        try {
+            return fn(...args);
+        } catch (err) {
+            utils.error(`[Lightspeed] ${label} handler error:`, err && err.message ? err.message : err);
+        }
+    };
+
+    function startConnection(retryCount = 0) {
+        if (isStopped) return;
+
+        const chatOn = ctx.globalOptions.online;
+        const foreground = false;
+        const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+        const cookies = ctx.jar.getCookiesSync('https://www.facebook.com').join('; ');
+        const cid = ctx.clientID;
+
+        const username = {
+            u: ctx.userID,
+            s: sessionID,
+            chat_on: chatOn,
+            fg: foreground,
+            d: cid,
+            ct: 'websocket',
+            aid: '2220391788200892',
+            mqtt_sid: '',
+            cp: 3,
+            ecp: 10,
+            st: [],
+            pm: [],
+            dc: '',
+            no_auto_fg: true,
+            gas: null,
+            pack: [],
+            a: ctx.globalOptions.userAgent,
+        };
+        
+        const queryParams = new URLSearchParams({
+            'x-dgw-appid': '2220391788200892',
+            'x-dgw-appversion': '0',
+            'x-dgw-authtype': '1:0',
+            'x-dgw-version': '5',
+            'x-dgw-uuid': ctx.userID,
+            'x-dgw-tier': 'prod',
+            'x-dgw-loggingid': utils.getGUID(),
+            'x-dgw-regionhint': ctx.region || 'PRN',
+            'x-dgw-deviceid': ctx.clientID
+        });
+        const host = `wss://gateway.facebook.com/ws/lightspeed?${queryParams.toString()}`;
+        
+        // Generate a unique clientId per session, just like a real browser would
+        const lsClientId = 'mqttwsclient_' + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+        const options = {
+            clientId: lsClientId,
+            protocolId: 'MQIsdp',
+            protocolVersion: 3,
+            username: JSON.stringify(username),
+            clean: true,
+            wsOptions: {
+                headers: {
+                    'Cookie': cookies,
+                    'Origin': 'https://www.facebook.com',
+                    'User-Agent': username.a,
+                    'Referer': 'https://www.facebook.com/',
+                    'Host': new URL(host).hostname
+                }
+            },
+            keepalive: 60, // 60s is standard; 10s was too aggressive (sent PING every 10 seconds)
+            reconnectPeriod: 0 
+        };
+        
+        if (ctx.globalOptions.proxy) {
+            options.wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+        }
+
+        try {
+            client = new mqtt.Client(_ => websocket(host, options.wsOptions), options);
+            utils.log("[Lightspeed] Attempting MQTT connection...");
+        } catch (err) {
+            utils.error("[Lightspeed] MQTT Client creation failed:", err.message);
+            reconnect(retryCount + 1);
+            return;
+        }
+
+        client.on('connect', guard("connect", () => {
+            utils.log("[Lightspeed] MQTT client connected. Attempting to subscribe to topics...");
+            retryCount = 0;
+
+
+            const topicsToSubscribe = [
+                "/t_ms", // Para sa mga messages at deltas
+                "/orca_presence", // Para sa online status
+                "/messaging_events" // Para sa ibang events
+            ];
+
+            topicsToSubscribe.forEach(topic => {
+                client.subscribe(topic, (err) => {
+                    if (err) {
+                        utils.error(`[Lightspeed] Failed to subscribe to topic ${topic}:`, err.message);
+                    } else {
+                        utils.log(`[Lightspeed] Subscribed to topic: ${topic}`);
+                    }
+                });
+            });
+
+        }));
+
+        client.on('message', guard("message", (topic, payload) => {
+            utils.log(`[Lightspeed] Payload Received on topic ${topic}:`);
+            globalCallback(null, { type: 'lightspeed_message', topic: topic.toString(), payload: payload });
+        }));
+
+        client.on('close', guard("close", () => {
+            utils.warn(`[Lightspeed] Connection closed.`);
+            if (!isStopped) {
+                reconnect(retryCount + 1);
+            }
+        }));
+
+        client.on('error', guard("error", (err) => {
+            utils.error("[Lightspeed] MQTT Connection Error:", err.message);
+        }));
+    }
+
+    function reconnect(retryCount) {
+        const delay = Math.min(3000 * Math.pow(2, retryCount), 60000);
+        utils.log(`[Lightspeed] Reconnecting in ${delay / 1000} seconds...`);
+        setTimeout(() => startConnection(retryCount), delay);
+    }
+
+    startConnection();
+
+    return {
+        stop: () => {
+            isStopped = true;
+            if (client) client.end(true);
+            utils.log("[Lightspeed] Listener has been manually stopped.");
+        }
+    };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return (callback) => {
+        class MessageEmitter extends EventEmitter {
+            constructor() {
+                super();
+                this.listener = null;
+            }
+            stop() {
+                if (this.listener) {
+                    this.listener.stop();
+                }
+                this.emit('stop');
+            }
+        }
+        const msgEmitter = new MessageEmitter();
+        const globalCallback = (error, message) => {
+            if (error) return msgEmitter.emit("error", error);
+            msgEmitter.emit("message", message);
+        };
+        if (typeof callback === 'function') {
+            msgEmitter.listener = connectLightspeed(ctx, callback);
+        } else {
+            msgEmitter.listener = connectLightspeed(ctx, globalCallback);
+        }
+        return msgEmitter;
+    };
+};

package/src/apis/logout.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(): Promise<void>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Logs the current user out of Facebook.
+   * @returns {Promise<void>} A promise that resolves when logout is successful or rejects on error.
+   */
+  return async function logout() {
+    const form = {
+      pmid: "0",
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/bluebar/modern_settings_menu/?help_type=364455653583099&show_contextual_help=1",
+          ctx.jar,
+          form,
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      const elem = resData.jsmods.instances[0][2][0].find(v => v.value === "logout");
+      if (!elem) {
+        throw { error: "Could not find logout form element." };
+      }
+      
+      const html = resData.jsmods.markup.find(v => v[0] === elem.markup.__m)[1].__html;
+      
+      const logoutForm = {
+        fb_dtsg: utils.getFrom(html, '"fb_dtsg" value="', '"'),
+        ref: utils.getFrom(html, '"ref" value="', '"'),
+        h: utils.getFrom(html, '"h" value="', '"'),
+      };
+
+      const logoutRes = await defaultFuncs
+        .post("https://www.facebook.com/logout.php", ctx.jar, logoutForm)
+        .then(utils.saveCookies(ctx.jar));
+
+      if (!logoutRes.headers || !logoutRes.headers.location) {
+        throw { error: "An error occurred when logging out." };
+      }
+
+      await defaultFuncs
+        .get(logoutRes.headers.location, ctx.jar)
+        .then(utils.saveCookies(ctx.jar));
+      
+      ctx.loggedIn = false;
+
+      // Clear sensitive session tokens so stale credentials cannot be reused
+      // if this ctx object is accidentally referenced again after logout.
+      ctx.fb_dtsg = undefined;
+      ctx.fb_dtsg_ag = undefined;
+      ctx.lsd = undefined;
+      ctx.access_token = undefined;
+
+      // Stop background timers that are owned by this session, if present.
+      if (typeof ctx._stopTokenRefresh === 'function') {
+        try { ctx._stopTokenRefresh(); } catch (_) {}
+      }
+      if (typeof ctx._stopAutoReLogin === 'function') {
+        try { ctx._stopAutoReLogin(); } catch (_) {}
+      }
+      if (typeof ctx._stopCookieBackup === 'function') {
+        try { ctx._stopCookieBackup(); } catch (_) {}
+      }
+      
+      // Stop auto backup
+      try {
+        const { stopAutoBackup } = require('../database/appStateBackup');
+        stopAutoBackup();
+      } catch (_) {}
+
+      // Invalidate the response cache so nothing stale is served after logout.
+      if (ctx.cache && typeof ctx.cache.clear === 'function') {
+        ctx.cache.clear();
+      }
+
+      utils.log("logout", "Logged out successfully.");
+
+    } catch (err) {
+      utils.error("logout", err);
+      throw err;
+    }
+  };
+};

package/src/apis/markAsDelivered.js

@@ -0,0 +1,47 @@
+
+"use strict";
+
+const utils = require('../utils');
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(threadID: string, messageID: string): Promise<void>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Marks a message as delivered.
+   * @param {string} threadID - The ID of the thread.
+   * @param {string} messageID - The ID of the message to mark as delivered.
+   * @returns {Promise<void>} A promise that resolves on success or rejects on error.
+   */
+  return async function markAsDelivered(threadID, messageID) {
+    if (!threadID || !messageID) {
+      const err = "Error: messageID or threadID is not defined";
+      utils.error("markAsDelivered", err);
+      throw new Error(err);
+    }
+
+    const form = {};
+    form["message_ids[0]"] = messageID;
+    form["thread_ids[" + threadID + "][0]"] = messageID;
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/delivery_receipts.php",
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData.error) {
+        throw resData;
+      }
+    } catch (err) {
+      utils.error("markAsDelivered", err);
+      throw err;
+    }
+  };
+};

package/src/apis/markAsRead.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Marks a thread as read.
+   * @param {string} threadID - The ID of the thread to mark as read.
+   * @param {boolean} [read=true] - Whether to mark as read (true) or unread (false). Defaults to true.
+   * @param {Function} [callback] - The callback function.
+   * @returns {Promise<null|Error>} A Promise that resolves with null on success, or rejects with an Error.
+   */
+  return async function markAsRead(threadID, read, callback) {
+    if (
+      utils.getType(read) === "Function" ||
+      utils.getType(read) === "AsyncFunction"
+    ) {
+      callback = read;
+      read = true;
+    }
+    if (read == undefined) {
+      read = true;
+    }
+
+    if (!callback) {
+      callback = () => {};
+    }
+
+    // E2EE routing: if threadID is a JID (e.g. '61234@msgr')
+    const threadStr = threadID ? threadID.toString() : '';
+    if (threadStr.includes('@msgr') || threadStr.includes('@facebook')) {
+      if (api.e2ee && api.e2ee.isAvailable() && api.e2ee.isConnected().e2eeConnected) {
+        try {
+          await api.e2ee.markRead(threadStr, Date.now());
+          callback();
+        } catch (err) {
+          callback(err);
+        }
+      } else {
+        callback(new Error("E2EE not connected. Call api.e2ee.connect() and api.e2ee.connectE2EE() first."));
+      }
+      return;
+    }
+
+    const form = {};
+
+    if (typeof ctx.globalOptions.pageID !== "undefined") {
+      form["source"] = "PagesManagerMessagesInterface";
+      form["request_user_id"] = ctx.globalOptions.pageID;
+      form["ids[" + threadID + "]"] = read;
+      form["watermarkTimestamp"] = new Date().getTime();
+      form["shouldSendReadReceipt"] = true;
+      form["commerce_last_message_type"] = "";
+
+      let resData;
+      try {
+        resData = await defaultFuncs
+          .post(
+            "https://www.facebook.com/ajax/mercury/change_read_status.php",
+            ctx.jar,
+            form,
+          )
+          .then(utils.saveCookies(ctx.jar))
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+      } catch (e) {
+        callback(e);
+        return e;
+      }
+
+      if (resData.error) {
+        const err = resData.error;
+        utils.error("markAsRead", err);
+        callback(err);
+        return err;
+      }
+
+      callback();
+      return null;
+    } else {
+      try {
+        if (ctx.mqttClient) {
+          await new Promise((resolve, reject) => {
+            // Guard against a disconnected MQTT client hanging forever.
+            const timer = setTimeout(
+              () => reject(new Error("markAsRead: MQTT publish timed out after 8s")),
+              8000
+            );
+            ctx.mqttClient.publish(
+              "/mark_thread",
+              JSON.stringify({ threadID, mark: "read", state: read }),
+              { qos: 1, retain: false },
+              (err, _packet) => {
+                clearTimeout(timer);
+                if (err) reject(err);
+                else resolve();
+              }
+            );
+          });
+        } else {
+          throw {
+            error: "You can only use this function after you start listening.",
+          };
+        }
+      } catch (e) {
+        callback(e);
+        return e;
+      }
+    }
+  };
+};

package/src/apis/markAsReadAll.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(): Promise<void>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * @returns {Promise<void>}
+   */
+  return async function markAsReadAll() {
+    const form = {
+      folder: "inbox",
+    };
+
+    try {
+      const parsedData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/mark_folder_as_read.php",
+          ctx.jar,
+          form
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (parsedData.error) {
+        throw parsedData;
+      }
+      
+      return; 
+    } catch (err) {
+      utils.error("markAsReadAll", err);
+      throw err;
+    }
+  };
+};

package/src/apis/markAsSeen.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Marks all messages as "seen" up to a specific timestamp.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
+   * @param {Function} [callback] - The callback function.
+   * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
+   */
+  return async function markAsSeen(seen_timestamp, callback) {
+    let resolveFunc = function () {};
+    let rejectFunc = function () {};
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (utils.getType(seen_timestamp) == "Function" || utils.getType(seen_timestamp) == "AsyncFunction") {
+      callback = seen_timestamp;
+      seen_timestamp = Date.now();
+    } else if (seen_timestamp === undefined) {
+      seen_timestamp = Date.now();
+    }
+
+    if (!callback) {
+      callback = function (err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      seen_timestamp: seen_timestamp,
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/ajax/mercury/mark_seen.php",
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData.error) {
+        throw resData;
+      }
+
+      return callback();
+    } catch (err) {
+      utils.error("markAsSeen", err);
+      if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
+        ctx.loggedIn = false;
+      }
+      return callback(err);
+    }
+
+    return returnPromise;
+  };
+};