agent-messenger 2.31.0 → 2.32.1

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/channel.test.ts

@@ -1,7 +1,8 @@
-import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { listAction } from './channel'
 
 let clientListChannelsSpy: ReturnType<typeof spyOn>
 let clientGetChannelSpy: ReturnType<typeof spyOn>
@@ -12,8 +13,10 @@ beforeEach(() => {
   // Spy on DiscordClient.prototype methods
   clientListChannelsSpy = spyOn(DiscordClient.prototype, 'listChannels').mockResolvedValue([
     { id: 'ch-1', guild_id: 'guild-1', name: 'general', type: 0, topic: 'General discussion' },
-    { id: 'ch-2', guild_id: 'guild-1', name: 'announcements', type: 0, topic: 'Announcements' },
+    { id: 'ch-2', guild_id: 'guild-1', name: 'announcements', type: 5, topic: 'Announcements' },
     { id: 'ch-3', guild_id: 'guild-1', name: 'voice-channel', type: 2, topic: undefined },
+    { id: 'ch-4', guild_id: 'guild-1', name: 'Text Channels', type: 4, topic: undefined },
+    { id: 'ch-5', guild_id: 'guild-1', name: 'a-thread', type: 11, topic: undefined },
   ])
 
   clientGetChannelSpy = spyOn(DiscordClient.prototype, 'getChannel').mockImplementation(async (channelId: string) => {
@@ -72,30 +75,37 @@ afterEach(() => {
   credManagerLoadSpy?.mockRestore()
 })
 
-it('list: returns text channels (type=0) from server', async () => {
-  // given: discord client with channels
-  const client = await new DiscordClient().login({ token: 'test-token' })
-  const channels = await client.listChannels('server-1')
-
-  // when: filtering text channels
-  const textChannels = channels.filter((ch) => ch.type === 0)
-
-  // then: only text channels are returned
-  expect(textChannels).toHaveLength(2)
-  expect(textChannels[0].name).toBe('general')
-  expect(textChannels[1].name).toBe('announcements')
+it('list: includes text, announcement, and voice channels but excludes categories and threads', async () => {
+  // given: a server with mixed channel types
+  const consoleSpy = mock(() => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  // when: listing channels
+  await listAction({ pretty: false })
+  console.log = originalLog
+
+  // then: only listable channels are output
+  const output = JSON.parse(consoleSpy.mock.calls[0][0] as string) as Array<{ name: string; type: number }>
+  const names = output.map((ch) => ch.name)
+  expect(names).toEqual(['general', 'announcements', 'voice-channel'])
+  expect(names).not.toContain('Text Channels')
+  expect(names).not.toContain('a-thread')
 })
 
 it('list: includes channel metadata', async () => {
-  // given: discord client with channels
-  const client = await new DiscordClient().login({ token: 'test-token' })
-  const channels = await client.listChannels('server-1')
-  const textChannels = channels.filter((ch) => ch.type === 0)
-
-  // when: checking channel properties
-  const channel = textChannels[0]
-
-  // then: channel has id, name, type, topic
+  // given: a server with channels
+  const consoleSpy = mock(() => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  // when: listing channels
+  await listAction({ pretty: false })
+  console.log = originalLog
+
+  // then: each channel carries id, name, type, parent_id, topic
+  const output = JSON.parse(consoleSpy.mock.calls[0][0] as string) as Array<Record<string, unknown>>
+  const channel = output[0]
   expect(channel.id).toBeDefined()
   expect(channel.name).toBeDefined()
   expect(channel.type).toBe(0)

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

@@ -5,6 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { isListableChannel } from '../types'
 
 export async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -19,9 +20,9 @@ export async function listAction(options: { pretty?: boolean }): Promise<void> {
     const client = await new DiscordClient().login({ token: config.token })
     const channels = await client.listChannels(config.current_server)
 
-    const textChannels = channels.filter((ch) => ch.type === 0)
+    const listableChannels = channels.filter(isListableChannel)
 
-    const output = textChannels.map((ch) => ({
+    const output = listableChannels.map((ch) => ({
       id: ch.id,
       name: ch.name,
       type: ch.type,

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

@@ -1,6 +1,84 @@
-import { expect, it } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
-import { snapshotCommand } from './snapshot'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { DiscordChannelType } from '../types'
+import { snapshotAction, snapshotCommand } from './snapshot'
+
+let listChannelsSpy: ReturnType<typeof spyOn>
+let getMessagesSpy: ReturnType<typeof spyOn>
+let getServerSpy: ReturnType<typeof spyOn>
+let listUsersSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+const mixedChannels = [
+  { id: 'text', guild_id: 'g1', name: 'general', type: DiscordChannelType.GUILD_TEXT },
+  { id: 'announce', guild_id: 'g1', name: 'news', type: DiscordChannelType.GUILD_ANNOUNCEMENT },
+  { id: 'voice', guild_id: 'g1', name: 'lounge', type: DiscordChannelType.GUILD_VOICE },
+  { id: 'forum', guild_id: 'g1', name: 'help', type: DiscordChannelType.GUILD_FORUM },
+  { id: 'directory', guild_id: 'g1', name: 'hub', type: DiscordChannelType.GUILD_DIRECTORY },
+  { id: 'category', guild_id: 'g1', name: 'Section', type: DiscordChannelType.GUILD_CATEGORY },
+  { id: 'thread', guild_id: 'g1', name: 'a-thread', type: DiscordChannelType.PUBLIC_THREAD },
+]
+
+function parseSnapshot(consoleSpy: ReturnType<typeof spyOn>): Record<string, any> {
+  const lastCall = consoleSpy.mock.calls.at(-1)
+  return JSON.parse(lastCall![0] as string)
+}
+
+beforeEach(() => {
+  listChannelsSpy = spyOn(DiscordClient.prototype, 'listChannels').mockResolvedValue(mixedChannels)
+  getMessagesSpy = spyOn(DiscordClient.prototype, 'getMessages').mockResolvedValue([])
+  getServerSpy = spyOn(DiscordClient.prototype, 'getServer').mockResolvedValue({ id: 'g1', name: 'Guild One' })
+  listUsersSpy = spyOn(DiscordClient.prototype, 'listUsers').mockResolvedValue([])
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'g1',
+    servers: { g1: { server_id: 'g1', server_name: 'Guild One' } },
+  })
+})
+
+afterEach(() => {
+  listChannelsSpy?.mockRestore()
+  getMessagesSpy?.mockRestore()
+  getServerSpy?.mockRestore()
+  listUsersSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+it('snapshot brief: lists listable channels and excludes categories and threads', async () => {
+  // given: a server with mixed channel types
+  const consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+
+  // when: running a brief snapshot
+  await snapshotAction({ pretty: false })
+  const snapshot = parseSnapshot(consoleSpy)
+  consoleSpy.mockRestore()
+
+  // then: only listable channels appear, no messages are fetched
+  const names = snapshot.channels.map((ch: { name: string }) => ch.name)
+  expect(names).toEqual(['general', 'news', 'lounge', 'help', 'hub'])
+  expect(getMessagesSpy).not.toHaveBeenCalled()
+})
+
+it('snapshot full: fetches messages only from message-readable channels', async () => {
+  // given: a server with mixed channel types
+  const consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+
+  // when: running a full snapshot
+  await snapshotAction({ full: true, pretty: false })
+  const snapshot = parseSnapshot(consoleSpy)
+  consoleSpy.mockRestore()
+
+  // then: listing includes containers but getMessages is called only for readable IDs
+  const listedNames = snapshot.channels.map((ch: { name: string }) => ch.name)
+  expect(listedNames).toEqual(['general', 'news', 'lounge', 'help', 'hub'])
+
+  const fetchedIds = getMessagesSpy.mock.calls.map((call) => call[0])
+  expect(fetchedIds.sort()).toEqual(['announce', 'text', 'voice'])
+  expect(fetchedIds).not.toContain('forum')
+  expect(fetchedIds).not.toContain('directory')
+})
 
 it('snapshot: command is defined', () => {
   expect(snapshotCommand).toBeDefined()

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

@@ -6,6 +6,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { isListableChannel, isMessageReadableChannel } from '../types'
 import type { DiscordChannel } from '../types'
 
 export async function snapshotAction(options: {
@@ -41,8 +42,9 @@ export async function snapshotAction(options: {
 
       if (!options.usersOnly) {
         const channels = await client.listChannels(serverId)
+        const listableChannels = channels.filter(isListableChannel)
 
-        snapshot.channels = channels.map((ch) => ({
+        snapshot.channels = listableChannels.map((ch) => ({
           id: ch.id,
           name: ch.name,
           type: ch.type,
@@ -50,11 +52,10 @@ export async function snapshotAction(options: {
         }))
 
         if (!options.channelsOnly) {
-          const isTextChannel = (ch: DiscordChannel) => ch.type === 0 || ch.type === 5
-          const textChannels = channels.filter(isTextChannel)
+          const readableChannels = listableChannels.filter(isMessageReadableChannel)
 
           const channelMessages = await parallelMap(
-            textChannels,
+            readableChannels,
             async (channel: DiscordChannel) => {
               const messages = await client.getMessages(channel.id, messageLimit)
               return messages.map((msg) => ({
@@ -88,8 +89,8 @@ export async function snapshotAction(options: {
     } else {
       if (!options.usersOnly) {
         const channels = await client.listChannels(serverId)
-        const textChannels = channels.filter((ch: DiscordChannel) => ch.type === 0 || ch.type === 5)
-        snapshot.channels = textChannels.map((ch) => ({ id: ch.id, name: ch.name }))
+        const listableChannels = channels.filter(isListableChannel)
+        snapshot.channels = listableChannels.map((ch) => ({ id: ch.id, name: ch.name }))
       }
 
       snapshot.hint =

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,