@lazyneoaz/metachat 1.0.11 → 1.1.0

package/src/apis/listenMqtt.js

@@ -499,6 +499,9 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
         }
         // Save connected state BEFORE clearing it — used for quick-close detection.
         const wasConnected = ctx._mqttConnected;
+        try {
+            if (ctx._emitter) ctx._emitter.emit('disconnected', { timestamp: Date.now(), wasConnected });
+        } catch (_) {}
         ctx._mqttConnected = false;
         if (ctx._ending || ctx._cycling) return;
 
@@ -564,6 +567,15 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
             ctx._mqttWatchdog = null;
         }
         ctx._mqttConnected = false;
+
+        if (!ctx._ending && !ctx._cycling && ctx.globalOptions.autoReconnect) {
+            try { mqttClient.end(true); } catch (_) {}
+            ctx._reconnectAttempts = (ctx._reconnectAttempts || 0) + 1;
+            const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
+            const d = computeBackoffDelay(ctx, baseDelay, MQTT_MAX_BACKOFF, MQTT_JITTER_MAX);
+            utils.warn("MQTT", `Disconnect received — reconnecting in ${d}ms (attempt ${ctx._reconnectAttempts})`);
+            scheduleReconnect(d);
+        }
     }));
 
     mqttClient.on('offline', guard("offline", () => {
@@ -769,6 +781,22 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
         if (ctx._ending) return;
         if (ctx._reconnectTimer) return;
         utils.warn("MQTT", `Will reconnect in ${ms}ms`);
+
+        if (!ctx._reconnectStats) ctx._reconnectStats = { totalAttempts: 0, lastAttemptAt: null, nextAttemptAt: null, lastSuccessAt: null };
+        ctx._reconnectStats.totalAttempts = (ctx._reconnectStats.totalAttempts || 0) + 1;
+        ctx._reconnectStats.lastAttemptAt = Date.now();
+        ctx._reconnectStats.nextAttemptAt = Date.now() + ms;
+        try {
+            if (ctx._emitter) {
+                ctx._emitter.emit('reconnecting', {
+                    attempt: ctx._reconnectAttempts || 0,
+                    delayMs: ms,
+                    nextAttemptAt: ctx._reconnectStats.nextAttemptAt,
+                    timestamp: Date.now()
+                });
+            }
+        } catch (_) {}
+
         ctx._reconnectTimer = setTimeout(() => {
             ctx._reconnectTimer = null;
             getSeqIDWrapper();
@@ -1080,7 +1108,8 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             try {
                 const LIFECYCLE_EVENTS = [
                     'sessionExpired', 'checkpoint', 'relogin', 'ready',
-                    'account_inactive', 'checkpoint_282', 'checkpoint_956', 'error'
+                    'account_inactive', 'checkpoint_282', 'checkpoint_956', 'error',
+                    'reconnecting', 'reconnected', 'connected', 'disconnected'
                 ];
                 for (const event of LIFECYCLE_EVENTS) {
                     // Use listeners() NOT rawListeners() — rawListeners() returns the
@@ -1149,8 +1178,64 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
 
         ctx.firstListen = false;
 
-        api.stopListening = msgEmitter.stopListening;
-        api.stopListeningAsync = msgEmitter.stopListeningAsync;
+        api.stopListening = msgEmitter.stopListening.bind(msgEmitter);
+        api.stopListeningAsync = msgEmitter.stopListeningAsync.bind(msgEmitter);
+
+        api.reconnect = function(callback) {
+            let resolveFunc, rejectFunc;
+            const returnPromise = new Promise((resolve, reject) => {
+                resolveFunc = resolve;
+                rejectFunc = reject;
+            });
+            const cb = typeof callback === "function"
+                ? (err) => { callback(err); if (err) rejectFunc(err); else resolveFunc(); }
+                : (err) => { if (err) rejectFunc(err); else resolveFunc(); };
+
+            if (ctx._ending) {
+                return cb(new Error("listenMqtt is not active — call listenMqtt() first")), returnPromise;
+            }
+            utils.log("MQTT", "api.reconnect() — force-reconnecting");
+            try { if (ctx.mqttClient) ctx.mqttClient.end(true); } catch (_) {}
+            ctx._mqttConnected = false;
+            ctx._reconnectAttempts = 0;
+            if (ctx._reconnectTimer) {
+                clearTimeout(ctx._reconnectTimer);
+                ctx._reconnectTimer = null;
+            }
+            try {
+                if (ctx._emitter) ctx._emitter.emit('reconnecting', { forced: true, attempt: 0, delayMs: 0, timestamp: Date.now() });
+            } catch (_) {}
+            getSeqIDWrapper().then(() => cb(null)).catch(cb);
+            return returnPromise;
+        };
+
+        api.getReconnectStatus = function() {
+            const stats = ctx._reconnectStats || {};
+            return {
+                connected: !!(ctx.mqttClient && ctx.mqttClient.connected),
+                reconnectAttempts: ctx._reconnectAttempts || 0,
+                totalReconnects: stats.totalAttempts || 0,
+                lastAttemptAt: stats.lastAttemptAt || null,
+                nextAttemptAt: ctx._reconnectTimer ? (stats.nextAttemptAt || null) : null,
+                lastSuccessAt: stats.lastSuccessAt || null,
+                reconnectPending: !!ctx._reconnectTimer,
+                autoReconnect: !!ctx.globalOptions.autoReconnect,
+                options: Object.assign({}, ctx._mqttOpt || {})
+            };
+        };
+
+        api.setReconnectOptions = function(newOpts) {
+            if (!newOpts || typeof newOpts !== "object") return;
+            ctx._mqttOpt = Object.assign({}, MQTT_DEFAULTS, ctx._mqttOpt || {}, newOpts);
+            if (typeof ctx._mqttOpt.autoReconnect === "boolean") {
+                ctx.globalOptions.autoReconnect = ctx._mqttOpt.autoReconnect;
+            }
+            if (typeof ctx._mqttOpt.cycleMs === "number") {
+                conf = Object.assign({}, conf, { cycleMs: ctx._mqttOpt.cycleMs });
+            }
+            utils.log("MQTT", "setReconnectOptions applied:", JSON.stringify(ctx._mqttOpt));
+            return ctx._mqttOpt;
+        };
 
         api.useMiddleware = function(nameOrFn, fn) {
             const remove = ctx._middleware.use(nameOrFn, fn);

package/src/apis/markAsRead.js

@@ -21,7 +21,18 @@ module.exports = function (defaultFuncs, api, ctx) {
 
     if (!callback) {
       callback = (err) => {
-        if (err) return rejectFunc(err instanceof Error ? err : new Error(String(err.error || err.message || err)));
+        if (err) return rejectFunc(err instanceof Error ? err : new Error(String(err && (err.error || err.message) || err)));
+        resolveFunc(null);
+      };
+    } else {
+      const _userCb = callback;
+      callback = (err) => {
+        if (err) {
+          const e = err instanceof Error ? err : new Error(String(err && (err.error || err.message) || err));
+          _userCb(e);
+          return rejectFunc(e);
+        }
+        _userCb(null);
         resolveFunc(null);
       };
     }
@@ -43,9 +54,7 @@ module.exports = function (defaultFuncs, api, ctx) {
           .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
         if (resData && resData.error) {
-          const err = new Error(String(resData.error.message || resData.error));
-          callback(err);
-          return returnPromise;
+          return callback(new Error(String(resData.error.message || resData.error)));
         }
 
         callback(null);
@@ -62,16 +71,13 @@ module.exports = function (defaultFuncs, api, ctx) {
           .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
         if (resData && resData.error) {
-          const err = new Error(String(resData.error.message || resData.error));
-          callback(err);
-          return returnPromise;
+          return callback(new Error(String(resData.error.message || resData.error)));
         }
 
         callback(null);
       }
     } catch (e) {
-      const err = e instanceof Error ? e : new Error(String(e.error || e.message || e));
-      callback(err);
+      callback(e instanceof Error ? e : new Error(String(e && (e.error || e.message) || e)));
     }
 
     return returnPromise;

package/src/apis/muteThread.js

@@ -31,7 +31,7 @@ module.exports = (defaultFuncs, api, ctx) => {
       ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
       if (res && res.error) {
-        throw res;
+        throw new Error(res.error_msg || res.errorSummary || String(res.error));
       }
 
       callback(null, { success: true });

package/src/apis/nickname.js

@@ -3,7 +3,7 @@
 const utils = require('../utils');
 const { publishLsRequestWithAck, buildLsTask, generateEpochId } = require('../utils/lsRequest');
 
-const NICKNAME_VERSION_ID = "25459622483894963";
+const NICKNAME_VERSION_ID = "8798795233522156";
 
 module.exports = function (defaultFuncs, api, ctx) { 
   /**

package/src/apis/pinMessage.js

@@ -1,152 +1,132 @@
 "use strict";
 
-const utils = require('../utils'); 
-const fs = require("fs");
-const path = require("path");
-const _ = require("lodash");
-const deepdash = require("deepdash");
-const { JSONPath } = require("jsonpath-plus");
+const utils = require('../utils');
 
-deepdash(_);
-
-/**
- * Extract and save the full lightspeed_web_request object from thread data.
- * Also search for specific pinned message commands.
- * @param {Object} allJsonData - Raw JSON response from Facebook.
- * @param {Object} options - Options for debug output.
- * @returns {Object|null} The full lightspeed_web_request object or null.
- */
-function extractAndSearchLightspeedRequest(allJsonData, options = {}) {
-  const { saveDebugFile = false, debugFilePath } = options;
-
-  let outputFile = null;
-  if (saveDebugFile && debugFilePath) {
-    outputFile = debugFilePath;
-  } else if (saveDebugFile) {
-    // Only save to current working directory if explicitly requested
-    outputFile = require('path').join(process.cwd(), "fca_neo_pro_lightspeed_debug.json");
-  }
-
-  const lightReq = _.get(allJsonData, "__bbox.result.data.viewer.lightspeed_web_request");
-  if (!lightReq) {
-    utils.warn("pin.js: lightspeed_web_request not found.");
-    return null;
-  }
-
-
-  if (outputFile) {
-    try {
-      fs.writeFileSync(outputFile, JSON.stringify(lightReq, null, 2), "utf8");
-      utils.log(`pin.js: Saved lightspeed_web_request to ${outputFile}`);
-    } catch (err) {
-      utils.error("pin.js: Failed to write lightspeed_web_request.json", err);
-    }
-  }
-
-
-  try {
-    const matches = JSONPath({
-      path: `$..[?(@ === "setPinnedMessage" || @ === "deleteThenInsertMessage")]`,
-      json: lightReq
-    });
-
-    utils.log(`pin.js: Found ${matches.length} matching command(s).`);
-    matches.forEach((match, idx) => {
-      utils.log(`📌 Match ${idx + 1}:`, match);
+module.exports = function (defaultFuncs, api, ctx) {
+  return async function pin(action, threadID, messageID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
     });
-  } catch (err) {
-    utils.error("pin.js: JSONPath search failed.", err);
-  }
 
-  return lightReq;
-}
-
-module.exports = function (defaultFuncs, api, ctx) {
-  return async function pin(action, threadID, messageID) {
-    if (action === "list") {
-      if (!threadID) throw new Error('Action "list" requires threadID.');
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    } else {
+      const _userCb = callback;
+      callback = (err, result) => {
+        if (err) { _userCb(err); return rejectFunc(err); }
+        _userCb(null, result);
+        resolveFunc(result);
+      };
+    }
 
-      try {
+    try {
+      if (action === "list") {
+        if (!threadID) throw new Error('Action "list" requires threadID.');
         const url = `https://www.facebook.com/messages/t/${threadID}/`;
         const allJsonData = await utils.json(url, ctx.jar, null, ctx.globalOptions, ctx);
-
-
-        const lightReq = extractAndSearchLightspeedRequest(allJsonData, { saveDebugFile: false });
+        const lightReq = allJsonData && allJsonData.__bbox &&
+          allJsonData.__bbox.result &&
+          allJsonData.__bbox.result.data &&
+          allJsonData.__bbox.result.data.viewer &&
+          allJsonData.__bbox.result.data.viewer.lightspeed_web_request;
         if (!lightReq || !lightReq.pin_status) {
-          utils.warn("pin.js: No pinned messages found or pin_status missing.");
-          return [];
+          utils.warn("pinMessage: No pinned messages found or pin_status missing.");
+          return callback(null, []);
         }
-        return lightReq;
-      } catch (err) {
-        utils.error(`pin.js: Failed to process "list" for thread ${threadID}`, err);
-        throw err;
+        return callback(null, lightReq);
       }
-    }
 
-    if (!ctx.mqttClient || !ctx.mqttClient.connected) throw new Error("MQTT not connected.");
-    if (!threadID || !messageID) throw new Error(`"${action}" requires threadID and messageID.`);
+      if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+        throw new Error("MQTT not connected — call listenMqtt() first.");
+      }
+      if (!threadID || !messageID) {
+        throw new Error(`"${action}" requires threadID and messageID.`);
+      }
 
-    const epoch_id = parseInt(utils.generateOfflineThreadingID());
-    const version_id = "9523201934447612";
-    const app_id = "2220391788200892";
+      if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+      if (typeof ctx.wsTaskNumber !== "number") ctx.wsTaskNumber = 0;
 
-    const createMqttRequest = (tasks, increment = 0) => ({
-      app_id,
-      payload: JSON.stringify({ epoch_id: epoch_id + increment, tasks, version_id }),
-      request_id: (ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1),
-      type: 3
-    });
+      const epoch_id = parseInt(utils.generateOfflineThreadingID());
+      const version_id = "9523201934447612";
+      const app_id = String(ctx.appID || ctx.mqttAppID || "2220391788200892");
 
-    const publishMqtt = (content) =>
-      new Promise((resolve, reject) => {
-        ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
-          if (err) reject(err);
-          else resolve({ success: true, request_id: content.request_id });
-        });
+      const createMqttRequest = (tasks, increment = 0) => ({
+        app_id,
+        payload: JSON.stringify({ epoch_id: epoch_id + increment, tasks, version_id }),
+        request_id: ++ctx.wsReqNumber,
+        type: 3
       });
 
-    if (action === "pin") {
-      const pinTask = {
-        label: "430",
-        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
-        queue_name: `pin_msg_v2_${threadID}`,
-        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
-      };
-      const setSearchTask = {
-        label: "751",
-        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 1 }),
-        queue_name: "set_pinned_message_search",
-        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
-      };
-      const req1 = createMqttRequest([pinTask], 0);
-      const req2 = createMqttRequest([setSearchTask], 1);
-      return Promise.all([publishMqtt(req1), publishMqtt(req2)]);
-    }
+      const publishMqtt = (content) =>
+        new Promise((resolve, reject) => {
+          ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, (err) => {
+            if (err) reject(err instanceof Error ? err : new Error(String(err)));
+            else resolve({ success: true, request_id: content.request_id });
+          });
+        });
 
-    if (action === "unpin") {
-      const setSearchTask1 = {
-        label: "751",
-        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
-        queue_name: "set_pinned_message_search",
-        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
-      };
-      const unpinTask = {
-        label: "431",
-        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
-        queue_name: `unpin_msg_v2_${threadID}`,
-        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
-      };
-      const setSearchTask2 = {
-        label: "751",
-        payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
-        queue_name: "set_pinned_message_search",
-        task_id: (ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1)
-      };
-      await publishMqtt(createMqttRequest([setSearchTask1], 0));
-      await publishMqtt(createMqttRequest([unpinTask], 1));
-      return publishMqtt(createMqttRequest([setSearchTask2], 2));
+      if (action === "pin") {
+        const pinTask = {
+          failure_count: null,
+          label: "430",
+          payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
+          queue_name: `pin_msg_v2_${threadID}`,
+          task_id: ++ctx.wsTaskNumber
+        };
+        const setSearchTask = {
+          failure_count: null,
+          label: "751",
+          payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 1 }),
+          queue_name: "set_pinned_message_search",
+          task_id: ++ctx.wsTaskNumber
+        };
+        const results = await Promise.all([
+          publishMqtt(createMqttRequest([pinTask], 0)),
+          publishMqtt(createMqttRequest([setSearchTask], 1))
+        ]);
+        return callback(null, { success: true, action: "pin", results });
+      }
+
+      if (action === "unpin") {
+        const setSearchTask1 = {
+          failure_count: null,
+          label: "751",
+          payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
+          queue_name: "set_pinned_message_search",
+          task_id: ++ctx.wsTaskNumber
+        };
+        const unpinTask = {
+          failure_count: null,
+          label: "431",
+          payload: JSON.stringify({ thread_key: threadID, message_id: messageID, timestamp_ms: Date.now() }),
+          queue_name: `unpin_msg_v2_${threadID}`,
+          task_id: ++ctx.wsTaskNumber
+        };
+        const setSearchTask2 = {
+          failure_count: null,
+          label: "751",
+          payload: JSON.stringify({ thread_key: threadID, message_id: messageID, pinned_message_state: 0 }),
+          queue_name: "set_pinned_message_search",
+          task_id: ++ctx.wsTaskNumber
+        };
+        await publishMqtt(createMqttRequest([setSearchTask1], 0));
+        await publishMqtt(createMqttRequest([unpinTask], 1));
+        const result = await publishMqtt(createMqttRequest([setSearchTask2], 2));
+        return callback(null, { success: true, action: "unpin", result });
+      }
+
+      throw new Error(`Invalid action: "${action}". Use "pin", "unpin", or "list".`);
+    } catch (err) {
+      utils.error("pinMessage", err);
+      callback(err instanceof Error ? err : new Error(String(err && err.message ? err.message : err)));
     }
 
-    throw new Error(`Invalid action: "${action}". Use "pin", "unpin", or "list".`);
+    return returnPromise;
   };
 };

package/src/apis/removeUserFromGroup.js

@@ -52,7 +52,7 @@ module.exports = (defaultFuncs, api, ctx) => {
               task_id: taskID
             }
           ],
-          version_id: '8798795233522156'
+          version_id: '25002366262773827'
         };
 
         const form = JSON.stringify({
@@ -110,7 +110,7 @@ module.exports = (defaultFuncs, api, ctx) => {
           .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
         if (!res || res.error) {
-          throw res || new Error("Remove from group failed");
+          throw new Error((res && (res.error_msg || res.errorSummary || String(res.error))) || "Remove from group failed");
         }
 
         callback(null, { success: true });

package/src/apis/resolvePhotoUrl.js

@@ -41,7 +41,7 @@ photo_id: photoID,
 .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
 .then((resData) => {
 if (resData.error) {
-throw resData;
+throw new Error(resData.error_msg || resData.errorSummary || String(resData.error));
 }
 
 const photoUrl = resData.jsmods.require[0][3][0];

package/src/apis/searchForThread.js

@@ -113,7 +113,7 @@ module.exports = (defaultFuncs, api, ctx) => {
         }
 
         if (res.error) {
-          throw res;
+          throw new Error(res.error_msg || res.errorSummary || String(res.error));
         }
 
         // Support both legacy payload.threads (object map) and newer payload.mercury_payload.threads (array)

package/src/apis/sendMessage.js

@@ -250,6 +250,13 @@ module.exports = (defaultFuncs, api, ctx) => {
         if (err) return rejectFunc(err);
         resolveFunc(data);
       };
+    } else {
+      const _userCb = callback;
+      callback = (err, data) => {
+        if (err) { _userCb(err); return rejectFunc(err); }
+        _userCb(null, data);
+        resolveFunc(data);
+      };
     }
 
     let msgType = utils.getType(msg);

package/src/apis/setMessageReaction.js

@@ -35,8 +35,9 @@ module.exports = function (defaultFuncs, api, ctx) {
       const defData = await defaultFuncs.postFormData(
         "https://www.facebook.com/webgraphql/mutation/",
         ctx.jar,
+        {},
         {
-          doc_id: "3360163564070970",
+          doc_id: "1491398900900362",
           variables: JSON.stringify({
             data: {
               client_mutation_id: ctx.clientMutationId++,
@@ -47,8 +48,7 @@ module.exports = function (defaultFuncs, api, ctx) {
             }
           }),
           dpr: 1
-        },
-        {}
+        }
       );
 
       const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);

package/src/apis/setMessageReactionMqtt.js

@@ -50,7 +50,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       failure_count: null,
       label: "29",
       payload: JSON.stringify(taskPayload),
-      queue_name: JSON.stringify(["reaction", messageID]),
+      queue_name: `reaction:${messageID}`,
       task_id: taskId
     };
 
@@ -60,7 +60,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         data_trace_id: null,
         epoch_id: parseInt(utils.generateOfflineThreadingID()),
         tasks: [task],
-        version_id: "7158486590867448"
+        version_id: "24585299697835063"
       }),
       request_id: requestId,
       type: 3