fca-neokex-fix 1.0.1

package/src/utils/clients.js

@@ -0,0 +1,270 @@
+"use strict";
+
+const { makeParsable, log, warn } = require("./constants");
+
+/**
+ * Formats a cookie array into a string for use in a cookie jar.
+ * @param {Array<string>} arr - An array containing cookie parts.
+ * @param {string} url - The base URL for the cookie domain.
+ * @returns {string} The formatted cookie string.
+ */
+function formatCookie(arr, url) {
+  return arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + url + ".com";
+}
+
+/**
+ * Parses a response from Facebook, checks for login status, and handles retries.
+ * @param {Object} ctx - The application context.
+ * @param {Object} http - The HTTP request functions.
+ * @param {number} [retryCount=0] - The current retry count for the request.
+ * @returns {function(data: Object): Promise<Object>} A function that processes the response data.
+ */
+function parseAndCheckLogin(ctx, http, retryCount = 0) {
+  const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  return async (data) => {
+    if (data.statusCode === 401) {
+      const err = new Error("Session expired - Authentication required");
+      err.error = 401;
+      err.errorCode = 401;
+      err.errorType = "AUTHENTICATION_REQUIRED";
+      err.requiresReLogin = true;
+      warn("Session Status", "Session expired. Re-login required.");
+      throw err;
+    }
+
+    if (data.statusCode >= 500 && data.statusCode < 600) {
+      if (retryCount >= 5) {
+        const err = new Error("Request retry failed. Check the `res` and `statusCode` property on this error.");
+        err.statusCode = data.statusCode;
+        err.res = data.body;
+        err.error = "Request retry failed. Check the `res` and `statusCode` property on this error.";
+        throw err;
+      }
+
+      retryCount++;
+      const retryTime = Math.floor(Math.random() * 5000);
+      const url = data.request.uri.protocol + "//" + data.request.uri.hostname + data.request.uri.pathname;
+
+      await delay(retryTime);
+
+      if (data.request.headers["content-type"].split(";")[0] === "multipart/form-data") {
+        const newData = await http.postFormData(
+          url,
+          ctx.jar,
+          data.request.formData,
+          data.request.qs,
+          ctx.globalOptions,
+          ctx
+        );
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      } else {
+        const newData = await http.post(
+          url,
+          ctx.jar,
+          data.request.form,
+          ctx.globalOptions,
+          ctx
+        );
+        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      }
+    }
+
+    if (data.statusCode === 404) return;
+
+    if (data.statusCode !== 200) {
+      throw new Error("parseAndCheckLogin got status code: " + data.statusCode + ". Bailing out of trying to parse response.");
+    }
+
+    let res = null;
+
+    if (typeof data.body === 'object' && data.body !== null) {
+      res = data.body;
+    } else if (typeof data.body === 'string') {
+      try {
+        res = JSON.parse(makeParsable(data.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 = data.body;
+        throw err;
+      }
+    } else {
+      throw new Error("Unknown response body type: " + typeof data.body);
+    }
+
+    if (res.redirect && data.request.method === "GET") {
+      const redirectRes = await http.get(res.redirect, ctx.jar);
+      return await parseAndCheckLogin(ctx, http)(redirectRes);
+    }
+
+    if (res.jsmods && res.jsmods.require && Array.isArray(res.jsmods.require[0]) && res.jsmods.require[0][0] === "Cookie") {
+      res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace("_js_", "");
+      const requireCookie = res.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 (res.jsmods && Array.isArray(res.jsmods.require)) {
+      const arr = res.jsmods.require;
+      for (const i in arr) {
+        if (arr[i][0] === "DTSG" && arr[i][1] === "setToken") {
+          ctx.fb_dtsg = arr[i][3][0];
+          ctx.ttstamp = "2";
+          for (let j = 0; j < ctx.fb_dtsg.length; j++) {
+            ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+          }
+        }
+      }
+    }
+
+    const SESSION_EXPIRY_CODES = {
+      1357046: "Session token expired - Re-authentication required",
+      1357045: "Invalid session token - Re-login needed",
+      458: "Session expired - User not logged in"
+    };
+
+    if (res.error && SESSION_EXPIRY_CODES[res.error]) {
+      const err = new Error(SESSION_EXPIRY_CODES[res.error]);
+      err.error = res.error;
+      err.errorCode = res.error;
+      err.errorType = "SESSION_EXPIRED";
+      err.requiresReLogin = true;
+      warn("Session Status", `${SESSION_EXPIRY_CODES[res.error]} (Code: ${res.error})`);
+      throw err;
+    }
+
+    const ACCOUNT_ERROR_CODES = {
+      1357001: "Account blocked - Facebook detected automated behavior",
+      1357004: "Account checkpoint required - Please verify your account on facebook.com",
+      1357031: "Account temporarily locked - Too many login attempts",
+      1357033: "Account suspended - Violation of terms of service",
+      2056003: "Account restricted - Suspicious activity detected"
+    };
+
+    if (res.error && ACCOUNT_ERROR_CODES[res.error]) {
+      const err = new Error(ACCOUNT_ERROR_CODES[res.error]);
+      err.error = "Account security issue";
+      err.errorCode = res.error;
+      err.errorType = res.error === 1357004 ? "CHECKPOINT" : res.error === 1357031 ? "LOCKED" : "BLOCKED";
+      err.requiresReLogin = res.error === 1357004 || res.error === 1357031;
+      warn("Account Status", `${ACCOUNT_ERROR_CODES[res.error]} (Code: ${res.error})`);
+      throw err;
+    }
+
+    if (res.error === 1357001 || (res.errorSummary && res.errorSummary.includes("blocked"))) {
+      const err = new Error("Facebook blocked the login");
+      err.error = "Not logged in.";
+      err.errorType = "BLOCKED";
+      throw err;
+    }
+
+    const resStr = JSON.stringify(res);
+    
+    if (resStr.includes("XCheckpointFBScrapingWarningController") || resStr.includes("601051028565049")) {
+      warn("Bot Detection", "Facebook checkpoint detected - scraping warning (601051028565049)");
+      const err = new Error("Facebook detected automated behavior - Account may be flagged");
+      err.error = "Bot checkpoint detected";
+      err.errorCode = "CHECKPOINT_SCRAPING";
+      err.errorType = "BOT_DETECTION";
+      err.requiresReLogin = true;
+      throw err;
+    }
+
+    if (resStr.includes("1501092823525282")) {
+      warn("Bot Detection", "Critical bot checkpoint 282 detected! Account requires immediate attention!");
+      log("Please check your Facebook account in a browser and complete any security checks.");
+      const err = new Error("Facebook detected automated behavior - Critical checkpoint required");
+      err.error = "Critical bot checkpoint";
+      err.errorCode = "CHECKPOINT_282";
+      err.errorType = "BOT_DETECTION_CRITICAL";
+      err.requiresReLogin = true;
+      throw err;
+    }
+
+    if (resStr.includes("828281030927956")) {
+      warn("Bot Detection", "Bot checkpoint 956 detected - Account may be restricted");
+      log("Please verify your Facebook account status in a browser.");
+    }
+
+    if (resStr.includes("https://www.facebook.com/login.php?") || String(res.redirect || "").includes("login.php?")) {
+      warn("Session Status", "Redirected to login page - Session expired");
+      const err = new Error("Session expired - Redirected to login page");
+      err.error = 401;
+      err.errorCode = 401;
+      err.errorType = "LOGIN_REDIRECT";
+      err.requiresReLogin = true;
+      throw err;
+    }
+
+    if (typeof data.body === 'string' && (data.body.includes('<title>Facebook - Log In or Sign Up</title>') || data.body.includes('name="login_form"'))) {
+      const err = new Error("Session expired - Redirected to login page");
+      err.error = 401;
+      err.errorCode = 401;
+      err.errorType = "LOGIN_REDIRECT";
+      err.requiresReLogin = true;
+      warn("Session Status", "Detected login page redirect. Session expired.");
+      throw err;
+    }
+
+    return res;
+  };
+}
+
+/**
+ * Saves cookies from a response to the cookie jar.
+ * @param {Object} jar - The cookie jar instance.
+ * @returns {function(res: Object): Object} A function that processes the response and returns it.
+ */
+function saveCookies(jar) {
+  return function (res) {
+    const cookies = res.headers["set-cookie"] || [];
+    cookies.forEach(function (c) {
+      if (c.indexOf(".facebook.com") > -1) {
+        jar.setCookie(c, "https://www.facebook.com");
+      }
+      const c2 = c.replace(/domain=\.facebook\.com/, "domain=.messenger.com");
+      jar.setCookie(c2, "https://www.messenger.com");
+    });
+    return res;
+  };
+}
+
+/**
+ * Retrieves an access token from a business account page.
+ * @param {Object} jar - The cookie jar instance.
+ * @param {Object} Options - Global request options.
+ * @returns {function(res: Object): Promise<[string, string|null]>}
+ */
+function getAccessFromBusiness(jar, Options) {
+  return async function (res) {
+    const html = res ? res.body : null;
+    const { get } = require("./request");
+    try {
+        const businessRes = await get("https://business.facebook.com/content_management", jar, null, Options, null, { noRef: true });
+        const token = /"accessToken":"([^.]+)","clientID":/g.exec(businessRes.body)[1];
+        return [html, token];
+    } catch (e) {
+        return [html, null];
+    }
+  };
+}
+
+/**
+ * Retrieves all cookies from the jar for both Facebook and Messenger domains.
+ * @param {Object} jar - The cookie jar instance.
+ * @returns {Array<Object>} An array of cookie objects.
+ */
+function getAppState(jar) {
+  return jar
+    .getCookiesSync("https://www.facebook.com")
+    .concat(jar.getCookiesSync("https://www.messenger.com"));
+}
+
+module.exports = {
+  parseAndCheckLogin,
+  saveCookies,
+  getAccessFromBusiness,
+  getAppState,
+};

package/src/utils/constants.js

@@ -0,0 +1,396 @@
+/* eslint-disable no-prototype-builtins */
+"use strict";
+
+const chalk = require("chalk");
+const gradient = require("gradient-string");
+
+const brandGradient = gradient(["#0061ff", "#681297"]);
+const successGradient = gradient(["#00ff87", "#60efff"]);
+const errorGradient = gradient(["#ff0000", "#ff006e"]);
+const warnGradient = gradient(["#ffbe0b", "#fb5607"]);
+const infoGradient = gradient(["#3a86ff", "#8338ec"]);
+const debugGradient = gradient(["#06ffa5", "#00d9ff"]);
+
+const ws = brandGradient("NeoKEX - FCA");
+
+let h;
+const i = {};
+const 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 () {
+  const l = [];
+  for (const m in j) {
+    i[j[m]] = m;
+    l.push(j[m]);
+  }
+  l.reverse();
+  h = new RegExp(l.join("|"), "g");
+})();
+
+const NUM_TO_MONTH = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+const NUM_TO_DAY = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+function getRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function padZeros(val, len) {
+  val = String(val);
+  len = len || 2;
+  while (val.length < len) val = "0" + val;
+  return val;
+}
+
+function generateThreadingID(clientID) {
+  const k = Date.now();
+  const l = Math.floor(Math.random() * 4294967295);
+  const m = clientID;
+  return "<" + k + ":" + l + "-" + m + "@mail.projektitan.com>";
+}
+
+function binaryToDecimal(data) {
+  let ret = "";
+  while (data !== "0") {
+    let end = 0;
+    let fullName = "";
+    let i = 0;
+    for (; i < data.length; i++) {
+      end = 2 * end + parseInt(data[i], 10);
+      if (end >= 10) {
+        fullName += "1";
+        end -= 10;
+      } else {
+        fullName += "0";
+      }
+    }
+    ret = end.toString() + ret;
+    data = fullName.slice(fullName.indexOf("1"));
+  }
+  return ret;
+}
+
+function generateOfflineThreadingID() {
+  const ret = Date.now();
+  const value = Math.floor(Math.random() * 4294967295);
+  const str = ("0000000000000000000000" + value.toString(2)).slice(-22);
+  const msgs = ret.toString(2) + str;
+  return binaryToDecimal(msgs);
+}
+
+function presenceEncode(str) {
+  return encodeURIComponent(str)
+    .replace(/([_A-Z])|%../g, function (m, n) {
+      return n ? "%" + n.charCodeAt(0).toString(16) : m;
+    })
+    .toLowerCase()
+    .replace(h, function (m) {
+      return i[m];
+    });
+}
+
+function presenceDecode(str) {
+  return decodeURIComponent(
+    str.replace(/[_A-Z]/g, function (m) {
+      return j[m];
+    })
+  );
+}
+
+function generatePresence(userID) {
+  const time = Date.now();
+  return (
+    "E" +
+    presenceEncode(
+      JSON.stringify({
+        v: 3,
+        time: parseInt(time / 1000, 10),
+        user: userID,
+        state: {
+          ut: 0,
+          t2: [],
+          lm2: null,
+          uct2: time,
+          tr: null,
+          tw: Math.floor(Math.random() * 4294967295) + 1,
+          at: time,
+        },
+        ch: {
+          ["p_" + userID]: 0,
+        },
+      })
+    )
+  );
+}
+
+function generateAccessiblityCookie() {
+  const time = Date.now();
+  return encodeURIComponent(
+    JSON.stringify({
+      sr: 0,
+      "sr-ts": time,
+      jk: 0,
+      "jk-ts": time,
+      kb: 0,
+      "kb-ts": time,
+      hcm: 0,
+      "hcm-ts": time,
+    })
+  );
+}
+
+function getGUID() {
+  let sectionLength = Date.now();
+  const id = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = Math.floor((sectionLength + Math.random() * 16) % 16);
+    sectionLength = Math.floor(sectionLength / 16);
+    const _guid = (c == "x" ? r : (r & 7) | 8).toString(16);
+    return _guid;
+  });
+  return id;
+}
+
+function getFrom(str, startToken, endToken) {
+  const start = str.indexOf(startToken) + startToken.length;
+  if (start < startToken.length) return "";
+
+  const lastHalf = str.substring(start);
+  const end = lastHalf.indexOf(endToken);
+  if (end === -1) {
+    throw Error(
+      "Could not find endTime `" + endToken + "` in the given string."
+    );
+  }
+  return lastHalf.substring(0, end);
+}
+
+function makeParsable(html) {
+  const withoutForLoop = html.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, "");
+  const maybeMultipleObjects = withoutForLoop.split(/\}\r\n *\{/);
+  if (maybeMultipleObjects.length === 1) return maybeMultipleObjects;
+
+  return "[" + maybeMultipleObjects.join("},{") + "]";
+}
+
+function arrToForm(form) {
+  return arrayToObject(
+    form,
+    function (v) {
+      return v.name;
+    },
+    function (v) {
+      return v.val;
+    }
+  );
+}
+
+function arrayToObject(arr, getKey, getValue) {
+  return arr.reduce(function (acc, val) {
+    acc[getKey(val)] = getValue(val);
+    return acc;
+  }, {});
+}
+
+function getSignatureID() {
+  return Math.floor(Math.random() * 2147483648).toString(16);
+}
+
+function generateTimestampRelative() {
+  const d = new Date();
+  return d.getHours() + ":" + padZeros(d.getMinutes());
+}
+
+function getType(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+
+let logging = true;
+let logLevel = 'info';
+
+const logLevels = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  silent: 5
+};
+
+function logOptions(bool) {
+  logging = bool;
+}
+
+function setLogLevel(level) {
+  if (logLevels.hasOwnProperty(level)) {
+    logLevel = level;
+  }
+}
+
+function getTimestamp() {
+  const now = new Date();
+  return chalk.gray.dim(`[${padZeros(now.getHours())}:${padZeros(now.getMinutes())}:${padZeros(now.getSeconds())}]`);
+}
+
+function shouldLog(level) {
+  return logging && logLevels[level] >= logLevels[logLevel];
+}
+
+function trace(...args) {
+  if (!shouldLog('trace')) return;
+  console.log(getTimestamp(), ws, debugGradient("◆ TRACE"), chalk.cyan(...args));
+}
+
+function debug(...args) {
+  if (!shouldLog('debug')) return;
+  console.log(getTimestamp(), ws, debugGradient("◆ DEBUG"), chalk.blue(...args));
+}
+
+function info(...args) {
+  if (!shouldLog('info')) return;
+  console.log(getTimestamp(), ws, infoGradient("◆ INFO"), chalk.white(...args));
+}
+
+function log(...args) {
+  if (!shouldLog('info')) return;
+  console.log(getTimestamp(), ws, successGradient("◆ LOG"), chalk.green(...args));
+}
+
+function success(...args) {
+  if (logging === false) return;
+  console.log(getTimestamp(), ws, successGradient("✓ SUCCESS"), chalk.greenBright.bold(...args));
+}
+
+function warn(...args) {
+  if (!shouldLog('warn')) return;
+  console.warn(getTimestamp(), ws, warnGradient("⚠ WARNING"), chalk.yellow(...args));
+}
+
+function error(...args) {
+  if (!shouldLog('error')) return;
+  console.error(getTimestamp(), ws, errorGradient("✖ ERROR"), chalk.red.bold(...args));
+}
+
+function critical(...args) {
+  if (!shouldLog('error')) return;
+  console.error(getTimestamp(), ws, errorGradient("☠ CRITICAL"), chalk.bgRed.white.bold(...args));
+}
+
+function banner(message, color = 'cyan') {
+  if (!shouldLog('info')) return;
+  const line = '═'.repeat(message.length + 4);
+  const colorFunc = chalk[color] || chalk.cyan;
+  console.log(colorFunc(`╔${line}╗`));
+  console.log(colorFunc(`║  ${message}  ║`));
+  console.log(colorFunc(`╚${line}╝`));
+}
+
+function box(title, content, style = 'info') {
+  if (!shouldLog('info')) return;
+  const contentLines = Array.isArray(content) ? content : [content];
+  const maxLength = Math.max(title.length, ...contentLines.map(l => String(l).length));
+  const topLine = '┌─' + '─'.repeat(maxLength + 2) + '─┐';
+  const bottomLine = '└─' + '─'.repeat(maxLength + 2) + '─┘';
+  const titleLine = `│ ${chalk.bold(title)}${' '.repeat(maxLength - title.length + 1)} │`;
+  
+  const colorMap = {
+    info: chalk.cyan,
+    success: chalk.green,
+    warn: chalk.yellow,
+    error: chalk.red,
+    debug: chalk.blue
+  };
+  
+  const colorFunc = colorMap[style] || chalk.cyan;
+  
+  console.log(colorFunc(topLine));
+  console.log(colorFunc(titleLine));
+  console.log(colorFunc('├─' + '─'.repeat(maxLength + 2) + '─┤'));
+  contentLines.forEach(line => {
+    const paddedLine = String(line) + ' '.repeat(maxLength - String(line).length);
+    console.log(colorFunc(`│ ${paddedLine} │`));
+  });
+  console.log(colorFunc(bottomLine));
+}
+
+module.exports = {
+  ws,
+  chalk,
+  gradient,
+  brandGradient,
+  successGradient,
+  errorGradient,
+  warnGradient,
+  infoGradient,
+  debugGradient,
+  logOptions,
+  setLogLevel,
+  trace,
+  debug,
+  info,
+  log,
+  success,
+  warn,
+  error,
+  critical,
+  banner,
+  box,
+  getRandom,
+  padZeros,
+  generateThreadingID,
+  binaryToDecimal,
+  generateOfflineThreadingID,
+  presenceEncode,
+  presenceDecode,
+  generatePresence,
+  generateAccessiblityCookie,
+  getGUID,
+  getFrom,
+  makeParsable,
+  arrToForm,
+  arrayToObject, 
+  getSignatureID,
+  generateTimestampRelative,
+  getType,
+  NUM_TO_MONTH,
+  NUM_TO_DAY,
+};