nodejs-insta-private-api-mqtt 1.3.49 → 1.3.51

package/dist/fbns/fbns.client.js

@@ -10,6 +10,18 @@ const mqtts_1 = require("../mqtt-shim");
 const errors_1 = require("../errors");
 const eventemitter3_1 = require("eventemitter3");
 const fbns_utilities_1 = require("./fbns.utilities");
+
+/**
+ * FbnsClient
+ *
+ * Lightweight wrapper around MQTToTClient to handle FBNS-specific connection
+ * payloads, registration, message handling and safe disconnect behavior.
+ *
+ * NOTE: This file contains a small but important robustness change:
+ * when receiving an empty CONNACK payload we no longer force a disconnect.
+ * Instagram sometimes returns a successful CONNACK with an empty payload;
+ * treating that as a fatal error causes unnecessary disconnect loops.
+ */
 class FbnsClient extends eventemitter3_1.EventEmitter {
     get auth() {
         return this._auth;
@@ -24,6 +36,7 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
         this.safeDisconnect = false;
         this._auth = new fbns_device_auth_1.FbnsDeviceAuth(this.ig);
     }
+
     buildConnection() {
         this.fbnsDebug('Constructing connection');
         this.conn = new mqttot_1.MQTToTConnection({
@@ -51,9 +64,25 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
             password: this._auth.password,
         });
     }
+
+    /**
+     * Connect to FBNS (Firebase/FBNS equivalent over Instagram MQTT)
+     *
+     * Options:
+     *  - enableTrace
+     *  - autoReconnect
+     *  - socksOptions
+     *  - additionalTlsOptions
+     *
+     * Important robustness changes:
+     *  - Do not force disconnect on empty CONNACK payload; log and continue.
+     *  - Use clean:false to prefer session resume on reconnect (less aggressive).
+     */
     async connect({ enableTrace, autoReconnect, socksOptions, additionalTlsOptions, } = {}) {
         this.fbnsDebug('Connecting to FBNS...');
+        // Ensure auth info is up-to-date
         this.auth.update();
+
         this.client = new mqttot_1.MQTToTClient({
             url: constants_1.FBNS.HOST_NAME_V6,
             payloadProvider: () => {
@@ -69,54 +98,91 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
             socksOptions,
             additionalOptions: additionalTlsOptions,
         });
+
+        // Re-emit warnings/errors to outer listeners
         this.client.on('warning', w => this.emit('warning', w));
         this.client.on('error', e => this.emit('error', e));
+
+        // If disconnect happens and safeDisconnect is false, emit error to upper layer
         this.client.on('disconnect', reason => this.safeDisconnect
             ? this.emit('disconnect', reason && JSON.stringify(reason))
             : this.emit('error', new errors_1.ClientDisconnectedError(`MQTToTClient got disconnected. Reason: ${reason && JSON.stringify(reason)}`)));
+
+        // Listen for FBNS messages and transform them accordingly
         this.client.listen(constants_1.FbnsTopics.FBNS_MESSAGE.id, msg => this.handleMessage(msg));
         this.client.listen({
             topic: constants_1.FbnsTopics.FBNS_EXP_LOGGING.id,
             transformer: async (msg) => JSON.parse((await (0, shared_1.tryUnzipAsync)(msg.payload)).toString()),
         }, msg => this.emit('logging', msg));
         this.client.listen(constants_1.FbnsTopics.PP.id, msg => this.emit('pp', msg.payload.toString()));
+
+        // Handle connect event from the underlying mqtt client
         this.client.on('connect', async (res) => {
             if (!this.client) {
                 throw new mqtts_1.IllegalStateError('No client registered but an event was received');
             }
+
             this.fbnsDebug('Connected to MQTT');
+
+            // IMPORTANT: Instagram sometimes returns a valid CONNACK with an empty payload.
+            // Historically this library treated that as an error and disconnected.
+            // That behavior causes unnecessary reconnect loops. Instead, log and continue.
             if (!res.payload?.length) {
-                this.fbnsDebug(`Received empty connect packet. Reason: ${res.errorName}; Try resetting your fbns state!`);
-                this.emit('error', new errors_1.EmptyPacketError('Received empty connect packet. Try resetting your fbns state!'));
-                await this.client.disconnect();
-                return;
+                this.fbnsDebug(`Received empty connect packet. Reason: ${res.errorName} (continuing without disconnect)`);
+                // Emit a warning but do not disconnect.
+                this.emit('warning', new errors_1.EmptyPacketError('Received empty connect packet (continuing).'));
+                // NOTE: we do not return here because some flows expect the registration step below.
+                // If you prefer to skip registration on empty payload, uncomment the next line:
+                // return;
+            } else {
+                // If payload present, read auth as before
+                try {
+                    const payload = res.payload.toString('utf8');
+                    this.fbnsDebug(`Received auth: ${payload}`);
+                    this._auth.read(payload);
+                    this.emit('auth', this.auth);
+                } catch (e) {
+                    this.fbnsDebug(`Failed to parse connect payload: ${e?.message || e}`);
+                    this.emit('error', e);
+                    // do not force disconnect here - let reconnect logic handle transient issues
+                }
+            }
+
+            // Continue with registration attempt if possible.
+            try {
+                await this.client.mqttotPublish({
+                    topic: constants_1.FbnsTopics.FBNS_REG_REQ.id,
+                    payload: Buffer.from(JSON.stringify({
+                        pkg_name: constants_1.INSTAGRAM_PACKAGE_NAME,
+                        appid: this.ig.state.fbAnalyticsApplicationId,
+                    }), 'utf8'),
+                    qosLevel: 1,
+                });
+            } catch (e) {
+                // Log registration publish error but don't necessarily abort connection entirely here
+                this.fbnsDebug(`FBNS_REG_REQ publish failed: ${e?.message || e}`);
+                this.emit('warning', e);
             }
-            const payload = res.payload.toString('utf8');
-            this.fbnsDebug(`Received auth: ${payload}`);
-            this._auth.read(payload);
-            this.emit('auth', this.auth);
-            await this.client.mqttotPublish({
-                topic: constants_1.FbnsTopics.FBNS_REG_REQ.id,
-                payload: Buffer.from(JSON.stringify({
-                    pkg_name: constants_1.INSTAGRAM_PACKAGE_NAME,
-                    appid: this.ig.state.fbAnalyticsApplicationId,
-                }), 'utf8'),
-                qosLevel: 1,
-            });
-            // this.buildConnection(); ?
         });
+
+        // Establish connection with conservative options (prefer session resume)
         await this.client
             .connect({
-            keepAlive: 60,
-            protocolLevel: 3,
-            clean: true,
-            connectDelay: 60 * 1000,
-        })
+                keepAlive: 60,
+                protocolLevel: 3,
+                // Use clean: false to allow session resume where the broker supports it.
+                // If you have issues with stale state, consider setting clean: true.
+                clean: false,
+                connectDelay: 60 * 1000,
+            })
             .catch(e => {
-            this.fbnsDebug(`Connection failed: ${e}`);
-            throw e;
-        });
+                this.fbnsDebug(`Connection failed: ${e}`);
+                throw e;
+            });
+
+        // Subscribe to FBNS message topic and wait for register response
         await this.client.subscribe({ topic: constants_1.FbnsTopics.FBNS_MESSAGE.id });
+
         const msg = await (0, shared_1.listenOnce)(this.client, constants_1.FbnsTopics.FBNS_REG_RESP.id);
         const data = await (0, shared_1.tryUnzipAsync)(msg.payload);
         const payload = data.toString('utf8');
@@ -136,6 +202,7 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
             throw e;
         }
     }
+
     disconnect() {
         this.safeDisconnect = true;
         if (!this.client) {
@@ -143,6 +210,7 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
         }
         return this.client.disconnect();
     }
+
     async handleMessage(msg) {
         const payload = JSON.parse((await (0, shared_1.tryUnzipAsync)(msg.payload)).toString('utf8'));
         if ((0, shared_1.notUndefined)(payload.fbpushnotif)) {
@@ -156,6 +224,7 @@ class FbnsClient extends eventemitter3_1.EventEmitter {
             this.emit('message', payload);
         }
     }
+
     async sendPushRegister(token) {
         const { body } = await this.ig.request.send({
             url: `/api/v1/push/register/`,

package/dist/mqttot/mqttot.client.js

@@ -1,23 +1,35 @@
 'use strict';
-// Instagram version: 412.0.0.35.87
+// Instagram version marker (adjust as you like)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mqttotConnectFlow = exports.MQTToTClient = void 0;
-// Export the Instagram version so it can be used programmatically
 exports.INSTAGRAM_VERSION = '420.0.0.42.95';
+
 const shared_1 = require("../shared");
 const mqttot_connect_request_packet_1 = require("./mqttot.connect.request.packet");
-// *** Change: import the external mqtts package instead of a local mqtt-shim ***
+// 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 the external mqtts.MqttClient implementation.
- * - Provides Instagram-specific connect/publish helpers (Thrift payload, debug).
- * - Keeps compatibility with options used by the original library.
+ * - 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,
@@ -42,13 +54,73 @@ class MQTToTClient extends mqtts_1.MqttClient {
                     additionalOptions: options.additionalOptions,
                 }),
         });
-        // small debug helper that prefixes messages with the broker url
-        this.mqttotDebug = (msg, ...args) => (0, shared_1.debugChannel)('mqttot')(`${options.url}: ${msg}`, ...args);
+
+        // 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;
+
+        // Keepalive: periodically send PINGREQ to avoid idle timeouts on Instagram
+        // Default interval 10-15 minutes; adjust if you need more/less aggressive keepalive.
+        // Use a relatively long interval to avoid being rate-limited, but short enough to stay online.
+        this._keepaliveMs = (typeof options.keepaliveMs === 'number') ? options.keepaliveMs : (10 * 60 * 1000); // 10 min default
+        this._startKeepalive();
     }
+
+    /**
+     * Start the periodic keepalive ping. Wrapped so we can restart/clear safely.
+     */
+    _startKeepalive() {
+        try {
+            if (this._keepaliveTimer) clearInterval(this._keepaliveTimer);
+            this._keepaliveTimer = setInterval(() => {
+                try {
+                    // Defensive: only call ping if function exists
+                    if (typeof this.ping === 'function') {
+                        this.mqttotDebug('Sending PINGREQ (keepalive)');
+                        // ping() may be sync or return a promise; wrap in try/catch
+                        const res = this.ping();
+                        if (res && typeof res.then === 'function') {
+                            res.catch((e) => this.mqttotDebug(`Ping promise rejected: ${e?.message || e}`));
+                        }
+                    } else {
+                        // As a fallback: write a zero-length control packet if library exposes low-level send
+                        this.mqttotDebug('ping() not available on client - keepalive skipped');
+                    }
+                } catch (e) {
+                    this.mqttotDebug(`Ping error: ${e?.message || e}`);
+                }
+            }, this._keepaliveMs);
+        } catch (e) {
+            this.mqttotDebug(`Keepalive setup error: ${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') {
@@ -58,47 +130,106 @@ class MQTToTClient extends mqtts_1.MqttClient {
                 this.mqttotDebug(`${type}: ${e.message}\n\tStack: ${e.stack}`);
             }
         };
-        // Attach basic diagnostics so errors/warnings are visible via debugChannel
+
+        // Attach diagnostics
         this.on('error', printErrorOrWarning('Error'));
         this.on('warning', printErrorOrWarning('Warning'));
-        this.on('disconnect', e => this.mqttotDebug(`Disconnected. ${e}`));
+
+        // Listen to ping responses if the library emits them
+        this.on('pingresp', () => {
+            this.mqttotDebug('Received PINGRESP (keepalive ok)');
+        });
+
+        // On disconnect: try to reconnect with exponential backoff.
+        // This avoids immediate tight reconnect loops and gives the server time.
+        this.on('disconnect', async (reason) => {
+            try {
+                this.mqttotDebug(`Disconnected. Reason: ${reason}`);
+                // Stop keepalive while disconnected
+                this._stopKeepalive();
+
+                // If autoReconnect option is false, do not attempt manual reconnect
+                if (this._options && this._options.autoReconnect === false) {
+                    this.mqttotDebug('autoReconnect disabled; will not attempt reconnect.');
+                    return;
+                }
+
+                // Exponential backoff parameters
+                let delay = 2000; // start with 2s
+                const maxAttempts = 8; // 2s,4s,8s,... up to ~512s
+                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                    try {
+                        this.mqttotDebug(`Reconnect attempt #${attempt + 1} (delay ${delay}ms)`);
+                        // Attempt to reconnect; call this.connect which will fetch new payload as needed
+                        // Use saved options; this.connect will call connectPayloadProvider internally
+                        await this.connect(this._options);
+                        this.mqttotDebug('Reconnected successfully');
+                        // restart keepalive after reconnect
+                        this._startKeepalive();
+                        return;
+                    } catch (err) {
+                        this.mqttotDebug(`Reconnect attempt #${attempt + 1} failed: ${err?.message || err}`);
+                        // wait before next attempt
+                        await new Promise(r => setTimeout(r, delay));
+                        // exponential backoff
+                        delay = Math.min(delay * 2, 5 * 60 * 1000); // cap to 5 minutes
+                    }
+                }
+                this.mqttotDebug('Exceeded reconnect attempts; giving up until next disconnect event triggers it again.');
+            } catch (e) {
+                this.mqttotDebug(`Error in disconnect handler: ${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.
-        this.connectPayload = await this.connectPayloadProvider();
+        if (typeof this.connectPayloadProvider === 'function') {
+            try {
+                this.connectPayload = await this.connectPayloadProvider();
+            } catch (e) {
+                this.mqttotDebug(`connectPayloadProvider failed: ${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 the payload and publishes it.
-     * NOTE: Always publishes with qosLevel: 0 to avoid puback/retry instability.
-     * Rationale: Instagram/edge MQTT sometimes behaves inconsistently with QoS1 (missing PUBACKs,
-     * delayed acks, etc.). For stability we force QoS 0 here so the library avoids waiting on ACKs
-     * that may never arrive and causing reconnect loops.
-     *
-     * @param {MqttMessage} message
-     * @returns {Promise}
+     * 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}bytes to topic ${message.topic}`);
+        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: await (0, shared_1.compressDeflate)(message.payload),
+            payload: compressed,
             qosLevel: 0, // FORCED: QoS 0 for stability on Instagram edge
         });
     }
+
     /**
-     * Special listener for specific topics with transformers
-     * This helper attaches a transformer that converts raw message payloads into
-     * structured data before calling the provided handler.
-     *
-     * @param {Object} config - { topic, transformer }
-     * @param {Function} handler - Callback to handle transformed data
+     * Helper to listen for a specific topic and run transformer before calling handler.
      */
     listen(config, handler) {
         this.mqttotDebug(`[LISTEN] Setting up listener on topic ${config.topic} with transformer`);
@@ -108,23 +239,36 @@ class MQTToTClient extends mqtts_1.MqttClient {
                     const data = await config.transformer({ payload: msg.payload });
                     handler(data);
                 } catch (e) {
-                    this.mqttotDebug(`Error in transformer for topic ${config.topic}: ${e.message}`);
+                    this.mqttotDebug(`Error in transformer for topic ${config.topic}: ${e?.message || e}`);
                     this.emit('error', e);
                 }
             }
         });
     }
+
+    /**
+     * 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?.message || e}`);
+        }
+    }
 }
 exports.MQTToTClient = MQTToTClient;
 
 /**
- * NOTE: changed acceptance logic for CONNACK payload:
- * - Historically the connect flow expected a payload in CONNACK (requirePayload = true),
- *   but Instagram/edge sometimes replies with an empty payload even when connection is valid.
- * - To avoid noisy 'CONNACK: no payload (payloadExpected)' errors and unnecessary disconnect logs,
- *   we now treat any successful CONNACK (packet.isSuccess) as success regardless of payload.
- *
- * If you *do* need to enforce payload presence for some reason, revert this block to check requirePayload.
+ * 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) => ({
@@ -138,7 +282,7 @@ function mqttotConnectFlow(payload, requirePayload) {
         accept: mqtts_1.isConnAck,
         next: (packet) => {
             if (packet.isSuccess) {
-                // *** CHANGED: accept success even if payload is empty ***
+                // Accept success even if payload is empty to avoid noisy errors
                 success(packet);
             }
             else {