@eryxenx/insta-chat 2.0.10 → 2.1.0

package/src/realtime/client.js

@@ -0,0 +1,376 @@
+/*!
+ * insta-chat - Unofficial Instagram Chat API
+ * Copyright (c) 2026 EryXenX (https://github.com/EryXenX)
+ * Licensed under the Apache License, Version 2.0. See LICENSE and NOTICE.
+ * Original author credit must be retained in all copies and derivatives.
+ */
+
+// Instagram's realtime broker (edge-mqtt.facebook.com) speaks MQTToT with
+// cookie_auth: the CONNECT password is "sessionid=<sessionid>" and the session
+// cookie authenticates the connection, so no app login is needed. This client
+// keeps that connection open and turns the broker's Direct message-sync and
+// realtime-sub publishes into plain events.
+//
+// Message-sync (topic 146) is the Direct stream: the broker pushes Relay-style
+// patches ({ path: "/direct_v2/threads/<threadID>", op, value }) as messages
+// arrive, which is what makes listen() push instead of poll. Topics:
+//   88 pubsub · 133 send-response · 135 iris-sub-response
+//   146 message-sync · 149 realtime-sub · 150 region-hint
+
+"use strict";
+
+const { EventEmitter } = require("events");
+const crypto = require("crypto");
+
+const {
+  MQTToTConnection,
+  SocketMQTToTTransport,
+  compressPayload,
+  writeConnectPacket,
+  writeDisconnectPacket,
+  writePingreqPacket,
+  writePublishPacket,
+  writeSubscribePacket,
+  decodePacket,
+  tryDecompressPayload,
+  parseJsonPayload
+} = 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];
+
+// An Android app identity. The broker expects the app's own UA + app version in
+// the CONNECT's appSpecificInfo; a web UA is rejected.
+const ANDROID_UA =
+  "Instagram 449.0.0.52.84 Android (34/14; 480dpi; 1344x2992; Google/google; Pixel 8 Pro; husky; husky; en_US; 1079242191)";
+const APP_VERSION = "449.0.0.52.84";
+const CAPABILITIES = "3brTv10=";
+const LOCALE = "en_US";
+
+const TOPICS = {
+  PUBSUB: "88",
+  SEND_MESSAGE: "132",
+  SEND_MESSAGE_RESPONSE: "133",
+  IRIS_SUB: "134",
+  IRIS_SUB_RESPONSE: "135",
+  MESSAGE_SYNC: "146",
+  REALTIME_SUB: "149",
+  REGION_HINT: "150"
+};
+
+class RealtimeClient extends EventEmitter {
+  constructor(context, options = {}) {
+    super();
+    this.context = context || {};
+    this.options = options;
+    this.host = options.host || REALTIME_HOST;
+    this.transport = options.transport || new SocketMQTToTTransport(this.host, 443, { timeout: options.socketTimeout || 30000 });
+    this.connected = false;
+    this._packetId = 0;
+    this._loop = null;
+    this._pingTimer = null;
+    this._stopRequested = false;
+  }
+
+  _deviceId() {
+    const id = this.context.deviceId || this.context.phoneId || this.context.uuid || "";
+    if (!id) throw new Error("realtime: deviceId is required");
+    return String(id);
+  }
+
+  _sessionId() {
+    const raw = this.context.sessionid;
+    if (!raw) throw new Error("realtime: sessionid is required");
+    // The browser stores the sessionid URL-encoded (32715034217%3A...); the
+    // broker wants the decoded value.
+    try {
+      return decodeURIComponent(String(raw));
+    } catch (_) {
+      return String(raw);
+    }
+  }
+
+  buildConnection() {
+    const deviceId = this._deviceId();
+    const userAgent = this.context.userAgent || ANDROID_UA;
+    const appVersion = this.context.appVersion || APP_VERSION;
+    return new MQTToTConnection({
+      clientIdentifier: deviceId.slice(0, 20),
+      clientInfo: {
+        userId: this.context.userId || 0,
+        userAgent,
+        clientCapabilities: 183,
+        endpointCapabilities: 0,
+        publishFormat: 1,
+        noAutomaticForeground: false,
+        makeUserAvailableInForeground: true,
+        deviceId,
+        isInitiallyForeground: true,
+        networkType: 1,
+        networkSubtype: 0,
+        clientMqttSessionId: Date.now() & 0xffffffff,
+        subscribeTopics: REALTIME_SUBSCRIBE_TOPICS,
+        clientType: "cookie_auth",
+        appId: IG_REALTIME_APP_ID,
+        deviceSecret: "",
+        clientStack: 3
+      },
+      password: `sessionid=${this._sessionId()}`,
+      appSpecificInfo: {
+        app_version: appVersion,
+        "X-IG-Capabilities": CAPABILITIES,
+        everclear_subscriptions: JSON.stringify({
+          inapp_notification_subscribe_comment: "17899377895239777",
+          inapp_notification_subscribe_comment_mention_and_reply: "17899377895239777",
+          video_call_participant_state_delivery: "17977239895057311",
+          presence_subscribe: "17846944882223835"
+        }),
+        "User-Agent": userAgent,
+        "Accept-Language": LOCALE.replace("_", "-"),
+        platform: "android",
+        ig_mqtt_route: "django",
+        pubsub_msg_type_blacklist: "direct, typing_type",
+        auth_cache_enabled: "0"
+      }
+    });
+  }
+
+  async connect() {
+    if (this.connected) return this;
+    await this.transport.connect();
+    await this.transport.send(writeConnectPacket(this.buildConnection()));
+    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})`);
+    }
+    this.connected = true;
+    this._stopRequested = false;
+    this.emit("connected", { host: this.host });
+    this._startPing();
+    this._startLoop();
+    return this;
+  }
+
+  _startPing() {
+    const keepAliveMs = this.options.keepAliveMs || 30000;
+    this._pingTimer = setInterval(() => {
+      if (this.connected) this.transport.send(writePingreqPacket()).catch(() => {});
+    }, keepAliveMs);
+    if (this._pingTimer.unref) this._pingTimer.unref();
+  }
+
+  _startLoop() {
+    this._loop = (async () => {
+      while (this.connected) {
+        let packet;
+        try {
+          packet = decodePacket(await this.transport.recvPacket());
+        } catch (err) {
+          if (!this._stopRequested) this.emit("error", err);
+          break;
+        }
+        try {
+          this._handlePacket(packet);
+        } catch (err) {
+          this.emit("error", err);
+        }
+      }
+      this.connected = false;
+      this.emit("disconnected", {});
+    })();
+  }
+
+  _handlePacket(packet) {
+    if (packet.packetType !== "publish" || packet.topic == null) return;
+    this.dispatch(packet.topic, packet.payload);
+    if (packet.qos === 1 && packet.packetId != null) {
+      this.transport.send(Buffer.concat([Buffer.from([0x40, 0x02]), uint16(packet.packetId)])).catch(() => {});
+    }
+  }
+
+  dispatch(topic, payload) {
+    const body = tryDecompressPayload(payload);
+    let parsed;
+    if (
+      topic === TOPICS.SEND_MESSAGE_RESPONSE ||
+      topic === TOPICS.IRIS_SUB_RESPONSE ||
+      topic === TOPICS.REALTIME_SUB ||
+      topic === TOPICS.MESSAGE_SYNC
+    ) {
+      parsed = safeJson(body);
+    } else {
+      parsed = safeJson(payload);
+    }
+    this.emit("receive", { topic, payload: parsed });
+    if (topic === TOPICS.SEND_MESSAGE_RESPONSE) this.emit("send_response", parsed);
+    if (topic === TOPICS.IRIS_SUB_RESPONSE) this.emit("iris_sub_response", parsed);
+    if (topic === TOPICS.MESSAGE_SYNC) this._dispatchMessageSync(parsed);
+    if (topic === TOPICS.REALTIME_SUB) this._dispatchRealtimeSub(parsed);
+    return parsed;
+  }
+
+  // message-sync payloads are a list of { data: [ { path, op, value } ] } patches.
+  _dispatchMessageSync(payload) {
+    if (!Array.isArray(payload)) return this.emit("iris", payload);
+    for (const item of payload) {
+      if (!item || typeof item !== "object" || !Array.isArray(item.data)) {
+        this.emit("iris", item);
+        continue;
+      }
+      const meta = {};
+      for (const [k, v] of Object.entries(item)) if (k !== "data") meta[k] = v;
+      for (const patch of item.data) {
+        if (!patch || typeof patch !== "object") continue;
+        const path = patch.path;
+        if (!path || patch.value == null) {
+          this.emit("iris", { ...meta, ...patch });
+          continue;
+        }
+        const value = parseMaybeJson(patch.value);
+        const threadID = threadIdFromPath(path);
+        const wrapped = {
+          ...meta,
+          message: {
+            path,
+            op: patch.op,
+            thread_id: threadID,
+            ...(value && typeof value === "object" ? value : { value })
+          }
+        };
+        this.emit(path.startsWith("/direct_v2/threads/") ? "message" : "thread_update", wrapped);
+        this._dispatchDirectEvent({ path, op: patch.op, value, threadID });
+      }
+    }
+  }
+
+  _dispatchRealtimeSub(payload) {
+    this.emit("realtime_sub", payload);
+    if (!payload || typeof payload !== "object") return;
+    let message = payload.message;
+    if (typeof message === "string") message = safeJson(Buffer.from(message));
+    if (!message || typeof message !== "object") return;
+    if (message.topic !== "direct") return;
+    let direct = message.json || message.payload;
+    if (typeof direct === "string") direct = safeJson(Buffer.from(direct));
+    this._dispatchDirectPayload(direct);
+  }
+
+  _dispatchDirectPayload(payload) {
+    if (!payload || typeof payload !== "object") return this._dispatchDirectEvent({ value: payload });
+    if (!Array.isArray(payload.data)) return this._dispatchDirectEvent(payload);
+    const meta = {};
+    for (const [k, v] of Object.entries(payload)) if (k !== "data") meta[k] = v;
+    for (const item of payload.data) {
+      this._dispatchDirectEvent(item && typeof item === "object" ? { ...meta, ...item } : { ...meta, value: item });
+    }
+  }
+
+  _dispatchDirectEvent(event) {
+    const out = { ...event };
+    let value = out.value;
+    if (typeof value === "string") value = safeJson(Buffer.from(value));
+    out.value = value;
+    if (out.path && !out.threadID) out.threadID = threadIdFromPath(out.path);
+    this.emit("direct", out);
+    const kind = classifyDirectEvent(out);
+    if (kind) this.emit(kind, out);
+  }
+
+  publishBytes(topic, payload) {
+    this._packetId += 1;
+    const packet = writePublishPacket(topic, payload, 1, this._packetId);
+    return this.transport.send(packet);
+  }
+
+  publishJson(topic, data) {
+    return this.publishBytes(topic, compressPayload(Buffer.from(JSON.stringify(data))));
+  }
+
+  irisSubscribe(seqId, snapshotAtMs, appVersion) {
+    return this.publishJson(TOPICS.IRIS_SUB, {
+      seq_id: seqId,
+      snapshot_at_ms: snapshotAtMs,
+      snapshot_app_version: appVersion || this.context.appVersion || APP_VERSION
+    });
+  }
+
+  graphQlSubscribe(subscriptions) {
+    return this.publishJson(TOPICS.REALTIME_SUB, { sub: [].concat(subscriptions) });
+  }
+
+  skywalkerSubscribe(subscriptions) {
+    return this.publishJson(TOPICS.PUBSUB, { sub: [].concat(subscriptions) });
+  }
+
+  async ping() {
+    if (!this.connected) throw new Error("Realtime client is not connected");
+    await this.transport.send(writePingreqPacket());
+    return true;
+  }
+
+  disconnect() {
+    this._stopRequested = true;
+    this.connected = false;
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    this._pingTimer = null;
+    try { this.transport.send(writeDisconnectPacket()); } catch (_) {}
+    this.transport.disconnect();
+    return this;
+  }
+}
+
+// Extracts the thread id from a message-sync path such as
+// "/direct_v2/threads/1234/items/..." or "/direct_v2/inbox/threads/1234".
+function threadIdFromPath(path) {
+  const p = String(path || "");
+  let m = p.match(/^\/direct_v2\/threads\/([^/]+)/);
+  if (m) return m[1];
+  m = p.match(/^\/direct_v2\/inbox\/threads\/([^/]+)/);
+  if (m) return m[1];
+  return null;
+}
+
+function classifyDirectEvent(event) {
+  const path = String(event.path || "").toLowerCase();
+  const action = String(event.action || "").toLowerCase();
+  const value = event.value;
+  const valueText = value && typeof value === "object" ? JSON.stringify(value).toLowerCase() : String(value || "").toLowerCase();
+  if (valueText.includes("activity_status") || path.includes("activity_indicator") || path.includes("typing")) return "typing";
+  if (path.includes("presence") || valueText.includes("is_active") || valueText.includes("last_active")) return "presence";
+  if (action === "mark_seen" || path.includes("/seen") || valueText.includes("seen")) return "seen";
+  return null;
+}
+
+function parseMaybeJson(value) {
+  if (typeof value !== "string") return value;
+  const parsed = safeJson(Buffer.from(value));
+  return parsed === undefined ? value : parsed;
+}
+
+function safeJson(buffer) {
+  try {
+    return JSON.parse(buffer.toString("utf8"));
+  } catch (_) {
+    return buffer;
+  }
+}
+
+function uint16(value) {
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16BE(value & 0xffff, 0);
+  return buf;
+}
+
+module.exports = {
+  RealtimeClient,
+  REALTIME_HOST,
+  IG_REALTIME_APP_ID,
+  REALTIME_SUBSCRIBE_TOPICS,
+  TOPICS,
+  ANDROID_UA,
+  APP_VERSION,
+  threadIdFromPath,
+  classifyDirectEvent,
+  newClientContext: () => crypto.randomUUID()
+};

package/src/realtime/listener.js

@@ -0,0 +1,86 @@
+/*!
+ * insta-chat - Unofficial Instagram Chat API
+ * Copyright (c) 2026 EryXenX (https://github.com/EryXenX)
+ * Licensed under the Apache License, Version 2.0. See LICENSE and NOTICE.
+ * Original author credit must be retained in all copies and derivatives.
+ */
+
+// The realtime listener: it opens the MQTT connection, subscribes to the Direct
+// message-sync stream and feeds decoded messages to a callback as they arrive,
+// instead of the inbox poller's interval. It is push, so a bot replies as soon
+// as Instagram delivers the message.
+//
+// Real-time is best-effort. Instagram can drop the socket, refuse the iris
+// subscription, or the process can run on a host that blocks the broker, so the
+// listener reports failure instead of pretending to be connected; listen() keeps
+// the poller as its fallback.
+
+"use strict";
+
+const { RealtimeClient } = require("./client");
+const { rawEventFromMessageSync } = require("./bridge");
+
+class RealtimeListener {
+  constructor(context, options = {}) {
+    this.context = context || {};
+    this.options = options;
+    this.connected = false;
+    this._client = null;
+    this._callback = null;
+    this._stopped = false;
+    this._subscribed = false;
+  }
+
+  _emitError(err) {
+    if (typeof this.options.onError === "function") this.options.onError(err);
+    else if (this._callback) this._callback(err, null);
+  }
+
+  _handleMessageSync(event) {
+    if (this._stopped || !this._callback) return;
+    const raw = rawEventFromMessageSync(event, this.context.userId);
+    if (raw) this._callback(null, raw);
+  }
+
+  _resolveCursor() {
+    const opts = this.options;
+    if (opts.seqId != null && opts.snapshotAtMs != null) {
+      return { seqId: opts.seqId, snapshotAtMs: opts.snapshotAtMs };
+    }
+    if (typeof opts.getRealtimeState === "function") {
+      return Promise.resolve(opts.getRealtimeState()).then((state) => state || null);
+    }
+    return Promise.resolve(null);
+  }
+
+  async start(callback) {
+    this._callback = callback;
+    this._client = new RealtimeClient(this.context, this.options);
+    this._client.on("message", (event) => this._handleMessageSync(event));
+    this._client.on("error", (err) => this._emitError(err));
+    this._client.on("disconnected", () => {
+      this.connected = false;
+      if (!this._stopped) this._emitError(new Error("Realtime MQTT connection closed"));
+    });
+
+    await this._client.connect();
+    this.connected = true;
+
+    const cursor = await this._resolveCursor();
+    if (cursor && cursor.seqId != null && cursor.snapshotAtMs != null) {
+      await this._client.irisSubscribe(Number(cursor.seqId) || 0, Number(cursor.snapshotAtMs));
+      this._subscribed = true;
+    } else if (typeof this.options.onReady === "function") {
+      this.options.onReady(this);
+    }
+    return this;
+  }
+
+  stop() {
+    this._stopped = true;
+    this.connected = false;
+    if (this._client) this._client.disconnect();
+  }
+}
+
+module.exports = { RealtimeListener };