agent-messenger 2.10.1 → 2.11.0

package/src/platforms/slackbot/client.ts

@@ -1,13 +1,28 @@
 import { WebClient } from '@slack/web-api'
 
 import { SlackBotCredentialManager } from './credential-manager'
-import { SlackBotError, type SlackChannel, type SlackMessage, type SlackUser } from './types'
+import { SlackBotError, type SlackChannel, type SlackFile, type SlackMessage, type SlackUser } from './types'
 
 const MAX_RETRIES = 3
 const RATE_LIMIT_ERROR_CODE = 'slack_webapi_rate_limited_error'
 
+function mapSlackFile(f: any): SlackFile {
+  return {
+    id: f?.id || '',
+    name: f?.name || '',
+    title: f?.title || f?.name || '',
+    mimetype: f?.mimetype || 'application/octet-stream',
+    size: f?.size || 0,
+    url_private: f?.url_private || '',
+    created: f?.created || 0,
+    user: f?.user || '',
+    channels: f?.channels,
+  }
+}
+
 export class SlackBotClient {
   private client: WebClient | null = null
+  private token: string | null = null
 
   async login(credentials?: { token: string }): Promise<this> {
     if (credentials) {
@@ -18,6 +33,7 @@ export class SlackBotClient {
       if (!token.startsWith('xoxb-')) {
         throw new SlackBotError('Token must be a bot token (xoxb-)', 'invalid_token_type')
       }
+      this.token = token
       this.client = new WebClient(token)
     } else {
       const credManager = new SlackBotCredentialManager()
@@ -52,7 +68,9 @@ export class SlackBotClient {
         break
       }
     }
-    throw new SlackBotError(lastError?.message || 'Unknown error', (lastError as any)?.code || 'unknown_error')
+    const code = (lastError as any)?.code || 'unknown_error'
+    const retryAfter = code === RATE_LIMIT_ERROR_CODE ? (lastError as any)?.retryAfter : undefined
+    throw new SlackBotError(lastError?.message || 'Unknown error', code, retryAfter)
   }
 
   private sleep(ms: number): Promise<void> {
@@ -451,6 +469,17 @@ export class SlackBotClient {
     })
   }
 
+  async setAssistantStatus(channel: string, threadTs: string, status: string): Promise<void> {
+    return this.withRetry(async () => {
+      const response = await this.ensureAuth().assistant.threads.setStatus({
+        channel_id: channel,
+        thread_ts: threadTs,
+        status,
+      })
+      this.checkResponse(response)
+    })
+  }
+
   async joinChannel(channel: string): Promise<void> {
     return this.withRetry(async () => {
       const response = await this.ensureAuth().conversations.join({ channel })
@@ -464,4 +493,103 @@ export class SlackBotClient {
       this.checkResponse(response)
     })
   }
+
+  async uploadFile(
+    channel: string,
+    file: Buffer,
+    filename: string,
+    options?: { thread_ts?: string; title?: string; initial_comment?: string },
+  ): Promise<SlackFile> {
+    return this.withRetry(async () => {
+      const response = await this.ensureAuth().files.uploadV2({
+        channel_id: channel,
+        file,
+        filename,
+        thread_ts: options?.thread_ts,
+        title: options?.title,
+        initial_comment: options?.initial_comment,
+      })
+      this.checkResponse(response)
+
+      const completionFiles = (response as any).files?.[0]?.files
+      const f = completionFiles?.[0]
+      if (!f) {
+        throw new SlackBotError('No file returned in upload response', 'file_not_found')
+      }
+      return mapSlackFile(f)
+    })
+  }
+
+  async listFiles(options?: { channel?: string; user?: string; limit?: number }): Promise<SlackFile[]> {
+    return this.withRetry(async () => {
+      const response = await this.ensureAuth().files.list({
+        channel: options?.channel,
+        user: options?.user,
+        count: options?.limit,
+      })
+      this.checkResponse(response)
+
+      return (response.files || []).map((f) => mapSlackFile(f))
+    })
+  }
+
+  async getFileInfo(fileId: string): Promise<SlackFile> {
+    return this.withRetry(async () => {
+      const response = await this.ensureAuth().files.info({ file: fileId })
+      this.checkResponse(response)
+
+      return mapSlackFile(response.file)
+    })
+  }
+
+  async downloadFile(fileId: string): Promise<{ buffer: Buffer; file: SlackFile }> {
+    const file = await this.getFileInfo(fileId)
+
+    if (!file.url_private) {
+      throw new SlackBotError('File has no download URL', 'no_download_url')
+    }
+
+    if (!this.token) {
+      throw new SlackBotError('Not authenticated. Call .login() first.', 'not_authenticated')
+    }
+
+    const response = await fetch(file.url_private, {
+      headers: { Authorization: `Bearer ${this.token}` },
+    })
+
+    if (!response.ok) {
+      throw new SlackBotError(`Failed to download file: ${response.statusText}`, 'download_failed')
+    }
+
+    const arrayBuffer = await response.arrayBuffer()
+    return {
+      buffer: Buffer.from(arrayBuffer),
+      file,
+    }
+  }
+
+  async deleteFile(fileId: string): Promise<void> {
+    return this.withRetry(async () => {
+      const response = await this.ensureAuth().files.delete({ file: fileId })
+      this.checkResponse(response)
+    })
+  }
+
+  async appsConnectionsOpen(appToken: string): Promise<{ url: string }> {
+    if (!appToken) {
+      throw new SlackBotError('App-level token is required for Socket Mode', 'missing_app_token')
+    }
+    if (!appToken.startsWith('xapp-')) {
+      throw new SlackBotError(
+        'Token must be an app-level token (xapp-) with connections:write scope',
+        'invalid_app_token_type',
+      )
+    }
+
+    return this.withRetry(async () => {
+      const response = await new WebClient(appToken).apps.connections.open()
+      this.checkResponse(response)
+      return { url: (response as { url: string }).url }
+    })
+  }
 }

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

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, it } from 'bun:test'
 import { existsSync, rmSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -46,7 +46,7 @@ describe('auth commands', () => {
   })
 
   describe('setAction', () => {
-    test('validates and stores bot token with default bot_id from auth', async () => {
+    it('validates and stores bot token with default bot_id from auth', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await setAction('xoxb-test-token', { _credManager: manager })
@@ -60,7 +60,7 @@ describe('auth commands', () => {
       expect(creds?.bot_id).toBe('B789')
     })
 
-    test('uses --bot flag as bot_id', async () => {
+    it('uses --bot flag as bot_id', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await setAction('xoxb-test-token', { bot: 'deploy', _credManager: manager })
@@ -70,7 +70,7 @@ describe('auth commands', () => {
       expect(creds?.token).toBe('xoxb-test-token')
     })
 
-    test('rejects user tokens', async () => {
+    it('rejects user tokens', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await setAction('xoxp-user-token', { _credManager: manager })
@@ -79,7 +79,7 @@ describe('auth commands', () => {
       expect(result.error).toContain('bot token')
     })
 
-    test('rejects invalid token format', async () => {
+    it('rejects invalid token format', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await setAction('invalid-token', { _credManager: manager })
@@ -89,7 +89,7 @@ describe('auth commands', () => {
   })
 
   describe('clearAction', () => {
-    test('removes all stored credentials', async () => {
+    it('removes all stored credentials', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-token',
@@ -107,7 +107,7 @@ describe('auth commands', () => {
   })
 
   describe('statusAction', () => {
-    test('returns no credentials when none set', async () => {
+    it('returns no credentials when none set', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await statusAction({ _credManager: manager })
@@ -116,7 +116,7 @@ describe('auth commands', () => {
       expect(result.error).toBeDefined()
     })
 
-    test('returns valid status for current bot', async () => {
+    it('returns valid status for current bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-token',
@@ -133,7 +133,7 @@ describe('auth commands', () => {
       expect(result.bot_id).toBe('mybot')
     })
 
-    test('returns status for specific --bot', async () => {
+    it('returns status for specific --bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-token',
@@ -158,7 +158,7 @@ describe('auth commands', () => {
   })
 
   describe('listAction', () => {
-    test('returns all stored bots', async () => {
+    it('returns all stored bots', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-a',
@@ -183,7 +183,7 @@ describe('auth commands', () => {
   })
 
   describe('useAction', () => {
-    test('switches current bot', async () => {
+    it('switches current bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-a',
@@ -206,7 +206,7 @@ describe('auth commands', () => {
       expect(result.bot_id).toBe('deploy')
     })
 
-    test('returns error for unknown bot', async () => {
+    it('returns error for unknown bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await useAction('nonexistent', { _credManager: manager })
@@ -216,7 +216,7 @@ describe('auth commands', () => {
   })
 
   describe('removeAction', () => {
-    test('removes a stored bot', async () => {
+    it('removes a stored bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
       await manager.setCredentials({
         token: 'xoxb-a',
@@ -232,7 +232,7 @@ describe('auth commands', () => {
       expect(await manager.getCredentials('deploy')).toBeNull()
     })
 
-    test('returns error for unknown bot', async () => {
+    it('returns error for unknown bot', async () => {
       const manager = new SlackBotCredentialManager(tempDir)
 
       const result = await removeAction('nonexistent', { _credManager: manager })

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

@@ -1,5 +1,6 @@
 import { Command } from 'commander'
 
+import { cliOutput } from '@/shared/utils/cli-output'
 import { formatOutput } from '@/shared/utils/output'
 
 import { SlackBotClient } from '../client'
@@ -177,11 +178,6 @@ export async function removeAction(botId: string, options: ActionOptions): Promi
   }
 }
 
-function cliOutput(result: ActionResult, pretty?: boolean, exitOnError = true): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error && exitOnError) process.exit(1)
-}
-
 export const authCommand = new Command('auth')
   .description('Bot authentication commands')
   .addCommand(

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

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { beforeEach, describe, expect, mock, it } from 'bun:test'
 
 const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
 const mockListChannels = mock(() =>
@@ -55,7 +55,7 @@ describe('channel commands', () => {
   })
 
   describe('listChannels', () => {
-    test('returns list of channels', async () => {
+    it('returns list of channels', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -68,7 +68,7 @@ describe('channel commands', () => {
       expect(channels[1].name).toBe('random')
     })
 
-    test('includes channel metadata', async () => {
+    it('includes channel metadata', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -84,7 +84,7 @@ describe('channel commands', () => {
       expect(channel.created).toBeDefined()
     })
 
-    test('passes limit option', async () => {
+    it('passes limit option', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -97,7 +97,7 @@ describe('channel commands', () => {
   })
 
   describe('getChannelInfo', () => {
-    test('returns channel details', async () => {
+    it('returns channel details', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -110,7 +110,7 @@ describe('channel commands', () => {
       expect(channel.is_private).toBe(false)
     })
 
-    test('includes topic and purpose', async () => {
+    it('includes topic and purpose', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -124,7 +124,7 @@ describe('channel commands', () => {
   })
 
   describe('resolveChannel', () => {
-    test('resolves channel name to ID', async () => {
+    it('resolves channel name to ID', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 

package/src/platforms/slackbot/commands/file.test.ts

@@ -0,0 +1,201 @@
+import { beforeEach, describe, expect, mock, it } from 'bun:test'
+
+const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
+const mockUploadFile = mock(() =>
+  Promise.resolve({
+    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: ['C123456'],
+  }),
+)
+const mockListFiles = mock(() =>
+  Promise.resolve([
+    {
+      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: ['C123456'],
+    },
+    {
+      id: 'F456',
+      name: 'document.pdf',
+      title: 'document.pdf',
+      mimetype: 'application/pdf',
+      size: 2048,
+      url_private: 'https://files.slack.com/files-pri/T123-F456/document.pdf',
+      created: 1234567891,
+      user: 'U456',
+      channels: ['C123456'],
+    },
+  ]),
+)
+const mockGetFileInfo = mock(() =>
+  Promise.resolve({
+    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: ['C123456'],
+  }),
+)
+const mockDownloadFile = mock(() =>
+  Promise.resolve({
+    buffer: Buffer.from('downloaded content'),
+    file: {
+      id: 'F123',
+      name: 'test.txt',
+      title: 'test.txt',
+      mimetype: 'text/plain',
+      size: 18,
+      url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+      created: 1234567890,
+      user: 'U123',
+      channels: ['C123456'],
+    },
+  }),
+)
+const mockDeleteFile = mock(() => Promise.resolve())
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    resolveChannel = mockResolveChannel
+    uploadFile = mockUploadFile
+    listFiles = mockListFiles
+    getFileInfo = mockGetFileInfo
+    downloadFile = mockDownloadFile
+    deleteFile = mockDeleteFile
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('file commands', () => {
+  beforeEach(() => {
+    mockResolveChannel.mockClear()
+    mockUploadFile.mockClear()
+    mockListFiles.mockClear()
+    mockGetFileInfo.mockClear()
+    mockDownloadFile.mockClear()
+    mockDeleteFile.mockClear()
+  })
+
+  describe('uploadFile', () => {
+    it('uploads a file to a channel', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const file = await client.uploadFile('C123456', Buffer.from('test content'), 'test.txt')
+
+      // then
+      expect(file.id).toBe('F123')
+      expect(file.name).toBe('test.txt')
+      expect(file.channels).toContain('C123456')
+    })
+
+    it('forwards thread, title, and initial_comment options', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.uploadFile('C123456', Buffer.from('x'), 'test.txt', {
+        thread_ts: '1234567890.000100',
+        title: 'My Title',
+        initial_comment: 'Here you go',
+      })
+
+      // then
+      expect(mockUploadFile).toHaveBeenCalledWith('C123456', Buffer.from('x'), 'test.txt', {
+        thread_ts: '1234567890.000100',
+        title: 'My Title',
+        initial_comment: 'Here you go',
+      })
+    })
+  })
+
+  describe('listFiles', () => {
+    it('returns all files visible to the bot', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const files = await client.listFiles()
+
+      // then
+      expect(files).toHaveLength(2)
+      expect(files[0].name).toBe('test.txt')
+      expect(files[1].name).toBe('document.pdf')
+    })
+
+    it('forwards channel/user/limit filters', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listFiles({ channel: 'C123456', user: 'U123', limit: 50 })
+
+      // then
+      expect(mockListFiles).toHaveBeenCalledWith({ channel: 'C123456', user: 'U123', limit: 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.name).toBe('test.txt')
+      expect(file.url_private).toBe('https://files.slack.com/files-pri/T123-F123/test.txt')
+    })
+  })
+
+  describe('downloadFile', () => {
+    it('returns buffer and file metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const result = await client.downloadFile('F123')
+
+      // then
+      expect(result.file.id).toBe('F123')
+      expect(result.buffer.toString()).toBe('downloaded content')
+    })
+  })
+
+  describe('deleteFile', () => {
+    it("deletes the bot's file", async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.deleteFile('F123')
+
+      // then
+      expect(mockDeleteFile).toHaveBeenCalledWith('F123')
+    })
+  })
+})