nodejs-insta-private-api-mqt 1.3.84 → 1.3.86

package/src-ts/dist/repositories/direct-thread.repository.ts

@@ -1,446 +0,0 @@
-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/src-ts/dist/repositories/direct.repository.ts

@@ -1,266 +0,0 @@
-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 errorCode = error.data?.content?.error_code || error.data?.error_code;
-      const errorType = error.data?.error_type;
-      const statusCode = error.status || error.data?.status_code;
-
-      const isPromptContribution = errorCode === 4415001;
-      const isAuthIssue = statusCode === 400 && isPromptContribution;
-      const isServerError = errorType === 'server_error';
-      const isRateLimited = errorType === 'rate_limited';
-      const isLoginRequired = error.data?.message === 'login_required' || errorType === 'login_required';
-
-      if ((isAuthIssue || isLoginRequired) && retries < this.maxRetries) {
-        try {
-          if (this.client.state.authorization) {
-            this.client.state.updateAuthorization();
-          }
-          if (this.client.account && typeof this.client.account.syncPostLoginExperiments === 'function') {
-            await this.client.account.syncPostLoginExperiments().catch(() => {});
-          }
-        } catch (syncErr) {}
-        const delay = 2000 * (retries + 1);
-        await new Promise(resolve => setTimeout(resolve, delay));
-        return this.requestWithRetry(requestFn, retries + 1);
-      }
-
-      const shouldRetry = (isServerError || isRateLimited) && 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) {
-    if (!this.client.state.authorization) {
-      throw new Error('Not authenticated. Please login first before accessing inbox.');
-    }
-
-    const userId = this.client.state.cookieUserId || this.client.state._userId;
-    if (!userId || userId === '0' || userId === 0) {
-      this.client.state.updateAuthorization();
-      if (this.client.state.parsedAuthorization && this.client.state.parsedAuthorization.ds_user_id) {
-        this.client.state._userId = this.client.state.parsedAuthorization.ds_user_id;
-        this.client.state.cookieUserId = this.client.state.parsedAuthorization.ds_user_id;
-      }
-    }
-
-    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;