agent-messenger 2.10.1 → 2.11.0

package/src/platforms/discordbot/listener.ts

@@ -0,0 +1,321 @@
+import { EventEmitter } from 'events'
+
+import WebSocket from 'ws'
+
+import type { DiscordBotClient } from './client'
+import type { DiscordBotListenerEventMap, DiscordGatewayGenericEvent } from './types'
+import { DiscordGatewayOpcode, DiscordIntent } from './types'
+
+const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'
+const GATEWAY_QUERY = '?v=10&encoding=json'
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+const NON_RECOVERABLE_CLOSE_CODES = [4004, 4010, 4011, 4012, 4013, 4014]
+const SESSION_RESET_CLOSE_CODES = [4007, 4009]
+
+const DEFAULT_INTENTS =
+  DiscordIntent.Guilds |
+  DiscordIntent.GuildMessages |
+  DiscordIntent.GuildMessageReactions |
+  DiscordIntent.GuildMessageTyping |
+  DiscordIntent.DirectMessages |
+  DiscordIntent.DirectMessageReactions |
+  DiscordIntent.DirectMessageTyping
+
+type EventKey = keyof DiscordBotListenerEventMap
+
+export class DiscordBotListener {
+  private client: DiscordBotClient
+  private intents: number
+  private running = false
+  private ws: WebSocket | null = null
+  private emitter = new EventEmitter()
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null
+  private heartbeatAckReceived = true
+  private heartbeatJitterTimer: ReturnType<typeof setTimeout> | null = null
+  private invalidSessionTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectAttempts = 0
+  private sequence: number | null = null
+  private sessionId: string | null = null
+  private resumeGatewayUrl: string | null = null
+  private token: string | null = null
+  private cachedUser: { id: string; username: string } | null = null
+  private generation = 0
+
+  constructor(client: DiscordBotClient, options?: { intents?: number }) {
+    this.client = client
+    this.intents = options?.intents ?? DEFAULT_INTENTS
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.reconnectAttempts = 0
+    this.generation++
+    await this.connect(this.generation)
+  }
+
+  stop(): void {
+    this.running = false
+    this.generation++
+    this.clearTimers()
+    if (this.ws) {
+      this.ws.close()
+      this.ws = null
+    }
+    this.sequence = null
+    this.sessionId = null
+    this.resumeGatewayUrl = null
+    this.token = null
+    this.cachedUser = null
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: DiscordBotListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: DiscordBotListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: DiscordBotListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  private isCurrent(generation: number, ws?: WebSocket): boolean {
+    if (generation !== this.generation || !this.running) return false
+    if (ws !== undefined && this.ws !== ws) return false
+    return true
+  }
+
+  private async connect(generation: number): Promise<void> {
+    if (!this.isCurrent(generation)) return
+
+    try {
+      const { token } = await this.client.gatewayConnect()
+      if (!this.isCurrent(generation)) return
+
+      this.token = token
+
+      const url = this.resumeGatewayUrl ? `${this.resumeGatewayUrl}${GATEWAY_QUERY}` : GATEWAY_URL
+      const ws = new WebSocket(url)
+      this.ws = ws
+
+      ws.on('open', () => {
+        if (!this.isCurrent(generation, ws)) {
+          ws.close()
+          return
+        }
+      })
+
+      ws.on('message', (raw) => {
+        if (!this.isCurrent(generation, ws)) return
+        try {
+          const data = JSON.parse(raw.toString())
+          this.handleMessage(data, generation, ws)
+        } catch {
+          // malformed gateway frame; ignore and let heartbeat handle liveness
+        }
+      })
+
+      ws.on('close', (code) => {
+        if (!this.isCurrent(generation, ws)) return
+        this.clearTimers()
+        this.ws = null
+        if (NON_RECOVERABLE_CLOSE_CODES.includes(code)) {
+          this.emitter.emit('error', new Error(`Discord gateway closed with non-recoverable code ${code}`))
+          this.running = false
+          return
+        }
+        if (SESSION_RESET_CLOSE_CODES.includes(code)) {
+          this.sequence = null
+          this.sessionId = null
+          this.resumeGatewayUrl = null
+        }
+        if (this.running) {
+          this.emitter.emit('disconnected')
+          this.scheduleReconnect()
+        }
+      })
+
+      ws.on('error', (err) => {
+        if (!this.isCurrent(generation, ws)) return
+        this.emitter.emit('error', err instanceof Error ? err : new Error(String(err)))
+      })
+    } catch (error) {
+      if (!this.isCurrent(generation)) return
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      if (this.running) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  private handleMessage(data: { op: number; d: any; s?: number; t?: string }, generation: number, ws: WebSocket): void {
+    if (!this.isCurrent(generation, ws)) return
+    const { op, d, s, t } = data
+
+    switch (op) {
+      case DiscordGatewayOpcode.Hello:
+        this.startHeartbeat(d.heartbeat_interval, generation, ws)
+        if (this.sessionId) {
+          this.sendResume()
+        } else {
+          this.sendIdentify()
+        }
+        break
+
+      case DiscordGatewayOpcode.HeartbeatACK:
+        this.heartbeatAckReceived = true
+        break
+
+      case DiscordGatewayOpcode.Dispatch:
+        if (typeof s === 'number') this.sequence = s
+        if (t) this.handleDispatch(t, d)
+        break
+
+      case DiscordGatewayOpcode.Reconnect:
+        this.reconnectAttempts = 0
+        ws.close()
+        break
+
+      case DiscordGatewayOpcode.InvalidSession: {
+        if (d === true) {
+          const delay = 1000 + Math.random() * 4000
+          this.invalidSessionTimer = setTimeout(() => {
+            this.invalidSessionTimer = null
+            if (this.isCurrent(generation, ws)) ws.close()
+          }, delay)
+        } else {
+          this.sequence = null
+          this.sessionId = null
+          this.resumeGatewayUrl = null
+          ws.close()
+        }
+        break
+      }
+
+      case DiscordGatewayOpcode.Heartbeat:
+        this.sendHeartbeat()
+        break
+    }
+  }
+
+  private handleDispatch(t: string, d: any): void {
+    if (t === 'READY') {
+      this.sessionId = d.session_id
+      this.resumeGatewayUrl = d.resume_gateway_url
+      this.cachedUser = d.user
+      this.reconnectAttempts = 0
+      this.emitter.emit('connected', { user: d.user, sessionId: d.session_id })
+      return
+    }
+
+    if (t === 'RESUMED') {
+      this.reconnectAttempts = 0
+      this.emitter.emit('connected', { user: this.cachedUser!, sessionId: this.sessionId! })
+      return
+    }
+
+    const eventType = t.toLowerCase()
+    const event: DiscordGatewayGenericEvent = { ...d, type: t }
+    this.emitter.emit(eventType, event)
+    this.emitter.emit('discord_event', event)
+  }
+
+  private sendIdentify(): void {
+    this.ws?.send(
+      JSON.stringify({
+        op: DiscordGatewayOpcode.Identify,
+        d: {
+          token: this.token,
+          intents: this.intents,
+          properties: {
+            os: 'linux',
+            browser: 'agent-messenger',
+            device: 'agent-messenger',
+          },
+        },
+      }),
+    )
+  }
+
+  private sendResume(): void {
+    this.ws?.send(
+      JSON.stringify({
+        op: DiscordGatewayOpcode.Resume,
+        d: {
+          token: this.token,
+          session_id: this.sessionId,
+          seq: this.sequence,
+        },
+      }),
+    )
+  }
+
+  private sendHeartbeat(): void {
+    this.ws?.send(JSON.stringify({ op: DiscordGatewayOpcode.Heartbeat, d: this.sequence }))
+  }
+
+  private startHeartbeat(interval: number, generation: number, ws: WebSocket): void {
+    this.clearHeartbeatTimers()
+    this.heartbeatAckReceived = true
+
+    this.heartbeatJitterTimer = setTimeout(() => {
+      this.heartbeatJitterTimer = null
+      if (!this.isCurrent(generation, ws)) return
+      this.heartbeatAckReceived = false
+      this.sendHeartbeat()
+
+      this.heartbeatTimer = setInterval(() => {
+        if (!this.isCurrent(generation, ws)) {
+          this.clearHeartbeatTimers()
+          return
+        }
+        if (!this.heartbeatAckReceived) {
+          ws.close()
+          return
+        }
+        this.heartbeatAckReceived = false
+        this.sendHeartbeat()
+      }, interval)
+    }, Math.random() * interval)
+  }
+
+  private scheduleReconnect(): void {
+    const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
+    this.reconnectAttempts++
+    const generation = this.generation
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect(generation)
+    }, delay)
+  }
+
+  private clearHeartbeatTimers(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+    if (this.heartbeatJitterTimer) {
+      clearTimeout(this.heartbeatJitterTimer)
+      this.heartbeatJitterTimer = null
+    }
+  }
+
+  private clearTimers(): void {
+    this.clearHeartbeatTimers()
+    if (this.invalidSessionTimer) {
+      clearTimeout(this.invalidSessionTimer)
+      this.invalidSessionTimer = null
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+}

package/src/platforms/discordbot/types.ts

@@ -187,3 +187,166 @@ export const DiscordFileSchema = z.object({
   height: z.number().optional(),
   width: z.number().optional(),
 })
+
+export const DiscordGatewayOpcode = {
+  Dispatch: 0,
+  Heartbeat: 1,
+  Identify: 2,
+  PresenceUpdate: 3,
+  VoiceStateUpdate: 4,
+  Resume: 6,
+  Reconnect: 7,
+  RequestGuildMembers: 8,
+  InvalidSession: 9,
+  Hello: 10,
+  HeartbeatACK: 11,
+} as const
+
+export const DiscordIntent = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1, // privileged
+  GuildModeration: 1 << 2,
+  GuildEmojisAndStickers: 1 << 3,
+  GuildIntegrations: 1 << 4,
+  GuildWebhooks: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildVoiceStates: 1 << 7,
+  GuildPresences: 1 << 8, // privileged
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15, // privileged
+  GuildScheduledEvents: 1 << 16,
+  AutoModerationConfiguration: 1 << 20,
+  AutoModerationExecution: 1 << 21,
+} as const
+
+export interface DiscordGatewayMessageCreateEvent {
+  type: 'MESSAGE_CREATE'
+  id: string
+  channel_id: string
+  guild_id?: string
+  author: { id: string; username: string; bot?: boolean }
+  content: string
+  timestamp: string
+  edited_timestamp?: string
+  mentions?: DiscordUser[]
+  attachments?: DiscordFile[]
+}
+
+export interface DiscordGatewayMessageUpdateEvent {
+  type: 'MESSAGE_UPDATE'
+  id: string
+  channel_id: string
+  guild_id?: string
+  content?: string
+  edited_timestamp?: string
+}
+
+export interface DiscordGatewayMessageDeleteEvent {
+  type: 'MESSAGE_DELETE'
+  id: string
+  channel_id: string
+  guild_id?: string
+}
+
+export interface DiscordGatewayReactionEvent {
+  type: 'MESSAGE_REACTION_ADD' | 'MESSAGE_REACTION_REMOVE'
+  user_id: string
+  channel_id: string
+  message_id: string
+  guild_id?: string
+  emoji: { id?: string; name: string }
+}
+
+export interface DiscordGatewayMemberEvent {
+  type: 'GUILD_MEMBER_ADD' | 'GUILD_MEMBER_REMOVE'
+  guild_id: string
+  user: { id: string; username: string }
+}
+
+export interface DiscordGatewayTypingEvent {
+  type: 'TYPING_START'
+  user_id: string
+  channel_id: string
+  guild_id?: string
+  timestamp: number
+}
+
+export interface DiscordGatewayPresenceEvent {
+  type: 'PRESENCE_UPDATE'
+  user: { id: string }
+  guild_id: string
+  status: 'online' | 'idle' | 'dnd' | 'offline'
+  activities?: Array<{ name: string; type: number }>
+}
+
+export interface DiscordGatewayChannelEvent {
+  type: 'CHANNEL_CREATE' | 'CHANNEL_UPDATE' | 'CHANNEL_DELETE'
+  id: string
+  guild_id?: string
+  name?: string
+}
+
+export interface DiscordGatewayGuildEvent {
+  type: 'GUILD_CREATE' | 'GUILD_UPDATE' | 'GUILD_DELETE'
+  id: string
+  name?: string
+  unavailable?: boolean
+}
+
+export interface DiscordGatewayInteractionEvent {
+  type: 'INTERACTION_CREATE'
+  id: string
+  application_id: string
+  token: string
+  data?: Record<string, unknown>
+  channel_id?: string
+  guild_id?: string
+  member?: Record<string, unknown>
+  user?: { id: string; username: string }
+}
+
+export interface DiscordGatewayGenericEvent {
+  type: string
+  [key: string]: unknown
+}
+
+export type DiscordGatewayEvent =
+  | DiscordGatewayMessageCreateEvent
+  | DiscordGatewayMessageUpdateEvent
+  | DiscordGatewayMessageDeleteEvent
+  | DiscordGatewayReactionEvent
+  | DiscordGatewayMemberEvent
+  | DiscordGatewayTypingEvent
+  | DiscordGatewayPresenceEvent
+  | DiscordGatewayChannelEvent
+  | DiscordGatewayGuildEvent
+  | DiscordGatewayInteractionEvent
+  | DiscordGatewayGenericEvent
+
+export interface DiscordBotListenerEventMap {
+  message_create: [event: DiscordGatewayMessageCreateEvent]
+  message_update: [event: DiscordGatewayMessageUpdateEvent]
+  message_delete: [event: DiscordGatewayMessageDeleteEvent]
+  message_reaction_add: [event: DiscordGatewayReactionEvent]
+  message_reaction_remove: [event: DiscordGatewayReactionEvent]
+  guild_member_add: [event: DiscordGatewayMemberEvent]
+  guild_member_remove: [event: DiscordGatewayMemberEvent]
+  presence_update: [event: DiscordGatewayPresenceEvent]
+  typing_start: [event: DiscordGatewayTypingEvent]
+  channel_create: [event: DiscordGatewayChannelEvent]
+  channel_update: [event: DiscordGatewayChannelEvent]
+  channel_delete: [event: DiscordGatewayChannelEvent]
+  guild_create: [event: DiscordGatewayGuildEvent]
+  guild_update: [event: DiscordGatewayGuildEvent]
+  guild_delete: [event: DiscordGatewayGuildEvent]
+  interaction_create: [event: DiscordGatewayInteractionEvent]
+  discord_event: [event: DiscordGatewayGenericEvent]
+  connected: [info: { user: { id: string; username: string }; sessionId: string }]
+  disconnected: []
+  error: [error: Error]
+}

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'bun:test'
 import { generateKeyPairSync } from 'node:crypto'
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
@@ -82,14 +82,14 @@ async function loadedClient(): Promise<InstagramClient> {
 
 describe('InstagramClient', () => {
   describe('constructor', () => {
-    test('creates instance with default credential manager', () => {
+    it('creates instance with default credential manager', () => {
       const client = new InstagramClient()
       expect(client).toBeInstanceOf(InstagramClient)
     })
   })
 
   describe('login', () => {
-    test('throws when no account configured', async () => {
+    it('throws when no account configured', async () => {
       const mockManager = {
         getAccount: () => Promise.resolve(null),
       } as any
@@ -100,7 +100,7 @@ describe('InstagramClient', () => {
       await expect(client.login()).rejects.toThrow('No Instagram credentials found')
     })
 
-    test('loads session from disk when file exists', async () => {
+    it('loads session from disk when file exists', async () => {
       const mockManager = {
         getAccount: () =>
           Promise.resolve({ account_id: 'testuser', username: 'testuser', created_at: '', updated_at: '' }),
@@ -116,7 +116,7 @@ describe('InstagramClient', () => {
   })
 
   describe('plaintextPassword format', () => {
-    test('produces #PWD_INSTAGRAM:0:timestamp:rawpassword format', async () => {
+    it('produces #PWD_INSTAGRAM:0:timestamp:rawpassword format', async () => {
       fetchResponses.push(
         new Response(null, {
           status: 200,
@@ -142,7 +142,7 @@ describe('InstagramClient', () => {
   })
 
   describe('encryptPassword format', () => {
-    test('produces #PWD_INSTAGRAM:4:timestamp:base64 format when encryption key provided', async () => {
+    it('produces #PWD_INSTAGRAM:4:timestamp:base64 format when encryption key provided', async () => {
       fetchResponses.push(
         new Response(null, {
           status: 200,
@@ -173,7 +173,7 @@ describe('InstagramClient', () => {
   })
 
   describe('buildHeaders', () => {
-    test('includes required Instagram headers', async () => {
+    it('includes required Instagram headers', async () => {
       fetchResponses.push(new Response(null, { status: 200, headers: {} }))
       fetchResponses.push(jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }))
 
@@ -189,7 +189,7 @@ describe('InstagramClient', () => {
       expect(headers['Content-Type']).toContain('application/x-www-form-urlencoded')
     })
 
-    test('includes device headers when session is set', async () => {
+    it('includes device headers when session is set', async () => {
       fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [] } }))
 
       const client = await loadedClient()
@@ -204,7 +204,7 @@ describe('InstagramClient', () => {
   })
 
   describe('mapThread', () => {
-    test('maps API thread to InstagramChatSummary', async () => {
+    it('maps API thread to InstagramChatSummary', async () => {
       const thread = {
         thread_id: 'thread-42',
         thread_title: 'Team Chat',
@@ -231,7 +231,7 @@ describe('InstagramClient', () => {
       expect(chat.participant_count).toBe(3)
     })
 
-    test('falls back to user names when no thread_title', async () => {
+    it('falls back to user names when no thread_title', async () => {
       const thread = {
         thread_id: 't-1',
         thread_type: 'private',
@@ -250,7 +250,7 @@ describe('InstagramClient', () => {
   })
 
   describe('mapMessage', () => {
-    test('maps API item to InstagramMessageSummary with media_url', async () => {
+    it('maps API item to InstagramMessageSummary with media_url', async () => {
       const item = {
         item_id: 'msg-7',
         user_id: '10',
@@ -282,7 +282,7 @@ describe('InstagramClient', () => {
       expect(msg.media_url).toBe('https://cdn.example.com/photo.jpg')
     })
 
-    test('sets is_outgoing true when from matches userId', async () => {
+    it('sets is_outgoing true when from matches userId', async () => {
       const item = {
         item_id: 'msg-8',
         user_id: '42',
@@ -300,7 +300,7 @@ describe('InstagramClient', () => {
   })
 
   describe('request', () => {
-    test('throws rate_limited on 429', async () => {
+    it('throws rate_limited on 429', async () => {
       fetchResponses.push(new Response('Rate limited', { status: 429 }))
 
       const client = await loadedClient()
@@ -310,7 +310,7 @@ describe('InstagramClient', () => {
       expect((err as InstagramError).code).toBe('rate_limited')
     })
 
-    test('throws on JSON parse error', async () => {
+    it('throws on JSON parse error', async () => {
       fetchResponses.push(new Response('not json', { status: 200 }))
 
       const client = await loadedClient()
@@ -318,7 +318,7 @@ describe('InstagramClient', () => {
       await expect(client.listChats()).rejects.toThrow(InstagramError)
     })
 
-    test('returns parsed response on success', async () => {
+    it('returns parsed response on success', async () => {
       fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [] } }))
 
       const client = await loadedClient()
@@ -329,7 +329,7 @@ describe('InstagramClient', () => {
   })
 
   describe('searchUsers', () => {
-    test('maps response to user list', async () => {
+    it('maps response to user list', async () => {
       fetchResponses.push(
         jsonResponse({
           status: 'ok',
@@ -350,7 +350,7 @@ describe('InstagramClient', () => {
   })
 
   describe('sendMessage', () => {
-    test('sends correct body params', async () => {
+    it('sends correct body params', async () => {
       fetchResponses.push(
         jsonResponse({
           status: 'ok',
@@ -370,7 +370,7 @@ describe('InstagramClient', () => {
   })
 
   describe('sendMessageToUser', () => {
-    test('sends correct body params', async () => {
+    it('sends correct body params', async () => {
       fetchResponses.push(
         jsonResponse({
           status: 'ok',