nodejs-insta-private-api-mqtt 1.0.0

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

@@ -0,0 +1,247 @@
+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') &&
+        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}`);
+        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;
+    });
+  }
+
+  /**
+   * 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;
+    });
+  }
+
+  /**
+   * 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 form = {
+      action: 'send_item',
+      [recipientsType]: JSON.stringify(recipientsIds),
+      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 response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/broadcast/${options.item}/`,
+        method: 'POST',
+        form: options.signed ? this.client.request.sign(form) : form,
+        qs: options.qs,
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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: {
+          _csrftoken: this.client.state.cookieCsrfToken,
+          _uuid: this.client.state.uuid,
+          use_unified_inbox: true,
+          action: 'mark_seen',
+          thread_id: threadId,
+          item_id: threadItemId,
+        },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, user_ids: JSON.stringify(userIds), _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * 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',
+        form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid, title },
+      });
+      return response.body;
+    });
+  }
+}
+
+module.exports = DirectThreadRepository;

package/dist/repositories/direct.repository.js

@@ -0,0 +1,153 @@
+const Repository = require('../core/repository');
+const fs = require('fs');
+
+class DirectRepository extends Repository {
+  constructor(client) {
+    super(client);
+    this.maxRetries = 3; // maximum retries for failed 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') &&
+        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}`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.requestWithRetry(requestFn, retries + 1);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Send a text message to a user
+   */
+  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 },
+      });
+    });
+  }
+
+  /**
+   * Send an image to a user
+   */
+  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 },
+      });
+    });
+  }
+
+  /**
+   * Send a video to a user
+   */
+  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' },
+      });
+    });
+  }
+
+  /**
+   * Get inbox threads with optional pagination cursor
+   */
+  async getInbox(cursor = null) {
+    return this.requestWithRetry(async () => {
+      const qs = cursor ? { cursor } : {};
+      const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/inbox/', qs });
+      return response.body;
+    });
+  }
+
+  /**
+   * Create a group thread
+   */
+  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({
+          _csrftoken: this.client.state.cookieCsrfToken,
+          _uuid: this.client.state.uuid,
+          _uid: this.client.state.cookieUserId,
+          recipient_users: JSON.stringify(recipientUsers),
+          thread_title: threadTitle,
+        }),
+      });
+      return response.body;
+    });
+  }
+
+  /**
+   * Get ranked recipients (suggested users to send DMs)
+   */
+  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;
+    });
+  }
+
+  /**
+   * Get online presence
+   */
+  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;
+    });
+  }
+}
+
+module.exports = DirectRepository;

package/dist/repositories/feed.repository.js

@@ -0,0 +1,233 @@
+const Repository = require('../core/repository');
+const fs = require('fs');
+
+class FeedRepository extends Repository {
+  async upload(options) {
+    const { imagePath, caption } = options;
+    
+    // Read image file
+    const imageBuffer = fs.readFileSync(imagePath);
+    
+    // Upload image first
+    const uploadResult = await this.client.upload.photo({
+      file: imageBuffer,
+      uploadId: Date.now()
+    });
+    
+    // Configure as feed post
+    const configureResult = await this.client.upload.configurePhoto({
+      uploadId: uploadResult.upload_id,
+      caption: caption || '',
+      source_type: '4',
+    });
+    
+    return configureResult;
+  }
+
+  async uploadVideo(options) {
+    const { videoPath, caption } = options;
+    
+    // Read video file
+    const videoBuffer = fs.readFileSync(videoPath);
+    
+    // Upload video first
+    const uploadResult = await this.client.upload.video({
+      video: videoBuffer,
+      uploadId: Date.now(),
+      duration_ms: options.duration_ms || 15000,
+      width: options.width || 720,
+      height: options.height || 1280,
+    });
+    
+    // Configure as feed post
+    const configureResult = await this.client.upload.configureVideo({
+      uploadId: uploadResult.upload_id,
+      caption: caption || '',
+      source_type: '4',
+      length: options.duration_ms || 15000,
+    });
+    
+    return configureResult;
+  }
+
+  async getFeed(maxId = null) {
+    const qs = {};
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/feed/timeline/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getUserFeed(userId, maxId = null) {
+    const qs = {};
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/user/${userId}/`,
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getTag(tag, maxId = null) {
+    const qs = {
+      rank_token: this.client.state.uuid
+    };
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/tag/${tag}/`,
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getLiked(maxId = null) {
+    const qs = {};
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/feed/liked/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getSaved(maxId = null) {
+    const qs = {};
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/feed/saved/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getLocation(locationId, maxId = null) {
+    const qs = {
+      rank_token: this.client.state.uuid
+    };
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/location/${locationId}/`,
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getExploreFeed(maxId = null) {
+    const qs = {
+      is_prefetch: false,
+      is_from_promote: false,
+      timezone_offset: this.client.state.timezoneOffset,
+      session_id: this.client.state.clientSessionId,
+    };
+    
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/discover/explore/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getReelsFeed(maxId = null) {
+    const qs = {};
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/clips/browse/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async uploadCarousel(options) {
+    const { items, caption } = options;
+    const uploadIds = [];
+    
+    // Upload all items first
+    for (const item of items) {
+      if (item.type === 'photo') {
+        const imageBuffer = fs.readFileSync(item.path);
+        const uploadResult = await this.client.upload.photo({
+          file: imageBuffer,
+          uploadId: Date.now() + Math.random() * 1000
+        });
+        uploadIds.push({
+          upload_id: uploadResult.upload_id,
+          source_type: '4'
+        });
+      } else if (item.type === 'video') {
+        const videoBuffer = fs.readFileSync(item.path);
+        const uploadResult = await this.client.upload.video({
+          video: videoBuffer,
+          uploadId: Date.now() + Math.random() * 1000,
+          duration_ms: item.duration_ms || 15000,
+          width: item.width || 720,
+          height: item.height || 1280,
+        });
+        uploadIds.push({
+          upload_id: uploadResult.upload_id,
+          source_type: '4'
+        });
+      }
+    }
+    
+    // Configure carousel
+    const response = await this.client.request.send({
+      url: '/api/v1/media/configure_sidecar/',
+      method: 'POST',
+      form: this.client.request.sign({
+        caption: caption || '',
+        client_sidecar_id: Date.now(),
+        children_metadata: uploadIds,
+        _csrftoken: this.client.state.cookieCsrfToken,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    
+    return response.body;
+  }
+}
+
+module.exports = FeedRepository;