@dongdev/fca-unofficial 1.0.20 → 2.0.1

package/{lib → src}/database/threadData.js

@@ -1,18 +1,18 @@
-const { Thread } = require('./models');
+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.');
+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 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) {
+module.exports = function(bot) {
   return {
     async create(threadID, data) {
       try {
@@ -58,15 +58,15 @@ module.exports = function (bot) {
     async del(threadID) {
       try {
         if (!threadID) {
-          throw new Error('threadID is required and cannot be undefined');
+          throw new Error("threadID is required and cannot be undefined");
         }
         threadID = validateThreadID(threadID);
         if (!threadID) {
-          throw new Error('Invalid 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');
+          throw new Error("No thread found with the specified threadID");
         }
         return result;
       } catch (error) {
@@ -82,12 +82,17 @@ module.exports = function (bot) {
     },
     async getAll(keys = null) {
       try {
-        const attributes = typeof keys === 'string' ? [keys] : Array.isArray(keys) ? keys : undefined;
+        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/src/utils/client.js

@@ -0,0 +1,159 @@
+"use strict";
+
+function saveCookies(jar) {
+  return res => {
+    try {
+      const setCookie = res?.headers?.["set-cookie"];
+      if (Array.isArray(setCookie) && setCookie.length) {
+        const url = res?.request?.res?.responseUrl || (res?.config?.baseURL ? new URL(res.config.url || "/", res.config.baseURL).toString() : res?.config?.url || "https://www.facebook.com");
+        for (const c of setCookie) {
+          try {
+            jar.setCookieSync(c, url);
+          } catch { }
+        }
+      }
+    } catch { }
+    return res;
+  };
+}
+
+function getAppState(jar) {
+  if (!jar || typeof jar.getCookiesSync !== "function") return [];
+  const urls = ["https://www.facebook.com", "https://www.messenger.com"];
+  const all = urls.flatMap(u => {
+    try { return jar.getCookiesSync(u) || []; } catch { return []; }
+  });
+  const seen = new Set();
+  const out = [];
+  for (const c of all) {
+    const key = c.key || c.name;
+    if (!key) continue;
+    const id = key + "|" + (c.domain || "") + "|" + (c.path || "/");
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push({
+      key,
+      value: c.value,
+      domain: c.domain || ".facebook.com",
+      path: c.path || "/",
+      hostOnly: !!c.hostOnly,
+      creation: c.creation || new Date(),
+      lastAccessed: c.lastAccessed || new Date(),
+      secure: !!c.secure,
+      httpOnly: !!c.httpOnly,
+      expires: c.expires && c.expires !== "Infinity" ? c.expires : "Infinity"
+    });
+  }
+  return out;
+}
+
+function makeParsable(html) {
+  const raw = cleanXssi(String(html || ""));
+  const split = raw.split(/\}\r?\n\s*\{/);
+  if (split.length === 1) return raw;
+  return "[" + split.join("},{") + "]";
+}
+
+function cleanXssi(t) {
+  if (t == null) return "";
+  let s = String(t);
+  s = s.replace(/^[\uFEFF\xEF\xBB\xBF]+/, "");
+  s = s.replace(/^\)\]\}',?\s*/, "");
+  s = s.replace(/^\s*for\s*\(;;\);\s*/i, "");
+  return s;
+}
+
+function parseAndCheckLogin(ctx, http, retryCount = 0) {
+  const delay = ms => new Promise(r => setTimeout(r, ms));
+  const headerOf = (headers, name) => {
+    if (!headers) return;
+    const k = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());
+    return k ? headers[k] : undefined;
+  };
+  const buildUrl = cfg => {
+    try {
+      return cfg?.baseURL ? new URL(cfg.url || "/", cfg.baseURL).toString() : cfg?.url || "";
+    } catch {
+      return cfg?.url || "";
+    }
+  };
+  return async (res) => {
+    const status = res?.status ?? 0;
+    if (status >= 500 && status < 600) {
+      if (retryCount >= 5) {
+        const err = new Error("Request retry failed. Check the `res` and `statusCode` property on this error.");
+        err.statusCode = status;
+        err.res = res?.data;
+        err.error = "Request retry failed. Check the `res` and `statusCode` property on this error.";
+        throw err;
+      }
+      const retryTime = Math.floor(Math.random() * 5000);
+      await delay(retryTime);
+      const url = buildUrl(res?.config);
+      const ctype = String(headerOf(res?.config?.headers, "content-type") || "").toLowerCase();
+      const isMultipart = ctype.includes("multipart/form-data");
+      const payload = res?.config?.data;
+      const params = res?.config?.params;
+      retryCount += 1;
+      if (isMultipart) {
+        const newData = await http.postFormData(url, ctx.jar, payload, params, ctx.globalOptions, ctx);
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      } else {
+        const newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      }
+    }
+    if (status === 404) return;
+    if (status !== 200) {
+      const err = new Error("parseAndCheckLogin got status code: " + status + ". Bailing out of trying to parse response.");
+      err.statusCode = status;
+      err.res = res?.data;
+      throw err;
+    }
+    const resBodyRaw = res?.data;
+    const body = typeof resBodyRaw === "string" ? makeParsable(resBodyRaw) : resBodyRaw;
+    let parsed;
+    try {
+      parsed = typeof body === "object" && body !== null ? body : JSON.parse(body);
+    } catch (e) {
+      const err = new Error("JSON.parse error. Check the `detail` property on this error.");
+      err.error = "JSON.parse error. Check the `detail` property on this error.";
+      err.detail = e;
+      err.res = resBodyRaw;
+      throw err;
+    }
+    const method = String(res?.config?.method || "GET").toUpperCase();
+    if (parsed.redirect && method === "GET") {
+      const redirectRes = await http.get(parsed.redirect, ctx.jar, null, ctx.globalOptions, ctx);
+      return await parseAndCheckLogin(ctx, http)(redirectRes);
+    }
+    if (parsed.jsmods && parsed.jsmods.require && Array.isArray(parsed.jsmods.require[0]) && parsed.jsmods.require[0][0] === "Cookie") {
+      parsed.jsmods.require[0][3][0] = parsed.jsmods.require[0][3][0].replace("_js_", "");
+      const requireCookie = parsed.jsmods.require[0][3];
+      ctx.jar.setCookie(formatCookie(requireCookie, "facebook"), "https://www.facebook.com");
+      ctx.jar.setCookie(formatCookie(requireCookie, "messenger"), "https://www.messenger.com");
+    }
+    if (parsed.jsmods && Array.isArray(parsed.jsmods.require)) {
+      for (const item of parsed.jsmods.require) {
+        if (item[0] === "DTSG" && item[1] === "setToken") {
+          ctx.fb_dtsg = item[3][0];
+          ctx.ttstamp = "2";
+          for (let j = 0; j < ctx.fb_dtsg.length; j++) ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+          break;
+        }
+      }
+    }
+    if (parsed.error === 1357001) {
+      const err = new Error("Facebook blocked the login");
+      err.error = "Not logged in.";
+      throw err;
+    }
+    return parsed;
+  };
+}
+
+module.exports = {
+  saveCookies,
+  getAppState,
+  parseAndCheckLogin
+};

package/src/utils/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+
+function getFrom(html, a, b) {
+  const i = html.indexOf(a);
+  if (i < 0) return;
+  const start = i + a.length;
+  const j = html.indexOf(b, start);
+  return j < 0 ? undefined : html.slice(start, j);
+}
+
+module.exports = {
+  getFrom
+};

package/src/utils/format.js

@@ -0,0 +1,60 @@
+"use strict";
+
+function getType(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+function generateOfflineThreadingID() {
+  var ret = Date.now();
+  var value = Math.floor(Math.random() * 4294967295);
+  var str = ("0000000000000000000000" + value.toString(2)).slice(-22);
+  var msgs = ret.toString(2) + str;
+  return binaryToDecimal(msgs);
+}
+var h;
+var i = {};
+var j = {
+  _: "%",
+  A: "%2",
+  B: "000",
+  C: "%7d",
+  D: "%7b%22",
+  E: "%2c%22",
+  F: "%22%3a",
+  G: "%2c%22ut%22%3a1",
+  H: "%2c%22bls%22%3a",
+  I: "%2c%22n%22%3a%22%",
+  J: "%22%3a%7b%22i%22%3a0%7d",
+  K: "%2c%22pt%22%3a0%2c%22vis%22%3a",
+  L: "%2c%22ch%22%3a%7b%22h%22%3a%22",
+  M: "%7b%22v%22%3a2%2c%22time%22%3a1",
+  N: ".channel%22%2c%22sub%22%3a%5b",
+  O: "%2c%22sb%22%3a1%2c%22t%22%3a%5b",
+  P: "%2c%22ud%22%3a100%2c%22lc%22%3a0",
+  Q: "%5d%2c%22f%22%3anull%2c%22uct%22%3a",
+  R: ".channel%22%2c%22sub%22%3a%5b1%5d",
+  S: "%22%2c%22m%22%3a0%7d%2c%7b%22i%22%3a",
+  T: "%2c%22blc%22%3a1%2c%22snd%22%3a1%2c%22ct%22%3a",
+  U: "%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
+  V: "%2c%22blc%22%3a0%2c%22snd%22%3a0%2c%22ct%22%3a",
+  W: "%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a",
+  X: "%2c%22ri%22%3a0%7d%2c%22state%22%3a%7b%22p%22%3a0%2c%22ut%22%3a1",
+  Y:
+    "%2c%22pt%22%3a0%2c%22vis%22%3a1%2c%22bls%22%3a0%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
+  Z:
+    "%2c%22sb%22%3a1%2c%22t%22%3a%5b%5d%2c%22f%22%3anull%2c%22uct%22%3a0%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a"
+};
+(function () {
+  var l = [];
+  for (var m in j) {
+    i[j[m]] = m;
+    l.push(j[m]);
+  }
+  l.reverse();
+  h = new RegExp(l.join("|"), "g");
+})();
+
+module.exports = {
+  getType,
+  generateOfflineThreadingID,
+};

package/src/utils/headers.js

@@ -0,0 +1,41 @@
+"use strict";
+
+function getHeaders(url, options, ctx, customHeader) {
+  const u = new URL(url);
+  const ua = options?.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36";
+  const referer = options?.referer || "https://www.facebook.com/";
+  const origin = referer.replace(/\/+$/, "");
+  const contentType = options?.contentType || "application/x-www-form-urlencoded";
+  const acceptLang = options?.acceptLanguage || "en-US,en;q=0.9,vi;q=0.8";
+  const headers = {
+    Host: u.host,
+    Origin: origin,
+    Referer: referer,
+    "User-Agent": ua,
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,application/json;q=0.8,*/*;q=0.7",
+    "Accept-Language": acceptLang,
+    "Accept-Encoding": "gzip, deflate, br",
+    "Content-Type": contentType,
+    Connection: "keep-alive",
+    DNT: "1",
+    "Upgrade-Insecure-Requests": "1",
+    "sec-ch-ua": "\"Chromium\";v=\"139\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"139\"",
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": "\"Windows\"",
+    "sec-ch-ua-arch": "\"x86\"",
+    "sec-ch-ua-bitness": "\"64\"",
+    "sec-ch-ua-full-version-list": "\"Chromium\";v=\"139.0.0.0\", \"Not;A=Brand\";v=\"24.0.0.0\", \"Google Chrome\";v=\"139.0.0.0\"",
+    "sec-ch-ua-platform-version": "\"15.0.0\"",
+    "Sec-Fetch-Site": "same-origin",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Dest": "empty",
+    "X-Requested-With": "XMLHttpRequest",
+    Pragma: "no-cache",
+    "Cache-Control": "no-cache"
+  };
+  if (ctx?.region) headers["X-MSGR-Region"] = ctx.region;
+  if (customHeader && typeof customHeader === "object") Object.assign(headers, customHeader);
+  return headers;
+}
+
+module.exports = { getHeaders };