@lazyneoaz/testfca 1.0.1 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/testfca",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "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",
@@ -84,15 +84,14 @@
     "typescript": "^5.8.3"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "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/build-go.mjs

@@ -17,7 +17,14 @@ function runGo(args) {
     const res = spawnSync(process.env.GO_BIN || "go", args, {
         cwd: bridgeDir,
         stdio: "inherit",
-        env: { ...process.env, CGO_ENABLED: "1" },
+        env: {
+            ...process.env,
+            CGO_ENABLED: "1",
+            // Prevent Go from downloading a newer toolchain when go.mod specifies
+            // a version higher than what is locally installed. The local compiler
+            // should always be used in sandboxed / offline environments.
+            GOTOOLCHAIN: "local",
+        },
     });
     if (res.error) {
         console.error(`[${name}] Failed to spawn Go: ${res.error.message}`);

package/scripts/download-prebuilt.mjs

@@ -9,20 +9,13 @@ import { packageJson as pkg } from "./package.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function defaultRepoSlug() {
-    // Use yumi-team/meta-messenger.js which hosts prebuilt messagix binaries
-    return "yumi-team/meta-messenger.js";
-}
-
-function latestTag() {
-    return "v1.1.3";
-}
-
 function buildBaseURL() {
-    const repo = defaultRepoSlug();
-    const versionTag = latestTag();
-    const baseURL = `https://github.com/${repo}/releases/download/${versionTag}`;
-    return baseURL.replace(/\/$/, "");
+    // yumi-team/meta-messenger.js hosts prebuilt messagix binaries for all
+    // platforms except linux-x64-gnu, which ships directly in this package's
+    // prebuilt/ directory and is therefore never fetched from here.
+    const repo = "yumi-team/meta-messenger.js";
+    const tag  = "v1.1.3";
+    return `https://github.com/${repo}/releases/download/${tag}`;
 }
 
 function httpGet(url, redirectCount = 0) {

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/scripts/postinstall.mjs

@@ -1,6 +1,5 @@
-import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { copyFile, mkdir, rm } from "node:fs/promises";
+import { copyFile, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -49,13 +48,8 @@ async function run() {
     console.log(`[${pkg.name}] Checking local prebuilt at: ${prebuilt}`);
     if (await copyIfExists(prebuilt, buildOut)) {
         console.log(`[${pkg.name}] Using local prebuilt for ${triplet}`);
-        if (process.env.MESSAGIX_KEEP_PREBUILT !== "true") {
-            try {
-                await rm(prebuiltDir, { recursive: true, force: true });
-            } catch {
-                //
-            }
-        }
+        // Keep the prebuilt copy so reinstalls (e.g. npm rebuild, CI caches) don't
+        // lose the patched binary and fall back to downloading an unpatched one.
         console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
         return;
     }
@@ -77,32 +71,20 @@ async function run() {
         );
     }
 
-    // 3) No prebuilt available. Try local build if allowed
-    if (process.env.MESSAGIX_BUILD_FROM_SOURCE === "true") {
-        console.log(`[${pkg.name}] No prebuilt found. Attempting local build...`);
-        try {
-            const res = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build:go"], {
-                cwd: join(__dirname, ".."),
-                stdio: "inherit",
-                env: process.env,
-            });
-            if (res.status === 0 && existsSync(buildOut)) {
-                console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
-                return;
-            }
-            console.warn(`[${pkg.name}] Local build did not produce the native library.`);
-        } catch (err) {
-            console.warn(`[${pkg.name}] Local build failed:`, err?.message || String(err));
-        }
-    }
-
-    console.warn(`[${pkg.name}] No prebuilt found (local/remote) and no local build completed.`);
-    console.warn(`[${pkg.name}] Expected triplet: ${triplet}, file: messagix-${triplet}.${ext}`);
-    console.warn(
-        `[${pkg.name}] You can:\n` +
-            "  - set MESSAGIX_BUILD_FROM_SOURCE=true and re-run install\n" +
-            "  - or build manually with: npm run build:go",
-    );
+    console.warn(`[${pkg.name}] ──────────────────────────────────────────────────────────`);
+    console.warn(`[${pkg.name}] No prebuilt E2EE bridge found for your platform.`);
+    console.warn(`[${pkg.name}] Platform detected: ${triplet}`);
+    console.warn(`[${pkg.name}]`);
+    console.warn(`[${pkg.name}] Supported out-of-the-box:`);
+    console.warn(`[${pkg.name}]   linux-x64-gnu  (ships inside the npm package)`);
+    console.warn(`[${pkg.name}]   linux-x64-musl / darwin-x64 / darwin-arm64 / win32-x64`);
+    console.warn(`[${pkg.name}]   (downloaded automatically from yumi-team/meta-messenger.js)`);
+    console.warn(`[${pkg.name}]`);
+    console.warn(`[${pkg.name}] If the download failed, check your internet connection and retry:`);
+    console.warn(`[${pkg.name}]   npm install`);
+    console.warn(`[${pkg.name}]`);
+    console.warn(`[${pkg.name}] Non-E2EE features (sendMessage, listen, etc.) work without the bridge.`);
+    console.warn(`[${pkg.name}] ──────────────────────────────────────────────────────────`);
 }
 
 run()

package/src/e2ee/bridge.js

@@ -1,275 +1,330 @@
 "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.`
+/**
+ * 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).
+ *
+ * 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
+ */
+
+let _Client = null;
+let _loadError = null;
+
+function loadClient() {
+    if (_Client) return _Client;
+    if (_loadError) throw _loadError;
+    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;
     }
-    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);
-}
+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,
+    };
 
-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;
-}
+    // 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';
+    }
 
-function callAsync(fn, payload) {
-    return new Promise((resolve, reject) => {
-        setImmediate(() => {
-            try { resolve(call(fn, payload)); }
-            catch (err) { reject(err); }
+    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();
+            }
         });
-    });
-}
-
-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 });
-    },
+    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 || {}),

package/src/utils/axios.js

@@ -8,6 +8,7 @@ const FormData = require("form-data");
 const { getHeaders } = require("./headers");
 const { getType } = require("./constants");
 const { globalRateLimiter } = require("./rateLimiter");
+const { globalAntiSuspension } = require("./antiSuspension");
 
 const jar = new CookieJar();
 const client = wrapper(axios.create({ jar }));
@@ -112,6 +113,8 @@ async function inspectResponseForSessionIssues(adapted, ctx) {
         typeof body === 'object' && body !== null && body.error === 1357001;
 
     if (isLoginBlocked) {
+        // Trip the circuit breaker to stop retries while the account is flagged.
+        globalAntiSuspension.tripCircuitBreaker('login_blocked (1357001)', 45 * 60 * 1000);
         const err = new Error('Facebook blocked the login.');
         err.error = 'login_blocked';
         err.res = body;

package/src/utils/clients.js

@@ -2,6 +2,7 @@
 
 const { makeParsable, log, warn } = require("./constants");
 const { globalRateLimiter, configureRateLimiter } = require("./rateLimiter");
+const { globalAntiSuspension } = require("./antiSuspension");
 
 /**
  * Formats a cookie array into a string for use in a cookie jar.
@@ -151,10 +152,17 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       err.errorType = res.error === 1357004 ? "CHECKPOINT" : res.error === 1357031 ? "LOCKED" : "BLOCKED";
       err.requiresReLogin = res.error === 1357004 || res.error === 1357031;
       warn("Account Status", `${ACCOUNT_ERROR_CODES[res.error]} (Code: ${res.error})`);
+      // Trip the anti-suspension circuit breaker immediately for blocking errors.
+      // This prevents the bot from hammering Facebook while the account is flagged.
+      if (res.error === 1357001 || res.error === 1357033 || res.error === 2056003) {
+        const cooldownMs = res.error === 1357001 ? 45 * 60 * 1000 : 20 * 60 * 1000;
+        globalAntiSuspension.tripCircuitBreaker(ACCOUNT_ERROR_CODES[res.error], cooldownMs);
+      }
       throw err;
     }
 
     if (res.error === 1357001 || (res.errorSummary && res.errorSummary.includes("blocked"))) {
+      globalAntiSuspension.tripCircuitBreaker("Facebook blocked the login (errorSummary)", 45 * 60 * 1000);
       const err = new Error("Facebook blocked the login");
       err.error = "Not logged in.";
       err.errorType = "BLOCKED";

package/src/utils/formatters.js

@@ -1196,6 +1196,13 @@ function formatID(id) {
                                                 err.error = "Not logged in.";
                                                 err.requiresReLogin = true;
                                                 err.loginBlocked = res.error === 1357004;
+                                                // Trip circuit breaker on blocking/locking to stop retries.
+                                                if (res.error === 1357001) {
+                                                    try {
+                                                        const { globalAntiSuspension } = require('./antiSuspension');
+                                                        globalAntiSuspension.tripCircuitBreaker('login_blocked (1357001 via formatters)', 45 * 60 * 1000);
+                                                    } catch (_) {}
+                                                }
                                                 throw err;
                                             }