nodejs-insta-private-api-mqtt 1.3.16 → 1.3.18

package/README.md

@@ -292,7 +292,7 @@ There are two practical, compatible flows you can use depending on your client h
 2. Call the direct broadcast / configure_photo or configure_video HTTP endpoint to create the message server-side. MQTT will then deliver the server-created message to connected clients.  
    - Use this if you prefer to avoid relying on the realtime command to create messages.
 
-> Summary: **Always rupload via HTTP.** Then either broadcast via HTTP (configure endpoints) or publish an MQTT `send_item` referencing `upload_id`. MQTT does not carry the media bytes, only the reference.
+> Summary: **Always rupload via HTTP.** Then **use the HTTP configure/broadcast endpoints as the primary, reliable method** to attach media to threads. Publishing an MQTT `send_item` referencing `upload_id` may work as a best-effort fallback on some servers, but it is not guaranteed. MQTT never carries the raw media bytes, only metadata/reference.
 
 ---
 
@@ -422,7 +422,7 @@ await mqtt.publish({
   **A:** No — MQTT is not used for large raw bytes. The app uploads bytes via rupload HTTP.
 
 - **Q:** *If I publish the MQTT `send_item` with `upload_id`, will the message appear in the thread?*  
-  **A:** Yes — the realtime server accepts an MQTT `send_item` referencing a valid `upload_id`. The server will attempt to create/attach the media message and then propagate the message via MESSAGE_SYNC to other clients. The exact behavior can differ between server versions, so keep fallback to HTTP broadcast if reliability is essential.
+  **A:** Sometimes the realtime server accepts an MQTT `send_item` referencing a valid `upload_id`, but this behavior is not universally reliable across server versions, accounts, or configurations. For production reliability prefer the HTTP broadcast/configure endpoints; keep MQTT reference as a best-effort fallback.
 
 - **Q:** *Do I need to call `/direct_v2/threads/broadcast/...` if I published MQTT?*  
   **A:** Often not — the APK pattern uses MQTT for the attach request. However, for absolute compatibility or for older server behavior, the HTTP configure/broadcast endpoints are a safe fallback.
@@ -2197,27 +2197,49 @@ async function sendVideoAsMqttReference({ ig, mqtt, videoBuffer, threadId, capti
 
   const serverUploadId = (uploadResponse && uploadResponse.upload_id) ? uploadResponse.upload_id : uploadId;
 
-  // Publish MQTT reference
-  const clientContext = uuidv4();
-  const command = {
-    action: 'send_item',
-    thread_id: String(threadId),
-    item_type: 'media',
-    upload_id: serverUploadId,
-    text: caption || '',
-    client_context: clientContext,
-    timestamp: Date.now(),
-  };
-
-  const json = JSON.stringify(command);
-  const payload = await compressDeflate(json);
-  await mqtt.publish({
-    topic: constants.Topics.SEND_MESSAGE.id,
-    qosLevel: 1,
-    payload,
+  // ATTACH VIA HTTP BROADCAST (preferred, reliable)
+// Attempt REST broadcast first (most reliable). This will create the direct message server-side
+// and let MQTT/clients receive the created message as normal sync.
+try {
+  const broadcastResponse = await ig.request.send({
+    url: '/direct_v2/threads/broadcast/upload_photo/',
+    method: 'POST',
+    form: {
+      upload_id: serverUploadId,
+      action: 'send_item',
+      thread_ids: JSON.stringify([String(threadId)]),
+      caption: caption || '',
+      client_context: clientContext,
+    },
+    timeout: 60000,
   });
-
-  return { upload_id: serverUploadId };
+  return { upload_id: serverUploadId, broadcastResponse };
+} catch (err) {
+  // If REST broadcast fails for transient reasons, fall back to attempting an MQTT reference publish.
+  // NOTE: MQTT 'reference' publish is not guaranteed to be accepted on all server versions or accounts.
+  // Keep it as a fallback only — the HTTP broadcast above is the recommended, reliable method.
+  try {
+    const json = JSON.stringify({
+      action: 'send_item',
+      thread_id: String(threadId),
+      item_type: 'media',
+      upload_id: serverUploadId,
+      text: caption || '',
+      client_context: clientContext,
+      timestamp: Date.now(),
+    });
+    const payload = await compressDeflate(json);
+    await mqtt.publish({
+      topic: constants.Topics.SEND_MESSAGE.id,
+      qosLevel: 1,
+      payload,
+    });
+    return { upload_id: serverUploadId, mqttFallback: true };
+  } catch (err2) {
+    // last-resort: return upload id and both errors for debugging
+    return { upload_id: serverUploadId, broadcastError: err?.message || String(err), mqttError: err2?.message || String(err2) };
+  }
+}
 }
 ```
 
@@ -2268,10 +2290,6 @@ async function sendVideoViaRestBroadcast({ ig, videoBuffer, threadId, caption =
 }
 ```
 
-### FAQ notes
-- **Does MQTT send the file?** No — MQTT only transports the JSON reference (`upload_id`) telling the server to attach that already-uploaded file into the thread.
-- **Why use MQTT for reference instead of REST broadcast?** MQTT gives near-realtime messaging semantics; the server applies the `upload_id` to the thread (same result), but the heavy binary upload must be done via HTTP `rupload`.
-- **Can you skip rupload and only send MQTT?** No — server needs the binary available under the `upload_id`. If you send only MQTT without previously uploading, the server won't have the file to attach.
 
 ---
 

package/dist/fbns/fbns.client.js

@@ -6,7 +6,7 @@ const fbns_device_auth_1 = require("./fbns.device-auth");
 const shared_1 = require("../shared");
 const mqttot_1 = require("../mqttot");
 const chance_1 = require("chance");
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../mqtt-shim");
 const errors_1 = require("../errors");
 const eventemitter3_1 = require("eventemitter3");
 const fbns_utilities_1 = require("./fbns.utilities");

package/dist/mqtt-shim.d.ts

@@ -0,0 +1,96 @@
+import { EventEmitter } from 'events';
+
+export class PacketType {
+  static Connect: number;
+  static ConnAck: number;
+  static Publish: number;
+  static PubAck: number;
+  static Subscribe: number;
+  static SubAck: number;
+  static Unsubscribe: number;
+  static UnsubAck: number;
+  static PingReq: number;
+  static PingResp: number;
+  static Disconnect: number;
+}
+
+export class ConnectResponsePacket {
+  ackFlags: number;
+  returnCode: number;
+  payload?: Buffer;
+  get isSuccess(): boolean;
+  get errorName(): string | null;
+  constructor(ackFlags: number, returnCode: number, payload?: Buffer);
+}
+
+export class IllegalStateError extends Error {}
+
+export interface MqttMessage {
+    topic: string;
+    payload: Buffer;
+    qosLevel?: number;
+}
+
+export interface MqttMessageOutgoing {
+    topic: string;
+    payload: Buffer;
+    qosLevel?: number;
+}
+
+export interface PacketFlowFunc {
+    (success: (packet: any) => void, error: (error: Error) => void): {
+        start: () => any;
+        accept: (packet: any) => boolean;
+        next: (packet: any) => void;
+    };
+}
+
+export class MqttClient extends EventEmitter {
+  constructor(options: any);
+  connect(options?: any): Promise<void>;
+  publish(message: MqttMessageOutgoing): Promise<any>;
+  subscribe(topic: string, qos?: number): Promise<void>;
+  disconnect(): void;
+  topicMap: Map<string, any>;
+}
+
+export class TlsTransport { constructor(options: any); }
+export class SocksTlsTransport { constructor(options: any); }
+
+export class PacketStream {
+  constructor(buffer: Buffer);
+  readByte(): number;
+  readStringAsBuffer(): Buffer;
+  readWord(): number;
+}
+
+export const DefaultPacketReadMap: any;
+export const DefaultPacketWriteMap: any;
+export function isConnAck(packet: any): boolean;
+
+export interface ConnectRequestOptions {
+    payload?: Buffer;
+    keepAlive?: number;
+    [key: string]: any;
+}
+
+export interface DefaultPacketReadResultMap {
+    [key: number]: (stream: PacketStream, length: number) => any;
+}
+
+export interface DefaultPacketWriteOptions {
+    [key: string]: any;
+}
+
+export interface PacketWriteResult {
+    [key: string]: any;
+}
+
+export enum ConnectReturnCode {
+    ACCEPTED = 0,
+    UNACCEPTABLE_PROTOCOL_VERSION = 1,
+    IDENTIFIER_REJECTED = 2,
+    SERVER_UNAVAILABLE = 3,
+    BAD_USERNAME_OR_PASSWORD = 4,
+    NOT_AUTHORIZED = 5,
+}

package/dist/mqtt-shim.js

@@ -0,0 +1,337 @@
+const EventEmitter = require('events');
+const tls = require('tls');
+const net = require('net');
+let SocksClient;
+try { SocksClient = require('socks').SocksClient; } catch (e) {}
+
+class PacketType {
+  static Connect = 1;
+  static ConnAck = 2;
+  static Publish = 3;
+  static PubAck = 4;
+  static Subscribe = 8;
+  static SubAck = 9;
+  static Unsubscribe = 10;
+  static UnsubAck = 11;
+  static PingReq = 12;
+  static PingResp = 13;
+  static Disconnect = 14;
+}
+
+class ConnectResponsePacket {
+  constructor(ackFlags, returnCode, payload) {
+    this.ackFlags = ackFlags;
+    this.returnCode = returnCode;
+    this.payload = payload;
+  }
+  get isSuccess() { return this.returnCode === 0; }
+  get errorName() { return this.returnCode !== 0 ? 'Connection Refused' : null; }
+}
+
+class IllegalStateError extends Error {
+  constructor(msg) { super(msg); this.name = 'IllegalStateError'; }
+}
+
+class PacketStream {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.offset = 0;
+  }
+  readByte() { 
+      if (this.offset >= this.buffer.length) return 0;
+      return this.buffer[this.offset++]; 
+  }
+  readStringAsBuffer() {
+    const len = this.readWord();
+    if (this.offset + len > this.buffer.length) return Buffer.alloc(0);
+    const buf = this.buffer.slice(this.offset, this.offset + len);
+    this.offset += len;
+    return buf;
+  }
+  readWord() {
+    if (this.offset + 2 > this.buffer.length) return 0;
+    const w = this.buffer.readUInt16BE(this.offset);
+    this.offset += 2;
+    return w;
+  }
+}
+
+class PacketWriter {
+    constructor() { this.chunks = []; }
+    writeByte(b) { const buf = Buffer.alloc(1); buf.writeUInt8(b); this.chunks.push(buf); return this; }
+    writeWord(w) { const buf = Buffer.alloc(2); buf.writeUInt16BE(w); this.chunks.push(buf); return this; }
+    writeString(s) { this.writeWord(s.length); this.chunks.push(Buffer.from(s)); return this; }
+    write(buf) { this.chunks.push(buf); return this; }
+    toBuffer() { return Buffer.concat(this.chunks); }
+}
+
+class MqttClient extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options || {};
+    this.readMap = options.readMap || {};
+    this.writeMap = options.writeMap || {};
+    this.socket = null;
+    this.topicMap = new Map();
+    this.packetIdCounter = 1;
+    this.pendingPublishes = new Map(); // PacketID -> {resolve, reject, timer}
+    this.pingTimer = null;
+    this.keepAliveInterval = 60000;
+  }
+
+  getNextPacketId() {
+      const id = this.packetIdCounter;
+      this.packetIdCounter++;
+      if (this.packetIdCounter > 65535) this.packetIdCounter = 1;
+      return id;
+  }
+
+  async connect(opts) {
+    return new Promise(async (resolve, reject) => {
+        const port = 443;
+        const host = this.options.transport && this.options.transport.host ? this.options.transport.host : 'edge-mqtt.facebook.com';
+        const connectOpts = opts || {};
+        
+        const onConnect = () => {
+             // Setup Ping Timer
+             this._setupPingTimer();
+             
+             try {
+                 const writer = new PacketWriter();
+                 const writeFunc = this.writeMap[PacketType.Connect];
+                 if (writeFunc) {
+                     writeFunc(writer, { 
+                         ...this.options, 
+                         ...connectOpts,
+                         payload: this.connectPayload || connectOpts.payload, 
+                         keepAlive: 60 
+                     });
+                     const packetData = writer.toBuffer();
+                     let remLen = packetData.length;
+                     const fixedHeader = [ (PacketType.Connect << 4) ];
+                     do {
+                         let byte = remLen % 128;
+                         remLen = Math.floor(remLen / 128);
+                         if (remLen > 0) byte = byte | 128;
+                         fixedHeader.push(byte);
+                     } while (remLen > 0);
+                     
+                     this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
+                 } else {
+                     this.emit('error', new Error('No write handler for CONNECT'));
+                 }
+            } catch (e) {
+                this.emit('error', e);
+            }
+        };
+
+        try {
+            if (this.options.transport instanceof SocksTlsTransport && SocksClient) {
+                // SOCKS Proxy Connection
+                const proxyOpts = this.options.transport.proxyOptions;
+                const info = {
+                    proxy: {
+                        host: proxyOpts.host || proxyOpts.ipaddress,
+                        port: parseInt(proxyOpts.port),
+                        type: 5
+                    },
+                    command: 'connect',
+                    destination: {
+                        host: host,
+                        port: port
+                    }
+                };
+                
+                if (proxyOpts.username) {
+                    info.proxy.userId = proxyOpts.username;
+                    info.proxy.password = proxyOpts.password;
+                }
+
+                const { socket: proxySocket } = await SocksClient.createConnection(info);
+                this.socket = tls.connect({
+                    socket: proxySocket,
+                    rejectUnauthorized: false,
+                    servername: host
+                }, onConnect);
+            } else {
+                // Direct TLS Connection
+                this.socket = tls.connect(port, host, { rejectUnauthorized: false }, onConnect);
+            }
+
+            this.socket.on('data', (data) => this._handleData(data));
+            this.socket.on('error', (err) => {
+                this._clearPingTimer();
+                this.emit('error', err);
+            });
+            this.socket.on('close', () => {
+                this._clearPingTimer();
+                this.emit('disconnect');
+            });
+            
+            this.once('connect_success', resolve);
+        } catch (e) {
+            reject(e);
+        }
+    });
+  }
+
+  _setupPingTimer() {
+      this._clearPingTimer();
+      this.pingTimer = setInterval(() => {
+          if (this.socket && !this.socket.destroyed) {
+              this.socket.write(Buffer.from([0xC0, 0x00])); // PINGREQ (12 << 4), Length 0
+          }
+      }, this.keepAliveInterval);
+  }
+
+  _clearPingTimer() {
+      if (this.pingTimer) clearInterval(this.pingTimer);
+      this.pingTimer = null;
+  }
+
+  _handleData(data) {
+      let offset = 0;
+      while(offset < data.length) {
+          const first = data[offset++];
+          const type = first >> 4;
+          let multiplier = 1;
+          let length = 0;
+          let digit;
+          do {
+             if (offset >= data.length) break;
+             digit = data[offset++];
+             length += (digit & 127) * multiplier;
+             multiplier *= 128;
+          } while ((digit & 128) !== 0);
+          
+          if (offset + length > data.length) break; 
+          
+          const payload = data.slice(offset, offset + length);
+          offset += length;
+          
+          if (type === PacketType.ConnAck) {
+             const readFunc = this.readMap[PacketType.ConnAck];
+             if (readFunc) {
+                 const stream = new PacketStream(payload);
+                 const packet = readFunc(stream, length);
+                 if (packet.isSuccess) this.emit('connect_success');
+                 this.emit('connect', { payload: packet.payload });
+             }
+          } else if (type === PacketType.Publish) {
+              try {
+                  const topicLen = payload.readUInt16BE(0);
+                  const topic = payload.slice(2, 2 + topicLen).toString();
+                  const qos = (first & 0x06) >> 1;
+                  let msgPayload;
+                  if (qos > 0) {
+                      // Skip Packet ID (2 bytes)
+                      msgPayload = payload.slice(2 + topicLen + 2);
+                  } else {
+                      msgPayload = payload.slice(2 + topicLen);
+                  }
+                  this.emit('message', { topic, payload: msgPayload, qosLevel: qos });
+              } catch (e) {}
+          } else if (type === PacketType.PubAck) {
+              // Handle PubAck (QoS 1)
+              if (payload.length >= 2) {
+                  const packetId = payload.readUInt16BE(0);
+                  const pending = this.pendingPublishes.get(packetId);
+                  if (pending) {
+                      pending.resolve();
+                      this.pendingPublishes.delete(packetId);
+                  }
+              }
+          } else if (type === PacketType.PingResp) {
+              // Pong received, good
+          }
+      }
+  }
+  
+  async publish(msg) {
+      if (!this.socket) return;
+      return new Promise((resolve, reject) => {
+          const writer = new PacketWriter();
+          writer.writeString(msg.topic);
+          let packetId = 0;
+          if (msg.qosLevel > 0) { 
+              packetId = this.getNextPacketId();
+              writer.writeWord(packetId); 
+          }
+          writer.write(msg.payload);
+          
+          const packetData = writer.toBuffer();
+          const fixedHeader = [ (PacketType.Publish << 4) | (msg.qosLevel ? 2 : 0) ];
+           let remLen = packetData.length;
+           do {
+               let byte = remLen % 128;
+               remLen = Math.floor(remLen / 128);
+               if (remLen > 0) byte = byte | 128;
+               fixedHeader.push(byte);
+           } while (remLen > 0);
+          
+          try {
+              this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
+              if (msg.qosLevel > 0) {
+                  this.pendingPublishes.set(packetId, { resolve, reject });
+                  // Timeout fallback for ack?
+                  setTimeout(() => {
+                      if (this.pendingPublishes.has(packetId)) {
+                           this.pendingPublishes.delete(packetId);
+                           resolve(); // Resolve anyway to not block logic
+                      }
+                  }, 5000);
+              } else {
+                  resolve();
+              }
+          } catch (e) {
+              reject(e);
+          }
+      });
+  }
+
+  async subscribe(topic, qos = 0) {
+      if (!this.socket) return;
+      const writer = new PacketWriter();
+      writer.writeWord(this.getNextPacketId());
+      writer.writeString(topic);
+      writer.writeByte(qos);
+      
+      const packetData = writer.toBuffer();
+      const fixedHeader = [ (PacketType.Subscribe << 4) | 2 ];
+      let remLen = packetData.length;
+       do {
+           let byte = remLen % 128;
+           remLen = Math.floor(remLen / 128);
+           if (remLen > 0) byte = byte | 128;
+           fixedHeader.push(byte);
+       } while (remLen > 0);
+       
+       this.socket.write(Buffer.concat([Buffer.from(fixedHeader), packetData]));
+  }
+  
+  disconnect() {
+      this._clearPingTimer();
+      if (this.socket) this.socket.end();
+  }
+}
+
+class TlsTransport { constructor(opts) { Object.assign(this, opts); } }
+class SocksTlsTransport { constructor(opts) { Object.assign(this, opts); } }
+
+function isConnAck(p) { return true; }
+
+const DefaultPacketReadMap = {};
+const DefaultPacketWriteMap = {};
+
+module.exports = {
+  MqttClient,
+  PacketType,
+  ConnectResponsePacket,
+  IllegalStateError,
+  TlsTransport,
+  SocksTlsTransport,
+  DefaultPacketReadMap,
+  DefaultPacketWriteMap,
+  isConnAck,
+  PacketStream
+};

package/dist/mqttot/mqttot.client.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { MQTToTConnectPacketOptions } from './mqttot.connect.request.packet';
-import { ConnectRequestOptions, DefaultPacketReadResultMap, DefaultPacketWriteOptions, MqttClient, MqttMessage, MqttMessageOutgoing, PacketFlowFunc, PacketType } from 'mqtts';
+import * as mqtts_1 from '../mqtt-shim';
 import { MQTToTConnectResponsePacket } from './mqttot.connect.response.packet';
 import { SocksProxy } from 'socks';
 import { ConnectionOptions } from 'tls';

package/dist/mqttot/mqttot.client.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mqttotConnectFlow = exports.MQTToTClient = void 0;
 const shared_1 = require("../shared");
 const mqttot_connect_request_packet_1 = require("./mqttot.connect.request.packet");
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../mqtt-shim");
 const errors_1 = require("../errors");
 const mqttot_connect_response_packet_1 = require("./mqttot.connect.response.packet");
 class MQTToTClient extends mqtts_1.MqttClient {

package/dist/mqttot/mqttot.connect.request.packet.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { PacketStream, PacketWriteResult } from 'mqtts';
+import * as mqtts_1 from '../mqtt-shim';
 export interface MQTToTConnectPacketOptions {
     keepAlive: number;
     payload: Buffer;

package/dist/mqttot/mqttot.connect.response.packet.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ConnectResponsePacket, PacketStream, ConnectReturnCode } from 'mqtts';
+import * as mqtts_1 from '../mqtt-shim';
 export declare class MQTToTConnectResponsePacket extends ConnectResponsePacket {
     readonly payload: Buffer;
     constructor(ackFlags: number, returnCode: ConnectReturnCode, payload: Buffer);

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConnectResponsePacket = exports.MQTToTConnectResponsePacket = void 0;
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../mqtt-shim");
 class MQTToTConnectResponsePacket extends mqtts_1.ConnectResponsePacket {
     constructor(ackFlags, returnCode, payload) {
         super(ackFlags, returnCode);

package/dist/package.json

@@ -33,7 +33,7 @@
     "eventemitter3": "^5.0.1",
     "form-data": "^4.0.0",
     "lodash": "^4.17.21",
-    "mqtts": "^1.5.0",
+    "mqtt": "^5.10.3",
     "node-persist": "^4.0.4",
     "pako": "^2.1.0",
     "protobufjs": "^7.5.4",

package/dist/realtime/commands/commands.d.ts

@@ -1,6 +1,6 @@
 import { Topic } from '../../topic';
 import { MQTToTClient } from '../../mqttot';
-import { MqttMessageOutgoing } from 'mqtts';
+import * as mqtts_1 from '../../mqtt-shim';
 export declare class Commands {
     private client;
     constructor(client: MQTToTClient);

package/dist/realtime/commands/direct.commands.d.ts

@@ -1,7 +1,7 @@
 import { MQTToTClient } from '../../mqttot';
 import { MessageSyncMessageTypes } from '../messages';
 import { ThriftPacketDescriptor } from '../../thrift';
-import { MqttMessageOutgoing } from 'mqtts';
+import * as mqtts_1 from '../../mqtt-shim';
 interface ItemBaseType {
     threadId: string;
     clientContext?: string;

package/dist/realtime/mixins/message-sync.mixin.js

@@ -4,7 +4,7 @@ exports.MessageSyncMixin = void 0;
 const mixin_1 = require("./mixin");
 const constants_1 = require("../../constants");
 const shared_1 = require("../../shared");
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../../mqtt-shim");
 
 /**
  * MessageSyncMixin - patched for 2026 (robust parsing + safe username fetch + tolerant timestamp handling)

package/dist/realtime/mixins/realtime-sub.mixin.js

@@ -4,7 +4,7 @@ exports.RealtimeSubMixin = void 0;
 const mixin_1 = require("./mixin");
 const constants_1 = require("../../constants");
 const shared_1 = require("../../shared");
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../../mqtt-shim");
 class RealtimeSubMixin extends mixin_1.Mixin {
     apply(client) {
         (0, mixin_1.hook)(client, 'connect', {

package/dist/realtime/realtime.client.js

@@ -5,7 +5,7 @@ const constants_1 = require("../constants");
 const commands_1 = require("./commands");
 const shared_1 = require("../shared");
 const mqttot_1 = require("../mqttot");
-const mqtts_1 = require("mqtts");
+const mqtts_1 = require("../mqtt-shim");
 const errors_1 = require("../errors");
 const eventemitter3_1 = require("eventemitter3");
 const mixins_1 = require("./mixins");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqtt",
-  "version": "1.3.16",
+  "version": "1.3.18",
   "description": "Complete Instagram MQTT protocol with FULL iOS + Android support. 33 device presets (21 iOS + 12 Android). iPhone 16/15/14/13/12, iPad Pro, Samsung, Pixel, Huawei. Real-time DM messaging, view-once media extraction, sub-500ms latency.",
   "main": "dist/index.js",
   "scripts": {
@@ -52,7 +52,7 @@
     "eventemitter3": "^5.0.1",
     "form-data": "^4.0.0",
     "lodash": "^4.17.21",
-    "mqtts": "^1.5.0",
+    "mqtt": "^5.10.3",
     "node-persist": "^4.0.4",
     "pako": "^2.1.0",
     "protobufjs": "^7.5.4",