nodejs-insta-private-api-mqtt 1.3.20 → 1.3.22

package/dist/mqtt-shim.js

@@ -34,34 +34,56 @@ class IllegalStateError extends Error {
 
 class PacketStream {
   constructor(buffer) {
-    this.buffer = buffer;
+    this.buffer = buffer || Buffer.alloc(0);
     this.offset = 0;
   }
-  readByte() { 
-      if (this.offset >= this.buffer.length) return 0;
-      return this.buffer[this.offset++]; 
+  readByte() {
+      if (this.offset >= this.buffer.length) throw new Error('Unexpected end of stream');
+      return this.buffer[this.offset++];
   }
   readStringAsBuffer() {
     const len = this.readWord();
-    if (this.offset + len > this.buffer.length) return Buffer.alloc(0);
+    if (this.offset + len > this.buffer.length) throw new Error('Unexpected end of stream');
     const buf = this.buffer.slice(this.offset, this.offset + len);
     this.offset += len;
     return buf;
   }
   readWord() {
-    if (this.offset + 2 > this.buffer.length) return 0;
+    if (this.offset + 2 > this.buffer.length) throw new Error('Unexpected end of stream');
     const w = this.buffer.readUInt16BE(this.offset);
     this.offset += 2;
     return w;
   }
+  readRemaining() {
+    const buf = this.buffer.slice(this.offset);
+    this.offset = this.buffer.length;
+    return buf;
+  }
 }
 
 class PacketWriter {
     constructor() { this.chunks = []; }
     writeByte(b) { const buf = Buffer.alloc(1); buf.writeUInt8(b); this.chunks.push(buf); return this; }
     writeWord(w) { const buf = Buffer.alloc(2); buf.writeUInt16BE(w); this.chunks.push(buf); return this; }
-    writeString(s) { this.writeWord(s.length); this.chunks.push(Buffer.from(s)); return this; }
-    write(buf) { this.chunks.push(buf); return this; }
+    writeString(s) {
+        if (Buffer.isBuffer(s)) {
+            this.writeWord(s.length);
+            this.chunks.push(s);
+        } else {
+            const str = String(s || '');
+            const b = Buffer.from(str);
+            this.writeWord(b.length);
+            this.chunks.push(b);
+        }
+        return this;
+    }
+    write(buf) { 
+        if (!buf) return this;
+        if (Buffer.isBuffer(buf)) this.chunks.push(buf);
+        else if (typeof buf === 'string') this.chunks.push(Buffer.from(buf));
+        else if (buf instanceof Uint8Array) this.chunks.push(Buffer.from(buf));
+        return this; 
+    }
     toBuffer() { return Buffer.concat(this.chunks); }
 }
 
@@ -76,7 +98,39 @@ class MqttClient extends EventEmitter {
     this.packetIdCounter = 1;
     this.pendingPublishes = new Map(); // PacketID -> {resolve, reject, timer}
     this.pingTimer = null;
-    this.keepAliveInterval = 60000;
+    this.keepAliveInterval = 30000;
+    this.recvBuffer = Buffer.alloc(0); // buffer pentru date primite (concatenează fragmente)
+    this._defaultReadMapInstalled = false;
+
+    // install defaults if user didn't provide
+    this._installDefaultReadMap();
+  }
+
+  _installDefaultReadMap() {
+    if (this._defaultReadMapInstalled) return;
+    // Only set a default ConnAck reader if user did not provide one
+    if (!this.readMap[PacketType.ConnAck]) {
+        this.readMap[PacketType.ConnAck] = (stream, length) => {
+            // read ackFlags and returnCode (minimum)
+            // Accept extra payload (Instagram often sends extra bytes)
+            let ackFlags = 0;
+            let returnCode = 255;
+            try {
+                ackFlags = stream.readByte();
+            } catch (e) {
+                throw new Error('Invalid CONNACK: missing ackFlags');
+            }
+            try {
+                returnCode = stream.readByte();
+            } catch (e) {
+                throw new Error('Invalid CONNACK: missing returnCode');
+            }
+            // remaining bytes as payload (could be protobuf or other)
+            const extra = stream.readRemaining();
+            return new ConnectResponsePacket(ackFlags, returnCode, extra);
+        };
+    }
+    this._defaultReadMapInstalled = true;
   }
 
   getNextPacketId() {
@@ -104,7 +158,7 @@ class MqttClient extends EventEmitter {
                          ...this.options, 
                          ...connectOpts,
                          payload: this.connectPayload || connectOpts.payload, 
-                         keepAlive: 60 
+                         keepAlive: 30 
                      });
                      const packetData = writer.toBuffer();
                      let remLen = packetData.length;
@@ -116,7 +170,12 @@ class MqttClient extends EventEmitter {
                          fixedHeader.push(byte);
                      } while (remLen > 0);
                      
-                     this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
+                     // Ensure socket writable
+                     if (this.socket && !this.socket.destroyed && this.socket.writable) {
+                         this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
+                     } else {
+                         this.emit('error', new Error('Socket not writable when sending CONNECT'));
+                     }
                  } else {
                      this.emit('error', new Error('No write handler for CONNECT'));
                  }
@@ -158,6 +217,9 @@ class MqttClient extends EventEmitter {
                 this.socket = tls.connect(port, host, { rejectUnauthorized: true }, onConnect);
             }
 
+            // reset recvBuffer on new socket
+            this.recvBuffer = Buffer.alloc(0);
+
             this.socket.on('data', (data) => this._handleData(data));
             this.socket.on('error', (err) => {
                 this._clearPingTimer();
@@ -168,6 +230,7 @@ class MqttClient extends EventEmitter {
                 this.emit('disconnect');
             });
             
+            // resolve when connect_success event fired (this is triggered by parsing CONNACK)
             this.once('connect_success', resolve);
         } catch (e) {
             reject(e);
@@ -178,8 +241,12 @@ class MqttClient extends EventEmitter {
   _setupPingTimer() {
       this._clearPingTimer();
       this.pingTimer = setInterval(() => {
-          if (this.socket && !this.socket.destroyed) {
-              this.socket.write(Buffer.from([0xC0, 0x00])); // PINGREQ (12 << 4), Length 0
+          if (this.socket && !this.socket.destroyed && this.socket.writable) {
+              try {
+                  this.socket.write(Buffer.from([0xC0, 0x00])); // PINGREQ (12 << 4), Length 0
+              } catch (e) {
+                  // ignore write errors here, they'll be handled by socket 'error'
+              }
           }
       }, this.keepAliveInterval);
   }
@@ -189,60 +256,140 @@ class MqttClient extends EventEmitter {
       this.pingTimer = null;
   }
 
+  /**
+   * Robust handler that collects incoming chunks into recvBuffer
+   * and parses complete MQTT frames. Handles variable Remaining Length
+   * encoding and fragmentation across TCP/TLS boundaries.
+   */
   _handleData(data) {
-      let offset = 0;
-      while(offset < data.length) {
-          const first = data[offset++];
-          const type = first >> 4;
+      // concat incoming chunk
+      this.recvBuffer = Buffer.concat([this.recvBuffer, data]);
+
+      // parse as many full packets as present
+      while (this.recvBuffer.length > 0) {
+          // need at least 2 bytes (1 for fixed header, at least 1 for remaining length byte)
+          if (this.recvBuffer.length < 2) break;
+
+          // first byte
+          const first = this.recvBuffer[0];
+          // parse Remaining Length (variable bytes, max 4)
           let multiplier = 1;
-          let length = 0;
+          let value = 0;
+          let remLenBytes = 0;
+          let i = 1;
           let digit;
+          let incomplete = false;
           do {
-             if (offset >= data.length) break;
-             digit = data[offset++];
-             length += (digit & 127) * multiplier;
-             multiplier *= 128;
+              if (i >= this.recvBuffer.length) { incomplete = true; break; } // waiting for more bytes
+              digit = this.recvBuffer[i++];
+              remLenBytes++;
+              value += (digit & 127) * multiplier;
+              multiplier *= 128;
+              if (remLenBytes > 4) {
+                  // malformed remaining length
+                  this.emit('error', new Error('Malformed Remaining Length'));
+                  return;
+              }
           } while ((digit & 128) !== 0);
-          
-          if (offset + length > data.length) break; 
-          
-          const payload = data.slice(offset, offset + length);
-          offset += length;
-          
-          if (type === PacketType.ConnAck) {
-             const readFunc = this.readMap[PacketType.ConnAck];
-             if (readFunc) {
-                 const stream = new PacketStream(payload);
-                 const packet = readFunc(stream, length);
-                 if (packet.isSuccess) this.emit('connect_success');
-                 this.emit('connect', { payload: packet.payload });
-             }
-          } else if (type === PacketType.Publish) {
-              try {
-                  const topicLen = payload.readUInt16BE(0);
-                  const topic = payload.slice(2, 2 + topicLen).toString();
-                  const qos = (first & 0x06) >> 1;
-                  let msgPayload;
-                  if (qos > 0) {
-                      // Skip Packet ID (2 bytes)
-                      msgPayload = payload.slice(2 + topicLen + 2);
-                  } else {
-                      msgPayload = payload.slice(2 + topicLen);
+
+          if (incomplete) break; // wait more data
+
+          const headerLen = 1 + remLenBytes;
+          const totalLen = headerLen + value;
+
+          if (this.recvBuffer.length < totalLen) break; // wait full packet
+
+          // we have a full packet: extract it
+          const packet = this.recvBuffer.slice(0, totalLen);
+          // payload starts after headerLen
+          const payload = packet.slice(headerLen, totalLen);
+
+          // remove processed packet from buffer
+          this.recvBuffer = this.recvBuffer.slice(totalLen);
+
+          const type = first >> 4;
+
+          try {
+              if (type === PacketType.ConnAck) {
+                 const readFunc = this.readMap[PacketType.ConnAck];
+                 if (readFunc) {
+                     const stream = new PacketStream(payload);
+                     let packetObj;
+                     try {
+                         packetObj = readFunc(stream, value);
+                     } catch (e) {
+                         // If parser throws, emit error but continue parsing other packets
+                         this.emit('error', e);
+                         continue;
+                     }
+                     // Only emit success if return code indicates success
+                     if (packetObj && packetObj.isSuccess) {
+                         this.emit('connect_success');
+                     } else if (packetObj && !packetObj.isSuccess) {
+                         // emit error so upper layers can react
+                         this.emit('error', new Error(packetObj.errorName || 'Connection refused'));
+                     }
+                     // emit connect event with raw payload (so caller can inspect extra data)
+                     this.emit('connect', { payload: packetObj ? packetObj.payload : payload });
+                 } else {
+                     // no read handler, just emit raw connect
+                     this.emit('connect', { payload });
+                 }
+              } else if (type === PacketType.Publish) {
+                  try {
+                      // parse topic length safely
+                      if (payload.length < 2) throw new Error('Publish payload too small for topic length');
+                      const topicLen = payload.readUInt16BE(0);
+                      if (payload.length < 2 + topicLen) throw new Error('Publish payload too small for topic');
+                      const topic = payload.slice(2, 2 + topicLen).toString();
+                      const qos = (first & 0x06) >> 1;
+                      let msgPayload;
+                      if (qos > 0) {
+                          // Skip Packet ID (2 bytes)
+                          msgPayload = payload.slice(2 + topicLen + 2);
+                      } else {
+                          msgPayload = payload.slice(2 + topicLen);
+                      }
+                      this.emit('message', { topic, payload: msgPayload, qosLevel: qos });
+                  } catch (e) {
+                      // ignore malformed publish frames but emit error
+                      this.emit('error', e);
                   }
-                  this.emit('message', { topic, payload: msgPayload, qosLevel: qos });
-              } catch (e) {}
-          } else if (type === PacketType.PubAck) {
-              // Handle PubAck (QoS 1)
-              if (payload.length >= 2) {
-                  const packetId = payload.readUInt16BE(0);
-                  const pending = this.pendingPublishes.get(packetId);
-                  if (pending) {
-                      pending.resolve();
-                      this.pendingPublishes.delete(packetId);
+              } else if (type === PacketType.PubAck) {
+                  // Handle PubAck (QoS 1)
+                  if (payload.length >= 2) {
+                      const packetId = payload.readUInt16BE(0);
+                      const pending = this.pendingPublishes.get(packetId);
+                      if (pending) {
+                          // clear timeout if present
+                          if (pending.timer) clearTimeout(pending.timer);
+                          pending.resolve();
+                          this.pendingPublishes.delete(packetId);
+                      }
+                  }
+              } else if (type === PacketType.PingResp) {
+                  // Pong received, good
+                  // no-op
+              } else if (type === PacketType.SubAck) {
+                  // for completeness - user can provide readMap[SubAck] if needed
+                  const readFunc = this.readMap[PacketType.SubAck];
+                  if (readFunc) {
+                      try {
+                          readFunc(new PacketStream(payload), payload.length);
+                      } catch (e) { this.emit('error', e); }
+                  }
+              } else {
+                  // Unknown packet type - ignore or let readMap handle if provided
+                  const readFunc = this.readMap[type];
+                  if (readFunc) {
+                      try {
+                          readFunc(new PacketStream(payload), payload.length);
+                      } catch (e) { this.emit('error', e); }
                   }
               }
-          } else if (type === PacketType.PingResp) {
-              // Pong received, good
+          } catch (e) {
+              // catch-any to avoid breaking parse loop
+              this.emit('error', e);
           }
       }
   }
@@ -272,14 +419,16 @@ class MqttClient extends EventEmitter {
           try {
               this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
               if (msg.qosLevel > 0) {
-                  this.pendingPublishes.set(packetId, { resolve, reject });
-                  // Timeout fallback for ack?
-                  setTimeout(() => {
+                  // set timeout for ack
+                  const timer = setTimeout(() => {
                       if (this.pendingPublishes.has(packetId)) {
+                           const pending = this.pendingPublishes.get(packetId);
                            this.pendingPublishes.delete(packetId);
-                           resolve(); // Resolve anyway to not block logic
+                           // reject rather than resolve silently - let caller handle retry
+                           pending.reject(new Error('PubAck timeout'));
                       }
                   }, 5000);
+                  this.pendingPublishes.set(packetId, { resolve, reject, timer });
               } else {
                   resolve();
               }

package/dist/realtime/realtime.client.js

@@ -445,6 +445,81 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         
         this.emit('connected');
         
+        // -------------------- WATCHDOG / KEEPALIVE / TRAFFIC MONITOR --------------------
+        // Track last message time for inactivity detection
+        try {
+            this._lastMessageAt = Date.now();
+
+            // update on common receive events
+            const updateLast = () => { try { this._lastMessageAt = Date.now(); } catch (e) {} };
+            this.on('receive', updateLast);
+            this.on('receiveRaw', updateLast);
+            this.on('message', updateLast);
+            this.on('iris', updateLast);
+
+            // Timings configurable via initOptions (fallback sensible defaults)
+            const KEEPALIVE_FOREGROUND_MS = (this.initOptions && this.initOptions.keepaliveForegroundMs) ? this.initOptions.keepaliveForegroundMs : 30000;
+            const MESSAGE_SYNC_REFRESH_MS = (this.initOptions && this.initOptions.messageSyncRefreshMs) ? this.initOptions.messageSyncRefreshMs : 60000;
+            const TRAFFIC_INACTIVITY_MS = (this.initOptions && this.initOptions.trafficInactivityMs) ? this.initOptions.trafficInactivityMs : 90000;
+
+            // Foreground keepalive: tell server we're foreground so it keeps delivering
+            try {
+                this._foregroundTimer = setInterval(async () => {
+                    try {
+                        if (!this.commands) return;
+                        await this.commands.updateSubscriptions({
+                            topic: constants_1.Topics.PUBSUB,
+                            data: { foreground: true }
+                        });
+                        this.realtimeDebug('[WATCHDOG] Foreground keepalive sent.');
+                    } catch (e) {
+                        this.realtimeDebug('[WATCHDOG] Foreground keepalive failed:', e?.message || e);
+                    }
+                }, KEEPALIVE_FOREGROUND_MS);
+            } catch (e) {
+                this.realtimeDebug('[WATCHDOG] Could not start foreground timer:', e?.message || e);
+            }
+
+            // Periodically refresh GraphQL/message_sync subscriptions to keep server sending events
+            try {
+                this._syncTimer = setInterval(async () => {
+                    try {
+                        if (!this.commands) return;
+                        // Refresh the important graphQl subs (idempotent)
+                        const subs = (this.initOptions && this.initOptions.graphQlSubs && this.initOptions.graphQlSubs.length) ? this.initOptions.graphQlSubs : ['ig_sub_direct', 'ig_sub_direct_v2_message_sync'];
+                        await this.graphQlSubscribe(subs);
+                        this.realtimeDebug('[WATCHDOG] MESSAGE_SYNC refreshed.');
+                    } catch (e) {
+                        this.realtimeDebug('[WATCHDOG] MESSAGE_SYNC refresh failed:', e?.message || e);
+                    }
+                }, MESSAGE_SYNC_REFRESH_MS);
+            } catch (e) {
+                this.realtimeDebug('[WATCHDOG] Could not start sync timer:', e?.message || e);
+            }
+
+            // Traffic watchdog: if no messages for a while -> reconnect
+            try {
+                this._trafficWatchdog = setInterval(async () => {
+                    try {
+                        const idle = Date.now() - (this._lastMessageAt || 0);
+                        if (idle > TRAFFIC_INACTIVITY_MS) {
+                            this.realtimeDebug(`[WATCHDOG] No traffic detected for ${idle}ms -> attempting reconnect`);
+                            await this._attemptReconnectSafely();
+                        }
+                    } catch (e) {
+                        this.realtimeDebug('[WATCHDOG] trafficWatchdog fault:', e?.message || e);
+                    }
+                }, Math.min(KEEPALIVE_FOREGROUND_MS, 30000));
+            } catch (e) {
+                this.realtimeDebug('[WATCHDOG] Could not start traffic watchdog:', e?.message || e);
+            }
+
+        } catch (e) {
+            // non-fatal
+            this.realtimeDebug('[WATCHDOG] initialization error:', e?.message || e);
+        }
+        // -------------------- END WATCHDOG --------------------
+
         this._mqtt.on('message', async (msg) => {
             const topicMap = this.mqtt?.topicMap;
             const topic = topicMap?.get(msg.topic);
@@ -505,6 +580,34 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         }
         this._setupMessageHandlers();
     }
+
+    /**
+     * Internal helper to attempt a reconnect safely (debounced)
+     */
+    async _attemptReconnectSafely() {
+        if (this._reconnectInProgress) return;
+        this._reconnectInProgress = true;
+        try {
+            // try graceful disconnect if possible
+            try {
+                await (this.mqtt?.disconnect?.() ?? Promise.resolve());
+            } catch (e) {
+                // ignore
+            }
+            // small delay to ensure socket closed
+            await (0, shared_1.delay)(500);
+            // reconnect using same initOptions
+            try {
+                await this.connect(this.initOptions);
+                this.realtimeDebug('[WATCHDOG] Reconnect succeeded.');
+            } catch (e) {
+                this.realtimeDebug('[WATCHDOG] Reconnect failed:', e?.message || e);
+            }
+        } finally {
+            this._reconnectInProgress = false;
+        }
+    }
+
     /**
      * Connect from saved session using MultiFileAuthState
      * @param {Object} authStateHelper - Result from useMultiFileAuthState()
@@ -522,12 +625,51 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             this._attachedAuthState = authStateHelper;
         } catch (e) {}
 
-        const savedOptions = authStateHelper.getMqttConnectOptions?.();
-        
+        // Try to read any previously-saved connect options (may include graphQlSubs/irisData/skywalkerSubs)
+        const savedOptions = authStateHelper.getMqttConnectOptions?.() || {};
+
+        // Prefer options.irisData -> savedOptions.irisData -> freshly fetched inbox (guarantee)
+        let irisData = options.irisData || savedOptions.irisData || null;
+
+        // CRITICAL FIX: If irisData is missing, actively fetch a fresh IRIS snapshot from REST before connecting.
+        // This ensures IRIS seq_id / snapshot_at_ms are valid after restarts so the server will resume sending events.
+        // Additionally: even if savedOptions.irisData exists, we prefer to fetch a fresh snapshot to avoid using stale/expired snapshot.
+        let fetchedInbox = null;
+        const shouldForceFetch = true; // always attempt fresh fetch on saved-session connect to ensure live events
+        if (shouldForceFetch) {
+            const maxAttempts = 3;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                try {
+                    console.log(`[RealtimeClient] Attempting to fetch fresh IRIS inbox snapshot (attempt ${attempt}/${maxAttempts})...`);
+                    fetchedInbox = await this.ig.direct.getInbox();
+                    if (fetchedInbox) {
+                        irisData = fetchedInbox;
+                        console.log('[RealtimeClient] Fetched IRIS snapshot successfully.');
+                        break;
+                    }
+                } catch (e) {
+                    console.warn(`[RealtimeClient] Failed to fetch IRIS snapshot (attempt ${attempt}):`, e?.message || e);
+                }
+                // small backoff
+                try {
+                    await (0, shared_1.delay)(500 * attempt);
+                } catch (e) {}
+            }
+            if (!fetchedInbox) {
+                // If we couldn't fetch fresh inbox, fall back to savedOptions.irisData if present, otherwise proceed (connect may still work)
+                if (savedOptions.irisData) {
+                    irisData = savedOptions.irisData;
+                    console.warn('[RealtimeClient] Could not fetch fresh IRIS snapshot — falling back to saved irisData (may be stale).');
+                } else if (!irisData) {
+                    console.warn('[RealtimeClient] No IRIS snapshot available (neither fetched nor saved). Proceeding without irisData — server may not replay missed events.');
+                }
+            }
+        }
+
         const connectOptions = {
-            graphQlSubs: options.graphQlSubs || savedOptions?.graphQlSubs || ['ig_sub_direct', 'ig_sub_direct_v2_message_sync'],
-            skywalkerSubs: options.skywalkerSubs || savedOptions?.skywalkerSubs || ['presence_subscribe', 'typing_subscribe'],
-            irisData: options.irisData || savedOptions?.irisData || null,
+            graphQlSubs: options.graphQlSubs || savedOptions.graphQlSubs || ['ig_sub_direct', 'ig_sub_direct_v2_message_sync'],
+            skywalkerSubs: options.skywalkerSubs || savedOptions.skywalkerSubs || ['presence_subscribe', 'typing_subscribe'],
+            irisData,
             ...options
         };
 
@@ -576,6 +718,25 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
     }
     disconnect() {
         this.safeDisconnect = true;
+
+        // clear watchdog timers if present
+        try {
+            if (this._foregroundTimer) {
+                clearInterval(this._foregroundTimer);
+                this._foregroundTimer = null;
+            }
+            if (this._syncTimer) {
+                clearInterval(this._syncTimer);
+                this._syncTimer = null;
+            }
+            if (this._trafficWatchdog) {
+                clearInterval(this._trafficWatchdog);
+                this._trafficWatchdog = null;
+            }
+        } catch (e) {
+            // non-fatal
+        }
+
         return this.mqtt?.disconnect() ?? Promise.resolve();
     }
     graphQlSubscribe(sub) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqtt",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "Complete Instagram MQTT protocol with FULL iOS + Android support. 33 device presets (21 iOS + 12 Android). iPhone 16/15/14/13/12, iPad Pro, Samsung, Pixel, Huawei. Real-time DM messaging, view-once media extraction, sub-500ms latency.",
   "main": "dist/index.js",
   "scripts": {