@lazyneoaz/metachat 1.0.10 → 1.1.0

package/src/apis/editMessage.js

@@ -1,70 +1,81 @@
 "use strict";
-/**
-* @author RFS-ADRENO
-* @rewrittenBy Isai Ivanov
-*/
 
 const utils = require('../utils');
-
-function canBeCalled(func) {
-    try {
-        Reflect.apply(func, null, []);
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
+const { publishLsRequestWithAck } = require('../utils/lsRequest');
 
 /**
-* A function for editing bot's messages.
-* @param {string} text - The text with which the bot will edit its messages.
-* @param {string} messageID - The message ID of the message the bot will edit.
-* @param {Object} callback - Callback for the function.
-*/
-
+ * Edits a previously sent bot message via MQTT with ACK confirmation.
+ *
+ * @param {string}   text       New text content for the message.
+ * @param {string}   messageID  The ID of the message to edit.
+ * @param {Function} [callback] Optional callback(err, result).
+ * @returns {Promise}
+ */
 module.exports = function (defaultFuncs, api, ctx) {
     return function editMessage(text, messageID, callback) {
-        if (!ctx.mqttClient) {
-            throw new Error('Not connected to MQTT');
+        let resolveFunc, rejectFunc;
+        const returnPromise = new Promise((resolve, reject) => {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+
+        const cb = (typeof callback === "function")
+            ? (err, data) => { callback(err, data); if (err) rejectFunc(err); else resolveFunc(data); }
+            : (err, data) => { if (err) rejectFunc(err); else resolveFunc(data); };
+
+        if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+            return cb(new Error("Not connected to MQTT — call listenMqtt() first")), returnPromise;
         }
 
-        ctx.wsReqNumber += 1;
-        ctx.wsTaskNumber += 1;
+        if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+        if (typeof ctx.wsTaskNumber !== "number") ctx.wsTaskNumber = 0;
 
-        const queryPayload = {
-            message_id: messageID,
-            text
-        };
+        const requestId = ++ctx.wsReqNumber;
+        const taskId = ++ctx.wsTaskNumber;
 
-        const query = {
+        const task = {
             failure_count: null,
-            label: '742',
-            payload: JSON.stringify(queryPayload),
-            queue_name: 'edit_message',
-            task_id: ctx.wsTaskNumber
+            label: "742",
+            payload: JSON.stringify({ message_id: messageID, text }),
+            queue_name: "edit_message",
+            task_id: taskId
         };
 
-        const context = {
-            app_id: '2220391788200892',
-            payload: {
+        const content = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify({
                 data_trace_id: null,
                 epoch_id: parseInt(utils.generateOfflineThreadingID()),
-                tasks: [query],
-                version_id: '6903494529735864'
-            },
-            request_id: ctx.wsReqNumber,
+                tasks: [task],
+                version_id: "6903494529735864"
+            }),
+            request_id: requestId,
             type: 3
         };
 
-        context.payload = JSON.stringify(context.payload);
-
-
-
-
-
-        ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {
-            qos: 1, retain: false
+        publishLsRequestWithAck({
+            client: ctx.mqttClient,
+            content,
+            requestId,
+            timeoutMs: 10000,
+            extract: (message) => ({
+                success: true,
+                messageID,
+                text,
+                ack: message.payload
+            })
+        }).then((result) => {
+            cb(null, result);
+        }).catch((err) => {
+            if (err && err.message && err.message.includes("Timeout waiting for LS ACK")) {
+                utils.warn("editMessage", "ACK timed out — edit may still have been applied");
+                cb(null, { success: true, messageID, text, ackTimeout: true });
+            } else {
+                utils.error("editMessage", err && err.message ? err.message : err);
+                cb(err instanceof Error ? err : new Error(String(err && err.message ? err.message : err)));
+            }
         });
+
+        return returnPromise;
     };
 };
-

package/src/apis/emoji.js

@@ -69,7 +69,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       return _callback(new Error("An emoji character is required."));
     }
 
-    if (!ctx.mqttClient) {
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
       return _callback(new Error("Not connected to MQTT"));
     }
 
@@ -92,7 +92,7 @@ module.exports = function (defaultFuncs, api, ctx) {
     };
 
     const context = {
-      app_id: ctx.appID,
+      app_id: ctx.appID || '2220391788200892',
       payload: {
         epoch_id: parseInt(utils.generateOfflineThreadingID()),
         tasks: [query],

package/src/apis/follow.js

@@ -1,27 +1,28 @@
 "use strict";
 
-/**
- * Author @YanMaglinte
- * https://github.com/YANDEVA
- * * Example:
- * api.follow("100090794779367", true);
- * jsdocs @ChoruOfficial
- */
- 
-/**
- * @param {object} defaultFuncs The default functions for making API requests.
- * @param {object} api The full API object.
- * @param {object} ctx The context object.
- * @returns {function(senderID: string, boolean: boolean, callback?: (err: any, data?: any) => void): void} The follow function.
- */
 module.exports = function (defaultFuncs, api, ctx) {
-  /**
-   * Follows or unfollows a user on Facebook.
-   * @param {string} senderID The ID of the user to follow or unfollow.
-   * @param {boolean} boolean Set to `true` to follow the user, `false` to unfollow.
-   * @param {(err: any, data?: any) => void} [callback] An optional callback function.
-   */
   return function follow(senderID, boolean, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        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 form;
     if (boolean) {
       form = {
@@ -67,15 +68,10 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     api.httpPost("https://www.facebook.com/api/graphql/", form, (err, data) => {
-      if (err) {
-        if (typeof callback === "function") {
-          callback(err);
-        }
-      } else {
-        if (typeof callback === "function") {
-          callback(null, data);
-        }
-      }
+      if (err) return callback(err instanceof Error ? err : new Error(String(err && err.message ? err.message : err)));
+      callback(null, data);
     });
+
+    return returnPromise;
   };
-};
+};

package/src/apis/forwardAttachment.js

@@ -48,6 +48,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       const timestamp = Date.now();
       const tid       = String(threadID);
       if (typeof ctx.wsReqNumber !== 'number') ctx.wsReqNumber = 0;
+      if (typeof ctx.wsTaskNumber !== 'number') ctx.wsTaskNumber = 0;
       const reqID     = ++ctx.wsReqNumber;
 
       const sendPayload = {
@@ -73,7 +74,7 @@ module.exports = function (defaultFuncs, api, ctx) {
               label:         "46",
               payload:       JSON.stringify(sendPayload),
               queue_name:    tid,
-              task_id:       400,
+              task_id:       ++ctx.wsTaskNumber,
               failure_count: null,
             },
             {
@@ -84,7 +85,7 @@ module.exports = function (defaultFuncs, api, ctx) {
                 sync_group:             1,
               }),
               queue_name:    tid,
-              task_id:       401,
+              task_id:       ++ctx.wsTaskNumber,
               failure_count: null,
             },
           ],

package/src/apis/forwardMessage.js

@@ -38,7 +38,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, forwardedTo: threadIDs });

package/src/apis/gcmember.js

@@ -54,7 +54,7 @@ module.exports = function (defaultFuncs, api, ctx) {
             _callback(null, { type: "error_gc", error: "threadID is required." });
             return returnPromise;
         }
-        if (!ctx.mqttClient) {
+        if (!ctx.mqttClient || !ctx.mqttClient.connected) {
             _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
             return returnPromise;
         }
@@ -99,7 +99,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         }
 
         const context = {
-          app_id: ctx.appID,
+          app_id: ctx.appID || '2220391788200892',
           payload: { epoch_id: parseInt(utils.generateOfflineThreadingID()), tasks: [query], version_id: "24631415369801570" },
           request_id: ctx.wsReqNumber,
           type: 3
@@ -121,7 +121,8 @@ module.exports = function (defaultFuncs, api, ctx) {
           return _callback(null, gcmemberInfo);
         });
     } catch (err) {
-        _callback(null, { type: "error_gc", error: err.message || "An unknown error occurred." });
+        utils.error("gcmember", err);
+        _callback(err instanceof Error ? err : new Error(err.message || "An unknown error occurred."));
     }
 
     return returnPromise;

package/src/apis/gcname.js

@@ -69,7 +69,7 @@ module.exports = function (defaultFuncs, api, ctx) {
       return _callback(new Error("newName must be a string."));
     }
 
-    if (!ctx.mqttClient) {
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
       return _callback(new Error("Not connected to MQTT"));
     }
 
@@ -91,11 +91,11 @@ module.exports = function (defaultFuncs, api, ctx) {
     };
 
     const context = {
-      app_id: ctx.appID,
+      app_id: ctx.appID || '2220391788200892',
       payload: {
         epoch_id: parseInt(utils.generateOfflineThreadingID()),
         tasks: [query],
-        version_id: '24631415369801570',
+        version_id: '8798795233522156',
       },
       request_id: ctx.wsReqNumber,
       type: 3,

package/src/apis/gcrule.js

@@ -46,7 +46,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         }
         if (!userID) { _callback(null, { type: "error_gc_rule", error: "userID is required." }); return returnPromise; }
         if (!threadID) { _callback(null, { type: "error_gc_rule", error: "threadID is required." }); return returnPromise; }
-        if (!ctx.mqttClient) { _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" }); return returnPromise; }
+        if (!ctx.mqttClient || !ctx.mqttClient.connected) { _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" }); return returnPromise; }
         
         const threadInfo = await api.getThreadInfo(threadID);
         if (!threadInfo) {
@@ -90,7 +90,7 @@ module.exports = function (defaultFuncs, api, ctx) {
             task_id: ctx.wsTaskNumber
         };
         const context = {
-            app_id: ctx.appID,
+            app_id: ctx.appID || '2220391788200892',
             payload: {
                 epoch_id: parseInt(utils.generateOfflineThreadingID()),
                 tasks: [query],
@@ -116,7 +116,8 @@ module.exports = function (defaultFuncs, api, ctx) {
         });
 
     } catch (err) {
-        _callback(null, { type: "error_gc_rule", error: err.message || "An unknown error occurred." });
+        utils.error("gcrule", err);
+        _callback(err instanceof Error ? err : new Error(err.message || "An unknown error occurred."));
     }
     
     return returnPromise;

package/src/apis/getFriendsList.js

@@ -61,11 +61,11 @@ module.exports = (defaultFuncs, api, ctx) => {
       ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
       if (!res) {
-        throw { error: "getFriendsList returned empty object." };
+        throw new Error("getFriendsList returned empty object.");
       }
 
       if (res.error) {
-        throw res;
+        throw new Error(res.error_msg || res.errorSummary || String(res.error));
       }
 
       callback(null, formatData(res.payload));

package/src/apis/getThreadInfo.js

@@ -225,7 +225,7 @@ module.exports = function (defaultFuncs, api, ctx) {
             .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
         if (resData.error) {
-            throw resData;
+            throw new Error(resData.error_msg || resData.errorSummary || String(resData.error));
         }
 
         const threadInfos = {};

package/src/apis/getThreadPictures.js

@@ -44,7 +44,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));
       }
 
       return callback(null, res?.payload || res);

package/src/apis/handleMessageRequest.js

@@ -36,7 +36,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));
       }
 
       return callback(null, { success: true, accepted: accept });

package/src/apis/listenMqtt.js

@@ -331,6 +331,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
     }));
 
     mqttClient.on('connect', guard("connect", async () => {
+        const wasReconnect = !ctx._mqttConnected && (ctx._reconnectAttempts || 0) > 0;
         if (!ctx._mqttConnected) {
             utils.log("MQTT connected successfully");
             ctx._mqttConnected = true;
@@ -338,6 +339,17 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
         ctx._cycling = false;
         ctx._reconnectAttempts = 0;
         ctx._mqttQuickCloseCount = 0;
+
+        // Update reconnect stats and emit lifecycle events
+        if (!ctx._reconnectStats) ctx._reconnectStats = { totalAttempts: 0, lastAttemptAt: null, nextAttemptAt: null, lastSuccessAt: null };
+        ctx._reconnectStats.nextAttemptAt = null;
+        ctx._reconnectStats.lastSuccessAt = Date.now();
+        try {
+            if (ctx._emitter) {
+                const eventName = wasReconnect ? 'reconnected' : 'connected';
+                ctx._emitter.emit(eventName, { timestamp: Date.now(), totalReconnects: ctx._reconnectStats.totalAttempts });
+            }
+        } catch (_) {}
         if (ctx._reconnectTimer) {
             clearTimeout(ctx._reconnectTimer);
             ctx._reconnectTimer = null;
@@ -440,7 +452,7 @@ async function listenMqtt(defaultFuncs, api, ctx, globalCallback, scheduleReconn
                     ctx.syncToken = jsonMessage.syncToken;
                 }
                 if (jsonMessage.lastIssuedSeqId) {
-                    ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId);
+                    ctx.lastSeqId = parseInt(jsonMessage.lastIssuedSeqId, 10);
                 }
 
                 if (jsonMessage.deltas) {
@@ -487,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;
 
@@ -552,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", () => {
@@ -583,7 +607,8 @@ const MQTT_DEFAULTS = {
     autoReconnect: true,
     watchdogIntervalMs: 60000,
     staleMs: 300000,
-    reconnectAfterStop: false 
+    reconnectAfterStop: false,
+    maxReconnectAttempts: 100
 };
 
 function mqttConf(ctx, overrides) {
@@ -756,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();
@@ -812,11 +853,67 @@ module.exports = (defaultFuncs, api, ctx, opts) => {
             const msg = ((err && err.error) || (err && err.message) || String(err || "")) + detail;
             
             if (/Not logged in/i.test(msg)) {
-                utils.error("MQTT", "Auth error in getSeqID: Not logged in");
+                utils.error("MQTT", "Auth error in getSeqID: Not logged in — attempting recovery...");
+                
+                // Step 1: Try token refresh first (fastest, least invasive)
+                let tokenRefreshed = false;
+                try {
+                    if (api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
+                        utils.log("MQTT", "getSeqID: refreshing tokens before giving up...");
+                        await api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, 'https://www.facebook.com');
+                        tokenRefreshed = true;
+                        utils.log("MQTT", "getSeqID: token refresh succeeded, scheduling reconnect");
+                    }
+                } catch (refreshErr) {
+                    utils.warn("MQTT", `getSeqID: token refresh failed: ${refreshErr && refreshErr.message ? refreshErr.message : refreshErr}`);
+                }
+                
+                if (tokenRefreshed && ctx.globalOptions.autoReconnect) {
+                    ctx._reconnectAttempts = Math.max(0, (ctx._reconnectAttempts || 0) - 1);
+                    const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 3000;
+                    return scheduleReconnect(baseDelay);
+                }
+                
+                // Step 2: Try full auto re-login (email+password) as last resort
+                let reloginOk = false;
+                try {
+                    const { globalAutoReLoginManager } = require('../utils/autoReLogin');
+                    if (globalAutoReLoginManager && globalAutoReLoginManager.isEnabled && globalAutoReLoginManager.isEnabled()) {
+                        utils.log("MQTT", "getSeqID: attempting auto re-login...");
+                        reloginOk = await globalAutoReLoginManager.handleSessionExpiry(api, 'https://www.facebook.com', "MQTT getSeqID Not logged in");
+                        if (reloginOk) {
+                            utils.log("MQTT", "getSeqID: re-login succeeded, scheduling MQTT reconnect");
+                        }
+                    }
+                } catch (reloginErr) {
+                    utils.warn("MQTT", `getSeqID: auto re-login failed: ${reloginErr && reloginErr.message ? reloginErr.message : reloginErr}`);
+                }
+                
+                if (reloginOk && ctx.globalOptions.autoReconnect) {
+                    ctx._reconnectAttempts = 0;
+                    const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 5000;
+                    return scheduleReconnect(baseDelay);
+                }
+                
+                // Both recovery paths exhausted — emit auth error to signal the user
                 return emitAuthError("not_logged_in", msg);
             }
             if (/blocked the login|checkpoint|security check|session.*expir|invalid.*session|authentication.*fail|auth.*fail|login.*block|account.*lock|verification.*requir/i.test(msg)) {
                 utils.error("MQTT", "Auth error in getSeqID: Session/Login blocked");
+                
+                // Still try token refresh for session expiry before giving up
+                try {
+                    if (api.tokenRefreshManager && typeof api.tokenRefreshManager.refreshTokens === 'function') {
+                        utils.log("MQTT", "getSeqID: refreshing tokens on session expiry...");
+                        await api.tokenRefreshManager.refreshTokens(ctx, defaultFuncs, 'https://www.facebook.com');
+                        if (ctx.globalOptions.autoReconnect) {
+                            ctx._reconnectAttempts = 0;
+                            const baseDelay = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 5000;
+                            return scheduleReconnect(baseDelay);
+                        }
+                    }
+                } catch (_) {}
+                
                 return emitAuthError("login_blocked", msg);
             }
             
@@ -1011,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
@@ -1080,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;