ayman-fca 1.0.0

package/src/utils/loginParser/autoLogin.js

@@ -0,0 +1,125 @@
+"use strict";
+
+const logger = require("../../../func/logger");
+
+/**
+ * Tạo hàm maybeAutoLogin: khi session hết hạn thì thử đăng nhập lại và retry request.
+ * @param {Object} ctx - Context (jar, performAutoLogin, globalOptions, ...)
+ * @param {Object} http - HTTP client (get, post, postFormData)
+ * @param {Object} helpers - { buildUrl, headerOf, formatCookie }
+ * @param {Function} emit - createEmit(ctx)
+ * @param {Function} parseAndCheckLogin - Hàm parse chính để retry sau khi auto login thành công
+ */
+function createMaybeAutoLogin(ctx, http, helpers, emit, parseAndCheckLogin) {
+  const { buildUrl, headerOf, formatCookie } = helpers;
+
+  return async function maybeAutoLogin(resData, resConfig) {
+    if (ctx.auto_login) {
+      const e = new Error("Not logged in. Auto login already in progress.");
+      e.error = "Not logged in.";
+      e.res = resData;
+      throw e;
+    }
+    if (typeof ctx.performAutoLogin !== "function") {
+      const e = new Error("Not logged in. Auto login function not available.");
+      e.error = "Not logged in.";
+      e.res = resData;
+      throw e;
+    }
+
+    ctx.auto_login = true;
+    logger("Login session expired, attempting auto login...", "warn");
+    emit("sessionExpired", { res: resData });
+
+    try {
+      const ok = await ctx.performAutoLogin();
+      if (ok) {
+        logger("Auto login successful! Retrying request...", "info");
+        emit("autoLoginSuccess", { res: resData });
+        ctx.auto_login = false;
+
+        if (resConfig) {
+          const url = buildUrl(resConfig);
+          const method = String(resConfig?.method || "GET").toUpperCase();
+          const ctype = String(headerOf(resConfig?.headers, "content-type") || "").toLowerCase();
+          const isMultipart = ctype.includes("multipart/form-data");
+          const payload = resConfig?.data;
+          const params = resConfig?.params;
+
+          try {
+            let newData;
+            if (method === "GET") {
+              newData = await http.get(url, ctx.jar, params || null, ctx.globalOptions, ctx);
+            } else if (isMultipart) {
+              newData = await http.postFormData(url, ctx.jar, payload, params, ctx.globalOptions, ctx);
+            } else {
+              newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
+            }
+            return await parseAndCheckLogin(ctx, http)(newData);
+          } catch (retryErr) {
+            if (
+              retryErr?.code === "ERR_INVALID_CHAR" ||
+              (retryErr?.message && retryErr.message.includes("Invalid character in header"))
+            ) {
+              logger(
+                `Auto login retry failed: Invalid header detected. Error: ${retryErr.message}`,
+                "error"
+              );
+              const e = new Error("Not logged in. Auto login retry failed due to invalid header.");
+              e.error = "Not logged in.";
+              e.res = resData;
+              e.originalError = retryErr;
+              throw e;
+            }
+            logger(
+              `Auto login retry failed: ${
+                retryErr && retryErr.message ? retryErr.message : String(retryErr)
+              }`,
+              "error"
+            );
+            const e = new Error("Not logged in. Auto login retry failed.");
+            e.error = "Not logged in.";
+            e.res = resData;
+            e.originalError = retryErr;
+            throw e;
+          }
+        } else {
+          const e = new Error(
+            "Not logged in. Auto login successful but cannot retry request."
+          );
+          e.error = "Not logged in.";
+          e.res = resData;
+          throw e;
+        }
+      } else {
+        ctx.auto_login = false;
+        const e = new Error("Not logged in. Auto login failed.");
+        e.error = "Not logged in.";
+        e.res = resData;
+        emit("autoLoginFailed", { error: e, res: resData });
+        throw e;
+      }
+    } catch (autoLoginErr) {
+      ctx.auto_login = false;
+      if (autoLoginErr.error === "Not logged in.") {
+        throw autoLoginErr;
+      }
+      logger(
+        `Auto login error: ${
+          autoLoginErr && autoLoginErr.message ? autoLoginErr.message : String(autoLoginErr)
+        }`,
+        "error"
+      );
+      const e = new Error("Not logged in. Auto login error.");
+      e.error = "Not logged in.";
+      e.res = resData;
+      e.originalError = autoLoginErr;
+      emit("autoLoginFailed", { error: e, res: resData });
+      throw e;
+    }
+  };
+}
+
+module.exports = {
+  createMaybeAutoLogin
+};

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/H

@@ -0,0 +1 @@
+

package/src/utils/request/client.js

@@ -0,0 +1,33 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — HTTP Client
+//  © 2025 Ayman. All Rights Reserved.
+//
+//  ملاحظة مهمة: لا نستخدم httpAgent/httpsAgent مخصص
+//  لأن axios-cookiejar-support لا يدعمه
+// ============================================================
+"use strict";
+
+const axios   = require("axios");
+const { CookieJar } = require("tough-cookie");
+const { wrapper } = require("axios-cookiejar-support");
+
+const jar = new CookieJar();
+
+// ✅ Client نظيف — timeout 30s أسرع من الافتراضي 60s
+const client = wrapper(
+  axios.create({
+    jar,
+    withCredentials: true,
+    timeout: 30000,
+    validateStatus: s => s >= 200 && s < 600,
+    maxRedirects: 5,
+    maxContentLength: Infinity,
+    maxBodyLength:    Infinity,
+    decompress: true
+  })
+);
+
+// ✅ delay utility
+const delay = ms => new Promise(r => setTimeout(r, ms));
+
+module.exports = { jar, client, delay };

package/src/utils/request/config.js

@@ -0,0 +1,25 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — Request Config
+//  © 2025 Ayman. All Rights Reserved.
+// ============================================================
+"use strict";
+
+const { sanitizeHeaders } = require("./sanitize");
+const { jar }             = require("./client");
+
+function cfg(base = {}) {
+  const { reqJar, headers, params, agent, timeout } = base;
+  return {
+    headers:         sanitizeHeaders(headers),
+    params,
+    jar:             reqJar || jar,
+    withCredentials: true,
+    timeout:         timeout || 30000,
+    ...(agent ? { httpAgent: agent, httpsAgent: agent } : {}),
+    proxy:           false,
+    validateStatus:  s => s >= 200 && s < 600,
+    decompress:      true
+  };
+}
+
+module.exports = { cfg };

package/src/utils/request/defaults.js

@@ -0,0 +1,40 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — Request Defaults Builder
+//  © 2025 Ayman. All Rights Reserved.
+// ============================================================
+"use strict";
+
+const constMod = require("../constants");
+const getFrom  = constMod.getFrom;
+const { get, post, postFormData } = require("./methods");
+
+function makeDefaults(html, userID, ctx) {
+  let reqCounter = 1;
+  const revision =
+    getFrom(html || "", 'revision":', ",") ||
+    getFrom(html || "", '"client_revision":', ",") || "";
+
+  function merge(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, h = {}) => get(url, j, merge(qs), ctx?.globalOptions, ctxx || ctx, h),
+    post:        (url, j, form, ctxx, h = {}) => post(url, j, merge(form), ctx?.globalOptions, ctxx || ctx, h),
+    postFormData:(url, j, form, qs, ctxx) =>
+      postFormData(url, j, merge(form), merge(qs), ctx?.globalOptions, ctxx || ctx),
+  };
+}
+
+module.exports = { makeDefaults };

package/src/utils/request/helpers.js

@@ -0,0 +1,31 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — Request Helpers
+//  © 2025 Ayman. All Rights Reserved.
+// ============================================================
+"use strict";
+
+const formatMod = require("../format");
+const getType   = formatMod.getType;
+
+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,12 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — Request Index
+//  © 2025 Ayman. All Rights Reserved.
+// ============================================================
+"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,92 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — HTTP Methods
+//  © 2025 Ayman. All Rights Reserved.
+// ============================================================
+"use strict";
+
+const FormData           = require("form-data");
+const { getHeaders }     = require("../headers");
+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, 800, 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, 800, ctx
+  );
+}
+
+function post(url, reqJar, form, options, ctx, customHeader) {
+  const headers = getHeaders(url, options, ctx, customHeader);
+  const ct = String(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, 800, 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 (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, 800, ctx
+  );
+}
+
+module.exports = { cleanGet, get, post, postFormData };