nodejs-insta-private-api-mqtt 1.3.41 → 1.3.43

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

@@ -12,14 +12,12 @@ const thrift_1 = require("../../thrift");
  *
  * - Full, self-contained class that publishes correctly-formatted payloads to Instagram's
  *   Direct MQTT (Thrift + compressed payloads).
- * - Includes a robust sendLocation implementation that sends a nested `location` object,
- *   and a fallback to sending a link (which reliably appears in chat).
+ * - Updated sendLocation implementation:
+ *    1) try publish a story with a Location sticker (preferred, matches APK behavior)
+ *    2) share that story to the thread (reel/media_share)
+ *    3) fallback: send a link to /explore/locations/{placeId}/ if (1) fails
  *
- * IMPORTANT:
- * - Instagram's internal protocol is not public. This implementation matches patterns
- *   observed in reverse-engineered clients. Even so, Instagram may silently reject
- *   location messages if server-side validation's schema differs. If a message is
- *   rejected, fallback sends a link to the location which is visible to users.
+ * Note: server-side validation may still reject location stickers in some contexts.
  */
 class EnhancedDirectCommands {
     constructor(client) {
@@ -289,72 +287,97 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send location via MQTT (enhanced)
+     * Send location via MQTT (reworked)
      *
-     * Accepts:
-     *  - threadId (string)
-     *  - clientContext (optional)
-     *  - venue (object) - should include at minimum:
-     *      { id, name, address, lat, lng, facebook_places_id, external_source }
+     * Now:
+     *  - Tries to publish a Story with a Location sticker (preferred; matches APK behavior)
+     *  - Shares that Story to the thread (reel_share / media_share)
+     *  - If any step fails, falls back to sending a link to /explore/locations/{placeId}/
      *
-     * The function tries to send a nested `location` object inside the item payload:
-     * {
-     *   item_type: 'location',
-     *   location: { lat, lng, name, address, external_source, facebook_places_id },
-     *   text: '' // optional text
-     * }
-     *
-     * If the venue is missing required fields, it falls back to sending a link that points
-     * to the explore/locations/<id> page (which reliably appears in the chat).
-     *
-     * NOTE: Instagram expects the payload to be Thrift-encoded + compressed for MQTT.
+     * venue shape expected:
+     *  { id, name, address, lat, lng, facebook_places_id, external_source }
      */
     async sendLocation({ threadId, clientContext, venue, text = '' }) {
         this.enhancedDebug(`Attempting to send location to ${threadId}. Venue: ${venue ? JSON.stringify(venue) : 'none'}`);
 
-        // Basic validation - if we don't have lat/lng and id, fallback to link or error
+        // Basic validation - need at least an id (or facebook_places_id)
         const hasCoords = venue && typeof venue.lat === 'number' && typeof venue.lng === 'number';
         const hasId = venue && (venue.facebook_places_id || venue.id);
 
-        // Build the "location" nested object expected semantically
-        const locationObj = hasCoords ? {
-            lat: Number(venue.lat),
-            lng: Number(venue.lng),
-            name: venue.name || '',
-            address: venue.address || '',
-            external_source: venue.external_source || 'facebook_places',
-            facebook_places_id: venue.facebook_places_id || String(venue.id || ''),
-        } : null;
+        // prefer facebook_places_id if present
+        const placeId = venue && (venue.facebook_places_id || venue.id);
+
+        // create sticker structure (format used by many reverse-engineered clients)
+        const sticker = this.createLocationStickerFromVenue(venue);
 
-        // If we have a good location object, attempt to send it
-        if (locationObj && hasId) {
+        // If we have an ig client capable of publishing stories, attempt the sticker flow.
+        const ig = this.realtimeClient && this.realtimeClient.ig;
+        if (ig && typeof ig.publish === 'object' && typeof ig.publish.story === 'function') {
             try {
-                const result = await this.sendItem({
-                    itemType: 'location',
-                    threadId,
-                    clientContext: clientContext || (0, uuid_1.v4)(),
-                    data: {
-                        text: text || '',
-                        // Put the nested `location` object in the payload as many reverse engineered
-                        // clients do. We also add the older-style ids for compatibility.
-                        location: locationObj,
-                        venue_id: locationObj.facebook_places_id,
-                        item_id: locationObj.facebook_places_id,
-                    },
-                });
+                // Use a tiny placeholder image if caller didn't provide one (1x1 PNG)
+                const SINGLE_PIXEL_PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAAWgmWQ0AAAAASUVORK5CYII=";
+                const photoBuffer = Buffer.from(SINGLE_PIXEL_PNG_BASE64, 'base64');
+
+                this.enhancedDebug(`Publishing story with location sticker (venue id: ${placeId})...`);
+
+                // Build publish params. Many clients accept `file` and `stickers` array like this.
+                const publishParams = {
+                    file: photoBuffer,
+                    stickers: [sticker],
+                    // optional: caption/text not always supported on story publish in the same way; keep minimal
+                };
+
+                const publishResult = await ig.publish.story(publishParams);
+
+                this.enhancedDebug(`Story publish result: ${publishResult ? JSON.stringify(publishResult).slice(0, 400) : 'no result'}`);
+
+                // Try to resolve story media id
+                let storyId = null;
+                if (publishResult) {
+                    // common fields returned by private clients
+                    storyId = publishResult.media && (publishResult.media.pk || publishResult.media.id || publishResult.media_id) ||
+                              publishResult.item_id || publishResult.upload_id || publishResult.media_id;
+                }
+
+                // If we didn't get a story id, try common fallback fields
+                if (!storyId && publishResult && publishResult.params && publishResult.params.upload_id) {
+                    storyId = publishResult.params.upload_id;
+                }
 
-                this.enhancedDebug(`✅ Location payload published via MQTT (may still be rejected server-side).`);
-                return result;
+                if (!storyId) {
+                    // If publish succeeded but no usable id found, still attempt best-effort: some clients return a "media" object later on pubsub
+                    this.enhancedDebug(`Could not determine story id from publish result; continuing to fallback to link/share attempt.`);
+                    throw new Error('Could not determine story id from publish result.');
+                }
+
+                // Now share the story to the thread (reel_share/media_share)
+                // Use the existing helper sendUserStory if available (it uses itemType: 'reel_share')
+                this.enhancedDebug(`Sharing published story ${storyId} to thread ${threadId}...`);
+                try {
+                    const shareResult = await this.sendUserStory({
+                        text: text || '',
+                        storyId: storyId,
+                        threadId,
+                        clientContext: clientContext || (0, uuid_1.v4)(),
+                    });
+                    this.enhancedDebug(`✅ Location story shared to thread via MQTT! (storyId=${storyId})`);
+                    return shareResult;
+                } catch (shareErr) {
+                    // If sharing via MQTT fails, try a fallback: some clients expose direct send helper
+                    this.enhancedDebug(`Sharing story to thread failed: ${shareErr && shareErr.message ? shareErr.message : String(shareErr)}`);
+                    // fall through to fallback link below
+                    throw shareErr;
+                }
             } catch (err) {
-                this.enhancedDebug(`Location publish failed: ${err && err.message ? err.message : String(err)} - falling back to link`);
-                // fallthrough to fallback below
+                this.enhancedDebug(`Story-with-sticker attempt failed: ${err && err.message ? err.message : String(err)} - falling back to link`);
+                // fallthrough to fallback block below
             }
+        } else {
+            this.enhancedDebug(`ig.publish.story not available on realtimeClient.ig — will use fallback link if possible.`);
         }
 
         // Fallback: send as a link to the location explore page (guaranteed to render in DM)
         if (hasId) {
-            // prefer facebook_places_id if provided
-            const placeId = venue.facebook_places_id || venue.id;
             const link = `https://www.instagram.com/explore/locations/${placeId}/`;
             this.enhancedDebug(`Sending location fallback link: ${link}`);
 
@@ -377,7 +400,60 @@ class EnhancedDirectCommands {
         }
 
         // If we don't have any usable info, throw an error
-        throw new Error('sendLocation requires a venue object with at least id (or facebook_places_id) and lat/lng to send a native location. Without that, nothing can be sent.');
+        throw new Error('sendLocation requires a venue object with at least id (or facebook_places_id).');
+    }
+
+    /**
+     * Helper that returns a "location sticker" object compatible with many reverse-engineered
+     * clients / the publish.story helper. This mirrors the "LocationStickerClientModel" semantics.
+     *
+     * Format produced:
+     * {
+     *   type: 'location',
+     *   location_id: '12345',
+     *   location: { lat, lng, name, address, external_source, facebook_places_id },
+     *   x: 0.5,
+     *   y: 0.5,
+     *   width: 0.7,
+     *   height: 0.15,
+     *   rotation: 0,
+     *   is_pinned: false
+     * }
+     */
+    createLocationStickerFromVenue(venue) {
+        // Defensive defaults
+        if (!venue) {
+            throw new Error('venue required to create location sticker');
+        }
+        const placeId = venue.facebook_places_id || String(venue.id || '');
+        const lat = (typeof venue.lat === 'number') ? venue.lat : (venue.location && venue.location.lat) || null;
+        const lng = (typeof venue.lng === 'number') ? venue.lng : (venue.location && venue.location.lng) || null;
+
+        const locationObj = {
+            lat: lat,
+            lng: lng,
+            name: venue.name || '',
+            address: venue.address || '',
+            external_source: venue.external_source || 'facebook_places',
+            facebook_places_id: placeId || '',
+        };
+
+        // Sticker appearance / position defaults - caller may tweak later if needed
+        const sticker = {
+            type: 'location',
+            // some clients expect locationId, some expect venue_id or location_id
+            locationId: placeId,
+            venue_id: placeId,
+            location: locationObj,
+            x: 0.5,
+            y: 0.5,
+            width: 0.7,
+            height: 0.15,
+            rotation: 0,
+            isPinned: false,
+        };
+
+        return sticker;
     }
 
     /**

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

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