@dongdev/fca-unofficial 3.0.29 → 3.0.31

package/src/api/threads/getThreadList.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const log = require("npmlog");
+const log = require("../../../func/logAdapter");
 const { parseAndCheckLogin } = require("../../utils/client");
 const { formatID, getType } = require("../../utils/format");
 function createProfileUrl(url, username, id) {

package/src/api/threads/getThreadPictures.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const log = require("npmlog");
+const log = require("../../../func/logAdapter");
 const { parseAndCheckLogin } = require("../../utils/client");
 module.exports = function(defaultFuncs, api, ctx) {
   return function getThreadPictures(threadID, offset, limit, callback) {

package/src/api/users/getUserID.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const log = require("npmlog");
+const log = require("../../../func/logAdapter");
 const { formatID } = require("../../utils/format");
 function formatData(data) {
   return {

package/src/api/users/getUserInfo.js

@@ -2,7 +2,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const log = require("npmlog");
+const log = require("../../../func/logAdapter");
 const logger = require("../../../func/logger");
 const { parseAndCheckLogin } = require("../../utils/client.js");
 
@@ -118,17 +118,88 @@ function mergeUserEntry(a, b) {
   };
 }
 
-const queue = [];
-let isProcessingQueue = false;
-const processingUsers = new Set();
-const queuedUsers = new Set();
-const cooldown = new Map();
-
 module.exports = function (defaultFuncs, api, ctx) {
-  const dbFiles = fs.readdirSync(path.join(__dirname, "../../database")).filter(f => path.extname(f) === ".js").reduce((acc, file) => {
-    acc[path.basename(file, ".js")] = require(path.join(__dirname, "../../database", file))(api);
-    return acc;
-  }, {});
+  // Read FastConfig-style anti-get-info flag from global config (if available)
+  const cfg = global.fca && global.fca.config;
+  const antiCfg = cfg && cfg.antiGetInfo;
+  const disableAntiUserInfo = !!(antiCfg && antiCfg.AntiGetUserInfo === true);
+
+  // Lightweight, Horizon-style implementation without database/queue
+  if (disableAntiUserInfo) {
+    function formatLegacyData(data) {
+      const retObj = {};
+      for (const prop in data) {
+        if (!Object.prototype.hasOwnProperty.call(data, prop)) continue;
+        const innerObj = data[prop] || {};
+        retObj[prop] = {
+          name: innerObj.name || null,
+          firstName: innerObj.firstName || null,
+          vanity: innerObj.vanity || null,
+          thumbSrc: innerObj.thumbSrc || null,
+          profileUrl: innerObj.uri || innerObj.profileUrl || null,
+          gender: innerObj.gender || null,
+          type: innerObj.type || null,
+          isFriend: !!innerObj.is_friend,
+          isBirthday: !!innerObj.is_birthday
+        };
+      }
+      return retObj;
+    }
+
+    return function getUserInfo(idsOrId, callback) {
+      let resolveFunc;
+      let rejectFunc;
+      const returnPromise = new Promise((resolve, reject) => {
+        resolveFunc = resolve;
+        rejectFunc = reject;
+      });
+
+      if (typeof callback !== "function") {
+        callback = (err, userInfo) => {
+          if (err) return rejectFunc(err);
+          resolveFunc(userInfo);
+        };
+      }
+
+      const ids = Array.isArray(idsOrId) ? idsOrId : [idsOrId];
+      const form = {};
+      ids.forEach((v, i) => {
+        form[`ids[${i}]`] = v;
+      });
+
+      defaultFuncs
+        .post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+        .then(parseAndCheckLogin(ctx, defaultFuncs))
+        .then(resData => {
+          if (resData.error) throw resData;
+          const profiles = resData?.payload?.profiles || {};
+          return callback(null, formatLegacyData(profiles));
+        })
+        .catch(err => {
+          log.error(
+            "getUserInfo",
+            "Lỗi: getUserInfo Có Thể Do Bạn Spam Quá Nhiều !,Hãy Thử Lại !"
+          );
+          return callback(err);
+        });
+
+      return returnPromise;
+    };
+  }
+
+  const queue = [];
+  let isProcessingQueue = false;
+  const processingUsers = new Set();
+  const queuedUsers = new Set();
+  const cooldown = new Map();
+
+  const dbFiles = fs.readdirSync(path.join(__dirname, "../../database"))
+    .filter(f => path.extname(f) === ".js")
+    .reduce((acc, file) => {
+      const mod = require(path.join(__dirname, "../../database", file));
+      acc[path.basename(file, ".js")] = typeof mod === "function" ? mod(api) : mod;
+      return acc;
+    }, {});
   const { userData } = dbFiles;
   const { create, get, update, getAll } = userData;
 
@@ -319,7 +390,11 @@ module.exports = function (defaultFuncs, api, ctx) {
       }
       return callback(null, ret);
     }).catch(err => {
-      log.error("getUserInfo", "Error: " + (err?.message || "Unknown"));
+      // Horizon-style anti-get-info message to hint rate limiting / spam block
+      log.error(
+        "getUserInfo",
+        "Lỗi: getUserInfo Có Thể Do Bạn Spam Quá Nhiều !,Hãy Thử Lại !"
+      );
       callback(err);
     });
     return returnPromise;

package/src/database/helpers.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/**
+ * Shared helpers for database layer (userData, threadData).
+ * Keeps validation and payload normalization in one place.
+ */
+
+const DB_NOT_INIT = "Database not initialized";
+
+function validateId(value, fieldName = "id") {
+  if (value == null) {
+    throw new Error(`${fieldName} is required and cannot be undefined`);
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new Error(`Invalid ${fieldName}: must be a string or number`);
+  }
+  return String(value);
+}
+
+function validateData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object");
+  }
+}
+
+/**
+ * @param {string|string[]|null} keys - "userID" | ["userID","data"] | null
+ * @returns {string[]|undefined}
+ */
+function normalizeAttributes(keys) {
+  if (keys == null) return undefined;
+  return typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
+}
+
+/**
+ * Normalize payload: accept either { data } or raw object.
+ */
+function normalizePayload(data, key = "data") {
+  return Object.prototype.hasOwnProperty.call(data, key) ? data : { [key]: data };
+}
+
+function wrapError(message, cause) {
+  return new Error(`${message}: ${cause && cause.message ? cause.message : cause}`);
+}
+
+module.exports = {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+};

package/src/database/models/index.js

@@ -63,6 +63,7 @@ try {
 
   models.sequelize = sequelize;
   models.Sequelize = Sequelize;
+  models.isReady = true;
   models.syncAll = async () => {
     try {
       if (!sequelize) {
@@ -75,10 +76,10 @@ try {
     }
   };
 } catch (initError) {
-  // If initialization fails completely, still export a valid structure
   console.error("Database initialization error:", initError && initError.message ? initError.message : String(initError));
   models.sequelize = null;
   models.Sequelize = Sequelize;
+  models.isReady = false;
   models.syncAll = async () => {
     throw new Error("Database not initialized");
   };

package/src/database/models/thread.js

@@ -16,6 +16,11 @@ module.exports = function(sequelize) {
         allowNull: false,
         unique: true
       },
+      messageCount: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
       data: {
         type: DataTypes.TEXT,
         allowNull: true,

package/src/database/threadData.js

@@ -1,97 +1,93 @@
-const { Thread } = require("./models");
+"use strict";
 
-const validateThreadID = threadID => {
-  if (typeof threadID !== "string" && typeof threadID !== "number") {
-    throw new Error("Invalid threadID: must be a string or number.");
-  }
-  return String(threadID);
-};
-const validateData = data => {
-  if (!data || typeof data !== "object" || Array.isArray(data)) {
-    throw new Error("Invalid data: must be a non-empty object.");
-  }
-};
+const models = require("./models");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  wrapError
+} = require("./helpers");
 
-module.exports = function(bot) {
+const Thread = models.Thread;
+const ID_FIELD = "threadID";
+
+module.exports = function (bot) {
   return {
     async create(threadID, data) {
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: true };
+      }
       try {
+        threadID = validateId(threadID, ID_FIELD);
         let thread = await Thread.findOne({ where: { threadID } });
-        if (thread) {
-          return { thread: thread.get(), created: false };
-        }
-        thread = await Thread.create({ threadID, ...data });
+        if (thread) return { thread: thread.get(), created: false };
+        thread = await Thread.create({ threadID, ...(data || {}) });
         return { thread: thread.get(), created: true };
-      } catch (error) {
-        throw new Error(`Failed to create thread: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to create thread", err);
       }
     },
 
     async get(threadID) {
+      if (!Thread) return null;
       try {
-        threadID = validateThreadID(threadID);
+        threadID = validateId(threadID, ID_FIELD);
         const thread = await Thread.findOne({ where: { threadID } });
         return thread ? thread.get() : null;
-      } catch (error) {
-        throw new Error(`Failed to get thread: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to get thread", err);
       }
     },
 
     async update(threadID, data) {
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: false };
+      }
       try {
-        threadID = validateThreadID(threadID);
+        threadID = validateId(threadID, ID_FIELD);
         validateData(data);
         const thread = await Thread.findOne({ where: { threadID } });
-
         if (thread) {
           await thread.update(data);
           return { thread: thread.get(), created: false };
-        } else {
-          const newThread = await Thread.create({ ...data, threadID });
-          return { thread: newThread.get(), created: true };
         }
-      } catch (error) {
-        throw new Error(`Failed to update thread: ${error.message}`);
+        const newThread = await Thread.create({ ...data, threadID });
+        return { thread: newThread.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update thread", err);
       }
     },
 
     async del(threadID) {
+      if (!Thread) throw new Error(DB_NOT_INIT);
       try {
-        if (!threadID) {
-          throw new Error("threadID is required and cannot be undefined");
-        }
-        threadID = validateThreadID(threadID);
-        if (!threadID) {
-          throw new Error("Invalid threadID");
-        }
+        threadID = validateId(threadID, ID_FIELD);
         const result = await Thread.destroy({ where: { threadID } });
-        if (result === 0) {
-          throw new Error("No thread found with the specified threadID");
-        }
+        if (result === 0) throw new Error("No thread found with the specified threadID");
         return result;
-      } catch (error) {
-        throw new Error(`Failed to delete thread: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to delete thread", err);
       }
     },
+
     async delAll() {
+      if (!Thread) return 0;
       try {
         return await Thread.destroy({ where: {} });
-      } catch (error) {
-        throw new Error(`Failed to delete all threads: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to delete all threads", err);
       }
     },
+
     async getAll(keys = null) {
+      if (!Thread) return [];
       try {
-        const attributes =
-          typeof keys === "string"
-            ? [keys]
-            : Array.isArray(keys)
-            ? keys
-            : undefined;
-        const threads = await Thread.findAll({ attributes });
-        return threads.map(thread => thread.get());
-      } catch (error) {
-        throw new Error(`Failed to get all threads: ${error.message}`);
+        const attributes = normalizeAttributes(keys);
+        const rows = await Thread.findAll({ attributes });
+        return rows.map((t) => t.get());
+      } catch (err) {
+        throw wrapError("Failed to get all threads", err);
       }
     }
   };

package/src/database/userData.js

@@ -1,88 +1,97 @@
-const { User } = require("./models");
+"use strict";
 
-const validateUserID = userID => {
-  if (typeof userID !== "string" && typeof userID !== "number") {
-    throw new Error("Invalid userID: must be a string or number.");
-  }
-  return String(userID);
-};
-const validateData = data => {
-  if (!data || typeof data !== "object" || Array.isArray(data)) {
-    throw new Error("Invalid data: must be a non-empty object.");
-  }
-};
+const models = require("./models");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+} = require("./helpers");
+
+const User = models.User;
+const ID_FIELD = "userID";
+
+function stubUser(userID, data) {
+  return { user: { userID, ...normalizePayload(data || {}, "data") }, created: true };
+}
 
 module.exports = function (bot) {
   return {
     async create(userID, data) {
+      if (!User) return stubUser(validateId(userID, ID_FIELD), data);
       try {
-        userID = validateUserID(userID);
+        userID = validateId(userID, ID_FIELD);
         validateData(data);
+        const payload = normalizePayload(data, "data");
         let user = await User.findOne({ where: { userID } });
         if (user) return { user: user.get(), created: false };
-        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
         user = await User.create({ userID, ...payload });
         return { user: user.get(), created: true };
-      } catch (error) {
-        throw new Error(`Failed to create user: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to create user", err);
       }
     },
 
     async get(userID) {
+      if (!User) return null;
       try {
-        userID = validateUserID(userID);
+        userID = validateId(userID, ID_FIELD);
         const user = await User.findOne({ where: { userID } });
         return user ? user.get() : null;
-      } catch (error) {
-        throw new Error(`Failed to get user: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to get user", err);
       }
     },
 
     async update(userID, data) {
+      if (!User) return { user: { userID: validateId(userID, ID_FIELD), ...normalizePayload(data || {}, "data") }, created: false };
       try {
-        userID = validateUserID(userID);
+        userID = validateId(userID, ID_FIELD);
         validateData(data);
-        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
+        const payload = normalizePayload(data, "data");
         const user = await User.findOne({ where: { userID } });
         if (user) {
           await user.update(payload);
           return { user: user.get(), created: false };
-        } else {
-          const newUser = await User.create({ userID, ...payload });
-          return { user: newUser.get(), created: true };
         }
-      } catch (error) {
-        throw new Error(`Failed to update user: ${error.message}`);
+        const newUser = await User.create({ userID, ...payload });
+        return { user: newUser.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update user", err);
       }
     },
 
     async del(userID) {
+      if (!User) throw new Error(DB_NOT_INIT);
       try {
-        if (!userID) throw new Error("userID is required and cannot be undefined");
-        userID = validateUserID(userID);
+        userID = validateId(userID, ID_FIELD);
         const result = await User.destroy({ where: { userID } });
         if (result === 0) throw new Error("No user found with the specified userID");
         return result;
-      } catch (error) {
-        throw new Error(`Failed to delete user: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to delete user", err);
       }
     },
 
     async delAll() {
+      if (!User) return 0;
       try {
         return await User.destroy({ where: {} });
-      } catch (error) {
-        throw new Error(`Failed to delete all users: ${error.message}`);
+      } catch (err) {
+        throw wrapError("Failed to delete all users", err);
       }
     },
 
     async getAll(keys = null) {
+      if (!User) return [];
       try {
-        const attributes = typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
-        const users = await User.findAll({ attributes });
-        return users.map(u => u.get());
-      } catch (error) {
-        throw new Error(`Failed to get all users: ${error.message}`);
+        const attributes = normalizeAttributes(keys);
+        const rows = await User.findAll({ attributes });
+        return rows.map((u) => u.get());
+      } catch (err) {
+        throw wrapError("Failed to get all users", err);
       }
     }
   };

package/src/remote/remoteClient.js

@@ -0,0 +1,123 @@
+"use strict";
+
+const WebSocket = require("ws");
+const logger = require("../../func/logger");
+
+function createRemoteClient(api, ctx, cfg) {
+  if (!cfg || !cfg.enabled || !cfg.url) return null;
+
+  const url = String(cfg.url);
+  const token = cfg.token ? String(cfg.token) : null;
+  const autoReconnect = cfg.autoReconnect !== false;
+  const emitter = ctx && ctx._emitter;
+
+  let ws = null;
+  let closed = false;
+  let reconnectTimer = null;
+
+  function log(message, level = "info") {
+    logger(`[remote] ${message}`, level);
+  }
+
+  function scheduleReconnect() {
+    if (!autoReconnect || closed) return;
+    if (reconnectTimer) return;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      if (!closed) connect();
+    }, 5000);
+  }
+
+  function safeEmit(event, payload) {
+    try {
+      if (emitter && typeof emitter.emit === "function") {
+        emitter.emit(event, payload);
+      }
+    } catch { }
+  }
+
+  function connect() {
+    try {
+      ws = new WebSocket(url, {
+        headers: token ? { Authorization: `Bearer ${token}` } : undefined
+      });
+    } catch (e) {
+      log(`connect error: ${e && e.message ? e.message : String(e)}`, "warn");
+      scheduleReconnect();
+      return;
+    }
+
+    ws.on("open", () => {
+      log("connected", "info");
+      const payload = {
+        type: "hello",
+        userID: ctx && ctx.userID,
+        region: ctx && ctx.region,
+        version: require("../../package.json").version
+      };
+      try {
+        ws.send(JSON.stringify(payload));
+      } catch { }
+      safeEmit("remoteConnected", payload);
+    });
+
+    ws.on("message", data => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (!msg || typeof msg !== "object") return;
+
+      switch (msg.type) {
+        case "ping":
+          try {
+            ws.send(JSON.stringify({ type: "pong" }));
+          } catch { }
+          break;
+        case "stop":
+          safeEmit("remoteStop", msg);
+          break;
+        case "broadcast":
+          safeEmit("remoteBroadcast", msg.payload || {});
+          break;
+        default:
+          safeEmit("remoteMessage", msg);
+          break;
+      }
+    });
+
+    ws.on("close", () => {
+      log("disconnected", "warn");
+      safeEmit("remoteDisconnected");
+      if (!closed) scheduleReconnect();
+    });
+
+    ws.on("error", err => {
+      log(`error: ${err && err.message ? err.message : String(err)}`, "warn");
+    });
+  }
+
+  connect();
+
+  return {
+    close() {
+      closed = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      try {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.close();
+        }
+      } catch { }
+    }
+  };
+}
+
+module.exports = {
+  createRemoteClient
+};
+