nodejs-insta-private-api-mqt 1.3.92 → 1.4.1

package/dist/dist/realtime/realtime.client.js

@@ -1036,8 +1036,48 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             // actually connect the mqtt client (this will emit connect when done)
             await this._mqtt.connect();
             // Commands uses mqtt client; Commands.updateSubscriptions has been set to use qos 0.
-            this.commands = new commands_1.Commands(this._mqtt);
-            // Notify higher-level code that we are connected
+            // Commands uses mqtt client; wrap commands to ensure online + serialize calls (prevents "idle-dead" send failures)
+
+            this._rawCommands = new commands_1.Commands(this._mqtt);
+
+            // Simple promise-chain queue to avoid concurrent publishes racing during reconnects
+
+            this._cmdQueue = this._cmdQueue || Promise.resolve();
+
+            const runQueued = (fn) => {
+
+                const task = async () => {
+
+                    await this.ensureOnline(); // ping/reconnect if needed
+
+                    return await fn();
+
+                };
+
+                // keep the queue alive even if a task fails
+
+                this._cmdQueue = this._cmdQueue.then(task, task);
+
+                return this._cmdQueue;
+
+            };
+
+            // Proxy: every command method becomes queued + guarded
+
+            this.commands = new Proxy(this._rawCommands, {
+
+                get: (target, prop) => {
+
+                    const value = target[prop];
+
+                    if (typeof value !== 'function') return value;
+
+                    return (...args) => runQueued(() => value.apply(target, args));
+
+                }
+
+            });
+// Notify higher-level code that we are connected
             this._mqttConnected = true;
             this._connectInProgress = false;
             this.emit('connected');
@@ -1057,11 +1097,12 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 this.on('iris', updateLast);
                 const KEEPALIVE_FOREGROUND_MS = (this.initOptions && this.initOptions.keepaliveForegroundMs) ? this.initOptions.keepaliveForegroundMs : 45000; // 45s keepalive pulse
                 const MESSAGE_SYNC_REFRESH_MS = (this.initOptions && this.initOptions.messageSyncRefreshMs) ? this.initOptions.messageSyncRefreshMs : 300000;
-                const TRAFFIC_INACTIVITY_MS = (this.initOptions && this.initOptions.trafficInactivityMs) ? this.initOptions.trafficInactivityMs : 180000; // 3 min default for faster recovery
+                const TRAFFIC_INACTIVITY_MS = (this.initOptions && this.initOptions.trafficInactivityMs) ? this.initOptions.trafficInactivityMs : 120000; // 2 min default for faster recovery
                 const HEARTBEAT_MS = (this.initOptions && this.initOptions.heartbeatMs) ? this.initOptions.heartbeatMs : 90000; // 90s mobile-like heartbeat
                 try {
                     if (this._foregroundTimer)
                         clearInterval(this._foregroundTimer);
+                    this._foregroundConsecutiveFailures = 0;
                     this._foregroundTimer = setInterval(async () => {
                         try {
                             if (!this.commands)
@@ -1071,10 +1112,18 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                                 data: { foreground: true }
                             });
                             this._lastMessageAt = Date.now();
+                            this._foregroundConsecutiveFailures = 0;
                             this.realtimeDebug('[KEEPALIVE] Foreground pulse sent.');
                         }
                         catch (e) {
-                            this.realtimeDebug('[KEEPALIVE] Foreground pulse failed:', e?.message || e);
+                            this._foregroundConsecutiveFailures = (this._foregroundConsecutiveFailures || 0) + 1;
+                            this.realtimeDebug(`[KEEPALIVE] Foreground pulse failed (${this._foregroundConsecutiveFailures}):`, e?.message || e);
+                            if (this._foregroundConsecutiveFailures >= 3 && !this._reconnectInProgress && !this.safeDisconnect) {
+                                this.realtimeDebug('[KEEPALIVE] 3 consecutive foreground failures - connection likely dead, triggering reconnect');
+                                this._mqttConnected = false;
+                                this._foregroundConsecutiveFailures = 0;
+                                try { await this._attemptReconnectSafely(e); } catch(re) {}
+                            }
                         }
                     }, KEEPALIVE_FOREGROUND_MS + Math.floor(Math.random() * 5000));
                 }
@@ -1113,6 +1162,7 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                                     if (this._mqtt && typeof this._mqtt.ping === 'function') {
                                         await this._mqtt.ping();
                                         this._lastMessageAt = Date.now();
+                                        this._lastServerTrafficAt = Date.now();
                                         this.realtimeDebug('[WATCHDOG] Ping succeeded, connection is alive.');
                                         return;
                                     }
@@ -1140,10 +1190,16 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                                 try {
                                     await this._mqtt.ping();
                                     this._lastMessageAt = Date.now();
+                                    this._lastServerTrafficAt = Date.now();
                                     this.realtimeDebug('[HEARTBEAT] mqtt.ping() ok.');
                                 }
                                 catch (e) {
                                     this.realtimeDebug('[HEARTBEAT] mqtt.ping failed:', e?.message || e);
+                                    if (!this._reconnectInProgress && !this.safeDisconnect) {
+                                        this.realtimeDebug('[HEARTBEAT] Ping failed - triggering reconnect');
+                                        this._mqttConnected = false;
+                                        try { await this._attemptReconnectSafely(e); } catch(re) {}
+                                    }
                                 }
                             }
                         }
@@ -1155,6 +1211,33 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 catch (e) {
                     this.realtimeDebug('[HEARTBEAT] Could not start heartbeat timer:', e?.message || e);
                 }
+                try {
+                    if (this._reconnectSafetyNet)
+                        clearInterval(this._reconnectSafetyNet);
+                    this._reconnectSafetyNet = setInterval(async () => {
+                        try {
+                            if (this._reconnectInProgress && this._reconnectStartedAt) {
+                                const stuckMs = Date.now() - this._reconnectStartedAt;
+                                if (stuckMs > 10 * 60 * 1000) {
+                                    this.realtimeDebug('[SAFETY_NET] _reconnectInProgress stuck for >10min — force resetting and retrying');
+                                    this._reconnectInProgress = false;
+                                    this._reconnectStartedAt = null;
+                                    try { await this._attemptReconnectSafely(); } catch(e) {}
+                                }
+                            }
+                            if (!this._mqttConnected && !this._reconnectInProgress && !this.safeDisconnect && !this._connectInProgress) {
+                                this.realtimeDebug('[SAFETY_NET] Not connected and no reconnect in progress — triggering reconnect');
+                                try { await this._attemptReconnectSafely(); } catch(e) {}
+                            }
+                        }
+                        catch (e) {
+                            this.realtimeDebug('[SAFETY_NET] fault:', e?.message || e);
+                        }
+                    }, 2 * 60 * 1000);
+                }
+                catch (e) {
+                    this.realtimeDebug('[SAFETY_NET] Could not start safety net timer:', e?.message || e);
+                }
             }
             catch (e) {
                 this.realtimeDebug('[WATCHDOG] initialization error:', e?.message || e);
@@ -1558,18 +1641,33 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
      */
     async _attemptReconnectSafely(lastError) {
         if (this._reconnectInProgress) {
-            this.realtimeDebug('[RECONNECT] Skipped — reconnect already in progress');
-            return;
+            const stuckMs = Date.now() - (this._reconnectStartedAt || Date.now());
+            if (stuckMs > 5 * 60 * 1000) {
+                this.realtimeDebug('[RECONNECT] _reconnectInProgress stuck for >5min — resetting flag');
+                this._reconnectInProgress = false;
+            } else {
+                this.realtimeDebug('[RECONNECT] Skipped — reconnect already in progress');
+                return;
+            }
         }
         if (this._mqttConnected) {
-            this.realtimeDebug('[RECONNECT] Skipped — MQTT is already connected');
-            return;
+            try {
+                if (this._mqtt && typeof this._mqtt.ping === 'function') {
+                    await this._mqtt.ping();
+                    this.realtimeDebug('[RECONNECT] Skipped — MQTT is already connected and ping succeeded');
+                    return;
+                }
+            } catch(e) {
+                this.realtimeDebug('[RECONNECT] MQTT marked connected but ping failed — proceeding with reconnect');
+                this._mqttConnected = false;
+            }
         }
         if (this.safeDisconnect) {
             this.realtimeDebug('[RECONNECT] Skipped — safe disconnect active');
             return;
         }
         this._reconnectInProgress = true;
+        this._reconnectStartedAt = Date.now();
         if (this._reconnectTimeoutId) {
             clearTimeout(this._reconnectTimeoutId);
             this._reconnectTimeoutId = null;
@@ -1581,7 +1679,7 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         }
         try {
             let attempt = 0;
-            const maxAttempts = 20;
+            const maxAttempts = 999;
             let lastErrorType = lastError ? (this.errorHandler ? this.errorHandler.classifyError(lastError) : 'unknown') : 'unknown';
             while (attempt < maxAttempts) {
                 attempt++;
@@ -1960,6 +2058,11 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 clearInterval(this._activeKeepaliveTimer);
                 this._activeKeepaliveTimer = null;
             }
+            // Clear reconnect safety net
+            if (this._reconnectSafetyNet) {
+                clearInterval(this._reconnectSafetyNet);
+                this._reconnectSafetyNet = null;
+            }
             // clear credential refresh timer
             if (this._mqttAuthRefreshTimer) {
                 try {
@@ -2102,5 +2205,80 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             this.realtimeDebug('[ACTIVE_QUERY] could not start keepalive timer:', e?.message || e);
         }
     }
+    /**
+     * ensureOnline()
+     *  - fixes the classic "idle -> socket half-dead -> sends fail" issue
+     *  - pings the broker; if ping fails/timeouts, triggers a safe reconnect and waits until connected
+     */
+    async ensureOnline(options = {}) {
+        const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 15000;
+        const pingTimeoutMs = typeof options.pingTimeoutMs === 'number' ? options.pingTimeoutMs : 7000;
+        if (this.safeDisconnect) {
+            throw new Error('RealtimeClient is in safeDisconnect state');
+        }
+        // If a connect/reconnect is already happening, just wait for it
+        if (this._connectInProgress || this._reconnectInProgress) {
+            await this._waitForConnected(timeoutMs);
+            return true;
+        }
+        // If we are not connected, reconnect and wait
+        if (!this._mqtt || !this._mqttConnected) {
+            try {
+                await this._attemptReconnectSafely();
+            } catch (e) { /* ignore */ }
+            await this._waitForConnected(timeoutMs);
+            return true;
+        }
+        // If we are connected, do a lightweight ping to detect half-dead sockets
+        if (this._mqtt && typeof this._mqtt.ping === 'function') {
+            try {
+                await Promise.race([
+                    this._mqtt.ping(),
+                    this._delay(pingTimeoutMs).then(() => { throw new Error('mqtt.ping timeout'); })
+                ]);
+                this._lastMessageAt = Date.now();
+                this._lastServerTrafficAt = Date.now();
+                return true;
+            } catch (e) {
+                // Ping failed -> force reconnect
+                this.realtimeDebug('[ensureOnline] ping failed -> reconnect', e?.message || e);
+                this._mqttConnected = false;
+                try { await this._attemptReconnectSafely(e); } catch (re) { /* ignore */ }
+                await this._waitForConnected(timeoutMs);
+                return true;
+            }
+        }
+        return true;
+    }
+    _delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    _waitForConnected(timeoutMs) {
+        return new Promise((resolve, reject) => {
+            if (this._mqttConnected) return resolve(true);
+            let done = false;
+            const finishOk = () => {
+                if (done) return;
+                done = true;
+                cleanup();
+                resolve(true);
+            };
+            const finishErr = (err) => {
+                if (done) return;
+                done = true;
+                cleanup();
+                reject(err);
+            };
+            const timer = setTimeout(() => finishErr(new Error('Timed out waiting for MQTT connection')), timeoutMs);
+            const cleanup = () => {
+                try { clearTimeout(timer); } catch (_) { }
+                try { this.off('connected', finishOk); } catch (_) { }
+                try { this.off('mqtt_connected', finishOk); } catch (_) { }
+            };
+            try { this.on('connected', finishOk); } catch (_) { }
+            try { this.on('mqtt_connected', finishOk); } catch (_) { }
+        });
+    }
+
 }
 exports.RealtimeClient = RealtimeClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqt",
-  "version": "1.3.92",
+  "version": "1.4.1",
   "description": "Complete Instagram MQTT protocol with full-featured REALTIME and REST API — all in one project.",
 
   "main": "dist/dist/index.js",