nodejs-insta-private-api-mqtt 1.3.15 → 1.3.17

package/README.md

@@ -265,102 +265,179 @@ startBot().catch(console.error);
 
 ## 🖼️ IMPORTANT: How media actually works (photos & videos)
 
-> **Critical clarification:** The previous README wording that claimed *"Send Media via MQTT"* was misleading. Instagram's real-time (MQTT) layer is a *sync/notification* channel — **it does not replace the HTTP upload + broadcast flow required to create new photo/video DM messages server-side**. The correct and reliable sequence to send media is:
+## 🖼️ IMPORTANT: How media actually works (photos & videos) — UPDATED (rupload + MQTT reference)
 
-1. **Upload the media (rupload) — HTTP**  
-   Upload the raw bytes to Instagram's rupload endpoint (this returns an `upload_id`). This step stores the media on Instagram's storage/CDN.
+> **Clarification (APK + client behaviour):**  
+> The mobile app uploads raw media bytes via **HTTP rupload** (rupload_igphoto / rupload_igvideo). After the rupload completes and the app receives an `upload_id`, the app **notifies Instagram's realtime layer (MQTT)** that "there is media with `upload_id` — attach it to thread X".  
+>
+> **Key points**
+> - **Media bytes are uploaded over HTTP (rupload).** MQTT never carries the raw image/video bytes.
+> - **MQTT is used as a realtime *reference/notification* channel**: the client publishes a `send_item` command containing `item_type: "media"` and `upload_id: "<id>"`. That tells the server: "the media exists; attach it to this thread".
+> - In some cases the client also calls HTTP broadcast/configure endpoints. The exact flow can vary by platform/version; the APK shows the pattern `RuploadClient.upload() -> upload_id` then `SendMessage.sendMedia(upload_id)` (MQTT). The hybrid pattern below matches that behavior.
 
-2. **Create / broadcast the media message — HTTP**  
-   Use the Direct API `configure_photo` (or video equivalent) endpoint to create the DM message that references the `upload_id`. This action makes the message exist on Instagram's servers and associates it with the target thread(s).
+---
 
-3. **MQTT = realtime sync / notification**  
-   Once the server-side message exists, MQTT will propagate a `MESSAGE_SYNC` (or similar) event so clients receive the message in realtime. MQTT does **not** perform the storage, processing or permanent creation of media on the server.
+### Correct / supported patterns
 
----
+There are two practical, compatible flows you can use depending on your client helpers and what the server expects:
+
+**A) Hybrid (rupload HTTP -> MQTT reference broadcast)** — matches what the APK does in many versions  
+1. Upload bytes to rupload_igphoto / rupload_igvideo (HTTP) -> receive `upload_id`.  
+2. Publish an MQTT `send_item` with `item_type: "media"` and `upload_id`: this tells the realtime server to attach the previously uploaded media to the thread.  
+   - MQTT payload is **only the metadata** (JSON), typically compressed/deflated by the realtime client before publish.  
+   - This is the recommended **APK-compatible** approach.
 
-### Why this change matters
+**B) Full HTTP (rupload HTTP -> configure/broadcast HTTP)** — always works, server-side creation via REST  
+1. Upload bytes to rupload endpoint (HTTP) -> receive `upload_id`.  
+2. Call the direct broadcast / configure_photo or configure_video HTTP endpoint to create the message server-side. MQTT will then deliver the server-created message to connected clients.  
+   - Use this if you prefer to avoid relying on the realtime command to create messages.
 
-- MQTT is excellent for **text**, **reactions**, **typing**, **presence** and **read receipts** — these can be (and are) sent directly over realtime topics.  
-- Media (images, videos, view-once content) require storage, processing and metadata which are handled by HTTP endpoints. Without the HTTP broadcast step, other clients will not see the uploaded bytes even if an MQTT "send" payload is transmitted.
+> Summary: **Always rupload via HTTP.** Then **use the HTTP configure/broadcast endpoints as the primary, reliable method** to attach media to threads. Publishing an MQTT `send_item` referencing `upload_id` may work as a best-effort fallback on some servers, but it is not guaranteed. MQTT never carries the raw media bytes, only metadata/reference.
 
 ---
 
-### Correct examples (upload + broadcast)
+### Example: Hybrid flow — Photo (rupload HTTP then MQTT reference)
 
-#### Upload a photo and broadcast (recommended pattern)
+This example shows the two steps required. It assumes you have `ig.request.send` for HTTP and a `realtime.mqtt.publish()` helper for MQTT. It also shows the `compressDeflate` helper pattern used in this project.
 
 ```javascript
-const fs = require('fs');
-const { v4: uuidv4 } = require('uuid');
+// 1) RUUPLOAD (HTTP) - upload bytes and get upload_id
+const uploadId = Date.now().toString(); // or use library helper that returns upload_id
+const objectName = `${uploadId}_${Math.floor(Math.random()*1e9)}.jpg`;
 
-const photoBuffer = fs.readFileSync('./image.jpg');
-
-// 1) rupload (helper may exist as ig.publish.photo)
-const upload = await ig.publish.photo({ file: photoBuffer });
-// upload.upload_id should be available (or upload.uploadId)
-
-// 2) broadcast the uploaded photo via HTTP to the thread(s)
-const mutationToken = uuidv4();
-const payload = {
-  action: 'configure_photo',
-  upload_id: String(upload.upload_id || upload.uploadId || upload),
-  thread_ids: JSON.stringify([threadId]), // or JSON array of thread ids
-  client_context: mutationToken,
-  mutation_token: mutationToken,
-  _csrftoken: ig.state.cookieCsrfToken || '',
-  _uuid: ig.state.uuid || '',
-  device_id: ig.state.deviceId || ''
+const ruploadParams = {
+  upload_id: uploadId,
+  media_type: 1, // photo
+  image_compression: '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}',
+  xsharing_user_ids: JSON.stringify([]),
+  is_clips_media: false,
 };
 
-const response = await ig.request.send({
-  url: '/api/v1/direct_v2/threads/broadcast/configure_photo/',
+const headers = {
+  'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+  'Content-Type': 'image/jpeg',
+  'X-Entity-Type': 'image/jpeg',
+  'X-Entity-Length': String(photoBuffer.length),
+  'Content-Length': String(photoBuffer.length),
+};
+
+// send bytes to /rupload_igphoto/<objectName>
+await ig.request.send({
+  url: `/rupload_igphoto/${objectName}`,
   method: 'POST',
-  form: payload,
-  timeout: 60000
+  headers,
+  body: photoBuffer,
+  timeout: 120000,
 });
 
-// If response indicates success (status: 'ok' or similar), the message is now created server-side.
-// MQTT will usually emit a MESSAGE_SYNC event shortly after with the CDN URL for the image.
+// server should now provide or accept the upload_id (uploadId)
+
+// 2) MQTT publish - tell realtime: "attach upload_id X to thread Y"
+const clientContext = require('uuid').v4();
+const command = {
+  action: 'send_item',
+  thread_id: String(threadId),
+  item_type: 'media',
+  upload_id: String(uploadId),
+  text: caption || '',
+  timestamp: Date.now(),
+  client_context: clientContext
+};
+
+// compress the JSON (match client's compress method)
+const json = JSON.stringify(command);
+const payload = await compressDeflate(json); // project helper
+
+// publish to MQTT send_message topic
+await mqtt.publish({
+  topic: Topics.SEND_MESSAGE.id,
+  qosLevel: 1,
+  payload: payload
+});
 ```
 
-#### Upload and broadcast a video
+**Notes**
+- This sends only a *reference* to the server. The bytes were already sent via rupload.
+- The APK calls something equivalent to `RuploadClient.upload()` then `SendMessage.sendMedia(upload_id)` — the second call is an MQTT notification that references `upload_id`.
+
+---
+
+### Example: Hybrid flow — Video (rupload HTTP then MQTT reference)
 
 ```javascript
-const videoBuffer = fs.readFileSync('./video.mp4');
+// 1) RUUPLOAD (video)
+const uploadId = Date.now().toString();
+const objectName = `${uploadId}_${Math.floor(Math.random()*1e9)}.mp4`;
 
-// 1) rupload video (may be ig.publish.video)
-const upload = await ig.publish.video({ video: videoBuffer, duration: 15000 });
-
-// 2) broadcast via HTTP similar to photo but to the upload_video endpoint
-const mutationToken = uuidv4();
-const payload = {
-  action: 'configure_video',
-  upload_id: String(upload.upload_id || upload.uploadId || upload),
-  thread_ids: JSON.stringify([threadId]),
-  client_context: mutationToken,
-  mutation_token: mutationToken,
-  _csrftoken: ig.state.cookieCsrfToken || '',
-  _uuid: ig.state.uuid || '',
-  device_id: ig.state.deviceId || ''
+const ruploadParams = {
+  upload_id: uploadId,
+  media_type: 2, // video
+  xsharing_user_ids: JSON.stringify([]),
+  upload_media_duration_ms: Math.round(duration * 1000),
+  upload_media_width: width,
+  upload_media_height: height
 };
 
-const response = await ig.request.send({
-  url: '/api/v1/direct_v2/threads/broadcast/configure_video/',
+const headers = {
+  'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+  'Content-Type': 'video/mp4',
+  'X-Entity-Type': 'video/mp4',
+  'X-Entity-Length': String(videoBuffer.length),
+  'Content-Length': String(videoBuffer.length),
+  'Offset': '0'
+};
+
+await ig.request.send({
+  url: `/rupload_igvideo/${objectName}`,
   method: 'POST',
-  form: payload,
-  timeout: 90000
+  headers,
+  body: videoBuffer,
+  timeout: 300000
+});
+
+// 2) MQTT publish - notify realtime to attach upload_id to thread
+const command = {
+  action: 'send_item',
+  thread_id: String(threadId),
+  item_type: 'media',
+  upload_id: String(uploadId),
+  text: caption || '',
+  timestamp: Date.now(),
+  client_context: require('uuid').v4()
+};
+
+const payload = await compressDeflate(JSON.stringify(command));
+await mqtt.publish({
+  topic: Topics.SEND_MESSAGE.id,
+  qosLevel: 1,
+  payload: payload
 });
 ```
 
 ---
 
-### What was removed/changed
-- Any claim that photos/videos can be **created** solely through MQTT was corrected.
-- Examples and helper text were updated to show the required HTTP upload + broadcast flow.
-- MQTT examples for text and realtime events remain unchanged; MQTT should still be used for fast realtime behavior.
+### Short FAQ & Troubleshooting
+
+- **Q:** *Can I send the raw image through MQTT?*  
+  **A:** No — MQTT is not used for large raw bytes. The app uploads bytes via rupload HTTP.
+
+- **Q:** *If I publish the MQTT `send_item` with `upload_id`, will the message appear in the thread?*  
+  **A:** Sometimes the realtime server accepts an MQTT `send_item` referencing a valid `upload_id`, but this behavior is not universally reliable across server versions, accounts, or configurations. For production reliability prefer the HTTP broadcast/configure endpoints; keep MQTT reference as a best-effort fallback.
+
+- **Q:** *Do I need to call `/direct_v2/threads/broadcast/...` if I published MQTT?*  
+  **A:** Often not — the APK pattern uses MQTT for the attach request. However, for absolute compatibility or for older server behavior, the HTTP configure/broadcast endpoints are a safe fallback.
 
 ---
 
+### Security & Best Practices
+
+- Ensure `upload_id` you publish via MQTT is the one returned by rupload; otherwise servers will reject or ignore it.
+- Keep rupload headers accurate (`X-Entity-Length`, `X-Instagram-Rupload-Params`, etc.).
+- Use `client_context` (UUID) per message to track mutations.
+- Implement retries and exponential backoff for both rupload and MQTT publish.
+- Log both the rupload response and the MQTT publish result for debugging.
+
+---
 
 We've completely overhauled how the MQTT connection works. You no longer need to manually manage connection states every time your bot restarts. Just like **Baileys**, if a session is present in the default folder, the library takes care of everything for you.
 
@@ -1961,3 +2038,259 @@ For issues, bugs, or feature requests: https://github.com/Kunboruto20/nodejs-ins
 Documentation: https://github.com/Kunboruto20/nodejs-insta-private-api
 
 Examples: See repository examples/ directory for working implementations
+
+
+---
+
+## Examples using `ig.request.send` wrapper (photo & video, MQTT *reference* + REST broadcast)
+
+Below are practical code snippets that use the `ig.request.send` wrapper (the same request helper used inside the Instagram client).  
+Each example shows **two flows** so you can pick the behavior you want:
+
+1. **MQTT reference flow** — upload via `rupload` (HTTP) to obtain `upload_id` then **publish an MQTT `send_item` that contains only the `upload_id`** (Instagram attaches the already-uploaded file to the thread). This matches the APK behavior: MQTT only carries a reference, not the binary.
+2. **REST broadcast flow** — upload via `rupload` (HTTP) and then call the `direct_v2` broadcast REST endpoint to attach the uploaded media to a thread (alternate, server-side broadcast).
+
+> Note: these examples assume your runtime has access to:
+> - `ig` (Instagram client wrapper) and `ig.request.send` method,
+> - `mqtt` connected client exposing `.publish({ topic, qosLevel, payload })`,
+> - `compressDeflate` helper (same as in project `shared`),
+> - `uuid` (for `client_context` generation), and
+> - `constants.Topics.SEND_MESSAGE.id` for the MQTT send topic.
+
+### Photo — MQTT reference example (rupload via `ig.request.send` then MQTT reference)
+```javascript
+// Photo upload -> get upload_id (rupload) -> publish MQTT 'send_item' with upload_id
+const { v4: uuidv4 } = require('uuid');
+
+async function sendPhotoAsMqttReference({ ig, mqtt, photoBuffer, threadId, caption = '' }) {
+  if (!ig || !ig.request) throw new Error('ig.request not available');
+  if (!mqtt || typeof mqtt.publish !== 'function') throw new Error('mqtt client not available');
+  if (!Buffer.isBuffer(photoBuffer)) throw new Error('photoBuffer must be a Buffer');
+
+  // 1) perform rupload via ig.request.send
+  const uploadId = Date.now().toString();
+  const objectName = `${uuidv4()}.jpg`;
+  const ruploadParams = {
+    upload_id: uploadId,
+    media_type: 1,
+    image_compression: '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}',
+    xsharing_user_ids: JSON.stringify([]),
+  };
+
+  const uploadHeaders = {
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'Content-Type': 'image/jpeg',
+    'X-Entity-Type': 'image/jpeg',
+    'X-Entity-Length': String(photoBuffer.length),
+    'Content-Length': String(photoBuffer.length),
+  };
+
+  const uploadUrl = `/rupload_igphoto/${objectName}`;
+
+  const uploadResponse = await ig.request.send({
+    url: uploadUrl,
+    method: 'POST',
+    headers: uploadHeaders,
+    body: photoBuffer,
+  });
+
+  const serverUploadId = (uploadResponse && uploadResponse.upload_id) ? uploadResponse.upload_id : uploadId;
+
+  // 2) publish MQTT reference telling server "attach upload_id X to thread Y"
+  const clientContext = uuidv4();
+  const command = {
+    action: 'send_item',
+    thread_id: String(threadId),
+    item_type: 'media',
+    upload_id: serverUploadId,
+    text: caption || '',
+    client_context: clientContext,
+    timestamp: Date.now(),
+  };
+
+  const json = JSON.stringify(command);
+  const payload = await compressDeflate(json); // reuse shared helper
+  await mqtt.publish({
+    topic: constants.Topics.SEND_MESSAGE.id,
+    qosLevel: 1,
+    payload,
+  });
+
+  return { upload_id: serverUploadId };
+}
+```
+
+### Photo — REST broadcast example (rupload via `ig.request.send` then direct_v2 broadcast)
+```javascript
+// Photo upload -> rupload via ig.request.send -> REST broadcast to the thread
+async function sendPhotoViaRestBroadcast({ ig, photoBuffer, threadId, caption = '' }) {
+  const uploadId = Date.now().toString();
+  const objectName = `${uuidv4()}.jpg`;
+
+  const ruploadParams = {
+    upload_id: uploadId,
+    media_type: 1,
+    image_compression: '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}',
+    xsharing_user_ids: JSON.stringify([]),
+  };
+
+  const uploadResponse = await ig.request.send({
+    url: `/rupload_igphoto/${objectName}`,
+    method: 'POST',
+    headers: {
+      'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+      'Content-Type': 'image/jpeg',
+      'X-Entity-Type': 'image/jpeg',
+      'X-Entity-Length': String(photoBuffer.length),
+      'Content-Length': String(photoBuffer.length),
+    },
+    body: photoBuffer,
+  });
+
+  const serverUploadId = (uploadResponse && uploadResponse.upload_id) ? uploadResponse.upload_id : uploadId;
+
+  // Broadcast attach via REST endpoint
+  const broadcastResponse = await ig.request.send({
+    url: '/direct_v2/threads/broadcast/upload_photo/',
+    method: 'POST',
+    form: {
+      upload_id: serverUploadId,
+      action: 'send_item',
+      thread_ids: JSON.stringify([String(threadId)]),
+      caption: caption || '',
+    },
+  });
+
+  return { upload_id: serverUploadId, broadcastResponse };
+}
+```
+
+### Video — MQTT reference example (rupload video + MQTT reference)
+```javascript
+// Video upload -> rupload video via ig.request.send -> MQTT reference
+async function sendVideoAsMqttReference({ ig, mqtt, videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280 }) {
+  const uploadId = Date.now().toString();
+  const objectName = `${uuidv4()}.mp4`;
+
+  const ruploadParams = {
+    upload_id: uploadId,
+    media_type: 2, // video
+    xsharing_user_ids: JSON.stringify([]),
+    upload_media_duration_ms: Math.round(duration * 1000),
+    upload_media_width: width,
+    upload_media_height: height,
+  };
+
+  const uploadResponse = await ig.request.send({
+    url: `/rupload_igvideo/${objectName}`,
+    method: 'POST',
+    headers: {
+      'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+      'Content-Type': 'video/mp4',
+      'X-Entity-Type': 'video/mp4',
+      'X-Entity-Length': String(videoBuffer.length),
+      'Content-Length': String(videoBuffer.length),
+      'Offset': '0',
+    },
+    body: videoBuffer,
+  });
+
+  const serverUploadId = (uploadResponse && uploadResponse.upload_id) ? uploadResponse.upload_id : uploadId;
+
+  // ATTACH VIA HTTP BROADCAST (preferred, reliable)
+// Attempt REST broadcast first (most reliable). This will create the direct message server-side
+// and let MQTT/clients receive the created message as normal sync.
+try {
+  const broadcastResponse = await ig.request.send({
+    url: '/direct_v2/threads/broadcast/upload_photo/',
+    method: 'POST',
+    form: {
+      upload_id: serverUploadId,
+      action: 'send_item',
+      thread_ids: JSON.stringify([String(threadId)]),
+      caption: caption || '',
+      client_context: clientContext,
+    },
+    timeout: 60000,
+  });
+  return { upload_id: serverUploadId, broadcastResponse };
+} catch (err) {
+  // If REST broadcast fails for transient reasons, fall back to attempting an MQTT reference publish.
+  // NOTE: MQTT 'reference' publish is not guaranteed to be accepted on all server versions or accounts.
+  // Keep it as a fallback only — the HTTP broadcast above is the recommended, reliable method.
+  try {
+    const json = JSON.stringify({
+      action: 'send_item',
+      thread_id: String(threadId),
+      item_type: 'media',
+      upload_id: serverUploadId,
+      text: caption || '',
+      client_context: clientContext,
+      timestamp: Date.now(),
+    });
+    const payload = await compressDeflate(json);
+    await mqtt.publish({
+      topic: constants.Topics.SEND_MESSAGE.id,
+      qosLevel: 1,
+      payload,
+    });
+    return { upload_id: serverUploadId, mqttFallback: true };
+  } catch (err2) {
+    // last-resort: return upload id and both errors for debugging
+    return { upload_id: serverUploadId, broadcastError: err?.message || String(err), mqttError: err2?.message || String(err2) };
+  }
+}
+}
+```
+
+### Video — REST broadcast example (rupload video + direct_v2 broadcast)
+```javascript
+async function sendVideoViaRestBroadcast({ ig, videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280 }) {
+  const uploadId = Date.now().toString();
+  const objectName = `${uuidv4()}.mp4`;
+
+  const ruploadParams = {
+    upload_id: uploadId,
+    media_type: 2,
+    xsharing_user_ids: JSON.stringify([]),
+    upload_media_duration_ms: Math.round(duration * 1000),
+    upload_media_width: width,
+    upload_media_height: height,
+  };
+
+  const uploadResponse = await ig.request.send({
+    url: `/rupload_igvideo/${objectName}`,
+    method: 'POST',
+    headers: {
+      'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+      'Content-Type': 'video/mp4',
+      'X-Entity-Type': 'video/mp4',
+      'X-Entity-Length': String(videoBuffer.length),
+      'Content-Length': String(videoBuffer.length),
+      'Offset': '0',
+    },
+    body: videoBuffer,
+  });
+
+  const serverUploadId = (uploadResponse && uploadResponse.upload_id) ? uploadResponse.upload_id : uploadId;
+
+  const broadcastResponse = await ig.request.send({
+    url: '/direct_v2/threads/broadcast/upload_video/',
+    method: 'POST',
+    form: {
+      upload_id: serverUploadId,
+      action: 'send_item',
+      thread_ids: JSON.stringify([String(threadId)]),
+      video_result: '',
+      caption: caption || '',
+    },
+  });
+
+  return { upload_id: serverUploadId, broadcastResponse };
+}
+```
+
+
+---
+
+(Section added programmatically: `Examples using ig.request.send` — appended to the existing README content.)

package/dist/realtime/commands/enhanced.direct.commands.js

@@ -14,6 +14,57 @@ class EnhancedDirectCommands {
         this.enhancedDebug = (0, shared_1.debugChannel)('realtime', 'enhanced-commands');
     }
 
+    // ---------- HELPERS ----------
+    async _publishMqttCommand(commandObj) {
+        // helper: compress + publish to SEND_MESSAGE topic
+        const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
+        if (!mqtt || typeof mqtt.publish !== 'function') {
+            throw new Error('MQTT client not available');
+        }
+        const json = JSON.stringify(commandObj);
+        const { compressDeflate } = shared_1;
+        const payload = await compressDeflate(json);
+        this.enhancedDebug(`Publishing to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id} payload=${json}`);
+        const result = await mqtt.publish({
+            topic: constants_1.Topics.SEND_MESSAGE.id,
+            qosLevel: 1,
+            payload: payload,
+        });
+        return result;
+    }
+
+    /**
+     * Publish a media reference via MQTT (send_item with upload_id)
+     * This tells the server: "I have upload_id X, attach it to thread Y"
+     */
+    async sendMediaViaMqtt({ threadId, uploadId, clientContext, text, mediaId }) {
+        this.enhancedDebug(`sendMediaViaMqtt: thread=${threadId} upload_id=${uploadId}`);
+        if (!threadId) throw new Error('threadId is required');
+        if (!uploadId) throw new Error('uploadId is required');
+
+        const ctx = clientContext || (0, uuid_1.v4)();
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'media',
+            upload_id: String(uploadId),
+            client_context: ctx,
+            timestamp: Date.now(),
+        };
+        // optional fields if present
+        if (typeof text === 'string' && text.length > 0) {
+            // Instagram sometimes keeps a caption in the media message; include as text
+            command.text = text;
+        }
+        if (mediaId) {
+            // sometimes media_id is sent along, include if present
+            command.media_id = mediaId;
+        }
+
+        return this._publishMqttCommand(command);
+    }
+
+    // ---------- TEXT / BASIC COMMANDS (unchanged behavior) ----------
     /**
      * Send text via MQTT with proper payload format
      */
@@ -39,7 +90,8 @@ class EnhancedDirectCommands {
             
             // Compress JSON payload
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             // Send to MQTT
             this.enhancedDebug(`Publishing to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
@@ -79,7 +131,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing delete command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
             const result = await mqtt.publish({
@@ -119,7 +172,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing edit command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
             const result = await mqtt.publish({
@@ -160,7 +214,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing reply command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
             const result = await mqtt.publish({
@@ -198,7 +253,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing follow subscription to MQTT`);
             const result = await mqtt.publish({
@@ -236,7 +292,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing mention subscription to MQTT`);
             const result = await mqtt.publish({
@@ -274,7 +331,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing call subscription to MQTT`);
             const result = await mqtt.publish({
@@ -313,7 +371,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing add member command to MQTT`);
             const result = await mqtt.publish({
@@ -352,7 +411,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing remove member command to MQTT`);
             const result = await mqtt.publish({
@@ -394,7 +454,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing reaction to MQTT`);
             const result = await mqtt.publish({
@@ -433,7 +494,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing mark as seen to MQTT`);
             const result = await mqtt.publish({
@@ -472,7 +534,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing activity indicator to MQTT`);
             const result = await mqtt.publish({
@@ -490,95 +553,108 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send media (image/video) via MQTT
-     * If uploadId present or item_type indicates photo, delegate to MQTT photo path.
+     * Send media (image/video)
+     *
+     * Behavior: 
+     *  - if mediaBuffer provided -> perform rupload (REST) to get upload_id, then send MQTT send_item with upload_id (no REST broadcast)
+     *  - if only uploadId provided -> send MQTT send_item with upload_id
      */
-    async sendMedia({ text, mediaId, threadId, clientContext, uploadId }) {
-        this.enhancedDebug(`Sending media ${mediaId} (uploadId: ${uploadId}) to ${threadId} via MQTT`);
-        
+    async sendMedia({ text, mediaId, threadId, clientContext, uploadId, mediaBuffer, mimeType = 'image/jpeg', duration = 0, width = 720, height = 1280 }) {
+        this.enhancedDebug(`sendMedia called for thread ${threadId} (will rupload if buffer provided)`);
         try {
-            // If an uploadId exists, this is a DM upload flow — use photo MQTT path
-            if (uploadId) {
-                return this.sendPhotoMqtt({ uploadId: String(uploadId), threadId: String(threadId), caption: text || '', clientContext });
+            if (!threadId) {
+                throw new Error('threadId is required');
             }
 
-            // Otherwise continue with existing generic media publish (share/post style)
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
+            const ig = this.realtimeClient.ig;
+            if (!ig || !ig.request) {
+                throw new Error('Instagram client not available. Make sure you are logged in.');
             }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'media',
-                media_id: mediaId,
-                upload_id: uploadId || mediaId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            // Log payload for debugging
-            this.enhancedDebug(`Payload: ${JSON.stringify(command)}`);
-            
-            const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
-            
-            this.enhancedDebug(`Publishing media to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Media sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Media send failed: ${err.message}`);
-            throw err;
-        }
-    }
 
-    /**
-     * Proper MQTT photo send. This publishes the minimal payload Instagram expects
-     * for Direct Message photos (upload_id + thread_id). Must be called after rupload.
-     */
-    async sendPhotoMqtt({ uploadId, threadId, caption = '', clientContext }) {
-        this.enhancedDebug(`Sending photo via MQTT uploadId=${uploadId} to thread=${threadId}`);
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
+            let serverUploadId = uploadId || null;
+            const isVideo = mimeType && mimeType.startsWith('video/');
 
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: String(threadId),
-                item_type: 'photo',
-                upload_id: String(uploadId),
-                text: caption || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
+            if (mediaBuffer) {
+                if (!Buffer.isBuffer(mediaBuffer) || mediaBuffer.length === 0) {
+                    throw new Error('mediaBuffer must be a non-empty Buffer when provided');
+                }
 
-            this.enhancedDebug(`Photo payload: ${JSON.stringify(command)}`);
-            const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+                // generate upload id and object name
+                serverUploadId = serverUploadId || Date.now().toString();
+                const objectName = `${(0, uuid_1.v4)()}.${isVideo ? 'mp4' : (mimeType === 'image/png' ? 'png' : 'jpg')}`;
+
+                const ruploadParams = isVideo
+                    ? {
+                          upload_id: serverUploadId,
+                          media_type: 2,
+                          xsharing_user_ids: JSON.stringify([]),
+                          upload_media_duration_ms: Math.round(duration * 1000),
+                          upload_media_width: width,
+                          upload_media_height: height,
+                      }
+                    : {
+                          upload_id: serverUploadId,
+                          media_type: 1,
+                          image_compression: '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}',
+                          xsharing_user_ids: JSON.stringify([]),
+                          is_clips_media: false,
+                      };
+
+                const uploadHeaders = {
+                    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+                    'Content-Type': mimeType,
+                    'X-Entity-Type': mimeType,
+                    'X-Entity-Length': String(mediaBuffer.length),
+                    'Content-Length': String(mediaBuffer.length),
+                };
+
+                if (isVideo) {
+                    uploadHeaders['X_FB_VIDEO_WATERFALL_ID'] = (0, uuid_1.v4)();
+                    uploadHeaders['Offset'] = '0';
+                } else {
+                    uploadHeaders['X_FB_PHOTO_WATERFALL_ID'] = (0, uuid_1.v4)();
+                }
 
-            this.enhancedDebug(`Publishing photo to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
+                const uploadUrl = isVideo ? `/rupload_igvideo/${objectName}` : `/rupload_igphoto/${objectName}`;
+
+                this.enhancedDebug(`Uploading media to ${uploadUrl} (${mediaBuffer.length} bytes)`);
+                try {
+                    const uploadResponse = await ig.request.send({
+                        url: uploadUrl,
+                        method: 'POST',
+                        headers: uploadHeaders,
+                        body: mediaBuffer,
+                    });
+
+                    if (uploadResponse && typeof uploadResponse === 'object' && uploadResponse.upload_id) {
+                        serverUploadId = uploadResponse.upload_id;
+                    }
+                    this.enhancedDebug(`✅ Media uploaded (serverUploadId=${serverUploadId})`);
+                } catch (uploadErr) {
+                    this.enhancedDebug(`Upload error: ${uploadErr.message}`);
+                    throw new Error(`Media upload failed: ${uploadErr.message}`);
+                }
+            }
+
+            // now we must have upload id
+            if (!serverUploadId) {
+                throw new Error('uploadId is required if mediaBuffer is not provided');
+            }
+
+            // Publish MQTT reference (no REST broadcast)
+            const publishResult = await this.sendMediaViaMqtt({
+                threadId,
+                uploadId: serverUploadId,
+                clientContext,
+                text,
+                mediaId,
             });
 
-            this.enhancedDebug(`✅ Photo published via MQTT!`);
-            return result;
+            this.enhancedDebug(`✅ Media reference published via MQTT for upload_id=${serverUploadId}`);
+            return publishResult;
+
         } catch (err) {
-            this.enhancedDebug(`Photo MQTT publish failed: ${err.message}`);
+            this.enhancedDebug(`sendMedia failed: ${err.message}`);
             throw err;
         }
     }
@@ -607,7 +683,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing location to MQTT`);
             const result = await mqtt.publish({
@@ -648,7 +725,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing profile to MQTT`);
             const result = await mqtt.publish({
@@ -689,7 +767,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing hashtag to MQTT`);
             const result = await mqtt.publish({
@@ -728,7 +807,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing like to MQTT`);
             const result = await mqtt.publish({
@@ -769,7 +849,8 @@ class EnhancedDirectCommands {
             };
             
             const json = JSON.stringify(command);
-            const payload = await (0, shared_1.compressDeflate)(json);
+            const { compressDeflate } = shared_1;
+            const payload = await compressDeflate(json);
             
             this.enhancedDebug(`Publishing story to MQTT`);
             const result = await mqtt.publish({
@@ -787,19 +868,11 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send photo via Realtime (Upload + Broadcast via MQTT)
-     * This method uploads the photo first (rupload) then publishes the MQTT photo command (send_item item_type=photo).
-     * Returns the MQTT publish result.
-     * 
-     * @param {Object} options - Photo sending options
-     * @param {Buffer} options.photoBuffer - Image buffer (JPEG/PNG)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {string} [options.mimeType='image/jpeg'] - MIME type
-     * @param {string} [options.clientContext] - Optional client context
+     * Send photo via Realtime (Upload + MQTT-ref)
+     * Uploads the photo via rupload, then sends MQTT send_item with upload_id.
      */
     async sendPhotoViaRealtime({ photoBuffer, threadId, caption = '', mimeType = 'image/jpeg', clientContext }) {
-        this.enhancedDebug(`Sending photo to thread ${threadId} via Realtime (upload -> MQTT)`);
+        this.enhancedDebug(`Sending photo to thread ${threadId} via Realtime (rupload + mqtt-ref)`);
         
         try {
             // Validate inputs
@@ -810,66 +883,15 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
-            const ig = this.realtimeClient.ig;
-            if (!ig || !ig.request) {
-                throw new Error('Instagram client not available. Make sure you are logged in.');
-            }
-
-            // Step 1: Upload photo using rupload endpoint
-            this.enhancedDebug(`Step 1: Uploading photo (${photoBuffer.length} bytes)...`);
-            
-            const uploadId = Date.now().toString();
-            const objectName = `${(0, uuid_1.v4)()}.${mimeType === 'image/png' ? 'png' : 'jpg'}`;
-            
-            const isJpeg = mimeType === 'image/jpeg' || mimeType === 'image/jpg';
-            const compression = isJpeg
-                ? '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}'
-                : '{"lib_name":"png","lib_version":"1.0","quality":"100"}';
-
-            const ruploadParams = {
-                upload_id: uploadId,
-                media_type: 1,
-                image_compression: compression,
-                xsharing_user_ids: JSON.stringify([]),
-                is_clips_media: false,
-            };
-
-            const uploadHeaders = {
-                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
-                'Content-Type': mimeType,
-                'X_FB_PHOTO_WATERFALL_ID': (0, uuid_1.v4)(),
-                'X-Entity-Type': mimeType,
-                'X-Entity-Length': String(photoBuffer.length),
-                'Content-Length': String(photoBuffer.length),
-            };
-
-            const uploadUrl = `/rupload_igphoto/${objectName}`;
-
-            let serverUploadId = uploadId;
-            try {
-                const uploadResponse = await ig.request.send({
-                    url: uploadUrl,
-                    method: 'POST',
-                    headers: uploadHeaders,
-                    body: photoBuffer,
-                });
-
-                if (uploadResponse && typeof uploadResponse === 'object' && (uploadResponse.upload_id || uploadResponse.body?.upload_id || uploadResponse.data?.upload_id)) {
-                    serverUploadId = uploadResponse.upload_id || (uploadResponse.body && uploadResponse.body.upload_id) || (uploadResponse.data && uploadResponse.data.upload_id) || serverUploadId;
-                }
-                this.enhancedDebug(`✅ Photo uploaded! upload_id: ${serverUploadId}`);
-            } catch (uploadErr) {
-                this.enhancedDebug(`Upload error: ${uploadErr.message}`);
-                throw new Error(`Photo upload failed: ${uploadErr.message}`);
-            }
-
-            // Step 2: Publish photo via MQTT (correct path)
-            this.enhancedDebug(`Step 2: Publishing photo via MQTT to thread ${threadId}...`);
-            const mqttResult = await this.sendPhotoMqtt({ uploadId: serverUploadId, threadId: String(threadId), caption, clientContext });
-            this.enhancedDebug(`✅ Photo MQTT publish result: ${JSON.stringify(mqttResult)}`);
-            return mqttResult;
-
+            // delegate to sendMedia which handles rupload + mqtt publish
+            const result = await this.sendMedia({
+                text: caption,
+                threadId,
+                clientContext,
+                mediaBuffer: photoBuffer,
+                mimeType,
+            });
+            return result;
         } catch (err) {
             this.enhancedDebug(`sendPhotoViaRealtime failed: ${err.message}`);
             throw err;
@@ -884,22 +906,11 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send video via Realtime (Upload + Broadcast)
-     * 
-     * NOTE: Video via MQTT is more complex; for now this continues to use existing rupload + REST broadcast path.
-     * If you want MQTT video publish, we can add similar sendVideoMqtt that publishes item_type 'video' with upload_id.
-     * 
-     * @param {Object} options - Video sending options
-     * @param {Buffer} options.videoBuffer - Video buffer (MP4)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {number} [options.duration] - Video duration in seconds
-     * @param {number} [options.width] - Video width
-     * @param {number} [options.height] - Video height
-     * @param {string} [options.clientContext] - Optional client context
+     * Send video via Realtime (Upload + MQTT-ref)
+     * Uploads video via rupload, then sends MQTT send_item with upload_id.
      */
-    async sendVideoViaRealtime({ videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280, clientContext }) {
-        this.enhancedDebug(`Sending video to thread ${threadId} via Realtime`);
+    async sendVideoViaRealtime({ videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280, mimeType = 'video/mp4', clientContext }) {
+        this.enhancedDebug(`Sending video to thread ${threadId} via Realtime (rupload + mqtt-ref)`);
         
         try {
             // Validate inputs
@@ -910,85 +921,17 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
-            const ig = this.realtimeClient.ig;
-            if (!ig || !ig.request) {
-                throw new Error('Instagram client not available. Make sure you are logged in.');
-            }
-
-            // Step 1: Upload video using rupload endpoint
-            this.enhancedDebug(`Step 1: Uploading video (${videoBuffer.length} bytes)...`);
-            
-            const uploadId = Date.now().toString();
-            const objectName = `${(0, uuid_1.v4)()}.mp4`;
-            
-            const ruploadParams = {
-                upload_id: uploadId,
-                media_type: 2, // 2 = video
-                xsharing_user_ids: JSON.stringify([]),
-                upload_media_duration_ms: Math.round(duration * 1000),
-                upload_media_width: width,
-                upload_media_height: height,
-            };
-
-            const uploadHeaders = {
-                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
-                'Content-Type': 'video/mp4',
-                'X_FB_VIDEO_WATERFALL_ID': (0, uuid_1.v4)(),
-                'X-Entity-Type': 'video/mp4',
-                'X-Entity-Length': String(videoBuffer.length),
-                'Content-Length': String(videoBuffer.length),
-                'Offset': '0',
-            };
-
-            const uploadUrl = `/rupload_igvideo/${objectName}`;
-
-            let serverUploadId = uploadId;
-            try {
-                const uploadResponse = await ig.request.send({
-                    url: uploadUrl,
-                    method: 'POST',
-                    headers: uploadHeaders,
-                    body: videoBuffer,
-                });
-
-                if (uploadResponse && typeof uploadResponse === 'object' && (uploadResponse.upload_id || uploadResponse.body?.upload_id || uploadResponse.data?.upload_id)) {
-                    serverUploadId = uploadResponse.upload_id || (uploadResponse.body && uploadResponse.body.upload_id) || (uploadResponse.data && uploadResponse.data.upload_id) || serverUploadId;
-                }
-                this.enhancedDebug(`✅ Video uploaded! upload_id: ${serverUploadId}`);
-            } catch (uploadErr) {
-                this.enhancedDebug(`Video upload error: ${uploadErr.message}`);
-                throw new Error(`Video upload failed: ${uploadErr.message}`);
-            }
-
-            // Step 2: Broadcast the uploaded video to the thread via REST (legacy)
-            this.enhancedDebug(`Step 2: Broadcasting video to thread ${threadId} via REST upload_video endpoint...`);
-            
-            const broadcastForm = {
-                upload_id: serverUploadId,
-                action: 'send_item',
-                thread_ids: JSON.stringify([String(threadId)]),
-                video_result: '',
-            };
-
-            if (caption) {
-                broadcastForm.caption = caption;
-            }
-
-            try {
-                const broadcastResponse = await ig.request.send({
-                    url: '/direct_v2/threads/broadcast/upload_video/',
-                    method: 'POST',
-                    form: broadcastForm,
-                });
-
-                this.enhancedDebug(`✅ Video sent successfully to thread ${threadId}!`);
-                return broadcastResponse;
-            } catch (broadcastErr) {
-                this.enhancedDebug(`Video broadcast error: ${broadcastErr.message}`);
-                throw new Error(`Video broadcast failed: ${broadcastErr.message}`);
-            }
-
+            const result = await this.sendMedia({
+                text: caption,
+                threadId,
+                clientContext,
+                mediaBuffer: videoBuffer,
+                mimeType,
+                duration,
+                width,
+                height,
+            });
+            return result;
         } catch (err) {
             this.enhancedDebug(`sendVideoViaRealtime failed: ${err.message}`);
             throw err;
@@ -1003,4 +946,3 @@ class EnhancedDirectCommands {
     }
 }
 exports.EnhancedDirectCommands = EnhancedDirectCommands;
-

package/package.json

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