agent-messenger 2.31.0 → 2.32.0

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.31.0
+version: 2.32.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

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

@@ -1,6 +1,7 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test'
 
 import { DiscordClient, DiscordError } from './client'
+import type { DiscordReadState } from './types'
 
 describe('DiscordClient', () => {
   const originalFetch = globalThis.fetch
@@ -226,23 +227,50 @@ describe('DiscordClient', () => {
 
       expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages?limit=50')
     })
+
+    it('gets messages around a specific message', async () => {
+      mockResponse([])
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.getMessages('ch1', 1, { around: 'msg/1' })
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages?around=msg%2F1&limit=1')
+    })
   })
 
   describe('getMessage', () => {
     it('returns single message', async () => {
-      mockResponse({
-        id: 'msg1',
-        channel_id: 'ch1',
-        author: { id: '123', username: 'user1' },
-        content: 'Message 1',
-        timestamp: '2024-01-01T00:00:00.000Z',
-      })
+      mockResponse([
+        {
+          id: 'msg1',
+          channel_id: 'ch1',
+          author: { id: '123', username: 'user1' },
+          content: 'Message 1',
+          timestamp: '2024-01-01T00:00:00.000Z',
+        },
+      ])
 
       const client = await new DiscordClient().login({ token: 'test-token' })
       const message = await client.getMessage('ch1', 'msg1')
 
       expect(message.id).toBe('msg1')
-      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages/msg1')
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages?around=msg1&limit=1')
+    })
+
+    it('throws when the requested message is not returned', async () => {
+      mockResponse([
+        {
+          id: 'neighbor',
+          channel_id: 'ch1',
+          author: { id: '123', username: 'user1' },
+          content: 'Nearby message',
+          timestamp: '2024-01-01T00:00:00.000Z',
+        },
+      ])
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+
+      await expect(client.getMessage('ch1', 'missing')).rejects.toEqual(new DiscordError('Message not found', '10008'))
     })
   })
 
@@ -674,5 +702,198 @@ describe('DiscordClient', () => {
 
       expect(fetchCalls.length).toBe(2)
     })
+
+    it('normalizes query strings for the same channel route', async () => {
+      mockResponse([], 200, {
+        'X-RateLimit-Remaining': '0',
+        'X-RateLimit-Reset': String(Date.now() / 1000 + 0.1),
+        'X-RateLimit-Bucket': 'messages-bucket',
+      })
+      mockResponse([])
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.getMessages('123456789', 1, { around: 'message-1' })
+
+      const startTime = Date.now()
+      await client.getMessages('123456789', 1, { around: 'message-2' })
+      const elapsed = Date.now() - startTime
+
+      expect(elapsed).toBeGreaterThanOrEqual(50)
+      expect(fetchCalls.length).toBe(2)
+    })
+  })
+
+  describe('getUnreadMentions', () => {
+    const mention = (id: string, channelId: string, guildId?: string) => ({
+      id,
+      channel_id: channelId,
+      author: { id: 'a1', username: 'alice' },
+      content: `mention ${id}`,
+      timestamp: '2024-01-29T10:00:00Z',
+      mention_everyone: false,
+      mentions: [{ id: 'me', username: 'me' }],
+      ...(guildId ? { guild_id: guildId } : {}),
+    })
+
+    const stubReadState = (client: DiscordClient, readState: DiscordReadState[]) =>
+      spyOn(client, 'fetchReadState').mockResolvedValue(readState)
+
+    it('keeps mentions newer than the channel read marker', async () => {
+      // given: one channel with an unread mention (200 > marker 100) and one already read (50 < 100)
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+      mockResponse([mention('200', 'c1'), mention('50', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      // then: only the newer message is unread
+      expect(result.count).toBe(1)
+      expect(result.mentions[0].id).toBe('200')
+      expect(result.mentions[0].mention_count).toBe(1)
+    })
+
+    it('treats an equal snowflake as read', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+      mockResponse([mention('100', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.count).toBe(0)
+    })
+
+    it('omits mentions for channels with no read-state entry', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [])
+      mockResponse([mention('200', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.count).toBe(0)
+    })
+
+    it('omits channels whose mention_count is zero', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '100', mentionCount: 0 }])
+      mockResponse([mention('200', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.count).toBe(0)
+    })
+
+    it('includes all mentions when the read marker is null', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: null, mentionCount: 2 }])
+      mockResponse([mention('200', 'c1'), mention('50', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.count).toBe(2)
+    })
+
+    it('reports badgeCount from summed read-state mention counts', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [
+        { channelId: 'c1', lastMessageId: '100', mentionCount: 2 },
+        { channelId: 'c2', lastMessageId: '100', mentionCount: 3 },
+      ])
+      mockResponse([mention('200', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.badgeCount).toBe(5)
+      expect(result.count).toBe(1)
+    })
+
+    it('paginates mention history with a before cursor', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 200 }])
+
+      const firstPage = Array.from({ length: 100 }, (_, i) => mention(String(1000 - i), 'c1'))
+      const secondPage = [mention('900', 'c1')]
+      mockResponse(firstPage)
+      mockResponse(secondPage)
+
+      const result = await client.getUnreadMentions()
+
+      expect(fetchCalls.length).toBe(2)
+      expect(fetchCalls[1].url).toContain('before=901')
+      expect(result.count).toBe(101)
+    })
+
+    it('deduplicates mentions repeated across pages', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 100 }])
+
+      const page = Array.from({ length: 100 }, (_, i) => mention(String(1000 - i), 'c1'))
+      const overlap = [mention('901', 'c1'), mention('800', 'c1')]
+      mockResponse(page)
+      mockResponse(overlap)
+
+      const result = await client.getUnreadMentions()
+
+      const ids = result.mentions.map((m) => m.id)
+      expect(new Set(ids).size).toBe(ids.length)
+    })
+
+    it('caps the scan at limit 1 with a single bounded request', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 5 }])
+      mockResponse([mention('1000', 'c1')])
+
+      const result = await client.getUnreadMentions({ limit: 1 })
+
+      // then: exactly one page requested, capped to the limit, incomplete scan
+      expect(fetchCalls.length).toBe(1)
+      expect(fetchCalls[0].url).toContain('limit=1')
+      expect(result.count).toBe(1)
+      expect(result.complete).toBe(false)
+    })
+
+    it('caps the scan at a custom limit that spans multiple pages', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 200 }])
+
+      const firstPage = Array.from({ length: 100 }, (_, i) => mention(String(1000 - i), 'c1'))
+      const secondPage = Array.from({ length: 50 }, (_, i) => mention(String(900 - i), 'c1'))
+      mockResponse(firstPage)
+      mockResponse(secondPage)
+
+      const result = await client.getUnreadMentions({ limit: 150 })
+
+      // then: second page bounded to remaining 50, scan stops at the cap and is incomplete
+      expect(fetchCalls.length).toBe(2)
+      expect(fetchCalls[1].url).toContain('limit=50')
+      expect(result.count).toBe(150)
+      expect(result.complete).toBe(false)
+    })
+
+    it('marks the scan complete when a short page ends history', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 3 }])
+      mockResponse([mention('1000', 'c1'), mention('999', 'c1')])
+
+      const result = await client.getUnreadMentions()
+
+      expect(result.complete).toBe(true)
+      expect(result.count).toBe(2)
+    })
+
+    it('stops and reports incomplete when the cursor fails to advance', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      stubReadState(client, [{ channelId: 'c1', lastMessageId: '0', mentionCount: 200 }])
+
+      const fullPage = Array.from({ length: 100 }, (_, i) => mention(String(1000 - i), 'c1'))
+      const repeatedPage = Array.from({ length: 100 }, (_, i) => mention(String(1000 - i), 'c1'))
+      mockResponse(fullPage)
+      mockResponse(repeatedPage)
+
+      const result = await client.getUnreadMentions()
+
+      // then: the repeated page adds nothing new, so the guard stops the scan as incomplete
+      expect(result.complete).toBe(false)
+      expect(result.count).toBe(100)
+    })
   })
 })

package/src/platforms/discord/client.ts

@@ -10,14 +10,29 @@ import type {
   DiscordGuildMember,
   DiscordMention,
   DiscordMessage,
+  DiscordReadState,
   DiscordRelationship,
   DiscordSearchOptions,
   DiscordSearchResult,
+  DiscordUnreadMention,
+  DiscordUnreadMentionsResult,
   DiscordUser,
   DiscordUserNote,
   DiscordUserProfile,
 } from './types'
 
+const MENTIONS_WINDOW_DAYS = 7
+const MENTIONS_PAGE_SIZE = 100
+const UNREAD_MENTIONS_MAX = 500
+
+function isSnowflakeNewer(candidate: string, marker: string): boolean {
+  try {
+    return BigInt(candidate) > BigInt(marker)
+  } catch {
+    return false
+  }
+}
+
 export class DiscordError extends Error {
   code: string
 
@@ -75,7 +90,9 @@ export class DiscordClient {
   }
 
   private getBucketKey(method: string, path: string): string {
-    const normalized = path
+    const queryIndex = path.indexOf('?')
+    const route = queryIndex === -1 ? path : path.slice(0, queryIndex)
+    const normalized = route
       .replace(/\/channels\/\d+/, '/channels/{channel_id}')
       .replace(/\/guilds\/\d+/, '/guilds/{guild_id}')
       .replace(/\/users\/\d+/, '/users/{user_id}')
@@ -235,12 +252,22 @@ export class DiscordClient {
     return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, body)
   }
 
-  async getMessages(channelId: string, limit: number = 50): Promise<DiscordMessage[]> {
-    return this.request<DiscordMessage[]>('GET', `/channels/${channelId}/messages?limit=${limit}`)
+  async getMessages(channelId: string, limit: number = 50, options?: { around?: string }): Promise<DiscordMessage[]> {
+    const params = new URLSearchParams()
+    if (options?.around) {
+      params.set('around', options.around)
+    }
+    params.set('limit', limit.toString())
+    return this.request<DiscordMessage[]>('GET', `/channels/${channelId}/messages?${params}`)
   }
 
   async getMessage(channelId: string, messageId: string): Promise<DiscordMessage> {
-    return this.request<DiscordMessage>('GET', `/channels/${channelId}/messages/${messageId}`)
+    const messages = await this.getMessages(channelId, 1, { around: messageId })
+    const message = messages[0]
+    if (!message || message.id !== messageId) {
+      throw new DiscordError('Message not found', '10008')
+    }
+    return message
   }
 
   async editMessage(channelId: string, messageId: string, content: string): Promise<DiscordMessage> {
@@ -322,7 +349,7 @@ export class DiscordClient {
     })
   }
 
-  async getMentions(options?: { limit?: number; guildId?: string }): Promise<DiscordMention[]> {
+  async getMentions(options?: { limit?: number; guildId?: string; before?: string }): Promise<DiscordMention[]> {
     const params = new URLSearchParams()
     params.set('limit', (options?.limit ?? 25).toString())
     params.set('roles', 'true')
@@ -331,10 +358,100 @@ export class DiscordClient {
     if (options?.guildId) {
       params.set('guild_id', options.guildId)
     }
+    if (options?.before) {
+      params.set('before', options.before)
+    }
 
     return this.request<DiscordMention[]>('GET', `/users/@me/mentions?${params.toString()}`)
   }
 
+  async fetchReadState(): Promise<DiscordReadState[]> {
+    const { DiscordListener } = await import('./listener')
+    const listener = new DiscordListener(this)
+    try {
+      await listener.start()
+      const readState = listener.getReadState()
+      if (readState === null) {
+        throw new DiscordError('Discord gateway did not deliver read state', 'no_read_state')
+      }
+      return readState
+    } finally {
+      listener.stop()
+    }
+  }
+
+  async getUnreadMentions(options?: { guildId?: string; limit?: number }): Promise<DiscordUnreadMentionsResult> {
+    const limit = options?.limit ?? UNREAD_MENTIONS_MAX
+    const [readState, scan] = await Promise.all([
+      this.fetchReadState(),
+      this.collectMentions({ guildId: options?.guildId, limit }),
+    ])
+
+    const readStateByChannel = new Map(readState.map((state) => [state.channelId, state]))
+
+    const unread: DiscordUnreadMention[] = []
+    for (const mention of scan.mentions) {
+      const state = readStateByChannel.get(mention.channel_id)
+      // A channel with no read-state entry is unknown, not unread: omit rather than assume unread.
+      if (!state || state.mentionCount === 0) continue
+      if (state.lastMessageId !== null && !isSnowflakeNewer(mention.id, state.lastMessageId)) continue
+      unread.push({ ...mention, mention_count: state.mentionCount })
+    }
+
+    // READY read states carry no guild association, so badgeCount is always the
+    // account-wide unread-mention total even when mentions are guild-filtered.
+    const badgeCount = readState.reduce((sum, state) => sum + state.mentionCount, 0)
+
+    return {
+      mentions: unread,
+      count: unread.length,
+      badgeCount,
+      complete: scan.complete,
+      windowDays: MENTIONS_WINDOW_DAYS,
+    }
+  }
+
+  private async collectMentions(options: {
+    guildId?: string
+    limit: number
+  }): Promise<{ mentions: DiscordMention[]; complete: boolean }> {
+    const collected: DiscordMention[] = []
+    const seen = new Set<string>()
+    let before: string | undefined
+
+    while (collected.length < options.limit) {
+      const pageSize = Math.min(MENTIONS_PAGE_SIZE, options.limit - collected.length)
+      const page = await this.getMentions({ limit: pageSize, guildId: options.guildId, before })
+
+      // An empty or short page is the natural end of history: the scan is exhaustive.
+      if (page.length < pageSize) {
+        for (const mention of page) {
+          if (seen.has(mention.id)) continue
+          seen.add(mention.id)
+          collected.push(mention)
+        }
+        return { mentions: collected, complete: true }
+      }
+
+      let added = 0
+      for (const mention of page) {
+        if (collected.length >= options.limit) break
+        if (seen.has(mention.id)) continue
+        seen.add(mention.id)
+        collected.push(mention)
+        added++
+      }
+
+      // Discord returns pages newest-first; a non-advancing cursor means a repeated
+      // page, so stop to avoid looping. Either way the scan did not reach history's end.
+      const oldest = page[page.length - 1].id
+      if (added === 0 || oldest === before) return { mentions: collected, complete: false }
+      before = oldest
+    }
+
+    return { mentions: collected, complete: false }
+  }
+
   async getUserNote(userId: string): Promise<DiscordUserNote | null> {
     try {
       return await this.request<DiscordUserNote>('GET', `/users/@me/notes/${userId}`)

package/src/platforms/discord/commands/mention.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { unreadAction } from './mention'
 
 let clientGetMentionsSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
@@ -128,3 +129,86 @@ it('getMentions: includes mention metadata', async () => {
   expect(mention.mention_everyone).toBeDefined()
   expect(mention.mentions).toBeDefined()
 })
+
+it('unread command: emits snake_case JSON and forwards guild/limit options', async () => {
+  // given: an authenticated client whose getUnreadMentions returns one unread mention
+  credManagerLoadSpy.mockResolvedValue({
+    token: 'test-token',
+    current_server: null,
+    servers: {},
+  })
+  const loginSpy = spyOn(DiscordClient.prototype, 'login').mockImplementation(async function (this: DiscordClient) {
+    return this
+  })
+  const getUnreadSpy = spyOn(DiscordClient.prototype, 'getUnreadMentions').mockResolvedValue({
+    mentions: [
+      {
+        id: 'msg-1',
+        channel_id: 'ch-1',
+        author: { id: 'user-1', username: 'alice' },
+        content: 'Hey @testuser',
+        timestamp: '2024-01-29T10:00:00Z',
+        mention_everyone: false,
+        mentions: [{ id: 'user-me', username: 'testuser' }],
+        guild_id: 'guild-1',
+        mention_count: 2,
+      },
+    ],
+    count: 1,
+    badgeCount: 2,
+    complete: true,
+    windowDays: 7,
+  })
+  const consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+
+  // when: running the unread action with guild and limit
+  await unreadAction({ guild: 'guild-1', limit: 200 })
+
+  // then: options are forwarded and the emitted JSON uses documented snake_case keys
+  expect(getUnreadSpy).toHaveBeenCalledWith({ guildId: 'guild-1', limit: 200 })
+  const lastCall = consoleLogSpy.mock.calls.at(-1) as [string]
+  const emitted = JSON.parse(lastCall[0])
+  expect(emitted).toEqual({
+    mentions: [
+      {
+        id: 'msg-1',
+        channel_id: 'ch-1',
+        author: 'alice',
+        content: 'Hey @testuser',
+        timestamp: '2024-01-29T10:00:00Z',
+        mention_everyone: false,
+        mentioned_users: ['testuser'],
+        guild_id: 'guild-1',
+      },
+    ],
+    count: 1,
+    badge_count: 2,
+    complete: true,
+    window_days: 7,
+  })
+
+  loginSpy.mockRestore()
+  getUnreadSpy.mockRestore()
+  consoleLogSpy.mockRestore()
+})
+
+it('unread command: exits with error when not authenticated', async () => {
+  // given: no token in credentials
+  credManagerLoadSpy.mockResolvedValue({
+    token: undefined,
+    current_server: null,
+    servers: {},
+  })
+  const consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  const processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+
+  // when: running the unread action
+  await unreadAction({})
+
+  // then: it reports the auth error and exits
+  expect(consoleLogSpy).toHaveBeenCalledWith(JSON.stringify({ error: 'Not authenticated. Run "auth extract" first.' }))
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+
+  consoleLogSpy.mockRestore()
+  processExitSpy.mockRestore()
+})

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

@@ -1,4 +1,4 @@
-import { Command } from 'commander'
+import { Command, InvalidArgumentError } from 'commander'
 
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
@@ -6,6 +6,14 @@ import { formatOutput } from '@/shared/utils/output'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 
+function parseLimit(value: string): number {
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new InvalidArgumentError('Must be a positive integer.')
+  }
+  return parsed
+}
+
 export async function listAction(options: { limit?: number; guild?: string; pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
@@ -39,17 +47,72 @@ export async function listAction(options: { limit?: number; guild?: string; pret
   }
 }
 
-export const mentionCommand = new Command('mention').description('Mention commands').addCommand(
-  new Command('list')
-    .description('List mentions')
-    .option('--limit <n>', 'Number of mentions to fetch', '25')
-    .option('--guild <guild-id>', 'Filter by guild ID')
-    .option('--pretty', 'Pretty print JSON output')
-    .action((options) => {
-      listAction({
-        limit: options.limit ? parseInt(options.limit, 10) : undefined,
-        guild: options.guild,
-        pretty: options.pretty,
-      })
-    }),
-)
+export async function unreadAction(options: { guild?: string; limit?: number; pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const result = await client.getUnreadMentions({
+      guildId: options.guild,
+      limit: options.limit,
+    })
+
+    const output = {
+      mentions: result.mentions.map((mention) => ({
+        id: mention.id,
+        channel_id: mention.channel_id,
+        author: mention.author.username,
+        content: mention.content,
+        timestamp: mention.timestamp,
+        mention_everyone: mention.mention_everyone,
+        mentioned_users: mention.mentions.map((u) => u.username),
+        guild_id: mention.guild_id || null,
+      })),
+      count: result.count,
+      badge_count: result.badgeCount,
+      complete: result.complete,
+      window_days: result.windowDays,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const mentionCommand = new Command('mention')
+  .description('Mention commands')
+  .addCommand(
+    new Command('list')
+      .description('List mentions')
+      .option('--limit <n>', 'Number of mentions to fetch', parseLimit, 25)
+      .option('--guild <guild-id>', 'Filter by guild ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((options) => {
+        listAction({
+          limit: options.limit,
+          guild: options.guild,
+          pretty: options.pretty,
+        })
+      }),
+  )
+  .addCommand(
+    new Command('unread')
+      .description('List unread mentions (correlates mention history with per-channel read state)')
+      .option('--limit <n>', 'Max number of mentions to scan', parseLimit)
+      .option('--guild <guild-id>', 'Filter by guild ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((options) => {
+        unreadAction({
+          limit: options.limit,
+          guild: options.guild,
+          pretty: options.pretty,
+        })
+      }),
+  )

package/src/platforms/discord/commands/reaction.test.ts

@@ -37,7 +37,7 @@ beforeEach(() => {
         count: 1,
       },
     ],
-  } as any)
+  })
 
   // Spy on DiscordCredentialManager.prototype methods
   credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({

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

@@ -101,7 +101,7 @@ export async function listAction(channelId: string, messageId: string, options:
       process.exit(1)
     }
 
-    const reactions = (message as any).reactions || []
+    const reactions = message.reactions ?? []
 
     console.log(
       formatOutput(

package/src/platforms/discord/index.ts

@@ -25,10 +25,13 @@ export type {
   DiscordMention,
   DiscordMessage,
   DiscordReaction,
+  DiscordReadState,
   DiscordRelationship,
   DiscordSearchOptions,
   DiscordSearchResponse,
   DiscordSearchResult,
+  DiscordUnreadMention,
+  DiscordUnreadMentionsResult,
   DiscordUser,
   DiscordUserNote,
   DiscordUserProfile,