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

package/dist-ts/dist/downloadMedia.js

@@ -0,0 +1,336 @@
+/**
+ * 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) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    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 = (_a = visualMedia.expiring_media_action_summary) === null || _a === void 0 ? void 0 : _a.timestamp;
+            // Extract image
+            if ((_b = media.image_versions2) === null || _b === void 0 ? void 0 : _b.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 = (_c = result.urls[0]) === null || _c === void 0 ? void 0 : _c.width;
+                result.height = (_d = result.urls[0]) === null || _d === void 0 ? void 0 : _d.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 = (_e = result.urls[0]) === null || _e === void 0 ? void 0 : _e.width;
+                result.height = (_f = result.urls[0]) === null || _f === void 0 ? void 0 : _f.height;
+            }
+        }
+        return result.urls.length > 0 ? result : null;
+    }
+    // Handle regular media message
+    if (itemType === 'media' || message.media) {
+        const media = message.media || message;
+        // Image
+        if ((_g = media.image_versions2) === null || _g === void 0 ? void 0 : _g.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 = (_h = result.urls[0]) === null || _h === void 0 ? void 0 : _h.width;
+            result.height = (_j = result.urls[0]) === null || _j === void 0 ? void 0 : _j.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 = (_k = result.urls[0]) === null || _k === void 0 ? void 0 : _k.width;
+            result.height = (_l = result.urls[0]) === null || _l === void 0 ? void 0 : _l.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 ((_m = mediaShare.image_versions2) === null || _m === void 0 ? void 0 : _m.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 = ((_o = message.clip) === null || _o === void 0 ? void 0 : _o.clip) || ((_p = message.felix_share) === null || _p === void 0 ? void 0 : _p.video) || message;
+        if ((_q = clip.image_versions2) === null || _q === void 0 ? void 0 : _q.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 = ((_r = message.story_share) === null || _r === void 0 ? void 0 : _r.media) || message.story_share || message;
+        if ((_s = story.image_versions2) === null || _s === void 0 ? void 0 : _s.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 === null || selectedUrl === void 0 ? void 0 : 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 === null || info === void 0 ? void 0 : 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 === null || info === void 0 ? void 0 : info.isViewOnce) || false;
+}
+module.exports = {
+    downloadContentFromMessage,
+    downloadMediaBuffer,
+    extractMediaUrls,
+    hasMedia,
+    getMediaType,
+    isViewOnceMedia,
+    MEDIA_TYPES
+};

package/dist-ts/dist/errors/index.js

@@ -0,0 +1,37 @@
+"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;

package/dist-ts/dist/extend.js

@@ -0,0 +1,157 @@
+"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-ts/dist/fbns/fbns.client.events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });