@dongdev/fca-unofficial 3.0.28 → 3.0.30

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,13 +118,81 @@ 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) {
+  // 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) => {
     acc[path.basename(file, ".js")] = require(path.join(__dirname, "../../database", file))(api);
     return acc;
@@ -319,7 +387,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/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/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
+};
+

package/src/utils/broadcast.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const logger = require("../../func/logger");
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function broadcast(api, threadIDs, message, options) {
+  const opts = options || {};
+  const delayMs = typeof opts.delayMs === "number" ? opts.delayMs : 1000;
+  const skipBlocked = opts.skipBlocked !== false;
+  const onResult = typeof opts.onResult === "function" ? opts.onResult : null;
+
+  if (!api || typeof api.sendMessage !== "function") {
+    throw new Error("broadcast: api.sendMessage is required.");
+  }
+
+  const ids = Array.isArray(threadIDs) ? threadIDs : [threadIDs];
+  const results = [];
+
+  for (const id of ids) {
+    try {
+      const res = await api.sendMessage(message, id);
+      const item = { threadID: id, ok: true, res };
+      results.push(item);
+      if (onResult) onResult(null, item);
+    } catch (e) {
+      const msg = e && e.error ? e.error : e && e.message ? e.message : String(e);
+      logger(`broadcast: failed for ${id}: ${msg}`, "warn");
+      const item = { threadID: id, ok: false, error: e };
+      results.push(item);
+      if (onResult) onResult(e, item);
+
+      if (
+        skipBlocked &&
+        /permission|blocked|not allowed|cannot send message|not authorized/i.test(msg)
+      ) {
+        // Skip only this target, continue with others
+      }
+    }
+    if (delayMs > 0) {
+      await delay(delayMs);
+    }
+  }
+
+  return results;
+}
+
+module.exports = broadcast;
+

package/src/utils/loginParser.js

@@ -20,6 +20,13 @@ function makeParsable(html) {
 
 function parseAndCheckLogin(ctx, http, retryCount = 0) {
   const delay = ms => new Promise(r => setTimeout(r, ms));
+  const emit = (event, payload) => {
+    try {
+      if (ctx && ctx._emitter && typeof ctx._emitter.emit === "function") {
+        ctx._emitter.emit(event, payload);
+      }
+    } catch { }
+  };
   const headerOf = (headers, name) => {
     if (!headers) return;
     const k = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());
@@ -59,11 +66,13 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
     // Set flag to prevent concurrent auto login attempts
     ctx.auto_login = true;
     logger("Login session expired, attempting auto login...", "warn");
+    emit("sessionExpired", { res: resData });
 
     try {
       const ok = await ctx.performAutoLogin();
       if (ok) {
         logger("Auto login successful! Retrying request...", "info");
+        emit("autoLoginSuccess", { res: resData });
         ctx.auto_login = false;
 
         // After successful auto login, retry the original request
@@ -128,6 +137,7 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
         const e = new Error("Not logged in. Auto login failed.");
         e.error = "Not logged in.";
         e.res = resData;
+        emit("autoLoginFailed", { error: e, res: resData });
         throw e;
       }
     } catch (autoLoginErr) {
@@ -147,6 +157,7 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       e.error = "Not logged in.";
       e.res = resData;
       e.originalError = autoLoginErr;
+      emit("autoLoginFailed", { error: e, res: resData });
       throw e;
     }
   };
@@ -304,7 +315,9 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
     }
     if (parsed?.error === 1357001) {
       const err = new Error("Facebook blocked the login");
-      err.error = "Not logged in.";
+      err.error = "login_blocked";
+      err.res = parsed;
+      emit("loginBlocked", { res: parsed });
       throw err;
     }
     const resData = parsed;
@@ -313,6 +326,7 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       resStr.includes("XCheckpointFBScrapingWarningController") ||
       resStr.includes("601051028565049")
     ) {
+      emit("checkpoint", { type: "scraping_warning", res: resData });
       return await maybeAutoLogin(resData, res?.config);
     }
     if (
@@ -326,6 +340,8 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       const err = new Error("Checkpoint 282 detected");
       err.error = "checkpoint_282";
       err.res = resData;
+      emit("checkpoint", { type: "282", res: resData });
+      emit("checkpoint_282", { res: resData });
       throw err;
     }
     if (resStr.includes("828281030927956")) {
@@ -333,6 +349,8 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       const err = new Error("Checkpoint 956 detected");
       err.error = "checkpoint_956";
       err.res = resData;
+      emit("checkpoint", { type: "956", res: resData });
+      emit("checkpoint_956", { res: resData });
       throw err;
     }
     return parsed;

package/src/utils/request.js

@@ -85,8 +85,15 @@ const client = wrapper(axios.create({
 
 const delay = ms => new Promise(r => setTimeout(r, ms));
 
-async function requestWithRetry(fn, retries = 3, baseDelay = 1000) {
+async function requestWithRetry(fn, retries = 3, baseDelay = 1000, ctx) {
   let lastError;
+  const emit = (event, payload) => {
+    try {
+      if (ctx && ctx._emitter && typeof ctx._emitter.emit === "function") {
+        ctx._emitter.emit(event, payload);
+      }
+    } catch { }
+  };
   for (let i = 0; i < retries; i++) {
     try {
       return await fn();
@@ -104,6 +111,11 @@ async function requestWithRetry(fn, retries = 3, baseDelay = 1000) {
 
       // Don't retry on client errors (4xx) except 429 (rate limit)
       const status = e?.response?.status || e?.statusCode || 0;
+      const url = e?.config?.url || "";
+      const method = String(e?.config?.method || "").toUpperCase();
+      if (status === 429) {
+        emit("rateLimit", { status, url, method });
+      }
       if (status >= 400 && status < 500 && status !== 429) {
         return e.response || Promise.reject(e);
       }
@@ -111,6 +123,21 @@ async function requestWithRetry(fn, retries = 3, baseDelay = 1000) {
       if (i === retries - 1) {
         return e.response || Promise.reject(e);
       }
+      // Network errors (no status code)
+      const netCode = e?.code || "";
+      const msg = e && e.message ? e.message : String(e || "");
+      if (
+        !status &&
+        (netCode === "UND_ERR_CONNECT_TIMEOUT" ||
+          netCode === "ETIMEDOUT" ||
+          netCode === "ECONNRESET" ||
+          netCode === "ECONNREFUSED" ||
+          netCode === "ENOTFOUND" ||
+          /timeout|connect timeout|network error|fetch failed/i.test(msg))
+      ) {
+        emit("networkError", { code: netCode, message: msg, url, method });
+      }
+
       // Exponential backoff with jitter
       const backoffDelay = Math.min(
         baseDelay * Math.pow(2, i) + Math.floor(Math.random() * 200),
@@ -158,13 +185,13 @@ function isPairArrayList(arr) {
   return Array.isArray(arr) && arr.length > 0 && arr.every(x => Array.isArray(x) && x.length === 2 && typeof x[0] === "string");
 }
 
-function cleanGet(url) {
-  return requestWithRetry(() => client.get(url, cfg()), 3, 1000);
+function cleanGet(url, ctx) {
+  return requestWithRetry(() => client.get(url, cfg()), 3, 1000, ctx);
 }
 
 function get(url, reqJar, qs, options, ctx, customHeader) {
   const headers = getHeaders(url, options, ctx, customHeader);
-  return requestWithRetry(() => client.get(url, cfg({ reqJar, headers, params: qs })), 3, 1000);
+  return requestWithRetry(() => client.get(url, cfg({ reqJar, headers, params: qs })), 3, 1000, ctx);
 }
 
 function post(url, reqJar, form, options, ctx, customHeader) {
@@ -197,7 +224,7 @@ function post(url, reqJar, form, options, ctx, customHeader) {
     data = p.toString();
     headers["Content-Type"] = "application/x-www-form-urlencoded";
   }
-  return requestWithRetry(() => client.post(url, data, cfg({ reqJar, headers })), 3, 1000);
+  return requestWithRetry(() => client.post(url, data, cfg({ reqJar, headers })), 3, 1000, ctx);
 }
 
 async function postFormData(url, reqJar, form, qs, options, ctx) {
@@ -250,7 +277,7 @@ async function postFormData(url, reqJar, form, qs, options, ctx) {
     }
   }
   const headers = { ...getHeaders(url, options, ctx), ...fd.getHeaders() };
-  return requestWithRetry(() => client.post(url, fd, cfg({ reqJar, headers, params: qs })), 3, 1000);
+  return requestWithRetry(() => client.post(url, fd, cfg({ reqJar, headers, params: qs })), 3, 1000, ctx);
 }
 
 function makeDefaults(html, userID, ctx) {

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/LICENSE-MIT

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 DongDev (Donix-VN)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.