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

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

@@ -0,0 +1,178 @@
+const Repository = require('../core/repository');
+class SignupRepository extends Repository {
+    constructor(client) {
+        super(client);
+        this.waterfallId = this._generateUUID();
+    }
+    _generateUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+            const r = Math.random() * 16 | 0;
+            return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+    }
+    async signup(options = {}) {
+        const { username, password, email, phoneNumber = '', fullName = '', year = null, month = null, day = null, } = options;
+        await this.getSignupConfig();
+        const checkResult = await this.checkEmail(email);
+        if (!checkResult.valid) {
+            throw new Error(`Email not valid: ${checkResult.error_title || JSON.stringify(checkResult)}`);
+        }
+        if (!checkResult.available) {
+            throw new Error(`Email not available: ${checkResult.feedback_message || JSON.stringify(checkResult)}`);
+        }
+        const sendResult = await this.sendVerifyEmail(email);
+        if (!sendResult.email_sent) {
+            throw new Error(`Failed to send verification email: ${JSON.stringify(sendResult)}`);
+        }
+        if (year && month && day) {
+            const ageCheck = await this.checkAgeEligibility(year, month, day);
+            if (!ageCheck.eligible) {
+                throw new Error(`Not eligible based on age: ${JSON.stringify(ageCheck)}`);
+            }
+        }
+        return { status: 'verification_sent', email };
+    }
+    async getSignupConfig() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/consent/get_signup_config/',
+            qs: {
+                guid: this.client.state.uuid,
+                main_account_selected: false,
+            },
+        });
+        return response.body;
+    }
+    async checkEmail(email) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/users/check_email/',
+            form: {
+                android_device_id: this.client.state.deviceId,
+                login_nonce_map: '{}',
+                login_nonces: '[]',
+                email,
+                qe_id: this._generateUUID(),
+                waterfall_id: this.waterfallId,
+            },
+        });
+        return response.body;
+    }
+    async checkUsername(username) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/users/check_username/',
+            form: {
+                username,
+                _uuid: this.client.state.uuid,
+            },
+        });
+        return response.body;
+    }
+    async sendVerifyEmail(email) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/send_verify_email/',
+            form: {
+                phone_id: this.client.state.phoneId,
+                device_id: this.client.state.deviceId,
+                email,
+                waterfall_id: this.waterfallId,
+                auto_confirm_only: 'false',
+            },
+        });
+        return response.body;
+    }
+    async checkConfirmationCode(email, code) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/check_confirmation_code/',
+            form: {
+                code,
+                device_id: this.client.state.deviceId,
+                email,
+                waterfall_id: this.waterfallId,
+            },
+        });
+        return response.body;
+    }
+    async checkAgeEligibility(year, month, day) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/consent/check_age_eligibility/',
+            form: {
+                _uuid: this.client.state.uuid,
+                day: String(day),
+                month: String(month),
+                year: String(year),
+            },
+        });
+        return response.body;
+    }
+    async accountsCreate(options = {}) {
+        const { username, password, email, signupCode, fullName = '', year = null, month = null, day = null, } = options;
+        const { encrypted, time } = this.client.account.encryptPassword(password);
+        const data = {
+            enc_password: `#PWD_INSTAGRAM:4:${time}:${encrypted}`,
+            phone_id: this.client.state.phoneId,
+            username,
+            first_name: fullName,
+            day: day ? String(day) : '',
+            month: month ? String(month) : '',
+            year: year ? String(year) : '',
+            device_id: this.client.state.deviceId,
+            email,
+            signup_code: signupCode || '',
+            waterfall_id: this.waterfallId,
+            _uuid: this.client.state.uuid,
+            force_sign_up_code: '',
+            qs_stamp: '',
+            has_sms_consent: 'true',
+        };
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/create/',
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+    async sendSignupSmsCode(phoneNumber) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/send_signup_sms_code/',
+            form: this.client.request.sign({
+                phone_id: this.client.state.phoneId,
+                phone_number: phoneNumber,
+                waterfall_id: this.waterfallId,
+                has_whatsapp_installed: '0',
+            }),
+        });
+        return response.body;
+    }
+    async validateSignupSmsCode(phoneNumber, code) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/validate_signup_sms_code/',
+            form: this.client.request.sign({
+                phone_id: this.client.state.phoneId,
+                phone_number: phoneNumber,
+                verification_code: code,
+                waterfall_id: this.waterfallId,
+            }),
+        });
+        return response.body;
+    }
+    async getSuggestedUsernames(name, email) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/username_suggestions/',
+            form: {
+                name: name || '',
+                email: email || '',
+                waterfall_id: this.waterfallId,
+            },
+        });
+        return response.body;
+    }
+}
+module.exports = SignupRepository;

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

@@ -0,0 +1,268 @@
+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({
+                _uid: this.client.state.cookieUserId,
+                _uuid: this.client.state.uuid,
+                reaction_type: 'like',
+                emoji: reaction || '\u2764\uFE0F',
+            }),
+        });
+        return response.body;
+    }
+    async getFeed() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/feed/reels_tray/',
+            form: this.client.request.sign({
+                supported_capabilities_new: JSON.stringify(this.client.state.constants.SUPPORTED_CAPABILITIES),
+                reason: 'pull_to_refresh',
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        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 getUserStories(userId) {
+        return this.getUser(userId);
+    }
+    async upload(options) {
+        const { imagePath, caption, mentions, links, hashtags, stickers } = options;
+        const imageBuffer = fs.readFileSync(imagePath);
+        const uploadId = Date.now();
+        const uploadResult = await this.client.upload.photo({
+            file: imageBuffer,
+            uploadId,
+        });
+        return this.configureStory({
+            uploadId: uploadResult.upload_id,
+            caption,
+            mentions,
+            links,
+            hashtags,
+            stickers,
+        });
+    }
+    async uploadVideo(options) {
+        const { videoPath, caption, mentions, links, hashtags, stickers } = options;
+        const videoBuffer = fs.readFileSync(videoPath);
+        const uploadId = Date.now();
+        const uploadResult = await this.client.upload.video({
+            video: videoBuffer,
+            uploadId,
+            duration_ms: options.duration_ms || 15000,
+            width: options.width || 720,
+            height: options.height || 1280,
+        });
+        return this.configureStoryVideo({
+            uploadId: uploadResult.upload_id,
+            caption,
+            mentions,
+            links,
+            hashtags,
+            stickers,
+            length: options.duration_ms || 15000,
+        });
+    }
+    async configureStory(options = {}) {
+        const { uploadId, caption, mentions, links, hashtags, stickers } = options;
+        const data = {
+            upload_id: uploadId,
+            source_type: '4',
+            configure_mode: '1',
+            caption: caption || '',
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+        };
+        if (mentions && mentions.length > 0) {
+            data.reel_mentions = JSON.stringify(mentions);
+        }
+        if (links && links.length > 0) {
+            data.story_cta = JSON.stringify(links.map(l => ({
+                links: [{ webUri: l.url || l, linkType: 1 }],
+            })));
+        }
+        if (hashtags && hashtags.length > 0) {
+            data.story_hashtags = JSON.stringify(hashtags);
+        }
+        if (stickers && stickers.length > 0) {
+            data.story_sticker_ids = JSON.stringify(stickers.map(s => s.id || s));
+        }
+        const response = await this.client.request.send({
+            url: '/api/v1/media/configure_to_story/',
+            method: 'POST',
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+    async configureStoryVideo(options = {}) {
+        const { uploadId, caption, mentions, links, hashtags, stickers, length } = options;
+        const data = {
+            upload_id: uploadId,
+            source_type: '4',
+            configure_mode: '1',
+            caption: caption || '',
+            _uid: this.client.state.cookieUserId,
+            _uuid: this.client.state.uuid,
+            video_result: 'deprecated',
+            length: length || 0,
+            clips: JSON.stringify([{ length: length || 0, source_type: '4' }]),
+            poster_frame_index: '0',
+            audio_muted: '0',
+        };
+        if (mentions && mentions.length > 0) {
+            data.reel_mentions = JSON.stringify(mentions);
+        }
+        if (links && links.length > 0) {
+            data.story_cta = JSON.stringify(links.map(l => ({
+                links: [{ webUri: l.url || l, linkType: 1 }],
+            })));
+        }
+        if (hashtags && hashtags.length > 0) {
+            data.story_hashtags = JSON.stringify(hashtags);
+        }
+        if (stickers && stickers.length > 0) {
+            data.story_sticker_ids = JSON.stringify(stickers.map(s => s.id || s));
+        }
+        const response = await this.client.request.send({
+            url: '/api/v1/media/configure_to_story/',
+            method: 'POST',
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+    async seen(input, sourceId = null) {
+        let items = [];
+        if (Array.isArray(input)) {
+            items = input;
+        }
+        else {
+            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 ids = Array.isArray(highlightId) ? highlightId : [highlightId];
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/feed/reels_media/',
+            form: this.client.request.sign({
+                user_ids: ids,
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async getHighlightById(highlightId) {
+        return this.getHighlight(highlightId);
+    }
+    async viewers(storyId) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/media/${storyId}/list_reel_media_viewer/`,
+        });
+        return response.body;
+    }
+    async deleteStory(storyId) {
+        return this.client.media.delete(storyId, 'STORY');
+    }
+    async downloadByUrl(url) {
+        const axios = require('axios');
+        const response = await axios.get(url, { responseType: 'arraybuffer' });
+        return Buffer.from(response.data);
+    }
+    async download(storyPk) {
+        var _a;
+        const result = await this.client.media.info(storyPk);
+        const items = result.items || [result];
+        const item = items[0] || result;
+        if (item.video_versions && item.video_versions.length > 0) {
+            return this.downloadByUrl(item.video_versions[0].url);
+        }
+        const candidates = ((_a = item.image_versions2) === null || _a === void 0 ? void 0 : _a.candidates) || [];
+        if (candidates.length > 0) {
+            return this.downloadByUrl(candidates[0].url);
+        }
+        throw new Error('No media URL found for story');
+    }
+    async createHighlight(options = {}) {
+        const { title, coverMediaId, mediaIds = [] } = options;
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/highlights/create_reel/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                _uid: this.client.state.cookieUserId,
+                title: title || '',
+                cover: JSON.stringify({ media_id: coverMediaId }),
+                media_ids: JSON.stringify(mediaIds),
+            }),
+        });
+        return response.body;
+    }
+    async editHighlight(highlightId, options = {}) {
+        const { title, coverMediaId, addedMediaIds = [], removedMediaIds = [] } = options;
+        const data = {
+            _uuid: this.client.state.uuid,
+            _uid: this.client.state.cookieUserId,
+        };
+        if (title)
+            data.title = title;
+        if (coverMediaId)
+            data.cover = JSON.stringify({ media_id: coverMediaId });
+        if (addedMediaIds.length > 0)
+            data.added_media_ids = JSON.stringify(addedMediaIds);
+        if (removedMediaIds.length > 0)
+            data.removed_media_ids = JSON.stringify(removedMediaIds);
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/highlights/${highlightId}/edit_reel/`,
+            form: this.client.request.sign(data),
+        });
+        return response.body;
+    }
+    async deleteHighlight(highlightId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/highlights/${highlightId}/delete_reel/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                _uid: this.client.state.cookieUserId,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = StoryRepository;

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

@@ -0,0 +1,57 @@
+const Repository = require('../core/repository');
+class TimelineRepository extends Repository {
+    async reels(amount = 10, lastMediaPk = 0) {
+        return this._reelsTimelineMedia('clips/connected/', amount, lastMediaPk);
+    }
+    async exploreReels(amount = 10, lastMediaPk = 0) {
+        return this._reelsTimelineMedia('clips/discover/', amount, lastMediaPk);
+    }
+    async _reelsTimelineMedia(endpoint, amount = 10, lastMediaPk = 0) {
+        const totalItems = [];
+        let nextMaxId = '';
+        while (totalItems.length < amount) {
+            try {
+                const response = await this.client.request.send({
+                    method: 'POST',
+                    url: `/api/v1/${endpoint}`,
+                    form: { max_id: nextMaxId },
+                });
+                const body = response.body;
+                for (const item of (body.items || [])) {
+                    const media = item.media || item;
+                    if (lastMediaPk && String(media.pk) === String(lastMediaPk)) {
+                        return totalItems;
+                    }
+                    totalItems.push(media);
+                }
+                const pagingInfo = body.paging_info || {};
+                if (!pagingInfo.more_available)
+                    return totalItems;
+                nextMaxId = pagingInfo.max_id || '';
+            }
+            catch (e) {
+                return totalItems;
+            }
+        }
+        return totalItems.slice(0, amount);
+    }
+    async getFeed(maxId = '', options = {}) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/feed/timeline/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                is_prefetch: '0',
+                feed_view_info: '[]',
+                seen_posts: '',
+                phone_id: this.client.state.phoneId,
+                battery_level: String(Math.floor(Math.random() * 50) + 50),
+                timezone_offset: String(this.client.state.timezoneOffset),
+                max_id: maxId,
+                ...options,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = TimelineRepository;

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

@@ -0,0 +1,124 @@
+const Repository = require('../core/repository');
+const crypto = require('crypto');
+class TOTPRepository extends Repository {
+    async generateSeed() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/generate_two_factor_totp_key/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body.totp_seed;
+    }
+    async enable(verificationCode) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/enable_totp_two_factor/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                verification_code: verificationCode,
+            }),
+        });
+        return response.body.backup_codes || [];
+    }
+    async disable() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/disable_totp_two_factor/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body.status === 'ok';
+    }
+    generateCode(seed) {
+        const secret = this._base32Decode(seed);
+        const now = Math.floor(Date.now() / 1000);
+        const timeCode = Math.floor(now / 30);
+        return this._generateOTP(secret, timeCode);
+    }
+    _generateOTP(secret, input) {
+        if (input < 0)
+            throw new Error('Input must be positive');
+        const buffer = Buffer.alloc(8);
+        let val = input;
+        for (let i = 7; i >= 0; i--) {
+            buffer[i] = val & 0xff;
+            val = val >> 8;
+        }
+        const hmac = crypto.createHmac('sha1', secret);
+        hmac.update(buffer);
+        const hash = hmac.digest();
+        const offset = hash[hash.length - 1] & 0x0f;
+        const code = ((hash[offset] & 0x7f) << 24) |
+            ((hash[offset + 1] & 0xff) << 16) |
+            ((hash[offset + 2] & 0xff) << 8) |
+            (hash[offset + 3] & 0xff);
+        const otp = (code % 1000000).toString();
+        return otp.padStart(6, '0');
+    }
+    _base32Decode(input) {
+        const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+        let str = input.toUpperCase().replace(/=+$/, '');
+        const missing = str.length % 8;
+        if (missing)
+            str += '='.repeat(8 - missing);
+        str = str.replace(/=+$/, '');
+        let bits = '';
+        for (const char of str) {
+            const val = alphabet.indexOf(char);
+            if (val === -1)
+                continue;
+            bits += val.toString(2).padStart(5, '0');
+        }
+        const bytes = [];
+        for (let i = 0; i + 8 <= bits.length; i += 8) {
+            bytes.push(parseInt(bits.substr(i, 8), 2));
+        }
+        return Buffer.from(bytes);
+    }
+    async smsTwoFactorEnable(phoneNumber) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/send_two_factor_enable_sms/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                phone_number: phoneNumber,
+            }),
+        });
+        return response.body;
+    }
+    async smsTwoFactorConfirm(verificationCode) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/enable_sms_two_factor/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                verification_code: verificationCode,
+            }),
+        });
+        return response.body;
+    }
+    async disableSmsTwoFactor() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/disable_sms_two_factor/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async getBackupCodes() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/accounts/regen_backup_codes/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = TOTPRepository;

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

@@ -0,0 +1,50 @@
+const Repository = require('../core/repository');
+class TrackRepository extends Repository {
+    async downloadByUrl(url) {
+        const axios = require('axios');
+        const response = await axios.get(url, { responseType: 'arraybuffer' });
+        return Buffer.from(response.data);
+    }
+    async infoByCanonicalId(musicCanonicalId) {
+        var _a, _b;
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/clips/music/',
+            form: {
+                tab_type: 'clips',
+                referrer_media_id: '',
+                _uuid: this.client.state.uuid,
+                music_canonical_id: String(musicCanonicalId),
+            },
+        });
+        const body = response.body;
+        const trackData = (_b = (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.music_info) === null || _b === void 0 ? void 0 : _b.music_asset_info;
+        return trackData || body;
+    }
+    async infoById(trackId, maxId = '') {
+        const data = {
+            audio_cluster_id: trackId,
+            original_sound_audio_asset_id: trackId,
+        };
+        if (maxId)
+            data.max_id = maxId;
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/clips/music/',
+            form: data,
+        });
+        return response.body;
+    }
+    async search(query) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/music/audio_global_search/',
+            qs: {
+                query,
+                browse_session_id: this.client.state.uuid,
+            },
+        });
+        return response.body;
+    }
+}
+module.exports = TrackRepository;