agent-messenger 2.31.0 → 2.32.1

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

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, mock, it } from 'bun:test'
 
-import { DiscordListener } from '@/platforms/discord/listener'
+import { DiscordListener, parseReadStates } from '@/platforms/discord/listener'
 import type {
   DiscordGatewayGenericEvent,
   DiscordGatewayMessageCreateEvent,
@@ -68,7 +68,7 @@ class MockWs {
     this.simulateMessage({ op: 10, d: { heartbeat_interval: interval } })
   }
 
-  simulateReady(sessionId = 'session_123') {
+  simulateReady(sessionId = 'session_123', readState?: unknown) {
     this.simulateMessage({
       op: 0,
       t: 'READY',
@@ -77,6 +77,7 @@ class MockWs {
         session_id: sessionId,
         resume_gateway_url: 'wss://resume.discord.gg',
         user: { id: 'U_SELF', username: 'testbot' },
+        ...(readState === undefined ? {} : { read_state: readState }),
       },
     })
   }
@@ -135,6 +136,33 @@ async function startConnecting(listener: DiscordListener): Promise<MockWs> {
   return ws
 }
 
+describe('parseReadStates', () => {
+  it('filters out non-channel read state types', () => {
+    const result = parseReadStates([
+      { id: 'c1', last_message_id: '100', mention_count: 1 },
+      { id: 'c2', read_state_type: 2, mention_count: 5 },
+    ])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+  })
+
+  it('normalizes missing last_message_id and mention_count', () => {
+    const result = parseReadStates([{ id: 'c1' }])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: null, mentionCount: 0 }])
+  })
+
+  it('skips malformed entries but keeps valid ones', () => {
+    const result = parseReadStates([{ id: 'c1', mention_count: 1 }, { mention_count: 3 }])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: null, mentionCount: 1 }])
+  })
+
+  it('throws on a non-array, non-versioned payload', () => {
+    expect(() => parseReadStates({ foo: 'bar' })).toThrow(/invalid read_state/)
+  })
+})
+
 describe('DiscordListener', () => {
   let listener: DiscordListener
 
@@ -235,6 +263,45 @@ describe('DiscordListener', () => {
     })
   })
 
+  describe('read state', () => {
+    it('captures raw-array read_state from READY', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      const started = listener.start()
+      const ws = await waitForSocket()
+      ws.simulateOpen()
+      ws.simulateHello()
+      ws.simulateReady('session_123', [{ id: 'c1', last_message_id: '100', mention_count: 2 }])
+      await started
+
+      expect(listener.getReadState()).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 2 }])
+    })
+
+    it('captures versioned { entries } read_state from READY', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      const started = listener.start()
+      const ws = await waitForSocket()
+      ws.simulateOpen()
+      ws.simulateHello()
+      ws.simulateReady('session_123', { version: 7, entries: [{ id: 'c1', last_message_id: '100', mention_count: 1 }] })
+      await started
+
+      expect(listener.getReadState()).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+    })
+
+    it('defaults to an empty read state when READY omits read_state', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      await startAndReady(listener)
+
+      expect(listener.getReadState()).toEqual([])
+    })
+  })
+
   describe('identify', () => {
     it('sends Identify after Hello', async () => {
       const client = createMockClient()

package/src/platforms/discord/listener.ts

@@ -3,8 +3,30 @@ import { EventEmitter } from 'events'
 import WebSocket from 'ws'
 
 import type { DiscordClient } from './client'
-import type { DiscordListenerEventMap, DiscordGatewayGenericEvent } from './types'
-import { DiscordGatewayOpcode } from './types'
+import type { DiscordListenerEventMap, DiscordGatewayGenericEvent, DiscordReadState } from './types'
+import { DiscordGatewayOpcode, DiscordRawReadStateSchema, DiscordReadyReadStateSchema } from './types'
+
+export function parseReadStates(value: unknown): DiscordReadState[] {
+  const parsed = DiscordReadyReadStateSchema.safeParse(value)
+  if (!parsed.success) {
+    throw new Error('Discord READY contained an invalid read_state payload')
+  }
+
+  const entries = Array.isArray(parsed.data) ? parsed.data : parsed.data.entries
+
+  const readStates: DiscordReadState[] = []
+  for (const entry of entries) {
+    const state = DiscordRawReadStateSchema.safeParse(entry)
+    if (!state.success) continue
+    if ((state.data.read_state_type ?? 0) !== 0) continue
+    readStates.push({
+      channelId: state.data.id,
+      lastMessageId: state.data.last_message_id ?? null,
+      mentionCount: state.data.mention_count ?? 0,
+    })
+  }
+  return readStates
+}
 
 const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'
 const GATEWAY_QUERY = '?v=10&encoding=json'
@@ -57,6 +79,7 @@ export class DiscordListener {
   private resumeGatewayUrl: string | null = null
   private token: string | null = null
   private cachedUser: { id: string; username: string } | null = null
+  private readState: DiscordReadState[] | null = null
   private generation = 0
   private startPromise: Promise<void> | null = null
   private pendingStartReject: ((error: Error) => void) | null = null
@@ -151,6 +174,7 @@ export class DiscordListener {
     this.resumeGatewayUrl = null
     this.token = null
     this.cachedUser = null
+    this.readState = null
     rejectStart?.(new Error('Discord gateway start was stopped before becoming ready'))
   }
 
@@ -174,6 +198,10 @@ export class DiscordListener {
     return this
   }
 
+  getReadState(): DiscordReadState[] | null {
+    return this.readState
+  }
+
   private isCurrent(generation: number, ws?: WebSocket): boolean {
     if (generation !== this.generation || !this.running) return false
     if (ws !== undefined && this.ws !== ws) return false
@@ -298,6 +326,7 @@ export class DiscordListener {
       this.sessionId = d.session_id
       this.resumeGatewayUrl = d.resume_gateway_url
       this.cachedUser = d.user
+      this.readState = d.read_state === undefined ? [] : parseReadStates(d.read_state)
       this.reconnectAttempts = 0
       this.emitter.emit('connected', { user: d.user, sessionId: d.session_id })
       return

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

@@ -2,6 +2,7 @@ import { expect, it } from 'bun:test'
 
 import {
   DiscordChannelSchema,
+  DiscordChannelType,
   DiscordConfigSchema,
   DiscordCredentialsSchema,
   DiscordError,
@@ -10,6 +11,8 @@ import {
   DiscordMessageSchema,
   DiscordReactionSchema,
   DiscordUserSchema,
+  isListableChannel,
+  isMessageReadableChannel,
 } from './types'
 
 it('DiscordGuildSchema validates correct guild', () => {
@@ -150,6 +153,17 @@ it('DiscordReactionSchema validates reaction with custom emoji', () => {
   expect(result.success).toBe(true)
 })
 
+it('DiscordReactionSchema validates nullable emoji fields', () => {
+  const result = DiscordReactionSchema.safeParse({
+    emoji: {
+      id: null,
+      name: null,
+    },
+    count: 1,
+  })
+  expect(result.success).toBe(true)
+})
+
 it('DiscordReactionSchema rejects missing required fields', () => {
   const result = DiscordReactionSchema.safeParse({
     emoji: {
@@ -244,3 +258,45 @@ it('DiscordError is instance of Error', () => {
   const error = new DiscordError('Test error', 'TEST_CODE')
   expect(error instanceof Error).toBe(true)
 })
+
+it('isListableChannel includes text, announcement, voice, stage, forum, media, and directory', () => {
+  const listable = [
+    DiscordChannelType.GUILD_TEXT,
+    DiscordChannelType.GUILD_ANNOUNCEMENT,
+    DiscordChannelType.GUILD_VOICE,
+    DiscordChannelType.GUILD_STAGE_VOICE,
+    DiscordChannelType.GUILD_FORUM,
+    DiscordChannelType.GUILD_MEDIA,
+    DiscordChannelType.GUILD_DIRECTORY,
+  ]
+  expect(listable.every((type) => isListableChannel({ type }))).toBe(true)
+})
+
+it('isListableChannel excludes categories and threads', () => {
+  const excluded = [
+    DiscordChannelType.GUILD_CATEGORY,
+    DiscordChannelType.ANNOUNCEMENT_THREAD,
+    DiscordChannelType.PUBLIC_THREAD,
+    DiscordChannelType.PRIVATE_THREAD,
+  ]
+  expect(excluded.some((type) => isListableChannel({ type }))).toBe(false)
+})
+
+it('isMessageReadableChannel includes text, announcement, voice, and stage', () => {
+  const readable = [
+    DiscordChannelType.GUILD_TEXT,
+    DiscordChannelType.GUILD_ANNOUNCEMENT,
+    DiscordChannelType.GUILD_VOICE,
+    DiscordChannelType.GUILD_STAGE_VOICE,
+  ]
+  expect(readable.every((type) => isMessageReadableChannel({ type }))).toBe(true)
+})
+
+it('isMessageReadableChannel excludes forum, media, and directory containers', () => {
+  const notReadable = [
+    DiscordChannelType.GUILD_FORUM,
+    DiscordChannelType.GUILD_MEDIA,
+    DiscordChannelType.GUILD_DIRECTORY,
+  ]
+  expect(notReadable.some((type) => isMessageReadableChannel({ type }))).toBe(false)
+})

package/src/platforms/discord/types.ts

@@ -27,6 +27,47 @@ export interface DiscordChannel {
   }
 }
 
+// https://discord.com/developers/docs/resources/channel#channel-object-channel-types
+export const DiscordChannelType = {
+  GUILD_TEXT: 0,
+  DM: 1,
+  GUILD_VOICE: 2,
+  GROUP_DM: 3,
+  GUILD_CATEGORY: 4,
+  GUILD_ANNOUNCEMENT: 5,
+  ANNOUNCEMENT_THREAD: 10,
+  PUBLIC_THREAD: 11,
+  PRIVATE_THREAD: 12,
+  GUILD_STAGE_VOICE: 13,
+  GUILD_DIRECTORY: 14,
+  GUILD_FORUM: 15,
+  GUILD_MEDIA: 16,
+} as const
+
+const THREAD_CHANNEL_TYPES: ReadonlySet<number> = new Set([
+  DiscordChannelType.ANNOUNCEMENT_THREAD,
+  DiscordChannelType.PUBLIC_THREAD,
+  DiscordChannelType.PRIVATE_THREAD,
+])
+
+// Channels with no directly fetchable message timeline:
+// forum/media messages live in child posts/threads, and directory channels
+// are hub listings, not message channels. Fetching messages from these aborts.
+const NON_MESSAGE_CHANNEL_TYPES: ReadonlySet<number> = new Set([
+  DiscordChannelType.GUILD_FORUM,
+  DiscordChannelType.GUILD_MEDIA,
+  DiscordChannelType.GUILD_DIRECTORY,
+])
+
+// Voice/stage channels are listed too because they carry embedded text chat.
+export function isListableChannel(channel: Pick<DiscordChannel, 'type'>): boolean {
+  return channel.type !== DiscordChannelType.GUILD_CATEGORY && !THREAD_CHANNEL_TYPES.has(channel.type)
+}
+
+export function isMessageReadableChannel(channel: Pick<DiscordChannel, 'type'>): boolean {
+  return isListableChannel(channel) && !NON_MESSAGE_CHANNEL_TYPES.has(channel.type)
+}
+
 export interface DiscordMessage {
   id: string
   channel_id: string
@@ -38,6 +79,7 @@ export interface DiscordMessage {
   timestamp: string
   edited_timestamp?: string
   thread_id?: string
+  reactions?: DiscordReaction[]
 }
 
 export interface DiscordUser {
@@ -58,8 +100,8 @@ export interface DiscordDMChannel {
 
 export interface DiscordReaction {
   emoji: {
-    id?: string
-    name: string
+    id?: string | null
+    name: string | null
   }
   count: number
 }
@@ -91,6 +133,26 @@ export interface DiscordUserNote {
   note: string
 }
 
+export interface DiscordReadState {
+  channelId: string
+  lastMessageId: string | null
+  mentionCount: number
+}
+
+export interface DiscordUnreadMention extends DiscordMention {
+  mention_count: number
+}
+
+export interface DiscordUnreadMentionsResult {
+  mentions: DiscordUnreadMention[]
+  count: number
+  // Account-wide unread-mention badge total; not narrowed by guildId because
+  // READY read states carry no guild association.
+  badgeCount: number
+  complete: boolean
+  windowDays: number
+}
+
 export interface DiscordSearchResult {
   id: string
   channel_id: string
@@ -190,6 +252,14 @@ export const DiscordChannelSchema = z.object({
   position: z.number().optional(),
 })
 
+export const DiscordReactionSchema = z.object({
+  emoji: z.object({
+    id: z.string().nullish(),
+    name: z.string().nullable(),
+  }),
+  count: z.number(),
+})
+
 export const DiscordMessageSchema = z.object({
   id: z.string(),
   channel_id: z.string(),
@@ -201,6 +271,7 @@ export const DiscordMessageSchema = z.object({
   timestamp: z.string(),
   edited_timestamp: z.string().optional(),
   thread_id: z.string().optional(),
+  reactions: z.array(DiscordReactionSchema).optional(),
 })
 
 export const DiscordUserSchema = z.object({
@@ -219,14 +290,6 @@ export const DiscordDMChannelSchema = z.object({
   name: z.string().optional(),
 })
 
-export const DiscordReactionSchema = z.object({
-  emoji: z.object({
-    id: z.string().optional(),
-    name: z.string(),
-  }),
-  count: z.number(),
-})
-
 export const DiscordFileSchema = z.object({
   id: z.string(),
   filename: z.string(),
@@ -402,6 +465,24 @@ export interface DiscordGatewayGenericEvent {
   [key: string]: unknown
 }
 
+// read_state_type 0 = channel read state (carries last_message_id); non-zero types
+// carry last_acked_id instead and must be filtered out for mention correlation.
+export const DiscordRawReadStateSchema = z.object({
+  id: z.string(),
+  read_state_type: z.number().optional(),
+  last_message_id: z.string().nullish(),
+  mention_count: z.number().optional(),
+})
+
+export type DiscordRawReadState = z.infer<typeof DiscordRawReadStateSchema>
+
+// READY sends read_state as a raw array, or as { entries, version } when the
+// VERSIONED_READ_STATES gateway capability is negotiated.
+export const DiscordReadyReadStateSchema = z.union([
+  z.array(z.unknown()),
+  z.object({ entries: z.array(z.unknown()), version: z.number().optional() }),
+])
+
 export type DiscordGatewayEvent =
   | DiscordGatewayMessageCreateEvent
   | DiscordGatewayMessageUpdateEvent

package/src/platforms/slack/index.ts

@@ -3,6 +3,7 @@ export { SlackCredentialManager, CredentialManager } from './credential-manager'
 export { SlackListener } from './listener'
 export { loginWithQr } from './qr-http-login'
 export type { QrLoginOptions, QrSession } from './qr-http-login'
+export type { SlackConfirmationChallenge, SlackConfirmationCodeRequest } from './qr-confirmation'
 export { decodeSlackQr } from './qr-login'
 export type { SlackQrLogin } from './qr-login'
 export type {

package/src/platforms/slack/qr-confirmation.ts

@@ -0,0 +1,86 @@
+import type { SlackQrLogin } from './qr-login'
+
+export interface SlackConfirmationChallenge {
+  readonly email: string
+  readonly type: string | null
+}
+
+export type SlackConfirmationCodeRequest = (challenge: SlackConfirmationChallenge) => Promise<string>
+
+type SigninProps = {
+  readonly magicLogin: string
+  readonly emailAddress: string
+  readonly twoFactorType: string | null
+}
+
+export function parseConfirmationPage(html: string): SigninProps | null {
+  const match = html.match(/id="props_node"[^>]*\bdata-props="([^"]*)"/i)
+  const encoded = match?.[1]
+  if (!encoded) return null
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(decodeHtml(encoded))
+  } catch {
+    return null
+  }
+  if (!isRecord(parsed)) return null
+
+  const magicLogin = parsed.magicLogin
+  const emailAddress = parsed.emailAddress
+  if (typeof magicLogin !== 'string' || magicLogin === '') return null
+  if (typeof emailAddress !== 'string' || emailAddress === '') return null
+  return {
+    magicLogin,
+    emailAddress,
+    twoFactorType: typeof parsed.twoFactorType === 'string' ? parsed.twoFactorType : null,
+  }
+}
+
+export function buildConfirmationRequest(
+  login: SlackQrLogin,
+  finalUrl: string,
+  props: SigninProps,
+  code: string,
+): { readonly url: string; readonly body: string } | null {
+  const expected = expectedConfirmationPath(login)
+  if (!expected) return null
+  const url = new URL(finalUrl)
+  if (url.hostname !== `${login.workspace}.slack.com`) return null
+  if (url.pathname !== expected) return null
+
+  url.search = ''
+  url.searchParams.set('domain', login.workspace)
+  url.searchParams.set('domainLogin', '1')
+  url.searchParams.set('email', props.emailAddress)
+
+  return {
+    url: url.toString(),
+    body: new URLSearchParams({
+      '2fa_magiclogin': props.magicLogin,
+      remember: '0',
+      has_remember: 'false',
+      '2fa_code': code.trim(),
+      '2fa_action': 'submit_primary',
+    }).toString(),
+  }
+}
+
+export function expectedConfirmationPath(login: SlackQrLogin): string | null {
+  const qrSecret = new URL(login.url).pathname.split('/').at(-1)
+  if (!qrSecret || !qrSecret.startsWith('z-app-')) return null
+  return `/login/${qrSecret}`
+}
+
+function decodeHtml(value: string): string {
+  return value
+    .replaceAll('&quot;', '"')
+    .replaceAll('&#39;', "'")
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&amp;', '&')
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}

package/src/platforms/slack/qr-cookie-jar.ts

@@ -0,0 +1,54 @@
+import { CookieJar } from 'tough-cookie'
+
+const BROWSER_USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36'
+
+const SESSION_COOKIE_NAME = 'd'
+const SESSION_COOKIE_PREFIX = 'xoxd-'
+
+export class SlackCookieJar {
+  readonly #jar = new CookieJar()
+
+  async fetch(doFetch: typeof fetch, url: string, init: RequestInit = {}): Promise<Response> {
+    const cookie = await this.#jar.getCookieString(url)
+    const response = await doFetch(url, {
+      ...init,
+      redirect: 'manual',
+      headers: {
+        'User-Agent': BROWSER_USER_AGENT,
+        Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.9',
+        ...init.headers,
+        ...(cookie ? { Cookie: cookie } : {}),
+      },
+    })
+    for (const setCookie of getSetCookies(response)) {
+      await this.#jar.setCookie(setCookie, url, { ignoreError: true })
+    }
+    return response
+  }
+
+  async sessionCookie(url: string): Promise<string | null> {
+    const cookies = await this.#jar.getCookies(url)
+    for (const cookie of cookies) {
+      if (cookie.key === SESSION_COOKIE_NAME && cookie.value.startsWith(SESSION_COOKIE_PREFIX)) {
+        return cookie.value
+      }
+    }
+    return null
+  }
+}
+
+export function setCookieNames(response: Response): readonly string[] {
+  return getSetCookies(response).flatMap((setCookie) => {
+    const name = setCookie.split('=')[0]?.trim()
+    return name ? [name] : []
+  })
+}
+
+function getSetCookies(response: Response): readonly string[] {
+  const withGetter = response.headers as Headers & { getSetCookie?: () => string[] }
+  if (typeof withGetter.getSetCookie === 'function') return withGetter.getSetCookie()
+  const single = response.headers.get('set-cookie')
+  return single ? [single] : []
+}