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

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',
@@ -155,13 +226,26 @@ class DirectCommands {
             },
         });
     }
-    async sendTextViaRealtime(threadId, text, clientContext) {
-        return this.sendText({
+    async sendText({ text, clientContext, threadId }) {
+    const timestamp = Date.now() * 1000;
+    const messageId = `${timestamp}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    const result = await this.sendItem({
+        itemType: 'text',
+        threadId,
+        clientContext: messageId,
+        timestamp,
+        offline_threading_id: messageId,
+        data: {
             text,
-            threadId,
-            clientContext,
-        });
-    }
+        },
+        ttl: 0,
+        shh_mode: false,
+        send_attribution: 'direct_thread',
+    });
+    
+    return result;
+}
     async markAsSeen({ threadId, itemId }) {
         return this.sendCommand({
             action: 'mark_seen',

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)
@@ -206,19 +272,26 @@ class EnhancedDirectCommands {
     /**
      * Send text via MQTT
      */
-    async sendText({ text, clientContext, threadId }) {
-        this.enhancedDebug(`Sending text to ${threadId}: "${text}"`);
-        const result = await this.sendItem({
-            itemType: 'text',
-            threadId,
-            clientContext,
-            data: {
-                text,
-            },
-        });
-        this.enhancedDebug(`✅ Text sent via MQTT!`);
-        return result;
-    }
+async sendText({ text, clientContext, threadId }) {
+    const timestamp = Date.now() * 1000;
+    const messageId = `${timestamp}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    const result = await this.sendItem({
+        itemType: 'text',
+        threadId,
+        clientContext: messageId,
+        timestamp,
+        offline_threading_id: messageId,
+        data: {
+            text,
+        },
+        ttl: 0,
+        shh_mode: false,
+        send_attribution: 'direct_thread',
+    });
+    
+    return result;
+}
     /**
      * Alias for sendText
      */

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/package.json

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