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

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/commands/direct.commands.js

@@ -5,6 +5,58 @@ const constants_1 = require("../../constants");
 const shared_1 = require("../../shared");
 const Chance = require("chance");
 const thrift_1 = require("../../thrift");
+
+/**
+ * SerialQueue — Coadă strict serială cu retry și exponential backoff.
+ * Folosită per-thread pentru a serializa operațiile MQTT și a preveni
+ * race conditions și mesaje pierdute la reconectare.
+ */
+class SerialQueue {
+    constructor(name) {
+        this.name = name;
+        this.queue = [];
+        this.running = false;
+    }
+    enqueue(label, fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ label, fn, resolve, reject, retries: 0 });
+            this._tick();
+        });
+    }
+    _tick() {
+        if (this.running || this.queue.length === 0) return;
+        this.running = true;
+        this._processNext();
+    }
+    async _processNext() {
+        const MAX_RETRIES = 3;
+        const BASE_DELAY_MS = 500;
+        const item = this.queue[0];
+        if (!item) { this.running = false; return; }
+        try {
+            const result = await item.fn();
+            this.queue.shift();
+            item.resolve(result);
+        } catch (err) {
+            if (item.retries < MAX_RETRIES) {
+                item.retries++;
+                const delay = BASE_DELAY_MS * Math.pow(2, item.retries - 1);
+                console.warn(`[Queue:${this.name}] "${item.label}" failed (try ${item.retries}/${MAX_RETRIES}), retry in ${delay}ms:`, err && err.message || err);
+                await new Promise(r => setTimeout(r, delay));
+            } else {
+                console.error(`[Queue:${this.name}] "${item.label}" failed after ${MAX_RETRIES} retries:`, err && err.message || err);
+                this.queue.shift();
+                item.reject(err);
+            }
+        }
+        if (this.queue.length > 0) {
+            this._processNext();
+        } else {
+            this.running = false;
+        }
+    }
+}
+
 class DirectCommands {
     constructor(client) {
         this.directDebug = (0, shared_1.debugChannel)('realtime', 'direct');
@@ -20,23 +72,38 @@ class DirectCommands {
         ];
         this.client = client;
         this.chance = new Chance();
+        // Coadă per-thread pentru operații MQTT
+        this._threadQueues = new Map();
+        // Coadă globală pentru operații non-thread (ex: foreground state)
+        this._globalQueue = new SerialQueue('direct:global');
+    }
+
+    /** Returnează (sau creează) coada pentru un threadId specific */
+    _getThreadQueue(threadId) {
+        if (!this._threadQueues.has(threadId)) {
+            this._threadQueues.set(threadId, new SerialQueue(`direct:${threadId}`));
+        }
+        return this._threadQueues.get(threadId);
     }
+
     async sendForegroundState(state) {
         this.directDebug(`Updated foreground state: ${JSON.stringify(state)}`);
-        return this.client
-            .publish({
-            topic: constants_1.Topics.FOREGROUND_STATE.id,
-            payload: await (0, shared_1.compressDeflate)(Buffer.concat([Buffer.alloc(1, 0), (0, thrift_1.thriftWriteFromObject)(state, this.foregroundStateConfig)])),
-            qosLevel: 1,
-        })
-            .then(res => {
-            // updating the keepAlive to match the shared value
-            if ((0, shared_1.notUndefined)(state.keepAliveTimeout)) {
-                this.client.keepAlive = state.keepAliveTimeout;
-            }
-            return res;
-        });
-    }
+        return this._globalQueue.enqueue('sendForegroundState', async () => {
+            return this.client
+                .publish({
+                topic: constants_1.Topics.FOREGROUND_STATE.id,
+                payload: await (0, shared_1.compressDeflate)(Buffer.concat([Buffer.alloc(1, 0), (0, thrift_1.thriftWriteFromObject)(state, this.foregroundStateConfig)])),
+                qosLevel: 1,
+            })
+                .then(res => {
+                if ((0, shared_1.notUndefined)(state.keepAliveTimeout)) {
+                    this.client.keepAlive = state.keepAliveTimeout;
+                }
+                return res;
+            });
+        });
+    }
+
     async sendCommand({ action, data, threadId, clientContext, }) {
         if (clientContext) {
             data.client_context = clientContext;
@@ -46,12 +113,16 @@ class DirectCommands {
             thread_id: threadId,
             ...data,
         });
-        return this.client.publish({
-            topic: constants_1.Topics.SEND_MESSAGE.id,
-            qosLevel: 1,
-            payload: await (0, shared_1.compressDeflate)(json),
+        const q = this._getThreadQueue(threadId);
+        return q.enqueue(action, async () => {
+            return this.client.publish({
+                topic: constants_1.Topics.SEND_MESSAGE.id,
+                qosLevel: 1,
+                payload: await (0, shared_1.compressDeflate)(json),
+            });
         });
     }
+
     async sendItem({ threadId, itemType, data, clientContext }) {
         return this.sendCommand({
             action: 'send_item',

package/dist/dist/realtime/commands/enhanced.direct.commands.js

@@ -5,6 +5,57 @@ const shared_1 = require("../../shared");
 const uuid_1 = require("uuid");
 const constants_1 = require("../../constants");
 const thrift_1 = require("../../thrift");
+
+/**
+ * SerialQueue — Coadă strict serială cu retry și exponential backoff.
+ * Folosită per-thread pentru a serializa operațiile MQTT și a preveni
+ * race conditions și mesaje pierdute la reconectare.
+ */
+class SerialQueue {
+    constructor(name) {
+        this.name = name;
+        this.queue = [];
+        this.running = false;
+    }
+    enqueue(label, fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ label, fn, resolve, reject, retries: 0 });
+            this._tick();
+        });
+    }
+    _tick() {
+        if (this.running || this.queue.length === 0) return;
+        this.running = true;
+        this._processNext();
+    }
+    async _processNext() {
+        const MAX_RETRIES = 3;
+        const BASE_DELAY_MS = 500;
+        const item = this.queue[0];
+        if (!item) { this.running = false; return; }
+        try {
+            const result = await item.fn();
+            this.queue.shift();
+            item.resolve(result);
+        } catch (err) {
+            if (item.retries < MAX_RETRIES) {
+                item.retries++;
+                const delay = BASE_DELAY_MS * Math.pow(2, item.retries - 1);
+                console.warn(`[Queue:${this.name}] "${item.label}" failed (try ${item.retries}/${MAX_RETRIES}), retry in ${delay}ms:`, err && err.message || err);
+                await new Promise(r => setTimeout(r, delay));
+            } else {
+                console.error(`[Queue:${this.name}] "${item.label}" failed after ${MAX_RETRIES} retries:`, err && err.message || err);
+                this.queue.shift();
+                item.reject(err);
+            }
+        }
+        if (this.queue.length > 0) {
+            this._processNext();
+        } else {
+            this.running = false;
+        }
+    }
+}
 /**
  * EnhancedDirectCommands
  *
@@ -32,6 +83,17 @@ class EnhancedDirectCommands {
             thrift_1.ThriftDescriptors.listOfBinary('unsubscribeGenericTopics', 7),
             thrift_1.ThriftDescriptors.int64('requestId', 8),
         ];
+        // Coadă per-thread pentru operații MQTT
+        this._threadQueues = new Map();
+        // Coadă globală pentru operații non-thread (ex: foreground state)
+        this._globalQueue = new SerialQueue('enhanced:global');
+    }
+    /** Returnează (sau creează) coada pentru un threadId specific */
+    _getThreadQueue(threadId) {
+        if (!this._threadQueues.has(threadId)) {
+            this._threadQueues.set(threadId, new SerialQueue(`enhanced:${threadId}`));
+        }
+        return this._threadQueues.get(threadId);
     }
     /**
      * Attempt to locate the MQTT client object on the realtime client.
@@ -132,62 +194,66 @@ class EnhancedDirectCommands {
     }
     /**
      * Send foreground state via MQTT with Thrift encoding (matching instagram_mqtt)
+     * Folosește coada globală — nu depinde de un thread specific.
      */
     async sendForegroundState(state) {
         this.enhancedDebug(`Updated foreground state: ${JSON.stringify(state)}`);
-        try {
-            const mqtt = this.getMqtt();
-            const thriftBuffer = (0, thrift_1.thriftWriteFromObject)(state, this.foregroundStateConfig);
-            const concat = Buffer.concat([
-                Buffer.alloc(1, 0),
-                thriftBuffer
-            ]);
-            // ensure we pass Buffer to compressDeflate
-            const payload = await (0, shared_1.compressDeflate)(concat);
-            const result = await this.publishToMqtt(mqtt, {
-                topic: constants_1.Topics.FOREGROUND_STATE.id,
-                payload: payload,
-                qosLevel: 1,
-            });
-            // Update keepAlive if provided
-            if ((0, shared_1.notUndefined)(state.keepAliveTimeout)) {
-                mqtt.keepAlive = state.keepAliveTimeout;
+        return this._globalQueue.enqueue('sendForegroundState', async () => {
+            try {
+                const mqtt = this.getMqtt();
+                const thriftBuffer = (0, thrift_1.thriftWriteFromObject)(state, this.foregroundStateConfig);
+                const concat = Buffer.concat([
+                    Buffer.alloc(1, 0),
+                    thriftBuffer
+                ]);
+                const payload = await (0, shared_1.compressDeflate)(concat);
+                const result = await this.publishToMqtt(mqtt, {
+                    topic: constants_1.Topics.FOREGROUND_STATE.id,
+                    payload: payload,
+                    qosLevel: 1,
+                });
+                if ((0, shared_1.notUndefined)(state.keepAliveTimeout)) {
+                    mqtt.keepAlive = state.keepAliveTimeout;
+                }
+                this.enhancedDebug(`✅ Foreground state updated via MQTT!`);
+                return result;
             }
-            this.enhancedDebug(`✅ Foreground state updated via MQTT!`);
-            return result;
-        }
-        catch (err) {
-            this.enhancedDebug(`Foreground state failed: ${err && err.message ? err.message : String(err)}`);
-            throw err;
-        }
+            catch (err) {
+                this.enhancedDebug(`Foreground state failed: ${err && err.message ? err.message : String(err)}`);
+                throw err;
+            }
+        });
     }
     /**
      * Base command sender (matching instagram_mqtt format)
      * It encodes the command as JSON, compresses, and publishes to SEND_MESSAGE topic.
+     * All operations are serialized per-thread via SerialQueue. 
      */
     async sendCommand({ action, data, threadId, clientContext }) {
-        try {
-            const mqtt = this.getMqtt();
-            if (clientContext) {
-                data.client_context = clientContext;
-            }
-            const json = JSON.stringify({
-                action,
-                thread_id: threadId,
-                ...data,
-            });
-            // ensure Buffer (some compress implementations expect Buffer)
-            const payload = await (0, shared_1.compressDeflate)(Buffer.from(json));
-            return this.publishToMqtt(mqtt, {
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-        }
-        catch (err) {
-            this.enhancedDebug(`sendCommand failed: ${err && err.message ? err.message : String(err)}`);
-            throw err;
+        if (clientContext) {
+            data.client_context = clientContext;
         }
+        const json = JSON.stringify({
+            action,
+            thread_id: threadId,
+            ...data,
+        });
+        const q = this._getThreadQueue(threadId);
+        return q.enqueue(action, async () => {
+            try {
+                const mqtt = this.getMqtt();
+                const payload = await (0, shared_1.compressDeflate)(Buffer.from(json));
+                return this.publishToMqtt(mqtt, {
+                    topic: constants_1.Topics.SEND_MESSAGE.id,
+                    qosLevel: 1,
+                    payload: payload,
+                });
+            }
+            catch (err) {
+                this.enhancedDebug(`sendCommand failed: ${err && err.message ? err.message : String(err)}`);
+                throw err;
+            }
+        });
     }
     /**
      * Base item sender (matching instagram_mqtt format)

package/dist/dist/realtime/features/dm-sender.js

@@ -3,14 +3,78 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DMSender = void 0;
 const shared_1 = require("../../shared");
 const uuid_1 = require("uuid");
+
+/**
+ *SerialQueue — Strictly serial queue with retry and exponential backoff.
+ * Used per-thread to serialize MQTT operations and prevent
+ * Race conditions and messages lost when reconnecting. 
+ */
+class SerialQueue {
+    constructor(name) {
+        this.name = name;
+        this.queue = [];
+        this.running = false;
+    }
+    enqueue(label, fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ label, fn, resolve, reject, retries: 0 });
+            this._tick();
+        });
+    }
+    _tick() {
+        if (this.running || this.queue.length === 0) return;
+        this.running = true;
+        this._processNext();
+    }
+    async _processNext() {
+        const MAX_RETRIES = 3;
+        const BASE_DELAY_MS = 500;
+        const item = this.queue[0];
+        if (!item) { this.running = false; return; }
+        try {
+            const result = await item.fn();
+            this.queue.shift();
+            item.resolve(result);
+        } catch (err) {
+            if (item.retries < MAX_RETRIES) {
+                item.retries++;
+                const delay = BASE_DELAY_MS * Math.pow(2, item.retries - 1);
+                console.warn(`[Queue:${this.name}] "${item.label}" failed (try ${item.retries}/${MAX_RETRIES}), retry in ${delay}ms:`, err && err.message || err);
+                await new Promise(r => setTimeout(r, delay));
+            } else {
+                console.error(`[Queue:${this.name}] "${item.label}" failed after ${MAX_RETRIES} retries:`, err && err.message || err);
+                this.queue.shift();
+                item.reject(err);
+            }
+        }
+        if (this.queue.length > 0) {
+            this._processNext();
+        } else {
+            this.running = false;
+        }
+    }
+}
+
 /**
  * Direct Message Sender via MQTT
+ * All operations are serialized per-thread via SerialQueue.
  */
 class DMSender {
     constructor(client) {
         this.dmDebug = (0, shared_1.debugChannel)('realtime', 'dm-sender');
         this.client = client;
+         //Per-thread queue for DM operations 
+        this._threadQueues = new Map();
     }
+
+    /** Returns (or creates) the queue for a specific threadId */ 
+    _getThreadQueue(threadId) {
+        if (!this._threadQueues.has(threadId)) {
+            this._threadQueues.set(threadId, new SerialQueue(`dm-sender:${threadId}`));
+        }
+        return this._threadQueues.get(threadId);
+    }
+
     /**
      * Send text message via MQTT
      */
@@ -24,18 +88,22 @@ class DMSender {
             timestamp: Date.now(),
             client_context: clientContext || (0, uuid_1.v4)(),
         };
-        try {
-            return await this.client.directCommands?.sendCommand({
-                action: 'send_item',
-                data: command,
-                threadId,
-            });
-        }
-        catch (err) {
-            this.dmDebug(`Failed to send message: ${err.message}`);
-            throw err;
-        }
+        const q = this._getThreadQueue(threadId);
+        return q.enqueue('sendTextMessage', async () => {
+            try {
+                return await this.client.directCommands?.sendCommand({
+                    action: 'send_item',
+                    data: command,
+                    threadId,
+                });
+            }
+            catch (err) {
+                this.dmDebug(`Failed to send message: ${err.message}`);
+                throw err;
+            }
+        });
     }
+
     /**
      * Send media message via MQTT (photo/video)
      */
@@ -49,18 +117,22 @@ class DMSender {
             timestamp: Date.now(),
             client_context: clientContext || (0, uuid_1.v4)(),
         };
-        try {
-            return await this.client.directCommands?.sendCommand({
-                action: 'send_item',
-                data: command,
-                threadId,
-            });
-        }
-        catch (err) {
-            this.dmDebug(`Failed to send media: ${err.message}`);
-            throw err;
-        }
+        const q = this._getThreadQueue(threadId);
+        return q.enqueue('sendMediaMessage', async () => {
+            try {
+                return await this.client.directCommands?.sendCommand({
+                    action: 'send_item',
+                    data: command,
+                    threadId,
+                });
+            }
+            catch (err) {
+                this.dmDebug(`Failed to send media: ${err.message}`);
+                throw err;
+            }
+        });
     }
+
     /**
      * Send link message
      */
@@ -75,17 +147,20 @@ class DMSender {
             timestamp: Date.now(),
             client_context: clientContext || (0, uuid_1.v4)(),
         };
-        try {
-            return await this.client.directCommands?.sendCommand({
-                action: 'send_item',
-                data: command,
-                threadId,
-            });
-        }
-        catch (err) {
-            this.dmDebug(`Failed to send link: ${err.message}`);
-            throw err;
-        }
+        const q = this._getThreadQueue(threadId);
+        return q.enqueue('sendLinkMessage', async () => {
+            try {
+                return await this.client.directCommands?.sendCommand({
+                    action: 'send_item',
+                    data: command,
+                    threadId,
+                });
+            }
+            catch (err) {
+                this.dmDebug(`Failed to send link: ${err.message}`);
+                throw err;
+            }
+        });
     }
 }
 exports.DMSender = DMSender;

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.2",
   "description": "Complete Instagram MQTT protocol with full-featured REALTIME and REST API — all in one project.",
 
   "main": "dist/dist/index.js",