shadowx-fca 2.3.0 → 2.5.0

package/src/listenMqtt.js

@@ -114,27 +114,24 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
 
         // Display connection success message with branding and loading animation
         const messages = [
-            '\n SHADOWX-FCA MQTT Connected',
-            ` Region: ${ctx.region || 'PNB'}`,
+            '\n🖤 SHADOWX FCA MQTT Connected',
+            `🔰 Region: ${ctx.region || 'PNB'}`,
             `🔄 Auto-reconnect: ${ctx.globalOptions.autoReconnect ? 'Enabled' : 'Disabled'}${ctx.globalOptions.autoReconnect ? ' (reconnects every 3s on disconnect)' : ''}`,
             `⏱️  MQTT Restart Interval: ${ctx.globalOptions.restartListenMqtt?.enable ? `${ctx.globalOptions.restartListenMqtt.timeRestart / 1000}s` : 'Disabled'}`,
-            'Author: Mueid Mursalin Rifat\n'
+            '✅ ShadowX FCA STARTED\n'
         ];
 
         let index = 0;
         const displayMessages = () => {
             if (index < messages.length) {
-                const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-                let frameIndex = 0;
                 
-                const loadingInterval = setInterval(() => {
-                    process.stdout.write(`\r${frames[frameIndex]} Loading...`);
-                    frameIndex = (frameIndex + 1) % frames.length;
-                }, 80);
+                // loading condition - Using the extra safe method to prevent reconnect spam
+                if (index === 0 && !ctx._loadedOnce) {
+                    process.stdout.write("⏳ Loading...\n");
+                    ctx._loadedOnce = true;
+                }
 
                 setTimeout(() => {
-                    clearInterval(loadingInterval);
-                    process.stdout.write('\r' + ' '.repeat(20) + '\r');
                     console.log(messages[index]);
                     index++;
                     displayMessages();
@@ -677,110 +674,6 @@ function markDelivery(ctx, api, threadID, messageID) {
 
 module.exports = function (defaultFuncs, api, ctx) {
     let globalCallback = identity;
-    // function getSeqID() {
-    // ctx.t_mqttCalled = false;
-    // async function attemptRequest(retries = 3) {
-    //   try {
-    //     if (!ctx.fb_dtsg) {
-    //       const dtsg = await api.getFreshDtsg();
-    //       if (!dtsg) {
-    //         if (retries > 0) {
-    //           logger.Warning("Failed to get fb_dtsg, retrying...");
-    //                     await utils.sleep(2000); // Longer delay for token retry
-    //                     return attemptRequest(retries - 1);
-    //                   }
-    //                   throw { error: "Could not obtain fb_dtsg after multiple attempts" };
-    //                 }
-    //                 ctx.fb_dtsg = dtsg;
-    //               }
-
-    //               const form = {
-    //                 av: ctx.userID,
-    //                 fb_dtsg: ctx.fb_dtsg,
-    //                 queries: JSON.stringify({
-    //                   o0: {
-    //                     doc_id: '3336396659757871',
-    //                     query_params: {
-    //                       limit: 1,
-    //                       before: null,
-    //                       tags: ['INBOX'],
-    //                       includeDeliveryReceipts: false,
-    //                       includeSeqID: true
-    //                     }
-    //                   }
-    //                 }),
-    //                 __user: ctx.userID,
-    //                 __a: '1',
-    //                 __req: '8',
-    //                 __hs: '19577.HYP:comet_pkg.2.1..2.1',
-    //                 dpr: '1',
-    //                 fb_api_caller_class: 'RelayModern',
-    //                 fb_api_req_friendly_name: 'MessengerGraphQLThreadlistFetcher'
-    //               };
-
-    //               const headers = {
-    //                 'Content-Type': 'application/x-www-form-urlencoded',
-    //                 'Referer': 'https://www.facebook.com/',
-    //                 'Origin': 'https://www.facebook.com',
-    //                 'sec-fetch-site': 'same-origin',
-    //                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
-    //                 'Cookie': ctx.jar.getCookieString('https://www.facebook.com'),
-    //                 'accept': '*/*',
-    //                 'accept-encoding': 'gzip, deflate, br'
-    //               };
-
-    //               const resData = await defaultFuncs
-    //               .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form, { headers })
-    //               .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-
-    //               if (debugSeq) {
-    //                 console.log('GraphQL SeqID Response:', JSON.stringify(resData, null, 2));
-    //               }
-
-    //               if (resData.error === 1357004 || resData.error === 1357001) {
-    //                 if (retries > 0) {
-    //                   logger.Warning("Session error, refreshing token and retrying...");
-    //                 ctx.fb_dtsg = null; // Force new token
-    //                 await utils.sleep(2000);
-    //                 return attemptRequest(retries - 1);
-    //               }
-    //               throw { error: "Session refresh failed after retries" };
-    //             }
-
-    //             if (!Array.isArray(resData)) {
-    //               throw { error: "Invalid response format", res: resData };
-    //             }
-
-    //             const seqID = resData[0]?.o0?.data?.viewer?.message_threads?.sync_sequence_id;
-    //             if (!seqID) {
-    //               throw { error: "Missing sync_sequence_id", res: resData };
-    //             }
-
-    //             ctx.lastSeqId = seqID;
-    //             if (debugSeq) {
-    //               console.log('Got SeqID:', ctx.lastSeqId);
-    //             }
-
-    //             return listenMqtt(defaultFuncs, api, ctx, globalCallback);
-
-    //           } catch (err) {
-    //             if (retries > 0) {
-    //               console.log("Request failed, retrying...");
-
-    //               return attemptRequest(retries - 1);
-    //             }
-    //             throw err;
-    //           }
-    //         }
-
-    //         return attemptRequest()
-    // 		.catch((err) => {
-    // 			log.error("getSeqId", err);
-    // 			if (utils.getType(err) == "Object" && err.error === "Not logged in") ctx.loggedIn = false;
-    // 			return globalCallback(err);
-    // 		});
-    //       }
-
     getSeqID = function getSeqID() {
         ctx.t_mqttCalled = false;
         defaultFuncs
@@ -867,4 +760,4 @@ module.exports = function (defaultFuncs, api, ctx) {
         api.stopListeningAsync = msgEmitter.stopListeningAsync;
         return msgEmitter;
     };
-};
+};

package/src/nickname.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) { 
+  /**
+   * Author: S4hiilAns4ri (github.com/S4hiilAns4ri) 
+   * Mqtt
+   * Sets a nickname for a participant in a Facebook thread via MQTT.
+   *
+   * @param {string} nickname The new nickname to set.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
+   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   */
+  return function setNickname(nickname, threadID, participantID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolvePromise;
+    let _rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        _resolvePromise = resolve;
+        _rejectPromise = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(participantID) === "Function" || utils.getType(participantID) === "AsyncFunction") {
+        _callback = participantID;
+        participantID = ctx.userID;
+        _initiatorID = callback;
+    }
+    else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (__err, __data) {
+        if (__err) _rejectPromise(__err);
+        else _resolvePromise(__data);
+      };
+    } else {
+      const originalCallback = _callback;
+      _callback = function(__err, __data) {
+        if (__err) {
+          originalCallback(__err);
+          _rejectPromise(__err);
+        } else {
+          originalCallback(null, __data);
+          _resolvePromise(__data);
+        }
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+    participantID = participantID || ctx.userID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to set a nickname."));
+    }
+    if (typeof nickname !== 'string') {
+      return _callback(new Error("nickname must be a string."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const queryPayload = {
+      thread_key: threadID.toString(),
+      contact_id: participantID.toString(),
+      nickname: nickname,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '44',
+      payload: JSON.stringify(queryPayload),
+      queue_name: 'thread_participant_nickname',
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const context = {
+      app_id: ctx.appID,
+      payload: {
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [query],
+        version_id: '24631415369801570',
+      },
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+    context.payload = JSON.stringify(context.payload);
+    
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+      if (err) {
+        return _callback(new Error(`MQTT publish failed for setNickname: ${err.message || err}`));
+      }
+      
+      const nicknameChangeEvent = {
+        type: "thread_nickname_update", 
+        threadID: threadID,
+        participantID: participantID,
+        newNickname: nickname,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, nicknameChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/postFormData.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function postFormData(url, form, callback) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (
+      !callback &&
+      (utils.getType(form) == "Function" ||
+        utils.getType(form) == "AsyncFunction")
+    ) {
+      callback = form;
+      form = {};
+    }
+
+    form = form || {};
+
+    callback =
+      callback ||
+      function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    defaultFuncs
+      .postFormData(url, ctx.jar, form, {})
+      .then(function (resData) {
+        callback(null, resData.body.toString());
+      })
+      .catch(function (err) {
+        log.error("postFormData", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};