nodejs-insta-private-api-mqtt 1.3.42 → 1.3.44

package/README.md

@@ -814,6 +814,140 @@ await ig.direct.sendText({ thread_ids: [threadId], text: 'Hello' });
 | `presence` | User presence update |
 | `error` | Connection error |
 
+### Advanced Real-time Events (instagram_mqtt compatible)
+
+These events provide deeper access to Instagram's MQTT protocol. They were added for full compatibility with the instagram_mqtt library.
+
+| Event | Description |
+|-------|-------------|
+| `realtimeSub` | Raw realtime subscription data (all MQTT messages) |
+| `direct` | Direct message events with parsed data |
+| `subscription` | Legacy subscription event (backwards compatible) |
+| `directTyping` | When someone is typing in a DM thread |
+| `appPresence` | User online/offline status updates |
+| `directStatus` | DM thread status changes |
+| `liveWave` | Instagram Live wave notifications |
+| `liveRealtimeComments` | Real-time comments on Instagram Live |
+| `liveTypingIndicator` | Typing indicator in Live comments |
+| `mediaFeedback` | Media engagement feedback |
+| `clientConfigUpdate` | Client configuration updates |
+
+#### Using the realtimeSub Event
+
+The `realtimeSub` event gives you access to all raw MQTT messages. This is useful for debugging or implementing custom message handling:
+
+```javascript
+realtime.on('realtimeSub', ({ data, topic }) => {
+  console.log('Raw MQTT data received:', data);
+  console.log('Topic:', topic);
+});
+```
+
+#### Using the direct Event
+
+The `direct` event provides parsed direct message updates with automatic JSON parsing of nested values:
+
+```javascript
+realtime.on('direct', (data) => {
+  console.log('Direct update:', data);
+  
+  // data.op contains the operation type (e.g., 'add', 'replace', 'remove')
+  // data.path contains the affected path
+  // data.value contains the parsed message data
+  
+  if (data.op === 'add' && data.value) {
+    console.log('New message:', data.value.text);
+  }
+});
+```
+
+#### Using QueryID-based Events
+
+These events are automatically emitted when Instagram sends specific subscription updates:
+
+```javascript
+// Listen for typing indicators
+realtime.on('directTyping', (data) => {
+  console.log('User is typing:', data);
+});
+
+// Listen for presence updates (online/offline status)
+realtime.on('appPresence', (data) => {
+  console.log('Presence update:', data);
+});
+
+// Listen for DM status changes
+realtime.on('directStatus', (data) => {
+  console.log('Direct status changed:', data);
+});
+
+// Listen for Instagram Live comments
+realtime.on('liveRealtimeComments', (data) => {
+  console.log('Live comment:', data);
+});
+```
+
+#### Complete Example: Multi-Event Listener
+
+Here's a complete example showing how to listen to multiple events:
+
+```javascript
+const { IgApiClient, RealtimeClient, useMultiFileAuthState } = require('nodejs-insta-private-api-mqtt');
+
+async function startAdvancedBot() {
+  const ig = new IgApiClient();
+  const auth = await useMultiFileAuthState('./auth_info_ig');
+  
+  ig.state.usePresetDevice('Samsung Galaxy S25 Ultra');
+  
+  const realtime = new RealtimeClient(ig);
+
+  // Standard message handling
+  realtime.on('message_live', (msg) => {
+    console.log(`[${msg.username}]: ${msg.text}`);
+  });
+
+  // Advanced: Raw MQTT data (useful for debugging)
+  realtime.on('realtimeSub', ({ data }) => {
+    console.log('[Debug] Raw MQTT:', JSON.stringify(data).substring(0, 200));
+  });
+
+  // Direct message updates with parsed data
+  realtime.on('direct', (data) => {
+    if (data.op === 'add') {
+      console.log('[Direct] New item added');
+    }
+  });
+
+  // Typing indicators
+  realtime.on('directTyping', (data) => {
+    console.log('[Typing] Someone is typing...');
+  });
+
+  // User presence (online/offline)
+  realtime.on('appPresence', (data) => {
+    console.log('[Presence] User status changed');
+  });
+
+  // Login and connect
+  if (!auth.hasSession()) {
+    await ig.login({
+      username: 'your_username',
+      password: 'your_password'
+    });
+    await auth.saveCreds(ig);
+  } else {
+    await auth.loadCreds(ig);
+  }
+
+  await realtime.startRealTimeListener();
+  
+  console.log('Advanced bot with full MQTT events is running!');
+}
+
+startAdvancedBot().catch(console.error);
+```
+
 ---
 
 ## Important Notes

package/dist/mqttot/mqttot.client.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mqttotConnectFlow = exports.MQTToTClient = void 0;
 // Export the Instagram version so it can be used programmatically
-exports.INSTAGRAM_VERSION = '412.0.0.35.87';
+exports.INSTAGRAM_VERSION = '414.0.0.40.83';
 const shared_1 = require("../shared");
 const mqttot_connect_request_packet_1 = require("./mqttot.connect.request.packet");
 // *** Change: import the external mqtts package instead of a local mqtt-shim ***

package/dist/realtime/mixins/realtime-sub.mixin.js

@@ -1,15 +1,36 @@
 "use strict";
+/**
+ * RealtimeSubMixin - ENHANCED VERSION
+ * 
+ * This file has been modified to include all MQTT features from instagram_mqtt library.
+ * 
+ * CHANGES MADE (from instagram_mqtt compatibility):
+ * 1. Added import for subscriptions (QueryIDs) - was MISSING
+ * 2. Added client.mqtt.listen() approach for REALTIME_SUB topic - was MISSING
+ * 3. Added 'realtimeSub' event emission - was MISSING (only had 'subscription')
+ * 4. Added 'direct' topic processing - was MISSING
+ * 5. Added emitDirectEvent() method - was MISSING
+ * 6. Added QueryIDs-based event emission (directTyping, appPresence, etc.) - was MISSING
+ * 
+ * PRESERVED:
+ * - Original 'subscription' event emission (for backwards compatibility)
+ * - Original on('message') approach with topicMap (extended, not replaced)
+ * - All existing retry logic and error handling
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RealtimeSubMixin = void 0;
 const mixin_1 = require("./mixin");
 const constants_1 = require("../../constants");
 const shared_1 = require("../../shared");
+// ADDED: Import subscriptions for QueryIDs (was MISSING in nodejs-insta-private-api-mqtt)
+const subscriptions_1 = require("../subscriptions");
 const mqtts_1 = require("mqtts");
+
 class RealtimeSubMixin extends mixin_1.Mixin {
     apply(client) {
         (0, mixin_1.hook)(client, 'connect', {
             post: async () => {
-                // Wait for MQTT client to be ready
+                // Wait for MQTT client to be ready (PRESERVED from original)
                 let retries = 0;
                 while (!client.mqtt && retries < 50) {
                     await new Promise(r => setTimeout(r, 100));
@@ -18,6 +39,33 @@ class RealtimeSubMixin extends mixin_1.Mixin {
                 if (!client.mqtt) {
                     throw new mqtts_1.IllegalStateError('No mqtt client created after retries');
                 }
+
+                // ADDED: Use client.mqtt.listen() for REALTIME_SUB topic (from instagram_mqtt)
+                // This is the approach used by instagram_mqtt for handling realtime subscriptions
+                if (client.mqtt.listen) {
+                    client.mqtt.listen({
+                        topic: constants_1.Topics.REALTIME_SUB.id,
+                        transformer: async ({ payload }) => {
+                            try {
+                                return constants_1.Topics.REALTIME_SUB.parser.parseMessage(
+                                    constants_1.Topics.REALTIME_SUB, 
+                                    await (0, shared_1.tryUnzipAsync)(payload)
+                                );
+                            } catch (err) {
+                                // If transformer fails, return null so handler can skip
+                                console.warn('[RealtimeSubMixin] transformer parse failed:', err?.message || err);
+                                return null;
+                            }
+                        },
+                    }, data => {
+                        if (data) {
+                            // ADDED: Call the instagram_mqtt compatible handler
+                            this.handleRealtimeSubFromListen(client, data);
+                        }
+                    });
+                }
+
+                // PRESERVED: Original on('message') approach with topicMap (for backwards compatibility)
                 client.mqtt.on('message', async (msg) => {
                     const topicMap = client.mqtt?.topicMap;
                     const topic = topicMap?.get(msg.topic);
@@ -40,13 +88,91 @@ class RealtimeSubMixin extends mixin_1.Mixin {
             },
         });
     }
+
+    /**
+     * ADDED: Handler compatible with instagram_mqtt's listen() approach
+     * This method handles data from client.mqtt.listen() and emits instagram_mqtt compatible events
+     * 
+     * @param {Object} client - The realtime client instance
+     * @param {Object} param1 - The parsed data object containing { data, topic }
+     */
+    handleRealtimeSubFromListen(client, { data, topic: messageTopic }) {
+        const { message } = data;
+        
+        // ADDED: Emit 'realtimeSub' event (was MISSING - this is what instagram_mqtt does)
+        client.emit('realtimeSub', { data, topic: messageTopic });
+        
+        // ADDED: Process message based on type (was MISSING)
+        if (typeof message === 'string') {
+            // If message is a string, parse it and emit direct event
+            this.emitDirectEvent(client, JSON.parse(message));
+        }
+        else if (message) {
+            const { topic, payload, json } = message;
+            switch (topic) {
+                case 'direct': {
+                    // ADDED: Handle 'direct' topic specifically (was MISSING)
+                    this.emitDirectEvent(client, json);
+                    break;
+                }
+                default: {
+                    // ADDED: Emit QueryID-based events (was MISSING)
+                    // This emits events like 'directTyping', 'appPresence', 'directStatus', etc.
+                    const entries = Object.entries(subscriptions_1.QueryIDs);
+                    const query = entries.find(e => e[1] === topic);
+                    if (query) {
+                        client.emit(query[0], json || payload);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * ADDED: Method to emit direct events (was MISSING from nodejs-insta-private-api-mqtt)
+     * This method parses string values in parsed.data and emits 'direct' event for each
+     * 
+     * @param {Object} client - The realtime client instance  
+     * @param {Object} parsed - The parsed message object containing data array
+     */
+    emitDirectEvent(client, parsed) {
+        if (!parsed || !parsed.data || !Array.isArray(parsed.data)) {
+            return;
+        }
+        
+        parsed.data = parsed.data.map((e) => {
+            if (typeof e.value === 'string') {
+                try {
+                    e.value = JSON.parse(e.value);
+                } catch (parseErr) {
+                    // If parsing fails, keep original value
+                    console.warn('[RealtimeSubMixin] emitDirectEvent JSON parse failed:', parseErr?.message);
+                }
+            }
+            return e;
+        });
+        
+        // Emit 'direct' event for each data item
+        parsed.data.forEach((data) => client.emit('direct', data));
+    }
+
+    /**
+     * PRESERVED: Original handler for on('message') approach (for backwards compatibility)
+     * This emits the 'subscription' event that existing code may depend on
+     * 
+     * @param {Object} client - The realtime client instance
+     * @param {Object} topic - The topic object from topicMap
+     * @param {Object} data - The parsed message data
+     */
     handleRealtimeSub(client, topic, data) {
+        // PRESERVED: Emit 'subscription' event (original behavior)
         client.emit('subscription', {
             query: topic.path,
             data: data,
             topic: topic,
         });
     }
+
     get name() {
         return 'Realtime Sub';
     }

package/dist/realtime/realtime.client.js

@@ -339,7 +339,7 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                     ? this.ig.state.appUserAgent
                     : typeof this.ig.state.deviceString === 'string'
                         ? this.ig.state.deviceString
-                        : 'Instagram 155.0.0.37.107 Android';
+                        : 'Instagram 414.0.0.40.83 Android';
 
         // deviceId / phoneId fallback handling (string coercion)
         const deviceId = String(this.ig.state.phoneId || this.ig.state.deviceId || 'device_unknown');

package/package.json

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