agent-messenger 1.14.0 → 2.0.0

package/src/platforms/slack/listener.test.ts

@@ -0,0 +1,370 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackListener } from '@/platforms/slack/listener'
+import type { SlackRTMMessageEvent, SlackRTMReactionEvent } from '@/platforms/slack/types'
+
+type WsHandler = (...args: any[]) => void
+
+let mockWsInstance: MockWs
+
+class MockWs {
+  static OPEN = 1
+  static CLOSED = 3
+  readyState = MockWs.OPEN
+
+  private handlers = new Map<string, WsHandler[]>()
+  sent: string[] = []
+
+  constructor(_url: string, _options?: any) {
+    mockWsInstance = this
+  }
+
+  on(event: string, handler: WsHandler) {
+    const list = this.handlers.get(event) ?? []
+    list.push(handler)
+    this.handlers.set(event, list)
+  }
+
+  send(data: string) {
+    this.sent.push(data)
+  }
+
+  close() {
+    this.readyState = MockWs.CLOSED
+    setTimeout(() => this.emit('close'), 0)
+  }
+
+  emit(event: string, ...args: any[]) {
+    for (const handler of this.handlers.get(event) ?? []) {
+      handler(...args)
+    }
+  }
+
+  simulateOpen() {
+    this.emit('open')
+  }
+
+  simulateMessage(data: Record<string, unknown>) {
+    this.emit('message', Buffer.from(JSON.stringify(data)))
+  }
+
+  simulateClose() {
+    this.readyState = MockWs.CLOSED
+    this.emit('close')
+  }
+}
+
+mock.module('ws', () => ({ default: MockWs, __esModule: true }))
+
+function createMockClient(overrides: Record<string, any> = {}) {
+  return {
+    rtmConnect: mock(() =>
+      Promise.resolve({
+        url: 'wss://fake.slack.com/ws',
+        cookie: 'fake-cookie',
+        self: { id: 'U_SELF' },
+        team: { id: 'T_TEAM' },
+      }),
+    ),
+    ...overrides,
+  } as any
+}
+
+describe('SlackListener', () => {
+  let listener: SlackListener
+
+  afterEach(() => {
+    listener?.stop()
+  })
+
+  describe('start', () => {
+    test('calls rtmConnect and opens WebSocket', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+
+      expect(client.rtmConnect).toHaveBeenCalledTimes(1)
+    })
+
+    test('is idempotent', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      await listener.start()
+
+      expect(client.rtmConnect).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('connected event', () => {
+    test('emits connected with self/team on hello', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const connected: any[] = []
+      listener.on('connected', (info) => connected.push(info))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+
+      expect(connected.length).toBe(1)
+      expect(connected[0].self.id).toBe('U_SELF')
+      expect(connected[0].team.id).toBe('T_TEAM')
+    })
+  })
+
+  describe('message events', () => {
+    test('emits message events', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const messages: SlackRTMMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+      mockWsInstance.simulateMessage({
+        type: 'message',
+        channel: 'C123',
+        user: 'U456',
+        text: 'hello world',
+        ts: '123.456',
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].type).toBe('message')
+      expect(messages[0].channel).toBe('C123')
+      expect(messages[0].text).toBe('hello world')
+    })
+  })
+
+  describe('reaction events', () => {
+    test('emits reaction_added events', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const reactions: SlackRTMReactionEvent[] = []
+      listener.on('reaction_added', (event) => reactions.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({
+        type: 'reaction_added',
+        user: 'U789',
+        reaction: 'thumbsup',
+        item: { type: 'message', channel: 'C123', ts: '100.001' },
+        event_ts: '200.001',
+      })
+
+      expect(reactions.length).toBe(1)
+      expect(reactions[0].reaction).toBe('thumbsup')
+    })
+  })
+
+  describe('slack_event catch-all', () => {
+    test('emits slack_event for every non-hello event', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const events: any[] = []
+      listener.on('slack_event', (event) => events.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+      mockWsInstance.simulateMessage({ type: 'message', text: 'hi', channel: 'C1', ts: '1' })
+      mockWsInstance.simulateMessage({ type: 'user_typing', channel: 'C1', user: 'U1' })
+
+      expect(events.length).toBe(2)
+      expect(events[0].type).toBe('message')
+      expect(events[1].type).toBe('user_typing')
+    })
+  })
+
+  describe('ping/pong', () => {
+    test('does not treat pong reply as an event', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const events: any[] = []
+      listener.on('slack_event', (event) => events.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+      mockWsInstance.simulateMessage({ reply_to: 1, type: 'pong' })
+
+      expect(events.length).toBe(0)
+    })
+  })
+
+  describe('stop', () => {
+    test('closes WebSocket and prevents reconnection', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+
+      listener.stop()
+
+      await new Promise((r) => setTimeout(r, 50))
+      expect(client.rtmConnect).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('reconnection', () => {
+    test('reconnects on WebSocket close when still running', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const disconnected: boolean[] = []
+      listener.on('disconnected', () => disconnected.push(true))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateClose()
+
+      expect(disconnected.length).toBe(1)
+
+      await new Promise((r) => setTimeout(r, 1500))
+      expect(client.rtmConnect.mock.calls.length).toBeGreaterThanOrEqual(2)
+    })
+
+    test('emits error and reconnects on rtmConnect failure', async () => {
+      let callCount = 0
+      const client = createMockClient({
+        rtmConnect: mock(() => {
+          callCount++
+          if (callCount === 1) return Promise.reject(new Error('network_error'))
+          return Promise.resolve({
+            url: 'wss://fake.slack.com/ws',
+            cookie: 'fake-cookie',
+            self: { id: 'U_SELF' },
+            team: { id: 'T_TEAM' },
+          })
+        }),
+      })
+
+      listener = new SlackListener(client)
+
+      const errors: Error[] = []
+      listener.on('error', (err) => errors.push(err))
+
+      await listener.start()
+
+      await new Promise((r) => setTimeout(r, 1500))
+
+      expect(errors.length).toBe(1)
+      expect(errors[0].message).toBe('network_error')
+      expect(client.rtmConnect.mock.calls.length).toBeGreaterThanOrEqual(2)
+    })
+  })
+
+  describe('on/off/once', () => {
+    test('off removes listener', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const messages: any[] = []
+      const handler = (event: any) => messages.push(event)
+      listener.on('message', handler)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'message', text: 'a', channel: 'C1', ts: '1' })
+
+      listener.off('message', handler)
+      mockWsInstance.simulateMessage({ type: 'message', text: 'b', channel: 'C1', ts: '2' })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].text).toBe('a')
+    })
+
+    test('once fires only once', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const messages: any[] = []
+      listener.once('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'message', text: 'first', channel: 'C1', ts: '1' })
+      mockWsInstance.simulateMessage({ type: 'message', text: 'second', channel: 'C1', ts: '2' })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].text).toBe('first')
+    })
+  })
+
+  describe('goodbye / team_migration_started', () => {
+    test('goodbye triggers immediate reconnect without backoff', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+
+      // simulate several failed reconnects to build up backoff
+      ;(listener as any).reconnectAttempts = 5
+
+      mockWsInstance.simulateMessage({ type: 'goodbye' })
+
+      // goodbye should reset reconnectAttempts to 0
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+
+    test('team_migration_started triggers immediate reconnect', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+
+      ;(listener as any).reconnectAttempts = 5
+      mockWsInstance.simulateMessage({ type: 'team_migration_started' })
+
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+
+    test('goodbye and team_migration_started are not emitted as events', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      const events: any[] = []
+      listener.on('slack_event', (event) => events.push(event))
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateMessage({ type: 'hello' })
+      mockWsInstance.simulateMessage({ type: 'goodbye' })
+      mockWsInstance.simulateMessage({ type: 'team_migration_started' })
+      mockWsInstance.simulateMessage({ type: 'message', text: 'hi', channel: 'C1', ts: '1' })
+
+      expect(events.length).toBe(1)
+      expect(events[0].type).toBe('message')
+    })
+  })
+
+  describe('start after stop', () => {
+    test('resets reconnect attempts on fresh start', async () => {
+      const client = createMockClient()
+      listener = new SlackListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+      listener.stop()
+
+      await listener.start()
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+  })
+})

package/src/platforms/slack/listener.ts

@@ -0,0 +1,181 @@
+import { EventEmitter } from 'events'
+
+import WebSocket from 'ws'
+
+import type { SlackClient } from './client'
+import type { SlackListenerEventMap, SlackRTMGenericEvent } from './types'
+
+const PING_INTERVAL = 30_000
+const PONG_TIMEOUT = 10_000
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+
+type EventKey = keyof SlackListenerEventMap
+
+export class SlackListener {
+  private client: SlackClient
+  private running = false
+  private ws: WebSocket | null = null
+  private emitter = new EventEmitter()
+  private pingTimer: ReturnType<typeof setInterval> | null = null
+  private pongTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private messageId = 0
+  private reconnectAttempts = 0
+  private selfId: string | null = null
+  private teamId: string | null = null
+
+  constructor(client: SlackClient) {
+    this.client = client
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.reconnectAttempts = 0
+    await this.connect()
+  }
+
+  stop(): void {
+    this.running = false
+    this.clearTimers()
+    if (this.ws) {
+      this.ws.close()
+      this.ws = null
+    }
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: SlackListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: SlackListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: SlackListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  private async connect(): Promise<void> {
+    if (!this.running) return
+
+    try {
+      const rtm = await this.client.rtmConnect()
+      if (!this.running) return
+
+      this.selfId = rtm.self.id
+      this.teamId = rtm.team.id
+
+      const ws = new WebSocket(rtm.url, {
+        headers: { Cookie: `d=${rtm.cookie}` },
+      })
+      this.ws = ws
+
+      ws.on('open', () => {
+        if (!this.running) {
+          ws.close()
+          return
+        }
+        this.reconnectAttempts = 0
+        this.startPing()
+      })
+
+      ws.on('message', (raw) => {
+        try {
+          const data = JSON.parse(raw.toString())
+          this.handleEvent(data)
+        } catch {
+          // malformed message, ignore
+        }
+      })
+
+      ws.on('close', () => {
+        this.clearTimers()
+        if (this.ws === ws) this.ws = null
+        if (this.running) {
+          this.emitter.emit('disconnected')
+          this.scheduleReconnect()
+        }
+      })
+
+      ws.on('error', (err) => {
+        this.emitter.emit('error', err instanceof Error ? err : new Error(String(err)))
+        // onclose will fire after onerror, reconnect handled there
+      })
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      if (this.running) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  private handleEvent(event: SlackRTMGenericEvent): void {
+    if (!event.type) return
+
+    if (event.type === 'hello') {
+      this.emitter.emit('connected', { self: { id: this.selfId! }, team: { id: this.teamId! } })
+      return
+    }
+
+    // server graceful shutdown or team migration — reconnect immediately
+    if (event.type === 'goodbye' || event.type === 'team_migration_started') {
+      this.reconnectAttempts = 0
+      this.ws?.close()
+      return
+    }
+
+    // pong — any reply_to acknowledges our ping
+    if (event.reply_to !== undefined) {
+      this.clearPongTimer()
+      return
+    }
+
+    this.emitter.emit(event.type, event)
+    this.emitter.emit('slack_event', event)
+  }
+
+  private scheduleReconnect(): void {
+    const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
+    this.reconnectAttempts++
+    this.reconnectTimer = setTimeout(() => this.connect(), delay)
+  }
+
+  private startPing(): void {
+    this.pingTimer = setInterval(() => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return
+
+      this.messageId++
+      this.ws.send(JSON.stringify({ type: 'ping', id: this.messageId }))
+
+      this.clearPongTimer()
+      this.pongTimer = setTimeout(() => {
+        // no pong received, force reconnect
+        this.ws?.close()
+      }, PONG_TIMEOUT)
+    }, PING_INTERVAL)
+  }
+
+  private clearPongTimer(): void {
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer)
+      this.pongTimer = null
+    }
+  }
+
+  private clearTimers(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer)
+      this.pingTimer = null
+    }
+    this.clearPongTimer()
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+}