agent-messenger 2.10.2 → 2.11.0

package/src/platforms/slackbot/listener.ts

@@ -0,0 +1,362 @@
+import { EventEmitter } from 'events'
+
+import WebSocket from 'ws'
+
+import type { SlackBotClient } from './client'
+import { SlackBotError } from './types'
+import type {
+  SlackBotListenerEventMap,
+  SlackSocketModeAck,
+  SlackSocketModeEnvelope,
+  SlackSocketModeEventsApiArgs,
+  SlackSocketModeEventsApiEnvelope,
+  SlackSocketModeGenericEvent,
+  SlackSocketModeInteractiveArgs,
+  SlackSocketModeInteractiveEnvelope,
+  SlackSocketModeSlashCommandArgs,
+  SlackSocketModeSlashCommandEnvelope,
+} from './types'
+
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+const PING_INTERVAL = 30_000
+const PONG_TIMEOUT = 10_000
+const HELLO_TIMEOUT = 10_000
+
+const FATAL_ERROR_CODES = new Set([
+  'not_authed',
+  'invalid_auth',
+  'account_inactive',
+  'user_removed_from_team',
+  'team_disabled',
+  'not_allowed_token_type',
+  'missing_app_token',
+  'invalid_app_token_type',
+])
+
+const TERMINAL_DISCONNECT_REASONS = new Set(['link_disabled'])
+
+type EventKey = keyof SlackBotListenerEventMap
+
+export interface SlackBotListenerOptions {
+  appToken: string
+  debugReconnects?: boolean
+}
+
+export class SlackBotListener {
+  private client: SlackBotClient
+  private appToken: string
+  private debugReconnects: boolean
+  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 helloTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectAttempts = 0
+  private nextReconnectFloorMs = 0
+  private generation = 0
+
+  constructor(client: SlackBotClient, options: SlackBotListenerOptions) {
+    if (!options?.appToken) {
+      throw new SlackBotError('App-level token (xapp-) is required for Socket Mode', 'missing_app_token')
+    }
+    this.client = client
+    this.appToken = options.appToken
+    this.debugReconnects = options.debugReconnects ?? false
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.reconnectAttempts = 0
+    this.nextReconnectFloorMs = 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
+    }
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: SlackBotListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: SlackBotListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: SlackBotListenerEventMap[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 { url } = await this.client.appsConnectionsOpen(this.appToken)
+      if (!this.isCurrent(generation)) return
+
+      const wsUrl = this.debugReconnects ? `${url}${url.includes('?') ? '&' : '?'}debug_reconnects=true` : url
+      const ws = new WebSocket(wsUrl)
+      this.ws = ws
+
+      ws.on('open', () => {
+        if (!this.isCurrent(generation, ws)) {
+          ws.close()
+          return
+        }
+        this.startPing(generation, ws)
+        this.armHelloTimeout(generation, ws)
+      })
+
+      ws.on('message', (raw) => {
+        if (!this.isCurrent(generation, ws)) return
+        try {
+          const data = JSON.parse(raw.toString()) as SlackSocketModeEnvelope
+          this.handleEnvelope(data, generation, ws)
+        } catch {
+          // Malformed frame; ignore — ping/pong handles liveness.
+        }
+      })
+
+      ws.on('pong', () => {
+        if (!this.isCurrent(generation, ws)) return
+        this.clearPongTimer()
+      })
+
+      ws.on('close', () => {
+        if (!this.isCurrent(generation, ws)) return
+        this.clearTimers()
+        this.ws = 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
+      const wrapped = error instanceof Error ? error : new Error(String(error))
+      this.emitter.emit('error', wrapped)
+
+      const code = (error as { code?: string })?.code
+      if (code && FATAL_ERROR_CODES.has(code)) {
+        this.running = false
+        return
+      }
+
+      const retryAfter = (error as { retryAfter?: number })?.retryAfter
+      if (typeof retryAfter === 'number' && retryAfter > 0) {
+        this.nextReconnectFloorMs = retryAfter * 1000
+      }
+
+      if (this.running) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  private handleEnvelope(envelope: SlackSocketModeEnvelope, generation: number, ws: WebSocket): void {
+    if (!this.isCurrent(generation, ws)) return
+
+    switch (envelope.type) {
+      case 'hello': {
+        const hello = envelope as { connection_info?: { app_id?: string }; num_connections?: number }
+        this.clearHelloTimer()
+        this.reconnectAttempts = 0
+        this.emitter.emit('connected', {
+          app_id: hello.connection_info?.app_id,
+          num_connections: hello.num_connections,
+        })
+        return
+      }
+
+      case 'disconnect': {
+        // Server-requested reconnect (warning, refresh_requested) — analogous to
+        // Discord opcode 7, so reset backoff. `link_disabled` is terminal: the app
+        // was disabled, reconnecting would loop forever.
+        const reason = (envelope as { reason?: string }).reason
+        if (reason && TERMINAL_DISCONNECT_REASONS.has(reason)) {
+          this.emitter.emit(
+            'error',
+            new SlackBotError(`Slack closed the Socket Mode session: ${reason}`, 'disconnect_terminal'),
+          )
+          this.running = false
+          ws.close()
+          return
+        }
+        this.reconnectAttempts = 0
+        ws.close()
+        return
+      }
+
+      case 'events_api': {
+        this.dispatchEventsApi(envelope as SlackSocketModeEventsApiEnvelope, generation, ws)
+        return
+      }
+
+      case 'slash_commands': {
+        this.dispatchSlashCommand(envelope as SlackSocketModeSlashCommandEnvelope, generation, ws)
+        return
+      }
+
+      case 'interactive': {
+        this.dispatchInteractive(envelope as SlackSocketModeInteractiveEnvelope, generation, ws)
+        return
+      }
+
+      default: {
+        this.emitter.emit('slack_event', envelope)
+      }
+    }
+  }
+
+  private dispatchEventsApi(envelope: SlackSocketModeEventsApiEnvelope, generation: number, ws: WebSocket): void {
+    const event = envelope.payload?.event as SlackSocketModeGenericEvent | undefined
+    if (!event?.type) return
+
+    const ack = this.makeAck(envelope.envelope_id, generation, ws)
+    const args: SlackSocketModeEventsApiArgs = {
+      ack,
+      envelope_id: envelope.envelope_id,
+      body: envelope.payload,
+      event,
+      retry_num: envelope.retry_attempt,
+      retry_reason: envelope.retry_reason,
+      accepts_response_payload: envelope.accepts_response_payload,
+    }
+
+    this.emitter.emit(event.type, args)
+    this.emitter.emit('slack_event', args)
+  }
+
+  private dispatchSlashCommand(envelope: SlackSocketModeSlashCommandEnvelope, generation: number, ws: WebSocket): void {
+    const ack = this.makeAck(envelope.envelope_id, generation, ws)
+    const args: SlackSocketModeSlashCommandArgs = {
+      ack,
+      envelope_id: envelope.envelope_id,
+      body: envelope.payload,
+      accepts_response_payload: envelope.accepts_response_payload,
+    }
+    this.emitter.emit('slash_commands', args)
+  }
+
+  private dispatchInteractive(envelope: SlackSocketModeInteractiveEnvelope, generation: number, ws: WebSocket): void {
+    const ack = this.makeAck(envelope.envelope_id, generation, ws)
+    const args: SlackSocketModeInteractiveArgs = {
+      ack,
+      envelope_id: envelope.envelope_id,
+      body: envelope.payload,
+      accepts_response_payload: envelope.accepts_response_payload,
+    }
+    this.emitter.emit('interactive', args)
+  }
+
+  private makeAck(envelopeId: string, generation: number, ws: WebSocket): SlackSocketModeAck {
+    let acked = false
+    return (responsePayload?: Record<string, unknown>) => {
+      if (acked) return
+      acked = true
+      if (!this.isCurrent(generation, ws)) return
+      if (ws.readyState !== WebSocket.OPEN) return
+      const message =
+        responsePayload === undefined
+          ? { envelope_id: envelopeId }
+          : { envelope_id: envelopeId, payload: responsePayload }
+      ws.send(JSON.stringify(message))
+    }
+  }
+
+  private armHelloTimeout(generation: number, ws: WebSocket): void {
+    this.clearHelloTimer()
+    this.helloTimer = setTimeout(() => {
+      this.helloTimer = null
+      if (!this.isCurrent(generation, ws)) return
+      ws.close()
+    }, HELLO_TIMEOUT)
+  }
+
+  private clearHelloTimer(): void {
+    if (this.helloTimer) {
+      clearTimeout(this.helloTimer)
+      this.helloTimer = null
+    }
+  }
+
+  private startPing(generation: number, ws: WebSocket): void {
+    this.clearPingTimers()
+    this.pingTimer = setInterval(() => {
+      if (!this.isCurrent(generation, ws)) {
+        this.clearPingTimers()
+        return
+      }
+      if (ws.readyState !== WebSocket.OPEN) return
+
+      ws.ping()
+
+      this.clearPongTimer()
+      this.pongTimer = setTimeout(() => {
+        if (!this.isCurrent(generation, ws)) return
+        ws.close()
+      }, PONG_TIMEOUT)
+    }, PING_INTERVAL)
+  }
+
+  private scheduleReconnect(): void {
+    const exponential = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
+    const delay = Math.max(exponential, this.nextReconnectFloorMs)
+    this.nextReconnectFloorMs = 0
+    this.reconnectAttempts++
+    const generation = this.generation
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect(generation)
+    }, delay)
+  }
+
+  private clearPongTimer(): void {
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer)
+      this.pongTimer = null
+    }
+  }
+
+  private clearPingTimers(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer)
+      this.pingTimer = null
+    }
+    this.clearPongTimer()
+  }
+
+  private clearTimers(): void {
+    this.clearPingTimers()
+    this.clearHelloTimer()
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+}

package/src/platforms/slackbot/types.ts

@@ -30,11 +30,13 @@ export interface SlackBotConfig {
 // Error class for SlackBot operations
 export class SlackBotError extends Error {
   code: string
+  retryAfter?: number
 
-  constructor(message: string, code: string) {
+  constructor(message: string, code: string, retryAfter?: number) {
     super(message)
     this.name = 'SlackBotError'
     this.code = code
+    if (retryAfter !== undefined) this.retryAfter = retryAfter
   }
 }
 
@@ -221,3 +223,224 @@ export const SlackFileSchema = z.object({
   user: z.string(),
   channels: z.array(z.string()).optional(),
 })
+
+// Socket Mode envelope types — see https://api.slack.com/apis/socket-mode
+
+export interface SlackSocketModeHelloEnvelope {
+  type: 'hello'
+  connection_info?: { app_id: string }
+  num_connections?: number
+  debug_info?: {
+    host?: string
+    started?: string
+    build_number?: number
+    approximate_connection_time?: number
+  }
+}
+
+export type SlackSocketModeDisconnectReason = 'warning' | 'refresh_requested' | 'link_disabled' | string
+
+export interface SlackSocketModeDisconnectEnvelope {
+  type: 'disconnect'
+  reason: SlackSocketModeDisconnectReason
+  debug_info?: {
+    host?: string
+  }
+}
+
+export interface SlackSocketModeEventsApiEnvelope {
+  type: 'events_api'
+  envelope_id: string
+  payload: {
+    token?: string
+    team_id?: string
+    api_app_id?: string
+    event: SlackSocketModeEvent
+    type?: 'event_callback' | string
+    event_id?: string
+    event_time?: number
+    [key: string]: unknown
+  }
+  accepts_response_payload?: boolean
+  retry_attempt?: number
+  retry_reason?: string
+}
+
+export interface SlackSocketModeSlashCommandEnvelope {
+  type: 'slash_commands'
+  envelope_id: string
+  payload: {
+    command: string
+    text: string
+    user_id: string
+    user_name?: string
+    channel_id: string
+    channel_name?: string
+    team_id: string
+    team_domain?: string
+    api_app_id?: string
+    response_url?: string
+    trigger_id?: string
+    [key: string]: unknown
+  }
+  accepts_response_payload?: boolean
+}
+
+export interface SlackSocketModeInteractiveEnvelope {
+  type: 'interactive'
+  envelope_id: string
+  payload: {
+    type: string
+    user?: { id: string; username?: string; name?: string; team_id?: string }
+    api_app_id?: string
+    token?: string
+    trigger_id?: string
+    response_url?: string
+    actions?: Array<Record<string, unknown>>
+    view?: Record<string, unknown>
+    [key: string]: unknown
+  }
+  accepts_response_payload?: boolean
+}
+
+export interface SlackSocketModeGenericEnvelope {
+  type: string
+  envelope_id?: string
+  payload?: Record<string, unknown>
+  accepts_response_payload?: boolean
+  [key: string]: unknown
+}
+
+export type SlackSocketModeEnvelope =
+  | SlackSocketModeHelloEnvelope
+  | SlackSocketModeDisconnectEnvelope
+  | SlackSocketModeEventsApiEnvelope
+  | SlackSocketModeSlashCommandEnvelope
+  | SlackSocketModeInteractiveEnvelope
+  | SlackSocketModeGenericEnvelope
+
+// Inner Events API event lives at `payload.event` — see SlackSocketModeEventsApiEnvelope.
+
+export interface SlackSocketModeMessageEvent {
+  type: 'message'
+  subtype?: string
+  channel: string
+  channel_type?: string
+  user?: string
+  bot_id?: string
+  text?: string
+  ts: string
+  thread_ts?: string
+  event_ts?: string
+  edited?: { user: string; ts: string }
+  hidden?: boolean
+  [key: string]: unknown
+}
+
+export interface SlackSocketModeAppMentionEvent {
+  type: 'app_mention'
+  channel: string
+  user: string
+  text: string
+  ts: string
+  thread_ts?: string
+  event_ts?: string
+  [key: string]: unknown
+}
+
+export interface SlackSocketModeReactionEvent {
+  type: 'reaction_added' | 'reaction_removed'
+  user: string
+  reaction: string
+  item: { type: string; channel: string; ts: string }
+  item_user?: string
+  event_ts: string
+  [key: string]: unknown
+}
+
+export interface SlackSocketModeMemberChannelEvent {
+  type: 'member_joined_channel' | 'member_left_channel'
+  user: string
+  channel: string
+  channel_type?: string
+  team?: string
+  event_ts?: string
+  [key: string]: unknown
+}
+
+export interface SlackSocketModeChannelEvent {
+  type:
+    | 'channel_created'
+    | 'channel_deleted'
+    | 'channel_rename'
+    | 'channel_archive'
+    | 'channel_unarchive'
+    | 'channel_left'
+  channel: { id: string; name?: string } | string
+  event_ts?: string
+  [key: string]: unknown
+}
+
+export interface SlackSocketModeGenericEvent {
+  type: string
+  [key: string]: unknown
+}
+
+export type SlackSocketModeEvent =
+  | SlackSocketModeMessageEvent
+  | SlackSocketModeAppMentionEvent
+  | SlackSocketModeReactionEvent
+  | SlackSocketModeMemberChannelEvent
+  | SlackSocketModeChannelEvent
+  | SlackSocketModeGenericEvent
+
+// Acknowledgment callback. Without args sends `{ envelope_id }`; with args sends
+// `{ envelope_id, payload }` (for `accepts_response_payload: true` envelopes).
+export type SlackSocketModeAck = (responsePayload?: Record<string, unknown>) => void
+
+export interface SlackSocketModeEventsApiArgs<E extends SlackSocketModeEvent = SlackSocketModeEvent> {
+  ack: SlackSocketModeAck
+  envelope_id: string
+  body: SlackSocketModeEventsApiEnvelope['payload']
+  event: E
+  retry_num?: number
+  retry_reason?: string
+  accepts_response_payload?: boolean
+}
+
+export interface SlackSocketModeSlashCommandArgs {
+  ack: SlackSocketModeAck
+  envelope_id: string
+  body: SlackSocketModeSlashCommandEnvelope['payload']
+  accepts_response_payload?: boolean
+}
+
+export interface SlackSocketModeInteractiveArgs {
+  ack: SlackSocketModeAck
+  envelope_id: string
+  body: SlackSocketModeInteractiveEnvelope['payload']
+  accepts_response_payload?: boolean
+}
+
+export interface SlackBotListenerEventMap {
+  connected: [info: { app_id?: string; num_connections?: number }]
+  disconnected: []
+  error: [error: Error]
+
+  message: [args: SlackSocketModeEventsApiArgs<SlackSocketModeMessageEvent>]
+  app_mention: [args: SlackSocketModeEventsApiArgs<SlackSocketModeAppMentionEvent>]
+  reaction_added: [args: SlackSocketModeEventsApiArgs<SlackSocketModeReactionEvent>]
+  reaction_removed: [args: SlackSocketModeEventsApiArgs<SlackSocketModeReactionEvent>]
+  member_joined_channel: [args: SlackSocketModeEventsApiArgs<SlackSocketModeMemberChannelEvent>]
+  member_left_channel: [args: SlackSocketModeEventsApiArgs<SlackSocketModeMemberChannelEvent>]
+  channel_created: [args: SlackSocketModeEventsApiArgs<SlackSocketModeChannelEvent>]
+  channel_deleted: [args: SlackSocketModeEventsApiArgs<SlackSocketModeChannelEvent>]
+  channel_rename: [args: SlackSocketModeEventsApiArgs<SlackSocketModeChannelEvent>]
+  channel_archive: [args: SlackSocketModeEventsApiArgs<SlackSocketModeChannelEvent>]
+  channel_unarchive: [args: SlackSocketModeEventsApiArgs<SlackSocketModeChannelEvent>]
+
+  slash_commands: [args: SlackSocketModeSlashCommandArgs]
+  interactive: [args: SlackSocketModeInteractiveArgs]
+
+  slack_event: [args: SlackSocketModeEventsApiArgs<SlackSocketModeGenericEvent> | SlackSocketModeGenericEnvelope]
+}

package/src/platforms/teams/commands/auth.test.ts

@@ -16,7 +16,7 @@ let clientGetRegionSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   extractorExtractSpy = spyOn(TeamsTokenExtractor.prototype, 'extract').mockResolvedValue([
-    { token: 'test-skype-token-123', accountType: 'work' as const },
+    { token: 'test-skype-token-123', accountType: 'work' as const, accountTypeKnown: true },
   ])
 
   clientTestAuthSpy = spyOn(TeamsClient.prototype, 'testAuth').mockResolvedValue({