nodejs-insta-private-api-mqt 1.3.70

package/dist/repositories/user.repository.js

@@ -0,0 +1,360 @@
+const Repository = require('../core/repository');
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+class UserRepository extends Repository {
+  constructor(client) {
+    super(client);
+    this._usersCache = {};
+    this._usernamesCache = {};
+  }
+
+  async infoByUsername(username) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/users/${username}/usernameinfo/`,
+    });
+    return response.body.user;
+  }
+
+  async info(userId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/users/${userId}/info/`,
+    });
+    return response.body.user;
+  }
+
+  async infoV1(userId, fromModule = 'self_profile') {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/users/${userId}/info/`,
+      qs: { from_module: fromModule },
+    });
+    return response.body.user;
+  }
+
+  async userIdFromUsername(username) {
+    const user = await this.infoByUsername(username.toLowerCase());
+    return String(user.pk);
+  }
+
+  async usernameFromUserId(userId) {
+    const user = await this.info(userId);
+    return user.username;
+  }
+
+  async search(query, count = 50) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/users/search/',
+      qs: { q: query, count },
+    });
+    return response.body.users;
+  }
+
+  async searchExact(username) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/users/search/',
+      qs: {
+        q: username,
+        count: 1,
+        search_surface: 'user_search_page',
+      },
+    });
+    const users = response.body.users || [];
+    return users.find(u => u.username === username) || null;
+  }
+
+  async follow(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/create/${userId}/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+
+  async unfollow(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/destroy/${userId}/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+
+  async getFollowers(userId, amount = 200, maxId = null) {
+    return this._paginateUsers(`/api/v1/friendships/${userId}/followers/`, amount, maxId);
+  }
+
+  async getFollowing(userId, amount = 200, maxId = null) {
+    return this._paginateUsers(`/api/v1/friendships/${userId}/following/`, amount, maxId);
+  }
+
+  async _paginateUsers(endpoint, amount = 200, startMaxId = null) {
+    const allUsers = [];
+    let nextMaxId = startMaxId;
+    while (allUsers.length < amount) {
+      const qs = {};
+      if (nextMaxId) qs.max_id = nextMaxId;
+      const response = await this.client.request.send({
+        method: 'GET',
+        url: endpoint,
+        qs,
+      });
+      const body = response.body;
+      const users = body.users || [];
+      allUsers.push(...users);
+      if (!body.next_max_id) break;
+      nextMaxId = body.next_max_id;
+    }
+    return { users: allUsers.slice(0, amount), nextMaxId };
+  }
+
+  async getFriendshipStatuses(userIds) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/friendships/show_many/',
+      form: this.client.request.sign({
+        user_ids: Array.isArray(userIds) ? userIds.join(',') : userIds,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async friendshipShow(userId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/friendships/show/${userId}/`,
+    });
+    return response.body;
+  }
+
+  async getReelsTrayFeed() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/feed/reels_tray/',
+    });
+    return response.body;
+  }
+
+  async getUserTags(userId, maxId = null) {
+    const qs = {};
+    if (maxId) qs.max_id = maxId;
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/usertags/${userId}/feed/`,
+      qs,
+    });
+    return response.body;
+  }
+
+  async getUserMedias(userId, amount = 50, maxId = null) {
+    const allItems = [];
+    let nextMaxId = maxId;
+    while (allItems.length < amount) {
+      const qs = { count: Math.min(amount - allItems.length, 33) };
+      if (nextMaxId) qs.max_id = nextMaxId;
+      const response = await this.client.request.send({
+        method: 'GET',
+        url: `/api/v1/feed/user/${userId}/`,
+        qs,
+      });
+      const body = response.body;
+      allItems.push(...(body.items || []));
+      if (!body.more_available || !body.next_max_id) break;
+      nextMaxId = body.next_max_id;
+    }
+    return allItems.slice(0, amount);
+  }
+
+  async getUserReels(userId, amount = 50, maxId = null) {
+    const allItems = [];
+    let nextMaxId = maxId;
+    while (allItems.length < amount) {
+      const response = await this.client.request.send({
+        method: 'POST',
+        url: '/api/v1/clips/user/',
+        form: {
+          target_user_id: userId,
+          page_size: Math.min(amount - allItems.length, 12),
+          max_id: nextMaxId || '',
+        },
+      });
+      const body = response.body;
+      for (const item of (body.items || [])) {
+        allItems.push(item.media || item);
+      }
+      const pagingInfo = body.paging_info || {};
+      if (!pagingInfo.more_available) break;
+      nextMaxId = pagingInfo.max_id || '';
+    }
+    return allItems.slice(0, amount);
+  }
+
+  async getUserClips(userId, amount = 50, maxId = null) {
+    return this.getUserReels(userId, amount, maxId);
+  }
+
+  async getUserStories(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/feed/user/${userId}/story/`,
+      form: {
+        supported_capabilities_new: JSON.stringify(this.client.state.constants.SUPPORTED_CAPABILITIES),
+      },
+    });
+    return response.body;
+  }
+
+  async setSelfBio(biography) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/accounts/set_biography/',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        raw_text: biography,
+      }),
+    });
+    return response.body;
+  }
+
+  async report(userId, reason = 1) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/users/${userId}/flag_user/`,
+      form: this.client.request.sign({
+        reason_id: reason,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async getSuggested() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/discover/ayml/',
+    });
+    return response.body;
+  }
+
+  async block(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/block/${userId}/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+
+  async unblock(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/unblock/${userId}/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+
+  async mute(userId, { muteStories = false, mutePosts = false } = {}) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/mute_posts_or_story_from_follow/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        target_posts_author_id: mutePosts ? userId : '',
+        target_reel_author_id: muteStories ? userId : '',
+      }),
+    });
+    return response.body;
+  }
+
+  async unmute(userId, { unmuteStories = false, unmutePosts = false } = {}) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/unmute_posts_or_story_from_follow/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        target_posts_author_id: unmutePosts ? userId : '',
+        target_reel_author_id: unmuteStories ? userId : '',
+      }),
+    });
+    return response.body;
+  }
+
+  async removeFollower(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/remove_follower/${userId}/`,
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+
+  async getBlockedUsers() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/users/blocked_list/',
+    });
+    return response.body;
+  }
+
+  async getMutualFollowers(userId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/friendships/${userId}/mutual_followers/`,
+    });
+    return response.body;
+  }
+
+  static mediaPkFromCode(code) {
+    let pk = BigInt(0);
+    for (let i = 0; i < code.length; i++) {
+      const idx = ALPHABET.indexOf(code[i]);
+      if (idx === -1) continue;
+      pk = pk * BigInt(64) + BigInt(idx);
+    }
+    return pk.toString();
+  }
+
+  static mediaCodeFromPk(pk) {
+    let id = BigInt(pk);
+    let code = '';
+    while (id > BigInt(0)) {
+      const remainder = Number(id % BigInt(64));
+      code = ALPHABET[remainder] + code;
+      id = id / BigInt(64);
+    }
+    return code;
+  }
+}
+
+module.exports = UserRepository;

package/dist/sendmedia/index.js

@@ -0,0 +1,27 @@
+const sendPhoto = require('./sendPhoto');
+const sendFile = require('./sendFile');
+const uploadPhoto = require('./uploadPhoto');
+const uploadFile = require('./uploadfFile');
+const sendRavenPhotoModule = require('./sendRavenPhoto');
+const sendRavenVideoModule = require('./sendRavenVideo');
+
+const sendRavenPhoto = sendRavenPhotoModule.sendRavenPhoto || sendRavenPhotoModule;
+const sendRavenPhotoOnce = sendRavenPhotoModule.sendRavenPhotoOnce;
+const sendRavenPhotoReplayable = sendRavenPhotoModule.sendRavenPhotoReplayable;
+
+const sendRavenVideo = sendRavenVideoModule.sendRavenVideo || sendRavenVideoModule;
+const sendRavenVideoOnce = sendRavenVideoModule.sendRavenVideoOnce;
+const sendRavenVideoReplayable = sendRavenVideoModule.sendRavenVideoReplayable;
+
+module.exports = {
+  sendPhoto,
+  sendFile,
+  uploadPhoto,
+  uploadFile,
+  sendRavenPhoto,
+  sendRavenPhotoOnce,
+  sendRavenPhotoReplayable,
+  sendRavenVideo,
+  sendRavenVideoOnce,
+  sendRavenVideoReplayable,
+};

package/dist/sendmedia/sendFile.js

@@ -0,0 +1,72 @@
+/**
+ * sendFile.js - Fixed to support MQTT if realtime client provided
+ */
+
+const uploadFile = require('./uploadfFile');
+
+/**
+ * Send a file to Instagram Direct.
+ */
+async function sendFile(session, opts = {}) {
+  const {
+    fileBuffer,
+    mimeType = 'video/mp4',
+    fileName,
+    caption = '',
+    userId,
+    threadId,
+    signal,
+    realtimeClient,
+  } = opts;
+
+  if (!userId && !threadId) {
+    throw new Error('sendFile: Provide userId or threadId.');
+  }
+  if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+    throw new Error('sendFile: fileBuffer must be a non-empty Buffer.');
+  }
+
+  // 1) Upload
+  const upload_id = await uploadFile(session, fileBuffer, {
+    mimeType,
+    fileName,
+    signal,
+  });
+
+  // 2) MQTT Check
+  if (realtimeClient && realtimeClient.direct && typeof realtimeClient.direct.sendMedia === 'function') {
+      return await realtimeClient.direct.sendMedia({
+          text: caption,
+          mediaId: upload_id,
+          threadId: threadId || userId,
+      });
+  }
+
+  // 3) REST Fallback
+  const url = '/direct_v2/threads/broadcast/upload_video/';
+  const form = {
+    upload_id,
+    action: 'send_item',
+    caption,
+  };
+
+  if (userId) {
+    form.recipient_users = JSON.stringify([[String(userId)]]);
+  } else {
+    form.thread_ids = JSON.stringify([String(threadId)]);
+  }
+
+  try {
+    const response = await session.request.send({
+      url,
+      method: 'POST',
+      form,
+      signal,
+    });
+    return response;
+  } catch (err) {
+    throw new Error(`sendFile: Broadcast failed — ${err.message}`);
+  }
+}
+
+module.exports = sendFile;

package/dist/sendmedia/sendPhoto.js

@@ -0,0 +1,142 @@
+/**
+ * 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 { 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'
+  };
+}
+
+/**
+ * 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 uploadPhoto(session, photoBuffer, options = {}) {
+  const {
+    mimeType = 'image/jpeg',
+    fileName,
+    signal
+  } = options;
+
+  validateImageInput(photoBuffer, mimeType);
+
+  // 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;
+
+  const ruploadParams = buildRuploadParams(uploadId, mimeType);
+
+  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',
+      headers,
+      data: photoBuffer,
+      signal,
+      // ensure axios does not apply any transform that would corrupt binary
+      transformRequest: [(d) => d]
+    });
+
+    if (!response) {
+      throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
+    }
+
+    // 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) {
+    // 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 = uploadPhoto;