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

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

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