@lazyneoaz/nkxchat 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/nkxchat",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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/apis/sendEffect.js

@@ -40,131 +40,6 @@ function resolveEffect(name) {
   return EFFECTS[key] ? EFFECTS[key].tag : name.toUpperCase();
 }
 
-function buildForm(effectTag, msgObj, threadID, ctx) {
-  const messageAndOTID = utils.generateOfflineThreadingID();
-  const timestamp = Date.now();
-  const messagingTag = 'fb.messaging.effects.' + effectTag;
-  const body = typeof msgObj === 'string' ? msgObj : (msgObj.body || '');
-
-  const form = {
-    client:               'mercury',
-    action_type:          'ma-type:user-generated-message',
-    author:               'fbid:' + ctx.userID,
-    timestamp,
-    timestamp_absolute:   'Today',
-    timestamp_relative:   utils.generateTimestampRelative(),
-    timestamp_time_passed:'0',
-    is_unread:            false,
-    is_cleared:           false,
-    is_forward:           false,
-    is_filtered_content:  false,
-    is_filtered_content_bh: false,
-    is_filtered_content_account: false,
-    is_filtered_content_quasar: false,
-    is_filtered_content_invalid_app: false,
-    is_spoof_warning:     false,
-    source:               'source:chat:web',
-    'source_tags[0]':     'source:chat',
-    body,
-    html_body:            false,
-    ui_push_phase:        'V3',
-    status:               '0',
-    offline_threading_id: messageAndOTID,
-    message_id:           messageAndOTID,
-    threading_id:         utils.generateThreadingID(ctx.clientID),
-    'ephemeral_ttl_mode:':'0',
-    manual_retry_cnt:     '0',
-    has_attachment:       !!(msgObj && msgObj.sticker),
-    signatureID:          utils.getSignatureID(),
-    has_lightweight_action:                          true,
-    'lightweight_action_attached[message_id]':       messageAndOTID,
-    'lightweight_action_attached[messaging_tag]':    messagingTag,
-  };
-
-  if (msgObj && msgObj.sticker) {
-    form.sticker_id = msgObj.sticker;
-  }
-
-  if (typeof msgObj === 'object' && msgObj.reply_to_message_id) {
-    form.replied_to_message_id = msgObj.reply_to_message_id;
-  }
-
-  const tid = String(threadID);
-  const isGroup = tid.length >= 16;
-  if (isGroup) {
-    form.thread_fbid = tid;
-  } else {
-    form['specific_to_list[0]'] = 'fbid:' + tid;
-    form['specific_to_list[1]'] = 'fbid:' + ctx.userID;
-    form.other_user_fbid        = tid;
-    form.client_thread_id       = 'root:' + messageAndOTID;
-  }
-
-  return { form, messageAndOTID, timestamp, messagingTag };
-}
-
-function buildMqttPayload(effectTag, msgObj, threadID, ctx) {
-  const otid      = utils.generateOfflineThreadingID();
-  const epoch_id  = utils.generateOfflineThreadingID();
-  const timestamp = Date.now();
-  const body      = typeof msgObj === 'string' ? msgObj : (msgObj && msgObj.body || '');
-  const tid       = String(threadID);
-
-  const sendPayload = {
-    thread_id:            tid,
-    otid:                 otid.toString(),
-    source:               0,
-    send_type:            1,
-    sync_group:           1,
-    text:                 body,
-    initiating_source:    1,
-    skip_url_preview_gen: 0,
-    lightweight_action_attached: {
-      messaging_tag: 'fb.messaging.effects.' + effectTag,
-    },
-  };
-
-  if (typeof msgObj === 'object' && msgObj && msgObj.sticker) {
-    sendPayload.send_type  = 2;
-    sendPayload.sticker_id = msgObj.sticker;
-    sendPayload.text       = null;
-  }
-
-  const request_id = ++ctx.wsReqNumber;
-  const content = {
-    app_id:  '2220391788200892',
-    payload: JSON.stringify({
-      tasks: [
-        {
-          label:        '46',
-          payload:      JSON.stringify(sendPayload),
-          queue_name:   tid,
-          task_id:      ++ctx.wsTaskNumber,
-          failure_count: null,
-        },
-        {
-          label:  '21',
-          payload: JSON.stringify({
-            thread_id:             tid,
-            last_read_watermark_ts: timestamp,
-            sync_group:            1,
-          }),
-          queue_name:   tid,
-          task_id:      ++ctx.wsTaskNumber,
-          failure_count: null,
-        },
-      ],
-      epoch_id,
-      version_id:    '6120284488008082',
-      data_trace_id: null,
-    }),
-    request_id,
-    type: 3,
-  };
-
-  return { content, request_id, otid, timestamp };
-}
-
 module.exports = function (defaultFuncs, api, ctx) {
   /**
    * Lists all available send effects.
@@ -214,68 +89,19 @@ module.exports = function (defaultFuncs, api, ctx) {
       const effectTag = resolveEffect(effectName);
       utils.log('sendEffect', `Effect "${effectTag}" → thread ${threadID}`);
 
-      // ── Try HTTP first ───────────────────────────────────────────────────
-      try {
-        const { form, messageAndOTID, timestamp } = buildForm(effectTag, message, threadID, ctx);
-
-        const resData = await defaultFuncs
-          .post('https://www.facebook.com/messaging/send/', ctx.jar, form, { ...ctx, requestThreadID: String(threadID) })
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-
-        if (!resData) throw new Error('Empty response from messaging/send');
-        if (resData.error) throw new Error(JSON.stringify(resData));
-
-        const actions  = (resData.payload && resData.payload.actions) || [];
-        const msgInfo  = actions.reduce((p, v) => ({
-          threadID:  v.thread_fbid  || p.threadID,
-          messageID: v.message_id   || p.messageID,
-          timestamp: v.timestamp    || p.timestamp,
-        }), { threadID, messageID: messageAndOTID, timestamp });
-
-        return callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
-      } catch (httpErr) {
-        utils.warn('sendEffect', `HTTP failed: ${httpErr.message}. Falling back to MQTT.`);
-      }
-
-      // ── MQTT fallback ────────────────────────────────────────────────────
+      // Effects only work via MQTT (label-46 task). The legacy /messaging/send/
+      // HTTP endpoint silently drops lightweight_action_attached fields and
+      // delivers a plain message with no animation.
       if (!ctx.mqttClient) {
         throw new Error('MQTT is not connected. Call api.listenMqtt() first.');
       }
 
-      const { content, request_id, otid, timestamp } = buildMqttPayload(effectTag, message, threadID, ctx);
+      const msg = typeof message === 'string'
+        ? { body: message, effect: effectTag }
+        : { ...message, effect: effectTag };
 
-      await new Promise((res, rej) => {
-        let done    = false;
-        const timer = setTimeout(() => {
-          if (done) return;
-          done = true;
-          ctx.mqttClient.removeListener('message', onMsg);
-          rej(new Error('MQTT effect send timeout'));
-        }, 15000);
-
-        const onMsg = (topic, raw) => {
-          if (topic !== '/ls_resp') return;
-          let parsed;
-          try { parsed = JSON.parse(raw.toString()); parsed.payload = JSON.parse(parsed.payload); } catch { return; }
-          if (parsed.request_id !== request_id) return;
-          if (done) return;
-          done = true;
-          clearTimeout(timer);
-          ctx.mqttClient.removeListener('message', onMsg);
-          callback(null, { threadID, messageID: otid, timestamp, effect: effectTag, method: 'mqtt' });
-          res();
-        };
-
-        ctx.mqttClient.on('message', onMsg);
-        ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, (err) => {
-          if (err && !done) {
-            done = true;
-            clearTimeout(timer);
-            ctx.mqttClient.removeListener('message', onMsg);
-            rej(err);
-          }
-        });
-      });
+      const result = await api.sendMessageMqtt(msg, threadID);
+      return callback(null, { ...result, effect: effectTag, method: 'mqtt' });
 
     } catch (err) {
       utils.error('sendEffect', err.message || err);

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;