agent-messenger 2.10.2 → 2.11.1

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

@@ -6,11 +6,20 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
+import { ChromiumCookieDecryptor } from '@/shared/chromium'
+
 import { ExtractedWorkspace, TokenExtractor } from './token-extractor'
 
 const tempDirs: string[] = []
+const originalAgentBrowserProfile = process.env.AGENT_BROWSER_PROFILE
 
 afterEach(() => {
+  if (originalAgentBrowserProfile) {
+    process.env.AGENT_BROWSER_PROFILE = originalAgentBrowserProfile
+  } else {
+    delete process.env.AGENT_BROWSER_PROFILE
+  }
+
   for (const dir of tempDirs) {
     rmSync(dir, { recursive: true, force: true })
   }
@@ -802,6 +811,52 @@ describe('TokenExtractor browser fallback', () => {
     expect(result).toEqual([])
   })
 
+  it('resolves Local State from agent-browser profile root for encrypted cookies', async () => {
+    // given
+    const agentBrowserProfile = mkdtempSync(join(tmpdir(), 'agent-browser-slack-profile-'))
+    tempDirs.push(agentBrowserProfile)
+    process.env.AGENT_BROWSER_PROFILE = agentBrowserProfile
+
+    const hex64 = 'c'.repeat(64)
+    const token = `xoxc-1111111111-2222222222-3333333333-${hex64}`
+    const profileDir = join(agentBrowserProfile, 'Default')
+    const leveldbDir = join(profileDir, 'Local Storage', 'leveldb')
+    const networkDir = join(profileDir, 'Network')
+    mkdirSync(leveldbDir, { recursive: true })
+    mkdirSync(networkDir, { recursive: true })
+    writeFileSync(join(leveldbDir, '000001.log'), `"${token}"T12345678"name":"agent-browser-workspace"`)
+    writeFileSync(join(agentBrowserProfile, 'Local State'), '{}')
+    createCookiesDb(join(networkDir, 'Cookies'), [
+      {
+        name: 'd',
+        value: '',
+        encrypted_value: new Uint8Array([1, 2, 3]),
+        host_key: '.slack.com',
+        last_access_utc: 1,
+      },
+    ])
+    const decryptSpy = spyOn(ChromiumCookieDecryptor.prototype, 'decryptCookie').mockReturnValue('xoxd-AgentBrowser')
+
+    try {
+      // when
+      const extractor = new TokenExtractor('darwin', join(agentBrowserProfile, 'missing-desktop'))
+      const result = await extractor.extractFromBrowsers()
+
+      // then
+      expect(result).toEqual([
+        {
+          workspace_id: 'T12345678',
+          workspace_name: 'agent-browser-workspace',
+          token,
+          cookie: 'xoxd-AgentBrowser',
+        },
+      ])
+      expect(decryptSpy).toHaveBeenCalledWith(Buffer.from([1, 2, 3]), join(agentBrowserProfile, 'Local State'))
+    } finally {
+      decryptSpy.mockRestore()
+    }
+  })
+
   it('extract tries desktop before browser profiles', async () => {
     // given — slackDir with LevelDB token data
     const slackDir = mkdtempSync(join(tmpdir(), 'slack-fallback-desktop-'))
@@ -826,6 +881,47 @@ describe('TokenExtractor browser fallback', () => {
     extractFromBrowsersSpy.mockRestore()
   })
 
+  it('custom browser profile can upgrade desktop token with a cookie', async () => {
+    // given
+    const slackDir = mkdtempSync(join(tmpdir(), 'slack-custom-cookie-upgrade-'))
+    tempDirs.push(slackDir)
+
+    const hex64 = 'd'.repeat(64)
+    const token = `xoxc-1111111111-2222222222-3333333333-${hex64}`
+    const leveldbDir = join(slackDir, 'Local Storage', 'leveldb')
+    mkdirSync(leveldbDir, { recursive: true })
+    writeFileSync(join(leveldbDir, '000001.log'), `"${token}"T12345678"name":"desktop-workspace"`)
+
+    const browserWorkspace: ExtractedWorkspace = {
+      workspace_id: 'T12345678',
+      workspace_name: 'browser-workspace',
+      token,
+      cookie: 'xoxd-browser-cookie',
+    }
+    const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype as any, 'extractFromBrowsers').mockResolvedValue([
+      browserWorkspace,
+    ])
+
+    try {
+      // when
+      const extractor = new TokenExtractor('darwin', slackDir, undefined, undefined, ['/tmp/custom-profile'])
+      const result = await extractor.extract()
+
+      // then
+      expect(extractFromBrowsersSpy).toHaveBeenCalled()
+      expect(result).toEqual([
+        {
+          workspace_id: 'T12345678',
+          workspace_name: 'desktop-workspace',
+          token,
+          cookie: 'xoxd-browser-cookie',
+        },
+      ])
+    } finally {
+      extractFromBrowsersSpy.mockRestore()
+    }
+  })
+
   it('extract falls back to browser profiles when desktop has no tokens', async () => {
     // given — empty slackDir (no tokens)
     const slackDir = mkdtempSync(join(tmpdir(), 'slack-fallback-browser-'))

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

@@ -12,7 +12,9 @@ import {
   ChromiumCookieDecryptor,
   ChromiumCookieReader,
   discoverBrowserProfileDirs,
+  findLocalStatePath,
   getBrowserBasePath,
+  getAgentBrowserProfileDirs,
 } from '@/shared/chromium'
 import { DerivedKeyCache } from '@/shared/utils/derived-key-cache'
 import { lookupLinuxKeyringPassword } from '@/shared/utils/linux-keyring'
@@ -63,12 +65,14 @@ export class TokenExtractor {
   private debugLog: ((message: string) => void) | null
   private browserDecryptor: ChromiumCookieDecryptor
   private browserCookieReader: ChromiumCookieReader
+  private customBrowserProfileDirs: string[]
 
   constructor(
     platform?: NodeJS.Platform,
     slackDir?: string,
     keyCache?: DerivedKeyCache,
     debugLog?: (message: string) => void,
+    customBrowserProfileDirs?: string[],
   ) {
     this.platform = platform ?? process.platform
 
@@ -79,6 +83,7 @@ export class TokenExtractor {
     this.slackDir = slackDir ?? this.getSlackDir()
     this.keyCache = keyCache ?? new DerivedKeyCache()
     this.debugLog = debugLog ?? null
+    this.customBrowserProfileDirs = customBrowserProfileDirs ?? []
     this.browserDecryptor = new ChromiumCookieDecryptor({ platform: this.platform })
     this.browserCookieReader = new ChromiumCookieReader()
   }
@@ -188,6 +193,9 @@ export class TokenExtractor {
   }
 
   async extract(): Promise<ExtractedWorkspace[]> {
+    const results: ExtractedWorkspace[] = []
+    const seenTokens = new Set<string>()
+
     if (existsSync(this.slackDir)) {
       await this.getDerivedKeyAsync()
 
@@ -201,27 +209,55 @@ export class TokenExtractor {
           if (this.cachedKey) {
             await this.keyCache.set('slack', this.cachedKey)
             const retryCookie = await this.extractCookieFromSQLite()
-            return tokens.map((t) => ({
-              workspace_id: t.teamId,
-              workspace_name: t.teamName,
-              token: t.token,
-              cookie: retryCookie,
-            }))
+            this.addExtractedWorkspaces(results, seenTokens, tokens, retryCookie)
+            return this.customBrowserProfileDirs.length > 0 ? this.mergeBrowserResults(results, seenTokens) : results
           }
         }
 
-        return tokens.map((t) => ({
-          workspace_id: t.teamId,
-          workspace_name: t.teamName,
-          token: t.token,
-          cookie: cookie,
-        }))
+        this.addExtractedWorkspaces(results, seenTokens, tokens, cookie)
+        return this.customBrowserProfileDirs.length > 0 ? this.mergeBrowserResults(results, seenTokens) : results
       }
     }
 
     return this.extractFromBrowsers()
   }
 
+  private async mergeBrowserResults(
+    results: ExtractedWorkspace[],
+    seenTokens: Set<string>,
+  ): Promise<ExtractedWorkspace[]> {
+    for (const workspace of await this.extractFromBrowsers()) {
+      const existing = results.find((item) => item.token === workspace.token)
+      if (existing) {
+        if (!existing.cookie && workspace.cookie) {
+          existing.cookie = workspace.cookie
+        }
+        continue
+      }
+      seenTokens.add(workspace.token)
+      results.push(workspace)
+    }
+    return results
+  }
+
+  private addExtractedWorkspaces(
+    results: ExtractedWorkspace[],
+    seenTokens: Set<string>,
+    tokens: TokenInfo[],
+    cookie: string,
+  ): void {
+    for (const token of tokens) {
+      if (seenTokens.has(token.token)) continue
+      seenTokens.add(token.token)
+      results.push({
+        workspace_id: token.teamId,
+        workspace_name: token.teamName,
+        token: token.token,
+        cookie,
+      })
+    }
+  }
+
   async extractFromBrowsers(): Promise<ExtractedWorkspace[]> {
     const results: ExtractedWorkspace[] = []
     const seenTokens = new Set<string>()
@@ -259,6 +295,33 @@ export class TokenExtractor {
       }
     }
 
+    for (const profileDir of getAgentBrowserProfileDirs({ customProfileDirs: this.customBrowserProfileDirs })) {
+      const leveldbDir = join(profileDir, 'Local Storage', 'leveldb')
+      if (!existsSync(leveldbDir)) continue
+
+      let tokenInfos: TokenInfo[]
+      try {
+        tokenInfos = await this.extractFromLevelDB(leveldbDir, 'local-storage')
+      } catch {
+        continue
+      }
+
+      if (tokenInfos.length === 0) continue
+
+      const cookie = await this.extractCookieFromBrowserProfile(profileDir, profileDir)
+
+      for (const t of tokenInfos) {
+        if (seenTokens.has(t.token)) continue
+        seenTokens.add(t.token)
+        results.push({
+          workspace_id: t.teamId,
+          workspace_name: t.teamName,
+          token: t.token,
+          cookie,
+        })
+      }
+    }
+
     return results
   }
 
@@ -293,7 +356,7 @@ export class TokenExtractor {
     if (row.value?.startsWith('xoxd-')) return row.value
 
     if (row.encrypted_value && row.encrypted_value.length > 0) {
-      const localStatePath = join(browserBase, 'Local State')
+      const localStatePath = findLocalStatePath(cookiesPath) ?? join(browserBase, 'Local State')
       const decrypted = this.browserDecryptor.decryptCookie(
         Buffer.from(row.encrypted_value),
         existsSync(localStatePath) ? localStatePath : undefined,

package/src/platforms/slackbot/cli.ts

@@ -6,6 +6,7 @@ import pkg from '../../../package.json' with { type: 'json' }
 import {
   authCommand,
   channelCommand,
+  fileCommand,
   messageCommand,
   reactionCommand,
   userCommand,
@@ -18,7 +19,17 @@ program
   .name('agent-slackbot')
   .description('CLI tool for Slack bot integration using bot tokens (xoxb-)')
   .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
   .option('--bot <id>', 'Use specific bot (default: current)')
+  .hook('preAction', (thisCmd, actionCmd) => {
+    for (const [key, value] of Object.entries(thisCmd.opts())) {
+      if (value === undefined) continue
+      const source = actionCmd.getOptionValueSource(key)
+      if (source === undefined || source === 'default') {
+        actionCmd.setOptionValue(key, value)
+      }
+    }
+  })
 
 program.addCommand(authCommand)
 program.addCommand(whoamiCommand)
@@ -26,7 +37,8 @@ program.addCommand(messageCommand)
 program.addCommand(channelCommand)
 program.addCommand(userCommand)
 program.addCommand(reactionCommand)
+program.addCommand(fileCommand)
 
-program.parse(process.argv)
+program.parseAsync(process.argv)
 
 export default program

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

@@ -65,6 +65,70 @@ const mockReactions = {
   add: mock(() => Promise.resolve({ ok: true })),
   remove: mock(() => Promise.resolve({ ok: true })),
 }
+const mockAssistant = {
+  threads: {
+    setStatus: mock(() => Promise.resolve({ ok: true })),
+  },
+}
+const mockFiles = {
+  uploadV2: mock(() =>
+    Promise.resolve({
+      ok: true,
+      files: [
+        {
+          ok: true,
+          files: [
+            {
+              id: 'F123',
+              name: 'test.txt',
+              title: 'test.txt',
+              mimetype: 'text/plain',
+              size: 12,
+              url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+              created: 1234567890,
+              user: 'U123',
+              channels: ['C123'],
+            },
+          ],
+        },
+      ],
+    }),
+  ),
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      files: [
+        {
+          id: 'F123',
+          name: 'test.txt',
+          title: 'test.txt',
+          mimetype: 'text/plain',
+          size: 1024,
+          url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+          created: 1234567890,
+          user: 'U123',
+        },
+      ],
+    }),
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      file: {
+        id: 'F123',
+        name: 'test.txt',
+        title: 'test.txt',
+        mimetype: 'text/plain',
+        size: 1024,
+        url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+        created: 1234567890,
+        user: 'U123',
+        channels: ['C123'],
+      },
+    }),
+  ),
+  delete: mock(() => Promise.resolve({ ok: true })),
+}
 const mockUsers = {
   list: mock(() =>
     Promise.resolve({
@@ -105,6 +169,8 @@ mock.module('@slack/web-api', () => ({
     chat = mockChat
     reactions = mockReactions
     users = mockUsers
+    files = mockFiles
+    assistant = mockAssistant
   },
 }))
 
@@ -120,6 +186,11 @@ describe('SlackBotClient', () => {
     mockReactions.remove.mockClear()
     mockUsers.list.mockClear()
     mockUsers.info.mockClear()
+    mockFiles.uploadV2.mockClear()
+    mockFiles.list.mockClear()
+    mockFiles.info.mockClear()
+    mockFiles.delete.mockClear()
+    mockAssistant.threads.setStatus.mockClear()
   })
 
   describe('login', () => {
@@ -224,6 +295,38 @@ describe('SlackBotClient', () => {
     })
   })
 
+  describe('setAssistantStatus', () => {
+    it('sets assistant typing status with channel_id and thread_ts', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.setAssistantStatus('C123', '1234567890.123456', 'is typing...')
+
+      // then
+      expect(mockAssistant.threads.setStatus).toHaveBeenCalledWith({
+        channel_id: 'C123',
+        thread_ts: '1234567890.123456',
+        status: 'is typing...',
+      })
+    })
+
+    it('clears status when given empty string', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.setAssistantStatus('C123', '1234567890.123456', '')
+
+      // then
+      expect(mockAssistant.threads.setStatus).toHaveBeenCalledWith({
+        channel_id: 'C123',
+        thread_ts: '1234567890.123456',
+        status: '',
+      })
+    })
+  })
+
   describe('listChannels', () => {
     it('returns list of channels', async () => {
       // given
@@ -367,4 +470,175 @@ describe('SlackBotClient', () => {
       expect(user.name).toBe('testuser')
     })
   })
+
+  describe('uploadFile', () => {
+    it('uploads file via files.uploadV2 and returns mapped file', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const file = await client.uploadFile('C123', Buffer.from('test content'), 'test.txt')
+
+      // then
+      expect(file.id).toBe('F123')
+      expect(file.name).toBe('test.txt')
+      expect(file.size).toBe(12)
+      expect(mockFiles.uploadV2).toHaveBeenCalledWith(
+        expect.objectContaining({ channel_id: 'C123', filename: 'test.txt' }),
+      )
+    })
+
+    it('forwards thread_ts, title, initial_comment to the SDK', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.uploadFile('C123', Buffer.from('x'), 'test.txt', {
+        thread_ts: '1234567890.123456',
+        title: 'My Title',
+        initial_comment: 'Here you go',
+      })
+
+      // then
+      expect(mockFiles.uploadV2).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel_id: 'C123',
+          filename: 'test.txt',
+          thread_ts: '1234567890.123456',
+          title: 'My Title',
+          initial_comment: 'Here you go',
+        }),
+      )
+    })
+
+    it('throws SlackBotError when API responds not ok', async () => {
+      // given
+      mockFiles.uploadV2.mockResolvedValueOnce({ ok: false, error: 'file_upload_failed' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.uploadFile('C123', Buffer.from('x'), 'test.txt')).rejects.toThrow(SlackBotError)
+    })
+
+    it('throws SlackBotError when completion has no inner files', async () => {
+      // given
+      mockFiles.uploadV2.mockResolvedValueOnce({ ok: true, files: [{ ok: true, files: [] }] } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.uploadFile('C123', Buffer.from('x'), 'test.txt')).rejects.toThrow(SlackBotError)
+    })
+  })
+
+  describe('listFiles', () => {
+    it('returns mapped files', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const files = await client.listFiles()
+
+      // then
+      expect(files).toHaveLength(1)
+      expect(files[0].id).toBe('F123')
+      expect(files[0].mimetype).toBe('text/plain')
+    })
+
+    it('forwards channel/user/limit to the SDK', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listFiles({ channel: 'C123', user: 'U123', limit: 50 })
+
+      // then
+      expect(mockFiles.list).toHaveBeenCalledWith({ channel: 'C123', user: 'U123', count: 50 })
+    })
+  })
+
+  describe('getFileInfo', () => {
+    it('returns file metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const file = await client.getFileInfo('F123')
+
+      // then
+      expect(file.id).toBe('F123')
+      expect(file.url_private).toBe('https://files.slack.com/files-pri/T123-F123/test.txt')
+    })
+
+    it('throws on API failure', async () => {
+      // given
+      mockFiles.info.mockResolvedValueOnce({ ok: false, error: 'file_not_found' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.getFileInfo('F999')).rejects.toThrow(SlackBotError)
+    })
+  })
+
+  describe('downloadFile', () => {
+    it('downloads file content using the bot token', async () => {
+      // given
+      const originalFetch = globalThis.fetch
+      let capturedAuthHeader: string | null = null
+      globalThis.fetch = async (_url: any, init: any = {}) => {
+        capturedAuthHeader = init?.headers?.Authorization ?? null
+        return new Response(Buffer.from('downloaded content'), { status: 200 })
+      }
+
+      try {
+        const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+        // when
+        const result = await client.downloadFile('F123')
+
+        // then
+        expect(capturedAuthHeader).toBe('Bearer xoxb-test-token')
+        expect(result.file.id).toBe('F123')
+        expect(result.buffer.toString()).toBe('downloaded content')
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+
+    it('throws SlackBotError when download HTTP response is not ok', async () => {
+      // given
+      const originalFetch = globalThis.fetch
+      globalThis.fetch = async () => new Response('forbidden', { status: 403, statusText: 'Forbidden' })
+
+      try {
+        const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+        // when/then
+        await expect(client.downloadFile('F123')).rejects.toThrow(SlackBotError)
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+  })
+
+  describe('deleteFile', () => {
+    it('calls files.delete with the given file ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.deleteFile('F123')
+
+      // then
+      expect(mockFiles.delete).toHaveBeenCalledWith({ file: 'F123' })
+    })
+
+    it('throws on API failure', async () => {
+      // given
+      mockFiles.delete.mockResolvedValueOnce({ ok: false, error: 'cant_delete_file' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.deleteFile('F123')).rejects.toThrow(SlackBotError)
+    })
+  })
 })