nodejs-insta-private-api-mqtt 1.0.0

package/dist/sendmedia/sendPhoto.js

@@ -0,0 +1,145 @@
+/**
+ * sendPhoto.js
+ * High-level helper to send a previously uploaded photo to Instagram Direct (DM or Group).
+ *
+ * Requires:
+ *  - uploadPhoto(session, photoBuffer, options) from ./uploadPhoto
+ *
+ * Supports:
+ *  - Send to a single user by userId (recipient_users)
+ *  - Send to an existing thread (group) by threadId
+ *  - Optional caption
+ *  - Optional mentions (array of userIds) embedded in caption
+ *
+ * Usage:
+ *   const sendPhoto = require('./sendPhoto');
+ *   await sendPhoto(session, {
+ *     photoBuffer: fs.readFileSync('./image.jpg'),
+ *     userId: '123456789',            // or threadId: '340282366841710300949128123456789'
+ *     caption: 'Salut! 👋',
+ *   });
+ *
+ * Notes:
+ *  - If you pass userId, it broadcasts to that user (DM).
+ *  - If you pass threadId, it broadcasts into that existing thread (group or DM thread).
+ *  - Exactly one of { userId, threadId } must be provided.
+ */
+
+const uploadPhoto = require('./uploadPhoto');
+
+/**
+ * @typedef {Object} SendPhotoOptions
+ * @property {Buffer} photoBuffer - Required image buffer (JPEG/PNG)
+ * @property {string} [mimeType='image/jpeg'] - 'image/jpeg' | 'image/png'
+ * @property {string} [fileName] - Optional file name (will be sanitized)
+ * @property {string} [caption] - Optional caption text
+ * @property {string} [userId] - Send to user (DM) — exactly one of userId or threadId
+ * @property {string} [threadId] - Send to existing thread (group or DM) — exactly one of userId or threadId
+ * @property {string[]} [mentions] - Optional array of userIds mentioned in caption
+ * @property {AbortSignal} [signal] - Optional AbortSignal to cancel
+ */
+
+/**
+ * Send a photo to Instagram Direct.
+ * Internally:
+ *  - Uploads photo via rupload to get upload_id
+ *  - Broadcasts the uploaded photo to either a user (DM) or an existing thread
+ *
+ * @param {object} session - Authenticated session (with request.send)
+ * @param {SendPhotoOptions} opts - Options
+ * @returns {Promise<object>} Instagram response object
+ */
+async function sendPhoto(session, opts = {}) {
+  const {
+    photoBuffer,
+    mimeType = 'image/jpeg',
+    fileName,
+    caption = '',
+    userId,
+    threadId,
+    mentions = [],
+    signal,
+  } = 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.');
+  }
+  // Validate photo buffer
+  if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+    throw new Error('sendPhoto: photoBuffer must be a non-empty Buffer.');
+  }
+
+  // 1) Upload photo to get upload_id
+  const upload_id = await uploadPhoto(session, photoBuffer, { mimeType, fileName, signal });
+
+  // 2) Build base form payload
+  const form = {
+    upload_id,
+    action: 'send_item',
+    // Optional caption field
+    caption,
+  };
+
+  // 3) Mentions (optional): IG expects entities when caption includes mentions
+  // This is a basic structure; adjust offsets if you programmatically embed @handles into caption.
+  if (Array.isArray(mentions) && mentions.length > 0) {
+    form.entities = JSON.stringify(
+      mentions.map((uid) => ({
+        // Simple entity type for user mention; offsets require matching caption positions
+        // If you don't compute offsets, IG may still accept the payload without entities.
+        // Providing user_id can help IG recognize mentions linked to caption text.
+        user_id: String(uid),
+        type: 'mention',
+      }))
+    );
+  }
+
+  // 4) Destination-specific fields
+  let url;
+  if (userId) {
+    // DM to user: recipient_users is an array-of-arrays of userIds as strings
+    url = '/direct_v2/threads/broadcast/upload_photo/';
+    form.recipient_users = JSON.stringify([[String(userId)]]);
+  } else {
+    // Existing thread: use thread id
+    url = '/direct_v2/threads/broadcast/upload_photo/';
+    form.thread_ids = JSON.stringify([String(threadId)]);
+  }
+
+  // 5) Send broadcast request
+  try {
+    const response = await session.request.send({
+      url,
+      method: 'POST',
+      form,
+      signal,
+    });
+
+    if (!response) {
+      throw new Error('sendPhoto: Empty response from Instagram broadcast endpoint.');
+    }
+    return response;
+  } catch (err) {
+    throw new Error(`sendPhoto: Broadcast failed — ${normalizeError(err)}`);
+  }
+}
+
+/**
+ * Normalize error shapes to readable text.
+ */
+function normalizeError(err) {
+  if (!err) return 'Unknown error';
+  if (typeof err === 'string') return err;
+  if (err.message) return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return 'Unserializable error';
+  }
+}
+
+module.exports = sendPhoto;

package/dist/sendmedia/uploadPhoto.js

@@ -0,0 +1,175 @@
+/**
+ * uploadPhoto.js
+ * Robust image upload helper for nodejs-insta-private-api.
+ *
+ * Usage:
+ *   const uploadPhoto = require('./uploadPhoto');
+ *   const uploadId = await uploadPhoto(session, photoBuffer, { mimeType: 'image/jpeg' });
+ *
+ * Notes:
+ * - Expects a valid `session` object from nodejs-insta-private-api with `request.send`.
+ * - Handles JPEG/PNG; converts common metadata to Instagram-friendly headers.
+ * - Returns a string upload_id to be used in the subsequent direct send call.
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Validate buffer and mime type
+ */
+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(', ')}.`);
+  }
+}
+
+/**
+ * Build Instagram rupload params for photo
+ */
+function buildRuploadParams(uploadId, mimeType) {
+  // Instagram expects media_type=1 for photo.
+  // image_compression string must be JSON but sent as string.
+  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"}';
+
+  return {
+    upload_id: uploadId,
+    media_type: 1,
+    image_compression: compression,
+    // Optional hints commonly used by IG web clients
+    xsharing_user_ids: JSON.stringify([]),
+    // mark this upload as photo (not reels/clips)
+    is_clips_media: false,
+  };
+}
+
+/**
+ * Upload a photo to Instagram's rupload endpoint.
+ * Returns upload_id string on success.
+ *
+ * @param {object} session - An authenticated session with request.send({ url, method, headers, body })
+ * @param {Buffer} photoBuffer - Image buffer (JPEG or PNG)
+ * @param {object} [options]
+ * @param {string} [options.mimeType='image/jpeg'] - 'image/jpeg' | 'image/png'
+ * @param {string} [options.fileName] - Optional file name; autogenerated if not provided
+ * @param {number} [options.quality] - 50..100 (only applies to JPEG header hint)
+ * @param {AbortSignal} [options.signal] - Optional AbortSignal to cancel
+ * @returns {Promise<string>} upload_id
+ */
+async function uploadPhoto(session, photoBuffer, options = {}) {
+  const {
+    mimeType = 'image/jpeg',
+    fileName,
+    quality,
+    signal,
+  } = options;
+
+  validateImageInput(photoBuffer, mimeType);
+
+  // Generate uploadId and object name used in rupload path
+  const uploadId = Date.now().toString();
+  const objectName = fileName
+    ? sanitizeFileName(fileName, mimeType)
+    : `${uuidv4()}.${mimeType === 'image/png' ? 'png' : 'jpg'}`;
+
+  // Build rupload params
+  const ruploadParams = buildRuploadParams(uploadId, mimeType);
+  if (quality && Number.isFinite(quality)) {
+    const q = Math.max(50, Math.min(100, Math.round(quality)));
+    // override compression string for JPEG quality if provided
+    if (mimeType === 'image/jpeg' || mimeType === 'image/jpg') {
+      ruploadParams.image_compression = `{"lib_name":"moz","lib_version":"3.1.m","quality":"${q}"}`;
+    }
+  }
+
+  // Headers expected by Instagram rupload
+  const headers = {
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'Content-Type': mimeType,
+    'X_FB_PHOTO_WATERFALL_ID': uuidv4(), // optional tracing header used by IG
+    'X-Entity-Type': mimeType,
+    'X-Entity-Length': String(photoBuffer.length),
+    'Content-Length': String(photoBuffer.length),
+    // Some clients also send:
+    // 'Offset': '0',
+  };
+
+  const url = `/rupload_igphoto/${objectName}`;
+
+  // Send the upload request
+  try {
+    const response = await session.request.send({
+      url,
+      method: 'POST',
+      headers,
+      body: photoBuffer,
+      signal,
+    });
+
+    // Basic success validation (IG often returns JSON with upload_id or ok status)
+    if (!response) {
+      throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
+    }
+
+    // If response contains upload_id, prefer it; otherwise use our generated one
+    const serverUploadId =
+      (typeof response === 'object' && response.upload_id) ||
+      (response?.body && parseUploadIdFromBody(response.body));
+
+    return serverUploadId || uploadId;
+  } catch (err) {
+    const message = normalizeError(err);
+    throw new Error(`uploadPhoto: Upload failed — ${message}`);
+  }
+}
+
+/**
+ * Ensure file name extension matches mime type; strip invalid chars.
+ */
+function sanitizeFileName(name, mimeType) {
+  const safe = String(name).replace(/[^a-zA-Z0-9._-]/g, '_');
+  const ext = safe.split('.').pop()?.toLowerCase();
+  const desiredExt = mimeType === 'image/png' ? 'png' : 'jpg';
+  if (ext !== desiredExt) {
+    // replace or append correct extension
+    const base = safe.replace(/\.[^.]+$/, '');
+    return `${base}.${desiredExt}`;
+  }
+  return safe;
+}
+
+/**
+ * Attempt to parse upload_id from response body if present.
+ */
+function parseUploadIdFromBody(body) {
+  try {
+    const text = Buffer.isBuffer(body) ? body.toString('utf8') : String(body || '');
+    const json = JSON.parse(text);
+    if (json && typeof json.upload_id === 'string') return json.upload_id;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Normalize common error shapes to readable text.
+ */
+function normalizeError(err) {
+  if (!err) return 'Unknown error';
+  if (typeof err === 'string') return err;
+  if (err.message) return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return 'Unserializable error';
+  }
+}
+
+module.exports = uploadPhoto;

package/dist/sendmedia/uploadfFile.js

@@ -0,0 +1,264 @@
+/**
+ * uploadFile.js
+ * Robust, resumable upload helper for videos/audio/doc-like media (where supported) to Instagram rupload.
+ *
+ * Usage:
+ *   const uploadFile = require('./uploadFile');
+ *   const uploadId = await uploadFile(session, fileBuffer, {
+ *     mimeType: 'video/mp4',
+ *     fileName: 'clip.mp4',
+ *     isClipsMedia: false,     // set true for reels-like uploads if your flow supports it
+ *     chunkSize: 512 * 1024,   // 512KB chunks (safe default)
+ *   });
+ *
+ * Notes:
+ * - Instagram Direct primarily supports photo/video/audio; arbitrary files (pdf/zip) are typically NOT accepted by IG clients.
+ * - For videos, use `video/mp4`. For audio, try `audio/mpeg` (limited support). For images, prefer uploadPhoto.js.
+ * - This helper performs chunked upload using rupload endpoints and returns an `upload_id` string.
+ * - Expects `session.request.send({ url, method, headers, body })` similar to nodejs-insta-private-api clients.
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+const DEFAULT_CHUNK_SIZE = 512 * 1024; // 512KB default chunks
+
+/**
+ * Validate upload input
+ */
+function validateFileInput(fileBuffer, mimeType) {
+  if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+    throw new Error('uploadFile: fileBuffer must be a non-empty Buffer.');
+  }
+  if (typeof mimeType !== 'string' || mimeType.length === 0) {
+    throw new Error('uploadFile: mimeType must be a non-empty string (e.g., "video/mp4").');
+  }
+}
+
+/**
+ * Ensure file name extension matches mime type; strip invalid chars.
+ */
+function sanitizeFileName(name, mimeType) {
+  const safe = String(name || '').replace(/[^a-zA-Z0-9._-]/g, '_');
+  const ext = safe.split('.').pop()?.toLowerCase();
+  const desiredExt = guessExtFromMime(mimeType);
+  if (!safe) {
+    return `${uuidv4()}.${desiredExt}`;
+  }
+  if (!ext || ext !== desiredExt) {
+    const base = safe.replace(/\.[^.]+$/, '');
+    return `${base}.${desiredExt}`;
+  }
+  return safe;
+}
+
+/**
+ * Guess file extension based on mime type (limited map).
+ */
+function guessExtFromMime(mimeType) {
+  if (mimeType === 'video/mp4') return 'mp4';
+  if (mimeType === 'image/jpeg' || mimeType === 'image/jpg') return 'jpg';
+  if (mimeType === 'image/png') return 'png';
+  if (mimeType === 'audio/mpeg') return 'mp3';
+  // fallback
+  return 'bin';
+}
+
+/**
+ * Build rupload params for non-photo media.
+ * - For video: media_type=2
+ * - For audio: still treated as video-like upload in some web flows (limited)
+ */
+function buildRuploadParams(uploadId, mimeType, opts) {
+  const isVideo = mimeType.startsWith('video/');
+  const isAudio = mimeType.startsWith('audio/');
+  const isImage = mimeType.startsWith('image/');
+
+  // Instagram expects:
+  // - video: media_type=2 with specific flags
+  // - image: use uploadPhoto.js (media_type=1). Here we allow image for completeness but recommend uploadPhoto.js
+  const params = {
+    upload_id: uploadId,
+    media_type: isImage ? 1 : 2,
+    xsharing_user_ids: JSON.stringify([]),
+    is_clips_media: Boolean(opts.isClipsMedia),
+  };
+
+  if (isVideo) {
+    params.video_format = 'mp4';
+    params.for_direct_story = false;
+  }
+  if (isAudio) {
+    // IG web may not fully support audio in Direct; leaving generic params
+    params.audio_format = 'mpeg';
+  }
+
+  return params;
+}
+
+/**
+ * Parse `upload_id` from response body if present.
+ */
+function parseUploadIdFromBody(body) {
+  try {
+    const text = Buffer.isBuffer(body) ? body.toString('utf8') : String(body || '');
+    const json = JSON.parse(text);
+    if (json && typeof json.upload_id === 'string') return json.upload_id;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Normalize error shapes to readable text.
+ */
+function normalizeError(err) {
+  if (!err) return 'Unknown error';
+  if (typeof err === 'string') return err;
+  if (err.message) return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return 'Unserializable error';
+  }
+}
+
+/**
+ * Perform the initial "create upload" handshake for video/audio.
+ * Some IG flows accept an initial POST with headers only (no body) to initialize the rupload.
+ */
+async function initRupload(session, url, headers, signal) {
+  try {
+    const res = await session.request.send({
+      url,
+      method: 'POST',
+      headers,
+      // body omitted for init in some flows
+      signal,
+    });
+    return res;
+  } catch (err) {
+    // Some endpoints accept direct chunk upload without explicit init; not fatal.
+    return null;
+  }
+}
+
+/**
+ * Upload a single chunk to rupload endpoint.
+ */
+async function uploadChunk(session, url, headers, chunk, offset, signal) {
+  const chunkHeaders = {
+    ...headers,
+    'X-Entity-Length': String(headers['X-Entity-Length']), // total length
+    'X-Entity-Name': headers['X-Entity-Name'],
+    'X-Entity-Type': headers['X-Entity-Type'],
+    'Offset': String(offset),
+    'Content-Length': String(chunk.length),
+  };
+
+  const res = await session.request.send({
+    url,
+    method: 'POST',
+    headers: chunkHeaders,
+    body: chunk,
+    signal,
+  });
+  return res;
+}
+
+/**
+ * Upload file (video/audio/image as supported) via rupload with chunking.
+ *
+ * @param {object} session - Authenticated session with request.send
+ * @param {Buffer} fileBuffer - File data buffer
+ * @param {object} [options]
+ * @param {string} [options.mimeType='video/mp4'] - e.g., 'video/mp4', 'audio/mpeg'
+ * @param {string} [options.fileName] - Optional, sanitized based on mime
+ * @param {number} [options.chunkSize=512*1024] - Chunk size in bytes
+ * @param {boolean} [options.isClipsMedia=false] - Mark as clips/reels upload hint
+ * @param {AbortSignal} [options.signal] - Optional AbortSignal
+ * @returns {Promise<string>} upload_id
+ */
+async function uploadFile(session, fileBuffer, options = {}) {
+  const {
+    mimeType = 'video/mp4',
+    fileName,
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    isClipsMedia = false,
+    signal,
+  } = options;
+
+  validateFileInput(fileBuffer, mimeType);
+
+  const uploadId = Date.now().toString();
+  const objectName = sanitizeFileName(fileName, mimeType);
+  const totalLength = fileBuffer.length;
+
+  const ruploadParams = buildRuploadParams(uploadId, mimeType, { isClipsMedia });
+  const baseHeaders = {
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'X_FB_VIDEO_WATERFALL_ID': uuidv4(), // tracing header for video-like uploads
+    'X-Entity-Type': mimeType,
+    'X-Entity-Name': objectName,
+    'X-Entity-Length': String(totalLength),
+    'Content-Type': mimeType,
+  };
+
+  // Choose endpoint based on type
+  const endpoint =
+    mimeType.startsWith('image/')
+      ? `/rupload_igphoto/${objectName}`
+      : `/rupload_igvideo/${objectName}`;
+
+  // Optional init step (some IG flows initialize upload session)
+  await initRupload(session, endpoint, baseHeaders, signal).catch(() => null);
+
+  // Chunked upload loop
+  let offset = 0;
+  const size = Math.max(64 * 1024, Math.min(4 * 1024 * 1024, chunkSize)); // clamp to 64KB..4MB
+
+  try {
+    while (offset < totalLength) {
+      const end = Math.min(offset + size, totalLength);
+      const chunk = fileBuffer.subarray(offset, end);
+
+      const res = await uploadChunk(session, endpoint, baseHeaders, chunk, offset, signal);
+
+      // Server may respond with intermediate states; we proceed unless explicit failure
+      if (!res) {
+        throw new Error(`uploadFile: Empty response at offset ${offset}.`);
+      }
+
+      // Advance offset
+      offset = end;
+    }
+  } catch (err) {
+    throw new Error(`uploadFile: Chunk upload failed at offset ${offset} — ${normalizeError(err)}`);
+  }
+
+  // Final confirmation: attempt a "finish" ping (some clients re-POST zero-length or rely on server auto-finish)
+  // We'll try a lightweight confirmation request and parse upload_id if present.
+  try {
+    const confirm = await session.request.send({
+      url: endpoint,
+      method: 'POST',
+      headers: {
+        ...baseHeaders,
+        'Offset': String(totalLength),
+        'Content-Length': '0',
+      },
+      signal,
+    });
+
+    const serverUploadId =
+      (typeof confirm === 'object' && confirm.upload_id) ||
+      (confirm?.body && parseUploadIdFromBody(confirm.body));
+
+    return serverUploadId || uploadId;
+  } catch {
+    // If confirmation fails but chunks completed, many flows still accept the generated uploadId.
+    return uploadId;
+  }
+}
+
+module.exports = uploadFile;