@cexy/hoonfca 1.0.4 → 1.0.5

package/src/api/messaging/threadColors.js

@@ -0,0 +1,128 @@
+"use strict";
+
+module.exports = function(_defaultFuncs, _api, _ctx) {
+  // Currently the only colors that can be passed to api.changeThreadColor(); may change if Facebook adds more
+  return {
+    //Old hex colors.
+    ////MessengerBlue: null,
+    ////Viking: "#44bec7",
+    ////GoldenPoppy: "#ffc300",
+    ////RadicalRed: "#fa3c4c",
+    ////Shocking: "#d696bb",
+    ////PictonBlue: "#6699cc",
+    ////FreeSpeechGreen: "#13cf13",
+    ////Pumpkin: "#ff7e29",
+    ////LightCoral: "#e68585",
+    ////MediumSlateBlue: "#7646ff",
+    ////DeepSkyBlue: "#20cef5",
+    ////Fern: "#67b868",
+    ////Cameo: "#d4a88c",
+    ////BrilliantRose: "#ff5ca1",
+    ////BilobaFlower: "#a695c7"
+
+    //#region This part is for backward compatibly
+    //trying to match the color one-by-one. kill me plz
+    MessengerBlue: "196241301102133", //DefaultBlue
+    Viking: "1928399724138152", //TealBlue
+    GoldenPoppy: "174636906462322", //Yellow
+    RadicalRed: "2129984390566328", //Red
+    Shocking: "2058653964378557", //LavenderPurple
+    FreeSpeechGreen: "2136751179887052", //Green
+    Pumpkin: "175615189761153", //Orange
+    LightCoral: "980963458735625", //CoralPink
+    MediumSlateBlue: "234137870477637", //BrightPurple
+    DeepSkyBlue: "2442142322678320", //AquaBlue
+    BrilliantRose: "169463077092846", //HotPink
+    DefaultBlue: "196241301102133",
+    HotPink: "169463077092846",
+    AquaBlue: "2442142322678320",
+    BrightPurple: "234137870477637",
+    CoralPink: "980963458735625",
+    Orange: "175615189761153",
+    Green: "2136751179887052",
+    LavenderPurple: "2058653964378557",
+    Red: "2129984390566328",
+    Yellow: "174636906462322",
+    TealBlue: "1928399724138152",
+    Aqua: "417639218648241",
+    Mango: "930060997172551",
+    Berry: "164535220883264",
+    Citrus: "370940413392601",
+    Candy: "205488546921017",
+
+    /**
+     * July 06, 2022
+     * added by @NTKhang
+     */
+    Earth: "1833559466821043",
+    Support: "365557122117011",
+    Music: "339021464972092",
+    Pride: "1652456634878319",
+    DoctorStrange: "538280997628317",
+    LoFi: "1060619084701625",
+    Sky: "3190514984517598",
+    LunarNewYear: "357833546030778",
+    Celebration: "627144732056021",
+    Chill: "390127158985345",
+    StrangerThings: "1059859811490132",
+    Dune: "1455149831518874",
+    Care: "275041734441112",
+    Astrology: "3082966625307060",
+    JBalvin: "184305226956268",
+    Birthday: "621630955405500",
+    Cottagecore: "539927563794799",
+    Ocean: "736591620215564",
+    Love: "741311439775765",
+    TieDye: "230032715012014",
+    Monochrome: "788274591712841",
+    Default: "3259963564026002",
+    Rocket: "582065306070020",
+    Berry2: "724096885023603",
+    Candy2: "624266884847972",
+    Unicorn: "273728810607574",
+    Tropical: "262191918210707",
+    Maple: "2533652183614000",
+    Sushi: "909695489504566",
+    Citrus2: "557344741607350",
+    Lollipop: "280333826736184",
+    Shadow: "271607034185782",
+    Rose: "1257453361255152",
+    Lavender: "571193503540759",
+    Tulip: "2873642949430623",
+    Classic: "3273938616164733",
+    Peach: "3022526817824329",
+    Honey: "672058580051520",
+    Kiwi: "3151463484918004",
+    Grape: "193497045377796",
+
+    /**
+     * July 15, 2022
+     * added by @NTKhang
+     */
+    NonBinary: "737761000603635",
+
+    /**
+     * November 25, 2022
+     * added by @NTKhang
+     */
+    ThankfulForFriends: "1318983195536293",
+    Transgender: "504518465021637",
+    TaylorSwift: "769129927636836",
+    NationalComingOutDay: "788102625833584",
+    Autumn: "822549609168155",
+    Cyberpunk2077: "780962576430091",
+
+    /**
+     * May 13, 2023
+     */
+    MothersDay: "1288506208402340",
+    APAHM: "121771470870245",
+    Parenthood: "810978360551741",
+    StarWars: "1438011086532622",
+    GuardianOfTheGalaxy: "101275642962533",
+    Bloom: "158263147151440",
+    BubbleTea: "195296273246380",
+    Basketball: "6026716157422736",
+    ElephantsAndFlowers: "693996545771691"
+  };
+};

package/src/api/messaging/unsendMessage.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { generateOfflineThreadingID } = require("../../utils/format.js");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function unsendMessage(messageID, threadID, callback) {
+    return new Promise((resolve, reject) => {
+      if (!ctx.mqttClient) {
+        const err = new Error("Not connected to MQTT");
+        callback?.(err);
+        return reject(err);
+      }
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+      const taskPayload = {
+        message_id: messageID,
+        thread_key: threadID,
+        sync_group: 1,
+      };
+      const task = {
+        failure_count: null,
+        label: "33",
+        payload: JSON.stringify(taskPayload),
+        queue_name: "unsend_message",
+        task_id: taskID,
+      };
+      const content = {
+        app_id: "2220391788200892",
+        payload: JSON.stringify({
+          tasks: [task],
+          epoch_id: parseInt(generateOfflineThreadingID()),
+          version_id: "25393437286970779",
+        }),
+        request_id: reqID,
+        type: 3,
+      };
+      try {
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), {
+          qos: 1,
+          retain: false
+        });
+      } catch (err) {
+        log.error("unsendMessage (MQTT publish failed)", err);
+        callback?.(err);
+        return reject(err);
+      }
+      const handleRes = (topic, message) => {
+        if (topic !== "/ls_resp") return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch (err) {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        ctx.mqttClient.removeListener("message", handleRes);
+        try {
+          const msgID = jsonMsg.payload.step?.[1]?.[2]?.[2]?.[1]?.[2];
+          const msgReplace = jsonMsg.payload.step?.[1]?.[2]?.[2]?.[1]?.[4];
+          if (msgID && msgReplace) {
+            const bodies = {
+              body: msgReplace,
+              messageID: msgID
+            };
+            callback?.(null, bodies);
+            return resolve(bodies);
+          } else {
+            callback?.(null, { success: true });
+            return resolve({ success: true });
+          }
+        } catch (err) {
+          callback?.(null, { success: true });
+          return resolve({ success: true });
+        }
+      };
+      ctx.mqttClient.on("message", handleRes);
+    });
+  };
+};

package/src/api/messaging/uploadAttachment.js

@@ -0,0 +1,94 @@
+"use strict";
+const log = require("npmlog");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { getType } = require("../../utils/format");
+const { isReadableStream } = require("../../utils/constants");
+module.exports = function(defaultFuncs, api, ctx) {
+  function upload(attachments, callback) {
+    callback = callback || function() {};
+    const uploads = [];
+
+    // create an array of promises
+    for (let i = 0; i < attachments.length; i++) {
+      if (!isReadableStream(attachments[i])) {
+        throw {
+          error:
+            "Attachment should be a readable stream and not " +
+            getType(attachments[i]) +
+            "."
+        };
+      }
+
+      const form = {
+        farr: attachments[i]
+      };
+
+      uploads.push(
+        defaultFuncs
+          .postFormData(
+            "https://www.facebook.com/ajax/mercury/upload.php",
+            ctx.jar,
+            form,
+            {}
+          )
+          .then(parseAndCheckLogin(ctx, defaultFuncs))
+          .then(function(resData) {
+            if (resData.error) {
+              throw resData;
+            }
+
+            // We have to return the data unformatted unless we want to change it
+            // back in sendMessage.
+            return resData.payload.metadata[0];
+          })
+      );
+    }
+
+    // resolve all promises
+    Promise.all(uploads)
+      .then(function(resData) {
+        callback(null, resData);
+      })
+      .catch(function(err) {
+        log.error("uploadAttachment", err);
+        return callback(err);
+      });
+  }
+
+  return function uploadAttachment(attachments, callback) {
+    if (
+      !attachments &&
+      !isReadableStream(attachments) &&
+      !getType(attachments) === "Array" &&
+      getType(attachments) === "Array" && !attachments.length
+    )
+      throw { error: "Please pass an attachment or an array of attachments." };
+
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, info) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(info);
+      };
+    }
+
+    if (getType(attachments) !== "Array") attachments = [attachments];
+
+    upload(attachments, (err, info) => {
+      if (err) {
+        return callback(err);
+      }
+      callback(null, info);
+    });
+
+    return returnPromise;
+  };
+};

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

@@ -0,0 +1,255 @@
+"use strict";
+const { formatID } = require("../../../utils/format");
+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) || 2000;
+      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;
+    // Remove global reference to prevent memory leak
+    // Only set if needed for debugging, but clear on cleanup
+    if (process.env.DEBUG_MQTT) {
+      global.mqttClient = 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 (/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) || 2000;
+        logger(`mqtt autoReconnect listenMqtt() in ${d}ms`, "warn");
+        // Use scheduleReconnect to prevent multiple reconnections
+        scheduleReconnect(d);
+      } else {
+        globalCallback({ type: "stop_listen", error: msg || "Connection refused" }, null);
+      }
+    });
+
+    mqttClient.on("connect", function () {
+      if (process.env.OnStatus === undefined) {
+        logger("fca-unoffcial premium", "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) || 2000;
+      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);
+      }, 5000);
+
+      // 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;
+          if (ctx["tasks"].has(reqID)) {
+            const taskData = ctx["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");
+    });
+
+    mqttClient.on("disconnect", () => {
+      if (ctx._ending || ctx._cycling) {
+        logger("mqtt disconnect expected", "info");
+        return;
+      }
+      logger("mqtt disconnected", "warn");
+    });
+  };
+};

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

@@ -0,0 +1,106 @@
+"use strict";
+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 (_) { }
+
+    // Clear global mqttClient reference if set
+    try {
+      if (global.mqttClient) {
+        delete global.mqttClient;
+      }
+    } 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");
+      }
+    }
+  };
+};