ayman-fca 1.0.0

package/src/utils/format/ids.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const { padZeros } = require("./utils");
+
+function binaryToDecimal(data) {
+  var ret = "";
+  while (data !== "0") {
+    var end = 0;
+    var fullName = "";
+    var 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() {
+  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);
+}
+
+function generateThreadingID(clientID) {
+  var k = Date.now();
+  var l = Math.floor(Math.random() * 4294967295);
+  var m = clientID;
+  return "<" + k + ":" + l + "-" + m + "@mail.projektitan.com>";
+}
+
+function getGUID() {
+  var sectionLength = Date.now();
+  var id = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
+    /[xy]/g,
+    function (c) {
+      var r = Math.floor((sectionLength + Math.random() * 16) % 16);
+      sectionLength = Math.floor(sectionLength / 16);
+      var _guid = (c == "x" ? r : (r & 7) | 8).toString(16);
+      return _guid;
+    },
+  );
+  return id;
+}
+
+function generateTimestampRelative() {
+  var d = new Date();
+  return d.getHours() + ":" + padZeros(d.getMinutes());
+}
+
+module.exports = {
+  binaryToDecimal,
+  generateOfflineThreadingID,
+  generateThreadingID,
+  getGUID,
+  generateTimestampRelative,
+};

package/src/utils/format/index.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const utils = require("./utils");
+const ids = require("./ids");
+const date = require("./date");
+const presence = require("./presence");
+const attachment = require("./attachment");
+const delta = require("./delta");
+const message = require("./message");
+const readTyp = require("./readTyp");
+const thread = require("./thread");
+const decode = require("./decode");
+const cookie = require("./cookie");
+
+module.exports = {
+  getType: utils.getType,
+  formatID: utils.formatID,
+  padZeros: utils.padZeros,
+  arrayToObject: utils.arrayToObject,
+  arrToForm: utils.arrToForm,
+  getData_Path: utils.getData_Path,
+  setData_Path: utils.setData_Path,
+  getPaths: utils.getPaths,
+  cleanHTML: utils.cleanHTML,
+  getCurrentTimestamp: utils.getCurrentTimestamp,
+  getSignatureID: utils.getSignatureID,
+
+  generateOfflineThreadingID: ids.generateOfflineThreadingID,
+  generateThreadingID: ids.generateThreadingID,
+  getGUID: ids.getGUID,
+  generateTimestampRelative: ids.generateTimestampRelative,
+
+  formatDate: date.formatDate,
+
+  presenceEncode: presence.presenceEncode,
+  presenceDecode: presence.presenceDecode,
+  generatePresence: presence.generatePresence,
+  generateAccessiblityCookie: presence.generateAccessiblityCookie,
+  formatProxyPresence: presence.formatProxyPresence,
+  formatPresence: presence.formatPresence,
+
+  _formatAttachment: attachment._formatAttachment,
+  formatAttachment: attachment.formatAttachment,
+
+  getAdminTextMessageType: delta.getAdminTextMessageType,
+  formatDeltaEvent: delta.formatDeltaEvent,
+  formatDeltaMessage: delta.formatDeltaMessage,
+  getMentionsFromDeltaMessage: delta.getMentionsFromDeltaMessage,
+  formatDeltaReadReceipt: delta.formatDeltaReadReceipt,
+
+  formatMessage: message.formatMessage,
+  formatEvent: message.formatEvent,
+  formatHistoryMessage: message.formatHistoryMessage,
+
+  formatReadReceipt: readTyp.formatReadReceipt,
+  formatRead: readTyp.formatRead,
+  formatTyp: readTyp.formatTyp,
+
+  formatThread: thread.formatThread,
+
+  decodeClientPayload: decode.decodeClientPayload,
+
+  formatCookie: cookie.formatCookie,
+};

package/src/utils/format/message.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const { formatID } = require("./utils");
+const { formatAttachment } = require("./attachment");
+const { getAdminTextMessageType } = require("./delta");
+
+function formatMessage(m) {
+  var originalMessage = m.message ? m.message : m;
+  var body = originalMessage.body || "";
+  var args = body == "" ? [] : body.trim().split(/\s+/);
+  var obj = {
+    type: "message",
+    senderName: originalMessage.sender_name,
+    senderID: formatID(originalMessage.sender_fbid.toString()),
+    participantNames: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.participant_names
+      : [originalMessage.sender_name.split(" ")[0]],
+    participantIDs: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.participant_ids.map(function (v) {
+          return formatID(v.toString());
+        })
+      : [formatID(originalMessage.sender_fbid)],
+    body: body,
+    args: args,
+    threadID: formatID(
+      (
+        originalMessage.thread_fbid || originalMessage.other_user_fbid
+      ).toString(),
+    ),
+    threadName: originalMessage.group_thread_info
+      ? originalMessage.group_thread_info.name
+      : originalMessage.sender_name,
+    location: originalMessage.coordinates ? originalMessage.coordinates : null,
+    messageID: originalMessage.mid
+      ? originalMessage.mid.toString()
+      : originalMessage.message_id,
+    attachments: formatAttachment(
+      originalMessage.attachments,
+      originalMessage.attachmentIds,
+      originalMessage.attachment_map,
+      originalMessage.share_map,
+    ),
+    timestamp: originalMessage.timestamp,
+    timestampAbsolute: originalMessage.timestamp_absolute,
+    timestampRelative: originalMessage.timestamp_relative,
+    timestampDatetime: originalMessage.timestamp_datetime,
+    tags: originalMessage.tags,
+    reactions: originalMessage.reactions ? originalMessage.reactions : [],
+    isUnread: originalMessage.is_unread,
+  };
+  if (m.type === "pages_messaging")
+    obj.pageID = m.realtime_viewer_fbid.toString();
+  obj.isGroup = obj.participantIDs.length > 2;
+  return obj;
+}
+
+function formatEvent(m) {
+  var originalMessage = m.message ? m.message : m;
+  var logMessageType = originalMessage.log_message_type;
+  var logMessageData;
+  if (logMessageType === "log:generic-admin-text") {
+    logMessageData = originalMessage.log_message_data.untypedData;
+    logMessageType = getAdminTextMessageType(
+      originalMessage.log_message_data.message_type,
+    );
+  } else logMessageData = originalMessage.log_message_data;
+  return Object.assign(formatMessage(originalMessage), {
+    type: "event",
+    logMessageType: logMessageType,
+    logMessageData: logMessageData,
+    logMessageBody: originalMessage.log_message_body,
+  });
+}
+
+function formatHistoryMessage(m) {
+  switch (m.action_type) {
+    case "ma-type:log-message":
+      return formatEvent(m);
+    default:
+      return formatMessage(m);
+  }
+}
+
+module.exports = {
+  formatMessage,
+  formatEvent,
+  formatHistoryMessage,
+};

package/src/utils/format/presence.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var PRESENCE_MAP = {
+  _: "%",
+  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",
+};
+
+var PRESENCE_REVERSE = {};
+var PRESENCE_REGEX;
+(function () {
+  var l = [];
+  for (var m in PRESENCE_MAP) {
+    PRESENCE_REVERSE[PRESENCE_MAP[m]] = m;
+    l.push(PRESENCE_MAP[m]);
+  }
+  l.reverse();
+  PRESENCE_REGEX = new RegExp(l.join("|"), "g");
+})();
+
+function presenceEncode(str) {
+  return encodeURIComponent(str)
+    .replace(/([_A-Z])|%../g, function (m, n) {
+      return n ? "%" + n.charCodeAt(0).toString(16) : m;
+    })
+    .toLowerCase()
+    .replace(PRESENCE_REGEX, function (m) {
+      return PRESENCE_REVERSE[m];
+    });
+}
+
+function presenceDecode(str) {
+  return decodeURIComponent(
+    str.replace(/[_A-Z]/g, function (m) {
+      return PRESENCE_MAP[m];
+    }),
+  );
+}
+
+function generatePresence(userID) {
+  var 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() {
+  var 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 formatProxyPresence(presence, userID) {
+  if (presence.lat === undefined || presence.p === undefined) return null;
+  return {
+    type: "presence",
+    timestamp: presence.lat * 1000,
+    userID: userID || "",
+    statuses: presence.p,
+  };
+}
+
+function formatPresence(presence, userID) {
+  return {
+    type: "presence",
+    timestamp: presence.la * 1000,
+    userID: userID || "",
+    statuses: presence.a,
+  };
+}
+
+module.exports = {
+  presenceEncode,
+  presenceDecode,
+  generatePresence,
+  generateAccessiblityCookie,
+  formatProxyPresence,
+  formatPresence,
+};

package/src/utils/format/readTyp.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { formatID } = require("./utils");
+
+function formatReadReceipt(event) {
+  return {
+    reader: event.reader.toString(),
+    time: event.time,
+    threadID: formatID((event.thread_fbid || event.reader).toString()),
+    type: "read_receipt",
+  };
+}
+
+function formatRead(event) {
+  return {
+    threadID: formatID(
+      (
+        (event.chat_ids && event.chat_ids[0]) ||
+        (event.thread_fbids && event.thread_fbids[0])
+      ).toString(),
+    ),
+    time: event.timestamp,
+    type: "read",
+  };
+}
+
+function formatTyp(event) {
+  return {
+    isTyping: !!event.st,
+    from: event.from.toString(),
+    threadID: formatID(
+      (event.to || event.thread_fbid || event.from).toString(),
+    ),
+    fromMobile: event.hasOwnProperty("from_mobile") ? event.from_mobile : true,
+    userID: (event.realtime_viewer_fbid || event.from).toString(),
+    type: "typ",
+  };
+}
+
+module.exports = {
+  formatReadReceipt,
+  formatRead,
+  formatTyp,
+};

package/src/utils/format/thread.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { formatID } = require("./utils");
+
+function formatThread(data) {
+  return {
+    threadID: formatID(data.thread_fbid.toString()),
+    participants: data.participants.map(formatID),
+    participantIDs: data.participants.map(formatID),
+    name: data.name,
+    nicknames: data.custom_nickname,
+    snippet: data.snippet,
+    snippetAttachments: data.snippet_attachments,
+    snippetSender: formatID((data.snippet_sender || "").toString()),
+    unreadCount: data.unread_count,
+    messageCount: data.message_count,
+    imageSrc: data.image_src,
+    timestamp: data.timestamp,
+    muteUntil: data.mute_until,
+    isCanonicalUser: data.is_canonical_user,
+    isCanonical: data.is_canonical,
+    isSubscribed: data.is_subscribed,
+    folder: data.folder,
+    isArchived: data.is_archived,
+    recipientsLoadable: data.recipients_loadable,
+    hasEmailParticipant: data.has_email_participant,
+    readOnly: data.read_only,
+    canReply: data.can_reply,
+    cannotReplyReason: data.cannot_reply_reason,
+    lastMessageTimestamp: data.last_message_timestamp,
+    lastReadTimestamp: data.last_read_timestamp,
+    lastMessageType: data.last_message_type,
+    emoji: data.custom_like_icon,
+    color: data.custom_color,
+    adminIDs: data.admin_ids,
+    threadType: data.thread_type,
+  };
+}
+
+module.exports = {
+  formatThread,
+};

package/src/utils/format/utils.js

@@ -0,0 +1,141 @@
+"use strict";
+
+function getType(obj) {
+  return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+function formatID(id) {
+  if (id != undefined && id != null) return id.replace(/(fb)?id[:.]/, "");
+  else return id;
+}
+
+function padZeros(val, len) {
+  val = String(val);
+  len = len || 2;
+  while (val.length < len) val = "0" + val;
+  return val;
+}
+
+function arrayToObject(arr, getKey, getValue) {
+  return arr.reduce(function (acc, val) {
+    acc[getKey(val)] = getValue(val);
+    return acc;
+  }, {});
+}
+
+function arrToForm(form) {
+  return arrayToObject(
+    form,
+    function (v) {
+      return v.name;
+    },
+    function (v) {
+      return v.val;
+    },
+  );
+}
+
+function getData_Path(Obj, Arr, Stt) {
+  if (Arr.length === 0 && Obj != undefined) {
+    return Obj;
+  } else if (Obj == undefined) {
+    return Stt;
+  }
+  const head = Arr[0];
+  if (head == undefined) {
+    return Stt;
+  }
+  const tail = Arr.slice(1);
+  return getData_Path(Obj[head], tail, Stt++);
+}
+
+function setData_Path(obj, path, value) {
+  if (!path.length) {
+    return obj;
+  }
+  const currentKey = path[0];
+  let currentObj = obj[currentKey];
+
+  if (!currentObj) {
+    obj[currentKey] = value;
+    currentObj = obj[currentKey];
+  }
+  path.shift();
+  if (!path.length) {
+    currentObj = value;
+  } else {
+    currentObj = setData_Path(currentObj, path, value);
+  }
+
+  return obj;
+}
+
+function getPaths(obj, parentPath = []) {
+  let paths = [];
+  for (let prop in obj) {
+    if (typeof obj[prop] === "object") {
+      paths = paths.concat(getPaths(obj[prop], [...parentPath, prop]));
+    } else {
+      paths.push([...parentPath, prop]);
+    }
+  }
+  return paths;
+}
+
+function cleanHTML(text) {
+  text = text.replace(
+    /(<br>)|(<\/?i>)|(<\/?em>)|(<\/?b>)|(!?~)|(&amp;)|(&#039;)|(&lt;)|(&gt;)|(&quot;)/g,
+    (match) => {
+      switch (match) {
+        case "<br>":
+          return "\n";
+        case "<i>":
+        case "<em>":
+        case "</i>":
+        case "</em>":
+          return "*";
+        case "<b>":
+        case "</b>":
+          return "**";
+        case "~!":
+        case "!~":
+          return "||";
+        case "&amp;":
+          return "&";
+        case "&#039;":
+          return "'";
+        case "&lt;":
+          return "<";
+        case "&gt;":
+          return ">";
+        case "&quot;":
+          return '"';
+      }
+    },
+  );
+  return text;
+}
+
+function getCurrentTimestamp() {
+  const date = new Date();
+  const unixTime = date.getTime();
+  return unixTime;
+}
+
+function getSignatureID() {
+  return Math.floor(Math.random() * 2147483648).toString(16);
+}
+
+module.exports = {
+  getType,
+  formatID,
+  padZeros,
+  arrayToObject,
+  arrToForm,
+  getData_Path,
+  setData_Path,
+  getPaths,
+  cleanHTML,
+  getCurrentTimestamp,
+  getSignatureID,
+};

package/src/utils/headers.js

@@ -0,0 +1,96 @@
+// ============================================================
+//  AYMAN-FCA v2.0 — Smart Headers + Random User-Agent
+//  © 2025 Ayman. All Rights Reserved.
+//  مستوحى من: ws3-fca | مطوَّر بالكامل بواسطة أيمن
+//
+//  السر الأول لاستمرارية الجلسة:
+//  كل request يستخدم User-Agent مختلف لتجنب كشف البوت
+// ============================================================
+"use strict";
+
+// ✅ قائمة Chrome versions حقيقية لتغيير عشوائي
+const CHROME_VERSIONS = [
+  "120.0.0.0","121.0.0.0","122.0.0.0","123.0.0.0",
+  "124.0.0.0","125.0.0.0","126.0.0.0","127.0.0.0"
+];
+
+const PLATFORMS = [
+  { os: "Windows NT 10.0; Win64; x64",          platform: "Windows", version: '"15.0.0"' },
+  { os: "Macintosh; Intel Mac OS X 10_15_7",    platform: "macOS",   version: '"13.6.0"' },
+  { os: "X11; Linux x86_64",                    platform: "Linux",   version: '"6.1.0"'  }
+];
+
+function getRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+// ✅ يُولّد User-Agent + Sec-CH headers حقيقية عشوائية
+function randomUserAgent() {
+  const platform = getRandom(PLATFORMS);
+  const version  = getRandom(CHROME_VERSIONS);
+  const major    = version.split(".")[0];
+
+  const userAgent = `Mozilla/5.0 (${platform.os}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36`;
+
+  const secChUa = `"Not/A)Brand";v="8", "Chromium";v="${major}", "Google Chrome";v="${major}"`;
+
+  return {
+    userAgent,
+    secChUa,
+    secChUaPlatform:        `"${platform.platform}"`,
+    secChUaPlatformVersion: platform.version,
+    secChUaMobile:          "?0"
+  };
+}
+
+// ✅ Headers شاملة تُحاكي المتصفح الحقيقي
+function getHeaders(url, options, ctx, customHeader) {
+  let host;
+  try { host = new URL(url).hostname; } catch { host = "www.facebook.com"; }
+
+  const { userAgent, secChUa, secChUaPlatform, secChUaPlatformVersion, secChUaMobile }
+    = randomUserAgent();
+
+  const ua = options?.userAgent || ctx?.globalOptions?.userAgent || userAgent;
+
+  const headers = {
+    "Accept":                    "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+    "Accept-Encoding":           "gzip, deflate, br",
+    "Accept-Language":           "ar,en-US;q=0.9,en;q=0.8",
+    "Cache-Control":             "max-age=0",
+    "Connection":                "keep-alive",
+    "Content-Type":              "application/x-www-form-urlencoded",
+    "Host":                      host,
+    "Origin":                    `https://${host}`,
+    "Referer":                   `https://${host}/`,
+    "Sec-Ch-Ua":                 secChUa,
+    "Sec-Ch-Ua-Mobile":          secChUaMobile,
+    "Sec-Ch-Ua-Platform":        secChUaPlatform,
+    "Sec-Ch-Ua-Platform-Version": secChUaPlatformVersion,
+    "Sec-Fetch-Dest":            "document",
+    "Sec-Fetch-Mode":            "navigate",
+    "Sec-Fetch-Site":            "same-origin",
+    "Sec-Fetch-User":            "?1",
+    "Upgrade-Insecure-Requests": "1",
+    "User-Agent":                ua,
+    "Viewport-Width":            "1920",
+    "Dpr":                       "1"
+  };
+
+  // ✅ إضافة رؤوس المنطقة لتسريع الاتصال
+  if (ctx?.region) {
+    headers["X-MSGR-Region"] = ctx.region;
+  }
+
+  // ✅ merge custom headers
+  if (customHeader && typeof customHeader === "object") {
+    for (const [k, v] of Object.entries(customHeader)) {
+      if (k !== "noRef") headers[k] = v;
+    }
+    if (customHeader.noRef) delete headers["Referer"];
+  }
+
+  return headers;
+}
+
+module.exports = { getHeaders, randomUserAgent };