agent-messenger 2.10.2 → 2.11.1

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/commands/auth.ts

@@ -4,6 +4,7 @@ import { Writable } from 'node:stream'
 
 import { Command } from 'commander'
 
+import { collectBrowserProfileOption } from '@/shared/chromium'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { info, warn, error as stderrError, debug } from '@/shared/utils/stderr'
@@ -385,11 +386,12 @@ async function useAction(accountId: string, options: { pretty?: boolean }): Prom
   }
 }
 
-async function extractAction(options: { pretty?: boolean; debug?: boolean }): Promise<void> {
+async function extractAction(options: { pretty?: boolean; debug?: boolean; browserProfile?: string[] }): Promise<void> {
   try {
     const extractor = new InstagramTokenExtractor(
       undefined,
       options.debug ? (msg) => debug(`[debug] ${msg}`) : undefined,
+      options.browserProfile,
     )
 
     if (options.debug) {
@@ -536,6 +538,12 @@ export const authCommand = new Command('auth')
       .description('Extract Instagram cookies from browser (Chrome, Edge, Arc, Brave)')
       .option('--pretty', 'Pretty print JSON output')
       .option('--debug', 'Show debug output')
+      .option(
+        '--browser-profile <path>',
+        'Additional Chromium profile/user-data directory to scan (repeatable, comma-separated supported)',
+        collectBrowserProfileOption,
+        [],
+      )
       .action(extractAction),
   )
   .addCommand(

package/src/platforms/instagram/token-extractor.ts

@@ -10,6 +10,7 @@ import {
   discoverBrowserProfileDirs,
   findLocalStatePath,
   getBrowserBasePath,
+  getAgentBrowserProfileDirs,
 } from '@/shared/chromium'
 import type { KeychainVariant } from '@/shared/chromium'
 
@@ -30,10 +31,12 @@ export class InstagramTokenExtractor {
   private debugLog: ((message: string) => void) | null
   private decryptor: ChromiumCookieDecryptor
   private cookieReader: ChromiumCookieReader
+  private customBrowserProfileDirs: string[]
 
-  constructor(platform?: NodeJS.Platform, debugLog?: (message: string) => void) {
+  constructor(platform?: NodeJS.Platform, debugLog?: (message: string) => void, customBrowserProfileDirs?: string[]) {
     this.platform = platform ?? process.platform
     this.debugLog = debugLog ?? null
+    this.customBrowserProfileDirs = customBrowserProfileDirs ?? []
     this.decryptor = new ChromiumCookieDecryptor({ platform: this.platform })
     this.cookieReader = new ChromiumCookieReader()
   }
@@ -52,6 +55,11 @@ export class InstagramTokenExtractor {
       }
     }
 
+    for (const profileDir of getAgentBrowserProfileDirs({ customProfileDirs: this.customBrowserProfileDirs })) {
+      paths.push(join(profileDir, 'Cookies'))
+      paths.push(join(profileDir, 'Network', 'Cookies'))
+    }
+
     return paths
   }
 
@@ -65,6 +73,10 @@ export class InstagramTokenExtractor {
       paths.push(join(browserBase, 'Local State'))
     }
 
+    for (const profileDir of getAgentBrowserProfileDirs({ customProfileDirs: this.customBrowserProfileDirs })) {
+      paths.push(join(profileDir, 'Local State'))
+    }
+
     return paths
   }
 

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

@@ -1,5 +1,7 @@
 import { Command } from 'commander'
 
+import { collectBrowserProfileOption } from '@/shared/chromium'
+import type { BrowserProfileOption } from '@/shared/chromium'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { debug } from '@/shared/utils/stderr'
@@ -19,13 +21,14 @@ async function extractAction(options: {
   pretty?: boolean
   debug?: boolean
   unsafelyShowSecrets?: boolean
+  browserProfile?: string[]
 }): Promise<void> {
   try {
     if (options.unsafelyShowSecrets) {
       options.debug = true
     }
     const debugLog = options.debug ? (msg: string) => debug(`[debug] ${msg}`) : undefined
-    const extractor = new TokenExtractor(undefined, undefined, undefined, debugLog)
+    const extractor = new TokenExtractor(undefined, undefined, undefined, debugLog, options.browserProfile)
 
     if (process.platform === 'darwin') {
       console.log('')
@@ -246,8 +249,14 @@ export const authCommand = new Command('auth')
       .description('Extract tokens from Slack 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,
+        [],
+      )
       .option('--unsafely-show-secrets', 'Show full token and cookie values in debug output')
-      .action(extractAction),
+      .action((options: BrowserProfileOption & Parameters<typeof extractAction>[0]) => extractAction(options)),
   )
   .addCommand(
     new Command('logout')