nodejs-insta-private-api-mqt 1.3.70

package/dist/repositories/direct-thread.repository.js

@@ -0,0 +1,446 @@
+const Repository = require('../core/repository');
+const Chance = require('chance');
+
+class DirectThreadRepository extends Repository {
+  constructor(client) {
+    super(client);
+    this.maxRetries = 3; // default max retries for requests
+  }
+
+  /**
+   * Generic request wrapper with retry and debug logging
+   * @param {Function} requestFn - async function performing request
+   * @param {number} retries - current retry count
+   */
+  async requestWithRetry(requestFn, retries = 0) {
+    try {
+      if (process.env.DEBUG) console.log(`[DEBUG] Attempt #${retries + 1}`);
+      const result = await requestFn();
+      return result;
+    } catch (error) {
+      const shouldRetry =
+        (error.data?.error_type === 'server_error' ||
+         error.data?.error_type === 'rate_limited' ||
+         error.name === 'IgActionSpamError' ||
+         error.status === 503 ||
+         error.status === 429) &&
+        retries < this.maxRetries;
+
+      if (shouldRetry) {
+        const delay = 1000 * (retries + 1);
+        if (process.env.DEBUG) console.log(`[DEBUG] Retrying after ${delay}ms due to ${error.data?.error_type || error.message || error.name || error.status}`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.requestWithRetry(requestFn, retries + 1);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Send a text message to a group thread
+   * @param {Object} options - { threadId, message }
+   */
+  async sendToGroup(options) {
+    const { threadId, message } = options;
+    if (!threadId || !message) throw new Error('threadId and message are required');
+
+    return this.broadcast({
+      threadIds: [threadId],
+      item: 'text',
+      form: { text: message },
+    });
+  }
+
+  /**
+   * Fetch a specific thread by its ID
+   * @param {string} threadId
+   */
+  async getThread(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        method: 'GET',
+        url: `/api/v1/direct_v2/threads/${threadId}/`,
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Fetch threads by participants
+   * @param {Array} recipientUsers
+   */
+  async getByParticipants(recipientUsers) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        method: 'GET',
+        url: '/api/v1/direct_v2/threads/get_by_participants/',
+        qs: { recipient_users: JSON.stringify(recipientUsers) },
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Broadcast a message to multiple threads or users
+   */
+  async broadcast(options) {
+    const mutationToken = new Chance().guid();
+    const recipients = options.threadIds || options.userIds;
+    const recipientsType = options.threadIds ? 'thread_ids' : 'recipient_users';
+    const recipientsIds = Array.isArray(recipients) ? recipients : [recipients];
+    const recipientsValue = recipientsType === 'thread_ids'
+      ? JSON.stringify(recipientsIds)
+      : JSON.stringify([recipientsIds]);
+
+    const form = {
+      action: 'send_item',
+      [recipientsType]: recipientsValue,
+      client_context: mutationToken,
+      _csrftoken: this.client.state.cookieCsrfToken,
+      device_id: this.client.state.deviceId,
+      mutation_token: mutationToken,
+      _uuid: this.client.state.uuid,
+      ...options.form,
+    };
+
+    return this.requestWithRetry(async () => {
+      const payloadForm = options.signed && this.client.request && typeof this.client.request.sign === 'function'
+        ? this.client.request.sign(form)
+        : form;
+
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/broadcast/${options.item}/`,
+        method: 'POST',
+        form: payloadForm,
+        qs: options.qs,
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Broadcast a photo to one or more threads (uses REST configure_photo)
+   * Options:
+   *  - uploadId (required) : upload_id returned from rupload
+   *  - threadIds or threadId (required) : target thread id(s)
+   *  - caption (optional) : caption/text to attach
+   *  - signed (optional, default true) : whether to sign the form (if client.request.sign available)
+   */
+  async broadcastPhoto(options) {
+    // normalize inputs
+    const uploadId = options.uploadId || options.upload_id || options.uploadIdStr;
+    const threadIds = options.threadIds || (options.threadId ? [options.threadId] : []);
+    const caption = options.caption || options.text || '';
+    const signed = (options.signed === undefined) ? true : !!options.signed; // default to true for media
+    const mutationToken = new Chance().guid();
+    const clientContext = mutationToken;
+
+    if (!uploadId) throw new Error('broadcastPhoto: uploadId is required');
+    if (!threadIds || !Array.isArray(threadIds) || threadIds.length === 0) throw new Error('broadcastPhoto: at least one threadId is required');
+
+    const form = {
+      action: 'send_item',
+      upload_id: uploadId.toString(),
+      thread_ids: JSON.stringify(threadIds),
+      client_context: clientContext,
+      _csrftoken: this.client.state.cookieCsrfToken,
+      mutation_token: mutationToken,
+      offline_threading_id: clientContext,
+      device_id: this.client.state.deviceId,
+      _uuid: this.client.state.uuid,
+    };
+
+    if (caption) {
+      // Instagram often expects 'text' for the message body
+      form.text = caption;
+    }
+
+    // perform request with retry wrapper
+    return this.requestWithRetry(async () => {
+      const payloadForm = (signed && this.client.request && typeof this.client.request.sign === 'function')
+        ? this.client.request.sign(form)
+        : form;
+
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/broadcast/configure_photo/`,
+        method: 'POST',
+        form: payloadForm,
+        qs: {
+          use_unified_inbox: true,
+        },
+      });
+
+      // normalize: some wrappers return { body } or axios response
+      const body = response && (response.body || response.data || response);
+
+      if (!body) {
+        const err = new Error('broadcastPhoto: empty response');
+        throw err;
+      }
+
+      // parse if string
+      let parsed = null;
+      if (typeof body === 'string') {
+        try {
+          parsed = JSON.parse(body);
+        } catch (e) {
+          parsed = null;
+        }
+      } else if (typeof body === 'object') {
+        parsed = body;
+      }
+
+      // Typical success: parsed.status === 'ok' OR parsed.media/parsed.result/payload present
+      const ok = parsed && (parsed.status === 'ok' || parsed.media || parsed.result || parsed.payload || parsed.items || parsed.thread);
+      if (ok) return parsed;
+
+      // If we reach here, treat as error to trigger retry logic
+      const error = new Error('broadcastPhoto: Request failed');
+      error.response = response;
+      if (parsed) error.data = parsed;
+      throw error;
+    });
+  }
+
+  /**
+   * Broadcast a raven (view-once/ephemeral) attachment to one or more threads via REST.
+   * IMPORTANT: Media must be uploaded to rupload.facebook.com/messenger_image/ first!
+   * Uses endpoint: /api/v1/direct_v2/threads/broadcast/raven_attachment/
+   *
+   * Options:
+   *  - uploadId (required): upload_id from messenger_image rupload
+   *  - attachmentFbid (optional): media_id from messenger_image upload response
+   *  - threadIds or threadId (required): target thread id(s)
+   *  - viewMode (optional, default 'replayable'): 'once' or 'replayable'
+   *  - mediaType (optional, default '1'): '1' = photo, '2' = video
+   */
+  async broadcastRaven(options) {
+    const uploadId = options.uploadId || options.upload_id;
+    const threadIds = options.threadIds || (options.threadId ? [options.threadId] : []);
+    const viewMode = options.viewMode || 'replayable';
+    const mediaType = String(options.mediaType || '1');
+    const attachmentFbid = options.attachmentFbid || options.attachment_fbid || null;
+
+    if (!uploadId) throw new Error('broadcastRaven: uploadId is required');
+    if (!threadIds || !Array.isArray(threadIds) || threadIds.length === 0) throw new Error('broadcastRaven: at least one threadId is required');
+
+    const { v4: uuidv4 } = require('uuid');
+    const clientContext = BigInt(Math.floor(Math.random() * 2**62)).toString();
+    const now = Math.floor(Date.now() / 1000);
+
+    const form = {
+      allow_multi_configures: '1',
+      recipient_users: '[]',
+      view_mode: viewMode,
+      is_shh_mode: '0',
+      camera_entry_point: '3',
+      thread_ids: JSON.stringify(threadIds.map(String)),
+      reshare_mode: 'allow_reshare',
+      original_media_type: mediaType,
+      send_attribution: 'direct_thread_camera',
+      client_context: clientContext,
+      camera_session_id: uuidv4(),
+      include_e2ee_mentioned_user_list: '1',
+      hide_from_profile_grid: 'false',
+      scene_capture_type: '',
+      timezone_offset: String(new Date().getTimezoneOffset() * -60),
+      client_shared_at: String(now),
+      configure_mode: '2',
+      source_type: '4',
+      camera_position: 'unknown',
+      _uid: String(this.client.state.cookieUserId || this.client.state.igUserId),
+      device_id: this.client.state.deviceId,
+      composition_id: uuidv4(),
+      mutation_token: clientContext,
+      _uuid: this.client.state.uuid,
+      creation_tool_info: '[]',
+      creation_surface: 'camera',
+      capture_type: 'normal',
+      audience: 'default',
+      upload_id: uploadId.toString(),
+      client_timestamp: String(now),
+      sampled: 'true',
+      media_transformation_info: JSON.stringify({
+        width: '720', height: '1280',
+        x_transform: '0', y_transform: '0',
+        zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+      }),
+      edits: JSON.stringify({ filter_type: 0, filter_strength: 0.5, crop_original_size: [720.0, 1280.0] }),
+      extra: JSON.stringify({ source_width: 720, source_height: 1280 }),
+      device: JSON.stringify({
+        manufacturer: this.client.state.devicePayload?.manufacturer || 'samsung',
+        model: this.client.state.devicePayload?.model || 'SM-S938B',
+        android_version: this.client.state.devicePayload?.android_version || 35,
+        android_release: this.client.state.devicePayload?.android_release || '15',
+      }),
+    };
+
+    if (attachmentFbid) {
+      form.attachment_fbid = String(attachmentFbid);
+    }
+
+    return this.requestWithRetry(async () => {
+      const payloadForm = (this.client.request && typeof this.client.request.sign === 'function')
+        ? this.client.request.sign(form)
+        : form;
+
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/broadcast/raven_attachment/`,
+        method: 'POST',
+        form: payloadForm,
+        qs: {
+          use_unified_inbox: true,
+        },
+      });
+
+      const body = response && (response.body || response.data || response);
+      if (!body) {
+        throw new Error('broadcastRaven: empty response');
+      }
+
+      let parsed = null;
+      if (typeof body === 'string') {
+        try { parsed = JSON.parse(body); } catch (e) { parsed = null; }
+      } else if (typeof body === 'object') {
+        parsed = body;
+      }
+
+      const ok = parsed && (parsed.status === 'ok' || parsed.media || parsed.result || parsed.payload || parsed.items || parsed.thread);
+      if (ok) return parsed;
+
+      const error = new Error('broadcastRaven: Request failed');
+      error.response = response;
+      if (parsed) error.data = parsed;
+      throw error;
+    });
+  }
+
+  /**
+   * Mark a specific item in a thread as seen
+   */
+  async markItemSeen(threadId, threadItemId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/items/${threadItemId}/seen/`,
+        method: 'POST',
+        form: {
+          _uuid: this.client.state.uuid,
+          use_unified_inbox: true,
+          action: 'mark_seen',
+          thread_id: threadId,
+          item_id: threadItemId,
+        },
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Delete an item from a thread
+   */
+  async deleteItem(threadId, itemId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/items/${itemId}/delete/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Approve a pending thread
+   */
+  async approve(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/approve/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Decline a pending thread
+   */
+  async decline(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/decline/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Mute a thread
+   */
+  async mute(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/mute/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Unmute a thread
+   */
+  async unmute(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/unmute/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Add users to a thread
+   */
+  async addUser(threadId, userIds) {
+    if (!Array.isArray(userIds)) throw new Error('userIds must be an array');
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/add_user/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Leave a thread
+   */
+  async leave(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/leave/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Update thread title
+   */
+  async updateTitle(threadId, title) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/${threadId}/update_title/`,
+        method: 'POST',
+      });
+      return response.body || response.data || response;
+    });
+  }
+}
+
+module.exports = DirectThreadRepository;
+

package/dist/repositories/direct.repository.js

@@ -0,0 +1,232 @@
+const Repository = require('../core/repository');
+const fs = require('fs');
+
+class DirectRepository extends Repository {
+  constructor(client) {
+    super(client);
+    this.maxRetries = 3;
+  }
+
+  async requestWithRetry(requestFn, retries = 0) {
+    try {
+      const result = await requestFn();
+      return result;
+    } catch (error) {
+      const shouldRetry =
+        (error.data?.error_type === 'server_error' ||
+         error.data?.error_type === 'rate_limited') &&
+        retries < this.maxRetries;
+      if (shouldRetry) {
+        const delay = 1000 * (retries + 1);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.requestWithRetry(requestFn, retries + 1);
+      }
+      throw error;
+    }
+  }
+
+  async send(options) {
+    const { to, message } = options;
+    if (!to || !message) throw new Error('Recipient (to) and message are required');
+
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'text',
+        form: { text: message },
+      });
+    });
+  }
+
+  async sendToUserId(userId, message) {
+    return this.requestWithRetry(async () => {
+      return this.client.directThread.broadcast({
+        userIds: [userId],
+        item: 'text',
+        form: { text: message },
+      });
+    });
+  }
+
+  async sendImage(options) {
+    const { to, imagePath } = options;
+    if (!to || !imagePath) throw new Error('Recipient (to) and imagePath are required');
+
+    return this.requestWithRetry(async () => {
+      const imageBuffer = fs.readFileSync(imagePath);
+      const uploadResult = await this.client.upload.photo({ file: imageBuffer, uploadId: Date.now() });
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'configure_photo',
+        form: { upload_id: uploadResult.upload_id, allow_full_aspect_ratio: true },
+      });
+    });
+  }
+
+  async sendVideo(options) {
+    const { to, videoPath } = options;
+    if (!to || !videoPath) throw new Error('Recipient (to) and videoPath are required');
+
+    return this.requestWithRetry(async () => {
+      const videoBuffer = fs.readFileSync(videoPath);
+      const uploadResult = await this.client.upload.video({ video: videoBuffer, uploadId: Date.now() });
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'configure_video',
+        form: { upload_id: uploadResult.upload_id, video_result: 'deprecated' },
+      });
+    });
+  }
+
+  async sendLink(options) {
+    const { to, text, urls } = options;
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'link',
+        form: {
+          link_text: text || '',
+          link_urls: JSON.stringify(urls || []),
+        },
+      });
+    });
+  }
+
+  async sendMediaShare(options) {
+    const { to, mediaId } = options;
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'media_share',
+        form: { media_id: mediaId },
+      });
+    });
+  }
+
+  async sendProfile(options) {
+    const { to, profileUserId } = options;
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'profile',
+        form: { profile_user_id: profileUserId },
+      });
+    });
+  }
+
+  async sendHashtag(options) {
+    const { to, hashtag, text } = options;
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'hashtag',
+        form: {
+          hashtag,
+          text: text || '',
+        },
+      });
+    });
+  }
+
+  async sendLocation(options) {
+    const { to, locationId, text } = options;
+    return this.requestWithRetry(async () => {
+      const user = await this.client.user.infoByUsername(to);
+      const thread = await this.client.directThread.getByParticipants([user.pk]);
+      return this.client.directThread.broadcast({
+        threadIds: [thread.thread_id],
+        item: 'location',
+        form: {
+          venue_id: locationId,
+          text: text || '',
+        },
+      });
+    });
+  }
+
+  async getInbox(cursor = null, limit = 20) {
+    return this.requestWithRetry(async () => {
+      const qs = { persistentBadging: true, limit };
+      if (cursor) qs.cursor = cursor;
+      const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/inbox/', qs });
+      return response.body;
+    });
+  }
+
+  async getPendingInbox(cursor = null) {
+    return this.requestWithRetry(async () => {
+      const qs = cursor ? { cursor } : {};
+      const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/pending_inbox/', qs });
+      return response.body;
+    });
+  }
+
+  async createGroupThread(recipientUsers, threadTitle) {
+    if (!Array.isArray(recipientUsers) || !threadTitle) throw new Error('recipientUsers must be array and threadTitle required');
+
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        method: 'POST',
+        url: '/api/v1/direct_v2/create_group_thread/',
+        form: this.client.request.sign({
+          _uuid: this.client.state.uuid,
+          _uid: this.client.state.cookieUserId,
+          recipient_users: JSON.stringify(recipientUsers),
+          thread_title: threadTitle,
+        }),
+      });
+      return response.body;
+    });
+  }
+
+  async rankedRecipients(mode = 'raven', query = '') {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        method: 'GET',
+        url: '/api/v1/direct_v2/ranked_recipients/',
+        qs: { mode, query, show_threads: true },
+      });
+      return response.body;
+    });
+  }
+
+  async getPresence() {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/get_presence/' });
+      return response.body;
+    });
+  }
+
+  async markAsSeen(threadId, itemId) {
+    return this.client.directThread.markItemSeen(threadId, itemId);
+  }
+
+  async hideThread(threadId) {
+    return this.requestWithRetry(async () => {
+      const response = await this.client.request.send({
+        method: 'POST',
+        url: `/api/v1/direct_v2/threads/${threadId}/hide/`,
+        form: this.client.request.sign({
+          _uuid: this.client.state.uuid,
+        }),
+      });
+      return response.body;
+    });
+  }
+}
+
+module.exports = DirectRepository;