nodejs-insta-private-api-mqtt 1.1.3 → 1.1.5

package/README.md

@@ -2,24 +2,15 @@ Dear users,
 First of all, when handling view-once images or videos, please make sure to save the received media in a folder such as /storage/emulated/0/Pictures/, or depending on your device's path. The photos and videos are saved correctly on your phone, but the library currently has some issues with uploading them back to Instagram. This will be resolved as soon as possible.
 I post many versions of the project because Instagram changes the protocol almost daily, if you like this project leave a star on github https://github.com/Kunboruto20/nodejs-insta-private-api.git 
 
-⚠️ IMPORTANT NOTICE
-This is an important announcement regarding the nodejs-insta-private-api library.
-The old repository and NPM package were lost and are now associated with a different NPM account.
-Starting from today, this NPM account will be the official and active source where this library will be published and maintained.
-Please make sure you are using this package from this account only to receive future updates, fixes, and support.
 
-You can subscribe to any Instagram topic in this library visit the bookstore code, it would help me a lot if you like this project and if it helps you! 
 
-If you see clones of nodejs-insta-private-api on npm don't download, it could be malicious code and you may have security issues on your Instagram accounts, always use this project or the nodejs-insta-private-api project but that's on the lost account, always use npm install nodejs-insta-private-api-mqtt in your projects 
-
-
-# nodejs-insta-private-api-mqtt
+# nodejs-insta-private-api
 
 This project implements a complete and production-ready MQTT protocol client for Instagram's real-time messaging infrastructure. Instagram uses MQTT natively for direct messages, notifications, and real-time presence updates. This library replicates that exact implementation, allowing developers to build high-performance bots and automation tools that communicate with Instagram's backend using the same protocol the official app uses.
 
 By leveraging MQTT instead of Instagram's REST API, this library achieves sub-500ms message latency, bidirectional real-time communication, and native support for notifications, presence tracking, and thread management. The implementation is reverse-engineered from Instagram's mobile app protocol and tested extensively for reliability and compatibility.
 
-## Features ( - iOS + Android Full Support)
+## Features (v5.61.11 - iOS + Android Full Support)
 
 - **NEW: FULL iOS SUPPORT** - iPhone 16/15/14/13/12 + iPad Pro/Air device emulation
 - **NEW: FULL ANDROID SUPPORT** - Samsung, Huawei, Google Pixel, OnePlus, Xiaomi, OPPO
@@ -75,7 +66,7 @@ Requires **Node.js 18 or higher**.
 
 ---
 
-## NEW: Custom Device Emulation ()
+## NEW: Custom Device Emulation (v5.60.7)
 
 **Default Device:** Samsung Galaxy S25 Ultra (Android 15) - used automatically if you don't set a custom device.
 
@@ -93,7 +84,7 @@ This feature allows you to **choose which phone model Instagram sees** when your
 The easiest way to set a custom device is using the built-in presets:
 
 ```javascript
-const { IgApiClient } = require('nodejs-insta-private-api-mqtt');
+const { IgApiClient } = require('nodejs-insta-private-api');
 
 const ig = new IgApiClient();
 
@@ -1004,7 +995,7 @@ realtime.on('message', async (data) => {
 ### Extract Media URLs Without Downloading
 
 ```javascript
-const { extractMediaUrls } = require('nodejs-insta-private-api-mqtt');
+const { extractMediaUrls } = require('nodejs-insta-private-api');
 
 realtime.on('message', async (data) => {
   const msg = data.message;

package/dist/constants/constants.js

@@ -84,16 +84,14 @@ exports.FBNS = {
     PACKAGE: 'com.instagram.android',
     APP_ID: '567310203415052',
     HOST_NAME_V6: 'mqtt-mini.facebook.com',
-    CLIENT_CAPABILITIES: 6143,
-    ENDPOINT_CAPABILITIES: 255,
+    CLIENT_CAPABILITIES: 439,
+    ENDPOINT_CAPABILITIES: 128,
     CLIENT_STACK: 3,
     PUBLISH_FORMAT: 1,
 };
 exports.REALTIME = {
     HOST_NAME_V6: 'edge-mqtt.facebook.com',
 };
-exports.APP_VERSION = '380.0.0.40.94';
-exports.APP_VERSION_CODE = '525123456';
 // TODO: exclude in release
 /* eslint @typescript-eslint/no-unused-vars: "off" */
 exports.PossibleTopics = [

package/dist/core/request.js

@@ -14,14 +14,7 @@ class Request {
       timeout: 30000,
       headers: {
         'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
-      },
-      // Modern TLS settings to bypass basic fingerprinting (Strict Instagram Fizz mimicry)
-      httpsAgent: new (require('https').Agent)({
-        ciphers: 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305',
-        honorCipherOrder: true,
-        minVersion: 'TLSv1.3', // Instagram 2026 enforces TLS 1.3
-        maxVersion: 'TLSv1.3'
-      })
+      }
     });
   }
 
@@ -208,9 +201,6 @@ class Request {
       'X-IG-Android-ID': this.client.state.deviceId,
       'Accept-Language': this.client.state.language.replace('_', '-'),
       'X-FB-HTTP-Engine': 'Liger',
-      'X-FB-Client-IP': 'True',
-      'X-FB-Server-Cluster': 'True',
-      'X-IG-Nav-Chain': 'MainFeed:FeedTimelineFragment:1',
       'Authorization': this.client.state.authorization,
       'Host': 'i.instagram.com',
       'Accept-Encoding': 'gzip, deflate',

package/dist/core/state.js

@@ -21,10 +21,8 @@ class State {
     this.language = 'en_US';
     this.timezoneOffset = String(new Date().getTimezoneOffset() * -60);
     this.radioType = 'wifi-none';
-    this.capabilitiesHeader = '3brTvw==';
+    this.capabilitiesHeader = '3brTv10=';
     this.connectionTypeHeader = 'WIFI';
-    this.clientCapabilities = 6143;
-    this.endpointCapabilities = 255;
     this.isLayoutRTL = false;
     this.adsOptOut = false;
     this.thumbnailCacheBustingValue = 1000;
@@ -37,12 +35,10 @@ class State {
 
     // ===== PLATFORM SUPPORT (iOS + Android) =====
     this.platform = 'android'; // 'android' or 'ios'
-    this.androidVersion = '15';
-    this.androidApiLevel = '35';
     this.iosVersion = '18.1';
-    this.iosAppVersion = '411.0.0';
-    this.iosAppVersionCode = '700123456';
-    this.iosDeviceModel = 'iPhone17,1'; // iPhone 16 Pro Max
+    this.iosAppVersion = '347.0.0.36.89';
+    this.iosAppVersionCode = '618023787';
+    this.iosDeviceModel = 'iPhone16,2'; // iPhone 15 Pro Max
     this.iosDeviceName = 'iPhone';
     this.iosBundleId = 'com.burbn.instagram';
 

package/dist/mqttot/mqttot.client.js

@@ -23,26 +23,12 @@ class MQTToTClient extends mqtts_1.MqttClient {
                     host: options.url,
                     port: 443,
                     proxyOptions: options.socksOptions,
-                    additionalOptions: {
-                        ...options.additionalOptions,
-                        ciphers: 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256',
-                        minVersion: 'TLSv1.3',
-                        maxVersion: 'TLSv1.3',
-                        honorCipherOrder: true,
-                        ALPNProtocols: ['h2', 'mqtt']
-                    },
+                    additionalOptions: options.additionalOptions,
                 })
                 : new mqtts_1.TlsTransport({
                     host: options.url,
                     port: 443,
-                    additionalOptions: {
-                        ...options.additionalOptions,
-                        ciphers: 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256',
-                        minVersion: 'TLSv1.3',
-                        maxVersion: 'TLSv1.3',
-                        honorCipherOrder: true,
-                        ALPNProtocols: ['h2', 'mqtt']
-                    },
+                    additionalOptions: options.additionalOptions,
                 }),
         });
         this.mqttotDebug = (msg, ...args) => (0, shared_1.debugChannel)('mqttot')(`${options.url}: ${msg}`, ...args);
@@ -114,7 +100,7 @@ function mqttotConnectFlow(payload, requirePayload) {
             type: mqtts_1.PacketType.Connect,
             options: {
                 payload,
-                keepAlive: 120,
+                keepAlive: 60,
             },
         }),
         accept: mqtts_1.isConnAck,

package/dist/mqttot/mqttot.connection.js

@@ -7,8 +7,6 @@ class MQTToTConnection {
         this.fbnsConnectionData = connectionData;
     }
     toThrift() {
-        this.fbnsConnectionData.clientCapabilities = this.fbnsConnectionData.clientCapabilities || 6143;
-        this.fbnsConnectionData.endpointCapabilities = this.fbnsConnectionData.endpointCapabilities || 255;
         return (0, thrift_1.thriftWriteFromObject)(this.fbnsConnectionData, MQTToTConnection.thriftConfig);
     }
     toString() {

package/dist/realtime/realtime.client.js

@@ -17,6 +17,9 @@ const error_handler_1 = require("./features/error-handler");
 const gap_handler_1 = require("./features/gap-handler");
 const enhanced_direct_commands_1 = require("./commands/enhanced.direct.commands");
 const presence_typing_mixin_1 = require("./mixins/presence-typing.mixin");
+const fs = require('fs');
+const path = require('path');
+
 class RealtimeClient extends eventemitter3_1.EventEmitter {
     get mqtt() {
         return this._mqtt;
@@ -35,7 +38,20 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         this.emitWarning = (e) => this.emit('warning', e);
         this.ig = ig;
         this.threads = new Map();
-        
+
+        // === New: observability & metrics ===
+        this.metrics = {
+            reconnectCount: 0,
+            messagesReceived: 0,
+            parseErrors: 0,
+            lastConnectTime: null,
+            backoffAttempts: 0,
+        };
+
+        // Session state persistence file (changeable)
+        this._sessionStateFile = path.join('.', '.mqtt_session_state.json');
+        this._sessionState = this._loadSessionState();
+
         this.irisHandshake = new iris_handshake_1.IrisHandshake(this);
         this.skywalkerProtocol = new skywalker_protocol_1.SkywalkerProtocol(this);
         this.presenceManager = new presence_manager_1.PresenceManager(this);
@@ -43,21 +59,52 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         this.errorHandler = new error_handler_1.ErrorHandler(this);
         this.gapHandler = new gap_handler_1.GapHandler(this);
         this.directCommands = new enhanced_direct_commands_1.EnhancedDirectCommands(this);
-        
+
         this.realtimeDebug(`Applying mixins: ${mixins.map(m => m.name).join(', ')}`);
         (0, mixins_1.applyMixins)(mixins, this, this.ig);
+
+        // Periodic metrics logging (only if not disabled)
+        this._metricsInterval = setInterval(() => {
+            try {
+                if (this.metrics) {
+                    this.realtimeDebug('METRICS', JSON.stringify(this.metrics));
+                }
+            } catch (e) { }
+        }, 60 * 1000); // every 60s
+    }
+
+    // -------------------- Session state persistence --------------------
+    _loadSessionState() {
+        try {
+            if (fs.existsSync(this._sessionStateFile)) {
+                const raw = fs.readFileSync(this._sessionStateFile, 'utf8');
+                return JSON.parse(raw || '{}');
+            }
+        } catch (e) {
+            // ignore
+        }
+        return {};
+    }
+    _saveSessionState() {
+        try {
+            fs.writeFileSync(this._sessionStateFile, JSON.stringify(this._sessionState || {}, null, 2), 'utf8');
+        } catch (e) {
+            this.realtimeDebug('Failed to save session state:', e?.message || e);
+        }
     }
 
+    // ------------------------------------------------------------------
+
     /**
      * Start Real-Time Listener with Auto-Inbox Fetch + MQTT
      */
     async startRealTimeListener(options = {}) {
         try {
             console.log('[REALTIME] Starting Real-Time Listener...');
-            
+
             console.log('[REALTIME] Fetching inbox (IRIS data)...');
             const inboxData = await this.ig.direct.getInbox();
-            
+
             console.log('[REALTIME] Connecting to MQTT with IRIS subscription...');
             await this.connect({
                 graphQlSubs: [
@@ -70,15 +117,15 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 ],
                 irisData: inboxData
             });
-            
+
             console.log('[REALTIME] MQTT Connected with IRIS');
             console.log('----------------------------------------');
             console.log('[REALTIME] Real-Time Listener ACTIVE');
             console.log('[REALTIME] Waiting for messages...');
             console.log('----------------------------------------');
-            
+
             this._setupMessageHandlers();
-            
+
             return { success: true };
         } catch (error) {
             console.error('[REALTIME] Failed:', error.message);
@@ -90,46 +137,92 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
      * Setup automatic message handlers
      */
     _setupMessageHandlers() {
+        // handle raw mqtt 'message' events (parsed by this._parseMessage)
         this.on('message', (data) => {
-            const msg = this._parseMessage(data);
-            if (msg) {
-                this.emit('message_live', msg);
+            const parsed = this._parseMessage(data);
+            // emit raw version always for debugging/compatibility
+            if (parsed && parsed._rawMessage) {
+                this.emit('message_raw', parsed._rawMessage);
+            }
+            // normalize and emit only if it's a real message
+            const normalized = this._normalizeToYowsupLike(parsed);
+            if (normalized) {
+                this.metrics.messagesReceived++;
+                // emit cleaned payload as the primary "live" message (Yowsup-like)
+                this.emit('message_live', normalized);
+            } else {
+                // not a real message -> no message_live; keep raw available
             }
         });
 
+        // handle iris events (graph/iris)
         this.on('iris', (data) => {
-            const msg = this._parseIrisMessage(data);
-            if (msg) {
-                this.emit('message_live', msg);
+            const parsed = this._parseIrisMessage(data);
+            if (parsed && parsed._rawIris) {
+                this.emit('message_raw', parsed._rawIris);
+            }
+            const normalized = this._normalizeToYowsupLike(parsed);
+            if (normalized) {
+                this.metrics.messagesReceived++;
+                this.emit('message_live', normalized);
+            } else {
+                // not a message event
             }
         });
     }
 
     /**
      * Parse direct message
+     * Returns an object that always contains the original raw as _rawMessage when available
      */
     _parseMessage(data) {
         try {
             const msg = data.message;
             if (!msg) return null;
-            
+
             if (data.parsed) {
-                return data.parsed;
+                // Keep mqttString/mqtt for backwards compatibility in parsed cases
+                const base = Object.assign({}, data.parsed);
+                base.mqttString = `Mqtt client: [${base.username || (base.userId ? 'user_' + base.userId : 'unknown')}] ${base.text || ''}`;
+                base.mqtt = {
+                    from: base.username || base.userId,
+                    body: base.text || '',
+                    timestamp: base.timestamp || Date.now()
+                };
+                base.status = 'received'; // changed from 'good'
+                base._rawMessage = msg;
+                return base;
             }
-            
+
             const threadInfo = this.threads.get(msg.thread_id);
-            return {
+            const username = msg.username || msg.from_username || `user_${msg.user_id || 'unknown'}`;
+            const text = msg.text || msg.body || '';
+
+            // Provide mqtt-like representations
+            const mqttString = `Mqtt client: [${username}] ${text}`;
+            const mqtt = {
+                from: username,
+                body: text,
+                timestamp: msg.timestamp || Date.now()
+            };
+
+            const out = {
                 id: msg.item_id || msg.id,
                 userId: msg.user_id || msg.from_user_id,
-                username: msg.username || msg.from_username || `user_${msg.user_id || 'unknown'}`,
-                text: msg.text || msg.body || '',
+                username,
+                text,
                 itemType: msg.item_type || 'text',
                 thread: threadInfo?.title || `Thread ${msg.thread_id}`,
                 thread_id: msg.thread_id,
                 timestamp: msg.timestamp,
                 isGroup: threadInfo?.isGroup,
-                status: 'good'
+                status: 'received', // replaced 'good'
+                mqttString,
+                mqtt,
+                _rawMessage: msg
             };
+
+            return out;
         } catch (e) {
             return null;
         }
@@ -141,22 +234,125 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
     _parseIrisMessage(data) {
         try {
             if (data.event !== 'message_create' && !data.type?.includes('message')) {
-                return null;
+                // still return raw for potential debug, but normalized filter will drop it
+                return { _rawIris: data };
             }
-            
-            return {
+
+            const username = data.username || data.from_username || `user_${data.user_id || 'unknown'}`;
+            const text = data.text || '';
+
+            const mqttString = `Mqtt client: [${username}] ${text}`;
+            const mqtt = {
+                from: username,
+                body: text,
+                timestamp: data.timestamp || Date.now()
+            };
+
+            const out = {
                 id: data.item_id || data.id,
                 userId: data.user_id || data.from_user_id,
-                username: data.username || data.from_username || `user_${data.user_id || 'unknown'}`,
-                text: data.text || '',
+                username,
+                text,
                 itemType: data.item_type || 'text',
                 thread_id: data.thread_id,
                 timestamp: data.timestamp,
-                status: 'good'
+                status: 'received', // replaced 'good'
+                mqttString,
+                mqtt,
+                _rawIris: data
             };
+
+            return out;
         } catch (e) {
+            return { _rawIris: data };
+        }
+    }
+
+    /**
+     * NORMALIZE to Yowsup-like full payload (but branded "Mqtt client")
+     * Returns normalized object or null if the parsed input is NOT a real message
+     *
+     * Normalized schema (Yowsup-like full payload):
+     * {
+     *   client: 'Mqtt client',
+     *   from: 'username',
+     *   fromId: 'numeric id',
+     *   body: 'text or description',
+     *   timestamp: 1700000000000,
+     *   type: 'text'|'image'|'video'|'voice'|'sticker'|'unknown',
+     *   thread_id: '...',
+     *   id: 'message id',
+     *   raw: { original raw object }
+     * }
+     */
+    _normalizeToYowsupLike(parsed) {
+        if (!parsed) return null;
+
+        // get raw object for detection
+        const raw = parsed._rawMessage || parsed._rawIris || parsed;
+
+        // Heuristics to decide if this is a "real message" (text/media/voice)
+        // Accept if:
+        // - parsed.text or parsed.body present and non-empty
+        // - or raw contains visual_media/media fields
+        // - or itemType indicates media
+        const hasText = Boolean(parsed.text && String(parsed.text).trim().length > 0);
+        const hasBodyField = Boolean(parsed.body && String(parsed.body).trim().length > 0);
+        const hasMediaField = Boolean(
+            (raw && (raw.visual_media || raw.media || raw.media_share || raw.items || raw.has_media)) ||
+            (parsed.itemType && String(parsed.itemType).toLowerCase() !== 'text')
+        );
+
+        if (!hasText && !hasBodyField && !hasMediaField) {
+            // Not a message that Yowsup would surface — drop from message_live
             return null;
         }
+
+        // Determine type
+        let type = 'text';
+        try {
+            if (hasMediaField) {
+                // try to deduce image/video/voice from raw fields if possible
+                const rl = raw || {};
+                if (rl.item_type && String(rl.item_type).toLowerCase().includes('video')) type = 'video';
+                else if (rl.item_type && String(rl.item_type).toLowerCase().includes('voice')) type = 'voice';
+                else if (rl.media && Array.isArray(rl.media)) {
+                    // naive check for media types in array
+                    const m0 = rl.media[0] || {};
+                    if (m0.media_type === 2 || String(m0.media_type) === '2') type = 'video';
+                    else type = 'image';
+                } else if (rl.visual_media) {
+                    type = 'image';
+                } else {
+                    type = 'unknown';
+                }
+            } else {
+                type = 'text';
+            }
+        } catch (e) {
+            type = 'unknown';
+        }
+
+        // body selection
+        const body = hasText ? String(parsed.text).trim() : (hasBodyField ? String(parsed.body).trim() : (type !== 'text' ? `[${type.toUpperCase()}]` : ''));
+
+        // timestamp fallback
+        const ts = parsed.timestamp ? Number(parsed.timestamp) : (Date.now());
+
+        // Build normalized object (Yowsup-like full payload)
+        const normalized = {
+            client: 'Mqtt client',
+            from: parsed.username || parsed.from || (parsed.userId ? `user_${parsed.userId}` : 'unknown'),
+            fromId: String(parsed.userId || (raw && (raw.from_user_id || raw.user_id)) || 'unknown'),
+            body: body,
+            timestamp: ts,
+            type,
+            thread_id: parsed.thread_id || parsed.thread || (raw && (raw.thread_id || raw.thread)) || null,
+            id: parsed.id || (raw && (raw.item_id || raw.id)) || null,
+            raw: raw
+        };
+
+        return normalized;
     }
 
     setInitOptions(initOptions) {
@@ -230,6 +426,11 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             this.realtimeDebug(`SessionID generated (fallback): ${sessionid}`);
         }
         const password = `sessionid=${sessionid}`;
+
+        // Use persisted clientMqttSessionId if present (session continuity)
+        const persistedClientMqttSessionId = this._sessionState?.clientMqttSessionId ? BigInt(this._sessionState.clientMqttSessionId) : null;
+        const clientMqttSessionIdValue = persistedClientMqttSessionId ?? (BigInt(Date.now()) & BigInt(0xffffffff));
+
         this.connection = new mqttot_1.MQTToTConnection({
             clientIdentifier: deviceId.substring(0, 20),
             clientInfo: {
@@ -244,7 +445,7 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 isInitiallyForeground: true,
                 networkType: 1,
                 networkSubtype: 0,
-                clientMqttSessionId: BigInt(Date.now()) & BigInt(0xffffffff),
+                clientMqttSessionId: clientMqttSessionIdValue,
                 subscribeTopics: [88, 135, 149, 150, 133, 146],
                 clientType: 'cookie_auth',
                 appId: BigInt(567067343352427),
@@ -266,50 +467,123 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 'Accept-Language': this.ig.state.language.replace('_', '-'),
             },
         });
+
+        // update persisted state with chosen session id
+        try {
+            this._sessionState = this._sessionState || {};
+            this._sessionState.clientMqttSessionId = String(clientMqttSessionIdValue);
+            this._saveSessionState();
+        } catch (e) {
+            // ignore
+        }
     }
     async connect(options) {
         this.setInitOptions(options);
         this.constructConnection();
         const { MQTToTClient } = require("../mqttot");
         const { compressDeflate } = require("../shared");
-        
-        this._mqtt = new MQTToTClient({
-            url: 'edge-mqtt.facebook.com',
-            payloadProvider: async () => {
-                return await compressDeflate(this.connection.toThrift());
-            },
-            autoReconnect: true,
-            requirePayload: true,
-        });
-        
-        await this._mqtt.connect();
-        
+
+        // ----------- Enhanced connect with exponential backoff & cooldown -----------
+        const maxAttempts = (this.initOptions?.maxConnectAttempts) || 5;
+        let attempt = 0;
+        let lastError = null;
+        while (attempt < maxAttempts) {
+            attempt++;
+            try {
+                this.realtimeDebug(`Attempting MQTT connect (attempt ${attempt}/${maxAttempts})`);
+                this._mqtt = new MQTToTClient({
+                    url: 'edge-mqtt.facebook.com',
+                    payloadProvider: async () => {
+                        return await compressDeflate(this.connection.toThrift());
+                    },
+                    autoReconnect: true,
+                    requirePayload: true,
+                    // pass through any socks/proxy options if provided
+                    socksOptions: this.initOptions?.socksOptions,
+                    additionalOptions: this.initOptions?.additionalOptions
+                });
+
+                await this._mqtt.connect();
+
+                // mark metrics
+                this.metrics.reconnectCount++;
+                this.metrics.lastConnectTime = Date.now();
+                this.metrics.backoffAttempts += (attempt - 1);
+
+                // If we reach here, connected successfully
+                break;
+            } catch (err) {
+                lastError = err;
+                this.realtimeDebug(`MQTT connect attempt ${attempt} failed: ${err?.message || err}`);
+
+                // exponential backoff with jitter
+                const base = 1000; // 1s
+                const delayMs = Math.min(30000, base * Math.pow(2, attempt - 1)) + Math.floor(Math.random() * 250);
+                this.realtimeDebug(`Waiting ${delayMs}ms before next connect attempt...`);
+                await (0, shared_1.delay)(delayMs);
+
+                // cooldown behavior: if too many attempts, wait longer
+                if (attempt >= maxAttempts) {
+                    this.realtimeDebug('Max connect attempts reached, giving up for now.');
+                }
+            }
+        }
+        if (!this._mqtt) {
+            // fail with the last error
+            throw lastError || new Error('Failed to create MQTT client');
+        }
+        // ----------------------------------------------------------------------------
+
         this.commands = new commands_1.Commands(this._mqtt);
-        
+
         this.emit('connected');
-        
+
+        // Enhanced message handling: try tolerant parse, log unknown fields, fallback raw
         this._mqtt.on('message', async (msg) => {
             const topicMap = this.mqtt?.topicMap;
             const topic = topicMap?.get(msg.topic);
-            
+
             if (topic && topic.parser && !topic.noParse) {
                 try {
                     const unzipped = await (0, shared_1.tryUnzipAsync)(msg.payload);
-                    const parsedMessages = topic.parser.parseMessage(topic, unzipped);
+                    let parsedMessages;
+                    try {
+                        parsedMessages = topic.parser.parseMessage(topic, unzipped);
+                    } catch (parseErr) {
+                        // Tolerant parsing: log and attempt safe fallback
+                        this.metrics.parseErrors++;
+                        this.realtimeDebug('Parse error (topic parser) - attempting tolerant fallback:', parseErr?.message || parseErr);
+
+                        // Attempt to decode as JSON if possible (some thrift->json conversions may be present in tooling)
+                        try {
+                            const s = unzipped.toString('utf8');
+                            parsedMessages = JSON.parse(s);
+                            this.realtimeDebug('Fallback parsed as JSON.');
+                        } catch (jsonErr) {
+                            // Last resort: emit raw payload (preserve for debugging)
+                            this.realtimeDebug('Fallback JSON parse failed; emitting raw payload.');
+                            this.emit('receiveRaw', { topic: msg.topic, payload: unzipped, original: msg });
+                            return;
+                        }
+                    }
+
                     this.emit('receive', topic, Array.isArray(parsedMessages) ? parsedMessages : [parsedMessages]);
-                } catch(e) {
-                    // Silent parse error
+                } catch (e) {
+                    // Silent parse error but count & log minimal info
+                    this.metrics.parseErrors++;
+                    this.realtimeDebug('Silent parse/unzip error in message handler:', e?.message || e);
                 }
             } else {
                 try {
                     await (0, shared_1.tryUnzipAsync)(msg.payload);
                     this.emit('receiveRaw', msg);
-                } catch(e) {
+                } catch (e) {
                     // Silent decompress error
                 }
             }
         });
         this._mqtt.on('error', this.emitError);
+
         await (0, shared_1.delay)(100);
         if (this.initOptions.graphQlSubs && this.initOptions.graphQlSubs.length > 0) {
             await this.graphQlSubscribe(this.initOptions.graphQlSubs);
@@ -340,12 +614,23 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                     url: '/api/v1/direct_v2/threads/get_most_recent_message/',
                     method: 'POST',
                 });
-            } catch(e) {
+            } catch (e) {
                 // Silent force fetch error
             }
         } catch (error) {
             // Silent inbox fetch error - MQTT still listening
         }
+
+        // Persist last used clientMqttSessionId and optionally last seq_id if present in initOptions
+        try {
+            const clientMqttSessionId = this.connection?.toThrift()?.clientInfo?.clientMqttSessionId || this._sessionState?.clientMqttSessionId;
+            if (clientMqttSessionId) {
+                this._sessionState = this._sessionState || {};
+                this._sessionState.clientMqttSessionId = String(clientMqttSessionId);
+                this._saveSessionState();
+            }
+        } catch (e) { /* ignore */ }
+
         this._setupMessageHandlers();
     }
     /**
@@ -361,7 +646,7 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         console.log('[RealtimeClient] Connecting from saved session...');
 
         const savedOptions = authStateHelper.getMqttConnectOptions?.();
-        
+
         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'],
@@ -375,8 +660,12 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             hasIrisData: !!connectOptions.irisData
         });
 
+        // merge any persisted mqtt connect options into initOptions for continuity
+        this.initOptions = { ...(this.initOptions || {}), ...(savedOptions || {}) };
+
         await this.connect(connectOptions);
 
+        // Save session state into auth helper if supported
         if (authStateHelper.saveMqttSession) {
             try {
                 await authStateHelper.saveMqttSession(this);
@@ -386,6 +675,11 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             }
         }
 
+        // Also persist locally
+        try {
+            if (this._sessionState) this._saveSessionState();
+        } catch (e) { }
+
         return this;
     }
     /**
@@ -395,13 +689,21 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
     async saveSession(authStateHelper) {
         if (!authStateHelper || !authStateHelper.saveMqttSession) {
             console.warn('[RealtimeClient] No authStateHelper provided');
+            // still save local state
+            try { this._saveSessionState(); } catch (e) { }
             return false;
         }
         await authStateHelper.saveMqttSession(this);
+        // also persist locally
+        try { this._saveSessionState(); } catch (e) { }
         return true;
     }
     disconnect() {
         this.safeDisconnect = true;
+        // clear metrics interval when shutting down gracefully
+        try {
+            if (this._metricsInterval) clearInterval(this._metricsInterval);
+        } catch (e) { }
         return this.mqtt?.disconnect() ?? Promise.resolve();
     }
     graphQlSubscribe(sub) {
@@ -435,6 +737,13 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             throw new mqtts_1.IllegalStateError('connect() must be called before irisSubscribe()');
         }
         this.realtimeDebug(`Iris Sub to: seqId: ${seq_id}, snapshot: ${snapshot_at_ms}`);
+        // persist last seq_id for continuity
+        try {
+            this._sessionState = this._sessionState || {};
+            if (seq_id) this._sessionState.last_seq_id = seq_id;
+            if (snapshot_at_ms) this._sessionState.last_snapshot_at_ms = snapshot_at_ms;
+            this._saveSessionState();
+        } catch (e) { /* ignore */ }
         return this.commands.updateSubscriptions({
             topic: constants_1.Topics.IRIS_SUB,
             data: {
@@ -444,6 +753,68 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             },
         });
     }
+
+    // ---------------- Dynamic subscription helpers ----------------
+    async addGraphQlSub(sub) {
+        try {
+            const current = this.initOptions.graphQlSubs || [];
+            if (!current.includes(sub)) {
+                current.push(sub);
+                this.initOptions.graphQlSubs = current;
+                if (this.commands) {
+                    await this.graphQlSubscribe(current);
+                }
+            }
+            return true;
+        } catch (e) {
+            this.realtimeDebug('addGraphQlSub error:', e?.message || e);
+            return false;
+        }
+    }
+    async removeGraphQlSub(sub) {
+        try {
+            const current = (this.initOptions.graphQlSubs || []).filter(s => s !== sub);
+            this.initOptions.graphQlSubs = current;
+            if (this.commands) {
+                await this.graphQlSubscribe(current);
+            }
+            return true;
+        } catch (e) {
+            this.realtimeDebug('removeGraphQlSub error:', e?.message || e);
+            return false;
+        }
+    }
+    async addSkywalkerSub(sub) {
+        try {
+            const current = this.initOptions.skywalkerSubs || [];
+            if (!current.includes(sub)) {
+                current.push(sub);
+                this.initOptions.skywalkerSubs = current;
+                if (this.commands) {
+                    await this.skywalkerSubscribe(current);
+                }
+            }
+            return true;
+        } catch (e) {
+            this.realtimeDebug('addSkywalkerSub error:', e?.message || e);
+            return false;
+        }
+    }
+    async removeSkywalkerSub(sub) {
+        try {
+            const current = (this.initOptions.skywalkerSubs || []).filter(s => s !== sub);
+            this.initOptions.skywalkerSubs = current;
+            if (this.commands) {
+                await this.skywalkerSubscribe(current);
+            }
+            return true;
+        } catch (e) {
+            this.realtimeDebug('removeSkywalkerSub error:', e?.message || e);
+            return false;
+        }
+    }
+    // ----------------------------------------------------------------
+
 }
 exports.RealtimeClient = RealtimeClient;
 //# sourceMappingURL=realtime.client.js.map

package/dist/shared/shared.js

@@ -21,10 +21,10 @@ function createFbnsUserAgent(ig) {
         FBBD: 'Android',
         FBPN: 'com.instagram.android',
         FBDV: deviceName.trim(),
-        FBSV: ig.state.androidVersion,
+        FBSV: androidVersion.split('/')[1],
         FBLR: '0',
         FBBK: '1',
-        FBCA: 'arm64-v8a:armeabi-v7a:armeabi',
+        FBCA: 'x86:armeabi-v7a',
     };
     return `[${Object.entries(params)
         .map(p => p.join('/'))
@@ -32,7 +32,7 @@ function createFbnsUserAgent(ig) {
 }
 exports.createFbnsUserAgent = createFbnsUserAgent;
 function compressDeflate(data) {
-    return deflatePromise(data, { level: 6, windowBits: -15 });
+    return deflatePromise(data, { level: 9 });
 }
 exports.compressDeflate = compressDeflate;
 function unzipAsync(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqtt",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "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": {