agent-messenger 2.27.2 → 2.29.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/instagram/types.ts

@@ -60,19 +60,22 @@ export interface InstagramMessageSummary {
   media_url?: string
 }
 
+export interface InstagramDevice {
+  phone_id: string
+  uuid: string
+  android_device_id: string
+  advertising_id: string
+  client_session_id: string
+  device_string: string
+}
+
 export interface InstagramSessionState {
   cookies: string
-  device: {
-    phone_id: string
-    uuid: string
-    android_device_id: string
-    advertising_id: string
-    client_session_id: string
-    device_string: string
-  }
+  device: InstagramDevice
   authorization?: string
   user_id?: string
   mid?: string
+  www_claim?: string
   challenge_path?: string
 }
 

package/src/platforms/teams/app-config.ts

@@ -0,0 +1,92 @@
+import type { TeamsAccountType } from './types'
+
+export const TEAMS_DESKTOP_CLIENT_ID = '1fec8e78-bce4-4aaf-ab1b-5451cc387264'
+export const TEAMS_WEB_CLIENT_ID = '5e3ce6c0-2b1f-4285-8d4b-75ee78787346'
+
+export const CONSUMER_TENANT_ID = '9188040d-6c67-4c5b-b112-36a304b66dad'
+// The Microsoft Services (MSA passthrough) tenant. Consumer/MSA tokens for the
+// Skype resource carry this `tid`, so it is a placeholder that still requires
+// tenant discovery before the skype-token exchange.
+export const MICROSOFT_SERVICES_TENANT_ID = 'f8cdef31-a31e-4b4a-93e4-5f571e91255a'
+export const WORK_TENANT_ID = 'organizations'
+
+export const DEVICE_CODE_SCOPE_TEAMS = 'service::api.fl.teams.microsoft.com::MBI_SSL openid profile offline_access'
+export const DEVICE_CODE_SCOPE_SKYPE = 'service::api.fl.spaces.skype.com::MBI_SSL openid profile offline_access'
+export const WORK_DEVICE_CODE_SCOPE_TEAMS = 'https://api.spaces.skype.com/.default openid profile offline_access'
+export const WORK_DEVICE_CODE_SCOPE_SKYPE = 'https://api.spaces.skype.com/.default openid profile offline_access'
+
+export const SUBSTRATE_SEARCH_URL = 'https://substrate.office.com/searchservice/api/v2/query'
+export const TEAMS_WEB_ORIGIN = 'https://teams.microsoft.com'
+export const AAD_SCOPE_SUBSTRATE = 'https://substrate.office.com/.default offline_access'
+export const AAD_SCOPE_GRAPH = 'https://graph.microsoft.com/.default offline_access'
+export const AAD_AUDIENCE_SUBSTRATE = 'https://substrate.office.com'
+export const AAD_AUDIENCE_GRAPH = 'https://graph.microsoft.com'
+
+export const AUTHZ_CONSUMER_URL = 'https://teams.live.com/api/auth/v1.0/authz/consumer'
+export const AUTHZ_WORK_URL = 'https://teams.microsoft.com/api/authsvc/v1.0/authz'
+
+// Control-plane tenant-discovery endpoint. The region segment is not
+// authoritative for this call (it lists every tenant the user belongs to
+// regardless of home region), so we pin the value fossteams uses.
+export const TEAMS_TENANTS_URL = 'https://teams.microsoft.com/api/mt/emea/beta/users/tenants'
+
+export const GET_CREDENTIAL_TYPE_URL = 'https://login.microsoftonline.com/common/GetCredentialType'
+
+export function consumerDeviceCodeUrl(): string {
+  return `https://login.microsoftonline.com/${CONSUMER_TENANT_ID}/oauth2/v2.0/devicecode`
+}
+
+export function consumerTokenUrl(): string {
+  return `https://login.microsoftonline.com/${CONSUMER_TENANT_ID}/oauth2/v2.0/token`
+}
+
+export function organizationsDeviceCodeUrl(): string {
+  return `https://login.microsoftonline.com/${WORK_TENANT_ID}/oauth2/v2.0/devicecode`
+}
+
+export function organizationsTokenUrl(): string {
+  return `https://login.microsoftonline.com/${WORK_TENANT_ID}/oauth2/v2.0/token`
+}
+
+export function tenantTokenUrl(tenantId: string): string {
+  return `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`
+}
+
+export function deviceCodeUrl(accountType: TeamsAccountType): string {
+  return accountType === 'personal' ? consumerDeviceCodeUrl() : organizationsDeviceCodeUrl()
+}
+
+export function deviceCodeTokenUrl(accountType: TeamsAccountType, tenantId?: string): string {
+  if (tenantId) return tenantTokenUrl(tenantId)
+  return accountType === 'personal' ? consumerTokenUrl() : organizationsTokenUrl()
+}
+
+export function deviceCodeTeamsScope(accountType: TeamsAccountType): string {
+  return accountType === 'personal' ? DEVICE_CODE_SCOPE_TEAMS : WORK_DEVICE_CODE_SCOPE_TEAMS
+}
+
+export function deviceCodeSkypeScope(accountType: TeamsAccountType): string {
+  return accountType === 'personal' ? DEVICE_CODE_SCOPE_SKYPE : WORK_DEVICE_CODE_SCOPE_SKYPE
+}
+
+export function authzUrl(accountType: TeamsAccountType): string {
+  return accountType === 'personal' ? AUTHZ_CONSUMER_URL : AUTHZ_WORK_URL
+}
+
+export interface TeamsAppClient {
+  clientId: string
+  source: 'env' | 'builtin'
+}
+
+function parseTrimmed(value: string | undefined): string | undefined {
+  const normalized = value?.trim()
+  return normalized ? normalized : undefined
+}
+
+export function getTeamsAppClientId(accountType: TeamsAccountType = 'personal'): TeamsAppClient {
+  const envClientId = parseTrimmed(process.env.AGENT_TEAMS_CLIENT_ID)
+  if (envClientId) {
+    return { clientId: envClientId, source: 'env' }
+  }
+  return { clientId: accountType === 'work' ? TEAMS_DESKTOP_CLIENT_ID : TEAMS_WEB_CLIENT_ID, source: 'builtin' }
+}