@lazyneoaz/testfca 1.0.0 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/testfca",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "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",
@@ -84,7 +84,7 @@
     "typescript": "^5.8.3"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=20.18.1"
   },
   "scripts": {
     "prepack": "echo 'Preparing package for npm...'",

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,24 +9,13 @@ import { packageJson as pkg } from "./package.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-function defaultRepoSlug() {
-    const repo = pkg.repository;
-    if (typeof repo === "string") {
-        const m = repo.match(/github:(.+)/i);
-        if (m) return m[1];
-        if (/^[\w-]+\/[\w.-]+$/.test(repo)) return repo;
-    } else if (repo && typeof repo === "object" && repo.url) {
-        const m = repo.url.match(/github\.com[:/]+([^#]+?)(?:\.git)?$/i);
-        if (m) return m[1];
-    }
-    return "NeoKEX/nkxfca";
-}
-
 function buildBaseURL() {
-    const repo = defaultRepoSlug();
-    const versionTag = `v${pkg.version}`;
-    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.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/apis/getThreadInfo.js

@@ -40,6 +40,65 @@ function formatEventReminders(reminder) {
  * @returns {Object | null} A formatted thread object or null if data is invalid.
  * @throws {Error} If Facebook returns a GraphQL error
  */
+/**
+ * Returns a minimal synthetic thread-info object for E2EE DM threads that
+ * GraphQL does not expose. Goat Bot needs certain fields to avoid crashing.
+ */
+function buildE2EEThreadInfo(threadID, botUserID) {
+  const tid = String(threadID);
+  const participants = [tid];
+  if (botUserID && String(botUserID) !== tid) participants.push(String(botUserID));
+  return {
+    threadID: tid,
+    threadName: "",
+    name: "",
+    participantIDs: participants,
+    userInfo: participants.map(id => ({
+      id, name: "", firstName: "", vanity: "", url: "",
+      thumbSrc: "", profileUrl: "", gender: 0,
+      type: "User", isFriend: false, isBirthday: false,
+    })),
+    unreadCount: 0,
+    messageCount: 0,
+    timestamp: String(Date.now()),
+    serverTimestamp: String(Date.now()),
+    muteUntil: null,
+    isGroup: false,
+    threadType: 1,
+    isSubscribed: true,
+    isArchived: false,
+    folder: "INBOX",
+    cannotReplyReason: null,
+    canReply: true,
+    eventReminders: null,
+    emoji: null,
+    color: null,
+    threadTheme: null,
+    nicknames: {},
+    adminIDs: [],
+    approvalMode: false,
+    approvalQueue: [],
+    reactionsMuteMode: "reactions_not_muted",
+    mentionsMuteMode: "mentions_not_muted",
+    isPinProtected: false,
+    relatedPageThread: null,
+    snippet: null,
+    snippetSender: null,
+    snippetAttachments: [],
+    imageSrc: null,
+    isCanonicalUser: true,
+    isCanonical: true,
+    recipientsLoadable: true,
+    hasEmailParticipant: false,
+    readOnly: false,
+    lastMessageTimestamp: null,
+    lastMessageType: "message",
+    lastReadTimestamp: null,
+    inviteLink: { enable: false, link: null },
+    _isE2EESynthetic: true,
+  };
+}
+
 function formatThreadGraphQLResponse(data) {
   // Check for GraphQL errors and throw with details instead of silently returning null
   if (data.errors) {
@@ -52,14 +111,15 @@ function formatThreadGraphQLResponse(data) {
     utils.error("formatThreadGraphQLResponse", error);
     throw error;
   }
-  
+
   const messageThread = data.message_thread;
   if (!messageThread) {
+    // E2EE DM threads are not exposed via GraphQL — signal the caller to use synthetic fallback
     const error = new Error("No message_thread in GraphQL response - thread may not exist or access may be restricted");
     Object.assign(error, {
-      details: "The GraphQL query returned successfully but contained no message_thread data"
+      details: "The GraphQL query returned successfully but contained no message_thread data",
+      isE2EEThread: true,
     });
-    utils.error("formatThreadGraphQLResponse", error);
     throw error;
   }
 
@@ -185,7 +245,7 @@ module.exports = function (defaultFuncs, api, ctx) {
     if (!ctx.validator.validateIDArray(threadIDs, ctx.validator.isValidThreadID)) {
       throw new Error("Invalid thread ID(s)");
     }
-    
+
     let form = {};
     threadIDs.forEach((t, i) => {
       form["o" + i] = {
@@ -217,7 +277,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         const threadInfos = {};
         for (let i = resData.length - 2; i >= 0; i--) {
             const res = resData[i];
-            
+
             // Check for error_results and throw instead of silently continuing
             if (res.error_results) {
                 const error = new Error(`Facebook returned error_results for thread query: ${res.error_results} errors`);
@@ -228,10 +288,10 @@ module.exports = function (defaultFuncs, api, ctx) {
                 utils.error("getThreadInfo", error);
                 throw error;
             }
-            
+
             const oKey = Object.keys(res)[0];
             const responseData = res[oKey];
-            
+
             // Check for errors in the response object
             if (responseData.errors || responseData.error_results) {
                 const details = responseData.errors 
@@ -246,10 +306,22 @@ module.exports = function (defaultFuncs, api, ctx) {
                 utils.error("getThreadInfo", error);
                 throw error;
             }
-            
-            const threadInfo = formatThreadGraphQLResponse(responseData.data);
+
+            let threadInfo;
+            try {
+                threadInfo = formatThreadGraphQLResponse(responseData.data);
+            } catch (fmtErr) {
+                if (fmtErr.isE2EEThread) {
+                    // E2EE DM thread — GraphQL has no data for it, use synthetic fallback
+                    const tid = threadIDs[threadIDs.length - 1 - i] || threadIDs[0];
+                    utils.log("getThreadInfo", "E2EE DM thread " + tid + " not in GraphQL, using synthetic fallback.");
+                    threadInfo = buildE2EEThreadInfo(tid, ctx.userID);
+                } else {
+                    throw fmtErr;
+                }
+            }
             if (threadInfo) {
-                threadInfos[threadInfo.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
+                threadInfos[threadInfo.threadID || threadIDs[threadIDs.length - 1 - i]] = threadInfo;
             }
         }
 

package/src/apis/listenMqtt.js

@@ -49,7 +49,7 @@ function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000) {
             } catch (error) {
                 lastError = error;
                 if (i === maxRetries - 1) throw lastError;
-                
+
                 const delay = Math.min(baseDelay * Math.pow(2, i) + Math.random() * 500, 10000);
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
@@ -206,16 +206,16 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
 
     if (ctx.globalOptions.proxy) options.wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
     ctx._mqttLastConnectAttemptAt = Date.now();
-    
+
     // Create WebSocket stream - using exact fca-unofficial implementation
     let mqttClient;
-    
+
     try {
         const mqtt = require('mqtt');
         const WebSocket = require('ws');
         const { PassThrough, Writable } = require('stream');
         const Duplexify = require('duplexify');
-        
+
         // Exact buildProxy from fca-unofficial
         function buildProxy() {
             let target = null;
@@ -268,7 +268,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
             };
             return Proxy;
         }
-        
+
         // Exact buildStream from fca-unofficial
         function buildStream(opts, ws, Proxy) {
             const readable = new PassThrough();
@@ -280,18 +280,18 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
             let attached = false;
             let style = "prop";
             let closed = false;
-            
+
             const toBuffer = d => {
                 if (Buffer.isBuffer(d)) return d;
                 if (d instanceof ArrayBuffer) return Buffer.from(d);
                 if (ArrayBuffer.isView(d)) return Buffer.from(d.buffer, d.byteOffset, d.byteLength);
                 return Buffer.from(String(d));
             };
-            
+
             const swapToNoopWritable = () => {
                 try { Stream.setWritable(NoopWritable); } catch { }
             };
-            
+
             const onOpen = () => {
                 if (closed) return;
                 Proxy.setTarget(ws);
@@ -316,16 +316,16 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     }
                 }, 10000);
             };
-            
+
             const onMessage = data => {
                 lastActivity = Date.now();
                 readable.write(toBuffer(style === "dom" && data && data.data !== undefined ? data.data : data));
             };
-            
+
             const onPong = () => {
                 lastActivity = Date.now();
             };
-            
+
             const cleanup = () => {
                 if (closed) return;
                 closed = true;
@@ -346,18 +346,18 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                 }
                 readable.end();
             };
-            
+
             const onError = err => {
                 cleanup();
                 Stream.destroy(err);
             };
-            
+
             const onClose = () => {
                 cleanup();
                 Stream.end();
                 if (!Stream.destroyed) Stream.destroy();
             };
-            
+
             const attach = w => {
                 if (attached || !w) return;
                 attached = true;
@@ -382,7 +382,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     w.onclose = onClose;
                 }
             };
-            
+
             const detach = w => {
                 if (!attached || !w) return;
                 attached = false;
@@ -404,24 +404,24 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     w.onclose = null;
                 }
             };
-            
+
             attach(ws);
             if (ws && ws.readyState === 1) onOpen();
-            
+
             Stream.on("prefinish", swapToNoopWritable);
             Stream.on("finish", cleanup);
             Stream.on("close", cleanup);
             Proxy.on("close", swapToNoopWritable);
-            
+
             return Stream;
         }
-        
+
         // Create MQTT client exactly like fca-unofficial
         mqttClient = new mqtt.Client(
             () => buildStream(options, new WebSocket(host, options.wsOptions), buildProxy()),
             options
         );
-        
+
         mqttClient.publishSync = mqttClient.publish.bind(mqttClient);
         mqttClient.publish = (topic, message, opts = {}, callback = () => {}) => new Promise((resolve, reject) => {
             mqttClient.publishSync(topic, message, opts, (err, data) => {
@@ -543,10 +543,188 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
             queue.sync_token = ctx.syncToken; 
         }
         mqttClient.publish(topic, JSON.stringify(queue), { qos: 1, retain: false });
+
+        // Also subscribe to E2EE DM sync group (sync_group 2) for direct messages
+        const e2eeQueue = {
+            sync_api_version: 11,
+            max_deltas_able_to_process: 200,
+            delta_batch_size: 200,
+            encoding: "JSON",
+            entity_fbid: ctx.userID,
+            initial_titan_sequence_id: ctx.lastSeqId,
+            device_params: null,
+            sync_group: 2
+        };
+        const e2eeTopic = ctx.e2eeSyncToken ? "/messenger_sync_get_diffs" : "/messenger_sync_create_queue";
+        if (ctx.e2eeSyncToken) {
+            e2eeQueue.last_seq_id = ctx.lastSeqId;
+            e2eeQueue.sync_token = ctx.e2eeSyncToken;
+        }
+        mqttClient.publish(e2eeTopic, JSON.stringify(e2eeQueue), { qos: 1, retain: false });
+
         mqttClient.publish("/foreground_state", JSON.stringify({ foreground: chatOn }), { qos: 1 });
         mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
-        
-        utils.log("MQTT", "Queue setup messages sent");
+
+        utils.log("MQTT", "Queue setup messages sent (sync_group 1 + 2)");
+
+        // E2EE bridge polling loop — receives incoming DMs via messagix.so
+        if (api.e2ee && api.e2ee.isAvailable() && !ctx._e2eePollingActive) {
+            ctx._e2eePollingActive = true;
+            (async function bridgePollLoop() {
+                try {
+                    const status = api.e2ee.isConnected();
+                    if (!status.connected) {
+                        utils.log("E2EE", "Connecting bridge for DM receive...");
+                        await api.e2ee.connect();
+                        utils.log("E2EE", "Bridge transport connected.");
+                    }
+                    if (!api.e2ee.isConnected().e2eeConnected) {
+                        utils.log("E2EE", "Registering E2EE device keys...");
+                        await api.e2ee.connectE2EE();
+                        utils.log("E2EE", "E2EE ready. Starting DM poll loop.");
+                    } else {
+                        utils.log("E2EE", "Bridge already E2EE-ready. Starting DM poll loop.");
+                    }
+                } catch (bridgeErr) {
+                    utils.warn("E2EE", "Bridge connect failed (DMs via MQTT only):", bridgeErr && bridgeErr.message ? bridgeErr.message : bridgeErr);
+                    ctx._e2eePollingActive = false;
+                    return;
+                }
+                while (ctx._e2eePollingActive) {
+                    try {
+                        // Yield to event loop before blocking poll (same pattern as yumi-team)
+                        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);
+                        if (!ctx._e2eePollingActive) break;
+
+                        // No event / empty result
+                        if (!ev) continue;
+
+                        const evType = (ev.type || '').toLowerCase();
+
+                        // ── timeout: no event arrived during the poll window ──
+                        if (evType === 'timeout') continue;
+
+                        // ── closed: Go bridge shut down ──
+                        if (evType === 'closed') {
+                            utils.warn("E2EE", "Bridge closed. Stopping DM poll loop.");
+                            ctx._e2eePollingActive = false;
+                            break;
+                        }
+
+                        // ── 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;
+                        }
+
+                        // ── E2EE connection confirmed by the bridge ──
+                        if (evType === 'e2eeconnected') {
+                            utils.log("E2EE", "E2EE fully connected (bridge event).");
+                            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));
+                                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;
+                        }
+
+                        // ── 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;
+                        }
+
+                        // ready / reconnected / disconnected / deviceDataChanged / raw → ignore silently
+
+                    } catch (pollErr) {
+                        if (!ctx._e2eePollingActive) break;
+                        utils.warn("E2EE", "pollEvents error:", pollErr && pollErr.message ? pollErr.message : pollErr);
+                        await new Promise(r => setTimeout(r, 3000));
+                    }
+                }
+                utils.log("E2EE", "Poll loop stopped.");
+            })();
+        }
 
         // Disable T_MS timeout to prevent connection cycling
         if (ctx._tmsTimeout) {
@@ -564,7 +742,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
             }
             delete ctx.tmsWait;
         };
-        
+
         // Immediately mark as ready since we're connected
         if (ctx.tmsWait && typeof ctx.tmsWait === "function") ctx.tmsWait();
     }));
@@ -592,7 +770,11 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
 
                 if (jsonMessage.firstDeltaSeqId && jsonMessage.syncToken) {
                     ctx.lastSeqId = jsonMessage.firstDeltaSeqId;
-                    ctx.syncToken = jsonMessage.syncToken;
+                    if (!ctx.syncToken) {
+                        ctx.syncToken = jsonMessage.syncToken;
+                    } else if (!ctx.e2eeSyncToken && jsonMessage.syncToken !== ctx.syncToken) {
+                        ctx.e2eeSyncToken = jsonMessage.syncToken;
+                    }
                 }
                 if (jsonMessage.lastIssuedSeqId) {
                     ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
@@ -600,8 +782,11 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
 
                 if (jsonMessage.deltas) {
                     for (const delta of jsonMessage.deltas) {
+                        utils.log("MQTT_DELTA", "class=" + (delta.class || "none") + " threadFbId=" + (delta.messageMetadata?.threadKey?.threadFbId || "null") + " otherUserFbId=" + (delta.messageMetadata?.threadKey?.otherUserFbId || "null") + " body=" + (delta.body !== undefined ? JSON.stringify(String(delta.body).slice(0,40)) : "undefined"));
                         parseDelta(defaultFuncs, api, ctx, globalCallback, { delta });
                     }
+                } else if (jsonMessage.firstDeltaSeqId) {
+                    utils.log("MQTT_DELTA", "Queue ACK: syncToken=" + (jsonMessage.syncToken ? jsonMessage.syncToken.slice(0,20) + "..." : "none") + " firstDeltaSeqId=" + jsonMessage.firstDeltaSeqId);
                 }
             } else if (topic === "/thread_typing" || topic === "/orca_typing_notifications") {
                 const typ = {
@@ -657,7 +842,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                 ctx._mqttQuickCloseCount = 0;
                 if (!ctx._mqttReauthing && globalAutoReLoginManager && globalAutoReLoginManager.isEnabled && globalAutoReLoginManager.isEnabled()) {
                     ctx._mqttReauthing = true;
-                    
+
                     // Try to refresh tokens first before full re-login
                     try {
                         if (api && api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
@@ -674,7 +859,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     } catch (refreshErr) {
                         utils.warn("MQTT", "Token refresh failed, proceeding with full re-login:", refreshErr.message);
                     }
-                    
+
                     globalAutoReLoginManager.handleSessionExpiry(api, 'https://www.facebook.com', "MQTT quick close loop")
                         .then((ok) => {
                             ctx._mqttReauthing = false;
@@ -738,7 +923,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
         ctx._mqttConnected = false;
         if (!ctx._ending && !ctx._cycling && ctx.globalOptions.autoReconnect) {
             try { mqttClient.end(true); } catch (_) { }
-            
+
             // Try token refresh before reconnecting
             try {
                 if (api && api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
@@ -746,7 +931,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     await api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, 'https://www.facebook.com');
                 }
             } catch (_) { /* Ignore refresh errors, will proceed with normal reconnect */ }
-            
+
             // Schedule a reconnect — without this the bot silently stays offline.
             const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
             ctx._reconnectAttempts = (ctx._reconnectAttempts || 0) + 1;
@@ -799,10 +984,10 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
         if (isPermanentFailure) {
             ctx._permanentFailure = true;
         }
-        
+
         const msg = detail || reason;
         utils.error("AUTH", `Authentication error -> ${reason}: ${msg}`);
-        
+
         if (typeof globalCallback === "function") {
             globalCallback({
                 type: "account_inactive",
@@ -860,7 +1045,7 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
         function postSafe(...args) {
             const lastArg = args[args.length - 1];
             const hasCallback = typeof lastArg === 'function';
-            
+
             if (hasCallback) {
                 const originalCallback = args[args.length - 1];
                 args[args.length - 1] = function(err, ...cbArgs) {
@@ -958,19 +1143,19 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             utils.log("MQTT", "Getting sequence ID...");
             ctx.t_mqttCalled = false;
             const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-            
+
             if (utils.getType(resData) !== "Array") {
                 throw { error: "Not logged in" };
             }
             if (!Array.isArray(resData) || !resData.length) {
                 throw { error: "getSeqID: empty response" };
             }
-            
+
             const lastRes = resData[resData.length - 1];
             if (lastRes && lastRes.successful_results === 0) {
                 throw { error: "getSeqID: no successful results" };
             }
-            
+
             const syncSeqId = resData[0] && resData[0].o0 && resData[0].o0.data && resData[0].o0.data.viewer && resData[0].o0.data.viewer.message_threads && resData[0].o0.data.viewer.message_threads.sync_sequence_id;
             if (syncSeqId) {
                 ctx.lastSeqId = syncSeqId;
@@ -983,13 +1168,13 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
         } catch (err) {
             const detail = (err && err.detail && err.detail.message) ? ` | detail=${err.detail.message}` : "";
             const msg = ((err && err.error) || (err && err.message) || String(err || "")) + detail;
-            
+
             if (/blocked the login|checkpoint|security check|authentication.*fail|auth.*fail|login.*block|account.*lock|verification.*requir|banned|disabled/i.test(msg)) {
                 utils.error("MQTT", "Auth error in getSeqID: Session/Login blocked (permanent)");
                 ctx._seqIdFailCount = 0;
                 return emitAuthError("login_blocked", msg);
             }
-            
+
             throw err; // Re-throw for retry mechanism
         }
     }, 3, 1500);
@@ -1063,10 +1248,12 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             ctx.mqttClient = undefined;
             ctx.lastSeqId = null;
             ctx.syncToken = undefined;
+            ctx.e2eeSyncToken = undefined;
             ctx.t_mqttCalled = false;
             ctx._ending = false;
             ctx._mqttConnected = false;
             ctx._seqIdFailCount = 0;
+            ctx._e2eePollingActive = false;
             next && next();
         };
         try {
@@ -1104,6 +1291,8 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
                 utils.log("MQTT", "Stop requested");
                 globalCallback = identity;
                 ctx._listeningActive = false;
+                ctx._e2eePollingActive = false;
+                try { if (api.e2ee && ctx._e2eeBridgeHandle != null) api.e2ee.disconnect(); } catch (_) {}
 
                 if (ctx._autoCycleTimer) {
                     clearInterval(ctx._autoCycleTimer);

package/src/apis/sendMessage.js

@@ -318,19 +318,80 @@ module.exports = (defaultFuncs, api, ctx) => {
         } catch (_) {}
       }
 
+      // Helper: auto-connect E2EE bridge if available but not yet connected
+      async function ensureBridgeConnected() {
+        if (!api.e2ee || !api.e2ee.isAvailable()) return false;
+        try {
+          const status = api.e2ee.isConnected();
+          if (status.e2eeConnected) return true;
+          if (!status.connected) await api.e2ee.connect();
+          if (!api.e2ee.isConnected().e2eeConnected) await api.e2ee.connectE2EE();
+          return !!api.e2ee.isConnected().e2eeConnected;
+        } catch (err) {
+          utils.warn("sendMessage", "E2EE bridge connect failed:", err && err.message ? err.message : err);
+          return false;
+        }
+      }
+
       try {
-        const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
-        callback(null, result);
-      } catch (primaryErr) {
-        if (api.sendMessageMqtt) {
+        if (isSingleUser) {
+          // E2EE DMs: bridge → MQTT → HTTP
+          const msgBody = typeof msg === 'string' ? msg : (msg.body || '');
+          const hasAttachment = msg && typeof msg === 'object' && (msg.attachment || msg.sticker || msg.url);
+          const chatJid = String(threadID) + '@msgr';
+
+          // 1. Bridge path (text messages only; attachments handled by later paths)
+          if (!hasAttachment && msgBody) {
+            const bridgeReady = await ensureBridgeConnected();
+            if (bridgeReady) {
+              try {
+                const bridgeResult = await api.e2ee.sendE2EEMessage(chatJid, msgBody, replyToMessage || undefined, undefined);
+                utils.log("sendMessage", "DM sent via E2EE bridge to " + chatJid);
+                return callback(null, bridgeResult || { messageID: null, threadID: String(threadID) });
+              } catch (bridgeErr) {
+                utils.warn("sendMessage", "Bridge E2EE send failed for " + chatJid + ", trying MQTT:", bridgeErr && bridgeErr.message ? bridgeErr.message : bridgeErr);
+              }
+            }
+          }
+
+          // 2. MQTT path
+          if (api.sendMessageMqtt) {
+            try {
+              const mqttRes = await api.sendMessageMqtt(msg, threadID, replyToMessage);
+              utils.log("sendMessage", "DM sent via MQTT to thread " + threadID);
+              return callback(null, mqttRes);
+            } catch (mqttErr) {
+              utils.warn("sendMessage", "MQTT send failed for DM " + threadID + ", falling back to HTTP:", mqttErr && mqttErr.message ? mqttErr.message : mqttErr);
+            }
+          }
+
+          // 3. HTTP fallback
           try {
-            const mqttRes = await api.sendMessageMqtt(msg, threadID, replyToMessage);
-            callback(null, mqttRes);
-          } catch (fallbackErr) {
-            callback(primaryErr);
+            const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
+            callback(null, result);
+          } catch (httpErr) {
+            utils.error("sendMessage", "All send paths failed for DM " + threadID, httpErr);
+            callback(httpErr);
           }
         } else {
-          callback(primaryErr);
+          // Groups: HTTP first, MQTT fallback
+          try {
+            const result = await sendContent(form, threadID, isSingleUser, messageAndOTID);
+            callback(null, result);
+          } catch (primaryErr) {
+            utils.warn("sendMessage", "HTTP send failed for group " + threadID + ", trying MQTT:", primaryErr && primaryErr.message ? primaryErr.message : primaryErr);
+            if (api.sendMessageMqtt) {
+              try {
+                const mqttRes = await api.sendMessageMqtt(msg, threadID, replyToMessage);
+                callback(null, mqttRes);
+              } catch (fallbackErr) {
+                utils.error("sendMessage", "Both HTTP and MQTT failed for group " + threadID, fallbackErr);
+                callback(primaryErr);
+              }
+            } else {
+              callback(primaryErr);
+            }
+          }
         }
       } finally {
         if (typingTimeout) clearTimeout(typingTimeout);

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;
                                             }