agent-messenger 2.7.0 → 2.9.0

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

@@ -1,9 +1,17 @@
 import { execSync, spawn } from 'node:child_process'
-import { createDecipheriv, pbkdf2Sync } from 'node:crypto'
+import { pbkdf2Sync } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import {
+  BROWSER_KEYCHAIN_VARIANTS,
+  CHROMIUM_BROWSERS,
+  ChromiumCookieDecryptor,
+  discoverBrowserProfileDirs,
+  getBrowserBasePath,
+} from '@/shared/chromium'
+import type { KeychainVariant } from '@/shared/chromium'
 import { DerivedKeyCache } from '@/shared/utils/derived-key-cache'
 import { lookupLinuxKeyringPassword } from '@/shared/utils/linux-keyring'
 
@@ -13,11 +21,6 @@ export interface ExtractedDiscordToken {
 
 export type DiscordVariant = 'stable' | 'canary' | 'ptb'
 
-interface KeychainVariant {
-  service: string
-  account: string
-}
-
 interface CDPTarget {
   id: string
   type: string
@@ -34,13 +37,6 @@ interface CDPMessage {
   error?: { code: number; message: string }
 }
 
-interface BrowserConfig {
-  name: string
-  darwin: string
-  linux: string
-  win32: string
-}
-
 const TOKEN_REGEX = /[\w-]{24,}\.[\w-]{6}\.[\w-]{25,110}/
 const MFA_TOKEN_REGEX = /mfa\.[\w-]{84}/
 const ENCRYPTED_PREFIX = 'dQw4w9WgXcQ:'
@@ -62,49 +58,13 @@ const DISCORD_APP_PATHS: Record<DiscordVariant, { darwin: string }> = {
   ptb: { darwin: '/Applications/Discord PTB.app/Contents/MacOS/Discord PTB' },
 }
 
-const BROWSERS: BrowserConfig[] = [
-  {
-    name: 'Chrome',
-    darwin: join('Google', 'Chrome'),
-    linux: 'google-chrome',
-    win32: join('Google', 'Chrome', 'User Data'),
-  },
-  {
-    name: 'Chrome Canary',
-    darwin: join('Google', 'Chrome Canary'),
-    linux: 'google-chrome-unstable',
-    win32: join('Google', 'Chrome SxS', 'User Data'),
-  },
-  {
-    name: 'Edge',
-    darwin: 'Microsoft Edge',
-    linux: 'microsoft-edge',
-    win32: join('Microsoft', 'Edge', 'User Data'),
-  },
-  {
-    name: 'Arc',
-    darwin: join('Arc', 'User Data'),
-    linux: '',
-    win32: join('Arc', 'User Data'),
-  },
-  {
-    name: 'Brave',
-    darwin: join('BraveSoftware', 'Brave-Browser'),
-    linux: join('BraveSoftware', 'Brave-Browser'),
-    win32: join('BraveSoftware', 'Brave-Browser', 'User Data'),
-  },
-  {
-    name: 'Vivaldi',
-    darwin: 'Vivaldi',
-    linux: 'vivaldi',
-    win32: join('Vivaldi', 'User Data'),
-  },
-  {
-    name: 'Chromium',
-    darwin: 'Chromium',
-    linux: 'chromium',
-    win32: join('Chromium', 'User Data'),
-  },
+const DISCORD_APP_KEYCHAIN_VARIANTS: KeychainVariant[] = [
+  { service: 'discord Safe Storage', account: 'discord Key' },
+  { service: 'discordcanary Safe Storage', account: 'discordcanary Key' },
+  { service: 'discordptb Safe Storage', account: 'discordptb Key' },
+  { service: 'Discord Safe Storage', account: 'Discord' },
+  { service: 'Discord Canary Safe Storage', account: 'Discord Canary' },
+  { service: 'Discord PTB Safe Storage', account: 'Discord PTB' },
 ]
 
 export class DiscordTokenExtractor {
@@ -113,12 +73,20 @@ export class DiscordTokenExtractor {
   private killWait: number
   private keyCache: DerivedKeyCache
   private cachedKey: Buffer | null = null
+  private decryptor: ChromiumCookieDecryptor
 
   constructor(platform?: NodeJS.Platform, startupWait?: number, killWait?: number, keyCache?: DerivedKeyCache) {
     this.platform = platform ?? process.platform
     this.startupWait = startupWait ?? DISCORD_STARTUP_WAIT
     this.killWait = killWait ?? 1000
     this.keyCache = keyCache ?? new DerivedKeyCache()
+    this.decryptor = new ChromiumCookieDecryptor({
+      platform: this.platform,
+      appKeychainVariants: DISCORD_APP_KEYCHAIN_VARIANTS,
+      keyCache: this.keyCache,
+      keyCachePlatform: 'discord',
+      linuxKeyringAppNames: ['discord', 'Discord'],
+    })
   }
 
   getDiscordDirs(): string[] {
@@ -147,11 +115,11 @@ export class DiscordTokenExtractor {
   getBrowserLevelDBDirs(): string[] {
     const dirs: string[] = []
 
-    for (const browser of BROWSERS) {
-      const browserBase = this.getBrowserBasePath(browser)
+    for (const browser of CHROMIUM_BROWSERS) {
+      const browserBase = getBrowserBasePath(browser, this.platform)
       if (!browserBase) continue
 
-      const profileDirs = this.discoverProfileDirs(browserBase)
+      const profileDirs = discoverBrowserProfileDirs(browserBase)
       for (const profileDir of profileDirs) {
         dirs.push(join(profileDir, 'Local Storage', 'leveldb'))
       }
@@ -160,49 +128,6 @@ export class DiscordTokenExtractor {
     return dirs
   }
 
-  private getBrowserBasePath(browser: BrowserConfig): string | null {
-    let relative: string
-
-    switch (this.platform) {
-      case 'darwin':
-        relative = browser.darwin
-        if (!relative) return null
-        return join(homedir(), 'Library', 'Application Support', relative)
-      case 'linux':
-        relative = browser.linux
-        if (!relative) return null
-        return join(homedir(), '.config', relative)
-      case 'win32':
-        relative = browser.win32
-        if (!relative) return null
-        return join(
-          process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local'),
-          relative,
-        )
-      default:
-        return null
-    }
-  }
-
-  private discoverProfileDirs(browserBase: string): string[] {
-    const dirs: string[] = []
-
-    dirs.push(join(browserBase, 'Default'))
-
-    if (!existsSync(browserBase)) return dirs
-
-    try {
-      const entries = readdirSync(browserBase, { withFileTypes: true })
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        if (!/^Profile \d+$/i.test(entry.name)) continue
-        dirs.push(join(browserBase, entry.name))
-      }
-    } catch {}
-
-    return dirs
-  }
-
   private findBrowserBaseDirForPath(path: string): string | null {
     const parts = path.split(/[/\\]/)
     for (let levels = 2; levels <= 5; levels++) {
@@ -214,24 +139,7 @@ export class DiscordTokenExtractor {
   }
 
   getKeychainVariants(): KeychainVariant[] {
-    return [
-      // Modern Discord (lowercase)
-      { service: 'discord Safe Storage', account: 'discord Key' },
-      { service: 'discordcanary Safe Storage', account: 'discordcanary Key' },
-      { service: 'discordptb Safe Storage', account: 'discordptb Key' },
-      // Legacy Discord (capitalized)
-      { service: 'Discord Safe Storage', account: 'Discord' },
-      { service: 'Discord Canary Safe Storage', account: 'Discord Canary' },
-      { service: 'Discord PTB Safe Storage', account: 'Discord PTB' },
-      // Browser keychain entries for fallback
-      { service: 'Chrome Safe Storage', account: 'Chrome' },
-      { service: 'Chrome Canary Safe Storage', account: 'Chrome Canary' },
-      { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
-      { service: 'Arc Safe Storage', account: 'Arc' },
-      { service: 'Brave Safe Storage', account: 'Brave' },
-      { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
-      { service: 'Chromium Safe Storage', account: 'Chromium' },
-    ]
+    return [...DISCORD_APP_KEYCHAIN_VARIANTS, ...BROWSER_KEYCHAIN_VARIANTS]
   }
 
   getVariantFromPath(path: string): DiscordVariant {
@@ -283,6 +191,8 @@ export class DiscordTokenExtractor {
   private async loadCachedKey(): Promise<void> {
     if (this.platform !== 'darwin') return
 
+    await this.decryptor.loadCachedKey()
+
     const cached = await this.keyCache.get('discord')
     if (cached) {
       this.cachedKey = cached
@@ -290,7 +200,7 @@ export class DiscordTokenExtractor {
   }
 
   async clearKeyCache(): Promise<void> {
-    await this.keyCache.clear('discord')
+    await this.decryptor.clearKeyCache()
     this.cachedKey = null
   }
 
@@ -445,27 +355,10 @@ export class DiscordTokenExtractor {
       const encryptedKey = Buffer.from(localState.os_crypt.encrypted_key, 'base64')
 
       const dpapiBlobKey = encryptedKey.subarray(5)
-      const masterKey = this.decryptDPAPI(dpapiBlobKey)
+      const masterKey = this.decryptor.decryptDPAPI(dpapiBlobKey)
       if (!masterKey) return null
 
-      return this.decryptAESGCM(encryptedData, masterKey)
-    } catch {
-      return null
-    }
-  }
-
-  private decryptDPAPI(encryptedBlob: Buffer): Buffer | null {
-    try {
-      const b64 = encryptedBlob.toString('base64')
-      const psScript = `
-        Add-Type -AssemblyName System.Security
-        $bytes = [Convert]::FromBase64String('${b64}')
-        $decrypted = [Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
-        [Convert]::ToBase64String($decrypted)
-      `.replace(/\n/g, ' ')
-
-      const result = execSync(`powershell -Command "${psScript}"`, { encoding: 'utf8' })
-      return Buffer.from(result.trim(), 'base64')
+      return this.decryptor.decryptAESGCM(encryptedData, masterKey)
     } catch {
       return null
     }
@@ -473,7 +366,7 @@ export class DiscordTokenExtractor {
 
   private decryptMacToken(encryptedData: Buffer, discordDir: string): string | null {
     if (this.cachedKey) {
-      const decrypted = this.decryptAESCBC(encryptedData, this.cachedKey)
+      const decrypted = this.decryptor.decryptAESCBC(encryptedData, this.cachedKey)
       if (decrypted && this.isValidToken(decrypted)) return decrypted
     }
 
@@ -500,7 +393,7 @@ export class DiscordTokenExtractor {
         ).trim()
 
         const key = pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1')
-        const decrypted = this.decryptAESCBC(encryptedData, key)
+        const decrypted = this.decryptor.decryptAESCBC(encryptedData, key)
         if (decrypted && this.isValidToken(decrypted)) {
           this.cachedKey = key
           this.keyCache.set('discord', key).catch(() => {})
@@ -514,63 +407,26 @@ export class DiscordTokenExtractor {
 
   private decryptLinuxToken(encryptedData: Buffer): string | null {
     const prefix = encryptedData.subarray(0, 3).toString()
+
     if (prefix === 'v11') {
-      const result = this.decryptV11LinuxToken(encryptedData)
-      if (result) return result
+      for (const appName of ['discord', 'Discord']) {
+        try {
+          const keyringPassword = this.getLinuxKeyringPassword(appName)
+          const key = pbkdf2Sync(keyringPassword, 'saltysalt', 1, 16, 'sha1')
+          const decrypted = this.decryptor.decryptAESCBC(encryptedData, key)
+          if (decrypted) return decrypted
+        } catch {}
+      }
     }
-    // v10 or fallback
+
     const key = pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1')
-    return this.decryptAESCBC(encryptedData, key)
+    return this.decryptor.decryptAESCBC(encryptedData, key)
   }
 
   private getLinuxKeyringPassword(appName: string): string {
     return lookupLinuxKeyringPassword(appName)
   }
 
-  private decryptV11LinuxToken(encryptedData: Buffer): string | null {
-    const appNames = ['discord', 'Discord']
-    for (const appName of appNames) {
-      try {
-        const keyringPassword = this.getLinuxKeyringPassword(appName)
-        const key = pbkdf2Sync(keyringPassword, 'saltysalt', 1, 16, 'sha1')
-        const result = this.decryptAESCBC(encryptedData, key)
-        if (result) return result
-      } catch {}
-    }
-    return null
-  }
-
-  private decryptAESCBC(encryptedData: Buffer, key: Buffer): string | null {
-    try {
-      const ciphertext = encryptedData.subarray(3)
-      const iv = Buffer.alloc(16, 0x20)
-
-      const decipher = createDecipheriv('aes-128-cbc', key, iv)
-      decipher.setAutoPadding(true)
-
-      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
-      return decrypted.toString('utf8')
-    } catch {
-      return null
-    }
-  }
-
-  private decryptAESGCM(encryptedData: Buffer, key: Buffer): string | null {
-    try {
-      const iv = encryptedData.subarray(3, 15)
-      const authTag = encryptedData.subarray(-16)
-      const ciphertext = encryptedData.subarray(15, -16)
-
-      const decipher = createDecipheriv('aes-256-gcm', key, iv)
-      decipher.setAuthTag(authTag)
-
-      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
-      return decrypted.toString('utf8')
-    } catch {
-      return null
-    }
-  }
-
   async isDiscordRunning(variant?: DiscordVariant): Promise<boolean> {
     const variants = variant ? [variant] : (['stable', 'canary', 'ptb'] as DiscordVariant[])
 

package/src/platforms/discordbot/client.ts

@@ -31,10 +31,7 @@ export class DiscordBotClient {
     const credManager = new DiscordBotCredentialManager()
     const creds = await credManager.getCredentials()
     if (!creds?.token) {
-      throw new DiscordBotError(
-        'No Discord bot credentials found. Run "auth set <token>" first.',
-        'no_credentials',
-      )
+      throw new DiscordBotError('No Discord bot credentials found. Run "auth set <token>" first.', 'no_credentials')
     }
     return this.login({ token: creds.token })
   }

package/src/platforms/discordbot/commands/auth.test.ts

@@ -21,7 +21,9 @@ const mockListGuilds = mock(() =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     testAuth = mockTestAuth
     listGuilds = mockListGuilds
   },

package/src/platforms/discordbot/commands/channel.test.ts

@@ -31,7 +31,9 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listChannels = mockListChannels
     getChannel = mockGetChannel
     resolveChannel = mockResolveChannel

package/src/platforms/discordbot/commands/message.test.ts

@@ -68,7 +68,9 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     sendMessage = mockSendMessage
     getMessages = mockGetMessages
     getMessage = mockGetMessage

package/src/platforms/discordbot/commands/server.test.ts

@@ -22,7 +22,9 @@ const mockGetGuild = mock((guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listGuilds = mockListGuilds
     getGuild = mockGetGuild
   },

package/src/platforms/discordbot/commands/snapshot.test.ts

@@ -41,7 +41,9 @@ const mockListUsers = mock((_guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listChannels = mockListChannels
     getMessages = mockGetMessages
     listUsers = mockListUsers
@@ -84,23 +86,17 @@ describe('snapshot command', () => {
     process.env = originalEnv
   })
 
-  describe('default (channels + messages)', () => {
-    test('returns channels with recent messages', async () => {
+  describe('default (brief)', () => {
+    test('returns channels with id and name only', async () => {
       const manager = await setupManager(tempDir)
 
       const result = await snapshotAction({ _credManager: manager })
 
       expect(result.server_id).toBe('guild1')
       expect(result.channels).toHaveLength(2)
-      expect(result.channels?.[0].id).toBe('ch1')
-      expect(result.channels?.[0].name).toBe('general')
-      expect(result.channels?.[0].messages).toHaveLength(2)
-      expect(result.channels?.[0].messages?.[0]).toEqual({
-        id: 'msg1-ch1',
-        author: 'alice',
-        content: 'Hello from ch1',
-        timestamp: '2025-01-01T00:00:00Z',
-      })
+      expect(result.channels?.[0]).toEqual({ id: 'ch1', name: 'general' })
+      expect(result.channels?.[1]).toEqual({ id: 'ch2', name: 'random' })
+      expect(result.hint).toBeDefined()
     })
 
     test('filters out non-text channels', async () => {
@@ -112,11 +108,39 @@ describe('snapshot command', () => {
       expect(channelNames).not.toContain('voice')
     })
 
-    test('fetches messages in parallel for all text channels', async () => {
+    test('does not fetch messages', async () => {
       const manager = await setupManager(tempDir)
 
       await snapshotAction({ _credManager: manager })
 
+      expect(mockGetMessages).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('--full (channels + messages)', () => {
+    test('returns channels with recent messages', async () => {
+      const manager = await setupManager(tempDir)
+
+      const result = await snapshotAction({ _credManager: manager, full: true })
+
+      expect(result.server_id).toBe('guild1')
+      expect(result.channels).toHaveLength(2)
+      expect(result.channels?.[0].id).toBe('ch1')
+      expect(result.channels?.[0].name).toBe('general')
+      expect(result.channels?.[0].messages).toHaveLength(2)
+      expect(result.channels?.[0].messages?.[0]).toEqual({
+        id: 'msg1-ch1',
+        author: 'alice',
+        content: 'Hello from ch1',
+        timestamp: '2025-01-01T00:00:00Z',
+      })
+    })
+
+    test('fetches messages in parallel for all text channels', async () => {
+      const manager = await setupManager(tempDir)
+
+      await snapshotAction({ _credManager: manager, full: true })
+
       expect(mockGetMessages).toHaveBeenCalledTimes(2)
       expect(mockGetMessages).toHaveBeenCalledWith('ch1', 5)
       expect(mockGetMessages).toHaveBeenCalledWith('ch2', 5)
@@ -125,7 +149,7 @@ describe('snapshot command', () => {
     test('respects --limit option', async () => {
       const manager = await setupManager(tempDir)
 
-      await snapshotAction({ _credManager: manager, limit: 10 })
+      await snapshotAction({ _credManager: manager, full: true, limit: 10 })
 
       expect(mockGetMessages).toHaveBeenCalledWith('ch1', 10)
       expect(mockGetMessages).toHaveBeenCalledWith('ch2', 10)
@@ -134,17 +158,17 @@ describe('snapshot command', () => {
     test('defaults limit to 5', async () => {
       const manager = await setupManager(tempDir)
 
-      await snapshotAction({ _credManager: manager })
+      await snapshotAction({ _credManager: manager, full: true })
 
       expect(mockGetMessages).toHaveBeenCalledWith('ch1', 5)
     })
   })
 
-  describe('--channels-only', () => {
+  describe('--full --channels-only', () => {
     test('returns only channel list without messages', async () => {
       const manager = await setupManager(tempDir)
 
-      const result = await snapshotAction({ _credManager: manager, channelsOnly: true })
+      const result = await snapshotAction({ _credManager: manager, full: true, channelsOnly: true })
 
       expect(result.server_id).toBe('guild1')
       expect(result.channels).toHaveLength(2)
@@ -154,11 +178,11 @@ describe('snapshot command', () => {
     })
   })
 
-  describe('--users-only', () => {
+  describe('--full --users-only', () => {
     test('returns only user list', async () => {
       const manager = await setupManager(tempDir)
 
-      const result = await snapshotAction({ _credManager: manager, usersOnly: true })
+      const result = await snapshotAction({ _credManager: manager, full: true, usersOnly: true })
 
       expect(result.server_id).toBe('guild1')
       expect(result.users).toHaveLength(3)

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

@@ -10,6 +10,7 @@ import { getClient } from './shared'
 interface SnapshotOption extends BotOption {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
 }
 
@@ -31,6 +32,7 @@ interface SnapshotResult {
     username: string
     global_name: string | null
   }>
+  hint?: string
   error?: string
 }
 
@@ -43,53 +45,66 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
     }
 
     const client = await getClient(options)
-    const limit = options.limit ?? 5
 
-    if (options.usersOnly) {
-      const users = await client.listUsers(serverId)
-      return {
-        server_id: serverId,
-        users: users.map((u) => ({
-          id: u.id,
-          username: u.username,
-          global_name: u.global_name ?? null,
-        })),
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      const limit = options.limit ?? 5
+
+      if (options.usersOnly) {
+        const users = await client.listUsers(serverId)
+        return {
+          server_id: serverId,
+          users: users.map((u) => ({
+            id: u.id,
+            username: u.username,
+            global_name: u.global_name ?? null,
+          })),
+        }
       }
-    }
 
-    const allChannels = await client.listChannels(serverId)
-    const textChannels = allChannels.filter((ch) => ch.type === 0)
+      const allChannels = await client.listChannels(serverId)
+      const textChannels = allChannels.filter((ch) => ch.type === 0)
+
+      if (options.channelsOnly) {
+        return {
+          server_id: serverId,
+          channels: textChannels.map((ch) => ({
+            id: ch.id,
+            name: ch.name,
+            type: ch.type,
+          })),
+        }
+      }
+
+      const channelsWithMessages = await Promise.all(
+        textChannels.map(async (ch) => {
+          const messages = await client.getMessages(ch.id, limit)
+          return {
+            id: ch.id,
+            name: ch.name,
+            messages: messages.map((msg) => ({
+              id: msg.id,
+              author: msg.author.username,
+              content: msg.content,
+              timestamp: msg.timestamp,
+            })),
+          }
+        }),
+      )
 
-    if (options.channelsOnly) {
       return {
         server_id: serverId,
-        channels: textChannels.map((ch) => ({
-          id: ch.id,
-          name: ch.name,
-          type: ch.type,
-        })),
+        channels: channelsWithMessages,
       }
     }
 
-    const channelsWithMessages = await Promise.all(
-      textChannels.map(async (ch) => {
-        const messages = await client.getMessages(ch.id, limit)
-        return {
-          id: ch.id,
-          name: ch.name,
-          messages: messages.map((msg) => ({
-            id: msg.id,
-            author: msg.author.username,
-            content: msg.content,
-            timestamp: msg.timestamp,
-          })),
-        }
-      }),
-    )
+    const allChannels = await client.listChannels(serverId)
+    const textChannels = allChannels.filter((ch) => ch.type === 0)
 
     return {
       server_id: serverId,
-      channels: channelsWithMessages,
+      channels: textChannels.map((ch) => ({ id: ch.id, name: ch.name })),
+      hint: "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for members.",
     }
   } catch (error) {
     return { error: (error as Error).message }
@@ -97,10 +112,11 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Server overview for AI agent context')
+  .description('Server overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages and members (verbose)')
   .option('--channels-only', 'List channels only, skip messages')
   .option('--users-only', 'List users only')
-  .option('--limit <n>', 'Messages per channel (default: 5)', '5')
+  .option('--limit <n>', 'Messages per channel with --full (default: 5)', '5')
   .option('--server <id>', 'Use specific server')
   .option('--bot <id>', 'Use specific bot')
   .option('--pretty', 'Pretty print JSON output')
@@ -108,6 +124,7 @@ export const snapshotCommand = new Command('snapshot')
     try {
       const result = await snapshotAction({
         ...options,
+        full: options.full,
         limit: parseInt(options.limit, 10),
       })
       console.log(formatOutput(result, options.pretty))

package/src/platforms/discordbot/commands/thread.test.ts

@@ -29,7 +29,9 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     createThread = mockCreateThread
     archiveThread = mockArchiveThread
     resolveChannel = mockResolveChannel