@dongdev/fca-unofficial 3.0.30 → 4.0.0

package/fca-config.example.json

@@ -0,0 +1,33 @@
+{
+  "autoUpdate": true,
+  "checkUpdate": {
+    "enabled": true,
+    "install": false,
+    "notifyIfCurrent": false,
+    "packageName": "@dongdev/fca-unofficial",
+    "registryUrl": "https://registry.npmjs.org",
+    "timeoutMs": 10000
+  },
+  "mqtt": {
+    "enabled": true,
+    "reconnectInterval": 3600
+  },
+  "autoLogin": true,
+  "apiServer": "https://donixdev.com",
+  "apiKey": "",
+  "credentials": {
+    "email": "",
+    "password": "",
+    "twofactor": ""
+  },
+  "antiGetInfo": {
+    "AntiGetThreadInfo": false,
+    "AntiGetUserInfo": false
+  },
+  "remoteControl": {
+    "enabled": false,
+    "url": "",
+    "token": "",
+    "autoReconnect": true
+  }
+}

package/package.json

@@ -1,30 +1,32 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "3.0.30",
+  "version": "4.0.0",
   "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "default": "./index.js",
-      "types": "./index.d.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.js"
     }
   },
   "files": [
-    "index.js",
-    "index.d.ts",
-    "module/",
-    "func/",
-    "src/",
-    "DOCS.md",
+    "dist/",
+    "docs/",
     "README.md",
+    "test/",
     "LICENSE",
-    "CHANGELOG.md"
+    "fca-config.example.json"
   ],
   "scripts": {
-    "test": "mocha",
-    "lint": "eslint ."
+    "test": "node ./test/fca.test.cjs",
+    "test:build": "npm run build && node ./test/fca.test.cjs",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean --out-dir dist --external gradient-string",
+    "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly"
   },
   "repository": {
     "type": "git",
@@ -46,8 +48,8 @@
     "fca"
   ],
   "author": {
-    "name": "DongDev",
-    "url": "https://www.facebook.com/mdong.dev"
+    "name": "Donix",
+    "url": "https://www.facebook.com/minhdong.dev"
   },
   "contributors": [
     {
@@ -55,31 +57,40 @@
       "url": "https://github.com/dongp06"
     }
   ],
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/dongp06/fca-unofficial/issues"
   },
   "homepage": "https://github.com/dongp06/fca-unofficial#readme",
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=14.0.0"
   },
   "dependencies": {
     "axios": "^1.13.5",
     "axios-cookiejar-support": "^5.0.5",
     "bluebird": "^3.7.2",
-    "chalk": "^4.1.2",
+    "boxen": "^8.0.1",
     "cheerio": "^1.0.0-rc.10",
+    "cli-progress": "^3.12.0",
     "duplexify": "^4.1.3",
-    "gradient-string": "^2.0.2",
+    "gradient-string": "^3.0.0",
     "https-proxy-agent": "^4.0.0",
     "mqtt": "^4.3.8",
+    "ora": "^9.3.0",
+    "picocolors": "^1.1.1",
     "sequelize": "^6.37.6",
+    "sqlite3": "^5.1.7",
     "totp-generator": "^1.0.0",
     "ws": "^8.18.1"
   },
   "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/duplexify": "^3.6.5",
+    "@types/node": "^24.6.1",
+    "@types/ws": "^8.18.1",
     "eslint": "^8.50.0",
-    "mocha": "^10.2.0"
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public",

package/test/fca.test.cjs

@@ -0,0 +1,533 @@
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const fca = require("../dist/index.js");
+
+const tests = [];
+const COOKIE_ATTRIBUTE_KEYS = new Set([
+  "domain",
+  "path",
+  "expires",
+  "max-age",
+  "secure",
+  "httponly",
+  "samesite",
+  "priority",
+  "partitioned"
+]);
+
+function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+function toCookiePair(name, value) {
+  const cookieName = String(name || "").trim();
+  if (!cookieName) {
+    return null;
+  }
+
+  const cookieValue = value === undefined || value === null ? "" : String(value).trim();
+  return `${cookieName}=${cookieValue}`;
+}
+
+function dedupeCookiePairs(pairs) {
+  const latestByName = new Map();
+
+  for (const pair of pairs) {
+    const normalized = String(pair || "").trim();
+    const eqIndex = normalized.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+
+    const name = normalized.slice(0, eqIndex).trim();
+    if (!name) {
+      continue;
+    }
+
+    latestByName.set(name, `${name}=${normalized.slice(eqIndex + 1).trim()}`);
+  }
+
+  return [...latestByName.values()];
+}
+
+function parseCookieHeaderString(raw) {
+  let header = String(raw || "").trim();
+  if (!header) {
+    return [];
+  }
+
+  if (/^cookie\s*:/i.test(header)) {
+    header = header.replace(/^cookie\s*:/i, "").trim();
+  }
+
+  const pairs = [];
+  for (const segment of header.split(/[;\r\n]+/)) {
+    const token = segment.trim();
+    const eqIndex = token.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+
+    const name = token.slice(0, eqIndex).trim();
+    if (!name || COOKIE_ATTRIBUTE_KEYS.has(name.toLowerCase())) {
+      continue;
+    }
+
+    const value = token.slice(eqIndex + 1).trim().replace(/^"(.*)"$/, "$1");
+    const pair = toCookiePair(name, value);
+    if (pair) {
+      pairs.push(pair);
+    }
+  }
+
+  return dedupeCookiePairs(pairs);
+}
+
+function parseNetscapeCookieText(raw) {
+  const pairs = [];
+  const lines = String(raw || "").split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    const normalized = trimmed.replace(/^#HttpOnly_/, "");
+    if (normalized.startsWith("#")) {
+      continue;
+    }
+
+    const columns = normalized.split("\t");
+    if (columns.length < 7) {
+      continue;
+    }
+
+    const name = columns[5];
+    const value = columns.slice(6).join("\t");
+    const pair = toCookiePair(name, value);
+    if (pair) {
+      pairs.push(pair);
+    }
+  }
+
+  return dedupeCookiePairs(pairs);
+}
+
+function normalizeCookiePayload(payload) {
+  if (!payload) {
+    return null;
+  }
+
+  if (typeof payload === "string") {
+    const netscapePairs = parseNetscapeCookieText(payload);
+    if (netscapePairs.length) {
+      return netscapePairs.join("; ");
+    }
+
+    const headerPairs = parseCookieHeaderString(payload);
+    if (headerPairs.length) {
+      return headerPairs.join("; ");
+    }
+
+    return null;
+  }
+
+  if (Array.isArray(payload)) {
+    const pairs = [];
+
+    for (const entry of payload) {
+      if (typeof entry === "string") {
+        const stringPairs = parseCookieHeaderString(entry);
+        if (stringPairs.length) {
+          pairs.push(...stringPairs);
+          continue;
+        }
+
+        const eqIndex = entry.indexOf("=");
+        if (eqIndex > 0) {
+          const pair = toCookiePair(entry.slice(0, eqIndex), entry.slice(eqIndex + 1));
+          if (pair) {
+            pairs.push(pair);
+          }
+        }
+        continue;
+      }
+
+      if (entry && typeof entry === "object") {
+        const pair = toCookiePair(entry.name || entry.key, entry.value);
+        if (pair) {
+          pairs.push(pair);
+        }
+      }
+    }
+
+    const deduped = dedupeCookiePairs(pairs);
+    return deduped.length ? deduped.join("; ") : null;
+  }
+
+  if (typeof payload === "object") {
+    if (payload.Cookie || payload.cookie || payload.cookies) {
+      return normalizeCookiePayload(payload.Cookie || payload.cookie || payload.cookies);
+    }
+
+    if ((payload.name || payload.key) && Object.prototype.hasOwnProperty.call(payload, "value")) {
+      return toCookiePair(payload.name || payload.key, payload.value);
+    }
+
+    const pairs = [];
+    for (const [name, value] of Object.entries(payload)) {
+      if (value === undefined || value === null || typeof value === "object") {
+        continue;
+      }
+
+      const pair = toCookiePair(name, value);
+      if (pair) {
+        pairs.push(pair);
+      }
+    }
+
+    const deduped = dedupeCookiePairs(pairs);
+    return deduped.length ? deduped.join("; ") : null;
+  }
+
+  return null;
+}
+
+function loadCookieCredentials(candidate, sourceLabel) {
+  if (!fs.existsSync(candidate)) {
+    return null;
+  }
+
+  const raw = fs.readFileSync(candidate, "utf8").trim();
+  if (!raw) {
+    return null;
+  }
+
+  let payload = raw;
+  if (candidate.endsWith(".json")) {
+    payload = JSON.parse(raw);
+  }
+
+  const cookieHeader = normalizeCookiePayload(payload);
+  if (!cookieHeader) {
+    return null;
+  }
+
+  return {
+    mode: "cookie",
+    source: sourceLabel,
+    credentials: {
+      Cookie: cookieHeader
+    }
+  };
+}
+
+function readJsonFileIfValid(candidate) {
+  if (!fs.existsSync(candidate)) {
+    return null;
+  }
+
+  const raw = fs.readFileSync(candidate, "utf8");
+  if (!raw.trim()) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function loadIntegrationCredentials() {
+  const rootDir = process.cwd();
+  const cookieCandidates = [
+    path.join(rootDir, "cookie.txt"),
+    path.join(rootDir, "cookies.txt"),
+    path.join(rootDir, "cookie.json"),
+    path.join(rootDir, "cookies.json"),
+    path.join(rootDir, "test", "cookie.txt"),
+    path.join(rootDir, "test", "cookie.json")
+  ];
+
+  for (const candidate of cookieCandidates) {
+    const loaded = loadCookieCredentials(candidate, path.relative(rootDir, candidate) || candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+
+  const appStateCandidates = [
+    path.join(rootDir, "appstate.json"),
+    path.join(rootDir, "appState.json"),
+    path.join(rootDir, "test", "appstate.json")
+  ];
+
+  for (const candidate of appStateCandidates) {
+    const parsedAppState = readJsonFileIfValid(candidate);
+    if (!parsedAppState) {
+      continue;
+    }
+
+    return {
+      mode: "appState",
+      source: path.relative(rootDir, candidate) || candidate,
+      credentials: {
+        appState: parsedAppState
+      }
+    };
+  }
+
+  const configPath = path.join(rootDir, "fca-config.json");
+  if (fs.existsSync(configPath)) {
+    const rawConfig = readJsonFileIfValid(configPath);
+    if (!rawConfig) {
+      return null;
+    }
+
+    const configCookiePath =
+      rawConfig.cookiePath ||
+      rawConfig.cookiesPath ||
+      rawConfig.cookieFile ||
+      rawConfig.cookiesFile ||
+      rawConfig.credentials?.cookiePath ||
+      rawConfig.credentials?.cookiesPath ||
+      rawConfig.credentials?.cookieFile ||
+      rawConfig.credentials?.cookiesFile;
+
+    if (configCookiePath) {
+      const resolvedCookiePath = path.resolve(rootDir, configCookiePath);
+      const loaded = loadCookieCredentials(
+        resolvedCookiePath,
+        path.relative(rootDir, resolvedCookiePath) || resolvedCookiePath
+      );
+      if (loaded) {
+        return loaded;
+      }
+    }
+
+    const configCookie =
+      rawConfig.Cookie ||
+      rawConfig.cookie ||
+      rawConfig.cookies ||
+      rawConfig.sessionCookie ||
+      rawConfig.credentials?.Cookie ||
+      rawConfig.credentials?.cookie ||
+      rawConfig.credentials?.cookies ||
+      rawConfig.credentials?.sessionCookie;
+
+    if (configCookie) {
+      const normalizedConfigCookie = normalizeCookiePayload(configCookie);
+      if (normalizedConfigCookie) {
+        return {
+          mode: "cookie",
+          source: "fca-config.json",
+          credentials: {
+            Cookie: normalizedConfigCookie
+          }
+        };
+      }
+    }
+
+    const fileAppStatePath =
+      rawConfig.appStatePath ||
+      rawConfig.appstatePath ||
+      rawConfig.appStateFile ||
+      rawConfig.appstateFile;
+
+    if (fileAppStatePath) {
+      const resolvedPath = path.resolve(rootDir, fileAppStatePath);
+      const parsedAppState = readJsonFileIfValid(resolvedPath);
+      if (parsedAppState) {
+        return {
+          mode: "appState",
+          source: path.relative(rootDir, resolvedPath) || resolvedPath,
+          credentials: {
+            appState: parsedAppState
+          }
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+test("public exports are available", () => {
+  assert.strictEqual(typeof fca.login, "function");
+  assert.strictEqual(typeof fca.createFcaClient, "function");
+  assert.strictEqual(typeof fca.attachClientFacade, "function");
+  assert.strictEqual(typeof fca.resolveConfig, "function");
+  assert.strictEqual(typeof fca.loadConfig, "function");
+});
+
+test("resolveConfig honors legacy autoUpdate alias", () => {
+  const resolved = fca.resolveConfig({
+    autoUpdate: false,
+    checkUpdate: {
+      notifyIfCurrent: true
+    }
+  });
+
+  assert.strictEqual(resolved.autoUpdate, false);
+  assert.strictEqual(resolved.checkUpdate.enabled, false);
+  assert.strictEqual(resolved.checkUpdate.notifyIfCurrent, true);
+});
+
+test("createFcaClient reuses grouped namespaces when they already exist", () => {
+  const send = () => "send-ok";
+  const getInfo = () => "thread-ok";
+  const listen = () => "listen-ok";
+
+  const api = {
+    messages: { send },
+    threads: { getInfo },
+    users: { getInfo: () => "user-ok" },
+    account: { getCurrentUserID: () => "123" },
+    realtime: { listen },
+    http: { get: () => "http-ok" },
+    scheduler: { scheduleMessage: () => "sched-ok" }
+  };
+
+  const client = fca.createFcaClient(api);
+
+  assert.strictEqual(client.messages.send, send);
+  assert.strictEqual(client.threads.getInfo, getInfo);
+  assert.strictEqual(client.realtime.listen, listen);
+  assert.strictEqual(client.scheduler.scheduleMessage(), "sched-ok");
+});
+
+test("attachClientFacade exposes grouped namespaces on legacy api object", () => {
+  const api = {
+    sendMessage() {
+      return "legacy-send";
+    },
+    getThreadInfo() {
+      return "legacy-thread";
+    },
+    getUserInfo() {
+      return "legacy-user";
+    },
+    getCurrentUserID() {
+      return "1000";
+    },
+    listenMqtt() {
+      return "legacy-listen";
+    },
+    stopListening() {
+      return "legacy-stop";
+    },
+    stopListeningAsync() {
+      return Promise.resolve("legacy-stop-async");
+    },
+    useMiddleware() {
+      return "legacy-use";
+    },
+    removeMiddleware() {
+      return "legacy-remove";
+    },
+    clearMiddleware() {
+      return "legacy-clear";
+    },
+    listMiddleware() {
+      return [];
+    },
+    setMiddlewareEnabled() {
+      return true;
+    },
+    httpGet() {
+      return "legacy-http-get";
+    },
+    httpPost() {
+      return "legacy-http-post";
+    },
+    postFormData() {
+      return "legacy-http-form";
+    }
+  };
+
+  const client = fca.attachClientFacade(api);
+
+  assert.strictEqual(api.client, client);
+  assert.strictEqual(typeof api.messages.send, "function");
+  assert.strictEqual(typeof api.threads.getInfo, "function");
+  assert.strictEqual(typeof api.users.getInfo, "function");
+  assert.strictEqual(typeof api.account.getCurrentUserID, "function");
+  assert.strictEqual(typeof api.realtime.listen, "function");
+  assert.strictEqual(typeof api.http.get, "function");
+});
+
+test("optional live login works when credentials are provided", async () => {
+  const integration = loadIntegrationCredentials();
+  if (!integration) {
+    return {
+      skipped: true,
+      reason: "add cookie.txt, cookies.txt, cookie.json, or cookiePath/Cookie in fca-config.json to enable real-cookie login"
+    };
+  }
+
+  let ctx;
+  try {
+    ctx = await fca.login(integration.credentials, {
+      online: false,
+      forceLogin: false,
+      autoMarkRead: false
+    });
+  } catch (error) {
+    return {
+      skipped: true,
+      reason: `live login failed from ${integration.source}: ${error && error.message ? error.message : String(error)}`
+    };
+  }
+
+  assert.ok(ctx);
+  assert.ok(ctx.api);
+  assert.strictEqual(typeof ctx.api.sendMessage, "function");
+  assert.strictEqual(typeof ctx.api.listenMqtt, "function");
+  assert.strictEqual(typeof ctx.api.client.messages.send, "function");
+  assert.ok(ctx.userID || ctx.fbid);
+
+  return {
+    mode: integration.mode,
+    source: integration.source,
+    userID: ctx.userID || ctx.fbid || null
+  };
+});
+
+async function main() {
+  let passed = 0;
+  let skipped = 0;
+
+  for (const { name, fn } of tests) {
+    try {
+      const result = await fn();
+      if (result && result.skipped) {
+        skipped += 1;
+        console.log(`SKIP ${name} - ${result.reason}`);
+        continue;
+      }
+
+      passed += 1;
+      if (result && result.userID) {
+        console.log(`PASS ${name} (${result.mode} from ${result.source}: ${result.userID})`);
+      } else {
+        console.log(`PASS ${name}`);
+      }
+    } catch (error) {
+      console.error(`FAIL ${name}`);
+      throw error;
+    }
+  }
+
+  console.log(`SUMMARY passed=${passed} skipped=${skipped} total=${tests.length}`);
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exitCode = 1;
+});