fca-neokex-fix 1.0.1

package/src/engine/models/buildAPI.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const utils = require('../../utils');
+
+/**
+ * Builds the core API context and default functions after successful login.
+ *
+ * @param {string} html The HTML body from the initial Facebook page.
+ * @param {object} jar The cookie jar.
+ * @param {Array<object>} netData Network data extracted from the HTML.
+ * @param {object} globalOptions The global options object.
+ * @param {function} fbLinkFunc A function to generate Facebook links.
+ * @param {string} errorRetrievingMsg The error message for retrieving user ID.
+ * @returns {Array<object>} An array containing [ctx, defaultFuncs, {}].
+ */
+async function buildAPI(html, jar, netData, globalOptions, fbLinkFunc, errorRetrievingMsg) {
+    let userID;
+    const cookies = jar.getCookiesSync(fbLinkFunc());
+    const primaryProfile = cookies.find((val) => val.cookieString().startsWith("c_user="));
+    const secondaryProfile = cookies.find((val) => val.cookieString().startsWith("i_user="));
+    if (!primaryProfile && !secondaryProfile) {
+        throw new Error(errorRetrievingMsg);
+    }
+    userID = secondaryProfile?.cookieString().split("=")[1] || primaryProfile.cookieString().split("=")[1];
+
+    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] && req[3][0].__bbox && 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 dtsgData = findConfig("DTSGInitialData");
+    const dtsg = dtsgData ? dtsgData.token : utils.getFrom(html, '"token":"', '"');
+    
+    const lsdData = findConfig("LSD");
+    const lsd = lsdData ? lsdData.token : utils.getFrom(html, '"LSD",[],{"token":"', '"');
+    
+    const dtsgResult = { 
+        fb_dtsg: dtsg, 
+        jazoest: `2${Array.from(dtsg).reduce((a, b) => a + b.charCodeAt(0), '')}`,
+        lsd: lsd
+    };
+
+    const clientIDData = findConfig("MqttWebDeviceID");
+    const clientID = clientIDData ? clientIDData.clientID : undefined;
+
+    const mqttConfigData = findConfig("MqttWebConfig");
+    const mqttAppID = mqttConfigData ? mqttConfigData.appID : undefined;
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const userAppID = currentUserData ? currentUserData.APP_ID : undefined;
+
+    let primaryAppID = userAppID || mqttAppID;
+
+    let mqttEndpoint = mqttConfigData ? mqttConfigData.endpoint : undefined;
+
+    let region = mqttEndpoint ? new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase() : undefined;
+    const irisSeqIDMatch = html.match(/irisSeqID:"(.+?)"/);
+    const irisSeqID = irisSeqIDMatch ? irisSeqIDMatch[1] : null;
+    if (globalOptions.bypassRegion && mqttEndpoint) {
+        const currentEndpoint = new URL(mqttEndpoint);
+        currentEndpoint.searchParams.set('region', globalOptions.bypassRegion.toLowerCase());
+        mqttEndpoint = currentEndpoint.toString();
+        region = globalOptions.bypassRegion.toUpperCase();
+    }
+
+    const ctx = {
+        userID,
+        jar,
+        clientID,
+        appID: primaryAppID, 
+        mqttAppID: mqttAppID, 
+        userAppID: userAppID, 
+        globalOptions,
+        loggedIn: true,
+        access_token: "NONE",
+        clientMutationId: 0,
+        mqttClient: undefined,
+        lastSeqId: irisSeqID,
+        syncToken: undefined,
+        mqttEndpoint,
+        wsReqNumber: 0,
+        wsTaskNumber: 0,
+        reqCallbacks: {},
+        callback_Task: {},
+        region,
+        firstListen: true,
+        ...dtsgResult,
+    };
+    const defaultFuncs = utils.makeDefaults(html, userID, ctx);
+
+    return [ctx, defaultFuncs, {}];
+}
+
+module.exports = buildAPI;

package/src/engine/models/loginHelper.js

@@ -0,0 +1,326 @@
+"use strict";
+
+const utils = require('../../utils');
+const axios = require("axios");
+const path = require('path');
+const fs = require('fs');
+const qs = require("querystring");
+const { normalizeCookieHeaderString, setJarFromPairs } = require('../../utils/formatters/value/formatCookie');
+const { parseRegion, genTotp } = require('../../utils/auth-helpers');
+const { generateUserAgentByPersona, cachePersonaData } = require('../../utils/user-agents');
+
+/**
+ * The main login helper function, orchestrating the login process.
+ *
+ * @param {object} credentials User credentials or appState.
+ * @param {object} globalOptions Global options for the API.
+ * @param {function} callback The final callback function.
+ * @param {function} setOptionsFunc Reference to the setOptions function from models.
+ * @param {function} buildAPIFunc Reference to the buildAPI function from models.
+ * @param {object} initialApi The initial API object to extend.
+ * @param {function} fbLinkFunc A function to generate Facebook links.
+ * @param {string} errorRetrievingMsg The error message for retrieving user ID.
+ * @returns {Promise<void>}
+ */
+async function loginHelper(credentials, globalOptions, callback, setOptionsFunc, buildAPIFunc, initialApi, fbLinkFunc, errorRetrievingMsg) {
+    let ctx = null;
+    let defaultFuncs = null;
+    let api = initialApi;
+
+    try {
+        const jar = utils.getJar();
+        utils.log("Logging in...");
+
+        const persona = globalOptions.persona || 'desktop';
+        const personaSwitched = globalOptions.cachedPersona && globalOptions.cachedPersona !== persona;
+
+        if (personaSwitched) {
+            const oldPersona = globalOptions.cachedPersona;
+            utils.log(`Persona switched from ${oldPersona} to ${persona}, clearing ALL cached fingerprints`);
+
+            delete globalOptions.cachedUserAgent;
+            delete globalOptions.cachedSecChUa;
+            delete globalOptions.cachedSecChUaFullVersionList;
+            delete globalOptions.cachedSecChUaPlatform;
+            delete globalOptions.cachedSecChUaPlatformVersion;
+            delete globalOptions.cachedBrowser;
+
+            delete globalOptions.cachedAndroidUA;
+            delete globalOptions.cachedAndroidVersion;
+            delete globalOptions.cachedAndroidDevice;
+            delete globalOptions.cachedAndroidBuildId;
+            delete globalOptions.cachedAndroidResolution;
+            delete globalOptions.cachedAndroidFbav;
+            delete globalOptions.cachedAndroidFbbv;
+            delete globalOptions.cachedAndroidLocale;
+            delete globalOptions.cachedAndroidCarrier;
+
+            delete globalOptions.cachedLocale;
+            delete globalOptions.cachedTimezone;
+        }
+
+        const needsDesktopCache = (persona === 'desktop') && !globalOptions.cachedUserAgent;
+        const needsAndroidCache = (persona === 'android' || persona === 'mobile') && !globalOptions.cachedAndroidUA;
+
+        if (needsDesktopCache || needsAndroidCache) {
+            const personaData = generateUserAgentByPersona(persona, globalOptions);
+            cachePersonaData(globalOptions, personaData);
+            globalOptions.cachedPersona = persona;
+
+            if (persona === 'desktop') {
+                utils.log("Using desktop persona with browser:", personaData.browser);
+            } else {
+                utils.log("Using Android/Orca mobile persona");
+            }
+
+            const { getRandomLocale, getRandomTimezone } = require('../../utils/headers');
+            if (!globalOptions.cachedLocale) {
+                globalOptions.cachedLocale = getRandomLocale();
+            }
+            if (!globalOptions.cachedTimezone) {
+                globalOptions.cachedTimezone = getRandomTimezone();
+            }
+        } else {
+            if (persona === 'desktop' && globalOptions.cachedUserAgent) {
+                utils.log("Using cached desktop persona");
+            } else if ((persona === 'android' || persona === 'mobile') && globalOptions.cachedAndroidUA) {
+                utils.log("Using cached Android/Orca mobile persona");
+            }
+        }
+
+        let appState = credentials.appState;
+
+        if (!appState && !credentials.email && !credentials.password) {
+            try {
+                const { hydrateJarFromDB } = require('../../database/appStateBackup');
+                const restored = await hydrateJarFromDB(jar, null);
+                if (restored) {
+                    utils.log("Restored AppState from database backup");
+                }
+            } catch (dbErr) {
+                utils.warn("Failed to restore AppState from database:", dbErr.message);
+            }
+        }
+
+        if (appState) {
+            let cookieStrings = [];
+            if (Array.isArray(appState)) {
+                cookieStrings = appState.map(c => [c.name || c.key, c.value].join('='));
+            } else if (typeof appState === 'string') {
+                cookieStrings = normalizeCookieHeaderString(appState);
+
+                if (cookieStrings.length === 0) {
+                    cookieStrings = appState.split(';').map(s => s.trim()).filter(Boolean);
+                }
+            } else {
+                throw new Error("Invalid appState format. Please provide an array of cookie objects or a cookie string.");
+            }
+
+            setJarFromPairs(jar, cookieStrings);
+            utils.log("Cookies set for facebook.com and messenger.com domains");
+
+        } else if (credentials.email && credentials.password) {
+
+            if (credentials.totpSecret) {
+                utils.log("TOTP secret detected, will generate 2FA code if needed");
+            }
+
+            const url = "https://api.facebook.com/method/auth.login";
+            const params = {
+                access_token: "350685531728|62f8ce9f74b12f84c123cc23437a4a32",
+                format: "json",
+                sdk_version: 2,
+                email: credentials.email,
+                locale: "en_US",
+                password: credentials.password,
+                generate_session_cookies: 1,
+                sig: "c1c640010993db92e5afd11634ced864",
+            }
+
+            if (credentials.totpSecret) {
+                try {
+                    const totpCode = await genTotp(credentials.totpSecret);
+                    params.credentials_type = "two_factor";
+                    params.twofactor_code = totpCode;
+                    utils.log("TOTP code generated successfully");
+                } catch (totpError) {
+                    utils.warn("Failed to generate TOTP code:", totpError.message);
+                }
+            }
+
+            const query = qs.stringify(params);
+            const xurl = `${url}?${query}`;
+            try {
+                const resp = await axios.get(xurl);
+                if (resp.status !== 200) {
+                    throw new Error("Wrong password / email");
+                }
+                let cstrs = resp.data["session_cookies"].map(c => `${c.name}=${c.value}`);
+                setJarFromPairs(jar, cstrs);
+                utils.log("Login successful with email/password");
+            } catch (e) {
+                if (credentials.totpSecret && !params.twofactor_code) {
+                    throw new Error("2FA required but TOTP code generation failed");
+                }
+                throw new Error("Wrong password / email");
+            }
+        } else {
+                throw new Error("No cookie or credentials found. Please provide cookies or credentials.");
+        }
+
+        if (!api) {
+            api = {
+                setOptions: setOptionsFunc.bind(null, globalOptions),
+                getAppState() {
+                    const appState = utils.getAppState(jar);
+                    if (!Array.isArray(appState)) return [];
+                    const uniqueAppState = appState.filter((item, index, self) => self.findIndex((t) => t.key === item.key) === index);
+                    return uniqueAppState.length > 0 ? uniqueAppState : appState;
+                },
+            };
+        }
+
+        const resp = await utils.get(fbLinkFunc(), jar, null, globalOptions, { noRef: true }).then(utils.saveCookies(jar));
+        const extractNetData = (html) => {
+            const allScriptsData = [];
+            const scriptRegex = /<script type="application\/json"[^>]*>(.*?)<\/script>/g;
+            let match;
+            while ((match = scriptRegex.exec(html)) !== null) {
+                try {
+                    allScriptsData.push(JSON.parse(match[1]));
+                } catch (e) {
+                    utils.error(`Failed to parse a JSON blob from HTML`, e.message);
+                }
+            }
+            return allScriptsData;
+        };
+
+        const netData = extractNetData(resp.body);
+
+        const [newCtx, newDefaultFuncs] = await buildAPIFunc(resp.body, jar, netData, globalOptions, fbLinkFunc, errorRetrievingMsg);
+        ctx = newCtx;
+        defaultFuncs = newDefaultFuncs;
+
+        const region = parseRegion(resp.body);
+        ctx.region = region;
+        utils.log("Detected Facebook region:", region);
+
+        try {
+            const { backupAppStateSQL } = require('../../database/appStateBackup');
+            await backupAppStateSQL(jar, ctx.userID);
+        } catch (backupErr) {
+            utils.warn("Failed to backup AppState to database:", backupErr.message);
+        }
+        api.message = new Map();
+        api.timestamp = {};
+
+        /**
+         * Loads API modules from the apis directory.
+         *
+         * @returns {void}
+         */
+        const loadApiModules = () => {
+            const apiPath = path.join(__dirname, '..', '..', 'apis');
+
+            if (!fs.existsSync(apiPath)) {
+                utils.error('API directory not found:', apiPath);
+                return;
+            }
+
+            const helperModules = ['mqttDeltaValue'];
+
+            fs.readdirSync(apiPath)
+                .filter(file => file.endsWith('.js'))
+                .forEach(file => {
+                    const moduleName = path.basename(file, '.js');
+
+                    if (helperModules.includes(moduleName)) {
+                        return;
+                    }
+
+                    const fullPath = path.join(apiPath, file);
+                    try {
+                        const moduleExport = require(fullPath);
+                        if (typeof moduleExport === 'function') {
+                            api[moduleName] = moduleExport(defaultFuncs, api, ctx);
+                        }
+                    } catch (e) {
+                        utils.error(`Failed to load API module ${moduleName}:`, e);
+                    }
+                });
+        };
+
+        api.getCurrentUserID = () => ctx.userID;
+        api.getOptions = (key) => key ? globalOptions[key] : globalOptions;
+        loadApiModules();
+
+        if (api.nickname && typeof api.nickname === 'function') {
+            api.changeNickname = api.nickname;
+        }
+
+        try {
+            const models = require('../../database/models');
+            const threadDataModule = require('../../database/threadData');
+            const userDataModule = require('../../database/userData');
+            
+            models.syncAll().then(() => {
+                utils.log("Database synchronized successfully");
+            }).catch(err => {
+                utils.warn("Failed to sync database:", err.message);
+            });
+
+            api.threadData = threadDataModule(api);
+            api.userData = userDataModule(api);
+            utils.log("Database methods initialized");
+        } catch (dbError) {
+            utils.warn("Database initialization failed (optional feature):", dbError.message);
+        }
+
+        api.ctx = ctx;
+        api.defaultFuncs = defaultFuncs;
+        api.globalOptions = globalOptions;
+
+        const { TokenRefreshManager } = require('../../utils/tokenRefresh');
+        if (api.tokenRefreshManager) {
+            api.tokenRefreshManager.stopAutoRefresh();
+        } else {
+            api.tokenRefreshManager = new TokenRefreshManager();
+        }
+
+        const { globalAutoReLoginManager } = require('../../utils/autoReLogin');
+
+        if (globalOptions.autoReLogin !== false) {
+            globalAutoReLoginManager.setCredentials(credentials, globalOptions, callback);
+            utils.log("AutoReLogin", "Auto re-login enabled with stored credentials");
+
+            api.tokenRefreshManager.setSessionExpiryCallback((error) => {
+                utils.warn("TokenRefresh", "Session expiry detected. Triggering auto re-login...");
+                globalAutoReLoginManager.handleSessionExpiry(api, fbLinkFunc(), errorRetrievingMsg);
+            });
+        }
+
+        api.tokenRefreshManager.startAutoRefresh(ctx, defaultFuncs, fbLinkFunc());
+
+        api.refreshTokens = () => api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, fbLinkFunc());
+        api.getTokenRefreshStatus = () => ({
+            lastRefresh: api.tokenRefreshManager.lastRefresh,
+            nextRefresh: api.tokenRefreshManager.getTimeUntilNextRefresh(),
+            failureCount: api.tokenRefreshManager.getFailureCount()
+        });
+        api.enableAutoReLogin = (enable = true) => {
+            if (enable) {
+                globalAutoReLoginManager.setCredentials(credentials, globalOptions, callback);
+            } else {
+                globalAutoReLoginManager.disable();
+            }
+        };
+        api.isAutoReLoginEnabled = () => globalAutoReLoginManager.isEnabled();
+
+        return callback(null, api);
+    } catch (error) {
+        utils.error("loginHelper", error.error || error);
+        return callback(error);
+    }
+}
+
+module.exports = loginHelper;

package/src/engine/models/setOptions.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const utils = require('../../utils');
+
+/**
+ * Sets global options for the API.
+ *
+ * @param {object} globalOptions The global options object to modify.
+ * @param {object} [options={}] New options to apply.
+ * @returns {Promise<void>}
+ */
+async function setOptions(globalOptions, options = {}) {
+    const optionHandlers = {
+        online: (value) => (globalOptions.online = Boolean(value)),
+        selfListen: (value) => (globalOptions.selfListen = Boolean(value)),
+        selfListenEvent: (value) => (globalOptions.selfListenEvent = value),
+        listenEvents: (value) => (globalOptions.listenEvents = Boolean(value)),
+        updatePresence: (value) => (globalOptions.updatePresence = Boolean(value)),
+        forceLogin: (value) => (globalOptions.forceLogin = Boolean(value)),
+        userAgent: (value) => (globalOptions.userAgent = value),
+        autoMarkDelivery: (value) => (globalOptions.autoMarkDelivery = Boolean(value)),
+        autoMarkRead: (value) => (globalOptions.autoMarkRead = Boolean(value)),
+        listenTyping: (value) => (globalOptions.listenTyping = Boolean(value)),
+        proxy(value) {
+            if (typeof value !== "string") {
+                delete globalOptions.proxy;
+                utils.setProxy();
+            } else {
+                globalOptions.proxy = value;
+                utils.setProxy(value);
+            }
+        },
+        autoReconnect: (value) => (globalOptions.autoReconnect = Boolean(value)),
+        emitReady: (value) => (globalOptions.emitReady = Boolean(value)),
+        randomUserAgent(value) {
+            globalOptions.randomUserAgent = Boolean(value);
+            if (value) {
+                globalOptions.userAgent = utils.randomUserAgent();
+            }
+        },
+        bypassRegion(value) {
+            if (value){
+                value = value.toUpperCase();
+            } 
+            globalOptions.bypassRegion = value;
+        }
+    };
+    Object.entries(options).forEach(([key, value]) => {
+        if (optionHandlers[key]) optionHandlers[key](value);
+    });
+}
+
+module.exports = setOptions;

package/src/utils/auth-helpers.js

@@ -0,0 +1,149 @@
+"use strict";
+
+const REGION_MAP = new Map([
+    ["PRN", { code: "PRN", name: "Pacific Northwest Region", location: "Khu vực Tây Bắc Thái Bình Dương" }],
+    ["VLL", { code: "VLL", name: "Valley Region", location: "Valley" }],
+    ["ASH", { code: "ASH", name: "Ashburn Region", location: "Ashburn" }],
+    ["DFW", { code: "DFW", name: "Dallas/Fort Worth Region", location: "Dallas/Fort Worth" }],
+    ["LLA", { code: "LLA", name: "Los Angeles Region", location: "Los Angeles" }],
+    ["FRA", { code: "FRA", name: "Frankfurt", location: "Frankfurt" }],
+    ["SIN", { code: "SIN", name: "Singapore", location: "Singapore" }],
+    ["NRT", { code: "NRT", name: "Tokyo", location: "Japan" }],
+    ["HKG", { code: "HKG", name: "Hong Kong", location: "Hong Kong" }],
+    ["SYD", { code: "SYD", name: "Sydney", location: "Sydney" }],
+    ["PNB", { code: "PNB", name: "Pacific Northwest - Beta", location: "Pacific Northwest" }]
+]);
+
+/**
+ * Parses the region from HTML response content with fallback to default.
+ * @param {string} html - The HTML response from Facebook.
+ * @returns {string} The region code (e.g., "PRN", "VLL", etc.).
+ */
+function parseRegion(html) {
+    try {
+        const match1 = html.match(/"endpoint":"([^"]+)"/);
+        const match2 = match1 ? null : html.match(/endpoint\\":\\"([^\\"]+)\\"/);
+        const rawEndpoint = (match1 && match1[1]) || (match2 && match2[1]);
+
+        if (!rawEndpoint) {
+            return "PRN";
+        }
+
+        const endpoint = rawEndpoint.replace(/\\\//g, "/");
+
+        try {
+            const url = new URL(endpoint);
+            const regionParam = url.searchParams ? url.searchParams.get("region") : null;
+
+            if (regionParam) {
+                const regionCode = regionParam.toUpperCase();
+                if (REGION_MAP.has(regionCode)) {
+                    return regionCode;
+                }
+            }
+        } catch (urlError) {
+        }
+
+        return "PRN";
+    } catch (error) {
+        return "PRN";
+    }
+}
+
+/**
+ * Generates a TOTP code from a secret using a basic TOTP algorithm.
+ * This is a fallback implementation that doesn't require external dependencies.
+ * @param {string} secret - The TOTP secret (base32 encoded).
+ * @returns {Promise<string>} The generated 6-digit TOTP code.
+ */
+async function genTotp(secret) {
+    try {
+        const cleaned = String(secret || "")
+            .replace(/\s+/g, "")
+            .toUpperCase();
+
+        if (!cleaned) {
+            throw new Error("TOTP secret is empty");
+        }
+
+        try {
+            const totpGenerator = require('totp-generator');
+            if (typeof totpGenerator.TOTP !== 'undefined' && typeof totpGenerator.TOTP.generate === 'function') {
+                const result = await totpGenerator.TOTP.generate(cleaned);
+                return typeof result === 'object' ? result.otp : result;
+            } else if (typeof totpGenerator === 'function') {
+                return totpGenerator(cleaned);
+            } else {
+                return totpGenerator(cleaned);
+            }
+        } catch (requireError) {
+            const crypto = require('crypto');
+
+            function base32Decode(base32) {
+                const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+                let bits = '';
+
+                for (let i = 0; i < base32.length; i++) {
+                    const val = alphabet.indexOf(base32.charAt(i).toUpperCase());
+                    if (val === -1) continue;
+                    bits += val.toString(2).padStart(5, '0');
+                }
+
+                const bytes = [];
+                for (let i = 0; i + 8 <= bits.length; i += 8) {
+                    bytes.push(parseInt(bits.substr(i, 8), 2));
+                }
+
+                return Buffer.from(bytes);
+            }
+
+            const key = base32Decode(cleaned);
+            const epoch = Math.floor(Date.now() / 1000);
+            const timeCounter = Math.floor(epoch / 30);
+
+            const buffer = Buffer.alloc(8);
+            buffer.writeBigUInt64BE(BigInt(timeCounter));
+
+            const hmac = crypto.createHmac('sha1', key);
+            hmac.update(buffer);
+            const digest = hmac.digest();
+
+            const offset = digest[digest.length - 1] & 0x0f;
+            const code = (
+                ((digest[offset] & 0x7f) << 24) |
+                ((digest[offset + 1] & 0xff) << 16) |
+                ((digest[offset + 2] & 0xff) << 8) |
+                (digest[offset + 3] & 0xff)
+            ) % 1000000;
+
+            return code.toString().padStart(6, '0');
+        }
+    } catch (error) {
+        throw new Error(`Failed to generate TOTP code: ${error.message}`);
+    }
+}
+
+/**
+ * Gets region information by code.
+ * @param {string} code - The region code.
+ * @returns {object|null} The region information or null if not found.
+ */
+function getRegionInfo(code) {
+    return REGION_MAP.get(code.toUpperCase()) || null;
+}
+
+/**
+ * Gets all available regions.
+ * @returns {Array<object>} Array of all region objects.
+ */
+function getAllRegions() {
+    return Array.from(REGION_MAP.values());
+}
+
+module.exports = {
+    REGION_MAP,
+    parseRegion,
+    genTotp,
+    getRegionInfo,
+    getAllRegions
+};