nodejs-insta-private-api-mqtt 1.0.0

package/dist/repositories/story.repository.js

@@ -0,0 +1,156 @@
+const Repository = require('../core/repository');
+const fs = require('fs');
+
+class StoryRepository extends Repository {
+  async react(options) {
+    const { storyId, reaction } = options;
+    
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${storyId}/story_react/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _csrftoken: this.client.state.cookieCsrfToken,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        reaction_type: 'like',
+        emoji: reaction || '❤️',
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async getFeed() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/feed/reels_tray/',
+    });
+    
+    return response.body;
+  }
+
+  async getUser(userId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/user/${userId}/reel_media/`,
+    });
+    
+    return response.body;
+  }
+
+  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 story
+    const configureResult = await this.client.upload.configure({
+      uploadId: uploadResult.upload_id,
+      source_type: '4',
+      configure_mode: 1, // Story mode
+      caption: caption || '',
+    });
+    
+    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 story
+    const configureResult = await this.client.upload.configureVideo({
+      uploadId: uploadResult.upload_id,
+      source_type: '4',
+      configure_mode: 1, // Story mode
+      caption: caption || '',
+      length: options.duration_ms || 15000,
+    });
+    
+    return configureResult;
+  }
+
+  async seen(input, sourceId = null) {
+    let items = [];
+    
+    if (Array.isArray(input)) {
+      items = input;
+    } else {
+      // Flatten reels object to items array
+      items = Object.values(input).reduce((acc, reel) => acc.concat(reel.items), []);
+    }
+    
+    const reels = {};
+    const maxSeenAt = Math.floor(Date.now() / 1000);
+    let seenAt = maxSeenAt - items.length;
+    
+    for (const item of items) {
+      const itemTakenAt = item.taken_at;
+      
+      if (seenAt < itemTakenAt) {
+        seenAt = itemTakenAt + 1;
+      }
+      if (seenAt > maxSeenAt) {
+        seenAt = maxSeenAt;
+      }
+      
+      const itemSourceId = sourceId === null ? item.user.pk : sourceId;
+      const reelId = `${item.id}_${itemSourceId}`;
+      reels[reelId] = [`${itemTakenAt}_${seenAt}`];
+      
+      seenAt += 1;
+    }
+    
+    return this.client.media.seen(reels);
+  }
+
+  async getHighlights(userId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/highlights/${userId}/highlights_tray/`,
+    });
+    
+    return response.body;
+  }
+
+  async getHighlight(highlightId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/reels_media/`,
+      qs: {
+        reel_ids: highlightId
+      }
+    });
+    
+    return response.body;
+  }
+
+  async viewers(storyId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/media/${storyId}/list_reel_media_viewer/`,
+    });
+    
+    return response.body;
+  }
+}
+
+module.exports = StoryRepository;

package/dist/repositories/upload.repository.js

@@ -0,0 +1,167 @@
+const Repository = require('../core/repository');
+const Chance = require('chance');
+const { random } = require('lodash');
+const FormData = require('form-data');
+
+class UploadRepository extends Repository {
+  constructor(client) {
+    super(client);
+    this.chance = new Chance();
+  }
+
+  async photo(options) {
+    const uploadId = options.uploadId || Date.now();
+    const name = `${uploadId}_0_${random(1000000000, 9999999999)}`;
+    const waterfallId = options.waterfallId || this.chance.guid();
+    
+    const ruploadParams = this.createPhotoRuploadParams(options, uploadId);
+    
+    const formData = new FormData();
+    formData.append('photo', options.file, { filename: 'photo.jpg' });
+    
+    const response = await this.client.request.send({
+      url: `/rupload_igphoto/${name}`,
+      method: 'POST',
+      headers: {
+        'X-FB-Photo-Waterfall-ID': waterfallId,
+        'X-Entity-Type': 'image/jpeg',
+        'Offset': '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': options.file.length.toString(),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': options.file.length.toString(),
+        'Accept-Encoding': 'gzip',
+        ...formData.getHeaders(),
+      },
+      data: options.file,
+    });
+    
+    return response.body;
+  }
+
+  async video(options) {
+    const uploadId = options.uploadId || Date.now();
+    const name = options.uploadName || `${uploadId}_0_${random(1000000000, 9999999999)}`;
+    const waterfallId = options.waterfallId || this.chance.guid();
+    
+    const ruploadParams = this.createVideoRuploadParams(options, uploadId);
+    
+    const response = await this.client.request.send({
+      url: `/rupload_igvideo/${name}`,
+      method: 'POST',
+      headers: {
+        'X-FB-Video-Waterfall-ID': waterfallId,
+        'X-Entity-Type': 'video/mp4',
+        'Offset': options.offset || '0',
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X-Entity-Name': name,
+        'X-Entity-Length': options.video.length.toString(),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': options.video.length.toString(),
+        'Accept-Encoding': 'gzip',
+      },
+      data: options.video,
+    });
+    
+    return response.body;
+  }
+
+  createPhotoRuploadParams(options, uploadId) {
+    return {
+      retry_context: JSON.stringify({
+        num_step_auto_retry: 0,
+        num_reupload: 0,
+        num_step_manual_retry: 0,
+      }),
+      media_type: '1',
+      xsharing_user_ids: JSON.stringify([]),
+      upload_id: uploadId.toString(),
+      image_compression: JSON.stringify({
+        lib_name: 'moz',
+        lib_version: '3.1.m',
+        quality: '95',
+      }),
+    };
+  }
+
+  createVideoRuploadParams(options, uploadId) {
+    return {
+      retry_context: JSON.stringify({
+        num_step_auto_retry: 0,
+        num_reupload: 0,
+        num_step_manual_retry: 0,
+      }),
+      media_type: '2',
+      xsharing_user_ids: JSON.stringify([]),
+      upload_id: uploadId.toString(),
+      upload_media_duration_ms: options.duration_ms || '0',
+      upload_media_width: options.width || '720',
+      upload_media_height: options.height || '1280',
+      for_album: options.for_album || false,
+    };
+  }
+
+  async configure(options) {
+    const basePayload = {
+      upload_id: options.uploadId,
+      source_type: options.source_type || '4',
+      camera_position: options.camera_position || 'back',
+      _csrftoken: this.client.state.cookieCsrfToken,
+      _uid: this.client.state.cookieUserId,
+      _uuid: this.client.state.uuid,
+      creation_logger_session_id: this.chance.guid(),
+      device: {
+        manufacturer: this.client.state.devicePayload.manufacturer,
+        model: this.client.state.devicePayload.model,
+        android_version: this.client.state.devicePayload.android_version,
+        android_release: this.client.state.devicePayload.android_release,
+      },
+      length: options.length || 0,
+      audio_muted: options.audio_muted || false,
+      poster_frame_index: options.poster_frame_index || 0,
+      filter_type: options.filter_type || '0',
+      video_result: options.video_result || '',
+      composition_id: this.chance.guid(),
+      clips: options.clips || [
+        {
+          length: options.length || 0,
+          source_type: '4',
+          camera_position: 'back',
+        },
+      ],
+    };
+
+    if (options.caption) {
+      basePayload.caption = options.caption;
+    }
+
+    if (options.location) {
+      basePayload.location = JSON.stringify(options.location);
+    }
+
+    const response = await this.client.request.send({
+      url: '/api/v1/media/configure/',
+      method: 'POST',
+      form: this.client.request.sign(basePayload),
+    });
+
+    return response.body;
+  }
+
+  async configureVideo(options) {
+    return this.configure({
+      ...options,
+      video_result: 'deprecated',
+    });
+  }
+
+  async configurePhoto(options) {
+    return this.configure({
+      ...options,
+      source_type: '4',
+    });
+  }
+}
+
+module.exports = UploadRepository;

package/dist/repositories/user.repository.js

@@ -0,0 +1,94 @@
+const Repository = require('../core/repository');
+
+class UserRepository extends Repository {
+  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 search(query) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/users/search/',
+      qs: {
+        q: query,
+        count: 50
+      }
+    });
+    
+    return response.body.users;
+  }
+
+  async follow(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/friendships/create/${userId}/`,
+      form: this.client.request.sign({
+        _csrftoken: this.client.state.cookieCsrfToken,
+        _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({
+        _csrftoken: this.client.state.cookieCsrfToken,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async getFollowers(userId, maxId = null) {
+    const qs = {
+      max_id: maxId
+    };
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/friendships/${userId}/followers/`,
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getFollowing(userId, maxId = null) {
+    const qs = {
+      max_id: maxId
+    };
+    
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/friendships/${userId}/following/`,
+      qs
+    });
+    
+    return response.body;
+  }
+}
+
+module.exports = UserRepository;

package/dist/sendmedia/index.js

@@ -0,0 +1,11 @@
+const sendPhoto = require('./sendPhoto');
+const sendFile = require('./sendFile');
+const uploadPhoto = require('./uploadPhoto');
+const uploadFile = require('./uploadfFile');
+
+module.exports = {
+  sendPhoto,
+  sendFile,
+  uploadPhoto,
+  uploadFile
+};

package/dist/sendmedia/sendFile.js

@@ -0,0 +1,154 @@
+/**
+ * sendFile.js
+ * High-level helper to send uploaded video/audio/image files to Instagram Direct (DM or existing thread).
+ *
+ * Requires:
+ *  - uploadFile(session, fileBuffer, options) from ./uploadFile
+ *
+ * Supports:
+ *  - Send to a single user by userId (recipient_users)
+ *  - Send to an existing thread (group or DM) by threadId
+ *  - Optional caption
+ *  - Optional mentions (array of userIds) embedded in caption
+ *  - Custom mimeType/fileName/chunkSize/isClipsMedia forwarded to uploadFile
+ *
+ * Usage:
+ *   const sendFile = require('./sendFile');
+ *   await sendFile(session, {
+ *     fileBuffer: fs.readFileSync('./clip.mp4'),
+ *     mimeType: 'video/mp4',
+ *     fileName: 'clip.mp4',
+ *     userId: '123456789',            // or threadId: '340282366841710300949128123456789'
+ *     caption: 'Uite clipul!',
+ *   });
+ *
+ * Notes:
+ *  - Exactly one of { userId, threadId } must be provided.
+ *  - For photos (JPEG/PNG), you can still use this with mimeType 'image/jpeg' or 'image/png',
+ *    but uploadPhoto.js + sendPhoto.js is preferred for image-specific flows.
+ */
+
+const uploadFile = require('./uploadfFile');
+
+/**
+ * @typedef {Object} SendFileOptions
+ * @property {Buffer} fileBuffer - Required Buffer data
+ * @property {string} [mimeType='video/mp4'] - e.g., 'video/mp4', 'audio/mpeg', 'image/jpeg'
+ * @property {string} [fileName] - Optional file name; sanitized based on mime
+ * @property {number} [chunkSize] - Optional chunk size for uploadFile
+ * @property {boolean} [isClipsMedia=false] - Hint for reels-like uploads (if your flow supports it)
+ * @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 file (video/audio/image) to Instagram Direct.
+ * Internally:
+ *  - Uploads via rupload to get upload_id
+ *  - Broadcasts the uploaded media to either a user (DM) or an existing thread
+ *
+ * @param {object} session - Authenticated session (with request.send)
+ * @param {SendFileOptions} opts - Options
+ * @returns {Promise<object>} Instagram response object
+ */
+async function sendFile(session, opts = {}) {
+  const {
+    fileBuffer,
+    mimeType = 'video/mp4',
+    fileName,
+    chunkSize,
+    isClipsMedia = false,
+    caption = '',
+    userId,
+    threadId,
+    mentions = [],
+    signal,
+  } = opts;
+
+  // Validate destination
+  if (!userId && !threadId) {
+    throw new Error('sendFile: You must provide either userId (DM) or threadId (existing thread).');
+  }
+  if (userId && threadId) {
+    throw new Error('sendFile: Provide only one destination — userId OR threadId, not both.');
+  }
+  // Validate buffer
+  if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+    throw new Error('sendFile: fileBuffer must be a non-empty Buffer.');
+  }
+  if (typeof mimeType !== 'string' || mimeType.length === 0) {
+    throw new Error('sendFile: mimeType must be a non-empty string (e.g., "video/mp4").');
+  }
+
+  // 1) Upload file to get upload_id
+  const upload_id = await uploadFile(session, fileBuffer, {
+    mimeType,
+    fileName,
+    chunkSize,
+    isClipsMedia,
+    signal,
+  });
+
+  // 2) Build base form payload
+  const form = {
+    upload_id,
+    action: 'send_item',
+    caption,
+  };
+
+  // 3) Mentions (optional)
+  if (Array.isArray(mentions) && mentions.length > 0) {
+    form.entities = JSON.stringify(
+      mentions.map((uid) => ({
+        user_id: String(uid),
+        type: 'mention',
+      }))
+    );
+  }
+
+  // 4) Destination-specific fields
+  // For video/audio/image via this flow, IG uses the "upload_video" broadcast endpoint.
+  // Images can also be sent via upload_photo (recommended via sendPhoto.js).
+  const url = '/direct_v2/threads/broadcast/upload_video/';
+  if (userId) {
+    form.recipient_users = JSON.stringify([[String(userId)]]);
+  } else {
+    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('sendFile: Empty response from Instagram broadcast endpoint.');
+    }
+    return response;
+  } catch (err) {
+    throw new Error(`sendFile: 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 = sendFile;