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

package/dist-ts/dist/repositories/upload.repository.js

@@ -0,0 +1,191 @@
+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 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',
+            },
+            body: 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',
+            },
+            body: options.video,
+        });
+        return response.body;
+    }
+    createPhotoRuploadParams(options, uploadId) {
+        const params = {
+            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: '80',
+            }),
+        };
+        if (options.for_album)
+            params.is_sidecar = '1';
+        if (options.isClip)
+            params.is_clips_video = '1';
+        return params;
+    }
+    createVideoRuploadParams(options, uploadId) {
+        const params = {
+            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',
+        };
+        if (options.for_album)
+            params.is_sidecar = '1';
+        if (options.isClip) {
+            params.is_clips_video = '1';
+            params.clips_uses_original_audio = '1';
+        }
+        return params;
+    }
+    async configure(options) {
+        var _a, _b, _c, _d;
+        const basePayload = {
+            upload_id: options.uploadId,
+            source_type: options.source_type || '4',
+            camera_position: options.camera_position || 'back',
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+            creation_logger_session_id: this.chance.guid(),
+            device: {
+                manufacturer: ((_a = this.client.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
+                model: ((_b = this.client.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S928B',
+                android_version: ((_c = this.client.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
+                android_release: ((_d = this.client.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+            },
+            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.configure_mode)
+            basePayload.configure_mode = options.configure_mode;
+        if (options.location)
+            basePayload.location = JSON.stringify(options.location);
+        if (options.usertags)
+            basePayload.usertags = JSON.stringify({ in: options.usertags });
+        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',
+        });
+    }
+    async configureToStory(options) {
+        return this.configure({
+            ...options,
+            configure_mode: 1,
+        });
+    }
+    async configureToClips(options) {
+        const data = {
+            upload_id: options.uploadId,
+            source_type: '4',
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+            caption: options.caption || '',
+            clips_share_preview_to_feed: options.shareToFeed ? '1' : '0',
+            device: {
+                manufacturer: 'samsung',
+                model: 'SM-S928B',
+                android_version: 35,
+                android_release: '15',
+            },
+            length: options.length || 0,
+            poster_frame_index: '0',
+            audio_muted: '0',
+            filter_type: '0',
+            video_result: '',
+            clips_creation_entry_point: 'clips',
+        };
+        const response = await this.client.request.send({
+            url: '/api/v1/media/configure_to_clips/',
+            method: 'POST',
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+}
+module.exports = UploadRepository;

package/dist-ts/dist/repositories/user.repository.js

@@ -0,0 +1,332 @@
+const Repository = require('../core/repository');
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+class UserRepository extends Repository {
+    constructor(client) {
+        super(client);
+        this._usersCache = {};
+        this._usernamesCache = {};
+    }
+    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 infoV1(userId, fromModule = 'self_profile') {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/users/${userId}/info/`,
+            qs: { from_module: fromModule },
+        });
+        return response.body.user;
+    }
+    async userIdFromUsername(username) {
+        const user = await this.infoByUsername(username.toLowerCase());
+        return String(user.pk);
+    }
+    async usernameFromUserId(userId) {
+        const user = await this.info(userId);
+        return user.username;
+    }
+    async search(query, count = 50) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/users/search/',
+            qs: { q: query, count },
+        });
+        return response.body.users;
+    }
+    async searchExact(username) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/users/search/',
+            qs: {
+                q: username,
+                count: 1,
+                search_surface: 'user_search_page',
+            },
+        });
+        const users = response.body.users || [];
+        return users.find(u => u.username === username) || null;
+    }
+    async follow(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/create/${userId}/`,
+            form: this.client.request.sign({
+                _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({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+    async getFollowers(userId, amount = 200, maxId = null) {
+        return this._paginateUsers(`/api/v1/friendships/${userId}/followers/`, amount, maxId);
+    }
+    async getFollowing(userId, amount = 200, maxId = null) {
+        return this._paginateUsers(`/api/v1/friendships/${userId}/following/`, amount, maxId);
+    }
+    async _paginateUsers(endpoint, amount = 200, startMaxId = null) {
+        const allUsers = [];
+        let nextMaxId = startMaxId;
+        while (allUsers.length < amount) {
+            const qs = {};
+            if (nextMaxId)
+                qs.max_id = nextMaxId;
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: endpoint,
+                qs,
+            });
+            const body = response.body;
+            const users = body.users || [];
+            allUsers.push(...users);
+            if (!body.next_max_id)
+                break;
+            nextMaxId = body.next_max_id;
+        }
+        return { users: allUsers.slice(0, amount), nextMaxId };
+    }
+    async getFriendshipStatuses(userIds) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/friendships/show_many/',
+            form: this.client.request.sign({
+                user_ids: Array.isArray(userIds) ? userIds.join(',') : userIds,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async friendshipShow(userId) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/friendships/show/${userId}/`,
+        });
+        return response.body;
+    }
+    async getReelsTrayFeed() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/feed/reels_tray/',
+        });
+        return response.body;
+    }
+    async getUserTags(userId, maxId = null) {
+        const qs = {};
+        if (maxId)
+            qs.max_id = maxId;
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/usertags/${userId}/feed/`,
+            qs,
+        });
+        return response.body;
+    }
+    async getUserMedias(userId, amount = 50, maxId = null) {
+        const allItems = [];
+        let nextMaxId = maxId;
+        while (allItems.length < amount) {
+            const qs = { count: Math.min(amount - allItems.length, 33) };
+            if (nextMaxId)
+                qs.max_id = nextMaxId;
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: `/api/v1/feed/user/${userId}/`,
+                qs,
+            });
+            const body = response.body;
+            allItems.push(...(body.items || []));
+            if (!body.more_available || !body.next_max_id)
+                break;
+            nextMaxId = body.next_max_id;
+        }
+        return allItems.slice(0, amount);
+    }
+    async getUserReels(userId, amount = 50, maxId = null) {
+        const allItems = [];
+        let nextMaxId = maxId;
+        while (allItems.length < amount) {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/clips/user/',
+                form: {
+                    target_user_id: userId,
+                    page_size: Math.min(amount - allItems.length, 12),
+                    max_id: nextMaxId || '',
+                },
+            });
+            const body = response.body;
+            for (const item of (body.items || [])) {
+                allItems.push(item.media || item);
+            }
+            const pagingInfo = body.paging_info || {};
+            if (!pagingInfo.more_available)
+                break;
+            nextMaxId = pagingInfo.max_id || '';
+        }
+        return allItems.slice(0, amount);
+    }
+    async getUserClips(userId, amount = 50, maxId = null) {
+        return this.getUserReels(userId, amount, maxId);
+    }
+    async getUserStories(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/feed/user/${userId}/story/`,
+            form: {
+                supported_capabilities_new: JSON.stringify(this.client.state.constants.SUPPORTED_CAPABILITIES),
+            },
+        });
+        return response.body;
+    }
+    async setSelfBio(biography) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/set_biography/',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                raw_text: biography,
+            }),
+        });
+        return response.body;
+    }
+    async report(userId, reason = 1) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/users/${userId}/flag_user/`,
+            form: this.client.request.sign({
+                reason_id: reason,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async getSuggested() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/discover/ayml/',
+        });
+        return response.body;
+    }
+    async block(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/block/${userId}/`,
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+    async unblock(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/unblock/${userId}/`,
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+    async mute(userId, { muteStories = false, mutePosts = false } = {}) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/mute_posts_or_story_from_follow/`,
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                target_posts_author_id: mutePosts ? userId : '',
+                target_reel_author_id: muteStories ? userId : '',
+            }),
+        });
+        return response.body;
+    }
+    async unmute(userId, { unmuteStories = false, unmutePosts = false } = {}) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/unmute_posts_or_story_from_follow/`,
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                target_posts_author_id: unmutePosts ? userId : '',
+                target_reel_author_id: unmuteStories ? userId : '',
+            }),
+        });
+        return response.body;
+    }
+    async removeFollower(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/friendships/remove_follower/${userId}/`,
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+    async getBlockedUsers() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/users/blocked_list/',
+        });
+        return response.body;
+    }
+    async getMutualFollowers(userId) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/friendships/${userId}/mutual_followers/`,
+        });
+        return response.body;
+    }
+    static mediaPkFromCode(code) {
+        let pk = BigInt(0);
+        for (let i = 0; i < code.length; i++) {
+            const idx = ALPHABET.indexOf(code[i]);
+            if (idx === -1)
+                continue;
+            pk = pk * BigInt(64) + BigInt(idx);
+        }
+        return pk.toString();
+    }
+    static mediaCodeFromPk(pk) {
+        let id = BigInt(pk);
+        let code = '';
+        while (id > BigInt(0)) {
+            const remainder = Number(id % BigInt(64));
+            code = ALPHABET[remainder] + code;
+            id = id / BigInt(64);
+        }
+        return code;
+    }
+}
+module.exports = UserRepository;

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

@@ -0,0 +1,24 @@
+const sendPhoto = require('./sendPhoto');
+const sendFile = require('./sendFile');
+const uploadPhoto = require('./uploadPhoto');
+const uploadFile = require('./uploadfFile');
+const sendRavenPhotoModule = require('./sendRavenPhoto');
+const sendRavenVideoModule = require('./sendRavenVideo');
+const sendRavenPhoto = sendRavenPhotoModule.sendRavenPhoto || sendRavenPhotoModule;
+const sendRavenPhotoOnce = sendRavenPhotoModule.sendRavenPhotoOnce;
+const sendRavenPhotoReplayable = sendRavenPhotoModule.sendRavenPhotoReplayable;
+const sendRavenVideo = sendRavenVideoModule.sendRavenVideo || sendRavenVideoModule;
+const sendRavenVideoOnce = sendRavenVideoModule.sendRavenVideoOnce;
+const sendRavenVideoReplayable = sendRavenVideoModule.sendRavenVideoReplayable;
+module.exports = {
+    sendPhoto,
+    sendFile,
+    uploadPhoto,
+    uploadFile,
+    sendRavenPhoto,
+    sendRavenPhotoOnce,
+    sendRavenPhotoReplayable,
+    sendRavenVideo,
+    sendRavenVideoOnce,
+    sendRavenVideoReplayable,
+};

package/dist-ts/dist/sendmedia/sendFile.js

@@ -0,0 +1,56 @@
+/**
+ * sendFile.js - Fixed to support MQTT if realtime client provided
+ */
+const uploadFile = require('./uploadfFile');
+/**
+ * Send a file to Instagram Direct.
+ */
+async function sendFile(session, opts = {}) {
+    const { fileBuffer, mimeType = 'video/mp4', fileName, caption = '', userId, threadId, signal, realtimeClient, } = opts;
+    if (!userId && !threadId) {
+        throw new Error('sendFile: Provide userId or threadId.');
+    }
+    if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+        throw new Error('sendFile: fileBuffer must be a non-empty Buffer.');
+    }
+    // 1) Upload
+    const upload_id = await uploadFile(session, fileBuffer, {
+        mimeType,
+        fileName,
+        signal,
+    });
+    // 2) MQTT Check
+    if (realtimeClient && realtimeClient.direct && typeof realtimeClient.direct.sendMedia === 'function') {
+        return await realtimeClient.direct.sendMedia({
+            text: caption,
+            mediaId: upload_id,
+            threadId: threadId || userId,
+        });
+    }
+    // 3) REST Fallback
+    const url = '/direct_v2/threads/broadcast/upload_video/';
+    const form = {
+        upload_id,
+        action: 'send_item',
+        caption,
+    };
+    if (userId) {
+        form.recipient_users = JSON.stringify([[String(userId)]]);
+    }
+    else {
+        form.thread_ids = JSON.stringify([String(threadId)]);
+    }
+    try {
+        const response = await session.request.send({
+            url,
+            method: 'POST',
+            form,
+            signal,
+        });
+        return response;
+    }
+    catch (err) {
+        throw new Error(`sendFile: Broadcast failed — ${err.message}`);
+    }
+}
+module.exports = sendFile;