@dongdev/fca-unofficial 3.0.30 → 3.0.31

package/src/utils/loginParser/helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const delay = ms => new Promise(r => setTimeout(r, ms));
+
+function createEmit(ctx) {
+  return (event, payload) => {
+    try {
+      if (ctx && ctx._emitter && typeof ctx._emitter.emit === "function") {
+        ctx._emitter.emit(event, payload);
+      }
+    } catch { }
+  };
+}
+
+function headerOf(headers, name) {
+  if (!headers) return;
+  const k = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());
+  return k ? headers[k] : undefined;
+}
+
+function buildUrl(cfg) {
+  try {
+    return cfg?.baseURL
+      ? new URL(cfg.url || "/", cfg.baseURL).toString()
+      : cfg?.url || "";
+  } catch {
+    return cfg?.url || "";
+  }
+}
+
+function formatCookie(arr, service) {
+  const n = String(arr?.[0] || "");
+  const v = String(arr?.[1] || "");
+  return `${n}=${v}; Domain=.${service}.com; Path=/; Secure`;
+}
+
+module.exports = {
+  delay,
+  createEmit,
+  headerOf,
+  buildUrl,
+  formatCookie
+};

package/src/utils/loginParser/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const { parseAndCheckLogin } = require("./parseAndCheckLogin");
+const { cleanXssi, makeParsable } = require("./textUtils");
+
+module.exports = {
+  parseAndCheckLogin,
+  cleanXssi,
+  makeParsable
+};

package/src/utils/loginParser/parseAndCheckLogin.js

@@ -0,0 +1,220 @@
+"use strict";
+
+const logger = require("../../../func/logger");
+const { makeParsable } = require("./textUtils");
+const { delay, createEmit, headerOf, buildUrl, formatCookie } = require("./helpers");
+const { createMaybeAutoLogin } = require("./autoLogin");
+
+/**
+ * Trả về hàm async (res) => parsed | throw.
+ * Xử lý: retry 5xx, parse JSON, redirect, cookie/DTSG, checkpoint và auto login.
+ */
+function parseAndCheckLogin(ctx, http, retryCount = 0) {
+  const emit = createEmit(ctx);
+  const helpers = { buildUrl, headerOf, formatCookie };
+  const maybeAutoLogin = createMaybeAutoLogin(ctx, http, helpers, emit, parseAndCheckLogin);
+
+  return async function handleResponse(res) {
+    const status = res?.status ?? 0;
+
+    // Retry khi 5xx
+    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.";
+        logger(`parseAndCheckLogin: Max retries (5) reached for status ${status}`, "error");
+        throw err;
+      }
+      const baseDelay = retryCount === 0 ? 1500 : 1000 * Math.pow(2, retryCount);
+      const jitter = Math.floor(Math.random() * 200);
+      const retryTime = Math.min(baseDelay + jitter, 10000);
+      const method = String(res?.config?.method || "GET").toUpperCase();
+      const url = buildUrl(res?.config);
+      logger(
+        `parseAndCheckLogin: [${method}] ${url || "(no url)"} -> Retrying request (attempt ${
+          retryCount + 1
+        }/5) after ${retryTime}ms for status ${status}`,
+        "warn"
+      );
+      await delay(retryTime);
+      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;
+      const nextRetry = retryCount + 1;
+      try {
+        if (method === "GET") {
+          const newData = await http.get(url, ctx.jar, params || null, ctx.globalOptions, ctx);
+          return await parseAndCheckLogin(ctx, http, nextRetry)(newData);
+        }
+        if (isMultipart) {
+          const newData = await http.postFormData(
+            url,
+            ctx.jar,
+            payload,
+            params,
+            ctx.globalOptions,
+            ctx
+          );
+          return await parseAndCheckLogin(ctx, http, nextRetry)(newData);
+        }
+        const newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
+        return await parseAndCheckLogin(ctx, http, nextRetry)(newData);
+      } catch (retryErr) {
+        if (
+          retryErr?.code === "ERR_INVALID_CHAR" ||
+          (retryErr?.message && retryErr.message.includes("Invalid character in header"))
+        ) {
+          logger(
+            `parseAndCheckLogin: Invalid header detected, aborting retry. Error: ${retryErr.message}`,
+            "error"
+          );
+          const err = new Error(
+            "Invalid header content detected. Request aborted to prevent crash."
+          );
+          err.error = "Invalid header content";
+          err.statusCode = status;
+          err.res = res?.data;
+          err.originalError = retryErr;
+          throw err;
+        }
+        if (nextRetry >= 5) {
+          logger(
+            `parseAndCheckLogin: Max retries reached, returning error instead of crashing`,
+            "error"
+          );
+          const err = new Error(
+            "Request retry failed after 5 attempts. Check the `res` and `statusCode` property on this error."
+          );
+          err.statusCode = status;
+          err.res = res?.data;
+          err.error = "Request retry failed after 5 attempts";
+          err.originalError = retryErr;
+          throw err;
+        }
+        return await parseAndCheckLogin(ctx, http, nextRetry)(res);
+      }
+    }
+
+    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);
+    }
+
+    // Cookie từ jsmods
+    if (
+      parsed?.jsmods &&
+      parsed.jsmods.require &&
+      Array.isArray(parsed.jsmods.require[0]) &&
+      parsed.jsmods.require[0][0] === "Cookie"
+    ) {
+      parsed.jsmods.require[0][3][0] = String(parsed.jsmods.require[0][3][0] || "").replace(
+        "_js_",
+        ""
+      );
+      const requireCookie = parsed.jsmods.require[0][3];
+      await ctx.jar.setCookie(
+        formatCookie(requireCookie, "facebook"),
+        "https://www.facebook.com"
+      );
+      await ctx.jar.setCookie(
+        formatCookie(requireCookie, "messenger"),
+        "https://www.messenger.com"
+      );
+    }
+
+    // DTSG token
+    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 = "login_blocked";
+      err.res = parsed;
+      emit("loginBlocked", { res: parsed });
+      throw err;
+    }
+
+    const resData = parsed;
+    const resStr = JSON.stringify(resData);
+
+    if (
+      resStr.includes("XCheckpointFBScrapingWarningController") ||
+      resStr.includes("601051028565049")
+    ) {
+      emit("checkpoint", { type: "scraping_warning", res: resData });
+      return await maybeAutoLogin(resData, res?.config);
+    }
+    if (
+      resStr.includes("https://www.facebook.com/login.php?") ||
+      String(parsed?.redirect || "").includes("login.php?")
+    ) {
+      return await maybeAutoLogin(resData, res?.config);
+    }
+    if (resStr.includes("1501092823525282")) {
+      logger("Bot checkpoint 282 detected, please check the account!", "error");
+      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")) {
+      logger("Bot checkpoint 956 detected, please check the account!", "error");
+      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;
+  };
+}
+
+module.exports = {
+  parseAndCheckLogin
+};

package/src/utils/loginParser/textUtils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+/**
+ * Loại bỏ XSSI prefix và ký tự thừa từ chuỗi response.
+ */
+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;
+}
+
+/**
+ * Chuẩn hóa HTML/JSON response thành chuỗi có thể parse (nối nhiều object thành array).
+ */
+function makeParsable(html) {
+  const raw = cleanXssi(String(html || ""));
+  const split = raw.split(/\}\r?\n\s*\{/);
+  if (split.length === 1) return raw;
+  return "[" + split.join("},{") + "]";
+}
+
+module.exports = {
+  cleanXssi,
+  makeParsable
+};

package/src/utils/request/client.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const axios = require("axios");
+const { CookieJar } = require("tough-cookie");
+const { wrapper } = require("axios-cookiejar-support");
+
+const jar = new CookieJar();
+const client = wrapper(
+  axios.create({
+    jar,
+    withCredentials: true,
+    timeout: 60000,
+    validateStatus: (s) => s >= 200 && s < 600,
+    maxRedirects: 5,
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+  })
+);
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+module.exports = {
+  jar,
+  client,
+  delay,
+};

package/src/utils/request/config.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const { sanitizeHeaders } = require("./sanitize");
+const { jar, client } = require("./client");
+
+function cfg(base = {}) {
+  const { reqJar, headers, params, agent, timeout } = base;
+  return {
+    headers: sanitizeHeaders(headers),
+    params,
+    jar: reqJar || jar,
+    withCredentials: true,
+    timeout: timeout || 60000,
+    httpAgent: agent || client.defaults.httpAgent,
+    httpsAgent: agent || client.defaults.httpsAgent,
+    proxy: false,
+    validateStatus: (s) => s >= 200 && s < 600,
+  };
+}
+
+module.exports = {
+  cfg,
+};

package/src/utils/request/defaults.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const constMod = require("../constants");
+const getFrom = constMod.getFrom || constMod;
+const { get, post, postFormData } = require("./methods");
+
+function makeDefaults(html, userID, ctx) {
+  let reqCounter = 1;
+  const revision =
+    getFrom(html || "", 'revision":', ",") ||
+    getFrom(html || "", '"client_revision":', ",") ||
+    "";
+  function mergeWithDefaults(obj) {
+    const base = {
+      av: userID,
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+    };
+    if (ctx?.fb_dtsg) base.fb_dtsg = ctx.fb_dtsg;
+    if (ctx?.jazoest) base.jazoest = ctx.jazoest;
+    if (!obj) return base;
+    for (const k of Object.keys(obj)) if (!(k in base)) base[k] = obj[k];
+    return base;
+  }
+  return {
+    get: (url, j, qs, ctxx, customHeader = {}) =>
+      get(url, j, mergeWithDefaults(qs), ctx?.globalOptions, ctxx || ctx, customHeader),
+    post: (url, j, form, ctxx, customHeader = {}) =>
+      post(url, j, mergeWithDefaults(form), ctx?.globalOptions, ctxx || ctx, customHeader),
+    postFormData: (url, j, form, qs, ctxx) =>
+      postFormData(
+        url,
+        j,
+        mergeWithDefaults(form),
+        mergeWithDefaults(qs),
+        ctx?.globalOptions,
+        ctxx || ctx
+      ),
+  };
+}
+
+module.exports = {
+  makeDefaults,
+};

package/src/utils/request/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const formatMod = require("../format");
+const getType = formatMod.getType || formatMod;
+
+function toStringVal(v) {
+  if (v === undefined || v === null) return "";
+  if (typeof v === "bigint") return v.toString();
+  if (typeof v === "boolean") return v ? "true" : "false";
+  return String(v);
+}
+
+function isStream(v) {
+  return (
+    v &&
+    typeof v === "object" &&
+    typeof v.pipe === "function" &&
+    typeof v.on === "function"
+  );
+}
+
+function isBlobLike(v) {
+  return (
+    v &&
+    typeof v.arrayBuffer === "function" &&
+    (typeof v.type === "string" || typeof v.name === "string")
+  );
+}
+
+function isPairArrayList(arr) {
+  return (
+    Array.isArray(arr) &&
+    arr.length > 0 &&
+    arr.every(
+      (x) => Array.isArray(x) && x.length === 2 && typeof x[0] === "string"
+    )
+  );
+}
+
+module.exports = {
+  getType,
+  toStringVal,
+  isStream,
+  isBlobLike,
+  isPairArrayList,
+};

package/src/utils/request/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const { jar, client } = require("./client");
+const { cleanGet, get, post, postFormData } = require("./methods");
+const { makeDefaults } = require("./defaults");
+const { setProxy } = require("./proxy");
+
+module.exports = {
+  cleanGet,
+  get,
+  post,
+  postFormData,
+  jar,
+  setProxy,
+  makeDefaults,
+  client,
+};

package/src/utils/request/methods.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const FormData = require("form-data");
+const headersMod = require("../headers");
+const getHeaders = headersMod.getHeaders || headersMod;
+const { client } = require("./client");
+const { cfg } = require("./config");
+const { requestWithRetry } = require("./retry");
+const {
+  getType,
+  toStringVal,
+  isStream,
+  isBlobLike,
+  isPairArrayList,
+} = require("./helpers");
+
+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,
+    ctx
+  );
+}
+
+function post(url, reqJar, form, options, ctx, customHeader) {
+  const headers = getHeaders(url, options, ctx, customHeader);
+  const ct = String(
+    headers["Content-Type"] || headers["content-type"] || "application/x-www-form-urlencoded"
+  ).toLowerCase();
+  let data;
+  if (ct.includes("json")) {
+    data = JSON.stringify(form || {});
+    headers["Content-Type"] = "application/json";
+  } else {
+    const p = new URLSearchParams();
+    if (form && typeof form === "object") {
+      for (const k of Object.keys(form)) {
+        let v = form[k];
+        if (isPairArrayList(v)) {
+          for (const [kk, vv] of v) p.append(`${k}[${kk}]`, toStringVal(vv));
+          continue;
+        }
+        if (Array.isArray(v)) {
+          for (const x of v) {
+            if (Array.isArray(x) && x.length === 2 && typeof x[1] !== "object")
+              p.append(k, toStringVal(x[1]));
+            else p.append(k, toStringVal(x));
+          }
+          continue;
+        }
+        if (getType(v) === "Object") v = JSON.stringify(v);
+        p.append(k, toStringVal(v));
+      }
+    }
+    data = p.toString();
+    headers["Content-Type"] = "application/x-www-form-urlencoded";
+  }
+  return requestWithRetry(
+    () => client.post(url, data, cfg({ reqJar, headers })),
+    3,
+    1000,
+    ctx
+  );
+}
+
+async function postFormData(url, reqJar, form, qs, options, ctx) {
+  const fd = new FormData();
+  if (form && typeof form === "object") {
+    for (const k of Object.keys(form)) {
+      const v = form[k];
+      if (v === undefined || v === null) continue;
+      if (isPairArrayList(v)) {
+        for (const [kk, vv] of v)
+          fd.append(
+            `${k}[${kk}]`,
+            typeof vv === "object" && !Buffer.isBuffer(vv) && !isStream(vv)
+              ? JSON.stringify(vv)
+              : vv
+          );
+        continue;
+      }
+      if (Array.isArray(v)) {
+        for (const x of v) {
+          if (
+            Array.isArray(x) &&
+            x.length === 2 &&
+            x[1] &&
+            typeof x[1] === "object" &&
+            !Buffer.isBuffer(x[1]) &&
+            !isStream(x[1])
+          ) {
+            fd.append(k, x[0], x[1]);
+          } else if (
+            Array.isArray(x) &&
+            x.length === 2 &&
+            typeof x[1] !== "object"
+          ) {
+            fd.append(k, toStringVal(x[1]));
+          } else if (
+            x &&
+            typeof x === "object" &&
+            "value" in x &&
+            "options" in x
+          ) {
+            fd.append(k, x.value, x.options || {});
+          } else if (isStream(x) || Buffer.isBuffer(x) || typeof x === "string") {
+            fd.append(k, x);
+          } else if (isBlobLike(x)) {
+            const buf = Buffer.from(await x.arrayBuffer());
+            fd.append(k, buf, {
+              filename: x.name || k,
+              contentType: x.type || undefined,
+            });
+          } else {
+            fd.append(k, JSON.stringify(x));
+          }
+        }
+        continue;
+      }
+      if (v && typeof v === "object" && "value" in v && "options" in v) {
+        fd.append(k, v.value, v.options || {});
+        continue;
+      }
+      if (isStream(v) || Buffer.isBuffer(v) || typeof v === "string") {
+        fd.append(k, v);
+        continue;
+      }
+      if (isBlobLike(v)) {
+        const buf = Buffer.from(await v.arrayBuffer());
+        fd.append(k, buf, {
+          filename: v.name || k,
+          contentType: v.type || undefined,
+        });
+        continue;
+      }
+      if (typeof v === "number" || typeof v === "boolean") {
+        fd.append(k, toStringVal(v));
+        continue;
+      }
+      fd.append(k, JSON.stringify(v));
+    }
+  }
+  const headers = { ...getHeaders(url, options, ctx), ...fd.getHeaders() };
+  return requestWithRetry(
+    () => client.post(url, fd, cfg({ reqJar, headers, params: qs })),
+    3,
+    1000,
+    ctx
+  );
+}
+
+module.exports = {
+  cleanGet,
+  get,
+  post,
+  postFormData,
+};

package/src/utils/request/proxy.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const { HttpsProxyAgent } = require("https-proxy-agent");
+const { client } = require("./client");
+
+function setProxy(proxyUrl) {
+  if (!proxyUrl) {
+    client.defaults.httpAgent = undefined;
+    client.defaults.httpsAgent = undefined;
+    client.defaults.proxy = false;
+    return;
+  }
+  const agent = new HttpsProxyAgent(proxyUrl);
+  client.defaults.httpAgent = agent;
+  client.defaults.httpsAgent = agent;
+  client.defaults.proxy = false;
+}
+
+module.exports = {
+  setProxy,
+};