@dongdev/fca-unofficial 3.0.17 → 3.0.20

package/CHANGELOG.md

@@ -170,3 +170,9 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v3.0.15 - 2025-12-12
 - Hotfix / auto bump
+
+## v3.0.17 - 2025-12-16
+- Hotfix / auto bump
+
+## v3.0.19 - 2025-12-31
+- Hotfix / auto bump

package/module/login.js

@@ -20,6 +20,11 @@ if (!global.fca._errorHandlersInstalled) {
         const errorCode = reason.code || reason.cause?.code;
         const errorMessage = reason.message || String(reason);
 
+        // Suppress Sequelize instance errors (handled gracefully in getBackupModel)
+        if (errorMessage.includes("No Sequelize instance passed")) {
+          return; // Silently ignore - already handled
+        }
+
         // Handle fetch timeout errors gracefully
         if (errorCode === "UND_ERR_CONNECT_TIMEOUT" ||
             errorCode === "ETIMEDOUT" ||
@@ -54,6 +59,11 @@ if (!global.fca._errorHandlersInstalled) {
       const errorMessage = error.message || String(error);
       const errorCode = error.code;
 
+      // Suppress Sequelize instance errors (handled gracefully in getBackupModel)
+      if (errorMessage.includes("No Sequelize instance passed")) {
+        return; // Silently ignore - already handled
+      }
+
       // Handle fetch/network errors
       if (errorCode === "UND_ERR_CONNECT_TIMEOUT" ||
           errorCode === "ETIMEDOUT" ||

package/module/loginHelper.js

@@ -182,28 +182,45 @@ function cookieHeaderFromJar(j) {
 let uniqueIndexEnsured = false;
 
 function getBackupModel() {
-  if (!models || !models.sequelize || !models.Sequelize) return null;
-  const sequelize = models.sequelize;
-  const { DataTypes } = models.Sequelize;
-  if (sequelize.models && sequelize.models.AppStateBackup) return sequelize.models.AppStateBackup;
-  const dialect = typeof sequelize.getDialect === "function" ? sequelize.getDialect() : "sqlite";
-  const LongText = (dialect === "mysql" || dialect === "mariadb") ? DataTypes.TEXT("long") : DataTypes.TEXT;
-  const AppStateBackup = sequelize.define(
-    "AppStateBackup",
-    {
-      id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
-      userID: { type: DataTypes.STRING, allowNull: false },
-      type: { type: DataTypes.STRING, allowNull: false },
-      data: { type: LongText }
-    },
-    { tableName: "app_state_backups", timestamps: true, indexes: [{ unique: true, fields: ["userID", "type"] }] }
-  );
-  return AppStateBackup;
+  try {
+    if (!models || !models.sequelize || !models.Sequelize) return null;
+    const sequelize = models.sequelize;
+
+    // Validate that sequelize is a proper Sequelize instance
+    if (!sequelize || typeof sequelize.define !== "function") return null;
+
+    const { DataTypes } = models.Sequelize;
+    if (sequelize.models && sequelize.models.AppStateBackup) return sequelize.models.AppStateBackup;
+    const dialect = typeof sequelize.getDialect === "function" ? sequelize.getDialect() : "sqlite";
+    const LongText = (dialect === "mysql" || dialect === "mariadb") ? DataTypes.TEXT("long") : DataTypes.TEXT;
+
+    try {
+      const AppStateBackup = sequelize.define(
+        "AppStateBackup",
+        {
+          id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+          userID: { type: DataTypes.STRING, allowNull: false },
+          type: { type: DataTypes.STRING, allowNull: false },
+          data: { type: LongText }
+        },
+        { tableName: "app_state_backups", timestamps: true, indexes: [{ unique: true, fields: ["userID", "type"] }] }
+      );
+      return AppStateBackup;
+    } catch (defineError) {
+      // If define fails, log and return null
+      logger(`Failed to define AppStateBackup model: ${defineError && defineError.message ? defineError.message : String(defineError)}`, "warn");
+      return null;
+    }
+  } catch (e) {
+    // Silently handle any errors in getBackupModel
+    return null;
+  }
 }
 
 async function ensureUniqueIndex(sequelize) {
-  if (uniqueIndexEnsured) return;
+  if (uniqueIndexEnsured || !sequelize) return;
   try {
+    if (typeof sequelize.getQueryInterface !== "function") return;
     await sequelize.getQueryInterface().addIndex("app_state_backups", ["userID", "type"], { unique: true, name: "app_state_user_type_unique" });
   } catch { }
   uniqueIndexEnsured = true;
@@ -225,6 +242,7 @@ async function backupAppStateSQL(j, userID) {
   try {
     const Model = getBackupModel();
     if (!Model) return;
+    if (!models || !models.sequelize) return;
     await Model.sync();
     await ensureUniqueIndex(models.sequelize);
     const appJson = getAppState(j);
@@ -289,26 +307,101 @@ async function setJarCookies(j, appstate) {
     const cookiePath = c.path || "/";
     const dom = cookieDomain.replace(/^\./, "");
 
-    // Format expires if provided
+    // Handle expirationDate (can be in seconds or milliseconds)
     let expiresStr = "";
-    if (c.expires) {
+    if (c.expirationDate !== undefined) {
+      let expiresDate;
+      if (typeof c.expirationDate === "number") {
+        // If expirationDate is less than a year from now in seconds, treat as seconds
+        // Otherwise treat as milliseconds
+        const now = Date.now();
+        const oneYearInMs = 365 * 24 * 60 * 60 * 1000;
+        if (c.expirationDate < (now + oneYearInMs) / 1000) {
+          expiresDate = new Date(c.expirationDate * 1000);
+        } else {
+          expiresDate = new Date(c.expirationDate);
+        }
+      } else {
+        expiresDate = new Date(c.expirationDate);
+      }
+      expiresStr = `; expires=${expiresDate.toUTCString()}`;
+    } else if (c.expires) {
       const expiresDate = typeof c.expires === "number" ? new Date(c.expires) : new Date(c.expires);
       expiresStr = `; expires=${expiresDate.toUTCString()}`;
     }
 
-    // Build cookie string
-    const str = `${cookieName}=${cookieValue}${expiresStr}; Domain=${cookieDomain}; Path=${cookiePath};`;
+    // Helper function to build cookie string
+    const buildCookieString = (domainOverride = null) => {
+      const domain = domainOverride || cookieDomain;
+      let cookieParts = [`${cookieName}=${cookieValue}${expiresStr}`];
+      cookieParts.push(`Domain=${domain}`);
+      cookieParts.push(`Path=${cookiePath}`);
 
-    // Set cookie for both http and https, with and without www
-    const base1 = `http://${dom}${cookiePath}`;
-    const base2 = `https://${dom}${cookiePath}`;
-    const base3 = `http://www.${dom}${cookiePath}`;
-    const base4 = `https://www.${dom}${cookiePath}`;
+      // Add Secure flag if secure is true
+      if (c.secure === true) {
+        cookieParts.push("Secure");
+      }
 
-    tasks.push(j.setCookie(str, base1).catch(() => { }));
-    tasks.push(j.setCookie(str, base2).catch(() => { }));
-    tasks.push(j.setCookie(str, base3).catch(() => { }));
-    tasks.push(j.setCookie(str, base4).catch(() => { }));
+      // Add HttpOnly flag if httpOnly is true
+      if (c.httpOnly === true) {
+        cookieParts.push("HttpOnly");
+      }
+
+      // Add SameSite attribute if provided
+      if (c.sameSite) {
+        const sameSiteValue = String(c.sameSite).toLowerCase();
+        if (["strict", "lax", "none"].includes(sameSiteValue)) {
+          cookieParts.push(`SameSite=${sameSiteValue.charAt(0).toUpperCase() + sameSiteValue.slice(1)}`);
+        }
+      }
+
+      return cookieParts.join("; ");
+    };
+
+    // Determine target URLs and cookie strings based on domain
+    const cookieConfigs = [];
+
+    // For .facebook.com domain, set for both facebook.com and messenger.com
+    if (cookieDomain === ".facebook.com" || cookieDomain === "facebook.com") {
+      // Set for facebook.com with .facebook.com domain
+      cookieConfigs.push({ url: `http://${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `http://www.${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://www.${dom}${cookiePath}`, cookieStr: buildCookieString() });
+
+      // Set for messenger.com with .messenger.com domain (or without domain for host-only)
+      // Use .messenger.com domain to allow cross-subdomain sharing
+      cookieConfigs.push({ url: `http://messenger.com${cookiePath}`, cookieStr: buildCookieString(".messenger.com") });
+      cookieConfigs.push({ url: `https://messenger.com${cookiePath}`, cookieStr: buildCookieString(".messenger.com") });
+      cookieConfigs.push({ url: `http://www.messenger.com${cookiePath}`, cookieStr: buildCookieString(".messenger.com") });
+      cookieConfigs.push({ url: `https://www.messenger.com${cookiePath}`, cookieStr: buildCookieString(".messenger.com") });
+    } else if (cookieDomain === ".messenger.com" || cookieDomain === "messenger.com") {
+      // Set for messenger.com only
+      const messengerDom = cookieDomain.replace(/^\./, "");
+      cookieConfigs.push({ url: `http://${messengerDom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://${messengerDom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `http://www.${messengerDom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://www.${messengerDom}${cookiePath}`, cookieStr: buildCookieString() });
+    } else {
+      // For other domains, set normally
+      cookieConfigs.push({ url: `http://${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `http://www.${dom}${cookiePath}`, cookieStr: buildCookieString() });
+      cookieConfigs.push({ url: `https://www.${dom}${cookiePath}`, cookieStr: buildCookieString() });
+    }
+
+    // Set cookie for all target URLs, silently catch domain errors
+    for (const config of cookieConfigs) {
+      tasks.push(j.setCookie(config.cookieStr, config.url).catch((err) => {
+        // Silently ignore domain mismatch errors for cross-domain cookies
+        // These are expected when setting cookies across domains
+        if (err && err.message && err.message.includes("Cookie not in this host's domain")) {
+          return; // Expected error, ignore
+        }
+        // Log other errors but don't throw
+        return;
+      }));
+    }
   }
   await Promise.all(tasks);
 }
@@ -835,8 +928,12 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
             }
           })
           .catch(function (error) {
-            console.error(error);
-            console.error("Database connection failed:", error && error.message ? error.message : String(error));
+            // Silently handle database errors - they're not critical for login
+            const errorMsg = error && error.message ? error.message : String(error);
+            if (!errorMsg.includes("No Sequelize instance passed")) {
+              // Only log non-Sequelize instance errors
+              logger(`Database connection failed: ${errorMsg}`, "warn");
+            }
           });
         logger("FCA fix/update by DongDev (Donix-VN)", "info");
         const ctxMain = {

package/package.json

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

package/src/api/socket/listenMqtt.js

@@ -61,7 +61,6 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
     }
     defaultFuncs.post = postSafe;
     ctx._postGuarded = true;
-    logger("postSafe guard installed for defaultFuncs.post", "info");
     return postSafe;
   }