node-ainzfb-new 1.7.10-16tfwiu → 1.7.10-24ejweqr

package/StateCrypt.js

@@ -1,22 +1,32 @@
-/* eslint-disable linebreak-style */
 const crypto = require('crypto');
 const aes = require("aes-js");
 
 function encryptState(data, key) {
-    let hashEngine = crypto.createHash("sha256");
-        let hashKey = hashEngine.update(key).digest();
-            let bytes = aes.utils.utf8.toBytes(data);
-            let aesCtr = new aes.ModeOfOperation.ctr(hashKey);
-        let encryptedData = aesCtr.encrypt(bytes);
-    return aes.utils.hex.fromBytes(encryptedData);
+    try {
+        const hashEngine = crypto.createHash("sha256");
+        const hashKey = hashEngine.update(key).digest();
+        const bytes = aes.utils.utf8.toBytes(data);
+        const aesCtr = new aes.ModeOfOperation.ctr(hashKey);
+        const encryptedData = aesCtr.encrypt(bytes);
+        return aes.utils.hex.fromBytes(encryptedData);
+    } catch (error) {
+        console.error("Error encrypting state:", error.message);
+        throw error;
+    }
 }
 
 function decryptState(data, key) {
-    let hashEngine = crypto.createHash("sha256");
-        let hashKey = hashEngine.update(key).digest();
-            let encryptedBytes = aes.utils.hex.toBytes(data);
-            let aesCtr = new aes.ModeOfOperation.ctr(hashKey);
-        let decryptedData = aesCtr.decrypt(encryptedBytes);
-    return aes.utils.utf8.fromBytes(decryptedData);
+    try {
+        const hashEngine = crypto.createHash("sha256");
+        const hashKey = hashEngine.update(key).digest();
+        const encryptedBytes = aes.utils.hex.toBytes(data);
+        const aesCtr = new aes.ModeOfOperation.ctr(hashKey);
+        const decryptedData = aesCtr.decrypt(encryptedBytes);
+        return aes.utils.utf8.fromBytes(decryptedData);
+    } catch (error) {
+        console.error("Error decrypting state:", error.message);
+        throw error;
+    }
 }
-module.exports = { encryptState,decryptState };
+
+module.exports = { encryptState, decryptState };

package/index.js

@@ -23,9 +23,7 @@ var utils = require("./utils"),
     logger = require('./logger'),
     fs = require('fs-extra'),
     getText = require('gettext.js')(),
-    logger = require('./logger'),
     Fetch = require('got'),
-    fs = require('fs-extra'),
     StateCrypt = require('./StateCrypt'),
     Client = require("@replit/database"),
     languageFile = require('./Language/index.json'),
@@ -455,7 +453,7 @@ function makeid(length) {
 
 
 // Helps the login
-async function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
+/*async function loginHelper(appState, email, password, globalOptions, callback, prCallback) {
     var mainPromise = null;
     var jar = utils.getJar();
 
@@ -1085,8 +1083,244 @@ async function loginHelper(appState, email, password, globalOptions, callback, p
             callback(e);
         });
     //!---------- Auto Check, Update END -----------------!//
+}*/
+
+
+async function loginHelper(
+  appState,
+  email,
+  password,
+  globalOptions,
+  callback,
+  prCallback
+) {
+  var mainPromise = null;
+  var jar = utils.getJar();
+
+  // If we're given an appState we loop through it and save each cookie
+  // back into the jar.
+  if (appState) {
+
+ 
+    // Decrypt the appState if FBKEY is provided
+    if (process.env['FBKEY']) {
+      try {
+        appState = JSON.parse(StateCrypt.decryptState(appState, process.env['FBKEY']));
+        console.log("AppState decrypted successfully");
+      } catch (e) {
+        console.error("Failed to decrypt AppState:", e.message);
+        return callback(new Error("Failed to decrypt AppState"));
+      }
+    }
+
+    if (!Array.isArray(appState)) {
+      return callback(new Error("AppState must be an array"));
+    }
+
+    appState.map(function (c) {
+      var str =
+        c.key +
+        '=' +
+        c.value +
+        '; expires=' +
+        c.expires +
+        '; domain=' +
+        c.domain +
+        '; path=' +
+        c.path +
+        ';';
+      jar.setCookie(str, 'http://' + c.domain);
+    });
+
+    // Load the main page.
+    mainPromise = utils
+      .get('https://www.facebook.com/', jar, null, globalOptions, {
+        noRef: true,
+      })
+      .then(utils.saveCookies(jar));
+  } else {
+    // Open the main page, then we login with the given credentials and finally
+    // load the main page again (it'll give us some IDs that we need)
+    mainPromise = utils
+      .get('https://www.facebook.com/', null, null, globalOptions, {
+        noRef: true,
+      })
+      .then(utils.saveCookies(jar))
+      .then(
+        makeLogin(jar, email, password, globalOptions, callback, prCallback)
+      )
+      .then(function () {
+        return utils
+          .get('https://www.facebook.com/', jar, null, globalOptions)
+          .then(utils.saveCookies(jar));
+      });
+  }
+
+  var ctx = null;
+  var _defaultFuncs = null;
+  var api = null;
+
+  let redirect = [1, "https://m.facebook.com/"], bypass_region_err = false;
+
+  function CheckAndFixErr(res) {
+    let reg_antierr = /This browser is not supported/gs;
+    if (reg_antierr.test(res.body)) {
+      const Data = JSON.stringify(res.body);
+      const Dt_Check = Data.split('2Fhome.php&gfid=')[1];
+      if (Dt_Check == undefined) return res
+      const fid = Dt_Check.split("\\\\")[0];
+      if (Dt_Check == undefined || Dt_Check == "") return res
+      const final_fid = fid.split(`\\`)[0];
+      if (final_fid == undefined || final_fid == '') return res;
+      const redirectlink = redirect[1] + "a/preferences.php?basic_site_devices=m_basic&uri=" + encodeURIComponent("https://m.facebook.com/home.php") + "&gfid=" + final_fid;
+      bypass_region_err = true;
+      return utils.get(redirectlink, jar, null, globalOptions).then(utils.saveCookies(jar));
+    }
+    else return res
+  }
+
+  function Redirect(res) {
+    var reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+    redirect = reg.exec(res.body);
+    if (redirect && redirect[1]) return utils.get(redirect[1], jar, null, globalOptions).then(utils.saveCookies(jar));
+    return res;
+  }
+
+  mainPromise = mainPromise
+    .then(function (res) {
+      var reg = /<meta http-equiv="refresh" content="0;url=([^"]+)[^>]+>/;
+      var redirect = reg.exec(res.body);
+      if (redirect && redirect[1]) return utils.get(redirect[1], jar, null, globalOptions).then(utils.saveCookies(jar));
+      return res;
+    })
+    .then(res => Redirect(res))
+    .then(res => CheckAndFixErr(res))
+    .then(function (res) {
+      let Regex_Via = /MPageLoadClientMetrics/gs;
+      if (!Regex_Via.test(res.body)) {
+        globalOptions.userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1";
+        return utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true }).then(utils.saveCookies(jar));
+      }
+      else return res
+    })
+    .then(res => Redirect(res))
+    .then(res => CheckAndFixErr(res))
+    .then(async function (res) {
+      var html = res.body;
+      var stuff = await buildAPI(globalOptions, html, jar);
+      ctx = stuff[0];
+      _defaultFuncs = stuff[1];
+      api = stuff[2];
+      return res;
+    });
+
+  if (globalOptions.pageID) {
+    mainPromise = mainPromise
+      .then(function () {
+        return utils.get('https://www.facebook.com/' + ctx.globalOptions.pageID + '/messages/?section=messages&subsection=inbox', ctx.jar, null, globalOptions);
+      })
+      .then(function (resData) {
+        var url = utils.getFrom(resData.body, 'window.location.replace("https:\\/\\/www.facebook.com\\', '");').split('\\').join('');
+        url = url.substring(0, url.length - 1);
+        return utils.get('https://www.facebook.com' + url, ctx.jar, null, globalOptions);
+      });
+  }
+
+  mainPromise
+    .then(function () {
+      // Encrypt and save the appState
+      if (process.env['FBKEY']) {
+        try {
+          const currentAppState = jar.getCookies("https://www.facebook.com").concat(jar.getCookies("https://facebook.com")).concat(jar.getCookies("https://www.messenger.com"));
+          const encryptedAppState = StateCrypt.encryptState(JSON.stringify(currentAppState), process.env['FBKEY']);
+          // Save the encrypted appState (you might want to implement a save function)
+          saveAppState(encryptedAppState, (err) => {
+            if (err) {
+              console.error("Failed to encrypt and save AppState:", err.message);
+            } else {
+              console.log("AppState encrypted and saved successfully");
+            }
+            callback(null, api);
+          });
+          console.log("AppState encrypted and saved successfully");
+        } catch (e) {
+          console.error("Failed to encrypt and save AppState:", e.message);
+        }
+      }
+       //callback(null, api);
+    })
+
+    // At the end we call the callback or catch an exception
+    mainPromise
+        .then(function () {
+            logger(Language.DoneLogin, "[ FCA-SUS ]");
+            logger(Language.AutoCheckUpdate, "[ FCA-SUS ]");
+            //!---------- Auto Check, Update START -----------------!//
+            var Fetch = require('got');
+            var { readFileSync } = require('fs-extra');
+            const { execSync } = require('child_process');
+            Fetch('https://raw.githubusercontent.com/amogusdevlol/node-ainzfb/main/package.json').then(async (res) => {
+                const localbrand = JSON.parse(readFileSync('./node_modules/node-ainzfb-new/package.json')).version;
+                if (Number(localbrand.replace(/\./g, "")) < Number(JSON.parse(res.body.toString()).version.replace(/\./g, ""))) {
+                    log.warn("[ FCA-SUS ] •", getText.gettext(Language.NewVersionFound, JSON.parse(readFileSync('./node_modules/node-ainzfb/package.json')).version, JSON.parse(res.body.toString()).version));
+                    log.warn("[ FCA-SUS ] •", Language.AutoUpdate);
+                    try {
+                        execSync('npm install node-ainzfb-new@latest', { stdio: 'inherit' });
+                        logger(Language.UpdateSuccess, "[ FCA-SUS ]")
+                        logger(Language.RestartAfterUpdate, '[ FCA-SUS ]');
+                        await new Promise(resolve => setTimeout(resolve, 5 * 1000));
+                        console.clear();
+                        process.exit(1);
+                    } catch (err) {
+                        log.warn('Error Update: ' + err);
+                        logger(Language.UpdateFailed, "[ FCA-SUS ]");
+                        try {
+                            require.resolve('sus-support');
+                        } catch (e) {
+                            logger(Language.InstallSupportTool, "[ FCA-SUS ]");
+                            execSync('npm install git+https://github.com/amogusdevlol/sus-support.git', { stdio: 'inherit' });
+                            process.exit(1);
+                        }
+                        var fcasp = require('sus-support');
+                        try {
+                            fcasp.onError()
+                        } catch (e) {
+                            logger(Language.NotiAfterUseToolFail, "[ Fca - Helper ]")
+                            logger("rmdir ./node_modules then enter npm i && npm start", "[ Fca - Helper ]");
+                            process.exit(0);
+                        }
+
+                    }
+                } else {
+                    logger(getText.gettext(Language.LocalVersion, localbrand), "[ FCA-SUS ]");
+                    logger(Language.WishMessage[Math.floor(Math.random() * Language.WishMessage.length)], "[ FCA-SUS ]");
+                    require('./Extra/ExtraUptimeRobot')()
+                    await new Promise(resolve => setTimeout(resolve, 5 * 1000));
+                   return callback(null, api);
+                }
+            });
+        })
+    .catch(function (e) {
+      log.error("login", e.error || e);
+      callback(e);
+    });
 }
 
+
+function saveAppState(encryptedAppState, callback) {
+    const appStatePath = './appstate.json';
+    fs.writeFile(appStatePath, encryptedAppState, 'utf8', (err) => {
+      if (err) {
+        console.error("Error saving AppState:", err.message);
+        callback(err);
+      } else {
+        console.log("AppState saved successfully to:", appStatePath);
+        callback(null);
+      }
+    });
+  }
+
+  
 function login(loginData, options, callback) {
     if (utils.getType(options) === 'Function' || utils.getType(options) === 'AsyncFunction') {
         callback = options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-ainzfb-new",
-  "version": "1.7.10-16tfwiu",
+  "version": "1.7.10-24ejweqr",
   "description": "A Facebook chat API that doesn't rely on XMPP. Will NOT be deprecated after April 30th 2015.",
   "scripts": {
     "test": "mocha",

package/utils.js

@@ -1326,8 +1326,8 @@ function decodeClientPayload(payload) {
 }
 
   
-
 /*function getAppState(jar) {
+    var StateCrypt = require('./StateCrypt');
   try {
   var appstate = jar.getCookies("https://www.facebook.com").concat(jar.getCookies("https://facebook.com")).concat(jar.getCookies("https://www.messenger.com"));