agent-messenger 2.26.0 → 2.27.1

package/src/platforms/discord/listener.ts

@@ -4,7 +4,7 @@ import WebSocket from 'ws'
 
 import type { DiscordClient } from './client'
 import type { DiscordListenerEventMap, DiscordGatewayGenericEvent } from './types'
-import { DiscordGatewayOpcode, DiscordIntent } from './types'
+import { DiscordGatewayOpcode } from './types'
 
 const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'
 const GATEWAY_QUERY = '?v=10&encoding=json'
@@ -13,20 +13,35 @@ 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
+// Hello arrives within milliseconds and READY within a few seconds on a healthy gateway;
+// 15s is generous for a successful handshake while still failing fast on bad tokens,
+// network stalls, or a gateway that accepts the socket but never delivers READY.
+const DEFAULT_CONNECT_TIMEOUT_MS = 15_000
+
+// User (non-bot) gateway capabilities bitmask, mirroring discord.py-self's default set.
+// Capabilities shape the READY payload; bit 10 (client_state_v2) requires client_state.guild_versions.
+const USER_GATEWAY_CAPABILITIES = 16381
+
+// Without MESSAGE_CONTENT (1<<15), Discord blanks `content`/`embeds`/`attachments` on messages
+// from OTHER users (self/DM/mention content still arrives). User sessions get all intents only
+// when `intents` is omitted OR explicitly set, so we send an all-intents value to guarantee content.
+const USER_GATEWAY_INTENTS = 33_554_431
+
+// Discord validates client_build_number against recent web-client builds; a stale value can
+// yield a connected-but-degraded session that fires READY yet delivers no message events.
+// Overridable via env so it can be refreshed without a release when it eventually goes stale.
+const DEFAULT_CLIENT_BUILD_NUMBER = 648814
+const USER_GATEWAY_BUILD_NUMBER = Number(process.env.AGENT_DISCORD_BUILD_NUMBER) || DEFAULT_CLIENT_BUILD_NUMBER
 
 type EventKey = keyof DiscordListenerEventMap
 
+export interface DiscordListenerOptions {
+  connectTimeoutMs?: number
+}
+
 export class DiscordListener {
   private client: DiscordClient
-  private intents: number
+  private connectTimeoutMs: number
   private running = false
   private ws: WebSocket | null = null
   private emitter = new EventEmitter()
@@ -35,6 +50,7 @@ export class DiscordListener {
   private heartbeatJitterTimer: ReturnType<typeof setTimeout> | null = null
   private invalidSessionTimer: ReturnType<typeof setTimeout> | null = null
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private connectTimeoutTimer: ReturnType<typeof setTimeout> | null = null
   private reconnectAttempts = 0
   private sequence: number | null = null
   private sessionId: string | null = null
@@ -42,24 +58,90 @@ export class DiscordListener {
   private token: string | null = null
   private cachedUser: { id: string; username: string } | null = null
   private generation = 0
+  private startPromise: Promise<void> | null = null
+  private pendingStartReject: ((error: Error) => void) | null = null
 
-  constructor(client: DiscordClient, options?: { intents?: number }) {
+  constructor(client: DiscordClient, options?: DiscordListenerOptions) {
     this.client = client
-    this.intents = options?.intents ?? DEFAULT_INTENTS
+    this.connectTimeoutMs = options?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS
   }
 
   async start(): Promise<void> {
+    if (this.startPromise) return this.startPromise
     if (this.running) return
+
     this.running = true
     this.reconnectAttempts = 0
-    this.generation++
-    await this.connect(this.generation)
+    const generation = ++this.generation
+
+    const ready = new Promise<void>((resolve, reject) => {
+      let settled = false
+
+      const cleanup = () => {
+        this.emitter.off('connected', onConnected)
+        this.emitter.off('error', onError)
+        this.pendingStartReject = null
+        if (this.connectTimeoutTimer) {
+          clearTimeout(this.connectTimeoutTimer)
+          this.connectTimeoutTimer = null
+        }
+      }
+
+      const onConnected = () => {
+        if (settled || !this.isCurrent(generation)) return
+        settled = true
+        cleanup()
+        resolve()
+      }
+
+      const onError = (error: Error) => {
+        if (settled || !this.isCurrent(generation)) return
+        settled = true
+        cleanup()
+        this.teardownFailedStart(generation)
+        reject(error)
+      }
+
+      this.emitter.once('connected', onConnected)
+      this.emitter.once('error', onError)
+
+      // Generation-agnostic on purpose: stop() invokes this to reject an in-flight start
+      // (after bumping generation) without leaking the once() handlers.
+      this.pendingStartReject = (error: Error) => {
+        if (settled) return
+        settled = true
+        cleanup()
+        reject(error)
+      }
+
+      this.connectTimeoutTimer = setTimeout(() => {
+        onError(new Error(`Discord gateway did not become ready within ${this.connectTimeoutMs}ms`))
+      }, this.connectTimeoutMs)
+    })
+
+    const run = async (): Promise<void> => {
+      try {
+        await Promise.all([this.connect(generation), ready])
+      } finally {
+        if (this.generation === generation) this.startPromise = null
+      }
+    }
+    const startPromise = run()
+    this.startPromise = startPromise
+    return startPromise
   }
 
   stop(): void {
     this.running = false
     this.generation++
     this.clearTimers()
+    if (this.connectTimeoutTimer) {
+      clearTimeout(this.connectTimeoutTimer)
+      this.connectTimeoutTimer = null
+    }
+    const rejectStart = this.pendingStartReject
+    this.pendingStartReject = null
+    this.startPromise = null
     if (this.ws) {
       this.ws.close()
       this.ws = null
@@ -69,6 +151,12 @@ export class DiscordListener {
     this.resumeGatewayUrl = null
     this.token = null
     this.cachedUser = null
+    rejectStart?.(new Error('Discord gateway start was stopped before becoming ready'))
+  }
+
+  private teardownFailedStart(generation: number): void {
+    if (!this.isCurrent(generation)) return
+    this.stop()
   }
 
   on<K extends EventKey>(event: K, listener: (...args: DiscordListenerEventMap[K]) => void): this {
@@ -233,12 +321,28 @@ export class DiscordListener {
         op: DiscordGatewayOpcode.Identify,
         d: {
           token: this.token,
-          intents: this.intents,
+          capabilities: USER_GATEWAY_CAPABILITIES,
+          intents: USER_GATEWAY_INTENTS,
           properties: {
-            os: 'linux',
-            browser: 'agent-messenger',
-            device: 'agent-messenger',
+            os: 'Linux',
+            browser: 'Chrome',
+            device: '',
+            system_locale: 'en-US',
+            browser_user_agent:
+              'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            browser_version: '131.0.0.0',
+            os_version: '',
+            referrer: '',
+            referring_domain: '',
+            referrer_current: '',
+            referring_domain_current: '',
+            release_channel: 'stable',
+            client_build_number: USER_GATEWAY_BUILD_NUMBER,
+            client_event_source: null,
           },
+          presence: { status: 'online', since: 0, activities: [], afk: false },
+          compress: false,
+          client_state: { guild_versions: {} },
         },
       }),
     )