agent-messenger 2.10.2 → 2.11.0

package/src/platforms/channeltalkbot/commands/bot.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { WorkspaceOption } from './shared'
 import { getClient } from './shared'
@@ -89,11 +89,6 @@ export async function deleteAction(botId: string, options: BotOptions): Promise<
   }
 }
 
-function cliOutput(result: BotResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const botCommand = new Command('bot')
   .description('Bot management commands')
   .addCommand(

package/src/platforms/channeltalkbot/commands/chat.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { WorkspaceOption } from './shared'
 import { getClient, getDefaultBotName } from './shared'
@@ -120,11 +120,6 @@ export async function deleteAction(chatId: string, options: ChatOptions): Promis
   }
 }
 
-function cliOutput(result: ChatResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const chatCommand = new Command('chat')
   .description('UserChat management commands')
   .addCommand(

package/src/platforms/channeltalkbot/commands/group.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { WorkspaceOption } from './shared'
 import { getClient } from './shared'
@@ -93,11 +93,6 @@ export async function messagesAction(group: string, options: GroupOptions): Prom
   }
 }
 
-function cliOutput(result: GroupResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const groupCommand = new Command('group')
   .description('Group management commands')
   .addCommand(

package/src/platforms/channeltalkbot/commands/manager.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { WorkspaceOption } from './shared'
 import { getClient } from './shared'
@@ -68,11 +68,6 @@ export async function getAction(managerId: string, options: ManagerOptions): Pro
   }
 }
 
-function cliOutput(result: ManagerResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const managerCommand = new Command('manager')
   .description('Manager commands')
   .addCommand(

package/src/platforms/channeltalkbot/commands/message.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import { wrapTextInBlocks } from '../message-utils'
 import type { WorkspaceOption } from './shared'
@@ -140,11 +140,6 @@ function detectTargetType(target: string): 'userchat' | 'group' {
   return 'userchat'
 }
 
-function cliOutput(result: MessageResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const messageCommand = new Command('message')
   .description('Message commands')
   .addCommand(

package/src/platforms/channeltalkbot/commands/whoami.test.ts

@@ -35,6 +35,8 @@ describe('whoami command', () => {
     originalEnv = { ...process.env }
     delete process.env.E2E_CHANNELBOT_ACCESS_KEY
     delete process.env.E2E_CHANNELBOT_ACCESS_SECRET
+    delete process.env.E2E_CHANNELTALKBOT_ACCESS_KEY
+    delete process.env.E2E_CHANNELTALKBOT_ACCESS_SECRET
     mockGetChannel.mockClear()
   })
 

package/src/platforms/channeltalkbot/commands/whoami.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { WorkspaceOption } from './shared'
 import { getClient } from './shared'
@@ -28,11 +28,6 @@ export async function whoamiAction(options: WorkspaceOption): Promise<WhoamiResu
   }
 }
 
-function cliOutput(result: WhoamiResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const whoamiCommand = new Command('whoami')
   .description('Show current authenticated bot')
   .option('--workspace <id>', 'Workspace ID to use')

package/src/platforms/channeltalkbot/credential-manager.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
 import { existsSync, rmSync } from 'node:fs'
-import { mkdir, stat } from 'node:fs/promises'
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
@@ -36,6 +36,8 @@ describe('ChannelBotCredentialManager', () => {
     }
     delete process.env.E2E_CHANNELBOT_ACCESS_KEY
     delete process.env.E2E_CHANNELBOT_ACCESS_SECRET
+    delete process.env.E2E_CHANNELTALKBOT_ACCESS_KEY
+    delete process.env.E2E_CHANNELTALKBOT_ACCESS_SECRET
   })
 
   describe('load', () => {
@@ -299,10 +301,102 @@ describe('ChannelBotCredentialManager', () => {
     it('saves file with secure permissions (600)', async () => {
       await manager.setCredentials(WORKSPACE_A)
 
-      const credPath = join(tempDir, 'channelbot-credentials.json')
+      const credPath = join(tempDir, 'channeltalkbot-credentials.json')
       const stats = await stat(credPath)
 
       expect(stats.mode & 0o777).toBe(0o600)
     })
   })
+
+  describe('legacy filename migration', () => {
+    it('renames channelbot-credentials.json to channeltalkbot-credentials.json on load', async () => {
+      const legacyPath = join(tempDir, 'channelbot-credentials.json')
+      const newPath = join(tempDir, 'channeltalkbot-credentials.json')
+      const legacyConfig = {
+        current: { workspace_id: WORKSPACE_A.workspace_id },
+        workspaces: { [WORKSPACE_A.workspace_id]: WORKSPACE_A },
+        default_bot: null,
+      }
+      await writeFile(legacyPath, JSON.stringify(legacyConfig))
+
+      const config = await manager.load()
+
+      expect(config.workspaces[WORKSPACE_A.workspace_id]).toEqual(WORKSPACE_A)
+      expect(existsSync(legacyPath)).toBe(false)
+      expect(existsSync(newPath)).toBe(true)
+      const migrated = JSON.parse(await readFile(newPath, 'utf-8'))
+      expect(migrated.workspaces[WORKSPACE_A.workspace_id]).toEqual(WORKSPACE_A)
+    })
+
+    it('does not overwrite an existing channeltalkbot-credentials.json', async () => {
+      const legacyPath = join(tempDir, 'channelbot-credentials.json')
+      const newPath = join(tempDir, 'channeltalkbot-credentials.json')
+      await writeFile(legacyPath, JSON.stringify({ workspaces: { stale: WORKSPACE_A } }))
+      const newConfig = {
+        current: { workspace_id: WORKSPACE_B.workspace_id },
+        workspaces: { [WORKSPACE_B.workspace_id]: WORKSPACE_B },
+        default_bot: null,
+      }
+      await writeFile(newPath, JSON.stringify(newConfig))
+
+      const config = await manager.load()
+
+      expect(config.workspaces[WORKSPACE_B.workspace_id]).toEqual(WORKSPACE_B)
+      expect(config.workspaces['stale']).toBeUndefined()
+      expect(existsSync(legacyPath)).toBe(true)
+    })
+
+    it('does not write back to legacy path when migration fails (no split-brain)', async () => {
+      const legacyPath = join(tempDir, 'channelbot-credentials.json')
+      const newPath = join(tempDir, 'channeltalkbot-credentials.json')
+      await writeFile(legacyPath, JSON.stringify({ workspaces: {}, default_bot: null }))
+
+      // Inject a rename that fails on first call to simulate a concurrent migration losing the race.
+      class FailingMigrationManager extends ChannelBotCredentialManager {
+        constructor(dir: string) {
+          super(dir)
+          let called = false
+          this.renameFile = async () => {
+            if (!called) {
+              called = true
+              throw new Error('ENOENT: simulated concurrent rename winner')
+            }
+          }
+        }
+      }
+      const failingManager = new FailingMigrationManager(tempDir)
+
+      await failingManager.load()
+      await failingManager.setCredentials(WORKSPACE_A)
+
+      // After failure, the manager must write to the NEW path, never re-create the legacy file.
+      expect(existsSync(newPath)).toBe(true)
+      const persisted = JSON.parse(await readFile(newPath, 'utf-8'))
+      expect(persisted.workspaces[WORKSPACE_A.workspace_id]).toEqual(WORKSPACE_A)
+    })
+  })
+
+  describe('env var prefix compatibility', () => {
+    it('prefers E2E_CHANNELTALKBOT_* over E2E_CHANNELBOT_*', async () => {
+      process.env.E2E_CHANNELBOT_ACCESS_KEY = 'old-key'
+      process.env.E2E_CHANNELBOT_ACCESS_SECRET = 'old-secret'
+      process.env.E2E_CHANNELTALKBOT_ACCESS_KEY = 'new-key'
+      process.env.E2E_CHANNELTALKBOT_ACCESS_SECRET = 'new-secret'
+
+      const creds = await manager.getCredentials()
+
+      expect(creds?.access_key).toBe('new-key')
+      expect(creds?.access_secret).toBe('new-secret')
+    })
+
+    it('falls back to E2E_CHANNELBOT_* when E2E_CHANNELTALKBOT_* is unset', async () => {
+      process.env.E2E_CHANNELBOT_ACCESS_KEY = 'legacy-key'
+      process.env.E2E_CHANNELBOT_ACCESS_SECRET = 'legacy-secret'
+
+      const creds = await manager.getCredentials()
+
+      expect(creds?.access_key).toBe('legacy-key')
+      expect(creds?.access_secret).toBe('legacy-secret')
+    })
+  })
 })

package/src/platforms/channeltalkbot/credential-manager.ts

@@ -1,21 +1,30 @@
 import { existsSync } from 'node:fs'
-import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 import type { ChannelBotConfig, ChannelBotCredentials, ChannelBotWorkspaceEntry } from './types'
 import { ChannelBotConfigSchema } from './types'
 
+const LEGACY_FILENAME = 'channelbot-credentials.json'
+const CREDENTIALS_FILENAME = 'channeltalkbot-credentials.json'
+
 export class ChannelBotCredentialManager {
   private configDir: string
   private credentialsPath: string
+  private legacyPath: string
+  private migratedLegacyFile = false
+  protected renameFile: typeof rename = rename
 
   constructor(configDir?: string) {
     this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
-    this.credentialsPath = join(this.configDir, 'channelbot-credentials.json')
+    this.credentialsPath = join(this.configDir, CREDENTIALS_FILENAME)
+    this.legacyPath = join(this.configDir, LEGACY_FILENAME)
   }
 
   async load(): Promise<ChannelBotConfig> {
+    await this.migrateLegacyFileIfNeeded()
+
     if (!existsSync(this.credentialsPath)) {
       return { current: null, workspaces: {}, default_bot: null }
     }
@@ -34,6 +43,30 @@ export class ChannelBotCredentialManager {
     return parsed.data
   }
 
+  private async migrateLegacyFileIfNeeded(): Promise<void> {
+    if (this.migratedLegacyFile) return
+    if (existsSync(this.credentialsPath)) {
+      this.migratedLegacyFile = true
+      return
+    }
+    if (!existsSync(this.legacyPath)) {
+      this.migratedLegacyFile = true
+      return
+    }
+    try {
+      await this.renameFile(this.legacyPath, this.credentialsPath)
+      process.stderr.write(
+        `[agent-channeltalkbot] Migrated credentials: ${LEGACY_FILENAME} -> ${CREDENTIALS_FILENAME}\n`,
+      )
+    } catch {
+      // Rename failed. If a concurrent process succeeded, the new file now exists — use it.
+      // Otherwise (real failure: permissions, etc.) keep the new path; load() will return
+      // empty config and the user can re-run `auth set`. Never fall back to writing the
+      // legacy path, which would resurrect the split-brain we are migrating away from.
+    }
+    this.migratedLegacyFile = true
+  }
+
   async save(config: ChannelBotConfig): Promise<void> {
     await mkdir(this.configDir, { recursive: true })
     await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
@@ -41,8 +74,8 @@ export class ChannelBotCredentialManager {
   }
 
   async getCredentials(workspaceId?: string): Promise<ChannelBotCredentials | null> {
-    const envAccessKey = process.env.E2E_CHANNELBOT_ACCESS_KEY
-    const envAccessSecret = process.env.E2E_CHANNELBOT_ACCESS_SECRET
+    const envAccessKey = process.env.E2E_CHANNELTALKBOT_ACCESS_KEY ?? process.env.E2E_CHANNELBOT_ACCESS_KEY
+    const envAccessSecret = process.env.E2E_CHANNELTALKBOT_ACCESS_SECRET ?? process.env.E2E_CHANNELBOT_ACCESS_SECRET
 
     if (envAccessKey && envAccessSecret && !workspaceId) {
       return {

package/src/platforms/discord/commands/auth.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander'
 
+import { collectBrowserProfileOption } from '@/shared/chromium'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { debug } from '@/shared/utils/stderr'
@@ -8,9 +9,13 @@ import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 import { DiscordTokenExtractor } from '../token-extractor'
 
-export async function extractAction(options: { pretty?: boolean; debug?: boolean }): Promise<void> {
+export async function extractAction(options: {
+  pretty?: boolean
+  debug?: boolean
+  browserProfile?: string[]
+}): Promise<void> {
   try {
-    const extractor = new DiscordTokenExtractor()
+    const extractor = new DiscordTokenExtractor(undefined, undefined, undefined, undefined, options.browserProfile)
 
     if (process.platform === 'darwin') {
       console.log('')
@@ -195,6 +200,12 @@ export const authCommand = new Command('auth')
       .description('Extract token from Discord desktop app or a supported Chromium browser')
       .option('--pretty', 'Pretty print JSON output')
       .option('--debug', 'Show debug output for troubleshooting')
+      .option(
+        '--browser-profile <path>',
+        'Additional Chromium profile/user-data directory to scan (repeatable, comma-separated supported)',
+        collectBrowserProfileOption,
+        [],
+      )
       .action(extractAction),
   )
   .addCommand(

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

@@ -16,12 +16,16 @@ let mockWsInstance: MockWs
 class MockWs {
   static OPEN = 1
   static CLOSED = 3
+  static lastUrl: string | null = null
   readyState = MockWs.OPEN
 
   private handlers = new Map<string, WsHandler[]>()
   sent: string[] = []
+  url: string
 
-  constructor(_url: string, _options?: any) {
+  constructor(url: string, _options?: any) {
+    this.url = url
+    MockWs.lastUrl = url
     // oxlint-disable-next-line typescript-eslint/no-this-alias
     mockWsInstance = this
   }
@@ -785,4 +789,58 @@ describe('DiscordListener', () => {
       expect((listener as any).reconnectAttempts).toBe(0)
     })
   })
+
+  describe('reconnect URL', () => {
+    it('appends ?v=10&encoding=json to resume_gateway_url on reconnect', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      await listener.start()
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateHello()
+      mockWsInstance.simulateMessage({
+        op: 0,
+        t: 'READY',
+        s: 1,
+        d: {
+          session_id: 'session_xyz',
+          resume_gateway_url: 'wss://gateway-us-east1-b.discord.gg',
+          user: { id: 'U_SELF', username: 'user' },
+        },
+      })
+
+      mockWsInstance.simulateClose()
+      await new Promise((r) => setTimeout(r, 1500))
+
+      expect(MockWs.lastUrl).toBe('wss://gateway-us-east1-b.discord.gg?v=10&encoding=json')
+    })
+  })
+
+  describe('reconnectAttempts deferred to READY/RESUMED', () => {
+    it('does not reset reconnectAttempts on socket open alone', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+
+      mockWsInstance.simulateOpen()
+
+      expect((listener as any).reconnectAttempts).toBe(5)
+    })
+
+    it('resets reconnectAttempts on READY dispatch', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+
+      mockWsInstance.simulateOpen()
+      mockWsInstance.simulateHello()
+      mockWsInstance.simulateReady()
+
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+  })
 })

package/src/platforms/discord/listener.ts

@@ -7,6 +7,7 @@ import type { DiscordListenerEventMap, DiscordGatewayGenericEvent } from './type
 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]
@@ -40,6 +41,7 @@ export class DiscordListener {
   private resumeGatewayUrl: string | null = null
   private token: string | null = null
   private cachedUser: { id: string; username: string } | null = null
+  private generation = 0
 
   constructor(client: DiscordClient, options?: { intents?: number }) {
     this.client = client
@@ -50,11 +52,13 @@ export class DiscordListener {
     if (this.running) return
     this.running = true
     this.reconnectAttempts = 0
-    await this.connect()
+    this.generation++
+    await this.connect(this.generation)
   }
 
   stop(): void {
     this.running = false
+    this.generation++
     this.clearTimers()
     if (this.ws) {
       this.ws.close()
@@ -82,39 +86,46 @@ export class DiscordListener {
     return this
   }
 
-  private async connect(): Promise<void> {
-    if (!this.running) return
+  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.running) return
+      if (!this.isCurrent(generation)) return
 
       this.token = token
 
-      const url = this.resumeGatewayUrl ?? GATEWAY_URL
+      const url = this.resumeGatewayUrl ? `${this.resumeGatewayUrl}${GATEWAY_QUERY}` : GATEWAY_URL
       const ws = new WebSocket(url)
       this.ws = ws
 
       ws.on('open', () => {
-        if (!this.running) {
+        if (!this.isCurrent(generation, ws)) {
           ws.close()
           return
         }
-        this.reconnectAttempts = 0
       })
 
       ws.on('message', (raw) => {
+        if (!this.isCurrent(generation, ws)) return
         try {
           const data = JSON.parse(raw.toString())
-          this.handleMessage(data)
+          this.handleMessage(data, generation, ws)
         } catch {
-          // malformed message, ignore
+          // malformed gateway frame; ignore and let heartbeat handle liveness
         }
       })
 
       ws.on('close', (code) => {
+        if (!this.isCurrent(generation, ws)) return
         this.clearTimers()
-        if (this.ws === ws) this.ws = null
+        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
@@ -132,9 +143,11 @@ export class DiscordListener {
       })
 
       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()
@@ -142,12 +155,13 @@ export class DiscordListener {
     }
   }
 
-  private handleMessage(data: { op: number; d: any; s?: number; t?: string }): void {
+  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)
+        this.startHeartbeat(d.heartbeat_interval, generation, ws)
         if (this.sessionId) {
           this.sendResume()
         } else {
@@ -166,22 +180,21 @@ export class DiscordListener {
 
       case DiscordGatewayOpcode.Reconnect:
         this.reconnectAttempts = 0
-        this.ws?.close()
+        ws.close()
         break
 
       case DiscordGatewayOpcode.InvalidSession: {
-        const currentWs = this.ws
         if (d === true) {
           const delay = 1000 + Math.random() * 4000
           this.invalidSessionTimer = setTimeout(() => {
             this.invalidSessionTimer = null
-            if (currentWs && currentWs === this.ws) currentWs.close()
+            if (this.isCurrent(generation, ws)) ws.close()
           }, delay)
         } else {
           this.sequence = null
           this.sessionId = null
           this.resumeGatewayUrl = null
-          currentWs?.close()
+          ws.close()
         }
         break
       }
@@ -197,11 +210,13 @@ export class DiscordListener {
       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
     }
@@ -246,18 +261,23 @@ export class DiscordListener {
     this.ws?.send(JSON.stringify({ op: DiscordGatewayOpcode.Heartbeat, d: this.sequence }))
   }
 
-  private startHeartbeat(interval: number): void {
+  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) {
-          this.ws?.close()
+          ws.close()
           return
         }
         this.heartbeatAckReceived = false
@@ -269,7 +289,11 @@ export class DiscordListener {
   private scheduleReconnect(): void {
     const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
     this.reconnectAttempts++
-    this.reconnectTimer = setTimeout(() => this.connect(), delay)
+    const generation = this.generation
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect(generation)
+    }, delay)
   }
 
   private clearHeartbeatTimers(): void {