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

package/dist-ts/dist/mqttot/mqttot.client.js

@@ -0,0 +1,322 @@
+'use strict';
+// Instagram version marker (adjust as you like)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mqttotConnectFlow = exports.MQTToTClient = void 0;
+exports.INSTAGRAM_VERSION = '415.0.0.36.76';
+const shared_1 = require("../shared");
+const mqttot_connect_request_packet_1 = require("./mqttot.connect.request.packet");
+// Use external mqtts package (must be installed in your project)
+const mqtts_1 = require("mqtts");
+const errors_1 = require("../errors");
+const mqttot_connect_response_packet_1 = require("./mqttot.connect.response.packet");
+/**
+ * MQTToTClient
+ * - Subclasses external mqtts.MqttClient
+ * - Adds Instagram-specific helpers (connect flow, compressed publish)
+ * - Adds keepalive (PING) and robust reconnect with exponential backoff
+ *
+ * Comments/notes are inline. This file is ready to paste into your project.
+ */
+class MQTToTClient extends mqtts_1.MqttClient {
+    /**
+     * @param {Object} options
+     *   options:
+     *     - url: broker host
+     *     - socksOptions: optional proxy options
+     *     - autoReconnect: boolean
+     *     - payloadProvider: async function returning connection payload (Thrift blob)
+     *     - requirePayload: boolean (legacy behavior)
+     *     - additionalOptions: transport options passthrough
+     */
+    constructor(options) {
+        super({
+            autoReconnect: options.autoReconnect,
+            readMap: {
+                ...mqtts_1.DefaultPacketReadMap,
+                [mqtts_1.PacketType.ConnAck]: mqttot_connect_response_packet_1.readConnectResponsePacket,
+            },
+            writeMap: {
+                ...mqtts_1.DefaultPacketWriteMap,
+                [mqtts_1.PacketType.Connect]: mqttot_connect_request_packet_1.writeConnectRequestPacket,
+            },
+            transport: options.socksOptions
+                ? new mqtts_1.SocksTlsTransport({
+                    host: options.url,
+                    port: 443,
+                    proxyOptions: options.socksOptions,
+                    additionalOptions: options.additionalOptions,
+                })
+                : new mqtts_1.TlsTransport({
+                    host: options.url,
+                    port: 443,
+                    additionalOptions: options.additionalOptions,
+                }),
+        });
+        // Save options for reconnect attempts
+        this._options = options || {};
+        // Debug helper prefixed with broker url
+        this.mqttotDebug = (msg, ...args) => (0, shared_1.debugChannel)('mqttot')(`${this._options.url}: ${msg}`, ...args);
+        this.connectPayloadProvider = options.payloadProvider;
+        this.mqttotDebug(`Creating client`);
+        // Register listeners (errors, disconnect, pingresps, etc.)
+        this.registerListeners();
+        this.requirePayload = options.requirePayload;
+        this._keepaliveMs = (typeof options.keepaliveMs === 'number') ? options.keepaliveMs : (8 * 60 * 1000);
+        this._consecutivePingFailures = 0;
+        this._startKeepalive();
+    }
+    _startKeepalive() {
+        try {
+            if (this._keepaliveTimer)
+                clearInterval(this._keepaliveTimer);
+            const jitter = Math.floor(Math.random() * 30000);
+            this._keepaliveTimer = setInterval(() => {
+                try {
+                    if (typeof this.ping === 'function') {
+                        this.mqttotDebug('Sending PINGREQ (keepalive)');
+                        const res = this.ping();
+                        if (res && typeof res.then === 'function') {
+                            res.then(() => {
+                                this._consecutivePingFailures = 0;
+                            }).catch((e) => {
+                                this._consecutivePingFailures++;
+                                this.mqttotDebug(`Ping failed (${this._consecutivePingFailures}): ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                                if (this._consecutivePingFailures >= 3) {
+                                    this.mqttotDebug('3 consecutive ping failures - emitting disconnect for reconnect');
+                                    this._consecutivePingFailures = 0;
+                                    this.emit('disconnect', 'ping_failure');
+                                }
+                            });
+                        }
+                    }
+                    else {
+                        this.mqttotDebug('ping() not available - keepalive skipped');
+                    }
+                }
+                catch (e) {
+                    this.mqttotDebug(`Ping error: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                }
+            }, this._keepaliveMs + jitter);
+        }
+        catch (e) {
+            this.mqttotDebug(`Keepalive setup error: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+        }
+    }
+    /**
+     * Stop keepalive timer (call on explicit close/disconnect)
+     */
+    _stopKeepalive() {
+        try {
+            if (this._keepaliveTimer) {
+                clearInterval(this._keepaliveTimer);
+                this._keepaliveTimer = null;
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    /**
+     * Register event listeners on the underlying mqtt client to handle:
+     * - errors / warnings
+     * - disconnects -> attempt reconnection with exponential backoff
+     * - pingresp events for diagnostics
+     */
+    registerListeners() {
+        const printErrorOrWarning = (type) => (e) => {
+            if (typeof e === 'string') {
+                this.mqttotDebug(`${type}: ${e}`);
+            }
+            else {
+                this.mqttotDebug(`${type}: ${e.message}\n\tStack: ${e.stack}`);
+            }
+        };
+        // Attach diagnostics
+        this.on('error', printErrorOrWarning('Error'));
+        this.on('warning', printErrorOrWarning('Warning'));
+        // Listen to ping responses if the library emits them
+        this.on('pingresp', () => {
+            this.mqttotDebug('Received PINGRESP (keepalive ok)');
+        });
+        this.on('disconnect', async (reason) => {
+            try {
+                this.mqttotDebug(`Disconnected. Reason: ${reason}`);
+                this._stopKeepalive();
+                if (this._options && this._options.autoReconnect === false) {
+                    this.mqttotDebug('autoReconnect disabled; will not attempt reconnect.');
+                    return;
+                }
+                let delay = 3000 + Math.floor(Math.random() * 2000);
+                const maxAttempts = 12;
+                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                    try {
+                        this.mqttotDebug(`Reconnect attempt #${attempt + 1} (delay ${delay}ms)`);
+                        try {
+                            this.reset();
+                        }
+                        catch (_e) { }
+                        try {
+                            this.transport.reset();
+                        }
+                        catch (_e) { }
+                        try {
+                            this.transformer = this.createTransformer();
+                        }
+                        catch (_e) { }
+                        await this.connect(this._options);
+                        this.mqttotDebug('Reconnected successfully');
+                        this._consecutivePingFailures = 0;
+                        this._startKeepalive();
+                        return;
+                    }
+                    catch (err) {
+                        const errMsg = ((err === null || err === void 0 ? void 0 : err.message) || String(err)).toLowerCase();
+                        const isRateLimit = errMsg.includes('rate') || errMsg.includes('throttl') || errMsg.includes('429');
+                        this.mqttotDebug(`Reconnect attempt #${attempt + 1} failed: ${(err === null || err === void 0 ? void 0 : err.message) || err}`);
+                        if (isRateLimit) {
+                            delay = Math.min(delay * 3, 10 * 60 * 1000);
+                        }
+                        else {
+                            delay = Math.min(delay * 2, 5 * 60 * 1000);
+                        }
+                        const jitter = Math.floor(Math.random() * Math.min(delay * 0.2, 5000));
+                        await new Promise(r => setTimeout(r, delay + jitter));
+                    }
+                }
+                this.mqttotDebug(`Exceeded ${maxAttempts} reconnect attempts. Waiting for external trigger.`);
+            }
+            catch (e) {
+                this.mqttotDebug(`Error in disconnect handler: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+            }
+        });
+    }
+    /**
+     * connect override
+     * - Waits for connect payload from provider before calling parent connect
+     */
+    async connect(options) {
+        // Acquire the payload (Thrift serialized connection blob) before connecting.
+        if (typeof this.connectPayloadProvider === 'function') {
+            try {
+                this.connectPayload = await this.connectPayloadProvider();
+            }
+            catch (e) {
+                this.mqttotDebug(`connectPayloadProvider failed: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                throw e;
+            }
+        }
+        else {
+            this.mqttotDebug('No connectPayloadProvider provided; proceeding without payload');
+            this.connectPayload = null;
+        }
+        // Call super.connect to establish connection
+        return super.connect(options);
+    }
+    /**
+     * Return an Instagram-flavored connect flow function for the mqtts client.
+     * If payload is missing but CONNACK indicates success, accept it (robustness).
+     */
+    getConnectFlow() {
+        if (!this.connectPayload) {
+            throw new mqtts_1.IllegalStateError('Called getConnectFlow() before calling connect()');
+        }
+        return mqttotConnectFlow(this.connectPayload, this.requirePayload);
+    }
+    /**
+     * Compresses payload using shared.compressDeflate and publishes with QoS 0.
+     * QoS 0 forced for Instagram edge stability (avoid PUBACK waits causing reconnect loops).
+     */
+    async mqttotPublish(message) {
+        this.mqttotDebug(`Publishing ${message.payload.byteLength || message.payload.length} bytes to topic ${message.topic}`);
+        const compressed = await (0, shared_1.compressDeflate)(message.payload);
+        return await this.publish({
+            topic: message.topic,
+            payload: compressed,
+            qosLevel: 0, // FORCED: QoS 0 for stability on Instagram edge
+        });
+    }
+    /**
+     * Helper to listen for a specific topic and run transformer before calling handler.
+     */
+    listen(configOrTopic, handler) {
+        if (typeof configOrTopic === 'string') {
+            const topicId = configOrTopic;
+            this.mqttotDebug(`[LISTEN] Setting up raw listener on topic ${topicId}`);
+            const listener = async (msg) => {
+                if (msg.topic === topicId) {
+                    try {
+                        handler(msg);
+                    }
+                    catch (e) {
+                        this.mqttotDebug(`Error in handler for topic ${topicId}: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                        this.emit('error', e);
+                    }
+                }
+            };
+            this.on('message', listener);
+            return () => { this.removeListener('message', listener); };
+        }
+        const config = configOrTopic;
+        this.mqttotDebug(`[LISTEN] Setting up listener on topic ${config.topic} with transformer`);
+        const listener = async (msg) => {
+            if (msg.topic === config.topic) {
+                try {
+                    const data = await config.transformer({ payload: msg.payload });
+                    handler(data);
+                }
+                catch (e) {
+                    this.mqttotDebug(`Error in transformer for topic ${config.topic}: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                    this.emit('error', e);
+                }
+            }
+        };
+        this.on('message', listener);
+        return () => { this.removeListener('message', listener); };
+    }
+    /**
+     * Clean shutdown helper: stop keepalive & close
+     */
+    async gracefulClose() {
+        try {
+            this._stopKeepalive();
+            if (typeof super.close === 'function') {
+                // some libs provide close() or end()
+                await super.close();
+            }
+            else if (typeof super.end === 'function') {
+                await super.end();
+            }
+        }
+        catch (e) {
+            this.mqttotDebug(`Error during gracefulClose: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+        }
+    }
+}
+exports.MQTToTClient = MQTToTClient;
+/**
+ * mqttotConnectFlow
+ * - Returns a flow object that the mqtts client uses to perform CONNECT/CONNACK handshake.
+ * - Changed behavior: treat CONNACK success as success even if payload missing (robustness).
+ */
+function mqttotConnectFlow(payload, requirePayload) {
+    return (success, error) => ({
+        start: () => ({
+            type: mqtts_1.PacketType.Connect,
+            options: {
+                payload,
+                keepAlive: 60,
+            },
+        }),
+        accept: mqtts_1.isConnAck,
+        next: (packet) => {
+            if (packet.isSuccess) {
+                // Accept success even if payload is empty to avoid noisy errors
+                success(packet);
+            }
+            else {
+                error(new errors_1.ConnectionFailedError(`CONNACK returnCode: ${packet.returnCode} errorName: ${packet.errorName}`));
+            }
+        },
+    });
+}
+exports.mqttotConnectFlow = mqttotConnectFlow;

package/dist-ts/dist/mqttot/mqttot.connect.request.packet.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeConnectRequestPacket = void 0;
+function writeConnectRequestPacket(stream, options) {
+    stream.writeString('MQTToT').writeByte(3).writeByte(194).writeWord(options.keepAlive).write(options.payload);
+    return {};
+}
+exports.writeConnectRequestPacket = writeConnectRequestPacket;

package/dist-ts/dist/mqttot/mqttot.connect.response.packet.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConnectResponsePacket = exports.MQTToTConnectResponsePacket = void 0;
+const mqtts_1 = require("mqtts");
+class MQTToTConnectResponsePacket extends mqtts_1.ConnectResponsePacket {
+    constructor(ackFlags, returnCode, payload) {
+        super(ackFlags, returnCode);
+        this.payload = payload;
+    }
+}
+exports.MQTToTConnectResponsePacket = MQTToTConnectResponsePacket;
+function readConnectResponsePacket(stream, remaining) {
+    const ack = stream.readByte();
+    const returnCode = stream.readByte();
+    if (ack > 1) {
+        throw new Error('Invalid ack');
+    }
+    else if (returnCode > 5) {
+        throw new Error('Invalid return code');
+    }
+    return new MQTToTConnectResponsePacket(ack, returnCode, remaining > 2 ? stream.readStringAsBuffer() : Buffer.alloc(0));
+}
+exports.readConnectResponsePacket = readConnectResponsePacket;

package/dist-ts/dist/mqttot/mqttot.connection.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTToTConnection = void 0;
+const thrift_1 = require("../thrift");
+class MQTToTConnection {
+    constructor(connectionData) {
+        this.fbnsConnectionData = connectionData;
+    }
+    toThrift() {
+        // Clone safely – DO NOT mutate original objects used by MQTT
+        const connCopy = Object.assign({}, this.fbnsConnectionData);
+        const originalClientInfo = this.fbnsConnectionData && this.fbnsConnectionData.clientInfo;
+        const clientInfoCopy = originalClientInfo ? Object.assign({}, originalClientInfo) : undefined;
+        if (clientInfoCopy) {
+            // ✅ MQTT REQUIRES STRING
+            if (typeof clientInfoCopy.userAgent !== 'string' || !clientInfoCopy.userAgent) {
+                clientInfoCopy.userAgent = 'Instagram 415.0.0.36.76 Android';
+            }
+            // ✅ MQTT REQUIRES STRING
+            if (typeof clientInfoCopy.clientType !== 'string' || !clientInfoCopy.clientType) {
+                clientInfoCopy.clientType = 'com.instagram.android';
+            }
+            connCopy.clientInfo = clientInfoCopy;
+        }
+        // ✅ Thrift will serialize binary fields correctly
+        return (0, thrift_1.thriftWriteFromObject)(connCopy, MQTToTConnection.thriftConfig);
+    }
+    toString() {
+        return this.toThrift().toString();
+    }
+}
+exports.MQTToTConnection = MQTToTConnection;
+MQTToTConnection.thriftConfig = [
+    thrift_1.ThriftDescriptors.binary('clientIdentifier', 1),
+    thrift_1.ThriftDescriptors.binary('willTopic', 2),
+    thrift_1.ThriftDescriptors.binary('willMessage', 3),
+    thrift_1.ThriftDescriptors.struct('clientInfo', 4, [
+        thrift_1.ThriftDescriptors.int64('userId', 1),
+        thrift_1.ThriftDescriptors.binary('userAgent', 2),
+        thrift_1.ThriftDescriptors.int64('clientCapabilities', 3),
+        thrift_1.ThriftDescriptors.int64('endpointCapabilities', 4),
+        thrift_1.ThriftDescriptors.int32('publishFormat', 5),
+        thrift_1.ThriftDescriptors.boolean('noAutomaticForeground', 6),
+        thrift_1.ThriftDescriptors.boolean('makeUserAvailableInForeground', 7),
+        thrift_1.ThriftDescriptors.binary('deviceId', 8),
+        thrift_1.ThriftDescriptors.boolean('isInitiallyForeground', 9),
+        thrift_1.ThriftDescriptors.int32('networkType', 10),
+        thrift_1.ThriftDescriptors.int32('networkSubtype', 11),
+        thrift_1.ThriftDescriptors.int64('clientMqttSessionId', 12),
+        thrift_1.ThriftDescriptors.binary('clientIpAddress', 13),
+        thrift_1.ThriftDescriptors.listOfInt32('subscribeTopics', 14),
+        thrift_1.ThriftDescriptors.binary('clientType', 15),
+        thrift_1.ThriftDescriptors.int64('appId', 16),
+        thrift_1.ThriftDescriptors.boolean('overrideNectarLogging', 17),
+        thrift_1.ThriftDescriptors.binary('connectTokenHash', 18),
+        thrift_1.ThriftDescriptors.binary('regionPreference', 19),
+        thrift_1.ThriftDescriptors.binary('deviceSecret', 20),
+        thrift_1.ThriftDescriptors.byte('clientStack', 21),
+        thrift_1.ThriftDescriptors.int64('fbnsConnectionKey', 22),
+        thrift_1.ThriftDescriptors.binary('fbnsConnectionSecret', 23),
+        thrift_1.ThriftDescriptors.binary('fbnsDeviceId', 24),
+        thrift_1.ThriftDescriptors.binary('fbnsDeviceSecret', 25),
+        thrift_1.ThriftDescriptors.int64('anotherUnknown', 26),
+    ]),
+    thrift_1.ThriftDescriptors.binary('password', 5), thrift_1.ThriftDescriptors.listOfBinary('getDiffsRequests', 6),
+    thrift_1.ThriftDescriptors.binary('zeroRatingTokenHash', 9),
+    thrift_1.ThriftDescriptors.mapBinaryBinary('appSpecificInfo', 10),
+];

package/dist-ts/dist/realtime/commands/commands.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+const shared_1 = require("../../shared");
+class Commands {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Publish a compressed payload to a topic.
+     * - Forces QoS 0 (no PUBACK wait) because Instagram internal MQTT often
+     *   doesn't reply PUBACK for these internal topics and QoS1 causes timeouts
+     *   and reconnect instability.
+     * - No-op if client is not connected to avoid "Socket not writable" errors.
+     * - Defensive checks: if the client exposes .connected or .isConnected(), respect them.
+     */
+    async publishToTopic(topic, compressedData, qos = 0) {
+        try {
+            // Defensive: ensure we have a client
+            if (!this.client)
+                return;
+            // If client exposes a boolean 'connected' flag, respect it
+            if (typeof this.client.connected !== 'undefined' && !this.client.connected) {
+                return;
+            }
+            // If client exposes an isConnected() method, respect it
+            if (typeof this.client.isConnected === 'function' && !this.client.isConnected()) {
+                return;
+            }
+            // Build payload buffer
+            const payloadBuf = compressedData instanceof Buffer ? compressedData : Buffer.from(compressedData);
+            // Always publish with QoS 0 for stability on IG edge MQTT
+            return this.client.publish({
+                topic,
+                payload: payloadBuf,
+                qosLevel: 0,
+            });
+        }
+        catch (err) {
+            // Swallow non-fatal publish errors. Upper layers/watchdog should handle reconnections.
+            return;
+        }
+    }
+    /**
+     * updateSubscriptions used by RealtimeClient for keepalive / subscription refreshes.
+     * - Compresses the subscription payload and publishes with QoS 0.
+     * - Skips publishing if the MQTT client doesn't appear ready.
+     */
+    async updateSubscriptions(options) {
+        try {
+            if (!this.client)
+                return;
+            // Defensive connection checks
+            if (typeof this.client.connected !== 'undefined' && !this.client.connected)
+                return;
+            if (typeof this.client.isConnected === 'function' && !this.client.isConnected())
+                return;
+            const payload = await (0, shared_1.compressDeflate)(JSON.stringify(options.data || {}));
+            return this.publishToTopic(options.topic.id, payload, 0);
+        }
+        catch (e) {
+            // Non-fatal — avoid bubbling errors from keepalive timers
+            return;
+        }
+    }
+}
+exports.Commands = Commands;