@lazyneoaz/testfca 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/testfca",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "commonjs",
   "description": "Advanced Facebook Chat API client for building Messenger bots — supports real-time messaging, thread management, MQTT, session stability, anti-automation protection, and real E2EE via Signal Protocol.",
   "main": "index.js",
@@ -11,8 +11,8 @@
   "files": [
     "index.js",
     "src/",
-    "scripts/",
     "prebuilt/",
+    "scripts/",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",
@@ -61,8 +61,8 @@
     "form-data": "^4.0.4",
     "https-proxy-agent": "^7.0.6",
     "jsonpath-plus": "^10.3.0",
-    "koffi": "^3.0.2",
     "lodash": "^4.17.21",
+    "meta-messenger.js": "^1.1.3",
     "mqtt": "^4.3.8",
     "node-cron": "^3.0.3",
     "npmlog": "^7.0.1",
@@ -87,12 +87,11 @@
     "node": ">=20.18.1"
   },
   "scripts": {
+    "postinstall": "node scripts/postinstall.js",
     "prepack": "echo 'Preparing package for npm...'",
     "test": "echo 'No tests configured yet'",
     "lint": "eslint src/",
     "format": "prettier --write src/**/*.js",
-    "postinstall": "node scripts/postinstall.mjs",
-    "build:go": "node scripts/build-go.mjs",
     "validate": "npm pack --dry-run"
   },
   "overrides": {

package/scripts/postinstall.js

@@ -0,0 +1,98 @@
+"use strict";
+
+/**
+ * Postinstall: replace meta-messenger.js's binary with our TLS-fixed build.
+ *
+ * WHY this is needed:
+ *   The meta-messenger.js binary lacks InsecureTLS=true in its messagix HTTP
+ *   client.  In sandboxed/containerised environments (Replit, Docker, CI) the
+ *   Go runtime cannot locate system CA certificates, so every prekey-bundle
+ *   HTTPS request to Facebook fails silently.  Without prekeys, Signal sessions
+ *   are never established and sendE2EEMessage always times out.
+ *
+ *   Our prebuilt/ ships the same binary compiled with InsecureTLS=true.
+ *
+ * INSTALL ORDER (guaranteed by npm):
+ *   1. meta-messenger.js postinstall runs first (copies/downloads their binary)
+ *   2. Our postinstall runs second and overwrites it with ours.
+ *
+ * PATH RESOLUTION:
+ *   Uses require.resolve() so the path is correct whether meta-messenger.js is
+ *   at the project root node_modules/ or nested — works in all npm versions.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+function platformKey() {
+    const p = process.platform;
+    const a = process.arch;
+    if (p === 'linux'  && a === 'x64')   return 'linux-x64-gnu';
+    if (p === 'linux'  && a === 'arm64') return 'linux-arm64-gnu';
+    if (p === 'darwin' && a === 'x64')   return 'darwin-x64';
+    if (p === 'darwin' && a === 'arm64') return 'darwin-arm64';
+    if (p === 'win32'  && a === 'x64')   return 'win32-x64-msvc';
+    return null;
+}
+
+function ext() {
+    if (process.platform === 'win32')  return '.dll';
+    if (process.platform === 'darwin') return '.dylib';
+    return '.so';
+}
+
+function findMetaMessengerBuildDir() {
+    try {
+        // resolve() finds the package regardless of hoisting depth
+        const pkgJson = require.resolve('meta-messenger.js/package.json');
+        return path.join(path.dirname(pkgJson), 'build');
+    } catch (_) {
+        return null;
+    }
+}
+
+function main() {
+    if (process.env.NKXFCA_SKIP_POSTINSTALL === 'true') {
+        console.log('[nkxfca] postinstall skipped (NKXFCA_SKIP_POSTINSTALL=true)');
+        return;
+    }
+
+    const key = platformKey();
+    if (!key) {
+        console.log('[nkxfca] postinstall: unsupported platform (' + process.platform + '/' + process.arch + '), skipping binary patch.');
+        return;
+    }
+
+    const binaryExt = ext();
+    const ourBin    = path.join(__dirname, '..', 'prebuilt', key, 'messagix' + binaryExt);
+
+    if (!fs.existsSync(ourBin)) {
+        console.log('[nkxfca] postinstall: no prebuilt for ' + key + ', skipping binary patch.');
+        return;
+    }
+
+    const mmBuildDir = findMetaMessengerBuildDir();
+    if (!mmBuildDir) {
+        console.log('[nkxfca] postinstall: meta-messenger.js not found via require.resolve, skipping patch.');
+        return;
+    }
+
+    const mmBin = path.join(mmBuildDir, 'messagix' + binaryExt);
+
+    // Ensure the build directory exists (meta-messenger.js postinstall creates it,
+    // but guard against edge cases where it hasn't run yet)
+    try {
+        fs.mkdirSync(mmBuildDir, { recursive: true });
+    } catch (_) {}
+
+    try {
+        fs.copyFileSync(ourBin, mmBin);
+        console.log('[nkxfca] postinstall: patched meta-messenger.js binary with TLS-fixed build (' + key + ')');
+    } catch (err) {
+        // Non-fatal: warn but don't fail the install
+        console.warn('[nkxfca] postinstall: could not patch binary: ' + err.message);
+        console.warn('[nkxfca] E2EE messaging may not work in sandboxed environments.');
+    }
+}
+
+main();

package/src/apis/listenMqtt.js

@@ -592,130 +592,134 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                 }
                 while (ctx._e2eePollingActive) {
                     try {
-                        // Yield to event loop before blocking poll (same pattern as yumi-team)
+                        // Yield to event loop before blocking poll
                         await new Promise(resolve => setImmediate(resolve));
                         if (!ctx._e2eePollingActive) break;
 
-                        // Poll with 1 s timeout — returns a typed event object, NOT an array
-                        const ev = await api.e2ee.pollEvents(1000);
+                        // pollEvents returns { events: [...] } — iterate the array
+                        const result = await api.e2ee.pollEvents(1000);
                         if (!ctx._e2eePollingActive) break;
 
-                        // No event / empty result
-                        if (!ev) continue;
+                        // No events returned (timeout or empty)
+                        if (!result || !Array.isArray(result.events) || result.events.length === 0) continue;
 
-                        const evType = (ev.type || '').toLowerCase();
+                        for (const ev of result.events) {
+                            if (!ctx._e2eePollingActive) break;
 
-                        // ── timeout: no event arrived during the poll window ──
-                        if (evType === 'timeout') continue;
+                            const evType = (ev.type || '').toLowerCase();
 
-                        // ── closed: Go bridge shut down ──
-                        if (evType === 'closed') {
-                            utils.warn("E2EE", "Bridge closed. Stopping DM poll loop.");
-                            ctx._e2eePollingActive = false;
-                            break;
-                        }
+                            // ── timeout: no event arrived during the poll window ──
+                            if (evType === 'timeout') continue;
 
-                        // ── permanent error (e.g. session invalid) ──
-                        if (evType === 'error') {
-                            const msg = ev.data && ev.data.message ? ev.data.message : JSON.stringify(ev.data);
-                            utils.warn("E2EE", "Bridge error event:", msg);
-                            if (ev.data && ev.data.code === 1) {
+                            // ── closed: bridge shut down ──
+                            if (evType === 'closed') {
+                                utils.warn("E2EE", "Bridge closed. Stopping DM poll loop.");
                                 ctx._e2eePollingActive = false;
                                 break;
                             }
-                            continue;
-                        }
 
-                        // ── E2EE connection confirmed by the bridge ──
-                        if (evType === 'e2eeconnected') {
-                            utils.log("E2EE", "E2EE fully connected (bridge event).");
-                            continue;
-                        }
+                            // ── permanent error (e.g. session invalid) ──
+                            if (evType === 'error') {
+                                const msg = ev.data && ev.data.message ? ev.data.message : JSON.stringify(ev.data);
+                                utils.warn("E2EE", "Bridge error event:", msg);
+                                if (ev.data && ev.data.code === 1) {
+                                    ctx._e2eePollingActive = false;
+                                    break;
+                                }
+                                continue;
+                            }
 
-                        // ── Incoming E2EE DM ─────────────────────────────────
-                        if (evType === 'e2eemessage') {
-                            const d = ev.data;
-                            if (!d) continue;
-                            // threadId may be 0 for pure-JID threads — fall back to chatJid
-                            const chatJid   = d.chatJid   || '';
-                            const senderJid = d.senderJid || '';
-                            const threadID  = String(d.threadId || chatJid.replace(/@.*/, '') || '');
-                            const senderID  = String(d.senderId || senderJid.replace(/@.*/, '') || '');
-                            if (!threadID || !senderID) {
-                                utils.log("E2EE", "e2eeMessage missing IDs — raw:", JSON.stringify(d).slice(0, 300));
+                            // ── E2EE connection confirmed by the bridge ──
+                            if (evType === 'e2eeconnected') {
+                                utils.log("E2EE", "E2EE fully connected (bridge event).");
                                 continue;
                             }
-                            if (senderID === ctx.userID.toString() && !ctx.globalOptions.selfListen) continue;
-
-                            utils.log("E2EE", "Incoming E2EE DM from", senderID, "→ thread", threadID, "body:", JSON.stringify(d.text || '').slice(0, 80));
-
-                            const fmtMsg = {
-                                type:        'message',
-                                senderID:    utils.formatID(senderID),
-                                body:        d.text || '',
-                                threadID:    utils.formatID(threadID),
-                                messageID:   d.id || '',
-                                isGroup:     false,
-                                attachments: [],
-                                mentions:    {},
-                                timestamp:   Number(d.timestampMs || Date.now()),
-                                isUnread:    true,
-                            };
-                            if (ctx.globalOptions.autoMarkDelivery) {
-                                try { api.markAsDelivered(fmtMsg.threadID, fmtMsg.messageID); } catch (_) {}
+
+                            // ── Incoming E2EE DM ─────────────────────────────────
+                            if (evType === 'e2eemessage') {
+                                const d = ev.data;
+                                if (!d) continue;
+                                // threadId may be 0 for pure-JID threads — fall back to chatJid
+                                const chatJid   = d.chatJid   || '';
+                                const senderJid = d.senderJid || '';
+                                const threadID  = String(d.threadId || chatJid.replace(/@.*/, '') || '');
+                                const senderID  = String(d.senderId || senderJid.replace(/@.*/, '') || '');
+                                if (!threadID || !senderID) {
+                                    utils.log("E2EE", "e2eeMessage missing IDs — raw:", JSON.stringify(d).slice(0, 300));
+                                    continue;
+                                }
+                                if (senderID === ctx.userID.toString() && !ctx.globalOptions.selfListen) continue;
+
+                                utils.log("E2EE", "Incoming E2EE DM from", senderID, "→ thread", threadID, "body:", JSON.stringify(d.text || '').slice(0, 80));
+
+                                const fmtMsg = {
+                                    type:        'message',
+                                    senderID:    utils.formatID(senderID),
+                                    body:        d.text || '',
+                                    threadID:    utils.formatID(threadID),
+                                    messageID:   d.id || '',
+                                    isGroup:     false,
+                                    attachments: [],
+                                    mentions:    {},
+                                    timestamp:   Number(d.timestampMs || Date.now()),
+                                    isUnread:    true,
+                                };
+                                if (ctx.globalOptions.autoMarkDelivery) {
+                                    try { api.markAsDelivered(fmtMsg.threadID, fmtMsg.messageID); } catch (_) {}
+                                }
+                                if (ctx.globalOptions.autoMarkRead) {
+                                    try { api.markAsRead(fmtMsg.threadID); } catch (_) {}
+                                }
+                                globalCallback(null, fmtMsg);
+                                continue;
                             }
-                            if (ctx.globalOptions.autoMarkRead) {
-                                try { api.markAsRead(fmtMsg.threadID); } catch (_) {}
+
+                            // ── Incoming regular (non-E2EE) message via bridge ───
+                            if (evType === 'message') {
+                                const d = ev.data;
+                                if (!d) continue;
+                                const threadID = String(d.threadId || '');
+                                const senderID = String(d.senderId || '');
+                                if (!threadID || !senderID) continue;
+                                if (senderID === ctx.userID.toString() && !ctx.globalOptions.selfListen) continue;
+                                globalCallback(null, {
+                                    type:        'message',
+                                    senderID:    utils.formatID(senderID),
+                                    body:        d.text || '',
+                                    threadID:    utils.formatID(threadID),
+                                    messageID:   d.id || '',
+                                    isGroup:     !!(d.isGroup),
+                                    attachments: [],
+                                    mentions:    {},
+                                    timestamp:   Number(d.timestampMs || Date.now()),
+                                    isUnread:    true,
+                                });
+                                continue;
                             }
-                            globalCallback(null, fmtMsg);
-                            continue;
-                        }
 
-                        // ── Incoming regular (non-E2EE) message via bridge ───
-                        if (evType === 'message') {
-                            const d = ev.data;
-                            if (!d) continue;
-                            const threadID = String(d.threadId || '');
-                            const senderID = String(d.senderId || '');
-                            if (!threadID || !senderID) continue;
-                            if (senderID === ctx.userID.toString() && !ctx.globalOptions.selfListen) continue;
-                            globalCallback(null, {
-                                type:        'message',
-                                senderID:    utils.formatID(senderID),
-                                body:        d.text || '',
-                                threadID:    utils.formatID(threadID),
-                                messageID:   d.id || '',
-                                isGroup:     !!(d.isGroup),
-                                attachments: [],
-                                mentions:    {},
-                                timestamp:   Number(d.timestampMs || Date.now()),
-                                isUnread:    true,
-                            });
-                            continue;
-                        }
+                            // ── E2EE reaction ────────────────────────────────────
+                            if (evType === 'e2eereaction') {
+                                if (!ctx.globalOptions.listenEvents) continue;
+                                const d = ev.data;
+                                if (!d) continue;
+                                const chatJid   = d.chatJid   || '';
+                                const senderJid = d.senderJid || '';
+                                globalCallback(null, {
+                                    type:                'message_reaction',
+                                    threadID:            utils.formatID(chatJid.replace(/@.*/, '')),
+                                    messageID:           d.messageId || '',
+                                    reaction:            d.reaction  || '',
+                                    senderID:            utils.formatID(senderJid.replace(/@.*/, '')),
+                                    offlineThreadingId:  null,
+                                    timestamp:           Date.now(),
+                                    isGroup:             false,
+                                });
+                                continue;
+                            }
 
-                        // ── E2EE reaction ────────────────────────────────────
-                        if (evType === 'e2eereaction') {
-                            if (!ctx.globalOptions.listenEvents) continue;
-                            const d = ev.data;
-                            if (!d) continue;
-                            const chatJid   = d.chatJid   || '';
-                            const senderJid = d.senderJid || '';
-                            globalCallback(null, {
-                                type:                'message_reaction',
-                                threadID:            utils.formatID(chatJid.replace(/@.*/, '')),
-                                messageID:           d.messageId || '',
-                                reaction:            d.reaction  || '',
-                                senderID:            utils.formatID(senderJid.replace(/@.*/, '')),
-                                offlineThreadingId:  null,
-                                timestamp:           Date.now(),
-                                isGroup:             false,
-                            });
-                            continue;
+                            // ready / reconnected / disconnected / deviceDataChanged / raw → ignore silently
                         }
 
-                        // ready / reconnected / disconnected / deviceDataChanged / raw → ignore silently
-
                     } catch (pollErr) {
                         if (!ctx._e2eePollingActive) break;
                         utils.warn("E2EE", "pollEvents error:", pollErr && pollErr.message ? pollErr.message : pollErr);

package/src/e2ee/bridge.js

@@ -1,275 +1,404 @@
 "use strict";
 
+/**
+ * Lightweight E2EE bridge — delegates to the `meta-messenger.js` npm package.
+ *
+ * Our postinstall replaces meta-messenger.js's binary with our TLS-fixed build
+ * so that prekey HTTPS requests succeed in sandboxed environments (Replit, Docker,
+ * Railway, etc.).  We also patch at runtime (ensureTlsFixedBinary) so the fix
+ * applies even when postinstall was skipped (npm ci --ignore-scripts, Railway
+ * production installs, etc.).
+ *
+ * Key design decisions:
+ *  - enableE2EE: false  → we call connectE2EE() explicitly; no auto-start race
+ *  - e2eeMemoryOnly: false → Signal sessions are persisted to devicePath on disk
+ *  - devicePath defaults to ".nkxfca_e2ee_device.json" in cwd when not provided
+ */
+
+const fs   = require('fs');
 const path = require('path');
-const fs = require('fs');
 
-let koffi;
-let lib;
-let fns;
-let initialized = false;
+// ── Runtime binary patcher ────────────────────────────────────────────────────
+// Ensures the TLS-fixed binary is in place before meta-messenger.js is loaded.
+// Runs once; safe to call multiple times.
+
+let _patchDone = false;
+
+function _platformKey() {
+    const p = process.platform;
+    const a = process.arch;
+    if (p === 'linux'  && a === 'x64')   return 'linux-x64-gnu';
+    if (p === 'linux'  && a === 'arm64') return 'linux-arm64-gnu';
+    if (p === 'darwin' && a === 'x64')   return 'darwin-x64';
+    if (p === 'darwin' && a === 'arm64') return 'darwin-arm64';
+    if (p === 'win32'  && a === 'x64')   return 'win32-x64-msvc';
+    return null;
+}
 
-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');
+function _binaryExt() {
+    if (process.platform === 'win32')  return '.dll';
+    if (process.platform === 'darwin') return '.dylib';
+    return '.so';
 }
 
-const LIB_PATH = libPath();
+function ensureTlsFixedBinary() {
+    if (_patchDone) return;
+    _patchDone = true;
 
-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;
-}
+    if (process.env.NKXFCA_SKIP_POSTINSTALL === 'true') return;
 
-function serialize(obj) {
-    return JSON.stringify(obj, (_, v) =>
-        typeof v === 'bigint' ? Number(v) : v
-    );
-}
+    const key = _platformKey();
+    if (!key) return;
 
-function deserialize(str) {
-    return JSON.parse(str);
-}
+    const ext    = _binaryExt();
+    // bridge.js lives at src/e2ee/bridge.js → prebuilt/ is two levels up
+    const ourBin = path.join(__dirname, '..', '..', 'prebuilt', key, 'messagix' + ext);
+    if (!fs.existsSync(ourBin)) return;
 
-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;
-}
+    try {
+        const pkgJson  = require.resolve('meta-messenger.js/package.json');
+        const buildDir = path.join(path.dirname(pkgJson), 'build');
+        const mmBin    = path.join(buildDir, 'messagix' + ext);
 
-function callAsync(fn, payload) {
-    return new Promise((resolve, reject) => {
-        setImmediate(() => {
-            try { resolve(call(fn, payload)); }
-            catch (err) { reject(err); }
-        });
-    });
-}
+        fs.mkdirSync(buildDir, { recursive: true });
 
-module.exports = {
-    isAvailable() {
-        try { init(); return true; } catch (_) { return false; }
-    },
+        // Only copy if sizes differ (avoids unnecessary writes on every boot)
+        let needsCopy = true;
+        if (fs.existsSync(mmBin)) {
+            needsCopy = fs.statSync(ourBin).size !== fs.statSync(mmBin).size;
+        }
 
-    newClient(cfg) {
-        return call('MxNewClient', cfg);
-    },
+        if (needsCopy) {
+            fs.copyFileSync(ourBin, mmBin);
+            fs.chmodSync(mmBin, 0o755);
+            console.log('[nkxfca] runtime patch: applied TLS-fixed binary (' + key + ')');
+        }
+    } catch (err) {
+        // Non-fatal — warn so the user knows why E2EE may not work
+        console.warn('[nkxfca] runtime patch failed (' + err.message + '). E2EE TLS errors may occur in sandboxed environments.');
+    }
+}
 
-    connect(handle) {
-        return callAsync('MxConnect', { handle });
-    },
+// ─────────────────────────────────────────────────────────────────────────────
+
+let _Client = null;
+let _loadError = null;
+
+function loadClient() {
+    if (_Client) return _Client;
+    if (_loadError) throw _loadError;
+
+    // Patch binary BEFORE the first require('meta-messenger.js') so the
+    // TLS-fixed .so/.dylib/.dll is loaded by Node rather than the original.
+    ensureTlsFixedBinary();
+
+    try {
+        const mm = require('meta-messenger.js');
+        _Client = mm.Client || mm.default?.Client;
+        if (!_Client) throw new Error('meta-messenger.js: Client class not found in exports');
+        return _Client;
+    } catch (err) {
+        _loadError = new Error(
+            'E2EE requires meta-messenger.js and its native binary.\n' +
+            'Install with: npm install meta-messenger.js\n' +
+            'Error: ' + err.message
+        );
+        throw _loadError;
+    }
+}
 
-    connectE2EE(handle) {
-        return callAsync('MxConnectE2EE', { handle });
-    },
+const EVENT_TYPES = [
+    'message', 'messageEdit', 'messageUnsend', 'reaction',
+    'typing', 'readReceipt', 'e2eeMessage', 'e2eeReaction',
+    'e2eeReceipt', 'e2eeConnected', 'ready', 'reconnected',
+    'disconnected', 'error', 'deviceDataChanged', 'raw',
+];
+
+// Registry: handle (string) -> { client, eventBuffer, resolveWaiter, lastDeviceData }
+const registry = new Map();
+let seq = 1;
+
+function newClient(cfg) {
+    const Client = loadClient();
+    const cookies = cfg.cookies || {};
+
+    const opts = {
+        platform:     cfg.platform || 'facebook',
+        logLevel:     cfg.logLevel || 'warn',
+        enableE2EE:   false,          // we call connectE2EE() explicitly
+        e2eeMemoryOnly: false,        // always persist sessions to disk
+        autoReconnect: cfg.autoReconnect !== false,
+    };
 
-    disconnect(handle) {
-        try { return call('MxDisconnect', { handle }); } catch (_) {}
-    },
+    // Device storage: prefer deviceData (in-memory JSON) > devicePath > default file
+    if (cfg.deviceData) {
+        opts.deviceData = cfg.deviceData;
+    } else {
+        opts.devicePath = cfg.devicePath || '.nkxfca_e2ee_device.json';
+    }
 
-    isConnected(handle) {
-        try { return call('MxIsConnected', { handle }); }
-        catch (_) { return { connected: false, e2eeConnected: false }; }
-    },
+    const client = new Client(cookies, opts);
+    const handle = String(seq++);
+    const entry = { client, eventBuffer: [], resolveWaiter: null, lastDeviceData: null };
+
+    for (const type of EVENT_TYPES) {
+        client.on(type, (data) => {
+            if (type === 'deviceDataChanged' && data?.deviceData) {
+                entry.lastDeviceData = data.deviceData;
+            }
+            entry.eventBuffer.push({ type, data: data ?? null, timestamp: Date.now() });
+            if (entry.resolveWaiter) {
+                const resolve = entry.resolveWaiter;
+                entry.resolveWaiter = null;
+                resolve();
+            }
+        });
+    }
 
-    getDeviceData(handle) {
-        return call('MxGetDeviceData', { handle });
-    },
+    registry.set(handle, entry);
+    return { handle };
+}
 
-    pollEvents(handle, timeoutMs) {
-        return callAsync('MxPollEvents', { handle, timeoutMs: timeoutMs || 5000 });
-    },
+function getEntry(handle) {
+    const entry = registry.get(String(handle));
+    if (!entry) throw new Error(`E2EE bridge: unknown handle "${handle}"`);
+    return entry;
+}
 
-    sendMessage(handle, options) {
-        return callAsync('MxSendMessage', { handle, options });
-    },
+async function connect(handle) {
+    return getEntry(handle).client.connect();
+}
 
-    sendReaction(handle, threadId, messageId, emoji) {
-        return callAsync('MxSendReaction', { handle, threadId, messageId, emoji });
-    },
+/**
+ * Initiate E2EE handshake.  Returns after the background connect is kicked
+ * off — listen for the 'e2eeConnected' event (via pollEvents) to know when
+ * the channel is fully ready.
+ */
+async function connectE2EE(handle) {
+    return getEntry(handle).client.connectE2EE();
+}
 
-    editMessage(handle, messageId, newText) {
-        return callAsync('MxEditMessage', { handle, messageId, newText });
-    },
+function disconnect(handle) {
+    const entry = registry.get(String(handle));
+    if (!entry) return;
+    try { entry.client.disconnect(); } catch (_) {}
+    registry.delete(String(handle));
+}
 
-    unsendMessage(handle, messageId) {
-        return callAsync('MxUnsendMessage', { handle, messageId });
-    },
+function isConnected(handle) {
+    try {
+        const { client } = getEntry(handle);
+        return { connected: !!client.isConnected, e2eeConnected: !!client.isE2EEConnected };
+    } catch (_) {
+        return { connected: false, e2eeConnected: false };
+    }
+}
 
-    sendTyping(handle, threadId, isTyping, isGroup, threadType) {
-        return callAsync('MxSendTyping', { handle, threadId, isTyping, isGroup, threadType });
-    },
+function getDeviceData(handle) {
+    return { deviceData: getEntry(handle).lastDeviceData };
+}
 
-    markRead(handle, threadId, watermarkTs) {
-        return callAsync('MxMarkRead', { handle, threadId, watermarkTs: watermarkTs || 0 });
-    },
+async function pollEvents(handle, timeoutMs = 5000) {
+    const entry = getEntry(handle);
+    if (entry.eventBuffer.length > 0) {
+        return { events: entry.eventBuffer.splice(0) };
+    }
+    await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            entry.resolveWaiter = null;
+            resolve();
+        }, timeoutMs);
+        entry.resolveWaiter = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+    });
+    return { events: entry.eventBuffer.splice(0) };
+}
 
-    sendE2EEMessage(handle, chatJid, text, replyToId, replyToSenderJid) {
-        return callAsync('MxSendE2EEMessage', { handle, chatJid, text, replyToId, replyToSenderJid });
-    },
+function toBuffer(data) {
+    if (Buffer.isBuffer(data)) return data;
+    if (typeof data === 'string') return Buffer.from(data, 'base64');
+    return Buffer.from(data);
+}
 
-    sendE2EEReaction(handle, chatJid, messageId, senderJid, emoji) {
-        return callAsync('MxSendE2EEReaction', { handle, chatJid, messageId, senderJid, emoji });
-    },
+// Convert JID string ("12345@msgr") or plain number/string to BigInt
+function toBigInt(val) {
+    if (typeof val === 'bigint') return val;
+    return BigInt(String(val).split('@')[0]);
+}
 
-    sendE2EETyping(handle, chatJid, isTyping) {
-        return callAsync('MxSendE2EETyping', { handle, chatJid, isTyping: !!isTyping });
-    },
+// ── E2EE operations ────────────────────────────────────────────────────────────
 
-    editE2EEMessage(handle, chatJid, messageId, newText) {
-        return callAsync('MxEditE2EEMessage', { handle, chatJid, messageId, newText });
-    },
+async function sendE2EEMessage(handle, chatJid, text, replyToId, replyToSenderJid) {
+    const opts = replyToId ? { replyToId, replyToSenderJid } : undefined;
+    return getEntry(handle).client.sendE2EEMessage(chatJid, text, opts);
+}
 
-    unsendE2EEMessage(handle, chatJid, messageId) {
-        return callAsync('MxUnsendE2EEMessage', { handle, chatJid, messageId });
-    },
+async function sendE2EEReaction(handle, chatJid, messageId, senderJid, emoji) {
+    return getEntry(handle).client.sendE2EEReaction(chatJid, messageId, senderJid, emoji);
+}
 
-    sendE2EEImage(handle, options) {
-        return callAsync('MxSendE2EEImage', { handle, options });
-    },
+async function sendE2EETyping(handle, chatJid, isTyping) {
+    return getEntry(handle).client.sendE2EETyping(chatJid, isTyping);
+}
 
-    sendE2EEVideo(handle, options) {
-        return callAsync('MxSendE2EEVideo', { handle, options });
-    },
+async function editE2EEMessage(handle, chatJid, messageId, newText) {
+    return getEntry(handle).client.editE2EEMessage(chatJid, messageId, newText);
+}
 
-    sendE2EEAudio(handle, options) {
-        return callAsync('MxSendE2EEAudio', { handle, options });
-    },
+async function unsendE2EEMessage(handle, chatJid, messageId) {
+    return getEntry(handle).client.unsendE2EEMessage(chatJid, messageId);
+}
 
-    sendE2EEDocument(handle, options) {
-        return callAsync('MxSendE2EEDocument', { handle, options });
-    },
+async function sendE2EEImage(handle, options) {
+    const { chatJid, data, mimeType, ...rest } = options;
+    return getEntry(handle).client.sendE2EEImage(chatJid, toBuffer(data), mimeType, rest);
+}
 
-    sendE2EESticker(handle, options) {
-        return callAsync('MxSendE2EESticker', { handle, options });
-    },
+async function sendE2EEVideo(handle, options) {
+    const { chatJid, data, mimeType, ...rest } = options;
+    return getEntry(handle).client.sendE2EEVideo(chatJid, toBuffer(data), mimeType, rest);
+}
 
-    downloadE2EEMedia(handle, options) {
-        return callAsync('MxDownloadE2EEMedia', { handle, options });
-    },
+async function sendE2EEAudio(handle, options) {
+    const { chatJid, data, mimeType, ...rest } = options;
+    return getEntry(handle).client.sendE2EEAudio(chatJid, toBuffer(data), mimeType, rest);
+}
 
-    getCookies(handle) {
-        return call('MxGetCookies', { handle });
-    },
+async function sendE2EEDocument(handle, options) {
+    const { chatJid, data, filename, mimeType, ...rest } = options;
+    return getEntry(handle).client.sendE2EEDocument(chatJid, toBuffer(data), filename, mimeType, rest);
+}
 
-    uploadMedia(handle, options) {
-        return callAsync('MxUploadMedia', { handle, options });
-    },
+async function sendE2EESticker(handle, options) {
+    const { chatJid, data, mimeType, ...rest } = options;
+    return getEntry(handle).client.sendE2EESticker(chatJid, toBuffer(data), mimeType, rest);
+}
 
-    sendImage(handle, options) {
-        return callAsync('MxSendImage', { handle, options });
-    },
+async function downloadE2EEMedia(handle, options) {
+    return getEntry(handle).client.downloadE2EEMedia(options);
+}
 
-    sendVideo(handle, options) {
-        return callAsync('MxSendVideo', { handle, options });
-    },
+// ── Regular (non-E2EE) Messenger methods ──────────────────────────────────────
 
-    sendVoice(handle, options) {
-        return callAsync('MxSendVoice', { handle, options });
-    },
+async function uploadMedia(handle, options) {
+    const { chatJid, data, filename, mimeType, isVoice } = options;
+    return getEntry(handle).client.uploadMedia(
+        toBigInt(chatJid), toBuffer(data), filename || 'file', mimeType || 'application/octet-stream', !!isVoice
+    );
+}
 
-    sendFile(handle, options) {
-        return callAsync('MxSendFile', { handle, options });
-    },
+async function sendImage(handle, options) {
+    const { chatJid, data, filename, caption, replyToId } = options;
+    const opts = {};
+    if (caption) opts.caption = caption;
+    if (replyToId) opts.replyToId = replyToId;
+    return getEntry(handle).client.sendImage(
+        toBigInt(chatJid), toBuffer(data), filename || 'image.jpg', Object.keys(opts).length ? opts : undefined
+    );
+}
 
-    sendSticker(handle, options) {
-        return callAsync('MxSendSticker', { handle, options });
-    },
+async function sendVideo(handle, options) {
+    const { chatJid, data, filename, caption, replyToId } = options;
+    const opts = {};
+    if (caption) opts.caption = caption;
+    if (replyToId) opts.replyToId = replyToId;
+    return getEntry(handle).client.sendVideo(
+        toBigInt(chatJid), toBuffer(data), filename || 'video.mp4', Object.keys(opts).length ? opts : undefined
+    );
+}
 
-    getUserInfo(handle, userId) {
-        return callAsync('MxGetUserInfo', { handle, options: { userId } });
-    },
+async function sendVoice(handle, options) {
+    const { chatJid, data, filename, replyToId } = options;
+    const opts = replyToId ? { replyToId } : undefined;
+    return getEntry(handle).client.sendVoice(
+        toBigInt(chatJid), toBuffer(data), filename || 'audio.ogg', opts
+    );
+}
 
-    createThread(handle, userId) {
-        return callAsync('MxCreateThread', { handle, options: { userId } });
-    },
+async function sendFile(handle, options) {
+    const { chatJid, data, filename, mimeType, caption, replyToId } = options;
+    const opts = {};
+    if (caption) opts.caption = caption;
+    if (replyToId) opts.replyToId = replyToId;
+    return getEntry(handle).client.sendFile(
+        toBigInt(chatJid), toBuffer(data), filename || 'file', mimeType || 'application/octet-stream',
+        Object.keys(opts).length ? opts : undefined
+    );
+}
 
-    searchUsers(handle, query) {
-        return callAsync('MxSearchUsers', { handle, options: { query } });
-    },
+async function sendSticker(handle, options) {
+    const { chatJid, stickerId, replyToId } = options;
+    const opts = replyToId ? { replyToId } : undefined;
+    return getEntry(handle).client.sendSticker(
+        toBigInt(chatJid), toBigInt(stickerId), opts
+    );
+}
 
-    renameThread(handle, threadId, newName) {
-        return callAsync('MxRenameThread', { handle, options: { threadId, newName } });
-    },
+async function getUserInfo(handle, userId) {
+    return getEntry(handle).client.getUserInfo(toBigInt(userId));
+}
 
-    muteThread(handle, threadId, muteSeconds) {
-        return callAsync('MxMuteThread', { handle, options: { threadId, muteSeconds } });
-    },
+async function createThread(handle, userId) {
+    return getEntry(handle).client.createThread(toBigInt(userId));
+}
 
-    deleteThread(handle, threadId) {
-        return callAsync('MxDeleteThread', { handle, options: { threadId } });
-    },
+async function searchUsers(handle, query) {
+    return getEntry(handle).client.searchUsers(query);
+}
 
-    setGroupPhoto(handle, threadId, data, mimeType) {
-        return callAsync('MxSetGroupPhoto', { handle, threadId, data, mimeType });
-    },
+async function markRead(handle, chatJid, watermarkTs) {
+    return getEntry(handle).client.markAsRead(toBigInt(chatJid), watermarkTs);
+}
 
-    registerPushNotifications(handle, options) {
-        return callAsync('MxRegisterPushNotifications', { handle, options });
-    },
+function getCookies(handle) {
+    return { cookies: {} };
+}
 
-    unload() {
-        if (lib) {
-            try { lib.unload(); } catch (_) {}
-            lib = null;
-            fns = null;
-            initialized = false;
-        }
+function unload() {
+    for (const entry of registry.values()) {
+        try { entry.client.disconnect(); } catch (_) {}
     }
+    registry.clear();
+    _Client = null;
+    _loadError = null;
+}
+
+module.exports = {
+    isAvailable() {
+        try { loadClient(); return true; } catch (_) { return false; }
+    },
+    newClient,
+    connect,
+    connectE2EE,
+    disconnect,
+    isConnected,
+    getDeviceData,
+    pollEvents,
+    // E2EE operations
+    sendE2EEMessage,
+    sendE2EEReaction,
+    sendE2EETyping,
+    editE2EEMessage,
+    unsendE2EEMessage,
+    sendE2EEImage,
+    sendE2EEVideo,
+    sendE2EEAudio,
+    sendE2EEDocument,
+    sendE2EESticker,
+    downloadE2EEMedia,
+    // Regular Messenger operations
+    uploadMedia,
+    sendImage,
+    sendVideo,
+    sendVoice,
+    sendFile,
+    sendSticker,
+    getUserInfo,
+    createThread,
+    searchUsers,
+    markRead,
+    getCookies,
+    unload,
 };

package/src/e2ee/index.js

@@ -1,7 +1,6 @@
 "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');
@@ -19,20 +18,10 @@ function extractCookies(jar) {
     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;
-}
-
+/**
+ * Return the bridge handle for this context, creating one on first call.
+ * meta-messenger.js handles device data persistence automatically via devicePath.
+ */
 async function getOrCreateHandle(ctx, options) {
     if (ctx._e2eeBridgeHandle != null) return ctx._e2eeBridgeHandle;
 
@@ -41,7 +30,7 @@ async function getOrCreateHandle(ctx, options) {
 
     const cfg = {
         cookies,
-        platform: detectPlatform(cookies),
+        platform: 'facebook',
         logLevel: 'warn',
         devicePath,
         ...(options || {}),