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

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

@@ -0,0 +1,370 @@
+const Repository = require('../core/repository');
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+class MediaRepository extends Repository {
+    async info(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/info/`,
+            method: 'GET',
+        });
+        return response.body;
+    }
+    async like(mediaId, moduleInfo = { module_name: 'feed_timeline' }) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/like/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                radio_type: this.client.state.radioType,
+                module_name: moduleInfo.module_name,
+            }),
+        });
+        return response.body;
+    }
+    async unlike(mediaId, moduleInfo = { module_name: 'feed_timeline' }) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/unlike/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                radio_type: this.client.state.radioType,
+                module_name: moduleInfo.module_name,
+            }),
+        });
+        return response.body;
+    }
+    async comment(mediaId, commentText) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                comment_text: commentText,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                radio_type: this.client.state.radioType,
+                module_name: 'feed_timeline',
+            }),
+        });
+        return response.body;
+    }
+    async deleteComment(mediaId, commentId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/${commentId}/delete/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async delete(mediaId, mediaType = 'PHOTO') {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/delete/`,
+            method: 'POST',
+            qs: { media_type: mediaType },
+            form: this.client.request.sign({
+                igtv_feed_preview: false,
+                media_id: mediaId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async edit(mediaId, captionText, options = {}) {
+        const { usertags, location } = options;
+        const data = {
+            igtv_feed_preview: false,
+            media_id: mediaId,
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+            caption_text: captionText,
+        };
+        if (usertags)
+            data.usertags = JSON.stringify({ in: usertags });
+        if (location) {
+            data.location = JSON.stringify(location);
+        }
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/edit_media/`,
+            method: 'POST',
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+    async seen(reels) {
+        const response = await this.client.request.send({
+            url: '/api/v1/media/seen/',
+            method: 'POST',
+            form: this.client.request.sign({
+                reels: JSON.stringify(reels),
+                live_vods: JSON.stringify([]),
+                nf_token: '',
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                container_module: 'feed_short_url',
+            }),
+        });
+        return response.body;
+    }
+    async likers(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/likers/`,
+            method: 'GET',
+        });
+        return response.body;
+    }
+    async comments(mediaId, maxId = null, amount = 20) {
+        const allComments = [];
+        let nextMaxId = maxId;
+        while (allComments.length < amount) {
+            const qs = {};
+            if (nextMaxId)
+                qs.max_id = nextMaxId;
+            const response = await this.client.request.send({
+                url: `/api/v1/media/${mediaId}/comments/`,
+                method: 'GET',
+                qs,
+            });
+            const body = response.body;
+            allComments.push(...(body.comments || []));
+            if (!body.has_more_comments || !body.next_max_id)
+                break;
+            nextMaxId = body.next_max_id;
+        }
+        return allComments.slice(0, amount);
+    }
+    async replyToComment(mediaId, commentId, replyText) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                comment_text: replyText,
+                replied_to_comment_id: commentId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                radio_type: this.client.state.radioType,
+            }),
+        });
+        return response.body;
+    }
+    async likeComment(mediaId, commentId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/${commentId}/comment_like/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async unlikeComment(mediaId, commentId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/${commentId}/comment_unlike/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async pinComment(mediaId, commentId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/${commentId}/pin_comment/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async unpinComment(mediaId, commentId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/${commentId}/unpin_comment/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async bulkDeleteComments(mediaId, commentIds) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comment/bulk_delete/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                comment_ids_to_delete: Array.isArray(commentIds) ? commentIds.join(',') : commentIds,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async save(mediaId, collectionId = null) {
+        const form = {
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+        };
+        if (collectionId)
+            form.added_collection_ids = JSON.stringify([collectionId]);
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/save/`,
+            method: 'POST',
+            form: this.client.request.sign(form),
+        });
+        return response.body;
+    }
+    async unsave(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/unsave/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async archive(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/only_me/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async unarchive(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/undo_only_me/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                media_id: mediaId,
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async disableComments(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/disable_comments/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async enableComments(mediaId) {
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/enable_comments/`,
+            method: 'POST',
+            form: this.client.request.sign({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async commentThreadComments(mediaId, commentId, maxId = null) {
+        const qs = {};
+        if (maxId)
+            qs.max_id = maxId;
+        const response = await this.client.request.send({
+            url: `/api/v1/media/${mediaId}/comments/${commentId}/inline_child_comments/`,
+            method: 'GET',
+            qs,
+        });
+        return response.body;
+    }
+    async oembed(url) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/oembed/',
+            qs: { url },
+        });
+        return response.body;
+    }
+    async downloadByUrl(url) {
+        const axios = require('axios');
+        const response = await axios.get(url, { responseType: 'arraybuffer' });
+        return Buffer.from(response.data);
+    }
+    async downloadPhoto(mediaPk) {
+        var _a;
+        const result = await this.info(mediaPk);
+        const items = result.items || [result];
+        const item = items[0] || result;
+        const candidates = ((_a = item.image_versions2) === null || _a === void 0 ? void 0 : _a.candidates) || [];
+        if (!candidates.length)
+            throw new Error('No image candidates found');
+        return this.downloadByUrl(candidates[0].url);
+    }
+    async downloadVideo(mediaPk) {
+        const result = await this.info(mediaPk);
+        const items = result.items || [result];
+        const item = items[0] || result;
+        const videoVersions = item.video_versions || [];
+        if (!videoVersions.length)
+            throw new Error('No video versions found');
+        return this.downloadByUrl(videoVersions[0].url);
+    }
+    static mediaPkFromCode(code) {
+        let pk = BigInt(0);
+        for (let i = 0; i < Math.min(code.length, 11); 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;
+    }
+    static mediaPkFromUrl(url) {
+        try {
+            const parsed = new URL(url);
+            const parts = parsed.pathname.split('/').filter(p => p.length > 0);
+            const code = parts[parts.length - 1];
+            return MediaRepository.mediaPkFromCode(code.substring(0, 11));
+        }
+        catch {
+            return null;
+        }
+    }
+    mediaId(mediaPk, userId) {
+        return `${mediaPk}_${userId}`;
+    }
+    mediaPk(mediaId) {
+        return String(mediaId).split('_')[0];
+    }
+    async getUser(mediaPk) {
+        const result = await this.info(mediaPk);
+        const items = result.items || [result];
+        return (items[0] || result).user;
+    }
+}
+module.exports = MediaRepository;

package/dist-ts/dist/repositories/multiple-accounts.repository.js

@@ -0,0 +1,36 @@
+const Repository = require('../core/repository');
+class MultipleAccountsRepository extends Repository {
+    async getFeaturedAccounts() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/multiple_accounts/get_featured_accounts/',
+        });
+        return response.body;
+    }
+    async getAccountFamily() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/multiple_accounts/get_account_family/',
+        });
+        return response.body;
+    }
+    async getAccountInfo() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/multiple_accounts/get_account_info/',
+        });
+        return response.body;
+    }
+    async switchAccount(userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/multiple_accounts/switch_account/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = MultipleAccountsRepository;

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

@@ -0,0 +1,32 @@
+const Repository = require('../core/repository');
+class NewsRepository extends Repository {
+    async inbox() {
+        const response = await this.client.request.send({
+            url: '/api/v1/news/inbox/',
+            method: 'GET',
+        });
+        return response.body;
+    }
+    async getFollowRequests(maxId = null) {
+        const qs = {};
+        if (maxId)
+            qs.max_id = maxId;
+        const response = await this.client.request.send({
+            url: '/api/v1/news/inbox/',
+            method: 'GET',
+            qs: { ...qs, filters: 'follow_requests' },
+        });
+        return response.body;
+    }
+    async markAsSeen(timestamps = {}) {
+        const response = await this.client.request.send({
+            url: '/api/v1/news/inbox_seen/',
+            method: 'POST',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = NewsRepository;

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

@@ -0,0 +1,51 @@
+const Repository = require('../core/repository');
+class NoteRepository extends Repository {
+    async getNotes() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/notes/get_notes/',
+        });
+        return response.body;
+    }
+    async createNote(text, audience = 0) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/notes/create_note/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                text,
+                audience,
+            }),
+        });
+        return response.body;
+    }
+    async deleteNote(noteId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/notes/delete_note/${noteId}/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                id: noteId,
+            }),
+        });
+        return response.body;
+    }
+    async lastSeenUpdateNote() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/notes/last_seen_update/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async getNotesFollowing() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/notes/following_notes/',
+        });
+        return response.body;
+    }
+}
+module.exports = NoteRepository;

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

@@ -0,0 +1,77 @@
+const Repository = require('../core/repository');
+const MUTE_ALL_VALUES = ['cancel', '15_minutes', '1_hour', '2_hour', '4_hour', '8_hour'];
+const SETTING_VALUES = ['off', 'following_only', 'everyone'];
+class NotificationRepository extends Repository {
+    async changeSettings(contentType, settingValue) {
+        let userId;
+        try {
+            userId = this.client.state.cookieUserId;
+        }
+        catch {
+            userId = '0';
+        }
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/notifications/change_notification_settings/',
+            form: this.client.request.sign({
+                content_type: contentType,
+                setting_value: settingValue,
+                _uid: userId,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async muteAll(settingValue = '8_hour') {
+        if (!MUTE_ALL_VALUES.includes(settingValue)) {
+            throw new Error(`Unsupported mute value: ${settingValue}. Must be one of: ${MUTE_ALL_VALUES.join(', ')}`);
+        }
+        return this.changeSettings('mute_all', settingValue);
+    }
+    async likes(settingValue = 'off') { return this._assertAndSet('likes', settingValue); }
+    async likeAndCommentOnPhotoUserTagged(v = 'off') { return this._assertAndSet('like_and_comment_on_photo_user_tagged', v); }
+    async userTagged(v = 'off') { return this._assertAndSet('user_tagged', v); }
+    async comments(v = 'off') { return this._assertAndSet('comments', v); }
+    async commentLikes(v = 'off') { return this._assertAndSet('comment_likes', v); }
+    async firstPost(v = 'off') { return this._assertAndSet('first_post', v); }
+    async newFollower(v = 'off') { return this._assertAndSet('new_follower', v); }
+    async followRequestAccepted(v = 'off') { return this._assertAndSet('follow_request_accepted', v); }
+    async connection(v = 'off') { return this._assertAndSet('connection', v); }
+    async taggedInBio(v = 'off') { return this._assertAndSet('tagged_in_bio', v); }
+    async pendingDirectShare(v = 'off') { return this._assertAndSet('pending_direct_share', v); }
+    async directShareActivity(v = 'off') { return this._assertAndSet('direct_share_activity', v); }
+    async directGroupRequests(v = 'off') { return this._assertAndSet('direct_group_requests', v); }
+    async videoCall(v = 'off') { return this._assertAndSet('video_call', v); }
+    async rooms(v = 'off') { return this._assertAndSet('rooms', v); }
+    async liveBroadcast(v = 'off') { return this._assertAndSet('live_broadcast', v); }
+    async felixUploadResult(v = 'off') { return this._assertAndSet('felix_upload_result', v); }
+    async viewCount(v = 'off') { return this._assertAndSet('view_count', v); }
+    async fundraiserCreator(v = 'off') { return this._assertAndSet('fundraiser_creator', v); }
+    async fundraiserSupporter(v = 'off') { return this._assertAndSet('fundraiser_supporter', v); }
+    async reminders(v = 'off') { return this._assertAndSet('reminders', v); }
+    async announcements(v = 'off') { return this._assertAndSet('announcements', v); }
+    async reportUpdated(v = 'off') { return this._assertAndSet('report_updated', v); }
+    async login(v = 'off') { return this._assertAndSet('login_notification', v); }
+    async disableAll() {
+        const methods = [
+            'likes', 'likeAndCommentOnPhotoUserTagged', 'userTagged', 'comments',
+            'commentLikes', 'firstPost', 'newFollower', 'followRequestAccepted',
+            'connection', 'taggedInBio', 'pendingDirectShare', 'directShareActivity',
+            'directGroupRequests', 'videoCall', 'rooms', 'liveBroadcast',
+            'felixUploadResult', 'viewCount', 'fundraiserCreator', 'fundraiserSupporter',
+            'reminders', 'announcements', 'reportUpdated', 'login',
+        ];
+        const results = [];
+        for (const method of methods) {
+            results.push(await this[method]('off'));
+        }
+        return results.every(r => (r === null || r === void 0 ? void 0 : r.status) === 'ok');
+    }
+    _assertAndSet(contentType, settingValue) {
+        if (!SETTING_VALUES.includes(settingValue)) {
+            throw new Error(`Unsupported setting value: ${settingValue}. Must be one of: ${SETTING_VALUES.join(', ')}`);
+        }
+        return this.changeSettings(contentType, settingValue);
+    }
+}
+module.exports = NotificationRepository;

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

@@ -0,0 +1,34 @@
+const Repository = require('../core/repository');
+class ShareRepository extends Repository {
+    shareInfo(code) {
+        let decoded;
+        if (Buffer.isBuffer(code)) {
+            decoded = code.toString('utf8').replace(/\x1d/g, '');
+        }
+        else {
+            try {
+                decoded = Buffer.from(code, 'base64').toString('utf8').replace(/\x1d/g, '');
+            }
+            catch {
+                decoded = String(code);
+            }
+        }
+        const parts = decoded.split(':');
+        return { type: parts[0], pk: parts[1] || '' };
+    }
+    shareInfoByUrl(url) {
+        const code = this.shareCodeFromUrl(url);
+        return this.shareInfo(code);
+    }
+    shareCodeFromUrl(url) {
+        try {
+            const parsed = new URL(url);
+            const parts = parsed.pathname.split('/').filter(p => p.length > 0);
+            return parts[parts.length - 1];
+        }
+        catch {
+            return url;
+        }
+    }
+}
+module.exports = ShareRepository;