fca-neokex-fix 1.0.1

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;
+  };
+};