@eryxenx/insta-chat 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -6,6 +6,36 @@ The format follows [Keep a Changelog](https://keepachangelog.com/) and uses
 
 ## [Unreleased]
 
+## [2.1.2] - 2026-11-06
+
+### Fixed
+
+- **Realtime MQTT no longer flaps.** A dropped broker connection could never be
+  brought back up: `SocketMQTToTTransport.connect()` kept the previous socket's
+  `_closed`/`_error` state, so every `recvPacket()` on a reconnect rejected with
+  the stale `MQTT socket closed` and the client reconnected in a tight loop
+  (`realtime: MQTT transport closed` → `realtime reaction push connected` →
+  `MQTT transport closed`). The transport now resets that state on connect.
+- **Keep-alive matches the ping interval.** The CONNECT advertised a 20 s
+  keep-alive while the PINGREQ timer fired every 30 s, so the broker dropped the
+  socket after ~30 s of apparent silence. The keep-alive (60 s) and ping interval
+  (25 s) now share the `KEEP_ALIVE_SECONDS` / `PING_INTERVAL_MS` constants, with
+  the ping comfortably inside the window.
+- **`realtimeConnect()` returns a live client.** After a drop it handed back the
+  stale, disconnected client, so a caller that "reconnected" was still holding a
+  dead socket. It now reuses the client only while `connected` and otherwise
+  builds a fresh one. Callers should attach handlers to the returned client (see
+  `README`); a reconnect can yield a new instance.
+- **`disconnect()` no longer leaks an unhandled rejection.** The teardown write
+  (`DISCONNECT` packet) is cancelled when the socket closes and its rejection
+  (`write ECANCELED Canceled because of SSL destruction`) was unhandled, which
+  could crash the process on every disconnect. It is now swallowed.
+- **No duplicate ping timers.** `connect()` clears any previous ping timer, so a
+  reconnect does not leave the old one running alongside the new one.
+- `test/realtime.test.js` now awaits its async sections (they previously resolved
+  after the process had already printed its result, so their assertions were
+  never counted) and covers the reset, reconnect, keep-alive and teardown paths.
+
 ## [2.1.0] - 2026-10-14
 
 ### Added

package/DOCS.md

@@ -49,7 +49,7 @@ commands call). Pass `{ native: true }` to get the bare `InstaAPI` instead.
 | `deviceFile` | `./device.json` | Persisted device identity. |
 | `pollInterval` | `15000` | `listen()` poll interval (ms), used when realtime is off. |
 | `minPollIntervalMs` | `15000` | Lowest interval `listen()` will honour (floor, min 2000). |
-| `realtime` | – | `{ enabled, fallback, host, keepAliveMs }` — realtime MQTT push for `listen()`. |
+| `realtime` | – | `{ enabled, fallback, host, keepAliveMs }` — realtime MQTT push for `listen()`. `keepAliveMs` (default 25000) is the PINGREQ interval and must stay below the CONNECT keep-alive (60 s). |
 
 ## `InstaClient` (FCA surface)
 
@@ -176,7 +176,7 @@ into the same raw inbox events the poller produces and normalized identically.
 | Method | Description |
 |--------|-------------|
 | `realtimeClient(options?)` | Build a raw `RealtimeClient` without connecting. |
-| `realtimeConnect(options?)` | Open the MQTT connection. Resolves to the client. |
+| `realtimeConnect(options?)` | Open the MQTT connection. Resolves to the client. Reuses the client only while connected; after a drop it builds a fresh one, so re-attach handlers to whatever it returns. |
 | `realtimeOn(event, handler)` | Subscribe to `message`, `typing`, `seen`, `presence`, `direct`, `receive`, `error`, `disconnected`. |
 | `realtimeSubscribe()` | Subscribe to the Direct message-sync stream (reads the cursor from the inbox query). |
 | `realtimePing()` | Send a keepalive ping. |

package/README.md

@@ -121,7 +121,8 @@ const api = await login(cookie, { realtime: { enabled: true } });
 
 `realtime` is `{ enabled, fallback, host, keepAliveMs }`. With `fallback !== false`
 (the default) a broker that will not connect degrades to the inbox poller, so the
-bot still gets events. See [Listening](#listening).
+bot still gets events. `keepAliveMs` is the PINGREQ interval; it must stay below
+the CONNECT keep-alive (60 s) and defaults to 25 s. See [Listening](#listening).
 
 ### Two layers
 
@@ -262,6 +263,19 @@ await api.realtimeSubscribe();   // reads seq_id/snapshot_at_ms from the inbox q
 api.realtimeDisconnect();
 ```
 
+`realtimeConnect()` reuses the client only while it is connected; after a drop it
+builds a fresh one, so **attach your handlers to the client it returns** and
+re-attach whenever it differs from the last one you saw:
+
+```javascript
+let client = await api.realtimeConnect();
+if (client !== previous) {
+  client.on("direct", onRealtimeDirect);
+  client.on("disconnected", () => reconnectLater());
+  previous = client;
+}
+```
+
 `RealtimeClient` (the raw client) and `RealtimeListener` (the listen() wrapper)
 are exported too, for callers that want to drive the socket themselves.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eryxenx/insta-chat",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": " Unofficial Instagram Chat API for Node.js | Build Instagram DM bots on personal accounts — send messages, media, voice notes, reactions, edit & unsend, listen for incoming chats. No browser at runtime",
   "main": "index.js",
   "types": "index.d.ts",

package/src/api.js

@@ -338,7 +338,17 @@ class InstaAPI {
   }
 
   async realtimeConnect(options = {}) {
-    if (!this._realtime) this._realtime = this.realtimeClient(options);
+    // A dropped client stays on the instance until something replaces it; reuse
+    // it only while it is actually connected, otherwise the caller gets a dead
+    // client back and believes the reconnect succeeded (the watcher's flapping
+    // loop). A new RealtimeClient is cheap: the MQTT/TLS connection is made by
+    // connect().
+    if (!this._realtime || !this._realtime.connected) {
+      if (this._realtime) {
+        try { this._realtime.disconnect(); } catch (_) {}
+      }
+      this._realtime = this.realtimeClient(options);
+    }
     await this._realtime.connect();
     return this._realtime;
   }

package/src/methods/media.js

@@ -78,20 +78,34 @@ class MediaMethods {
   }
 
   async _commitMedia(threadID, attachmentFbid, options = {}) {
-    return this.http.postGraphQL(
-      "IGDirectMediaSendMutation",
-      DOC_ID.MEDIA_SEND,
-      {
-        attachment_fbid: String(attachmentFbid),
-        thread_id: String(threadID),
-        offline_threading_id: this._offlineThreadingId(),
-        reply_to_message_id: options.replyToMessageId || null,
-        forwarded_from_thread_id: null,
-        is_forwarded_from_own_message: null
-      },
-      this._threadReferer(threadID),
-      { throwOnError: true }
-    );
+    // Instagram intermittently answers IGDirectMediaSendMutation with a
+    // transient `field_exception` even though the upload already succeeded; a
+    // short backoff retry (same attachment fbid, fresh offline_threading_id)
+    // commits it. Without this a media send fails once and the caller sees a
+    // hard error while the bytes are already uploaded.
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this.http.postGraphQL(
+          "IGDirectMediaSendMutation",
+          DOC_ID.MEDIA_SEND,
+          {
+            attachment_fbid: String(attachmentFbid),
+            thread_id: String(threadID),
+            offline_threading_id: this._offlineThreadingId(),
+            reply_to_message_id: options.replyToMessageId || null,
+            forwarded_from_thread_id: null,
+            is_forwarded_from_own_message: null
+          },
+          this._threadReferer(threadID),
+          { throwOnError: true }
+        );
+      } catch (error) {
+        const msg = String((error && error.message) || "");
+        const retriable = /field_exception|field exception|temporary failure|internal server error/i.test(msg);
+        if (!retriable || attempt >= 2) throw error;
+        await new Promise((r) => setTimeout(r, 1200 * (attempt + 1)));
+      }
+    }
   }
 
   async _send(threadID, uploadOptions, options) {

package/src/realtime/client.js

@@ -33,12 +33,17 @@ const {
   writeSubscribePacket,
   decodePacket,
   tryDecompressPayload,
-  parseJsonPayload
+  parseJsonPayload,
+  KEEP_ALIVE_SECONDS
 } = require("./mqttot");
 
 const REALTIME_HOST = "edge-mqtt.facebook.com";
 const IG_REALTIME_APP_ID = 567067343352427;
 const REALTIME_SUBSCRIBE_TOPICS = [88, 135, 149, 150, 133, 146];
+// The PINGREQ interval (ms). It must fire well inside the CONNECT keep-alive
+// (KEEP_ALIVE_SECONDS), or the broker tears the socket down between pings — a
+// 20s keep-alive with a 30s ping got the connection dropped every ~30s.
+const PING_INTERVAL_MS = 25000;
 
 // An Android app identity. The broker expects the app's own UA + app version in
 // the CONNECT's appSpecificInfo; a web UA is rejected.
@@ -138,8 +143,14 @@ class RealtimeClient extends EventEmitter {
 
   async connect() {
     if (this.connected) return this;
+    // A previous connection that dropped leaves a closed transport and a live
+    // ping timer behind; clear both so the reconnect is clean and pings do not
+    // accumulate one per attempt.
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    this._pingTimer = null;
+    if (this.transport && typeof this.transport.reset === "function") this.transport.reset();
     await this.transport.connect();
-    await this.transport.send(writeConnectPacket(this.buildConnection()));
+    await this.transport.send(writeConnectPacket(this.buildConnection(), KEEP_ALIVE_SECONDS));
     const packet = decodePacket(await this.transport.recvPacket());
     if (packet.packetType !== "connack" || packet.returnCode !== 0) {
       throw new Error(`Realtime MQTT connect failed (return code ${packet.returnCode})`);
@@ -153,7 +164,9 @@ class RealtimeClient extends EventEmitter {
   }
 
   _startPing() {
-    const keepAliveMs = this.options.keepAliveMs || 30000;
+    // Ping comfortably inside the keep-alive the CONNECT advertised, so the
+    // broker never times the connection out between pings.
+    const keepAliveMs = this.options.keepAliveMs || PING_INTERVAL_MS;
     this._pingTimer = setInterval(() => {
       if (this.connected) this.transport.send(writePingreqPacket()).catch(() => {});
     }, keepAliveMs);
@@ -314,7 +327,12 @@ class RealtimeClient extends EventEmitter {
     this.connected = false;
     if (this._pingTimer) clearInterval(this._pingTimer);
     this._pingTimer = null;
-    try { this.transport.send(writeDisconnectPacket()); } catch (_) {}
+    // send() returns a promise (the socket write); during teardown that write is
+    // cancelled and rejects with ECANCELED, so the rejection must be swallowed
+    // here rather than becoming an unhandled rejection that crashes the process.
+    try {
+      Promise.resolve(this.transport.send(writeDisconnectPacket())).catch(() => {});
+    } catch (_) {}
     this.transport.disconnect();
     return this;
   }
@@ -367,6 +385,8 @@ module.exports = {
   REALTIME_HOST,
   IG_REALTIME_APP_ID,
   REALTIME_SUBSCRIBE_TOPICS,
+  KEEP_ALIVE_SECONDS,
+  PING_INTERVAL_MS,
   TOPICS,
   ANDROID_UA,
   APP_VERSION,

package/src/realtime/mqttot.js

@@ -366,7 +366,12 @@ function tryDecompressPayload(data) {
   }
 }
 
-function writeConnectPacket(connection, keepAlive = 20) {
+// The CONNECT keep-alive in seconds. The client's PINGREQ timer must fire well
+// inside this window (see client.js PING_INTERVAL_MS); the broker drops a client
+// that stays silent for ~1.5x the keep-alive.
+const KEEP_ALIVE_SECONDS = 60;
+
+function writeConnectPacket(connection, keepAlive = KEEP_ALIVE_SECONDS) {
   const payload = compressPayload(connection.toThrift());
   const header = Buffer.concat([
     writeUtf8("MQTToT"),
@@ -495,7 +500,19 @@ class SocketMQTToTTransport {
     this._error = null;
   }
 
+  // Clears the failure/closed state so the transport can be re-connected after a
+  // broker drop. Without this, a reconnect on the same transport rejects every
+  // recvPacket() with the stale "MQTT socket closed" error and can never come
+  // back up — which is what made the realtime client flap.
+  reset() {
+    this._buffer = Buffer.alloc(0);
+    this._waiters = [];
+    this._closed = false;
+    this._error = null;
+  }
+
   connect() {
+    this.reset();
     return new Promise((resolve, reject) => {
       const socket = tls.connect({
         host: this.host,
@@ -603,6 +620,7 @@ module.exports = {
   parseJsonPayload,
   writeThriftObject,
   writeThriftStruct,
+  KEEP_ALIVE_SECONDS,
   readThriftObject: (data, descriptors) => new ThriftReader(data).readStruct(descriptors),
   zigzag,
   unzigzag