@eryxenx/fca 1.0.0

package/src/api/socket/OldMessage.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var utils = require("../../utils/nexca-utils");
+var logger = require("../../utils/nexca-logger");
+var bluebird = require("bluebird");
+
+var allowedProperties = {
+    attachment: true, url: true, sticker: true, emoji: true,
+    emojiSize: true, body: true, mentions: true, location: true,
+};
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+    function uploadAttachment(attachments, callback) {
+        var uploads = [];
+        for (var i = 0; i < attachments.length; i++) {
+            if (!utils.isReadableStream(attachments[i])) {
+                return callback({ error: "Attachment must be a readable stream." });
+            }
+            uploads.push(
+                defaultFuncs.postFormData("https://upload.facebook.com/ajax/mercury/upload.php", ctx.jar, {
+                    upload_1024: attachments[i],
+                    voice_clip: "true"
+                })
+                    .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+                    .then(resData => {
+                        if (resData.error) throw resData;
+                        return resData.payload.metadata[0];
+                    })
+            );
+        }
+        bluebird.all(uploads)
+            .then(resData => callback(null, resData))
+            .catch(err => { logger.error("OldMessage.upload", err); callback(err); });
+    }
+
+    function getUrl(url, callback) {
+        defaultFuncs.post("https://www.facebook.com/message_share_attachment/fromURI/", ctx.jar, {
+            image_height: 960, image_width: 960, uri: url
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) return callback(resData);
+                if (!resData.payload) return callback({ error: "Invalid URL" });
+                callback(null, resData.payload.share_data.share_params);
+            })
+            .catch(err => { logger.error("OldMessage.getUrl", err); callback(err); });
+    }
+
+    function sendContent(form, threadID, isSingleUser, messageAndOTID, callback) {
+        if (utils.getType(threadID) === "Array") {
+            for (var i = 0; i < threadID.length; i++) form["specific_to_list[" + i + "]"] = "fbid:" + threadID[i];
+            form["specific_to_list[" + threadID.length + "]"] = "fbid:" + ctx.userID;
+            form["client_thread_id"] = "root:" + messageAndOTID;
+        } else {
+            if (isSingleUser) {
+                form["specific_to_list[0]"] = "fbid:" + threadID;
+                form["specific_to_list[1]"] = "fbid:" + ctx.userID;
+                form["other_user_fbid"] = threadID;
+            } else {
+                form["thread_fbid"] = threadID;
+            }
+        }
+
+        if (ctx.globalOptions.pageID) {
+            form["author"] = "fbid:" + ctx.globalOptions.pageID;
+            form["specific_to_list[1]"] = "fbid:" + ctx.globalOptions.pageID;
+            form["creator_info[creatorID]"] = ctx.userID;
+            form["creator_info[creatorType]"] = "direct_admin";
+        }
+
+        defaultFuncs.post("https://www.facebook.com/messaging/send/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (!resData.payload) throw resData;
+                var messageID = (resData.payload.actions && resData.payload.actions[0] &&
+                    resData.payload.actions[0].message_id) || null;
+                var threadID2 = resData.payload.thread_fbid ||
+                    (resData.payload.actions && resData.payload.actions[0] && resData.payload.actions[0].thread_fbid);
+                callback(null, {
+                    threadID: threadID2 ? String(threadID2) : String(threadID),
+                    messageID: messageID ? String(messageID) : null,
+                    timestamp: resData.payload.timestamp
+                });
+            })
+            .catch(err => { logger.error("OldMessage.send", err); callback(err); });
+    }
+
+    function send(form, threadID, isSingleUser, callback) {
+        var messageAndOTID = utils.generateOfflineThreadingID();
+        form.client = "mercury";
+        form.action_type = "ma-type:user-generated-message";
+        form.timestamp = Date.now();
+        form.timestamp_absolute = "Today";
+        form.timestamp_relative = "12:00";
+        form.timestamp_time_passed = "0";
+        form.is_unread = false;
+        form.is_cleared = false;
+        form.is_forward = false;
+        form.is_filtered_content = false;
+        form.is_filtered_content_bec = false;
+        form.is_filtered_content_account = false;
+        form.is_filtered_content_quasar = false;
+        form.is_filtered_content_invalid_app = false;
+        form.is_not_supported = false;
+        form.message_id = messageAndOTID;
+        form.offline_threading_id = messageAndOTID;
+        form.ephemeral_ttl_mode = 0;
+        form.manual_retry_cnt = 0;
+        form.has_attachment = false;
+        form.signatureID = utils.getGUID().replace(/-/g, "").slice(0, 8);
+        sendContent(form, threadID, isSingleUser, messageAndOTID, callback);
+    }
+
+    return function OldMessage(msg, threadID, callback, replyToMessage, isSingleUser) {
+        if (typeof msg === "string") msg = { body: msg };
+
+        if (msg.body && /(https?:\/\/|www\.|t\.me\/|fb\.me\/|youtu\.be\/|facebook\.com\/|youtube\.com\/)/i.test(msg.body)) {
+            return require('./sendMessage')(defaultFuncs, api, ctx)(msg, threadID, callback, replyToMessage, false);
+        }
+
+        var resolveFunc = () => { };
+        var rejectFunc = () => { };
+        var promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+        if (!callback) {
+            callback = (err, data) => err ? rejectFunc(err) : resolveFunc(data);
+        }
+
+        for (var key in msg) {
+            if (!allowedProperties[key]) {
+                return callback({ error: "OldMessage: Unknown property '" + key + "'" });
+            }
+        }
+
+        var form = {};
+        if (msg.body) form.body = msg.body;
+
+        if (msg.mentions && Array.isArray(msg.mentions)) {
+            form.body = msg.body || "";
+            form['profile_to_mention[0]'] = msg.mentions.map(m => m.id).join(",");
+        }
+
+        if (replyToMessage) form.replied_to_message_id = replyToMessage;
+
+        if (msg.sticker) {
+            form["has_attachment"] = true;
+            form["sticker_id"] = msg.sticker;
+            return send(form, threadID, isSingleUser, callback);
+        }
+
+        if (msg.emoji) {
+            form.body = msg.emoji;
+            var size = msg.emojiSize || "small";
+            form["emoji_size"] = size;
+            return send(form, threadID, isSingleUser, callback);
+        }
+
+        if (msg.url) {
+            return getUrl(msg.url, (err, shareData) => {
+                if (err) return callback(err);
+                form["has_attachment"] = true;
+                form["image_ids[0]"] = shareData.image_ids && shareData.image_ids[0];
+                form["share_params"] = JSON.stringify(shareData);
+                send(form, threadID, isSingleUser, callback);
+            });
+        }
+
+        if (msg.attachment) {
+            var attachments = Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment];
+            return uploadAttachment(attachments, (err, uploaded) => {
+                if (err) return callback(err);
+                form["has_attachment"] = true;
+                uploaded.forEach((u, i) => {
+                    if (u.image_id) form["image_ids[" + i + "]"] = u.image_id;
+                    else if (u.video_id) form["video_ids[" + i + "]"] = u.video_id;
+                    else if (u.file_id) form["file_ids[" + i + "]"] = u.file_id;
+                    else if (u.audio_id) form["audio_ids[" + i + "]"] = u.audio_id;
+                });
+                send(form, threadID, isSingleUser, callback);
+            });
+        }
+
+        send(form, threadID, isSingleUser, callback);
+        return promise;
+    };
+};

package/src/api/socket/core/connectMqtt.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * MQTT/WebSocket listener for Facebook Messenger real-time events.
+ * Connects to edge-chat.facebook.com, subscribes to topics, parses deltas and typing/presence.
+ */
+const { formatID } = require("../../../utils/format");
+
+const DEFAULT_RECONNECT_DELAY_MS = 2000;
+const T_MS_WAIT_TIMEOUT_MS = 5000;
+
+module.exports = function createListenMqtt(deps) {
+  const { WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy,
+    topics, parseDelta, getTaskResponseData, logger, emitAuth
+  } = deps;
+
+  return function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
+
+    function scheduleReconnect(delayMs) {
+      const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || DEFAULT_RECONNECT_DELAY_MS;
+      const ms = typeof delayMs === "number" ? delayMs : d;
+      if (ctx._reconnectTimer) {
+        logger("mqtt reconnect already scheduled", "warn");
+        return; // debounce
+      }
+      if (ctx._ending) {
+        logger("mqtt reconnect skipped - ending", "warn");
+        return;
+      }
+      logger(`mqtt will reconnect in ${ms}ms`, "warn");
+      ctx._reconnectTimer = setTimeout(() => {
+        ctx._reconnectTimer = null;
+        if (!ctx._ending) {
+          listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        }
+      }, ms);
+    }
+    function isEndingLikeError(msg) {
+      return /No subscription existed|client disconnecting|socket hang up|ECONNRESET/i.test(msg || "");
+    }
+
+    const chatOn = ctx.globalOptions.online;
+    const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+    const username = {
+      u: ctx.userID, s: sessionID, chat_on: chatOn, fg: false, d: ctx.clientId,
+      ct: "websocket", aid: 219994525426954, aids: null, mqtt_sid: "",
+      cp: 3, ecp: 10, st: [], pm: [], dc: "", no_auto_fg: true, gas: null, pack: [], p: null, php_override: ""
+    };
+
+    const cookies = api.getCookies();
+    let host;
+    if (ctx.mqttEndpoint) host = `${ctx.mqttEndpoint}&sid=${sessionID}&cid=${ctx.clientId}`;
+    else if (ctx.region) host = `wss://edge-chat.facebook.com/chat?region=${ctx.region.toLowerCase()}&sid=${sessionID}&cid=${ctx.clientId}`;
+    else host = `wss://edge-chat.facebook.com/chat?sid=${sessionID}&cid=${ctx.clientId}`;
+
+    const options = {
+      clientId: "mqttwsclient",
+      protocolId: "MQIsdp",
+      protocolVersion: 3,
+      username: JSON.stringify(username),
+      clean: true,
+      wsOptions: {
+        headers: {
+          Cookie: cookies,
+          Origin: "https://www.facebook.com",
+          "User-Agent": ctx.globalOptions.userAgent || "Mozilla/5.0",
+          Referer: "https://www.facebook.com/",
+          Host: "edge-chat.facebook.com",
+          Connection: "Upgrade",
+          Pragma: "no-cache",
+          "Cache-Control": "no-cache",
+          Upgrade: "websocket",
+          "Sec-WebSocket-Version": "13",
+          "Accept-Encoding": "gzip, deflate, br",
+          "Accept-Language": "vi,en;q=0.9",
+          "Sec-WebSocket-Extensions": "permessage-deflate; client_max_window_bits"
+        },
+        origin: "https://www.facebook.com",
+        protocolVersion: 13,
+        binaryType: "arraybuffer"
+      },
+      keepalive: 30,
+      reschedulePings: true,
+      reconnectPeriod: 0,
+      connectTimeout: 5000
+    };
+    if (ctx.globalOptions.proxy !== undefined) {
+      const agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+      options.wsOptions.agent = agent;
+    }
+
+    ctx.mqttClient = new mqtt.Client(
+      () => buildStream(options, new WebSocket(host, options.wsOptions), buildProxy()),
+      options
+    );
+    const mqttClient = ctx.mqttClient;
+
+    mqttClient.on("error", function (err) {
+      const msg = String(err && err.message ? err.message : err || "");
+      if ((ctx._ending || ctx._cycling) && /No subscription existed|client disconnecting/i.test(msg)) {
+        logger(`mqtt expected during shutdown: ${msg}`, "info");
+        return;
+      }
+
+      if (/Invalid header flag bits|must be 0x0 for puback/i.test(msg)) {
+        logger(`mqtt puback ignored: ${msg}`, "warn");
+        return;
+      }
+
+      if (/Not logged in|Not logged in.|blocked the login|401|403/i.test(msg)) {
+        try {
+          if (mqttClient && mqttClient.connected) {
+            mqttClient.end(true);
+          }
+        } catch (_) { }
+        return emitAuth(ctx, api, globalCallback,
+          /blocked/i.test(msg) ? "login_blocked" : "not_logged_in",
+          msg
+        );
+      }
+      logger(`mqtt error: ${msg}`, "error");
+      try {
+        if (mqttClient && mqttClient.connected) {
+          mqttClient.end(true);
+        }
+      } catch (_) { }
+      if (ctx._ending || ctx._cycling) return;
+
+      if (ctx.globalOptions.autoReconnect && !ctx._ending) {
+        const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || DEFAULT_RECONNECT_DELAY_MS;
+        logger(`mqtt autoReconnect listenMqtt() in ${d}ms`, "warn");
+        scheduleReconnect(d);
+      } else {
+        globalCallback({ type: "stop_listen", error: msg || "Connection refused" }, null);
+      }
+    });
+
+    mqttClient.on("connect", function () {
+      if (process.env.OnStatus === undefined) {
+        logger("fca-unofficial", "info");
+        process.env.OnStatus = true;
+      }
+      ctx._cycling = false;
+
+      topics.forEach(t => mqttClient.subscribe(t));
+
+
+      const queue = {
+        sync_api_version: 11, max_deltas_able_to_process: 100, delta_batch_size: 500,
+        encoding: "JSON", entity_fbid: ctx.userID, initial_titan_sequence_id: ctx.lastSeqId, device_params: null
+      };
+      const topic = ctx.syncToken ? "/messenger_sync_get_diffs" : "/messenger_sync_create_queue";
+      if (ctx.syncToken) { queue.last_seq_id = ctx.lastSeqId; queue.sync_token = ctx.syncToken; }
+      mqttClient.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
+      mqttClient.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
+      mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
+      const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || DEFAULT_RECONNECT_DELAY_MS;
+      let rTimeout = setTimeout(function () {
+        rTimeout = null;
+        if (ctx._ending) {
+          logger("mqtt t_ms timeout skipped - ending", "warn");
+          return;
+        }
+        logger(`mqtt t_ms timeout, cycling in ${d}ms`, "warn");
+        try {
+          if (mqttClient && mqttClient.connected) {
+            mqttClient.end(true);
+          }
+        } catch (_) { }
+        scheduleReconnect(d);
+      }, T_MS_WAIT_TIMEOUT_MS);
+
+      // Store timeout reference for cleanup
+      ctx._rTimeout = rTimeout;
+
+      ctx.tmsWait = function () {
+        if (rTimeout) {
+          clearTimeout(rTimeout);
+          rTimeout = null;
+        }
+        if (ctx._rTimeout) {
+          delete ctx._rTimeout;
+        }
+        if (ctx.globalOptions.emitReady) globalCallback({ type: "ready", error: null });
+        delete ctx.tmsWait;
+      };
+    });
+
+    mqttClient.on("message", function (topic, message) {
+      if (ctx._ending) return; // Ignore messages if ending
+      try {
+        let jsonMessage = Buffer.isBuffer(message) ? Buffer.from(message).toString() : message;
+        try {
+          jsonMessage = JSON.parse(jsonMessage);
+        } catch (parseErr) {
+          logger(`mqtt message parse error for topic ${topic}: ${parseErr && parseErr.message ? parseErr.message : String(parseErr)}`, "warn");
+          jsonMessage = {};
+        }
+
+        if (jsonMessage.type === "jewel_requests_add") {
+          globalCallback(null, { type: "friend_request_received", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
+        } else if (jsonMessage.type === "jewel_requests_remove_old") {
+          globalCallback(null, { type: "friend_request_cancel", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
+        } else if (topic === "/t_ms") {
+          if (ctx.tmsWait && typeof ctx.tmsWait == "function") ctx.tmsWait();
+          if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) {
+            ctx.lastSeqId = jsonMessage.firstDeltaSeqId;
+            ctx.syncToken = jsonMessage.syncToken;
+          }
+          if (jsonMessage.lastIssuedSeqId) ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+          for (const dlt of (jsonMessage.deltas || [])) {
+            parseDelta(defaultFuncs, api, ctx, globalCallback, { delta: dlt });
+          }
+        } else if (topic === "/thread_typing" || topic === "/orca_typing_notifications") {
+          const typ = {
+            type: "typ",
+            isTyping: !!jsonMessage.state,
+            from: jsonMessage.sender_fbid.toString(),
+            threadID: formatID((jsonMessage.thread || jsonMessage.sender_fbid).toString())
+          };
+          globalCallback(null, typ);
+        } else if (topic === "/orca_presence") {
+          if (!ctx.globalOptions.updatePresence) {
+            for (const data of (jsonMessage.list || [])) {
+              const presence = { type: "presence", userID: String(data.u), timestamp: data.l * 1000, statuses: data.p };
+              globalCallback(null, presence);
+            }
+          }
+        } else if (topic === "/ls_resp") {
+          const parsedPayload = JSON.parse(jsonMessage.payload);
+          const reqID = jsonMessage.request_id;
+          const tasks = ctx.tasks;
+          if (tasks && tasks instanceof Map && tasks.has(reqID)) {
+            const taskData = tasks.get(reqID);
+            const { type: taskType, callback: taskCallback } = taskData;
+            const taskRespData = getTaskResponseData(taskType, parsedPayload);
+            if (taskRespData == null) taskCallback("error", null);
+            else taskCallback(null, Object.assign({ type: taskType, reqID }, taskRespData));
+          }
+        }
+      } catch (ex) {
+        const errMsg = ex && ex.message ? ex.message : String(ex || "Unknown error");
+        logger(`mqtt message handler error: ${errMsg}`, "error");
+        // Don't crash on message parsing errors, just log and continue
+      }
+    });
+
+    mqttClient.on("close", function () {
+      if (ctx._ending || ctx._cycling) {
+        logger("mqtt close expected", "info");
+        return;
+      }
+      logger("mqtt connection closed", "warn");
+      if (ctx.globalOptions.autoReconnect && !ctx._ending) {
+        scheduleReconnect();
+      }
+    });
+
+    mqttClient.on("disconnect", () => {
+      if (ctx._ending || ctx._cycling) {
+        logger("mqtt disconnect expected", "info");
+        return;
+      }
+      logger("mqtt disconnected", "warn");
+      if (ctx.globalOptions.autoReconnect && !ctx._ending) {
+        scheduleReconnect();
+      }
+    });
+  };
+};

package/src/api/socket/core/emitAuth.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Emits account_inactive to the global callback and cleans up MQTT/timers/scheduler.
+ * Used when login is invalid, blocked, or session is lost.
+ */
+module.exports = function createEmitAuth({ logger }) {
+  return function emitAuth(ctx, api, globalCallback, reason, detail) {
+    // Clean up all timers
+    try {
+      if (ctx._autoCycleTimer) {
+        clearInterval(ctx._autoCycleTimer);
+        ctx._autoCycleTimer = null;
+      }
+    } catch (_) { }
+    try {
+      if (ctx._reconnectTimer) {
+        clearTimeout(ctx._reconnectTimer);
+        ctx._reconnectTimer = null;
+      }
+    } catch (_) { }
+
+    try {
+      ctx._ending = true;
+      ctx._cycling = false;
+    } catch (_) { }
+
+    // Clean up MQTT client
+    try {
+      if (ctx.mqttClient) {
+        ctx.mqttClient.removeAllListeners();
+        if (ctx.mqttClient.connected) {
+          ctx.mqttClient.end(true);
+        }
+      }
+    } catch (_) { }
+
+    ctx.mqttClient = undefined;
+    ctx.loggedIn = false;
+
+    // Clean up timeout references
+    try {
+      if (ctx._rTimeout) {
+        clearTimeout(ctx._rTimeout);
+        ctx._rTimeout = null;
+      }
+    } catch (_) { }
+
+    // Clean up tasks Map to prevent memory leak
+    try {
+      if (ctx.tasks && ctx.tasks instanceof Map) {
+        ctx.tasks.clear();
+      }
+    } catch (_) { }
+
+    // Clean up userInfo intervals
+    try {
+      if (ctx._userInfoIntervals && Array.isArray(ctx._userInfoIntervals)) {
+        ctx._userInfoIntervals.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._userInfoIntervals = [];
+      }
+    } catch (_) { }
+
+    // Clean up autoSave intervals
+    try {
+      if (ctx._autoSaveInterval && Array.isArray(ctx._autoSaveInterval)) {
+        ctx._autoSaveInterval.forEach(interval => {
+          try {
+            clearInterval(interval);
+          } catch (_) { }
+        });
+        ctx._autoSaveInterval = [];
+      }
+    } catch (_) { }
+
+    // Clean up scheduler
+    try {
+      if (ctx._scheduler && typeof ctx._scheduler.destroy === "function") {
+        ctx._scheduler.destroy();
+        ctx._scheduler = undefined;
+      }
+    } catch (_) { }
+
+    const msg = detail || reason;
+    logger(`auth change -> ${reason}: ${msg}`, "error");
+
+    if (typeof globalCallback === "function") {
+      try {
+        globalCallback({
+          type: "account_inactive",
+          reason,
+          error: msg,
+          timestamp: Date.now()
+        }, null);
+      } catch (cbErr) {
+        logger(`emitAuth callback error: ${cbErr && cbErr.message ? cbErr.message : String(cbErr)}`, "error");
+      }
+    }
+  };
+};