@lazyneoaz/nkxchat 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/nkxchat",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "commonjs",
   "types": "src/types/index.d.ts",
   "description": "Advanced Facebook Chat API client for building Messenger bots — real-time messaging, thread management, MQTT, and session stability.",

package/src/apis/listenMqtt.js

@@ -3,6 +3,7 @@ const utils = require('../utils');
 const mqtt = require('mqtt');
 const WebSocket = require('ws');
 const duplexify = require('duplexify');
+const { PassThrough, Writable } = require('stream');
 const HttpsProxyAgent = require('https-proxy-agent');
 const EventEmitter = require('events');
 const { parseDelta } = require('./mqttDeltaValue');
@@ -188,21 +189,91 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
         const wsOpts = {
             headers: options.wsOptions.headers,
             origin: options.wsOptions.origin,
-            perMessageDeflate: false,
         };
         if (options.wsOptions.agent) wsOpts.agent = options.wsOptions.agent;
+
         const ws = new WebSocket(host, wsOpts);
-        const d = duplexify();
-        ws.once('open', () => {
-            const s = WebSocket.createWebSocketStream(ws, { objectMode: false });
-            d.setReadable(s);
-            d.setWritable(s);
+
+        // Custom writable — sends chunks directly through the WebSocket socket.send()
+        // rather than using createWebSocketStream, which avoids perMessageDeflate
+        // negotiation conflicts and stream buffering edge cases.
+        let wsTarget = null;
+        let proxyEnded = false;
+        const proxy = new Writable({
+            autoDestroy: true,
+            write(chunk, _enc, cb) {
+                if (proxyEnded || this.destroyed) return cb();
+                const sock = wsTarget;
+                if (sock && sock.readyState === WebSocket.OPEN) {
+                    try { sock.send(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), cb); }
+                    catch (e) { cb(e); }
+                } else { cb(); }
+            },
+            final(cb) {
+                proxyEnded = true;
+                const sock = wsTarget;
+                wsTarget = null;
+                if (sock && (sock.readyState === WebSocket.CONNECTING || sock.readyState === WebSocket.OPEN)) {
+                    try { sock.terminate ? sock.terminate() : sock.close(); } catch (_) {}
+                }
+                cb();
+            }
         });
-        ws.on('error', (err) => d.destroy(err));
+
+        const readable = new PassThrough();
+        const stream = new duplexify(undefined, undefined, { end: false, autoDestroy: true });
+
+        const toBuffer = (data) => {
+            if (Buffer.isBuffer(data)) return data;
+            if (data instanceof ArrayBuffer) return Buffer.from(data);
+            if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+            return Buffer.from(String(data));
+        };
+
+        let closed = false;
+        const cleanup = () => {
+            if (closed) return;
+            closed = true;
+            proxyEnded = true;
+            wsTarget = null;
+            try { ws.removeAllListeners(); } catch (_) {}
+            try { if (ws.readyState === WebSocket.OPEN) ws.terminate ? ws.terminate() : ws.close(); } catch (_) {}
+            readable.end();
+        };
+
+        ws.on('open', () => {
+            if (closed) return;
+            wsTarget = ws;
+            stream.setWritable(proxy);
+            stream.setReadable(readable);
+            stream.emit('connect');
+        });
+
+        ws.on('message', (data) => {
+            if (closed) return;
+            readable.write(toBuffer(data));
+        });
+
+        ws.on('error', (err) => {
+            cleanup();
+            stream.destroy(err instanceof Error ? err : new Error(String(err)));
+        });
+
+        ws.on('close', () => {
+            cleanup();
+            stream.end();
+            if (!stream.destroyed) stream.destroy();
+        });
+
         ws.on('unexpected-response', (_req, res) => {
-            d.destroy(new Error(`WebSocket unexpected response: ${res.statusCode}`));
+            cleanup();
+            stream.destroy(new Error(`WebSocket unexpected response: ${res.statusCode}`));
         });
-        return d;
+
+        stream.on('finish', cleanup);
+        stream.on('close', cleanup);
+
+        return stream;
     }
 
     const mqttClient = new mqtt.Client(buildMqttStream, options);

package/src/utils/autoReLogin.js

@@ -102,6 +102,8 @@ class AutoReLoginManager {
             const setOptionsModel = require('../engine/models/setOptions');
             const buildAPIModel = require('../engine/models/buildAPI');
 
+            const fbLinkFunc = typeof fbLink === 'function' ? fbLink : () => fbLink;
+
             await new Promise((resolve, reject) => {
                 loginHelperModel(
                     this.credentials,
@@ -126,7 +128,7 @@ class AutoReLoginManager {
                     setOptionsModel,
                     buildAPIModel,
                     api,
-                    fbLink,
+                    fbLinkFunc,
                     ERROR_RETRIEVING
                 );
             });

package/src/utils/constants.js

@@ -194,7 +194,7 @@ function getFrom(str, startToken, endToken) {
 }
 
 function makeParsable(html) {
-  const withoutForLoop = html.replace(/for\s*\(\s*;\s*;\s*\)\s*/, "");
+  const withoutForLoop = html.replace(/^\s*for\s*\(;;\);\s*/i, "");
   const maybeMultipleObjects = withoutForLoop.split(/\}\r\n *\{/);
   if (maybeMultipleObjects.length === 1) return maybeMultipleObjects;