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

package/dist/sendmedia/sendPhoto.js

@@ -1,101 +1,142 @@
 /**
- * sendPhoto.js - Fixed to support MQTT if realtime client provided
+ * uploadPhoto.fixed.js
+ *
+ * Fixed and hardened version of uploadPhoto for nodejs-insta-private-api(-mqtt).
+ * - sends Buffer in `data` (axios uses `data`, not `body`)
+ * - sets axios-friendly headers (X-Entity-Type uses provided mimeType)
+ * - removes explicit Accept-Encoding header (axios handles it)
+ * - sets maxContentLength / maxBodyLength via Request httpClient (should be patched there too)
+ * - returns the rupload/uploadId (server-provided when available, otherwise local uploadId)
+ *
+ * Usage:
+ *   const uploadPhoto = require('./uploadPhoto.fixed');
+ *   const uploadId = await uploadPhoto(session, photoBuffer, { mimeType: 'image/jpeg' });
+ *
+ * Note: session.request.send(...) is expected to accept axios-like options.
  */
 
-const uploadPhoto = require('./uploadPhoto');
+const { v4: uuidv4 } = require('uuid');
+
+function validateImageInput(photoBuffer, mimeType) {
+  if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+    throw new Error('uploadPhoto: photoBuffer must be a non-empty Buffer.');
+  }
+  const allowed = ['image/jpeg', 'image/jpg', 'image/png'];
+  if (!allowed.includes(mimeType)) {
+    throw new Error(`uploadPhoto: mimeType must be one of ${allowed.join(', ')}.`);
+  }
+}
+
+function buildRuploadParams(uploadId, mimeType) {
+  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' };
+
+  // Match instagram-private-api shape; include is_sidecar for compatibility
+  return {
+    retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+    media_type: '1',
+    upload_id: uploadId.toString(),
+    xsharing_user_ids: JSON.stringify([]),
+    image_compression: JSON.stringify(compression),
+    is_sidecar: '0'
+  };
+}
 
 /**
- * Send a photo to Instagram Direct.
+ * Upload a photo buffer to Instagram rupload endpoint.
+ *
+ * @param {Object} session - client/session object that exposes session.request.send(options)
+ * @param {Buffer} photoBuffer - binary buffer of the image
+ * @param {Object} options - { mimeType = 'image/jpeg', fileName?, signal? }
+ * @returns {Promise<string>} uploadId (server upload_id when available, otherwise local uploadId)
  */
-async function sendPhoto(session, opts = {}) {
+async function uploadPhoto(session, photoBuffer, options = {}) {
   const {
-    photoBuffer,
     mimeType = 'image/jpeg',
     fileName,
-    caption = '',
-    userId,
-    threadId,
-    mentions = [],
-    signal,
-    realtimeClient, // NEW: Optional realtime client for MQTT sending
-  } = opts;
-
-  // Validate destination
-  if (!userId && !threadId) {
-    throw new Error('sendPhoto: You must provide either userId (DM) or threadId (existing thread).');
-  }
-  if (userId && threadId) {
-    throw new Error('sendPhoto: Provide only one destination — userId OR threadId, not both.');
-  }
-  if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
-    throw new Error('sendPhoto: photoBuffer must be a non-empty Buffer.');
-  }
+    signal
+  } = options;
 
-  // 1) Upload photo to get upload_id
-  const upload_id = await uploadPhoto(session, photoBuffer, { mimeType, fileName, signal });
-
-  // 2) If RealtimeClient is provided and connected, use MQTT
-  if (realtimeClient) {
-      // We need to use EnhancedDirectCommands or similar
-      // Assuming realtimeClient has direct/enhanced/graph interface or we can just publish
-      // EnhancedDirectCommands is usually at realtimeClient.direct (if using standard structure)
-      // or we can instantiate it if not present.
-      
-      // Check if .direct exists and has sendMedia
-      if (realtimeClient.direct && typeof realtimeClient.direct.sendMedia === 'function') {
-          return await realtimeClient.direct.sendMedia({
-              text: caption,
-              mediaId: upload_id,
-              threadId: threadId || userId, // Note: MQTT usually needs threadId. If userId provided, might need to resolve threadId first or use specific user send.
-              // Actually, sendMedia usually takes threadId. If userId is provided, we might be stuck if we don't have a thread.
-              // MQTT is best for existing threads. 
-              // If userId is provided, we might need to create thread via REST first?
-              // For now, assume threadId is preferred for MQTT.
-          });
-      }
-  }
+  validateImageInput(photoBuffer, mimeType);
 
-  // 3) Fallback to REST Broadcast
-  const form = {
-    upload_id,
-    action: 'send_item',
-    caption,
-  };
+  // local upload id similar to insta clients
+  const uploadId = Date.now().toString();
+  // create an entity name similar to instagram-private-api naming
+  const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+  const name = `${uploadId}_0_${randomSuffix}`;
+  const contentLength = photoBuffer.byteLength;
 
-  if (Array.isArray(mentions) && mentions.length > 0) {
-    form.entities = JSON.stringify(
-      mentions.map((uid) => ({
-        user_id: String(uid),
-        type: 'mention',
-      }))
-    );
-  }
+  const ruploadParams = buildRuploadParams(uploadId, mimeType);
 
-  let url;
-  if (userId) {
-    url = '/direct_v2/threads/broadcast/upload_photo/';
-    form.recipient_users = JSON.stringify([[String(userId)]]);
-  } else {
-    url = '/direct_v2/threads/broadcast/upload_photo/';
-    form.thread_ids = JSON.stringify([String(threadId)]);
-  }
+  const headers = {
+    'X_FB_PHOTO_WATERFALL_ID': uuidv4(),
+    'X-Entity-Type': mimeType,                      // use actual mimeType
+    'Offset': '0',
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'X-Entity-Name': name,
+    'X-Entity-Length': String(contentLength),
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': String(contentLength),
+    // remove explicit Accept-Encoding to avoid conflicts; axios handles compression
+    // 'Accept-Encoding': 'gzip',
+  };
+
+  const url = `/rupload_igphoto/${name}`;
 
   try {
+    // session.request.send is expected to forward options to axios (or similar)
+    // We MUST use `data` (not `body`) for axios-friendly request.
     const response = await session.request.send({
       url,
       method: 'POST',
-      form,
+      headers,
+      data: photoBuffer,
       signal,
+      // ensure axios does not apply any transform that would corrupt binary
+      transformRequest: [(d) => d]
     });
 
     if (!response) {
-      throw new Error('sendPhoto: Empty response from Instagram broadcast endpoint.');
+      throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
     }
-    return response;
+
+    // The request wrapper in different forks may return { body, headers } OR axios response
+    // Normalize possible shapes:
+    let respBody = null;
+    if (response.body !== undefined) {
+      // wrapper returned { body, headers }
+      respBody = response.body;
+    } else if (response.data !== undefined) {
+      respBody = response.data;
+    } else {
+      respBody = response;
+    }
+
+    // If respBody is a string, try parse JSON
+    let parsed = null;
+    if (typeof respBody === 'string') {
+      try { parsed = JSON.parse(respBody); } catch (e) { parsed = null; }
+    } else if (typeof respBody === 'object') {
+      parsed = respBody;
+    }
+
+    // server might return upload_id inside parsed
+    const serverUploadId = parsed && (parsed.upload_id || parsed.uploadId || parsed.media && parsed.media.upload_id);
+    if (serverUploadId) {
+      return serverUploadId.toString();
+    }
+
+    // fallback: some endpoints respond with status only; return our local uploadId
+    return uploadId;
   } catch (err) {
-      const msg = err.message || JSON.stringify(err);
-    throw new Error(`sendPhoto: Broadcast failed — ${msg}`);
+    // try to unwrap axios error message
+    let msg = '';
+    if (err && err.message) msg = err.message;
+    else msg = String(err);
+    throw new Error(`uploadPhoto: Upload failed — ${msg}`);
   }
 }
 
-module.exports = sendPhoto;
+module.exports = uploadPhoto;

package/dist/sendmedia/uploadPhoto.js

@@ -55,10 +55,10 @@ async function uploadPhoto(session, photoBuffer, options = {}) {
 
   // Headers expected by Instagram rupload (matched with instagram-private-api)
   const headers = {
-    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
     'X_FB_PHOTO_WATERFALL_ID': uuidv4(),
-    'X-Entity-Type': 'image/jpeg', // Always seems to be image/jpeg for photos in IG api even if png? No, IG API uses image/jpeg for X-Entity-Type usually.
+    'X-Entity-Type': 'image/jpeg',
     'Offset': '0',
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
     'X-Entity-Name': name,
     'X-Entity-Length': String(contentLength),
     'Content-Type': 'application/octet-stream',

package/package.json

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