agent-messenger 2.27.1 → 2.28.0

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()
+  })
+})

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

@@ -0,0 +1,201 @@
+import { EventEmitter } from 'node:events'
+import { deflateSync, inflateSync } from 'node:zlib'
+
+import type { InstagramClient } from './client'
+import { buildConnectPayload } from './mqtt/connection'
+import { MqttTransport } from './mqtt/transport'
+import { extractMediaUrl, extractMessageText, getMessageType, type InstagramMessageSummary } from './types'
+
+export interface InstagramRealtimeListenerEventMap {
+  message: [InstagramMessageSummary]
+  error: [Error]
+  connected: [{ userId: string }]
+  disconnected: []
+}
+
+export interface InstagramRealtimeListenerOptions {
+  connackTimeoutMs?: number
+}
+
+type EventKey = keyof InstagramRealtimeListenerEventMap
+
+const TOPIC_PUBSUB = '88'
+const TOPIC_REALTIME_SUB = '149'
+const TOPIC_IRIS_SUB = '134'
+const TOPIC_MESSAGE_SYNC = '146'
+
+const ZLIB_MAGIC_BYTE = 0x78
+
+const DM_THREAD_PATH_PATTERN = /^\/direct_v2\/(?:inbox\/)?threads\//
+const THREAD_ID_PATTERN = /^\/direct_v2\/(?:inbox\/)?threads\/(\d+)/
+
+interface IrisEnvelope {
+  data?: IrisPatch[]
+}
+
+interface IrisPatch {
+  op?: string
+  path?: string
+  value?: string
+}
+
+export class InstagramRealtimeListener {
+  private client: InstagramClient
+  private transport: MqttTransport | null = null
+  private emitter = new EventEmitter()
+  private running = false
+  private userId: string
+  private connackTimeoutMs: number | undefined
+
+  constructor(client: InstagramClient, options: InstagramRealtimeListenerOptions = {}) {
+    this.client = client
+    this.userId = client.getUserId() ?? ''
+    this.connackTimeoutMs = options.connackTimeoutMs
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+
+    try {
+      const session = this.client.getSessionState()
+      const iris = await this.client.fetchIrisBootstrap()
+
+      if (!this.running) return
+
+      const connectPayload = buildConnectPayload(session)
+
+      const transport = new MqttTransport({ connackTimeoutMs: this.connackTimeoutMs })
+      this.transport = transport
+
+      transport.on('connect', () => {
+        this.sendSubscriptions(iris)
+        this.emitter.emit('connected', { userId: this.userId })
+      })
+      transport.on('publish', ({ topic, payload }) => this.handlePublish(topic, payload))
+      transport.on('error', (err) => this.emitter.emit('error', err))
+      transport.on('close', () => {
+        if (this.running) this.emitter.emit('disconnected')
+      })
+
+      transport.connect(connectPayload)
+    } catch (error) {
+      // Any setup failure must leave the listener cleanly restartable: reset running
+      // and discard the partial transport so a later start() does not no-op at the guard.
+      this.running = false
+      if (this.transport) {
+        this.transport.disconnect()
+        this.transport = null
+      }
+      throw error
+    }
+  }
+
+  stop(): void {
+    this.running = false
+    if (this.transport) {
+      this.transport.disconnect()
+      this.transport = null
+    }
+    this.emitter.emit('disconnected')
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: InstagramRealtimeListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: InstagramRealtimeListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: InstagramRealtimeListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  private sendSubscriptions(iris: { seqId: number; snapshotAtMs: number }): void {
+    const transport = this.transport
+    if (!transport) return
+
+    transport.publish(
+      TOPIC_IRIS_SUB,
+      deflateJson({
+        seq_id: iris.seqId,
+        snapshot_at_ms: iris.snapshotAtMs,
+        snapshot_app_version: APP_VERSION,
+      }),
+    )
+
+    transport.publish(TOPIC_PUBSUB, deflateJson({ sub: [`ig/u/v1/${this.userId}`] }))
+
+    transport.publish(
+      TOPIC_REALTIME_SUB,
+      deflateJson({
+        sub: [`1/graphqlsubscriptions/17867973967082385/{"input_data":{"user_id":"${this.userId}"}}`],
+      }),
+    )
+  }
+
+  private handlePublish(topic: string, payload: Buffer): void {
+    if (topic !== TOPIC_MESSAGE_SYNC) return
+
+    let envelopes: IrisEnvelope[]
+    try {
+      envelopes = JSON.parse(inflateIfNeeded(payload).toString('utf8')) as IrisEnvelope[]
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      return
+    }
+
+    for (const envelope of envelopes) {
+      for (const patch of envelope.data ?? []) {
+        const message = this.decodeDmPatch(patch)
+        if (message) this.emitter.emit('message', message)
+      }
+    }
+  }
+
+  private decodeDmPatch(patch: IrisPatch): InstagramMessageSummary | null {
+    if (patch.op !== 'add') return null
+    if (!patch.path || !patch.value || !DM_THREAD_PATH_PATTERN.test(patch.path)) return null
+
+    const threadId = patch.path.match(THREAD_ID_PATTERN)?.[1] ?? ''
+
+    let item: Record<string, unknown>
+    try {
+      item = JSON.parse(patch.value) as Record<string, unknown>
+    } catch {
+      return null
+    }
+
+    const itemId = String(item['item_id'] ?? '')
+    const fromUserId = String(item['user_id'] ?? '')
+    const timestampUs = item['timestamp'] as number | string | undefined
+
+    return {
+      id: itemId,
+      thread_id: threadId,
+      from: fromUserId,
+      timestamp: timestampUs ? new Date(Number(timestampUs) / 1000).toISOString() : new Date().toISOString(),
+      is_outgoing: fromUserId === this.userId,
+      type: getMessageType(item),
+      text: extractMessageText(item),
+      media_url: extractMediaUrl(item),
+    }
+  }
+}
+
+const APP_VERSION = '312.1.0.34.111'
+
+function deflateJson(value: unknown): Buffer {
+  return deflateSync(JSON.stringify(value), { level: 9 })
+}
+
+function inflateIfNeeded(payload: Buffer): Buffer {
+  if (payload.length > 0 && payload[0] === ZLIB_MAGIC_BYTE) {
+    return inflateSync(payload)
+  }
+  return payload
+}

package/src/platforms/kakaotalk/client.test.ts

@@ -540,6 +540,46 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('normalizes Long-like chat ids from LCHATLIST pages', async () => {
+      const loginResult = {
+        ...DEFAULT_LOGIN_RESULT,
+        eof: false,
+      }
+      mockLogin.mockResolvedValue(loginResult)
+
+      mockGetChatList.mockResolvedValueOnce({
+        body: {
+          chatDatas: [
+            {
+              c: makeLong(300),
+              t: 1,
+              k: ['Dave'],
+              i: [4],
+              a: 1,
+              n: 0,
+              o: 1698000000,
+              l: { authorId: 4, message: 'from paginated chat', sendAt: 1698000000 },
+              ll: makeLong(100),
+            },
+          ],
+          lastTokenId: makeLong(1),
+          lastChatId: makeLong(300),
+          eof: true,
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ all: true })
+
+      const paginatedChat = chats.find((chat) => chat.chat_id === '300')
+      expect(paginatedChat?.chat_id).toBe('300')
+      expect(paginatedChat?.display_name).toBe('Dave')
+      expect(paginatedChat?.last_message?.author_name).toBe('Dave')
+      expect(chats.some((chat) => chat.chat_id === '[object Object]')).toBe(false)
+
+      client.close()
+    })
+
     it('wraps errors as KakaoTalkError', async () => {
       mockLogin.mockRejectedValue(new Error('Connection refused'))
 

package/src/platforms/kakaotalk/client.ts

@@ -62,7 +62,7 @@ class MemberNameCache {
       const names = chat.k as string[] | undefined
       if (!Array.isArray(ids) || !Array.isArray(names)) continue
 
-      const chatId = String(chat.c)
+      const chatId = longToString(chat.c)
       let map = this.byChatId.get(chatId)
       if (!map) {
         map = new Map()
@@ -176,7 +176,7 @@ function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameC
   const memberNames = (chat.k ?? []) as string[]
   const lastLog = chat.l as Record<string, unknown> | null
   const displayName = memberNames.join(', ') || null
-  const chatId = String(chat.c)
+  const chatId = longToString(chat.c)
 
   return {
     chat_id: chatId,
@@ -256,7 +256,7 @@ function findMaxLogId(logs: Array<Record<string, unknown>>, field: string): Long
 
 function collectChats(chatDatas: ChatData[], into: ChatData[], seen: Set<string>): void {
   for (const chat of chatDatas) {
-    const id = String(chat.c)
+    const id = longToString(chat.c)
     if (!seen.has(id)) {
       seen.add(id)
       into.push(chat)
@@ -771,7 +771,9 @@ export class KakaoTalkClient {
         }
 
         const titles = options?.resolveTitles
-          ? await Promise.all(results.map((chat) => this.fetchChatTitle(session, parseLong(String(chat.c)), chat)))
+          ? await Promise.all(
+              results.map((chat) => this.fetchChatTitle(session, parseLong(longToString(chat.c)), chat)),
+            )
           : null
 
         return results.map((chat, i) => formatChat(chat, titles ? titles[i] : null, this.nameCache))