nodejs-insta-private-api-mqt 1.3.70

package/dist/downloadMedia.js

@@ -0,0 +1,381 @@
+/**
+ * Download Media from Instagram Messages
+ * 
+ * Similar to Baileys' downloadContentFromMessage() function.
+ * Extracts and downloads media (photos, videos, voice notes) from Instagram DM messages.
+ * 
+ * Supports:
+ * - Regular photos/videos in DMs
+ * - View-once (raven) media - MUST download BEFORE marking as seen
+ * - Voice messages
+ * - Shared reels/posts
+ * 
+ * @author Added for nodejs-insta-private-api
+ * @version 1.0.0
+ */
+
+const axios = require('axios');
+const { Transform } = require('stream');
+
+/**
+ * Media types supported
+ */
+const MEDIA_TYPES = {
+  IMAGE: 'image',
+  VIDEO: 'video', 
+  AUDIO: 'audio',
+  VOICE: 'voice',
+  RAVEN_IMAGE: 'raven_image',
+  RAVEN_VIDEO: 'raven_video',
+  MEDIA_SHARE: 'media_share',
+  REEL_SHARE: 'reel_share',
+  STORY_SHARE: 'story_share',
+  CLIP: 'clip'
+};
+
+/**
+ * Extract media URLs from an Instagram message object
+ * 
+ * @param {Object} message - The Instagram message object from MQTT/API
+ * @returns {Object|null} - Object with urls, type, and metadata or null if no media
+ */
+function extractMediaUrls(message) {
+  if (!message) return null;
+  
+  const result = {
+    urls: [],
+    type: null,
+    width: null,
+    height: null,
+    duration: null,
+    isViewOnce: false,
+    expiresAt: null,
+    originalMessage: message
+  };
+
+  // Check item_type for message type
+  const itemType = message.item_type || message.type;
+  
+  // Handle view-once (raven) media
+  if (itemType === 'raven_media' || message.visual_media) {
+    result.isViewOnce = true;
+    const visualMedia = message.visual_media || message.raven_media;
+    
+    if (visualMedia) {
+      const media = visualMedia.media || visualMedia;
+      result.expiresAt = visualMedia.expiring_media_action_summary?.timestamp;
+      
+      // Extract image
+      if (media.image_versions2?.candidates) {
+        result.type = MEDIA_TYPES.RAVEN_IMAGE;
+        result.urls = media.image_versions2.candidates.map(c => ({
+          url: c.url,
+          width: c.width,
+          height: c.height
+        }));
+        result.width = result.urls[0]?.width;
+        result.height = result.urls[0]?.height;
+      }
+      
+      // Extract video
+      if (media.video_versions) {
+        result.type = MEDIA_TYPES.RAVEN_VIDEO;
+        result.urls = media.video_versions.map(v => ({
+          url: v.url,
+          width: v.width,
+          height: v.height,
+          type: v.type
+        }));
+        result.duration = media.video_duration;
+        result.width = result.urls[0]?.width;
+        result.height = result.urls[0]?.height;
+      }
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle regular media message
+  if (itemType === 'media' || message.media) {
+    const media = message.media || message;
+    
+    // Image
+    if (media.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.IMAGE;
+      result.urls = media.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+      result.width = result.urls[0]?.width;
+      result.height = result.urls[0]?.height;
+    }
+    
+    // Video
+    if (media.video_versions) {
+      result.type = MEDIA_TYPES.VIDEO;
+      result.urls = media.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height,
+        type: v.type
+      }));
+      result.duration = media.video_duration;
+      result.width = result.urls[0]?.width;
+      result.height = result.urls[0]?.height;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle voice message
+  if (itemType === 'voice_media' || message.voice_media) {
+    const voiceMedia = message.voice_media || message;
+    const audio = voiceMedia.media || voiceMedia;
+    
+    if (audio.audio) {
+      result.type = MEDIA_TYPES.VOICE;
+      result.urls = [{
+        url: audio.audio.audio_src,
+        duration: audio.audio.duration
+      }];
+      result.duration = audio.audio.duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle media share (shared post)
+  if (itemType === 'media_share' || message.media_share) {
+    const mediaShare = message.media_share || message;
+    
+    if (mediaShare.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.MEDIA_SHARE;
+      result.urls = mediaShare.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (mediaShare.video_versions) {
+      result.type = MEDIA_TYPES.MEDIA_SHARE;
+      result.urls = mediaShare.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+      result.duration = mediaShare.video_duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle reel share
+  if (itemType === 'clip' || itemType === 'felix_share' || message.clip) {
+    const clip = message.clip?.clip || message.felix_share?.video || message;
+    
+    if (clip.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.CLIP;
+      result.urls = clip.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (clip.video_versions) {
+      result.type = MEDIA_TYPES.CLIP;
+      result.urls = clip.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+      result.duration = clip.video_duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle story share
+  if (itemType === 'story_share' || message.story_share) {
+    const story = message.story_share?.media || message.story_share || message;
+    
+    if (story.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.STORY_SHARE;
+      result.urls = story.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (story.video_versions) {
+      result.type = MEDIA_TYPES.STORY_SHARE;
+      result.urls = story.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  return null;
+}
+
+/**
+ * Download media content from an Instagram message
+ * Similar to Baileys' downloadContentFromMessage()
+ * 
+ * @param {Object} message - The Instagram message object containing media
+ * @param {string} type - Optional: 'image', 'video', 'audio' to specify which type to download
+ * @param {Object} options - Optional download options
+ * @param {number} options.quality - Quality index (0 = highest, default 0)
+ * @param {number} options.timeout - Request timeout in ms (default 30000)
+ * @param {Object} options.headers - Additional headers for the request
+ * @returns {Promise<Transform>} - Readable stream of the media content
+ * 
+ * @example
+ * // Download view-once image before marking as seen
+ * const stream = await downloadContentFromMessage(message, 'image');
+ * let buffer = Buffer.from([]);
+ * for await (const chunk of stream) {
+ *   buffer = Buffer.concat([buffer, chunk]);
+ * }
+ * fs.writeFileSync('saved-viewonce.jpg', buffer);
+ */
+async function downloadContentFromMessage(message, type = null, options = {}) {
+  const mediaInfo = extractMediaUrls(message);
+  
+  if (!mediaInfo || mediaInfo.urls.length === 0) {
+    throw new Error('No media found in message');
+  }
+  
+  // Select quality (0 = best)
+  const qualityIndex = options.quality || 0;
+  const selectedUrl = mediaInfo.urls[Math.min(qualityIndex, mediaInfo.urls.length - 1)];
+  
+  if (!selectedUrl?.url) {
+    throw new Error('Could not extract media URL from message');
+  }
+  
+  const timeout = options.timeout || 30000;
+  const headers = {
+    'User-Agent': 'Instagram 415.0.0.36.76 Android',
+    'Accept': '*/*',
+    'Accept-Encoding': 'gzip, deflate',
+    ...(options.headers || {})
+  };
+  
+  try {
+    const response = await axios({
+      method: 'GET',
+      url: selectedUrl.url,
+      responseType: 'stream',
+      timeout: timeout,
+      headers: headers,
+      maxRedirects: 5
+    });
+    
+    // Create transform stream to pass through
+    const transform = new Transform({
+      transform(chunk, encoding, callback) {
+        this.push(chunk);
+        callback();
+      }
+    });
+    
+    // Attach metadata to stream
+    transform.mediaInfo = {
+      type: mediaInfo.type,
+      isViewOnce: mediaInfo.isViewOnce,
+      width: selectedUrl.width || mediaInfo.width,
+      height: selectedUrl.height || mediaInfo.height,
+      duration: mediaInfo.duration,
+      contentType: response.headers['content-type'],
+      contentLength: parseInt(response.headers['content-length']) || null
+    };
+    
+    response.data.pipe(transform);
+    
+    return transform;
+    
+  } catch (error) {
+    throw new Error(`Failed to download media: ${error.message}`);
+  }
+}
+
+/**
+ * Download media content as a Buffer directly
+ * Convenience wrapper around downloadContentFromMessage
+ * 
+ * @param {Object} message - The Instagram message object containing media
+ * @param {string} type - Optional: 'image', 'video', 'audio' to specify type
+ * @param {Object} options - Optional download options
+ * @returns {Promise<{buffer: Buffer, mediaInfo: Object}>} - Buffer and metadata
+ * 
+ * @example
+ * const { buffer, mediaInfo } = await downloadMediaBuffer(message);
+ * console.log('Downloaded', mediaInfo.type, 'size:', buffer.length);
+ * fs.writeFileSync('media.' + (mediaInfo.type === 'video' ? 'mp4' : 'jpg'), buffer);
+ */
+async function downloadMediaBuffer(message, type = null, options = {}) {
+  const stream = await downloadContentFromMessage(message, type, options);
+  
+  const chunks = [];
+  
+  return new Promise((resolve, reject) => {
+    stream.on('data', (chunk) => chunks.push(chunk));
+    stream.on('end', () => {
+      resolve({
+        buffer: Buffer.concat(chunks),
+        mediaInfo: stream.mediaInfo
+      });
+    });
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Check if a message contains downloadable media
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {boolean} - True if message contains downloadable media
+ */
+function hasMedia(message) {
+  return extractMediaUrls(message) !== null;
+}
+
+/**
+ * Get media type from message without downloading
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {string|null} - Media type or null
+ */
+function getMediaType(message) {
+  const info = extractMediaUrls(message);
+  return info?.type || null;
+}
+
+/**
+ * Check if message is view-once (disappearing)
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {boolean} - True if view-once media
+ */
+function isViewOnceMedia(message) {
+  const info = extractMediaUrls(message);
+  return info?.isViewOnce || false;
+}
+
+module.exports = {
+  downloadContentFromMessage,
+  downloadMediaBuffer,
+  extractMediaUrls,
+  hasMedia,
+  getMediaType,
+  isViewOnceMedia,
+  MEDIA_TYPES
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,16 @@
+declare class BaseError extends Error {
+    constructor(message?: string);
+}
+export declare class ClientDisconnectedError extends BaseError {
+}
+export declare class EmptyPacketError extends BaseError {
+}
+export declare class InvalidStateError extends BaseError {
+}
+export declare class ConnectionFailedError extends BaseError {
+}
+export declare class IllegalArgumentError extends BaseError {
+}
+export declare class ThriftError extends BaseError {
+}
+export {};

package/dist/errors/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IgApiClientError = exports.ThriftError = exports.IllegalArgumentError = exports.ConnectionFailedError = exports.InvalidStateError = exports.EmptyPacketError = exports.ClientDisconnectedError = void 0;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        // @ts-ignore -- set the name to the class's actual name
+        this.name = this.__proto__.constructor.name;
+    }
+}
+class IgApiClientError extends BaseError {
+    constructor(message, statusCode, body) {
+        super(message);
+        this.statusCode = statusCode || null;
+        this.body = body || null;
+    }
+}
+exports.IgApiClientError = IgApiClientError;
+class ClientDisconnectedError extends BaseError {
+}
+exports.ClientDisconnectedError = ClientDisconnectedError;
+class EmptyPacketError extends BaseError {
+}
+exports.EmptyPacketError = EmptyPacketError;
+class InvalidStateError extends BaseError {
+}
+exports.InvalidStateError = InvalidStateError;
+class ConnectionFailedError extends BaseError {
+}
+exports.ConnectionFailedError = ConnectionFailedError;
+class IllegalArgumentError extends BaseError {
+}
+exports.IllegalArgumentError = IllegalArgumentError;
+// TODO: split further
+class ThriftError extends BaseError {
+}
+exports.ThriftError = ThriftError;
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":";;;AAAA,MAAM,SAAU,SAAQ,KAAK;IAC1B,YAAY,OAAgB;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,wDAAwD;QACxD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/C,CAAC;CACH;AAED,MAAa,uBAAwB,SAAQ,SAAS;CAAG;AAAzD,0DAAyD;AAEzD,MAAa,gBAAiB,SAAQ,SAAS;CAAG;AAAlD,4CAAkD;AAElD,MAAa,iBAAkB,SAAQ,SAAS;CAAG;AAAnD,8CAAmD;AAEnD,MAAa,qBAAsB,SAAQ,SAAS;CAAG;AAAvD,sDAAuD;AAEvD,MAAa,oBAAqB,SAAQ,SAAS;CAAG;AAAtD,oDAAsD;AAEtD,sBAAsB;AACtB,MAAa,WAAY,SAAQ,SAAS;CAAG;AAA7C,kCAA6C"}

package/dist/extend.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFbnsAndRealtime = exports.withRealtime = exports.withFbns = exports.IgApiClientExt = void 0;
+
+const IgApiClient = require('./core/client');
+
+let FbnsClient = null;
+try { FbnsClient = require('./fbns/fbns.client').FbnsClient; } catch (e) {}
+
+const { RealtimeClient } = require('./realtime');
+
+const { sendRavenPhoto, sendRavenPhotoOnce, sendRavenPhotoReplayable, sendRavenVideo, sendRavenVideoOnce, sendRavenVideoReplayable } = require('./sendmedia');
+
+class IgApiClientExt extends IgApiClient {
+    constructor() {
+        super();
+        this.stateHooks = [];
+        this.addStateHook({
+            name: 'client',
+            onExport: async (client) => {
+                if (client.state && typeof client.state.serialize === 'function') {
+                    const state = await client.state.serialize();
+                    const { constants, ...rest } = state;
+                    return rest;
+                }
+                return {};
+            },
+            onImport: (data, client) => {
+                if (client.state && typeof client.state.deserialize === 'function') {
+                    return client.state.deserialize(data);
+                }
+            },
+        });
+    }
+
+    async sendRavenPhoto(buffer, options) {
+        return sendRavenPhoto(this, buffer, options);
+    }
+
+    async sendRavenPhotoOnce(buffer, options) {
+        return sendRavenPhotoOnce(this, buffer, options);
+    }
+
+    async sendRavenPhotoReplayable(buffer, options) {
+        return sendRavenPhotoReplayable(this, buffer, options);
+    }
+
+    async sendRavenVideo(buffer, options) {
+        return sendRavenVideo(this, buffer, options);
+    }
+
+    async sendRavenVideoOnce(buffer, options) {
+        return sendRavenVideoOnce(this, buffer, options);
+    }
+
+    async sendRavenVideoReplayable(buffer, options) {
+        return sendRavenVideoReplayable(this, buffer, options);
+    }
+
+    async exportState() {
+        const data = {};
+        for (const hook of this.stateHooks) {
+            try {
+                data[hook.name] = await hook.onExport(this);
+            } catch (e) {
+                data[hook.name] = null;
+            }
+        }
+        return JSON.stringify(data);
+    }
+
+    async importState(state) {
+        if (typeof state === 'string') state = JSON.parse(state);
+        for (const [key, value] of Object.entries(state)) {
+            const hook = this.stateHooks.find(x => x.name === key);
+            if (hook) {
+                try {
+                    await hook.onImport(value, this);
+                } catch (e) {}
+            }
+        }
+    }
+
+    addStateHook(hook) {
+        if (this.stateHooks.some(x => x.name === hook.name)) {
+            return;
+        }
+        this.stateHooks.push(hook);
+    }
+}
+exports.IgApiClientExt = IgApiClientExt;
+
+function upgradeToExt(client) {
+    if (client instanceof IgApiClientExt) return client;
+    Object.setPrototypeOf(client, IgApiClientExt.prototype);
+    if (!client.stateHooks) {
+        client.stateHooks = [];
+        client.addStateHook({
+            name: 'client',
+            onExport: async (c) => {
+                if (c.state && typeof c.state.serialize === 'function') {
+                    const state = await c.state.serialize();
+                    const { constants, ...rest } = state;
+                    return rest;
+                }
+                return {};
+            },
+            onImport: (data, c) => {
+                if (c.state && typeof c.state.deserialize === 'function') {
+                    return c.state.deserialize(data);
+                }
+            },
+        });
+    }
+    return client;
+}
+
+function withFbns(client) {
+    if (!FbnsClient) {
+        throw new Error('FbnsClient is not available (mqtt-shim dependency missing)');
+    }
+    client = upgradeToExt(client);
+    Object.defineProperty(client, 'fbns', {
+        value: new FbnsClient(client),
+        enumerable: false,
+        configurable: true,
+    });
+    client.addStateHook({
+        name: 'fbns',
+        onExport: (c) => c.fbns && c.fbns.auth ? c.fbns.auth.toString() : null,
+        onImport: (data, c) => {
+            if (c.fbns && c.fbns.auth && typeof c.fbns.auth.read === 'function') {
+                c.fbns.auth.read(data);
+            }
+        },
+    });
+    return client;
+}
+exports.withFbns = withFbns;
+
+function withRealtime(client, mixins) {
+    client = upgradeToExt(client);
+    let realtimeInstance = null;
+    Object.defineProperty(client, 'realtime', {
+        get() {
+            if (!realtimeInstance) {
+                realtimeInstance = new RealtimeClient(client, mixins);
+            }
+            return realtimeInstance;
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    return client;
+}
+exports.withRealtime = withRealtime;
+
+function withFbnsAndRealtime(client, mixins) {
+    client = withRealtime(client, mixins);
+    if (FbnsClient) {
+        try {
+            client = withFbns(client);
+        } catch (e) {}
+    }
+    return client;
+}
+exports.withFbnsAndRealtime = withFbnsAndRealtime;

package/dist/fbns/fbns.client.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { IgApiClient, StatusResponse } from 'instagram-private-api';
+import { FbnsDeviceAuth } from './fbns.device-auth';
+import { ToEventFn } from '../shared';
+import { FbnsNotificationUnknown } from './fbns.types';
+import { EventEmitter } from 'eventemitter3';
+import { FbnsClientEvents } from './fbns.client.events';
+import { SocksProxy } from 'socks';
+import { ConnectionOptions } from 'tls';
+export declare class FbnsClient extends EventEmitter<ToEventFn<FbnsClientEvents & {
+    [x: string]: FbnsNotificationUnknown;
+}>> {
+    private readonly ig;
+    get auth(): FbnsDeviceAuth;
+    set auth(value: FbnsDeviceAuth);
+    private fbnsDebug;
+    private client?;
+    private conn?;
+    private _auth;
+    private safeDisconnect;
+    constructor(ig: IgApiClient);
+    buildConnection(): void;
+    connect({ enableTrace, autoReconnect, socksOptions, additionalTlsOptions, }?: {
+        enableTrace?: boolean;
+        autoReconnect?: boolean;
+        socksOptions?: SocksProxy;
+        additionalTlsOptions?: ConnectionOptions;
+    }): Promise<any>;
+    disconnect(): Promise<void>;
+    private handleMessage;
+    sendPushRegister(token: string): Promise<StatusResponse>;
+}

package/dist/fbns/fbns.client.events.d.ts

@@ -0,0 +1,41 @@
+import { FbnsMessageData, FbnsNotification, FbnsNotificationUnknown } from './fbns.types';
+import { FbnsDeviceAuth } from './fbns.device-auth';
+export interface FbnsClientEvents extends ToClientEvents<FbnsNotificationEventParams> {
+    auth: FbnsDeviceAuth;
+    push: FbnsNotificationUnknown;
+    error: Error;
+    warning: Error;
+    message: FbnsMessageData;
+    logging: {
+        beacon_id: number;
+    };
+    pp: string;
+    disconnect: string | undefined;
+}
+export type ToClientEvents<T> = {
+    [x in keyof T]: FbnsNotification<T[x]>;
+};
+export interface FbnsNotificationEventParams {
+    post: {
+        id: string;
+    };
+    first_post: {
+        username: string;
+    };
+    resurrected_user_post: {
+        id: string;
+    };
+    recent_follow_post: {
+        id: string;
+    };
+    fb_first_post: {
+        username: string;
+    };
+    first_bestie_post: {
+        id: string;
+    };
+    direct_v2_message: {
+        id: string;
+        x: string;
+    };
+}

package/dist/fbns/fbns.client.events.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fbns.client.events.js.map

package/dist/fbns/fbns.client.events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fbns.client.events.js","sourceRoot":"","sources":["../../src/fbns/fbns.client.events.ts"],"names":[],"mappings":""}