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

package/dist/dist/mqttot/mqttot.client.js

@@ -61,7 +61,7 @@ class MQTToTClient extends mqtts_1.MqttClient {
         // Register listeners (errors, disconnect, pingresps, etc.)
         this.registerListeners();
         this.requirePayload = options.requirePayload;
-        this._keepaliveMs = (typeof options.keepaliveMs === 'number') ? options.keepaliveMs : (45 * 1000);
+        this._keepaliveMs = (typeof options.keepaliveMs === 'number') ? options.keepaliveMs : (8 * 60 * 1000);
         this._consecutivePingFailures = 0;
         this._startKeepalive();
     }
@@ -69,7 +69,7 @@ class MQTToTClient extends mqtts_1.MqttClient {
         try {
             if (this._keepaliveTimer)
                 clearInterval(this._keepaliveTimer);
-            const jitter = Math.floor(Math.random() * 5000);
+            const jitter = Math.floor(Math.random() * 30000);
             this._keepaliveTimer = setInterval(() => {
                 try {
                     if (typeof this.ping === 'function') {
@@ -147,7 +147,7 @@ class MQTToTClient extends mqtts_1.MqttClient {
                     return;
                 }
                 let delay = 3000 + Math.floor(Math.random() * 2000);
-                const maxAttempts = 999;
+                const maxAttempts = 12;
                 for (let attempt = 0; attempt < maxAttempts; attempt++) {
                     try {
                         this.mqttotDebug(`Reconnect attempt #${attempt + 1} (delay ${delay}ms)`);

package/dist/dist/realtime/features/error-handler.js

@@ -30,7 +30,7 @@ class ErrorHandler {
     constructor(client) {
         this.errorDebug = (0, shared_1.debugChannel)('realtime', 'errors');
         this.errorCount = 0;
-        this.maxRetries = 999;
+        this.maxRetries = 15;
         this.client = client;
         this.errorHistory = [];
         this.rateLimitUntil = 0;

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');
@@ -2165,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.93",
+  "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",