agent-messenger 2.27.2 → 2.28.0

package/src/platforms/instagram/mqtt/connection.ts

@@ -0,0 +1,72 @@
+import { deflateSync } from 'node:zlib'
+
+import type { InstagramSessionState } from '../types'
+import { ThriftCompactWriter } from './thrift'
+
+const IG_APP_ID = 567067343352427n
+const IG_VERSION = '312.1.0.34.111'
+const CLIENT_CAPABILITIES = 183n
+const PUBLISH_FORMAT = 1
+const NETWORK_TYPE_WIFI = 1
+const CLIENT_STACK = 3
+const CLIENT_IDENTIFIER_MAX_LENGTH = 20
+const SESSION_ID_MASK = 0xffffffffn
+
+const CONNECT_SUBSCRIBE_TOPIC_IDS = [88, 135, 149, 150, 133, 146]
+
+export function extractSessionId(session: InstagramSessionState): string {
+  const authorization = session.authorization ?? ''
+  const igTokenMatch = authorization.match(/^Bearer IGT:2:(.+)$/)
+  if (igTokenMatch) {
+    try {
+      const decoded = JSON.parse(Buffer.from(igTokenMatch[1]!, 'base64').toString('utf8')) as { sessionid?: string }
+      if (decoded.sessionid) return decoded.sessionid
+    } catch {
+      // Malformed/stale token: fall through to the cookie-based sessionid below.
+    }
+  }
+
+  const cookieMatch = session.cookies.match(/sessionid=([^;]+)/)
+  if (cookieMatch) return cookieMatch[1]!
+
+  throw new Error('No sessionid found in Instagram session (checked authorization token and cookies)')
+}
+
+export function buildConnectPayload(session: InstagramSessionState): Buffer {
+  const sessionId = extractSessionId(session)
+  const userId = BigInt(session.user_id ?? '0')
+  const deviceId = session.device.phone_id
+  const userAgent = `Instagram ${IG_VERSION} Android (${session.device.device_string})`
+
+  const thrift = new ThriftCompactWriter()
+    .binary(1, deviceId.substring(0, CLIENT_IDENTIFIER_MAX_LENGTH))
+    .structStart(4)
+    .i64(1, userId)
+    .binary(2, userAgent)
+    .i64(3, CLIENT_CAPABILITIES)
+    .i64(4, 0)
+    .i32(5, PUBLISH_FORMAT)
+    .bool(6, false)
+    .bool(7, true)
+    .binary(8, deviceId)
+    .bool(9, true)
+    .i32(10, NETWORK_TYPE_WIFI)
+    .i32(11, 0)
+    .i64(12, BigInt(Date.now()) & SESSION_ID_MASK)
+    .listOfI32(14, CONNECT_SUBSCRIBE_TOPIC_IDS)
+    .binary(15, 'cookie_auth')
+    .i64(16, IG_APP_ID)
+    .binary(20, '')
+    .byte(21, CLIENT_STACK)
+    .structEnd()
+    .binary(5, `sessionid=${sessionId}`)
+    .mapBinaryBinary(10, {
+      platform: 'android',
+      ig_mqtt_route: 'django',
+      pubsub_msg_type_blacklist: 'direct, typing_type',
+      auth_cache_enabled: '0',
+    })
+    .finish()
+
+  return deflateSync(thrift, { level: 9 })
+}

package/src/platforms/instagram/mqtt/thrift.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'bun:test'
+
+import { ThriftCompactWriter } from '@/platforms/instagram/mqtt/thrift'
+
+describe('ThriftCompactWriter', () => {
+  it('encodes a true bool as a packed field header with a trailing stop byte', () => {
+    // field id 1 (delta 1) << 4 | TYPE_TRUE(0x01) = 0x11, then struct stop 0x00
+    const out = new ThriftCompactWriter().bool(1, true).finish()
+    expect([...out]).toEqual([0x11, 0x00])
+  })
+
+  it('encodes a false bool with the false type code', () => {
+    // field id 1 (delta 1) << 4 | TYPE_FALSE(0x02) = 0x12
+    const out = new ThriftCompactWriter().bool(1, false).finish()
+    expect([...out]).toEqual([0x12, 0x00])
+  })
+
+  it('encodes i32 using zigzag varint', () => {
+    // field 1 i32(0x05) = 0x15, zigzag(1) = 2
+    const out = new ThriftCompactWriter().i32(1, 1).finish()
+    expect([...out]).toEqual([0x15, 0x02, 0x00])
+  })
+
+  it('encodes negative i32 via zigzag', () => {
+    // zigzag(-1) = 1
+    const out = new ThriftCompactWriter().i32(1, -1).finish()
+    expect([...out]).toEqual([0x15, 0x01, 0x00])
+  })
+
+  it('encodes a large positive i32 as an unsigned <=5-byte varint', () => {
+    // 0x40000000: zigzag(1073741824) = 2147483648 = 0x80000000 -> varint 80 80 80 80 08
+    const out = new ThriftCompactWriter().i32(1, 0x40000000).finish()
+    expect([...out]).toEqual([0x15, 0x80, 0x80, 0x80, 0x80, 0x08, 0x00])
+  })
+
+  it('encodes INT32_MIN without overflowing into a 64-bit varint', () => {
+    // zigzag(-2147483648) = 4294967295 = 0xFFFFFFFF -> varint ff ff ff ff 0f (5 bytes, not 9)
+    const out = new ThriftCompactWriter().i32(1, -2147483648).finish()
+    expect([...out]).toEqual([0x15, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00])
+  })
+
+  it('encodes binary as length-prefixed utf8', () => {
+    // field 1 binary(0x08) = 0x18, length 2, "hi"
+    const out = new ThriftCompactWriter().binary(1, 'hi').finish()
+    expect([...out]).toEqual([0x18, 0x02, 0x68, 0x69, 0x00])
+  })
+
+  it('packs small field-id deltas across multiple fields', () => {
+    // field 1 binary = 0x18, then field 3 binary uses delta 2 = 0x28
+    const out = new ThriftCompactWriter().binary(1, 'a').binary(3, 'b').finish()
+    expect([...out]).toEqual([0x18, 0x01, 0x61, 0x28, 0x01, 0x62, 0x00])
+  })
+
+  it('falls back to explicit zigzag id when delta exceeds 15', () => {
+    // field 20 binary: delta 20 > 15, so type byte 0x08 then zigzag(20)=40=0x28
+    const out = new ThriftCompactWriter().binary(20, 'x').finish()
+    expect([...out]).toEqual([0x08, 0x28, 0x01, 0x78, 0x00])
+  })
+
+  it('encodes a short i32 list with size packed into the header nibble', () => {
+    // field 1 list = 0x19, list header size 2 << 4 | i32(0x05) = 0x25, zigzag(88)=176=0xb0 0x01, zigzag(146)=292=0xa4 0x02
+    const out = new ThriftCompactWriter().listOfI32(1, [88, 146]).finish()
+    expect([...out]).toEqual([0x19, 0x25, 0xb0, 0x01, 0xa4, 0x02, 0x00])
+  })
+
+  it('encodes an empty map as a single zero byte', () => {
+    // field 1 map = 0x1b, empty map size 0x00
+    const out = new ThriftCompactWriter().mapBinaryBinary(1, {}).finish()
+    expect([...out]).toEqual([0x1b, 0x00, 0x00])
+  })
+
+  it('encodes a binary->binary map with the key/value type byte', () => {
+    // field 1 map = 0x1b, size 1, types (binary<<4|binary)=0x88, key "k", value "v"
+    const out = new ThriftCompactWriter().mapBinaryBinary(1, { k: 'v' }).finish()
+    expect([...out]).toEqual([0x1b, 0x01, 0x88, 0x01, 0x6b, 0x01, 0x76, 0x00])
+  })
+
+  it('resets field-id delta tracking inside nested structs', () => {
+    // field 4 struct = 0x4c, inner field 1 binary = 0x18 "a", inner stop 0x00, outer stop 0x00
+    const out = new ThriftCompactWriter().structStart(4).binary(1, 'a').structEnd().finish()
+    expect([...out]).toEqual([0x4c, 0x18, 0x01, 0x61, 0x00, 0x00])
+  })
+
+  it('encodes i64 values larger than 32 bits', () => {
+    // field 16 i64: delta 16 > 15 -> type 0x06, zigzag id(16)=32=0x20, then zigzag64(567067343352427)
+    const out = new ThriftCompactWriter().i64(16, 567067343352427n).finish()
+    expect(out[0]).toBe(0x06)
+    expect(out[1]).toBe(0x20)
+    expect(out[out.length - 1]).toBe(0x00)
+  })
+})

package/src/platforms/instagram/mqtt/thrift.ts

@@ -0,0 +1,159 @@
+const TYPE_TRUE = 0x01
+const TYPE_FALSE = 0x02
+const TYPE_BYTE = 0x03
+const TYPE_I16 = 0x04
+const TYPE_I32 = 0x05
+const TYPE_I64 = 0x06
+const TYPE_BINARY = 0x08
+const TYPE_LIST = 0x09
+const TYPE_MAP = 0x0b
+const TYPE_STRUCT = 0x0c
+
+const VARINT_CONTINUE = 0x80
+const VARINT_MASK = 0x7f
+const U64_MASK = 0xffffffffffffffffn
+
+export class ThriftCompactWriter {
+  private bytes: number[] = []
+  private parentFieldStack: number[] = []
+  private lastFieldId = 0
+
+  bool(id: number, value: boolean): this {
+    this.writeFieldHeader(value ? TYPE_TRUE : TYPE_FALSE, id)
+    return this
+  }
+
+  byte(id: number, value: number): this {
+    this.writeFieldHeader(TYPE_BYTE, id)
+    this.bytes.push(value & 0xff)
+    return this
+  }
+
+  i16(id: number, value: number): this {
+    this.writeFieldHeader(TYPE_I16, id)
+    this.writeVarint(zigzag32(value))
+    return this
+  }
+
+  i32(id: number, value: number): this {
+    this.writeFieldHeader(TYPE_I32, id)
+    this.writeVarint(zigzag32(value))
+    return this
+  }
+
+  i64(id: number, value: number | bigint): this {
+    this.writeFieldHeader(TYPE_I64, id)
+    this.writeVarint(zigzag64(BigInt(value)))
+    return this
+  }
+
+  binary(id: number, value: string | Buffer): this {
+    this.writeFieldHeader(TYPE_BINARY, id)
+    this.writeBinaryValue(value)
+    return this
+  }
+
+  listOfI32(id: number, values: number[]): this {
+    this.writeFieldHeader(TYPE_LIST, id)
+    this.writeListHeader(TYPE_I32, values.length)
+    for (const value of values) this.writeVarint(zigzag32(value))
+    return this
+  }
+
+  listOfBinary(id: number, values: string[]): this {
+    this.writeFieldHeader(TYPE_LIST, id)
+    this.writeListHeader(TYPE_BINARY, values.length)
+    for (const value of values) this.writeBinaryValue(value)
+    return this
+  }
+
+  mapBinaryBinary(id: number, entries: Record<string, string>): this {
+    this.writeFieldHeader(TYPE_MAP, id)
+    const keys = Object.keys(entries)
+
+    // Compact protocol encodes an empty map as a single zero byte (size only).
+    if (keys.length === 0) {
+      this.bytes.push(0)
+      return this
+    }
+
+    this.writeVarint(keys.length)
+    this.bytes.push((TYPE_BINARY << 4) | TYPE_BINARY)
+    for (const key of keys) {
+      this.writeBinaryValue(key)
+      this.writeBinaryValue(entries[key]!)
+    }
+    return this
+  }
+
+  structStart(id: number): this {
+    this.writeFieldHeader(TYPE_STRUCT, id)
+    this.parentFieldStack.push(this.lastFieldId)
+    this.lastFieldId = 0
+    return this
+  }
+
+  structEnd(): this {
+    this.bytes.push(0)
+    this.lastFieldId = this.parentFieldStack.pop() ?? 0
+    return this
+  }
+
+  finish(): Buffer {
+    this.bytes.push(0)
+    return Buffer.from(this.bytes)
+  }
+
+  // Compact protocol packs a small field-id delta and the type into one byte
+  // (delta << 4 | type); deltas outside 1..15 fall back to a zigzag varint id.
+  private writeFieldHeader(type: number, id: number): void {
+    const delta = id - this.lastFieldId
+    if (delta > 0 && delta <= 15) {
+      this.bytes.push((delta << 4) | type)
+    } else {
+      this.bytes.push(type)
+      this.writeVarint(zigzag32(id))
+    }
+    this.lastFieldId = id
+  }
+
+  // Lists with fewer than 15 elements pack size into the header nibble;
+  // larger lists set the nibble to 0xf and append the size as a varint.
+  private writeListHeader(elementType: number, size: number): void {
+    if (size < 15) {
+      this.bytes.push((size << 4) | elementType)
+    } else {
+      this.bytes.push(0xf0 | elementType)
+      this.writeVarint(size)
+    }
+  }
+
+  private writeBinaryValue(value: string | Buffer): void {
+    const buf = Buffer.isBuffer(value) ? value : Buffer.from(value, 'utf8')
+    this.writeVarint(buf.length)
+    for (const b of buf) this.bytes.push(b)
+  }
+
+  private writeVarint(value: number | bigint): void {
+    let remaining = BigInt(value) & U64_MASK
+    while (true) {
+      const chunk = Number(remaining & BigInt(VARINT_MASK))
+      remaining >>= 7n
+      if (remaining === 0n) {
+        this.bytes.push(chunk)
+        return
+      }
+      this.bytes.push(chunk | VARINT_CONTINUE)
+    }
+  }
+}
+
+function zigzag32(value: number): number {
+  // `>>> 0` coerces the signed int32 bitwise result to an unsigned 32-bit value,
+  // so large positives and INT32_MIN encode as a <=5-byte varint, not a 64-bit one.
+  return ((value << 1) ^ (value >> 31)) >>> 0
+}
+
+function zigzag64(value: bigint): bigint {
+  return BigInt.asUintN(64, value << 1n) ^ (value >> 63n)
+}

package/src/platforms/instagram/mqtt/transport.ts

@@ -0,0 +1,285 @@
+import { EventEmitter } from 'node:events'
+import tls from 'node:tls'
+
+const MQTTOT_HOST = 'edge-mqtt.facebook.com'
+const MQTTOT_PORT = 443
+const PROTOCOL_NAME = 'MQTToT'
+const PROTOCOL_LEVEL = 3
+
+// CONNECT flags 0xC2 = username present + clean session; the "password" travels
+// inside the Thrift payload rather than the standard MQTT password field.
+const CONNECT_FLAGS = 0xc2
+const KEEPALIVE_SECONDS = 60
+const CONNACK_TIMEOUT_MS = 15_000
+
+const PacketType = {
+  Connect: 1,
+  ConnAck: 2,
+  Publish: 3,
+  PubAck: 4,
+  Subscribe: 8,
+  PingReq: 12,
+  PingResp: 13,
+  Disconnect: 14,
+} as const
+
+export interface MqttPublish {
+  topic: string
+  payload: Buffer
+}
+
+export interface MqttTransportEventMap {
+  connect: []
+  publish: [MqttPublish]
+  error: [Error]
+  close: []
+}
+
+type EventKey = keyof MqttTransportEventMap
+
+export class MqttTransport {
+  private socket: tls.TLSSocket | null = null
+  private emitter = new EventEmitter()
+  private buffer = Buffer.alloc(0)
+  private nextPacketId = 1
+  private pingTimer: ReturnType<typeof setInterval> | null = null
+  private connackTimer: ReturnType<typeof setTimeout> | null = null
+  private connackTimeoutMs: number
+
+  constructor(options: { connackTimeoutMs?: number } = {}) {
+    this.connackTimeoutMs = options.connackTimeoutMs ?? CONNACK_TIMEOUT_MS
+  }
+
+  connect(connectPayload: Buffer): void {
+    const socket = tls.connect({ host: MQTTOT_HOST, port: MQTTOT_PORT, servername: MQTTOT_HOST }, () => {
+      socket.write(this.buildConnectPacket(connectPayload))
+    })
+    this.socket = socket
+
+    // Guard against a peer that accepts TLS but never sends CONNACK, which would
+    // otherwise leave a hybrid caller waiting forever instead of failing over.
+    this.connackTimer = setTimeout(() => {
+      this.connackTimer = null
+      this.emitter.emit('error', new Error('MQTToT CONNACK timed out'))
+      socket.destroy()
+    }, this.connackTimeoutMs)
+
+    socket.on('data', (chunk: Buffer) => this.onData(chunk))
+    socket.on('error', (err: Error) => this.emitter.emit('error', err))
+    socket.on('close', () => {
+      this.clearConnackTimer()
+      this.stopPing()
+      this.emitter.emit('close')
+    })
+  }
+
+  publish(topic: string, payload: Buffer, qos: 0 | 1 = 1): void {
+    if (!this.socket) throw new Error('MQTT transport not connected')
+    this.socket.write(this.buildPublishPacket(topic, payload, qos))
+  }
+
+  subscribe(topics: string[]): void {
+    if (!this.socket) throw new Error('MQTT transport not connected')
+    this.socket.write(this.buildSubscribePacket(topics))
+  }
+
+  disconnect(): void {
+    this.clearConnackTimer()
+    this.stopPing()
+    if (this.socket) {
+      try {
+        this.socket.write(Buffer.from([PacketType.Disconnect << 4, 0]))
+      } catch {
+        // socket may already be torn down; closing below is sufficient
+      }
+      this.socket.destroy()
+      this.socket = null
+    }
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: MqttTransportEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  private onData(chunk: Buffer): void {
+    this.buffer = Buffer.concat([this.buffer, chunk])
+    this.drainPackets()
+  }
+
+  private drainPackets(): void {
+    while (this.buffer.length >= 2) {
+      const decoded = decodeRemainingLength(this.buffer, 1)
+      if (!decoded) return
+
+      const { length: remainingLength, bytesUsed } = decoded
+      const totalLength = 1 + bytesUsed + remainingLength
+      if (this.buffer.length < totalLength) return
+
+      const packet = this.buffer.subarray(0, totalLength)
+      this.buffer = this.buffer.subarray(totalLength)
+      this.handlePacket(packet, 1 + bytesUsed)
+    }
+  }
+
+  private handlePacket(packet: Buffer, bodyStart: number): void {
+    const type = (packet[0]! >> 4) & 0x0f
+
+    switch (type) {
+      case PacketType.ConnAck: {
+        this.clearConnackTimer()
+        const returnCode = packet[bodyStart + 1]
+        if (returnCode === 0) {
+          this.startPing()
+          this.emitter.emit('connect')
+        } else {
+          this.emitter.emit('error', new Error(`MQTToT CONNACK refused with return code ${returnCode}`))
+        }
+        break
+      }
+      case PacketType.Publish:
+        this.handlePublish(packet, bodyStart)
+        break
+      case PacketType.PingResp:
+      case PacketType.PubAck:
+      case PacketType.Subscribe + 1:
+        break
+    }
+  }
+
+  private handlePublish(packet: Buffer, bodyStart: number): void {
+    const qos = (packet[0]! >> 1) & 0x03
+
+    // A truncated/malformed frame must not throw out of the data handler, or it
+    // would crash the process instead of letting the listener fail over.
+    if (bodyStart + 2 > packet.length) return
+    const topicLength = packet.readUInt16BE(bodyStart)
+    let offset = bodyStart + 2
+    if (offset + topicLength > packet.length) return
+    const topic = packet.toString('utf8', offset, offset + topicLength)
+    offset += topicLength
+
+    let packetId: number | null = null
+    if (qos > 0) {
+      if (offset + 2 > packet.length) return
+      packetId = packet.readUInt16BE(offset)
+      offset += 2
+    }
+
+    const payload = packet.subarray(offset)
+    this.emitter.emit('publish', { topic, payload })
+
+    if (qos === 1 && packetId !== null) {
+      this.sendPubAck(packetId)
+    }
+  }
+
+  private sendPubAck(packetId: number): void {
+    const packet = Buffer.from([PacketType.PubAck << 4, 2, (packetId >> 8) & 0xff, packetId & 0xff])
+    this.socket?.write(packet)
+  }
+
+  private startPing(): void {
+    this.stopPing()
+    this.pingTimer = setInterval(() => {
+      this.socket?.write(Buffer.from([PacketType.PingReq << 4, 0]))
+    }, KEEPALIVE_SECONDS * 1000)
+  }
+
+  private stopPing(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer)
+      this.pingTimer = null
+    }
+  }
+
+  private clearConnackTimer(): void {
+    if (this.connackTimer) {
+      clearTimeout(this.connackTimer)
+      this.connackTimer = null
+    }
+  }
+
+  private buildConnectPacket(payload: Buffer): Buffer {
+    const variableHeader: number[] = []
+    appendString(variableHeader, PROTOCOL_NAME)
+    variableHeader.push(PROTOCOL_LEVEL, CONNECT_FLAGS)
+    variableHeader.push((KEEPALIVE_SECONDS >> 8) & 0xff, KEEPALIVE_SECONDS & 0xff)
+
+    const body = Buffer.concat([Buffer.from(variableHeader), payload])
+    return Buffer.concat([Buffer.from([PacketType.Connect << 4, ...encodeRemainingLength(body.length)]), body])
+  }
+
+  private buildPublishPacket(topic: string, payload: Buffer, qos: 0 | 1): Buffer {
+    const variableHeader: number[] = []
+    appendString(variableHeader, topic)
+    if (qos > 0) {
+      const packetId = this.allocatePacketId()
+      variableHeader.push((packetId >> 8) & 0xff, packetId & 0xff)
+    }
+
+    const body = Buffer.concat([Buffer.from(variableHeader), payload])
+    const flags = qos << 1
+    return Buffer.concat([
+      Buffer.from([(PacketType.Publish << 4) | flags, ...encodeRemainingLength(body.length)]),
+      body,
+    ])
+  }
+
+  private buildSubscribePacket(topics: string[]): Buffer {
+    const packetId = this.allocatePacketId()
+    const body: number[] = [(packetId >> 8) & 0xff, packetId & 0xff]
+    for (const topic of topics) {
+      appendString(body, topic)
+      body.push(0)
+    }
+    // SUBSCRIBE has reserved flags 0010 in the fixed-header low nibble.
+    return Buffer.concat([
+      Buffer.from([(PacketType.Subscribe << 4) | 0x02, ...encodeRemainingLength(body.length)]),
+      Buffer.from(body),
+    ])
+  }
+
+  private allocatePacketId(): number {
+    const id = this.nextPacketId
+    this.nextPacketId = (this.nextPacketId % 0xffff) + 1
+    return id
+  }
+}
+
+function appendString(target: number[], value: string): void {
+  const buf = Buffer.from(value, 'utf8')
+  target.push((buf.length >> 8) & 0xff, buf.length & 0xff)
+  for (const b of buf) target.push(b)
+}
+
+function encodeRemainingLength(length: number): number[] {
+  const bytes: number[] = []
+  let value = length
+  do {
+    let digit = value & 0x7f
+    value >>= 7
+    if (value > 0) digit |= 0x80
+    bytes.push(digit)
+  } while (value > 0)
+  return bytes
+}
+
+function decodeRemainingLength(buffer: Buffer, offset: number): { length: number; bytesUsed: number } | null {
+  let length = 0
+  let multiplier = 1
+  let bytesUsed = 0
+
+  while (offset + bytesUsed < buffer.length) {
+    const byte = buffer[offset + bytesUsed]!
+    length += (byte & 0x7f) * multiplier
+    bytesUsed++
+    if ((byte & 0x80) === 0) {
+      return { length, bytesUsed }
+    }
+    multiplier *= 128
+    if (bytesUsed > 4) return null
+  }
+
+  return null
+}

package/src/platforms/instagram/realtime-listener.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'bun:test'
+
+import { InstagramRealtimeListener } from '@/platforms/instagram/realtime-listener'
+
+function makeClient(overrides: Record<string, unknown> = {}) {
+  return {
+    getUserId: () => '123',
+    getSessionState: () => ({}) as never,
+    fetchIrisBootstrap: async () => ({ seqId: 1, snapshotAtMs: 1 }),
+    ...overrides,
+  } as never
+}
+
+describe('InstagramRealtimeListener', () => {
+  it('stays restartable after a bootstrap failure', async () => {
+    let calls = 0
+    const client = makeClient({
+      fetchIrisBootstrap: async () => {
+        calls++
+        throw new Error('bootstrap failed')
+      },
+    })
+    const listener = new InstagramRealtimeListener(client)
+
+    // given a failing bootstrap, when start() rejects, then running must be reset
+    await expect(listener.start()).rejects.toThrow('bootstrap failed')
+
+    // when start() is called again, then it must retry rather than no-op at the guard
+    await expect(listener.start()).rejects.toThrow('bootstrap failed')
+    expect(calls).toBe(2)
+
+    listener.stop()
+  })
+})