@lazyneoaz/nkxchat 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/nkxchat",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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.",
@@ -39,6 +39,7 @@
     "nkxchat"
   ],
   "dependencies": {
+    "@dongdev/fca-unofficial": "^4.0.3",
     "axios": "^1.13.5",
     "axios-cookiejar-support": "^4.0.7",
     "bluebird": "^3.7.2",

package/src/apis/listenMqtt.js

@@ -593,9 +593,72 @@ function mqttConf(ctx, overrides) {
     return ctx._mqttOpt;
 }
 
+function createMiddlewareSystem() {
+    const stack = [];
+    let nextId = 0;
+    function use(nameOrFn, fn) {
+        let name, middlewareFn;
+        if (typeof nameOrFn === "string" && typeof fn === "function") {
+            name = nameOrFn; middlewareFn = fn;
+        } else if (typeof nameOrFn === "function") {
+            middlewareFn = nameOrFn; name = `middleware_${nextId++}`;
+        } else throw new Error("Middleware must be a function or (name, function)");
+        const entry = { name, fn: middlewareFn, enabled: true };
+        stack.push(entry);
+        return function remove() {
+            const i = stack.indexOf(entry);
+            if (i !== -1) stack.splice(i, 1);
+        };
+    }
+    function remove(identifier) {
+        const i = typeof identifier === "string"
+            ? stack.findIndex(e => e.name === identifier)
+            : stack.findIndex(e => e.fn === identifier);
+        if (i !== -1) { stack.splice(i, 1); return true; }
+        return false;
+    }
+    function clear() { stack.length = 0; }
+    function list() { return stack.filter(e => e.enabled).map(e => e.name); }
+    function setEnabled(name, enabled) {
+        const e = stack.find(e => e.name === name);
+        if (e) { e.enabled = enabled; return true; }
+        return false;
+    }
+    function process(event, finalCallback) {
+        const active = stack.filter(e => e.enabled);
+        if (!active.length) return finalCallback(null, event);
+        let idx = 0;
+        function next(err) {
+            if (err && err !== false && err !== null) return finalCallback(err, null);
+            if (err === false || err === null) return finalCallback(null, null);
+            if (idx >= active.length) return finalCallback(null, event);
+            const mw = active[idx++];
+            try {
+                const r = mw.fn(event, next);
+                if (r && typeof r.then === "function") r.then(() => next()).catch(e => next(e));
+                else if (r === false || r === null) finalCallback(null, null);
+            } catch (e) { next(e); }
+        }
+        next();
+    }
+    function wrapCallback(callback) {
+        return function(err, event) {
+            if (err) return callback(err, null);
+            if (!event) return callback(null, null);
+            process(event, (mwErr, processed) => {
+                if (mwErr) return callback(mwErr, null);
+                if (processed === null) return;
+                callback(null, processed);
+            });
+        };
+    }
+    return { use, remove, clear, list, setEnabled, process, wrapCallback, get count() { return stack.filter(e => e.enabled).length; } };
+}
+
 module.exports = (defaultFuncs, api, ctx, opts) => {
     const identity = () => {};
     let globalCallback = identity;
+    if (!ctx._middleware) ctx._middleware = createMiddlewareSystem();
 
     function emitAuthError(reason, detail) {
         try { if (ctx._autoCycleTimer) clearTimeout(ctx._autoCycleTimer); } catch (_) { }
@@ -930,7 +993,7 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
 
         const msgEmitter = new MessageEmitter();
 
-        globalCallback = callback || function(error, message) {
+        const baseCallback = callback || function(error, message) {
             if (error) { 
                 utils.error("MQTT", "Emit error");
                 return msgEmitter.emit("error", error); 
@@ -941,6 +1004,12 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             msgEmitter.emit("message", message);
         };
 
+        globalCallback = ctx._middleware && ctx._middleware.count
+            ? ctx._middleware.wrapCallback(baseCallback)
+            : baseCallback;
+
+        ctx._emitter = msgEmitter;
+
         ctx._listeningActive = true;
         ctx._lastListenCallback = callback || null;
 
@@ -990,6 +1059,24 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
 
         api.stopListening = msgEmitter.stopListening;
         api.stopListeningAsync = msgEmitter.stopListeningAsync;
+
+        api.useMiddleware = function(nameOrFn, fn) {
+            const remove = ctx._middleware.use(nameOrFn, fn);
+            globalCallback = ctx._middleware.wrapCallback(baseCallback || identity);
+            return remove;
+        };
+        api.removeMiddleware = function(identifier) {
+            const ok = ctx._middleware.remove(identifier);
+            if (!ctx._middleware.count) globalCallback = baseCallback || identity;
+            return ok;
+        };
+        api.clearMiddleware = function() {
+            ctx._middleware.clear();
+            globalCallback = baseCallback || identity;
+        };
+        api.listMiddleware = function() { return ctx._middleware.list(); };
+        api.setMiddlewareEnabled = function(name, enabled) { return ctx._middleware.setEnabled(name, enabled); };
+
         return msgEmitter;
     };
 };

package/src/apis/scheduler.js

@@ -0,0 +1,129 @@
+"use strict";
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const scheduledMessages = new Map();
+  let nextId = 1;
+
+  function toTimestamp(when) {
+    if (when instanceof Date) return when.getTime();
+    if (typeof when === "number") return when;
+    if (typeof when === "string") return new Date(when).getTime();
+    return NaN;
+  }
+
+  function scheduleMessage(message, threadID, when, options) {
+    options = options || {};
+    const timestamp = toTimestamp(when);
+    if (isNaN(timestamp)) throw new Error("Invalid 'when'. Must be Date, number (ms timestamp), or ISO string.");
+    const now = Date.now();
+    if (timestamp <= now) throw new Error("Scheduled time must be in the future.");
+
+    const id = `scheduled_${nextId++}_${now}`;
+    const delay = timestamp - now;
+
+    const scheduled = {
+      id,
+      message,
+      threadID,
+      timestamp,
+      createdAt: now,
+      options: {
+        replyMessageID: options.replyMessageID || null,
+        callback: options.callback || null,
+      },
+      cancelled: false,
+      timeout: null,
+    };
+
+    scheduled.timeout = setTimeout(() => {
+      if (scheduled.cancelled) return;
+      const sendFn = api.sendMessage || api.sendMessageMqtt;
+      if (!sendFn) return;
+      Promise.resolve(
+        sendFn(message, threadID, scheduled.options.callback || (() => {}), scheduled.options.replyMessageID)
+      ).then(() => {
+        scheduledMessages.delete(id);
+      }).catch(() => {
+        scheduledMessages.delete(id);
+      });
+    }, delay);
+
+    scheduledMessages.set(id, scheduled);
+    return id;
+  }
+
+  function cancelScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return false;
+    clearTimeout(s.timeout);
+    s.cancelled = true;
+    scheduledMessages.delete(id);
+    return true;
+  }
+
+  function getScheduledMessage(id) {
+    const s = scheduledMessages.get(id);
+    if (!s || s.cancelled) return null;
+    return {
+      id: s.id,
+      message: s.message,
+      threadID: s.threadID,
+      timestamp: s.timestamp,
+      createdAt: s.createdAt,
+      options: { ...s.options },
+      timeUntilSend: s.timestamp - Date.now(),
+    };
+  }
+
+  function listScheduledMessages() {
+    const now = Date.now();
+    return Array.from(scheduledMessages.values())
+      .filter(s => !s.cancelled)
+      .map(s => ({
+        id: s.id,
+        message: s.message,
+        threadID: s.threadID,
+        timestamp: s.timestamp,
+        createdAt: s.createdAt,
+        options: { ...s.options },
+        timeUntilSend: s.timestamp - now,
+      }))
+      .sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  function cancelAllScheduledMessages() {
+    let count = 0;
+    for (const id of Array.from(scheduledMessages.keys())) {
+      if (cancelScheduledMessage(id)) count++;
+    }
+    return count;
+  }
+
+  function getScheduledCount() {
+    return scheduledMessages.size;
+  }
+
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [id, s] of scheduledMessages.entries()) {
+      if (s.cancelled || s.timestamp < now) scheduledMessages.delete(id);
+    }
+  }, 5 * 60 * 1000);
+
+  function destroy() {
+    clearInterval(cleanupInterval);
+    return cancelAllScheduledMessages();
+  }
+
+  ctx._scheduler = { destroy };
+
+  return {
+    scheduleMessage,
+    cancelScheduledMessage,
+    getScheduledMessage,
+    listScheduledMessages,
+    cancelAllScheduledMessages,
+    getScheduledCount,
+    destroy,
+  };
+};

package/src/apis/sendEffect.js

@@ -40,6 +40,131 @@ 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.
@@ -89,19 +214,68 @@ module.exports = function (defaultFuncs, api, ctx) {
       const effectTag = resolveEffect(effectName);
       utils.log('sendEffect', `Effect "${effectTag}" → thread ${threadID}`);
 
-      // 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.
+      // ── 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 ────────────────────────────────────────────────────
       if (!ctx.mqttClient) {
         throw new Error('MQTT is not connected. Call api.listenMqtt() first.');
       }
 
-      const msg = typeof message === 'string'
-        ? { body: message, effect: effectTag }
-        : { ...message, effect: effectTag };
+      const { content, request_id, otid, timestamp } = buildMqttPayload(effectTag, message, threadID, ctx);
 
-      const result = await api.sendMessageMqtt(msg, threadID);
-      return callback(null, { ...result, effect: effectTag, method: 'mqtt' });
+      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);
+          }
+        });
+      });
 
     } catch (err) {
       utils.error('sendEffect', err.message || err);