@lazyneoaz/testfca 1.0.0

package/src/apis/gcmember.js

@@ -0,0 +1,122 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by ChoruOfficial 
+   * Mqtt
+   * Adds or removes members from a group chat with pre-checking.
+   *
+   * @param {"add" | "remove"} action The action to perform.
+   * @param {string|string[]} userIDs The user ID or array of user IDs.
+   * @param {string} threadID The ID of the group chat.
+   * @param {Function} [callback] Optional callback function.
+   * @returns {Promise<object>} A promise that resolves with information about the action.
+   */
+  return async function gcmember(action, userIDs, threadID, callback) {
+    let _callback;
+    if (typeof threadID === 'function') {
+        _callback = threadID;
+        threadID = null;
+    } else if (typeof callback === 'function') {
+        _callback = callback;
+    }
+    
+    let resolvePromise, rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+
+    if (typeof _callback != "function") {
+      _callback = (err, data) => {
+        // Note: We will now rarely use the 'err' parameter for validation errors
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      }
+    }
+
+    try {
+        const validActions = ["add", "remove"];
+        action = action ? action.toLowerCase() : "";
+
+
+        if (!validActions.includes(action)) {
+            return _callback(null, { type: "error_gc", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+        }
+        if (!userIDs || userIDs.length === 0) {
+            return _callback(null, { type: "error_gc", error: "userIDs is required." });
+        }
+        if (!threadID) {
+            return _callback(null, { type: "error_gc", error: "threadID is required." });
+        }
+        if (!ctx.mqttClient) {
+            return _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
+        }
+
+        const threadInfo = await api.getThreadInfo(threadID);
+        if (!threadInfo) {
+            return _callback(null, { type: "error_gc", error: "Could not retrieve thread information." });
+        }
+        if (threadInfo.isGroup === false) {
+            return _callback(null, { type: "error_gc", error: "This feature is only for group chats, not private messages." });
+        }
+        
+        const currentMembers = threadInfo.participantIDs;
+        const usersToModify = Array.isArray(userIDs) ? userIDs : [userIDs];
+        let queryPayload, query;
+        let finalUsers = usersToModify;
+        
+        ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+        ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+        if (action === 'add') {
+            const usersToAdd = usersToModify.filter(id => !currentMembers.includes(id));
+            if (usersToAdd.length === 0) {
+                return _callback(null, { type: "error_gc", error: "All specified users are already in the group." });
+            }
+            finalUsers = usersToAdd;
+            queryPayload = { thread_key: parseInt(threadID), contact_ids: finalUsers.map(id => parseInt(id)), sync_group: 1 };
+            query = { label: "23", payload: JSON.stringify(queryPayload), queue_name: threadID, task_id: ctx.wsTaskNumber };
+        
+        } else { // action is 'remove'
+            const userToRemove = usersToModify[0];
+            if (!currentMembers.includes(userToRemove)) {
+                return _callback(null, { type: "error_gc", error: `User with ID ${userToRemove} is not in this group chat.` });
+            }
+            finalUsers = [userToRemove];
+            queryPayload = { thread_id: threadID, contact_id: userToRemove, sync_group: 1 };
+            query = { label: "140", payload: JSON.stringify(queryPayload), queue_name: "remove_participant_v2", 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(err);
+          
+          const gcmemberInfo = {
+            type: "gc_member_update",
+            threadID: threadID,
+            userIDs: finalUsers,
+            action: action,
+            senderID: ctx.userID,
+            BotID: ctx.userID,
+            timestamp: Date.now(),
+          };
+          return _callback(null, gcmemberInfo);
+        });
+    } catch (err) {
+      
+        return _callback(null, { type: "error_gc", error: err.message || "An unknown error occurred." });
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/gcname.js

@@ -0,0 +1,123 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by Choru Official
+   * Mqtt
+   * Sets the name of a group chat thread via MQTT.
+   *
+   * @param {string} newName The new name for the group chat.
+   * @param {string} threadID The ID of the group chat thread.
+   * @param {Function} [callback] Optional callback function to be invoked upon completion.
+   * @param {string} [initiatorID] The ID of the user who initiated the group name 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 gcname(newName, threadID, 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(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;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to change the group chat name."));
+    }
+    if (typeof newName !== 'string') {
+      return _callback(new Error("newName 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(),
+      thread_name: newName,
+      sync_group: 1,
+    };
+
+    const query = {
+      failure_count: null,
+      label: '32',
+      payload: JSON.stringify(queryPayload),
+      queue_name: threadID.toString(),
+      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 gcname: ${err.message || err}`));
+      }
+      
+      const gcnameChangeEvent = {
+        type: "thread_name_update",
+        threadID: threadID,
+        newName: newName,
+        senderID: _initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+      _callback(null, gcnameChangeEvent);
+    });
+
+    return returnPromise;
+  };
+};

package/src/apis/gcrule.js

@@ -0,0 +1,119 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by ChoruOfficial 
+   * Mqtt
+   * Adds or removes an admin from a group chat with pre-checking.
+   *
+   * @param {"admin" | "unadmin"} action The action to perform.
+   * @param {string} userID The ID of the user to promote or demote.
+   * @param {string} threadID The ID of the group chat.
+   * @param {Function} [callback] Optional callback function.
+   * @returns {Promise<object>} A promise that resolves with information about the action.
+   */
+  return async function gcrule(action, userID, threadID, callback) {
+    let _callback;
+    if (typeof threadID === 'function') {
+        _callback = threadID;
+        threadID = null;
+    } else if (typeof callback === 'function') {
+        _callback = callback;
+    }
+    
+    let resolvePromise, rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+
+    if (typeof _callback != "function") {
+      _callback = (err, data) => {
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      }
+    }
+
+    try {
+        const validActions = ["admin", "unadmin"];
+        action = action ? action.toLowerCase() : "";
+
+        if (!validActions.includes(action)) {
+            return _callback(null, { type: "error_gc_rule", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+        }
+        if (!userID) return _callback(null, { type: "error_gc_rule", error: "userID is required." });
+        if (!threadID) return _callback(null, { type: "error_gc_rule", error: "threadID is required." });
+        if (!ctx.mqttClient) return _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" });
+        
+        const threadInfo = await api.getThreadInfo(threadID);
+        if (!threadInfo) {
+            return _callback(null, { type: "error_gc_rule", error: "Could not retrieve thread information." });
+        }
+        if (threadInfo.isGroup === false) {
+            return _callback(null, { type: "error_gc_rule", error: "This feature is only for group chats." });
+        }
+
+        const adminIDs = threadInfo.adminIDs || [];
+        const isCurrentlyAdmin = adminIDs.some(admin => admin.id === userID);
+
+        if (action === 'admin') {
+            if (isCurrentlyAdmin) {
+                return _callback(null, { type: "error_gc_rule", error: `User is already an admin.` });
+            }
+        } else { // action is 'unadmin'
+            if (!isCurrentlyAdmin) {
+                return _callback(null, { type: "error_gc_rule", error: `User is not an admin.` });
+            }
+        }
+
+        const isAdminStatus = action === 'admin' ? 1 : 0;
+        ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+        ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+        const queryPayload = {
+            thread_key: parseInt(threadID),
+            contact_id: parseInt(userID),
+            is_admin: isAdminStatus
+        };
+        const query = {
+            failure_count: null,
+            label: "25",
+            payload: JSON.stringify(queryPayload),
+            queue_name: "admin_status",
+            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(err);
+            const gcruleInfo = {
+                type: "gc_rule_update",
+                threadID: threadID,
+                userID: userID,
+                action: action,
+                senderID: ctx.userID,
+                BotID: ctx.userID,
+                timestamp: Date.now(),
+            };
+            return _callback(null, gcruleInfo);
+        });
+
+    } catch (err) {
+        return _callback(null, { type: "error_gc_rule", error: err.message || "An unknown error occurred." });
+    }
+    
+    return returnPromise;
+  };
+};

package/src/apis/getAccess.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getAccess(authCode = '', callback) {
+    var cb;
+    var url = 'https://business.facebook.com/';
+    var Referer = url + 'security/twofactor/reauth/?twofac_next=' + encodeURIComponent(url + 'content_management') + '&type=avoid_bypass&app_id=0&save_device=0';
+    var rt = new Promise(function (resolve, reject) {
+      cb = (error, token) => token ? resolve(token) : reject(error);
+    });
+
+    if (typeof authCode == 'function') {
+      callback = authCode;
+      authCode = '';
+    }
+    if (typeof callback == 'function') cb = callback;
+    if (!!ctx.access_token) 
+      cb(null, ctx.access_token);
+    else 
+      utils
+        .get(url + 'content_management', ctx.jar, null, ctx.globalOptions, null, {
+          noRef: true,
+          Origin: url
+        })
+        .then(function (res) {
+          var html = res.body;
+          var lsd = utils.getFrom(html, "[\"LSD\",[],{\"token\":\"", "\"}");
+          return lsd;
+        })
+        .then(function (lsd) {
+          function submitCode(code) {
+            var pCb;
+            var rtPromise = new Promise(function (resolve) {
+              pCb = (error, token) => resolve(cb(error, token));
+            });
+            if (typeof code != 'string')
+              pCb({
+                error: 'submitCode',
+                lerror: 'code must be string',
+                continue: submitCode
+              });
+            else 
+              defaultFuncs
+                .post(url + 'security/twofactor/reauth/enter/', ctx.jar, {
+                  approvals_code: code,
+                  save_device: true,
+                  lsd 
+                }, ctx.globalOptions, null, {
+                  Referer,
+                  Origin: url
+                })
+                .then(function (res) {
+                  var { payload } = JSON.parse(res.body.split(';').pop() || '{}');
+                  if (payload && !payload.codeConfirmed)
+                    throw {
+                      error: 'submitCode',
+                      lerror: payload.message,
+                      continue: submitCode
+                    }
+                  
+                  return;
+                })
+                .then(function () {
+                  return utils
+                    .get(url + 'content_management', ctx.jar, null, ctx.globalOptions, null, { noRef: true })
+                    .then(function (res) {
+                      var html = res.body;
+                      var token = /"accessToken":"(\S+)","clientID":/g.exec(html);
+
+                      return [html, token];
+                    });
+                })
+                .then(function (res) {
+                  if (!res[1]) 
+                    throw {
+                      error: 'token-undefined',
+                      htmlData: res[0]
+                    }
+                  ctx.access_token = res[1][1];                      
+                  return pCb(null, res[1][1]);
+                })
+                .catch(function (err) {
+                  utils.error('getAccess', err.error || err);
+                  return pCb(err);
+                });
+    
+            return rtPromise;
+          }
+
+          if (authCode.length == 6 && !isNaN(authCode)) 
+            submitCode(authCode.toString());
+          else if (typeof callback == 'function') 
+            throw {
+              error: 'submitCode',
+              continue: submitCode
+            }
+          else 
+            throw {
+              error: 'authentication code must be string or number or callback must be a function to continue'
+            }
+        })
+        .catch(function (err) {
+          utils.error('getAccess', typeof callback == 'function' ? (err.error || err) : err);
+          return cb(err);
+        });
+
+    return rt;
+  }
+}

package/src/apis/getBotInfo.js

@@ -0,0 +1,88 @@
+
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(netData: Array<Object>): Object | null}
+ */
+module.exports = (defaultFuncs, api, ctx) => {
+  /**
+   * @param {Array<Object>} netData - The array of all extracted JSON objects from the HTML.
+   * @returns {Object|null} An object containing the bot's essential info, security tokens, and context accessor functions.
+   */
+  return function getBotInfo(netData) {
+    if (!netData || !Array.isArray(netData)) {
+        utils.error("getBotInfo", "netData is not a valid array.");
+        return null;
+    }
+
+    /**
+     * @param {string} key The configuration key to find (e.g., "MqttWebDeviceID").
+     * @returns {Object|null} The configuration object or null if not found.
+     */
+    const findConfig = (key) => {
+        for (const scriptData of netData) {
+            if (scriptData.require) {
+                for (const req of scriptData.require) {
+                    if (Array.isArray(req) && req[0] === key && req[2]) {
+                        return req[2];
+                    }
+                    if (Array.isArray(req) && req[3] && req[3][0]?.__bbox?.define) {
+                        for (const def of req[3][0].__bbox.define) {
+                            if (Array.isArray(def) && def[0].endsWith(key) && def[2]) {
+                                return def[2];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    };
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const dtsgInitialData = findConfig("DTSGInitialData");
+    const dtsgInitData = findConfig("DTSGInitData");
+    const lsdData = findConfig("LSD");
+
+    if (!currentUserData || !dtsgInitialData) {
+        utils.error("getBotInfo", "Could not find critical data (CurrentUserInitialData or DTSGInitialData).");
+        return null;
+    }
+
+    const botInfo = {
+        name: currentUserData.NAME,
+        firstName: currentUserData.SHORT_NAME,
+        uid: currentUserData.USER_ID,
+        appID: currentUserData.APP_ID,
+        dtsgToken: dtsgInitialData.token,
+        lsdToken: lsdData ? lsdData.token : undefined,
+        dtsgInit: dtsgInitData ? {
+            token: dtsgInitData.token,
+            async_get_token: dtsgInitData.async_get_token
+        } : undefined,
+
+        /**
+         * @param {string} key The key of the value to retrieve.
+         * @returns {any} The value from the context.
+         */
+        getCtx: (key) => ctx[key],
+
+        /**
+         * @param {string} key The key of the option to retrieve.
+         * @returns {any} The value of the option.
+         */
+        getOptions: (key) => ctx.globalOptions[key],
+
+        /**
+         * @returns {string | undefined} The current region.
+         */
+        getRegion: () => ctx?.region
+    };
+    return botInfo;
+  };
+};

package/src/apis/getBotInitialData.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const utils = require("../utils");
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async (callback) => {
+  let resolveFunc = () => {};
+  let rejectFunc = () => {};
+  const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+  });
+  if (!callback) {
+      callback = (err, data) => {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(data);
+      };
+  }
+  utils.log("Fetching account info...");
+  api.httpGet(`https://www.facebook.com/profile.php?id=${ctx.userID}`, null, {
+      customUserAgent: utils.windowsUserAgent
+  }, (err, data) => {
+  
+      if (err) throw err;
+      const profileMatch = data.match(/"CurrentUserInitialData",\[\],\{(.*?)\},(.*?)\]/);
+      if (profileMatch && profileMatch[1]){
+        const accountJson = JSON.parse(`{${profileMatch[1]}}`);
+        accountJson.name = accountJson.NAME;
+        accountJson.uid = accountJson.USER_ID;
+        delete accountJson.NAME;
+        delete accountJson.USER_ID;
+        return callback(null, {
+          ...accountJson
+      });
+      } else return callback(null, { error: "Something went wrong. Maybe its possible that it has a limitation due to spam requests. You can try again later." });
+  }, true);
+  return returnPromise;
+  };
+};
+ 
+ 

package/src/apis/getFriendsList.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require('../utils');
+
+const GENDERS = {
+  0: "unknown",
+  1: "female_singular",
+  2: "male_singular",
+  3: "female_singular_guess",
+  4: "male_singular_guess",
+  5: "mixed",
+  6: "neuter_singular",
+  7: "unknown_singular",
+  8: "female_plural",
+  9: "male_plural",
+  10: "neuter_plural",
+  11: "unknown_plural"
+};
+
+function formatData(obj) {
+  return Object.keys(obj).map(key => {
+    const user = obj[key];
+    return {
+      alternateName: user.alternateName,
+      firstName: user.firstName,
+      gender: GENDERS[user.gender],
+      userID: utils.formatID(user.id.toString()),
+      isFriend: user.is_friend != null && user.is_friend ? true : false,
+      fullName: user.name,
+      profilePicture: user.thumbSrc,
+      type: user.type,
+      profileUrl: user.uri,
+      vanity: user.vanity,
+      isBirthday: !!user.is_birthday
+    };
+  });
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function getFriendsList(callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const res = await defaultFuncs.postFormData(
+        "https://www.facebook.com/chat/user_info_all",
+        ctx.jar,
+        {},
+        { viewer: ctx.userID }
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (!res) {
+        throw { error: "getFriendsList returned empty object." };
+      }
+
+      if (res.error) {
+        throw res;
+      }
+
+      callback(null, formatData(res.payload));
+    } catch (err) {
+      utils.error("getFriendsList", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};