agent-messenger 2.1.0 → 2.2.0

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

@@ -13,9 +13,9 @@ let credManagerClearTokenSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   // Spy on DiscordTokenExtractor.prototype.extract
-  extractorExtractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue({
+  extractorExtractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue([{
     token: 'test-token-123',
-  })
+  }])
 
   // Spy on DiscordClient.prototype methods
   clientTestAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue({
@@ -53,7 +53,7 @@ test('extract: calls DiscordTokenExtractor', async () => {
   const extractor = new DiscordTokenExtractor()
   const result = await extractor.extract()
   expect(result).toBeDefined()
-  expect(result?.token).toBe('test-token-123')
+  expect(result[0]?.token).toBe('test-token-123')
 })
 
 test('extract: validates token with DiscordClient', async () => {

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

@@ -2,6 +2,7 @@ import { Command } from 'commander'
 
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
+import { debug } from '@/shared/utils/stderr'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
@@ -29,12 +30,12 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
     }
 
     if (options.debug) {
-      console.error(`[debug] Extracting Discord token...`)
+      debug(`[debug] Extracting Discord token...`)
     }
 
     const extracted = await extractor.extract()
 
-    if (!extracted) {
+    if (extracted.length === 0) {
       console.log(
         formatOutput(
           {
@@ -47,62 +48,58 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       process.exit(1)
     }
 
-    if (options.debug) {
-      console.error(`[debug] Token extracted: ${extracted.token.substring(0, 20)}...`)
-    }
-
-    try {
-      const client = await new DiscordClient().login({ token: extracted.token })
-
+    for (const { token } of extracted) {
       if (options.debug) {
-        console.error(`[debug] Testing token validity...`)
+        debug(`[debug] Token extracted: ${token.substring(0, 20)}...`)
       }
 
-      const authInfo = await client.testAuth()
+      try {
+        const client = await new DiscordClient().login({ token })
 
-      if (options.debug) {
-        console.error(`[debug] ✓ Token valid for user: ${authInfo.username}`)
-        console.error(`[debug] Discovering servers...`)
-      }
+        if (options.debug) {
+          debug(`[debug] Testing token validity...`)
+        }
 
-      const servers = await client.listServers()
+        const authInfo = await client.testAuth()
 
-      if (options.debug) {
-        console.error(`[debug] ✓ Found ${servers.length} server(s)`)
-      }
+        if (options.debug) {
+          debug(`[debug] ✓ Token valid for user: ${authInfo.username}`)
+          debug(`[debug] Discovering servers...`)
+        }
 
-      if (servers.length === 0) {
-        console.log(
-          formatOutput(
-            {
-              error: 'No servers found. Make sure you are a member of at least one Discord server.',
-            },
-            options.pretty,
-          ),
-        )
-        process.exit(1)
-      }
+        const servers = await client.listServers()
 
-      const credManager = new DiscordCredentialManager()
-      const serverMap: Record<string, { server_id: string; server_name: string }> = {}
+        if (options.debug) {
+          debug(`[debug] ✓ Found ${servers.length} server(s)`)
+        }
 
-      for (const server of servers) {
-        serverMap[server.id] = {
-          server_id: server.id,
-          server_name: server.name,
+        if (servers.length === 0) {
+          if (options.debug) {
+            debug(`[debug] No servers found for this token, trying next...`)
+          }
+          continue
         }
-      }
 
-      const config = {
-        token: extracted.token,
-        current_server: servers[0].id,
-        servers: serverMap,
-      }
+        const credManager = new DiscordCredentialManager()
+        const serverMap: Record<string, { server_id: string; server_name: string }> = {}
 
-      await credManager.save(config)
+        for (const server of servers) {
+          serverMap[server.id] = {
+            server_id: server.id,
+            server_name: server.name,
+          }
+        }
+
+        const config = {
+          token,
+          current_server: servers[0].id,
+          servers: serverMap,
+        }
+
+        await credManager.save(config)
 
       if (options.debug) {
-        console.error(`[debug] ✓ Credentials saved`)
+        debug(`[debug] ✓ Credentials saved`)
       }
 
       const output = {
@@ -111,18 +108,25 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       }
 
       console.log(formatOutput(output, options.pretty))
+      return
     } catch (error) {
-      console.log(
-        formatOutput(
-          {
-            error: `Token validation failed: ${(error as Error).message}`,
-            hint: 'Make sure your Discord token is valid and has not expired.',
-          },
-          options.pretty,
-        ),
-      )
-      process.exit(1)
+      if (options.debug) {
+        debug(`[debug] Token validation failed: ${(error as Error).message}, trying next...`)
+      }
+      continue
+    }
     }
+
+    console.log(
+      formatOutput(
+        {
+          error: 'No usable Discord token found. Tokens may be expired or have no servers.',
+          hint: 'Make sure Discord is logged in and you are a member of at least one server.',
+        },
+        options.pretty,
+      ),
+    )
+    process.exit(1)
   } catch (error) {
     handleError(error as Error)
   }

package/src/platforms/discord/ensure-auth.test.ts

@@ -14,9 +14,9 @@ let saveSpy: ReturnType<typeof spyOn>
 beforeEach(() => {
   getTokenSpy = spyOn(DiscordCredentialManager.prototype, 'getToken').mockResolvedValue(null)
 
-  extractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue({
+  extractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue([{
     token: 'test-token-123',
-  })
+  }])
 
   testAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue({
     id: 'user-123',
@@ -90,7 +90,7 @@ describe('ensureDiscordAuth', () => {
 
   test('does not save when extraction returns null', async () => {
     // given
-    extractSpy.mockResolvedValue(null)
+    extractSpy.mockResolvedValue([])
 
     // when
     await ensureDiscordAuth()

package/src/platforms/discord/ensure-auth.ts

@@ -10,9 +10,9 @@ export async function ensureDiscordAuth(): Promise<void> {
 
     const extractor = new DiscordTokenExtractor()
     const extracted = await extractor.extract()
-    if (!extracted) return
+    if (extracted.length === 0) return
 
-    const client = await new DiscordClient().login({ token: extracted.token })
+    const client = await new DiscordClient().login({ token: extracted[0].token })
     const authInfo = await client.testAuth()
     if (!authInfo) return
 
@@ -23,7 +23,7 @@ export async function ensureDiscordAuth(): Promise<void> {
     }
 
     await credManager.save({
-      token: extracted.token,
+      token: extracted[0].token,
       current_server: servers[0]?.id ?? null,
       servers: serverMap,
     })

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

@@ -55,6 +55,38 @@ describe('DiscordTokenExtractor', () => {
     })
   })
 
+  describe('getBrowserLevelDBDirs', () => {
+    test('returns browser LevelDB paths on macOS', () => {
+      const darwinExtractor = new DiscordTokenExtractor('darwin')
+      const dirs = darwinExtractor.getBrowserLevelDBDirs()
+
+      const chromeBase = join(homedir(), 'Library', 'Application Support', 'Google', 'Chrome')
+      expect(dirs).toContain(join(chromeBase, 'Default', 'Local Storage', 'leveldb'))
+    })
+
+    test('returns browser LevelDB paths on Linux', () => {
+      const linuxExtractor = new DiscordTokenExtractor('linux')
+      const dirs = linuxExtractor.getBrowserLevelDBDirs()
+
+      const chromeBase = join(homedir(), '.config', 'google-chrome')
+      expect(dirs).toContain(join(chromeBase, 'Default', 'Local Storage', 'leveldb'))
+    })
+
+    test('returns browser LevelDB paths on Windows', () => {
+      const winExtractor = new DiscordTokenExtractor('win32')
+      const dirs = winExtractor.getBrowserLevelDBDirs()
+
+      const localAppData = process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local')
+      const chromeBase = join(localAppData, 'Google', 'Chrome', 'User Data')
+      expect(dirs).toContain(join(chromeBase, 'Default', 'Local Storage', 'leveldb'))
+    })
+
+    test('returns empty array for unsupported platform', () => {
+      const unsupportedExtractor = new DiscordTokenExtractor('freebsd' as NodeJS.Platform)
+      expect(unsupportedExtractor.getBrowserLevelDBDirs()).toEqual([])
+    })
+  })
+
   describe('token patterns', () => {
     test('validates standard token format (base64.base64.base64)', () => {
       const validToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.ZZZZZZZZZZZZZZZZZZZZZZZZZ'
@@ -167,77 +199,217 @@ describe('DiscordTokenExtractor', () => {
   })
 
   describe('extract', () => {
-    test('returns null when no Discord directories exist on linux', async () => {
+    test('returns empty array when no Discord directories exist on linux', async () => {
       const linuxExtractor = new DiscordTokenExtractor('linux')
-      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue(null)
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([])
+      const extractFromBrowserLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([])
 
       const result = await linuxExtractor.extract()
-      expect(result).toBeNull()
+      expect(result).toEqual([])
 
       extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
     })
 
     test('extracts token from LevelDB when available', async () => {
       const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.ZZZZZZZZZZZZZZZZZZZZZZZZZ'
 
       const linuxExtractor = new DiscordTokenExtractor('linux')
-      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue({
-        token: mockToken,
-      })
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([
+        { token: mockToken },
+      ])
+      const extractFromBrowserLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([])
 
       const result = await linuxExtractor.extract()
 
-      expect(result).not.toBeNull()
-      expect(result?.token).toBe(mockToken)
+      expect(result).not.toEqual([])
+      expect(result[0]?.token).toBe(mockToken)
 
       extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
     })
 
-    test('tries CDP on macOS when LevelDB extraction fails', async () => {
+    test('tries browser LevelDB when desktop LevelDB extraction fails', async () => {
+      const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.browser_token_1234567890123'
+
+      const linuxExtractor = new DiscordTokenExtractor('linux')
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([])
+      const extractFromBrowserLevelDBSpy = spyOn(
+        linuxExtractor as any,
+        'extractFromBrowserLevelDB',
+      ).mockResolvedValue([{ token: mockToken }])
+
+      const result = await linuxExtractor.extract()
+
+      expect(extractFromLevelDBSpy).toHaveBeenCalled()
+      expect(extractFromBrowserLevelDBSpy).toHaveBeenCalled()
+      expect(result[0]?.token).toBe(mockToken)
+
+      extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+    })
+
+    test('tries CDP on macOS when both LevelDB extractions fail', async () => {
       const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.cdp_token_12345678901234567'
 
       const darwinExtractor = new DiscordTokenExtractor('darwin', 0)
-      const extractFromLevelDBSpy = spyOn(darwinExtractor as any, 'extractFromLevelDB').mockResolvedValue(null)
+      const extractFromLevelDBSpy = spyOn(darwinExtractor as any, 'extractFromLevelDB').mockResolvedValue([])
+      const extractFromBrowserLevelDBSpy = spyOn(
+        darwinExtractor as any,
+        'extractFromBrowserLevelDB',
+      ).mockResolvedValue([])
       const tryExtractViaCDPSpy = spyOn(darwinExtractor as any, 'tryExtractViaCDP').mockResolvedValue(mockToken)
 
       const result = await darwinExtractor.extract()
 
-      expect(result).not.toBeNull()
-      expect(result?.token).toBe(mockToken)
+      expect(extractFromLevelDBSpy).toHaveBeenCalled()
+      expect(extractFromBrowserLevelDBSpy).toHaveBeenCalled()
+      expect(tryExtractViaCDPSpy).toHaveBeenCalled()
+      expect(result[0]?.token).toBe(mockToken)
 
       extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
       tryExtractViaCDPSpy.mockRestore()
     })
 
-    test('returns first valid token found across variants', async () => {
+    test('browser LevelDB tried before CDP on macOS', async () => {
+      const callOrder: string[] = []
+
+      const darwinExtractor = new DiscordTokenExtractor('darwin', 0)
+      const extractFromLevelDBSpy = spyOn(darwinExtractor as any, 'extractFromLevelDB').mockImplementation(async () => {
+        callOrder.push('desktop')
+        return []
+      })
+      const extractFromBrowserLevelDBSpy = spyOn(
+        darwinExtractor as any,
+        'extractFromBrowserLevelDB',
+      ).mockImplementation(async () => {
+        callOrder.push('browser')
+        return []
+      })
+      const tryExtractViaCDPSpy = spyOn(darwinExtractor as any, 'tryExtractViaCDP').mockImplementation(async () => {
+        callOrder.push('cdp')
+        return null
+      })
+
+      await darwinExtractor.extract()
+
+      expect(callOrder).toEqual(['desktop', 'browser', 'cdp'])
+
+      extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+      tryExtractViaCDPSpy.mockRestore()
+    })
+
+    test('returns all valid tokens found across variants', async () => {
       const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.first_token_found_1234567'
 
       const linuxExtractor = new DiscordTokenExtractor('linux')
-      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue({
-        token: mockToken,
-      })
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([
+        { token: mockToken },
+      ])
+      const extractFromBrowserLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([])
+
+      const result = await linuxExtractor.extract()
+
+      expect(result).not.toEqual([])
+      expect(typeof result[0]?.token).toBe('string')
+
+      extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+    })
+
+    test('deduplicates the same token found in desktop and browser sources', async () => {
+      const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.ZZZZZZZZZZZZZZZZZZZZZZZZZ'
+
+      const linuxExtractor = new DiscordTokenExtractor('linux')
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([
+        { token: mockToken },
+      ])
+      const extractFromBrowserLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([
+        { token: mockToken },
+      ])
+
+      const result = await linuxExtractor.extract()
+      expect(result).toHaveLength(1)
+      expect(result[0]?.token).toBe(mockToken)
+
+      extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+    })
+
+    test('collects multiple distinct tokens from browser profiles', async () => {
+      const token1 = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.browser_token_1234567890123'
+      const token2 = 'YYYYYYYYYYYYYYYYYYYYYYYY.ZZZZZZ.browser_token_2345678901234'
+
+      const linuxExtractor = new DiscordTokenExtractor('linux')
+      const extractFromLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromLevelDB').mockResolvedValue([])
+      const extractFromBrowserLevelDBSpy = spyOn(linuxExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([
+        { token: token1 },
+        { token: token2 },
+      ])
 
       const result = await linuxExtractor.extract()
+      expect(result).toHaveLength(2)
+      expect(result.map((r) => r.token)).toContain(token1)
+      expect(result.map((r) => r.token)).toContain(token2)
+
+      extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+    })
+
+    test('does not call CDP when desktop LevelDB extraction returns results', async () => {
+      const mockToken = 'XXXXXXXXXXXXXXXXXXXXXXXX.YYYYYY.ZZZZZZZZZZZZZZZZZZZZZZZZZ'
 
-      expect(result).not.toBeNull()
-      expect(typeof result?.token).toBe('string')
+      const darwinExtractor = new DiscordTokenExtractor('darwin', 0)
+      const extractFromLevelDBSpy = spyOn(darwinExtractor as any, 'extractFromLevelDB').mockResolvedValue([
+        { token: mockToken },
+      ])
+      const extractFromBrowserLevelDBSpy = spyOn(darwinExtractor as any, 'extractFromBrowserLevelDB').mockResolvedValue([])
+      const tryExtractViaCDPSpy = spyOn(darwinExtractor as any, 'tryExtractViaCDP').mockResolvedValue(null)
+
+      await darwinExtractor.extract()
+      expect(tryExtractViaCDPSpy).not.toHaveBeenCalled()
 
       extractFromLevelDBSpy.mockRestore()
+      extractFromBrowserLevelDBSpy.mockRestore()
+      tryExtractViaCDPSpy.mockRestore()
     })
   })
 
   describe('getKeychainVariants', () => {
-    test('returns keychain variants for macOS', () => {
+    test('includes Discord-specific keychain variants', () => {
       const macExtractor = new DiscordTokenExtractor('darwin')
+      const variants = macExtractor.getKeychainVariants()
+
+      expect(variants).toContainEqual({ service: 'discord Safe Storage', account: 'discord Key' })
+      expect(variants).toContainEqual({ service: 'discordcanary Safe Storage', account: 'discordcanary Key' })
+      expect(variants).toContainEqual({ service: 'discordptb Safe Storage', account: 'discordptb Key' })
+      expect(variants).toContainEqual({ service: 'Discord Safe Storage', account: 'Discord' })
+      expect(variants).toContainEqual({ service: 'Discord Canary Safe Storage', account: 'Discord Canary' })
+      expect(variants).toContainEqual({ service: 'Discord PTB Safe Storage', account: 'Discord PTB' })
+    })
 
-      expect(macExtractor.getKeychainVariants()).toEqual([
-        { 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' },
-      ])
+    test('includes browser keychain variants appended after Discord entries', () => {
+      const macExtractor = new DiscordTokenExtractor('darwin')
+      const variants = macExtractor.getKeychainVariants()
+
+      expect(variants).toContainEqual({ service: 'Chrome Safe Storage', account: 'Chrome' })
+      expect(variants).toContainEqual({ service: 'Chrome Canary Safe Storage', account: 'Chrome Canary' })
+      expect(variants).toContainEqual({ service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' })
+      expect(variants).toContainEqual({ service: 'Arc Safe Storage', account: 'Arc' })
+      expect(variants).toContainEqual({ service: 'Brave Safe Storage', account: 'Brave' })
+      expect(variants).toContainEqual({ service: 'Vivaldi Safe Storage', account: 'Vivaldi' })
+      expect(variants).toContainEqual({ service: 'Chromium Safe Storage', account: 'Chromium' })
+    })
+
+    test('Discord entries come before browser entries', () => {
+      const macExtractor = new DiscordTokenExtractor('darwin')
+      const variants = macExtractor.getKeychainVariants()
+
+      const discordIdx = variants.findIndex((v) => v.service === 'discord Safe Storage')
+      const chromeIdx = variants.findIndex((v) => v.service === 'Chrome Safe Storage')
+      expect(discordIdx).toBeLessThan(chromeIdx)
     })
   })