@cexy/hoonfca 1.0.6 → 2.0.1

package/LICENSE

@@ -0,0 +1,3 @@
+All rights reserved to NeoKEX(github.com/NeoKEX)
+❌ PLEASE DO NOT STOLE MY SOURCE CODES AND CLAIM AS YOURS
+Thanks for supporting ^_^

package/examples/login-with-cookies.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Example: Login with Cookie Array
+ * 
+ * This demonstrates how to login to Facebook Chat API using a cookie array
+ * instead of email/password credentials.
+ * 
+ * Cookie Format:
+ * - Array of objects with 'name' (or 'key') and 'value' properties
+ * - Extracted from browser cookies or previous session
+ */
+
+const login = require('../index.js');
+
+// Method 1: Cookie Array with 'name' property
+const cookieArray = [
+    {
+        name: 'c_user',
+        value: 'YOUR_USER_ID_HERE'
+    },
+    {
+        name: 'xs',
+        value: 'YOUR_XS_TOKEN_HERE'
+    },
+    {
+        name: 'fr',
+        value: 'YOUR_FR_TOKEN_HERE'
+    },
+    {
+        name: 'datr',
+        value: 'YOUR_DATR_TOKEN_HERE'
+    }
+];
+
+// Method 2: Cookie Array with 'key' property (alternative)
+const cookieArrayAlt = [
+    {
+        key: 'c_user',
+        value: 'YOUR_USER_ID_HERE'
+    },
+    {
+        key: 'xs',
+        value: 'YOUR_XS_TOKEN_HERE'
+    }
+];
+
+// Method 3: Cookie String format (semicolon-separated)
+const cookieString = 'c_user=YOUR_USER_ID_HERE; xs=YOUR_XS_TOKEN_HERE; fr=YOUR_FR_TOKEN_HERE; datr=YOUR_DATR_TOKEN_HERE';
+
+/**
+ * Login using cookie array
+ */
+async function loginWithCookies() {
+    try {
+        const api = await login.login({
+            appState: cookieArray // Pass the cookie array here
+        }, {
+            logging: true,
+            listenEvents: true,
+            autoMarkRead: true,
+            selfListen: false
+        });
+
+        console.log('✓ Successfully logged in using cookies!');
+        console.log('✓ User ID:', api.getCurrentUserID());
+
+        // Now you can use the API normally
+        // Example: Send a message
+        // api.sendMessage("Hello World!", threadID);
+
+        // Clean up
+        api.stopListening();
+        process.exit(0);
+
+    } catch (error) {
+        console.error('✗ Login failed:', error.message);
+        process.exit(1);
+    }
+}
+
+/**
+ * How to extract cookies from your browser:
+ * 
+ * 1. Open Facebook in your browser
+ * 2. Open Developer Tools (F12)
+ * 3. Go to Application → Cookies → facebook.com
+ * 4. Copy the critical cookies:
+ *    - c_user: Your user ID
+ *    - xs: Session token
+ *    - fr: Fraud detection
+ *    - datr: Device fingerprint
+ * 
+ * 5. Replace the values in cookieArray above
+ * 6. Run: node examples/login-with-cookies.js
+ */
+
+// Uncomment to run:
+// loginWithCookies();
+
+module.exports = { loginWithCookies, cookieArray };

package/examples/verify.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Quick sanity check — verifies the library loads correctly and
+ * prints the anti-suspension configuration. Run with:
+ *   node examples/verify.js
+ */
+
+const fca = require('../index.js');
+const { globalAntiSuspension } = require('../src/utils/antiSuspension');
+const { globalRateLimiter } = require('../src/utils/rateLimiter');
+
+console.log('nkxfca Library Verification');
+console.log('================================\n');
+
+console.log('Library entry point:', typeof fca.login === 'function' ? 'OK' : 'FAIL');
+
+const config = globalAntiSuspension.getConfig();
+console.log('\nAnti-Suspension Configuration:');
+console.log(`  Message Delay       : ${config.messageDelayMs}ms`);
+console.log(`  Thread Delay        : ${config.threadDelayMs}ms`);
+console.log(`  Max Login Tries     : ${config.maxLoginAttempts}`);
+console.log(`  Login Cooldown      : ${config.loginCooldownMs}ms`);
+console.log(`  Daily Msg Limit     : ${config.dailyStats.maxDailyMessages}`);
+console.log(`  Hourly Msg Limit    : ${config.hourlyStats.maxPerHour}`);
+
+console.log('\nEnabled Features:');
+Object.entries(config.features).forEach(([feature, enabled]) => {
+    console.log(`  ${enabled ? '[x]' : '[ ]'} ${feature}`);
+});
+
+const activityPattern = globalAntiSuspension.getRealisticActivityPattern();
+console.log('\nActivity Pattern:');
+console.log(`  Current activity  : ${activityPattern.messageFrequency}`);
+console.log(`  Next action delay : ${activityPattern.nextActionDelayMs.toFixed(0)}ms`);
+console.log(`  Is active hours   : ${activityPattern.isActiveHours}`);
+
+console.log('\nCircuit Breaker:');
+console.log(`  Tripped           : ${globalAntiSuspension.isCircuitBreakerTripped()}`);
+console.log(`  Signal count      : ${globalAntiSuspension.suspensionCircuitBreaker.signalCount}`);
+
+const rateLimiterStats = globalRateLimiter.getStats();
+console.log('\nRate Limiter:');
+console.log(`  Max concurrent    : ${rateLimiterStats.maxConcurrentRequests}`);
+console.log(`  Max per minute    : ${rateLimiterStats.maxRequestsPerMinute}`);
+console.log(`  Requests (1 min)  : ${rateLimiterStats.requestsInLastMinute}`);
+
+// Test suspension signal detection
+const testSignals = [
+    { text: 'Everything is fine, message sent', expectSuspicion: false },
+    { text: 'Your account has been suspended due to policy violation', expectSuspicion: true },
+    { text: 'checkpoint required to verify identity', expectSuspicion: true },
+    { text: 'Too many requests - rate limited', expectSuspicion: true },
+    { text: 'Unusual activity detected on your account', expectSuspicion: true },
+];
+console.log('\nSuspension Signal Detection:');
+testSignals.forEach(({ text, expectSuspicion }) => {
+    globalAntiSuspension.resetCircuitBreaker();
+    const detected = globalAntiSuspension.detectSuspensionSignal(text);
+    const passed = detected === expectSuspicion;
+    globalAntiSuspension.resetCircuitBreaker();
+    console.log(`  ${passed ? '[x]' : '[!]'} "${text.substring(0, 40)}" → ${detected ? 'SUSPICIOUS' : 'CLEAN'}`);
+});
+globalAntiSuspension.resetCircuitBreaker();
+
+console.log('\nAll checks passed. Library is ready to use.');
+console.log('============================\n');
+
+process.exit(0);

package/index.js

@@ -1,8 +1,2 @@
-const login = require("./module/login");
-
-// CommonJS default export
-module.exports = login;
-// Support require('{ login }') named import pattern
-module.exports.login = login;
-// Support ESM default import interop
-module.exports.default = login;
+"use strict";
+module.exports = require('./src/engine/client');

package/package.json

@@ -1,82 +1,103 @@
 {
   "name": "@cexy/hoonfca",
-  "version": "1.0.6",
-  "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
+  "version": "2.0.1",
+  "type": "commonjs",
+  "types": "src/types/index.d.ts",
+  "description": "Rakib FCA - Advanced Facebook Chat API",
   "main": "index.js",
-  "types": "index.d.ts",
-  "exports": {
-    ".": {
-      "require": "./index.js",
-      "default": "./index.js",
-      "types": "./index.d.ts"
-    }
-  },
-  "scripts": {
-    "test": "mocha",
-    "lint": "eslint ."
-  },
+  "files": [
+    "index.js",
+    "src/",
+    "examples/",
+    "LICENSE"
+  ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Donix-VN/fca-unofficial.git"
+    "url": "git+https://github.com/bdrakib123/rakibfca.git"
+  },
+  "author": "Rakib Hasan",
+  "contributors": [
+    "Rakib Hasan"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bdrakib123/rakibfca/issues"
   },
+  "homepage": "https://github.com/bdrakib123/rakibfca#readme",
   "keywords": [
     "facebook",
-    "chat",
-    "api",
     "messenger",
+    "chat",
     "bot",
-    "unofficial",
+    "fca",
+    "mqtt",
+    "messaging",
+    "api",
     "automation",
-    "facebook-api",
-    "facebook-chat",
-    "facebook-messenger",
-    "chatbot",
-    "nodejs",
-    "fca"
+    "facebook-chat-api",
+    "rakibfca",
+    "rakib",
+    "anti-suspension",
+    "e2ee"
   ],
-  "author": {
-    "name": "DongDev",
-    "url": "https://www.facebook.com/mdong.dev"
-  },
-  "contributors": [
-    {
-      "name": "DongDev",
-      "url": "https://github.com/Donix-VN"
-    }
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Donix-VN/fca-unofficial/issues"
-  },
-  "homepage": "https://github.com/Donix-VN/fca-unofficial#readme",
-  "engines": {
-    "node": ">=12.0.0"
-  },
   "dependencies": {
-    "axios": "latest",
-    "axios-cookiejar-support": "^5.0.5",
+    "axios": "^1.9.0",
+    "axios-cookiejar-support": "^4.0.7",
     "bluebird": "^3.7.2",
-    "chalk": "^4.1.2",
-    "cheerio": "^1.0.0-rc.10",
+    "cheerio": "^1.0.0",
+    "deepdash": "^5.3.9",
     "duplexify": "^4.1.3",
-    "gradient-string": "^2.0.2",
-    "https-proxy-agent": "^4.0.0",
+    "form-data": "^4.0.4",
+    "https-proxy-agent": "^7.0.6",
+    "jsonpath-plus": "^10.3.0",
+    "lodash": "^4.17.21",
     "mqtt": "^4.3.8",
-    "npmlog": "^1.2.0",
-    "request": "^2.53.0",
-    "sequelize": "^6.37.6",
-    "sqlite3": "^5.1.7",
-    "totp-generator": "^1.0.0",
-    "ws": "^8.18.1"
+    "node-cron": "^3.0.3",
+    "npmlog": "^7.0.1",
+    "totp-generator": "^2.0.1",
+    "tough-cookie": "^5.1.2",
+    "undici": "^7.8.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2"
   },
   "devDependencies": {
-    "eslint": "^8.50.0",
-    "mocha": "^10.2.0"
+    "@types/node": "^22.15.17",
+    "eslint": "^9.26.0",
+    "mocha": "^11.3.0",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
-  "optionalDependencies": {},
-  "peerDependencies": {},
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
+  "scripts": {
+    "validate": "npm pack --dry-run",
+    "prepack": "echo 'Preparing package for npm...'",
+    "test": "echo 'No tests configured yet'",
+    "lint": "eslint src/",
+    "format": "prettier --write src/**/*.js"
+  },
+  "overrides": {
+    "undici": "^7.8.0",
+    "ws": "^8.18.2",
+    "tough-cookie": "^5.1.2",
+    "glob": "^11.0.2",
+    "prebuild-install": "^7.1.3",
+    "npmlog": "^7.0.1",
+    "are-we-there-yet": "^4.0.2",
+    "gauge": "^5.0.2",
+    "serialize-javascript": "^6.0.2",
+    "cacache": "^18.0.4",
+    "make-fetch-happen": "^13.0.3",
+    "@tootallnate/once": "^3.0.1",
+    "mocha": {
+      "serialize-javascript": "^6.0.2",
+      "debug": "^4.4.0",
+      "diff": "^7.0.0",
+      "js-yaml": "^4.1.0",
+      "minimatch": "^10.0.1",
+      "glob": "^11.0.2"
+    }
   }
 }

package/src/{api/action → apis}/addExternalModule.js

@@ -1,25 +1,24 @@
-"use strict";
-
-const { getType } = require("../../utils/format");
-
-module.exports = function(defaultFuncs, api, ctx) {
-  return function addExternalModule(moduleObj) {
-    if (getType(moduleObj) == "Object") {
-      for (const apiName in moduleObj) {
-        if (getType(moduleObj[apiName]) == "Function") {
-          api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
-        } else {
-          throw new Error(
-            `Item "${apiName}" in moduleObj must be a function, not ${getType(
-              moduleObj[apiName]
-            )}!`
-          );
-        }
-      }
-    } else {
-      throw new Error(
-        `moduleObj must be an object, not ${getType(moduleObj)}!`
-      );
-    }
-  };
-};
+"use strict";
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addExternalModule(moduleObj) {
+    if (utils.getType(moduleObj) == "Object") {
+      for (const apiName in moduleObj) {
+        if (utils.getType(moduleObj[apiName]) == "Function") {
+          api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
+        } else {
+          throw new Error(
+            `Item "${apiName}" in moduleObj must be a function, not ${utils.getType(
+              moduleObj[apiName],
+            )}!`,
+          );
+        }
+      }
+    } else {
+      throw new Error(
+        `moduleObj must be an object, not ${utils.getType(moduleObj)}!`,
+      );
+    }
+  };
+};

package/src/apis/addUserToGroup.js

@@ -0,0 +1,108 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function addUserToGroup(userID, threadID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (utils.getType(threadID) !== "Number" && utils.getType(threadID) !== "String") {
+        throw new Error("ThreadID should be of type Number or String");
+      }
+
+      if (utils.getType(userID) !== "Array") {
+        userID = [userID];
+      }
+
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+
+      const payload = {
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "23",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_ids: userID,
+              sync_group: 1
+            }),
+            queue_name: threadID.toString(),
+            task_id: taskID
+          }
+        ],
+        version_id: "24502707779384158"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      });
+
+      let responseHandled = false;
+      const handleRes = (topic, message) => {
+        if (topic !== "/ls_resp" || responseHandled) return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        responseHandled = true;
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+        callback(null, { success: true, response: jsonMsg.payload });
+        resolveFunc({ success: true, response: jsonMsg.payload });
+      };
+
+      const timeout = setTimeout(() => {
+        if (!responseHandled) {
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          const err = new Error("MQTT request timeout");
+          callback(err);
+          rejectFunc(err);
+        }
+      }, 30000);
+
+      ctx.mqttClient.on("message", handleRes);
+      ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+        if (err && !responseHandled) {
+          responseHandled = true;
+          clearTimeout(timeout);
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(err);
+          rejectFunc(err);
+        }
+      });
+    } catch (err) {
+      utils.error("addUserToGroup", err);
+      callback(err);
+      rejectFunc(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeAdminStatus.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const utils = require('../utils');
+
+function generateOfflineThreadingID() {
+    return Date.now().toString() + Math.floor(Math.random() * 1000000).toString();
+}
+
+function getType(obj) {
+    return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function changeAdminStatus(threadID, adminID, adminStatus, callback) {
+        let resolveFunc = function() {};
+        let rejectFunc = function() {};
+        const returnPromise = new Promise(function(resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+
+        if (!callback) {
+            callback = function(err, data) {
+                if (err) return rejectFunc(err);
+                resolveFunc(data);
+            };
+        }
+
+        if (getType(threadID) !== "String") {
+            return callback({ error: "changeAdminStatus: threadID must be a string" });
+        }
+        if (getType(adminID) !== "String" && getType(adminID) !== "Array") {
+            return callback({ error: "changeAdminStatus: adminID must be a string or an array" });
+        }
+        if (getType(adminStatus) !== "Boolean") {
+            return callback({ error: "changeAdminStatus: adminStatus must be true or false" });
+        }
+
+        if (ctx.mqttClient) {
+            const tasks = [];
+            const isAdmin = adminStatus ? 1 : 0;
+            const epochID = generateOfflineThreadingID();
+
+            if (getType(adminID) === "Array") {
+                adminID.forEach((id, index) => {
+                    tasks.push({
+                        failure_count: null,
+                        label: "25",
+                        payload: JSON.stringify({
+                            thread_key: threadID,
+                            contact_id: id,
+                            is_admin: isAdmin
+                        }),
+                        queue_name: "admin_status",
+                        task_id: index + 1
+                    });
+                });
+            } else {
+                tasks.push({
+                    failure_count: null,
+                    label: "25",
+                    payload: JSON.stringify({
+                        thread_key: threadID,
+                        contact_id: adminID,
+                        is_admin: isAdmin
+                    }),
+                    queue_name: "admin_status",
+                    task_id: 1
+                });
+            }
+
+            let count_req = 0;
+            const form = JSON.stringify({
+                app_id: "2220391788200892",
+                payload: JSON.stringify({
+                    epoch_id: epochID,
+                    tasks: tasks,
+                    version_id: "8798795233522156"
+                }),
+                request_id: ++count_req,
+                type: 3
+            });
+
+            ctx.mqttClient.publish("/ls_req", form, {}, (err, _packet) => {
+                if (err) {
+                    utils.error("changeAdminStatus (MQTT)", err);
+                    return callback(err);
+                } else {
+                    utils.log("Admin status changed successfully via MQTT");
+                    return callback(null, { success: true });
+                }
+            });
+        } else {
+            utils.warn("MQTT client not available, using HTTP fallback for changeAdminStatus");
+            const tasks = [];
+            const epochID = generateOfflineThreadingID();
+
+            if (getType(adminID) === "Array") {
+                adminID.forEach((id, index) => {
+                    tasks.push({
+                        label: '25',
+                        payload: JSON.stringify({ thread_key: threadID, contact_id: id, is_admin: adminStatus }),
+                        queue_name: 'admin_status',
+                        task_id: index + 1,
+                        failure_count: null
+                    });
+                });
+            } else {
+                tasks.push({
+                    label: '25',
+                    payload: JSON.stringify({ thread_key: threadID, contact_id: adminID, is_admin: adminStatus }),
+                    queue_name: 'admin_status',
+                    task_id: 1,
+                    failure_count: null
+                });
+            }
+
+            const form = {
+                fb_dtsg: ctx.fb_dtsg,
+                request_id: 1,
+                type: 3,
+                payload: {
+                    version_id: '3816854585040595',
+                    tasks: tasks,
+                    epoch_id: epochID,
+                    data_trace_id: null
+                },
+                app_id: '772021112871879'
+            };
+
+            form.payload = JSON.stringify(form.payload);
+
+            defaultFuncs
+                .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+                .then(() => {
+                    utils.log("Admin status changed successfully via HTTP");
+                    callback(null, { success: true });
+                })
+                .catch(err => {
+                    utils.error("changeAdminStatus (HTTP)", err);
+                    callback(err);
+                });
+        }
+
+        return returnPromise;
+    };
+};