nexus-fca 1.0.0

package/index.js

@@ -0,0 +1,361 @@
+"use strict";
+// Nexus-FCA: Advanced and Safe Facebook Chat API (custom build)
+const utils = require("./utils");
+const log = require("npmlog");
+const { execSync } = require('child_process');
+const { promises: fsPromises, readFileSync } = require('fs');
+const fs = require('fs');
+const axios = require('axios');
+const path = require('path');
+const models = require("./lib/database/models");
+const logger = require("./lib/logger");
+const { safeMode, isUserAllowed, rateLimiter } = require('./utils');
+let checkVerified = null;
+const defaultLogRecordSize = 100;
+log.maxRecordSize = defaultLogRecordSize;
+const defaultConfig = {
+  autoUpdate: true,
+  mqtt: {
+    enabled: true,
+    reconnectInterval: 3600,
+  }
+};
+const configPath = path.join(process.cwd(), "fca-config.json");
+let config;
+if (!fs.existsSync(configPath)) {
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+  config = defaultConfig;
+} else {
+  try {
+    const fileContent = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(fileContent);
+    config = { ...defaultConfig, ...config };
+  } catch (err) {
+    logger("Error reading config file, using defaults", "error");
+    config = defaultConfig;
+  }
+}
+global.fca = {
+  config: config
+};
+const Boolean_Option = [
+  "online",
+  "selfListen",
+  "listenEvents",
+  "updatePresence",
+  "forceLogin",
+  "autoMarkDelivery",
+  "autoMarkRead",
+  "listenTyping",
+  "autoReconnect",
+  "emitReady",
+];
+function setOptions(globalOptions, options) {
+  Object.keys(options).map(function (key) {
+    switch (Boolean_Option.includes(key)) {
+      case true: {
+        globalOptions[key] = Boolean(options[key]);
+        break;
+      }
+      case false: {
+        switch (key) {
+          case "pauseLog": {
+            if (options.pauseLog) log.pause();
+            else log.resume();
+            break;
+          }
+          case "logLevel": {
+            log.level = options.logLevel;
+            globalOptions.logLevel = options.logLevel;
+            break;
+          }
+          case "logRecordSize": {
+            log.maxRecordSize = options.logRecordSize;
+            globalOptions.logRecordSize = options.logRecordSize;
+            break;
+          }
+          case "pageID": {
+            globalOptions.pageID = options.pageID.toString();
+            break;
+          }
+          case "userAgent": {
+            globalOptions.userAgent =
+              options.userAgent ||
+              "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
+            break;
+          }
+          case "proxy": {
+            if (typeof options.proxy != "string") {
+              delete globalOptions.proxy;
+              utils.setProxy();
+            } else {
+              globalOptions.proxy = options.proxy;
+              utils.setProxy(globalOptions.proxy);
+            }
+            break;
+          }
+          default: {
+            log.warn(
+              "setOptions",
+              "Unrecognized option given to setOptions: " + key
+            );
+            break;
+          }
+        }
+        break;
+      }
+    }
+  });
+}
+function buildAPI(globalOptions, html, jar) {
+  const cookies = jar.getCookies("https://www.facebook.com");
+  const userCookie = cookies.find(c => c.cookieString().startsWith("c_user="));
+  const tiktikCookie = cookies.find(c => c.cookieString().startsWith("i_user="));
+  if (userCookie.length === 0 && tiktikCookie.length === 0) {
+    return log.error('login', "Không tìm thấy cookie cho người dùng, vui lòng kiểm tra lại thông tin đăng nhập")
+  } else if (!userCookie && !tiktikCookie) {
+    return log.error('login', "Không tìm thấy cookie cho người dùng, vui lòng kiểm tra lại thông tin đăng nhập")
+  } else if (html.includes("/checkpoint/block/?next")) {
+    return log.error('login', "Appstate die, vui lòng thay cái mới!", 'error');
+  }
+  const userID = (tiktikCookie || userCookie).cookieString().split("=")[1];
+  const i_userID = tiktikCookie ? tiktikCookie.cookieString().split("=")[1] : null;
+  logger(`Logged in as ${userID}`, 'info');
+  try {
+    clearInterval(checkVerified);
+  } catch (_) { }
+  const clientID = ((Math.random() * 2147483648) | 0).toString(16);
+  let mqttEndpoint, region, fb_dtsg, irisSeqID;
+  try {
+    const endpointMatch = html.match(/"endpoint":"([^"]+)"/);
+    if (endpointMatch) {
+      mqttEndpoint = endpointMatch[1].replace(/\\\//g, "/");
+      const url = new URL(mqttEndpoint);
+      region = url.searchParams.get("region")?.toUpperCase() || "PRN";
+    }
+    logger(`Sever region ${region}`, 'info');
+  } catch (e) {
+    log.warning("login", "Not MQTT endpoint");
+  }
+  const tokenMatch = html.match(/DTSGInitialData.*?token":"(.*?)"/);
+  if (tokenMatch) {
+    fb_dtsg = tokenMatch[1];
+  }
+  (async () => {
+    try {
+      await models.sequelize.authenticate();
+      await models.syncAll();
+    } catch (error) {
+      console.error(error);
+      console.error('Database connection failed:', error.message);
+    }
+  })();
+  // Professional gradient banner for Nexus-FCA
+  logger('═══════════════════════════════════════════════════════════════════════════════', 'info');
+  logger('        Welcome to Nexus-FCA - Advanced & Safe Facebook Chat API', 'info');
+  logger('═══════════════════════════════════════════════════════════════════════════════', 'info');
+  logger(`Nexus-FCA`, 'info');
+  const ctx = {
+    userID: userID,
+    i_userID: i_userID,
+    jar: jar,
+    clientID: clientID,
+    globalOptions: globalOptions,
+    loggedIn: true,
+    access_token: "NONE",
+    clientMutationId: 0,
+    mqttClient: undefined,
+    lastSeqId: irisSeqID,
+    syncToken: undefined,
+    mqttEndpoint,
+    region,
+    firstListen: true,
+    fb_dtsg,
+    wsReqNumber: 0,
+    wsTaskNumber: 0
+  };
+  const api = {
+    setOptions: setOptions.bind(null, globalOptions),
+    getAppState: function getAppState() {
+      const appState = utils.getAppState(jar);
+      return appState.filter(
+        (item, index, self) =>
+          self.findIndex((t) => {
+            return t.key === item.key;
+          }) === index
+      );
+    },
+    healthCheck: function(callback) {
+      // Simple health check: returns status and safeMode info
+      callback(null, {
+        status: 'ok',
+        safeMode,
+        time: new Date().toISOString(),
+        userID: ctx.userID || null
+      });
+    },
+  };
+  const defaultFuncs = utils.makeDefaults(html, i_userID || userID, ctx);
+  require("fs")
+    .readdirSync(__dirname + "/src/")
+    .filter((v) => v.endsWith(".js"))
+    .map(function (v) {
+      api[v.replace(".js", "")] = require("./src/" + v)(defaultFuncs, api, ctx);
+    });
+  api.listen = api.listenMqtt;
+  setInterval(async () => {
+    api
+      .refreshFb_dtsg()
+      .then(() => {
+        logger("Successfully refreshed fb_dtsg", 'info');
+      })
+      .catch((err) => {
+        console.error("An error occurred while refreshing fb_dtsg", err);
+      });
+  }, 1000 * 60 * 60 * 24);
+  return {
+    ctx,
+    defaultFuncs,
+    api
+  };
+}
+
+function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
+  let mainPromise = null;
+  const jar = utils.getJar();
+  if (appState) {
+    try {
+      appState = JSON.parse(appState);
+    } catch (e) {
+      try {
+        appState = appState;
+      } catch (e) {
+        return callback(new Error("Failed to parse appState"));
+      }
+    }
+
+    try {
+      appState.forEach(c => {
+        const str = `${c.key}=${c.value}; expires=${c.expires}; domain=${c.domain}; path=${c.path};`;
+        jar.setCookie(str, "http://" + c.domain);
+      });
+
+      mainPromise = utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
+        .then(utils.saveCookies(jar));
+    } catch (e) {
+      process.exit(0);
+    }
+  } else {
+    mainPromise = utils
+      .get("https://www.facebook.com/", null, null, globalOptions, { noRef: true })
+      .then(utils.saveCookies(jar))
+      .then(makeLogin(jar, email, password, globalOptions, callback, prCallback))
+      .then(() => utils.get('https://www.facebook.com/', jar, null, globalOptions).then(utils.saveCookies(jar)));
+  }
+
+  function handleRedirect(res) {
+    const reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+    const redirect = reg.exec(res.body);
+    if (redirect && redirect[1]) {
+      return utils.get(redirect[1], jar, null, globalOptions).then(utils.saveCookies(jar));
+    }
+    return res;
+  }
+
+  let ctx, api;
+  mainPromise = mainPromise
+    .then(handleRedirect)
+    .then(res => {
+      const mobileAgentRegex = /MPageLoadClientMetrics/gs;
+      if (!mobileAgentRegex.test(res.body)) {
+        globalOptions.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36";
+        return utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true }).then(utils.saveCookies(jar));
+      }
+      return res;
+    })
+    .then(handleRedirect)
+    .then(res => {
+      const html = res.body;
+      const Obj = buildAPI(globalOptions, html, jar);
+      ctx = Obj.ctx;
+      api = Obj.api;
+      return res;
+    });
+
+  if (globalOptions.pageID) {
+    mainPromise = mainPromise
+      .then(() => utils.get(`https://www.facebook.com/${globalOptions.pageID}/messages/?section=messages&subsection=inbox`, jar, null, globalOptions))
+      .then(resData => {
+        let url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
+        url = url.substring(0, url.length - 1);
+        return utils.get('https://www.facebook.com' + url, jar, null, globalOptions);
+      });
+  }
+
+  mainPromise
+    .then(async () => {
+      // Version check and auto-update code removed for safety and to prevent error spam.
+      logger('Login successful!', '[ Nexus-FCA ] >');
+      callback(null, api);
+    })
+    .catch(e => {
+      callback(e);
+    });
+}
+
+function login(loginData, options, callback) {
+  if (
+    utils.getType(options) === "Function" ||
+    utils.getType(options) === "AsyncFunction"
+  ) {
+    callback = options;
+    options = {};
+  }
+  const globalOptions = {
+    selfListen: false,
+    selfListenEvent: false,
+    listenEvents: false,
+    listenTyping: false,
+    updatePresence: false,
+    forceLogin: false,
+    autoMarkDelivery: true,
+    autoMarkRead: false,
+    autoReconnect: true,
+    logRecordSize: defaultLogRecordSize,
+    online: true,
+    emitReady: false,
+    userAgent:
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+  };
+  setOptions(globalOptions, options);
+  let prCallback = null;
+  if (
+    utils.getType(callback) !== "Function" &&
+    utils.getType(callback) !== "AsyncFunction"
+  ) {
+    let rejectFunc = null;
+    let resolveFunc = null;
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    prCallback = function (error, api) {
+      if (error) {
+        return rejectFunc(error);
+      }
+      return resolveFunc(api);
+    };
+    callback = prCallback;
+  }
+  loginHelper(
+    loginData.appState,
+    loginData.email,
+    loginData.password,
+    globalOptions,
+    callback,
+    prCallback
+  );
+  return returnPromise;
+}
+
+module.exports = login;

package/lib/database/models/index.js

@@ -0,0 +1,47 @@
+const { Sequelize } = require('sequelize');
+const fs = require('fs');
+const path = require('path');
+const databasePath = path.join(process.cwd(), 'Fca_Database');
+if (!fs.existsSync(databasePath)) {
+  fs.mkdirSync(databasePath, { recursive: true });
+}
+const sequelize = new Sequelize({
+  dialect: 'sqlite',
+  storage: path.join(databasePath, 'database.sqlite'),
+  logging: false,
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  },
+  retry: {
+    max: 3
+  },
+  dialectOptions: {
+    timeout: 5000
+  },
+  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
+});
+const models = {};
+fs.readdirSync(__dirname).filter(file => file.endsWith('.js') && file !== 'index.js').forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize);
+    models[model.name] = model;
+  });
+Object.keys(models).forEach(modelName => {
+  if (models[modelName].associate) {
+    models[modelName].associate(models);
+  }
+});
+models.sequelize = sequelize;
+models.Sequelize = Sequelize;
+models.syncAll = async () => {
+  try {
+    await sequelize.sync({ force: false }); 
+  } catch (error) {
+    console.error('Failed to synchronize models:', error);
+    throw error;
+  }
+};
+
+module.exports = models;

package/lib/database/models/thread.js

@@ -0,0 +1,31 @@
+module.exports = function(sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class Thread extends Model {}
+
+  Thread.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+      },
+      threadID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      data: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+      }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true,
+    }
+  );
+  return Thread;
+};

package/lib/database/threadData.js

@@ -0,0 +1,93 @@
+const { Thread } = require('./models');
+
+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.');
+  }
+};
+
+module.exports = function (bot) {
+  return {
+    async create(threadID, data) {
+      try {
+        let thread = await Thread.findOne({ where: { threadID } });
+        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}`);
+      }
+    },
+
+    async get(threadID) {
+      try {
+        threadID = validateThreadID(threadID);
+        const thread = await Thread.findOne({ where: { threadID } });
+        return thread ? thread.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get thread: ${error.message}`);
+      }
+    },
+
+    async update(threadID, data) {
+      try {
+        threadID = validateThreadID(threadID);
+        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}`);
+      }
+    },
+
+    async del(threadID) {
+      try {
+        if (!threadID) {
+          throw new Error('threadID is required and cannot be undefined');
+        }
+        threadID = validateThreadID(threadID);
+        if (!threadID) {
+          throw new Error('Invalid threadID');
+        }
+        const result = await Thread.destroy({ where: { 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}`);
+      }
+    },
+    async delAll() {
+      try {
+        return await Thread.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all threads: ${error.message}`);
+      }
+    },
+    async getAll(keys = null) {
+      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}`);
+      }
+    },
+  };
+};

package/lib/logger.js

@@ -0,0 +1,24 @@
+const chalk = require('chalk');
+const gradient = require('gradient-string');
+
+// Use a professional gradient for info logs
+const infoGradient = gradient(['#00c6ff', '#0072ff']); // blue-cyan gradient
+const warnColor = chalk.yellow.bold;
+const errorColor = chalk.red.bold;
+
+module.exports = (text, type) => {
+  switch (type) {
+    case "warn":
+      process.stderr.write(warnColor(`\r[ NEXUS-FCA WARN ] > ${text}`) + '\n');
+      break;
+    case "error":
+      process.stderr.write(errorColor(`\r[ NEXUS-FCA ERROR ] > ${text}`) + '\n');
+      break;
+    case "info":
+      process.stderr.write(infoGradient(`\r[ NEXUS-FCA ] > ${text}`) + '\n');
+      break;
+    default:
+      process.stderr.write(infoGradient(`\r[ NEXUS-FCA ] > ${text}`) + '\n');
+      break;
+  }
+};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "nexus-fca",
+  "version": "1.0.0",
+  "description": "A modern, safe, and advanced Facebook Chat API for Node.js. Messenger automation, bots, and integrations made easy.",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AlAminNexus/nexus-fca.git"
+  },
+  "author": "Al Amin",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "bluebird": "^3.7.2",
+    "chalk": "^4.1.2",
+    "cheerio": "^1.0.0-rc.10",
+    "duplexify": "^4.1.3",
+    "gradient-string": "^2.0.2",
+    "https-proxy-agent": "^4.0.0",
+    "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"
+  },
+  "devDependencies": {
+    "eslint": "^7.5.0",
+    "mocha": "^10.2.0",
+    "prettier": "^1.11.1"
+  },
+  "scripts": {
+    "test": "mocha",
+    "lint": "eslint **/*.js",
+    "prettier": "prettier utils.js src/* --write"
+  },
+  "keywords": [
+    "facebook",
+    "chat",
+    "api",
+    "fca",
+    "facebook-chat-api"
+  ],
+  "engines": {
+    "node": ">=10.x"
+  },
+  "eslintConfig": {
+    "env": {
+      "es6": true,
+      "es2017": true,
+      "node": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "sourceType": "module"
+    },
+    "rules": {
+      "linebreak-style": [
+        "error",
+        "unix"
+      ],
+      "semi": [
+        "error",
+        "always"
+      ],
+      "no-unused-vars": [
+        1,
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_"
+        }
+      ],
+      "no-empty": [
+        "error",
+        {
+          "allowEmptyCatch": true
+        }
+      ]
+    }
+  },
+  "types": "index.d.ts",
+  "homepage": "https://github.com/Nexus-016/Nexus-fCA#readme",
+  "bugs": {
+    "url": "https://github.com/Nexus-016/Nexus-fCA/issues"
+  },
+  "directories": {
+    "test": "test"
+  }
+}

package/src/addExternalModule.js

@@ -0,0 +1,19 @@
+"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)}!`);
+		}
+	};
+};