@lazyneoaz/testfca 1.0.0

package/src/e2ee/bridge.js

@@ -0,0 +1,275 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+
+let koffi;
+let lib;
+let fns;
+let initialized = false;
+
+function libPath() {
+    const base = path.join(__dirname, '../../build');
+    if (process.platform === 'win32') return path.join(base, 'messagix.dll');
+    if (process.platform === 'darwin') return path.join(base, 'messagix.dylib');
+    return path.join(base, 'messagix.so');
+}
+
+const LIB_PATH = libPath();
+
+function init() {
+    if (initialized) return;
+    if (!fs.existsSync(LIB_PATH)) {
+        throw new Error(
+            `E2EE bridge library not found at ${LIB_PATH}.\n` +
+            `Build it with: npm run build:go\n` +
+            `Or set MESSAGIX_BUILD_FROM_SOURCE=true and reinstall.`
+        );
+    }
+    koffi = require('koffi');
+    lib = koffi.load(LIB_PATH);
+    const mk = (ret, name, args) => lib.func(name, ret, args);
+    fns = {
+        MxFreeCString:           mk('void', 'MxFreeCString',           ['char*']),
+        MxNewClient:             mk('str',  'MxNewClient',             ['str']),
+        MxConnect:               mk('str',  'MxConnect',               ['str']),
+        MxConnectE2EE:           mk('str',  'MxConnectE2EE',           ['str']),
+        MxDisconnect:            mk('str',  'MxDisconnect',            ['str']),
+        MxIsConnected:           mk('str',  'MxIsConnected',           ['str']),
+        MxSendMessage:           mk('str',  'MxSendMessage',           ['str']),
+        MxSendReaction:          mk('str',  'MxSendReaction',          ['str']),
+        MxEditMessage:           mk('str',  'MxEditMessage',           ['str']),
+        MxUnsendMessage:         mk('str',  'MxUnsendMessage',         ['str']),
+        MxSendTyping:            mk('str',  'MxSendTyping',            ['str']),
+        MxMarkRead:              mk('str',  'MxMarkRead',              ['str']),
+        MxPollEvents:            mk('str',  'MxPollEvents',            ['str']),
+        MxGetDeviceData:         mk('str',  'MxGetDeviceData',         ['str']),
+        MxSendE2EEMessage:       mk('str',  'MxSendE2EEMessage',       ['str']),
+        MxSendE2EEReaction:      mk('str',  'MxSendE2EEReaction',      ['str']),
+        MxSendE2EETyping:        mk('str',  'MxSendE2EETyping',        ['str']),
+        MxEditE2EEMessage:       mk('str',  'MxEditE2EEMessage',       ['str']),
+        MxUnsendE2EEMessage:     mk('str',  'MxUnsendE2EEMessage',     ['str']),
+        MxSendE2EEImage:         mk('str',  'MxSendE2EEImage',         ['str']),
+        MxSendE2EEVideo:         mk('str',  'MxSendE2EEVideo',         ['str']),
+        MxSendE2EEAudio:         mk('str',  'MxSendE2EEAudio',         ['str']),
+        MxSendE2EEDocument:      mk('str',  'MxSendE2EEDocument',      ['str']),
+        MxSendE2EESticker:       mk('str',  'MxSendE2EESticker',       ['str']),
+        MxDownloadE2EEMedia:     mk('str',  'MxDownloadE2EEMedia',     ['str']),
+        MxGetCookies:            mk('str',  'MxGetCookies',            ['str']),
+        MxUploadMedia:           mk('str',  'MxUploadMedia',           ['str']),
+        MxSendImage:             mk('str',  'MxSendImage',             ['str']),
+        MxSendVideo:             mk('str',  'MxSendVideo',             ['str']),
+        MxSendVoice:             mk('str',  'MxSendVoice',             ['str']),
+        MxSendFile:              mk('str',  'MxSendFile',              ['str']),
+        MxSendSticker:           mk('str',  'MxSendSticker',           ['str']),
+        MxGetUserInfo:           mk('str',  'MxGetUserInfo',           ['str']),
+        MxCreateThread:          mk('str',  'MxCreateThread',          ['str']),
+        MxSearchUsers:                mk('str',  'MxSearchUsers',                ['str']),
+        MxRenameThread:               mk('str',  'MxRenameThread',               ['str']),
+        MxMuteThread:                 mk('str',  'MxMuteThread',                 ['str']),
+        MxDeleteThread:               mk('str',  'MxDeleteThread',               ['str']),
+        MxSetGroupPhoto:              mk('str',  'MxSetGroupPhoto',              ['str']),
+        MxRegisterPushNotifications:  mk('str',  'MxRegisterPushNotifications',  ['str']),
+    };
+    initialized = true;
+}
+
+function serialize(obj) {
+    return JSON.stringify(obj, (_, v) =>
+        typeof v === 'bigint' ? Number(v) : v
+    );
+}
+
+function deserialize(str) {
+    return JSON.parse(str);
+}
+
+function call(fn, payload) {
+    init();
+    const input = serialize(payload);
+    const out = fns[fn](input);
+    const data = deserialize(out);
+    if (!data.ok) throw new Error(data.error || 'Unknown E2EE bridge error');
+    return data.data;
+}
+
+function callAsync(fn, payload) {
+    return new Promise((resolve, reject) => {
+        setImmediate(() => {
+            try { resolve(call(fn, payload)); }
+            catch (err) { reject(err); }
+        });
+    });
+}
+
+module.exports = {
+    isAvailable() {
+        try { init(); return true; } catch (_) { return false; }
+    },
+
+    newClient(cfg) {
+        return call('MxNewClient', cfg);
+    },
+
+    connect(handle) {
+        return callAsync('MxConnect', { handle });
+    },
+
+    connectE2EE(handle) {
+        return callAsync('MxConnectE2EE', { handle });
+    },
+
+    disconnect(handle) {
+        try { return call('MxDisconnect', { handle }); } catch (_) {}
+    },
+
+    isConnected(handle) {
+        try { return call('MxIsConnected', { handle }); }
+        catch (_) { return { connected: false, e2eeConnected: false }; }
+    },
+
+    getDeviceData(handle) {
+        return call('MxGetDeviceData', { handle });
+    },
+
+    pollEvents(handle, timeoutMs) {
+        return callAsync('MxPollEvents', { handle, timeoutMs: timeoutMs || 5000 });
+    },
+
+    sendMessage(handle, options) {
+        return callAsync('MxSendMessage', { handle, options });
+    },
+
+    sendReaction(handle, threadId, messageId, emoji) {
+        return callAsync('MxSendReaction', { handle, threadId, messageId, emoji });
+    },
+
+    editMessage(handle, messageId, newText) {
+        return callAsync('MxEditMessage', { handle, messageId, newText });
+    },
+
+    unsendMessage(handle, messageId) {
+        return callAsync('MxUnsendMessage', { handle, messageId });
+    },
+
+    sendTyping(handle, threadId, isTyping, isGroup, threadType) {
+        return callAsync('MxSendTyping', { handle, threadId, isTyping, isGroup, threadType });
+    },
+
+    markRead(handle, threadId, watermarkTs) {
+        return callAsync('MxMarkRead', { handle, threadId, watermarkTs: watermarkTs || 0 });
+    },
+
+    sendE2EEMessage(handle, chatJid, text, replyToId, replyToSenderJid) {
+        return callAsync('MxSendE2EEMessage', { handle, chatJid, text, replyToId, replyToSenderJid });
+    },
+
+    sendE2EEReaction(handle, chatJid, messageId, senderJid, emoji) {
+        return callAsync('MxSendE2EEReaction', { handle, chatJid, messageId, senderJid, emoji });
+    },
+
+    sendE2EETyping(handle, chatJid, isTyping) {
+        return callAsync('MxSendE2EETyping', { handle, chatJid, isTyping: !!isTyping });
+    },
+
+    editE2EEMessage(handle, chatJid, messageId, newText) {
+        return callAsync('MxEditE2EEMessage', { handle, chatJid, messageId, newText });
+    },
+
+    unsendE2EEMessage(handle, chatJid, messageId) {
+        return callAsync('MxUnsendE2EEMessage', { handle, chatJid, messageId });
+    },
+
+    sendE2EEImage(handle, options) {
+        return callAsync('MxSendE2EEImage', { handle, options });
+    },
+
+    sendE2EEVideo(handle, options) {
+        return callAsync('MxSendE2EEVideo', { handle, options });
+    },
+
+    sendE2EEAudio(handle, options) {
+        return callAsync('MxSendE2EEAudio', { handle, options });
+    },
+
+    sendE2EEDocument(handle, options) {
+        return callAsync('MxSendE2EEDocument', { handle, options });
+    },
+
+    sendE2EESticker(handle, options) {
+        return callAsync('MxSendE2EESticker', { handle, options });
+    },
+
+    downloadE2EEMedia(handle, options) {
+        return callAsync('MxDownloadE2EEMedia', { handle, options });
+    },
+
+    getCookies(handle) {
+        return call('MxGetCookies', { handle });
+    },
+
+    uploadMedia(handle, options) {
+        return callAsync('MxUploadMedia', { handle, options });
+    },
+
+    sendImage(handle, options) {
+        return callAsync('MxSendImage', { handle, options });
+    },
+
+    sendVideo(handle, options) {
+        return callAsync('MxSendVideo', { handle, options });
+    },
+
+    sendVoice(handle, options) {
+        return callAsync('MxSendVoice', { handle, options });
+    },
+
+    sendFile(handle, options) {
+        return callAsync('MxSendFile', { handle, options });
+    },
+
+    sendSticker(handle, options) {
+        return callAsync('MxSendSticker', { handle, options });
+    },
+
+    getUserInfo(handle, userId) {
+        return callAsync('MxGetUserInfo', { handle, options: { userId } });
+    },
+
+    createThread(handle, userId) {
+        return callAsync('MxCreateThread', { handle, options: { userId } });
+    },
+
+    searchUsers(handle, query) {
+        return callAsync('MxSearchUsers', { handle, options: { query } });
+    },
+
+    renameThread(handle, threadId, newName) {
+        return callAsync('MxRenameThread', { handle, options: { threadId, newName } });
+    },
+
+    muteThread(handle, threadId, muteSeconds) {
+        return callAsync('MxMuteThread', { handle, options: { threadId, muteSeconds } });
+    },
+
+    deleteThread(handle, threadId) {
+        return callAsync('MxDeleteThread', { handle, options: { threadId } });
+    },
+
+    setGroupPhoto(handle, threadId, data, mimeType) {
+        return callAsync('MxSetGroupPhoto', { handle, threadId, data, mimeType });
+    },
+
+    registerPushNotifications(handle, options) {
+        return callAsync('MxRegisterPushNotifications', { handle, options });
+    },
+
+    unload() {
+        if (lib) {
+            try { lib.unload(); } catch (_) {}
+            lib = null;
+            fns = null;
+            initialized = false;
+        }
+    }
+};

package/src/e2ee/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+const bridge = require('./bridge');
+
+const DEFAULT_DEVICE_PATH = path.join(process.cwd(), '.nkxfca_e2ee_device.json');
+
+function extractCookies(jar) {
+    const cookies = {};
+    try {
+        const list = jar.getCookiesSync('https://www.facebook.com');
+        for (const c of list) cookies[c.key] = c.value;
+        const msgnList = jar.getCookiesSync('https://www.messenger.com');
+        for (const c of msgnList) {
+            if (!cookies[c.key]) cookies[c.key] = c.value;
+        }
+    } catch (_) {}
+    return cookies;
+}
+
+function detectPlatform(cookies) {
+    if (cookies.c_user || cookies.xs) return 'facebook';
+    return 'facebook';
+}
+
+function loadSavedDeviceData(devicePath) {
+    try {
+        if (fs.existsSync(devicePath)) {
+            return fs.readFileSync(devicePath, 'utf8');
+        }
+    } catch (_) {}
+    return null;
+}
+
+async function getOrCreateHandle(ctx, options) {
+    if (ctx._e2eeBridgeHandle != null) return ctx._e2eeBridgeHandle;
+
+    const cookies = extractCookies(ctx.jar);
+    const devicePath = (options && options.devicePath) || ctx._e2eeDevicePath || DEFAULT_DEVICE_PATH;
+
+    const cfg = {
+        cookies,
+        platform: detectPlatform(cookies),
+        logLevel: 'warn',
+        devicePath,
+        ...(options || {}),
+    };
+
+    if (cfg.deviceData === undefined && ctx._e2eeDeviceData) {
+        cfg.deviceData = ctx._e2eeDeviceData;
+    }
+
+    const { handle } = bridge.newClient(cfg);
+    ctx._e2eeBridgeHandle = handle;
+    ctx._e2eeDevicePath = devicePath;
+    return handle;
+}
+
+module.exports = { bridge, extractCookies, getOrCreateHandle, DEFAULT_DEVICE_PATH };

package/src/engine/client.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const utils = require("../utils");
+const setOptionsModel = require('./models/setOptions');
+const buildAPIModel = require('./models/buildAPI');
+const loginHelperModel = require('./models/loginHelper');
+
+let globalOptions = {};
+let ctx = null;
+let defaultFuncs = null;
+let api = null;
+
+const fbLink = (ext) => ("https://www.facebook.com" + (ext ? '/' + ext : ''));
+const ERROR_RETRIEVING = "Error retrieving userID. This can be caused by many factors, including being blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.";
+
+/**
+ * Initiates the login process for a Facebook account.
+ *
+ * @param {object} credentials The user's login credentials (e.g., email/password or appState cookies).
+ * @param {object} [options={}] Optional login configurations.
+ * @param {function} [callback] Optional callback function. If omitted, returns a Promise.
+ * @returns {Promise|void} Returns Promise if no callback provided, otherwise void.
+ */
+async function login(credentials, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    }
+    if (!options || typeof options !== "object") {
+        options = {};
+    }
+    
+    let promiseCallback = null;
+    let rejectFunc = null;
+    let resolveFunc = null;
+    let returnPromise = null;
+
+    if (typeof callback !== "function") {
+        returnPromise = new Promise(function (resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        promiseCallback = function (error, api) {
+            if (error) return rejectFunc(error);
+            return resolveFunc(api);
+        };
+        callback = promiseCallback;
+    }
+
+    if ('logging' in options) {
+        utils.logOptions(options.logging);
+    }
+    const defaultOptions = {
+        selfListen: false,
+        listenEvents: true,
+        listenTyping: false,
+        simulateTyping: true,
+        updatePresence: false,
+        forceLogin: false,
+        autoMarkDelivery: false,
+        autoMarkRead: true,
+        autoReconnect: true,
+        online: true,
+        emitReady: false,
+        userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    };
+    Object.assign(globalOptions, defaultOptions, options);
+
+    await setOptionsModel(globalOptions, options);
+
+    loginHelperModel(
+        credentials,
+        globalOptions,
+        (loginError, loginApi) => {
+            if (loginError) {
+                return callback(loginError);
+            }
+            api = loginApi;
+            ctx = loginApi.ctx;
+            defaultFuncs = loginApi.defaultFuncs;
+            return callback(null, loginApi);
+        },
+        setOptionsModel,
+        buildAPIModel,
+        api,
+        fbLink, 
+        ERROR_RETRIEVING
+    );
+
+    return returnPromise;
+}
+
+module.exports = {
+    login
+};

package/src/engine/models/buildAPI.js

@@ -0,0 +1,152 @@
+"use strict";
+
+const utils = require('../../utils');
+const SimpleCache = require('../../utils/cache');
+const { globalValidator } = require('../../utils/validation');
+
+/**
+ * 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":"', '"');
+    
+    // Extract additional DTSG AG token for better session persistence
+    const dtsgAgData = findConfig("DTSGAGInitialData");
+    const fb_dtsg_ag = dtsgAgData ? dtsgAgData.token : utils.getFrom(html, '"DTSGAGInitialData",[],{"token":"', '"');
+    
+    // Extract spin parameters for consistency
+    const spinRMatch = html.match(/"__spin_r":(\d+)/);
+    const __spin_r = spinRMatch ? spinRMatch[1] : undefined;
+    
+    const spinBMatch = html.match(/"__spin_b":"([^"]+)"/);
+    const __spin_b = spinBMatch ? spinBMatch[1] : undefined;
+    
+    const spinTMatch = html.match(/"__spin_t":(\d+)/);
+    const __spin_t = spinTMatch ? spinTMatch[1] : undefined;
+    
+    // Extract hsi (host session identifier)
+    const hsiMatch = html.match(/"hsi":"(\d+)"/);
+    const hsi = hsiMatch ? hsiMatch[1] : undefined;
+    
+    // Extract dyn and csr for consistency
+    const dynMatch = html.match(/"dyn":"([^"]+)"/);
+    const dyn = dynMatch ? dynMatch[1] : undefined;
+    
+    const csrMatch = html.match(/"csr":"([^"]+)"/);
+    const csr = csrMatch ? csrMatch[1] : undefined;
+    
+    const dtsgResult = { 
+        fb_dtsg: dtsg, 
+        jazoest: `2${Array.from(dtsg).reduce((a, b) => a + b.charCodeAt(0), '')}`,
+        lsd: lsd,
+        fb_dtsg_ag: fb_dtsg_ag,
+        __spin_r: __spin_r,
+        __spin_b: __spin_b,
+        __spin_t: __spin_t,
+        hsi: hsi,
+        dyn: dyn,
+        csr: csr
+    };
+
+    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;
+    if (mqttEndpoint) {
+        try {
+            region = new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase();
+        } catch (_) {
+            // Malformed or missing MQTT endpoint — region stays 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,
+        cache: new SimpleCache(),
+        validator: globalValidator,
+        ...dtsgResult,
+    };
+    const defaultFuncs = utils.makeDefaults(html, userID, ctx);
+
+    return [ctx, defaultFuncs, {}];
+}
+
+module.exports = buildAPI;