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

package/dist-ts/dist/services/live.service.js

@@ -0,0 +1,113 @@
+const Repository = require('../core/repository');
+class LiveService extends Repository {
+    async create(options = {}) {
+        const { previewWidth = 720, previewHeight = 1280, broadcastMessage = '', } = options;
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/live/create/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                preview_width: previewWidth,
+                preview_height: previewHeight,
+                broadcast_message: broadcastMessage,
+            }),
+        });
+        return response.body;
+    }
+    async start(broadcastId, shouldSendNotifications = false) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/start/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                should_send_notifications: shouldSendNotifications ? '1' : '0',
+            }),
+        });
+        return response.body;
+    }
+    async end(broadcastId, endAfterCopyrightWarning = false) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/end_broadcast/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                end_after_copyright_warning: endAfterCopyrightWarning ? '1' : '0',
+            }),
+        });
+        return response.body;
+    }
+    async info(broadcastId) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/live/${broadcastId}/info/`,
+        });
+        return response.body;
+    }
+    async getViewerList(broadcastId) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: `/api/v1/live/${broadcastId}/get_viewer_list/`,
+        });
+        return response.body;
+    }
+    async comment(broadcastId, message) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/comment/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                user_breadcrumb: this.client.request.userBreadcrumb(message.length),
+                idempotence_token: Date.now(),
+                comment_text: message,
+                live_or_vod: '1',
+                offset: '0',
+            }),
+        });
+        return response.body;
+    }
+    async like(broadcastId, likeCount = 1) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/like/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                user_like_count: likeCount,
+            }),
+        });
+        return response.body;
+    }
+    async getHeartbeatAndViewerCount(broadcastId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/heartbeat_and_get_viewer_count/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                offset_to_video_start: '0',
+            }),
+        });
+        return response.body;
+    }
+    async muteComment(broadcastId, userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/mute_comment/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+    async unmuteComment(broadcastId, userId) {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: `/api/v1/live/${broadcastId}/unmute_comment/`,
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+                user_id: userId,
+            }),
+        });
+        return response.body;
+    }
+}
+module.exports = LiveService;

package/dist-ts/dist/services/search.service.js

@@ -0,0 +1,91 @@
+const Repository = require('../core/repository');
+class SearchService extends Repository {
+    async search(query, options = {}) {
+        const { searchType = 'blended', count = 30, rankToken = this.client.state.uuid } = options;
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/fbsearch/topsearch/',
+            qs: {
+                query,
+                search_surface: 'top_search_page',
+                timezone_offset: this.client.state.timezoneOffset,
+                count,
+                rank_token: rankToken,
+            }
+        });
+        return response.body;
+    }
+    async searchUsers(query, count = 30) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/users/search/',
+            qs: {
+                q: query,
+                count,
+                rank_token: this.client.state.uuid,
+            }
+        });
+        return response.body;
+    }
+    async searchHashtags(query, count = 30) {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/tags/search/',
+            qs: {
+                q: query,
+                count,
+                rank_token: this.client.state.uuid,
+            }
+        });
+        return response.body;
+    }
+    async searchLocations(query, lat = null, lng = null, count = 30) {
+        const qs = {
+            search_query: query,
+            count,
+            rank_token: this.client.state.uuid,
+        };
+        if (lat && lng) {
+            qs.latitude = lat;
+            qs.longitude = lng;
+        }
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/location_search/',
+            qs
+        });
+        return response.body;
+    }
+    async getRecentSearches() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/fbsearch/recent_searches/',
+        });
+        return response.body;
+    }
+    async clearRecentSearches() {
+        const response = await this.client.request.send({
+            method: 'POST',
+            url: '/api/v1/fbsearch/clear_search_history/',
+            form: this.client.request.sign({
+                _uuid: this.client.state.uuid,
+            }),
+        });
+        return response.body;
+    }
+    async getSuggestedUsers() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/discover/ayml/',
+        });
+        return response.body;
+    }
+    async getSuggestedHashtags() {
+        const response = await this.client.request.send({
+            method: 'GET',
+            url: '/api/v1/tags/suggested/',
+        });
+        return response.body;
+    }
+}
+module.exports = SearchService;

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = exports.debugChannel = exports.tryUnzipAsync = exports.compressDeflate = exports.prepareLogString = void 0;
+const pako = require('pako');
+const debug = require('debug');
+function prepareLogString(str) {
+    return str.length > 100 ? str.substring(0, 100) + '...' : str;
+}
+exports.prepareLogString = prepareLogString;
+function compressDeflate(data) {
+    return Buffer.from(pako.deflate(data));
+}
+exports.compressDeflate = compressDeflate;
+async function tryUnzipAsync(data) {
+    try {
+        return Buffer.from(pako.inflate(data));
+    }
+    catch (e) {
+        return data;
+    }
+}
+exports.tryUnzipAsync = tryUnzipAsync;
+function debugChannel(channel) {
+    return debug(`ig:mqtt:${channel}`);
+}
+exports.debugChannel = debugChannel;
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.delay = delay;
+function createFbnsUserAgent(ig) {
+    var _a, _b, _c, _d;
+    const deviceStr = ((_a = ig.state) === null || _a === void 0 ? void 0 : _a.deviceString) || '';
+    const parts = deviceStr.split('; ');
+    const androidVersion = (parts[0] || '').split('/')[1] || '15';
+    const resolution = parts[2] || '1440x3120';
+    const manufacturer = (parts[3] || 'samsung').trim();
+    const deviceName = (parts[4] || 'SM-S928B').trim();
+    const [width, height] = resolution.split('x');
+    const params = {
+        FBAN: 'MQTT',
+        FBAV: ((_b = ig.state) === null || _b === void 0 ? void 0 : _b.appVersion) || '415.0.0.36.76',
+        FBBV: ((_c = ig.state) === null || _c === void 0 ? void 0 : _c.appVersionCode) || '580610226',
+        FBDM: `{density=4.0,width=${width},height=${height}`,
+        FBLC: ((_d = ig.state) === null || _d === void 0 ? void 0 : _d.language) || 'en_US',
+        FBCR: 'Android',
+        FBMF: manufacturer,
+        FBBD: 'Android',
+        FBPN: 'com.instagram.android',
+        FBDV: deviceName,
+        FBSV: androidVersion,
+        FBLR: '0',
+        FBBK: '1',
+        FBCA: 'x86:armeabi-v7a',
+    };
+    return `[${Object.entries(params).map(p => p.join('/')).join(';')}]`;
+}
+exports.createFbnsUserAgent = createFbnsUserAgent;
+function notUndefined(a) {
+    return typeof a !== 'undefined';
+}
+exports.notUndefined = notUndefined;
+function listenOnce(client, topic) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            if (typeof removeFn === 'function')
+                try {
+                    removeFn();
+                }
+                catch (e) { }
+            reject(new Error('listenOnce timeout after 30s'));
+        }, 30000);
+        let removeFn;
+        if (typeof client.listen === 'function') {
+            removeFn = client.listen(topic, msg => {
+                clearTimeout(timeout);
+                if (typeof removeFn === 'function')
+                    try {
+                        removeFn();
+                    }
+                    catch (e) { }
+                resolve(msg);
+            });
+        }
+        else {
+            const handler = (msg) => {
+                if (msg && (msg.topic === topic || String(msg.topic) === String(topic))) {
+                    clearTimeout(timeout);
+                    client.removeListener('message', handler);
+                    resolve(msg);
+                }
+            };
+            client.on('message', handler);
+            removeFn = () => client.removeListener('message', handler);
+        }
+    });
+}
+exports.listenOnce = listenOnce;

package/dist-ts/dist/shared/shared.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareLogString = exports.listenOnce = exports.notUndefined = exports.debugChannel = exports.isJson = exports.tryUnzipAsync = exports.unzipAsync = exports.compressDeflate = exports.createFbnsUserAgent = void 0;
+const zlib_1 = require("zlib");
+const debug_1 = require("debug");
+const util_1 = require("util");
+const deflatePromise = (0, util_1.promisify)(zlib_1.deflate);
+const unzipPromise = (0, util_1.promisify)(zlib_1.unzip);
+// TODO: map
+function createFbnsUserAgent(ig) {
+    const [androidVersion, , resolution, manufacturer, deviceName] = ig.state.deviceString.split('; ');
+    const [width, height] = resolution.split('x');
+    const params = {
+        FBAN: 'MQTT',
+        FBAV: ig.state.appVersion,
+        FBBV: ig.state.appVersionCode,
+        FBDM: `{density=4.0,width=${width},height=${height}`,
+        FBLC: ig.state.language,
+        FBCR: 'Android',
+        FBMF: manufacturer.trim(),
+        FBBD: 'Android',
+        FBPN: 'com.instagram.android',
+        FBDV: deviceName.trim(),
+        FBSV: androidVersion.split('/')[1],
+        FBLR: '0',
+        FBBK: '1',
+        FBCA: 'x86:armeabi-v7a',
+    };
+    return `[${Object.entries(params)
+        .map(p => p.join('/'))
+        .join(';')}]`;
+}
+exports.createFbnsUserAgent = createFbnsUserAgent;
+function compressDeflate(data) {
+    return deflatePromise(data, { level: 9 });
+}
+exports.compressDeflate = compressDeflate;
+function unzipAsync(data) {
+    return unzipPromise(data);
+}
+exports.unzipAsync = unzipAsync;
+async function tryUnzipAsync(data) {
+    try {
+        if (data.readInt8(0) !== 0x78)
+            return data;
+        return unzipAsync(data);
+    }
+    catch (e) {
+        return data;
+    }
+}
+exports.tryUnzipAsync = tryUnzipAsync;
+function isJson(buffer) {
+    return !!String.fromCharCode(buffer[0]).match(/[{[]/);
+}
+exports.isJson = isJson;
+/**
+ * Returns a debug function with a path starting with ig:mqtt
+ * @param {string} path
+ * @returns {(msg: string, ...additionalData: any) => void}
+ */
+const debugChannel = (...path) => (0, debug_1.default)(['ig', 'mqtt', ...path].join(':'));
+exports.debugChannel = debugChannel;
+function notUndefined(a) {
+    return typeof a !== 'undefined';
+}
+exports.notUndefined = notUndefined;
+function listenOnce(client, topic) {
+    return new Promise(resolve => {
+        const removeFn = client.listen(topic, msg => {
+            removeFn();
+            resolve(msg);
+        });
+    });
+}
+exports.listenOnce = listenOnce;
+const MAX_STRING_LENGTH = 128;
+const ACTUAL_MAX_LEN = MAX_STRING_LENGTH - `"[${MAX_STRING_LENGTH}...]"`.length;
+function prepareLogString(value) {
+    if (value.length > ACTUAL_MAX_LEN) {
+        value = `${value.substring(0, ACTUAL_MAX_LEN)}[${MAX_STRING_LENGTH}...]`;
+    }
+    return `"${value}"`;
+}
+exports.prepareLogString = prepareLogString;

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function (m, exports) {
+    for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+            __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./thrift"), exports);
+__exportStar(require("./thrift.reading"), exports);
+__exportStar(require("./thrift.writing"), exports);

package/dist-ts/dist/thrift/thrift.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeInt64 = exports.int64ToBigInt = exports.int64ToNumberSafe = exports.int64ToNumber = exports.ThriftDescriptors = exports.isThriftBoolean = exports.ThriftTypes = void 0;
+/**
+ * Thrift Compact Protocol (subset) helpers used by nodejs-insta-private-api-mqt.
+ * Notes:
+ * - Instagram's MQTT-over-Thrift payloads can contain INT_64 values that exceed JS Number safe range.
+ * - This module keeps backward compatibility (int64ToNumber) but also exposes safe helpers.
+ */
+exports.ThriftTypes = {
+    STOP: 0x00,
+    TRUE: 0x01,
+    FALSE: 0x02,
+    BYTE: 0x03,
+    INT_16: 0x04,
+    INT_32: 0x05,
+    INT_64: 0x06,
+    DOUBLE: 0x07,
+    BINARY: 0x08,
+    LIST: 0x09,
+    SET: 0x0a,
+    MAP: 0x0b,
+    STRUCT: 0x0c,
+    // Common "packed" meta-types used by this project:
+    LIST_INT_16: (0x04 << 8) | 0x09,
+    LIST_INT_32: (0x05 << 8) | 0x09,
+    LIST_INT_64: (0x06 << 8) | 0x09,
+    LIST_BINARY: (0x08 << 8) | 0x09,
+    MAP_BINARY_BINARY: (0x88 << 8) | 0x0b,
+    // internal!
+    BOOLEAN: 0xa1,
+};
+function isThriftBoolean(type) {
+    type &= 0x0f;
+    return (type === exports.ThriftTypes.TRUE ||
+        type === exports.ThriftTypes.FALSE ||
+        type === exports.ThriftTypes.BOOLEAN);
+}
+exports.isThriftBoolean = isThriftBoolean;
+exports.ThriftDescriptors = {
+    boolean: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.BOOLEAN }),
+    byte: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.BYTE }),
+    int16: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.INT_16 }),
+    int32: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.INT_32 }),
+    int64: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.INT_64 }),
+    double: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.DOUBLE }),
+    binary: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.BINARY }),
+    listOfInt16: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.LIST_INT_16 }),
+    listOfInt32: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.LIST_INT_32 }),
+    listOfInt64: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.LIST_INT_64 }),
+    listOfBinary: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.LIST_BINARY }),
+    mapBinaryBinary: (fieldName, field) => ({ field, fieldName, type: exports.ThriftTypes.MAP_BINARY_BINARY }),
+    struct: (fieldName, field, descriptors) => ({
+        field,
+        fieldName,
+        type: exports.ThriftTypes.STRUCT,
+        structDescriptors: descriptors,
+    }),
+};
+function int64ToBigInt(i64) {
+    if (typeof i64 === "bigint")
+        return i64;
+    if (typeof i64 === "number")
+        return BigInt(i64);
+    if (typeof i64 === "string")
+        return BigInt(i64);
+    if (i64 && typeof i64 === "object") {
+        // Support patterns: { int: bigint } (our reader), Long-like, etc.
+        if (typeof i64.int === "bigint")
+            return i64.int;
+        if (typeof i64.toString === "function")
+            return BigInt(i64.toString());
+    }
+    // Fallback (may throw)
+    return BigInt(i64);
+}
+exports.int64ToBigInt = int64ToBigInt;
+function isSafeInt64(i64) {
+    const bi = int64ToBigInt(i64);
+    const max = BigInt(Number.MAX_SAFE_INTEGER);
+    const min = BigInt(Number.MIN_SAFE_INTEGER);
+    return bi <= max && bi >= min;
+}
+exports.isSafeInt64 = isSafeInt64;
+/**
+ * Backward compatible: converts to Number (may lose precision if out of range).
+ */
+function int64ToNumber(i64) {
+    if (typeof i64 === "number")
+        return i64;
+    // Preserve previous behavior (Number(...) fallback)
+    return Number(i64 && typeof i64 === "object" && "int" in i64 ? i64.int : i64);
+}
+exports.int64ToNumber = int64ToNumber;
+/**
+ * Safe conversion: throws if out of safe range.
+ */
+function int64ToNumberSafe(i64) {
+    const bi = int64ToBigInt(i64);
+    if (!isSafeInt64(bi)) {
+        throw new RangeError(`int64 out of safe Number range: ${bi.toString()}`);
+    }
+    return Number(bi);
+}
+exports.int64ToNumberSafe = int64ToNumberSafe;