agent-messenger 2.10.2 → 2.11.1

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.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/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')
+    })
+  })
+})

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

@@ -0,0 +1,212 @@
+import { readFileSync, statSync, writeFileSync } from 'node:fs'
+import { basename, join, resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { type BotOption, getClient } from './shared'
+
+async function uploadAction(
+  channelInput: string,
+  path: string,
+  options: BotOption & { filename?: string; thread?: string; title?: string; comment?: string },
+): Promise<void> {
+  try {
+    const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
+
+    const filePath = resolve(path)
+    const fileBuffer = readFileSync(filePath)
+    const filename = options.filename || basename(filePath) || 'file'
+
+    const file = await client.uploadFile(channel, fileBuffer, filename, {
+      thread_ts: options.thread,
+      title: options.title,
+      initial_comment: options.comment,
+    })
+
+    console.log(
+      formatOutput(
+        {
+          id: file.id,
+          name: file.name,
+          title: file.title,
+          mimetype: file.mimetype,
+          size: file.size,
+          url_private: file.url_private,
+          created: file.created,
+          user: file.user,
+          channels: file.channels,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(options: BotOption & { channel?: string; user?: string; limit?: string }): Promise<void> {
+  try {
+    const client = await getClient(options)
+    const channel = options.channel ? await client.resolveChannel(options.channel) : undefined
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined
+
+    const files = await client.listFiles({ channel, user: options.user, limit })
+
+    console.log(
+      formatOutput(
+        files.map((file) => ({
+          id: file.id,
+          name: file.name,
+          title: file.title,
+          mimetype: file.mimetype,
+          size: file.size,
+          url_private: file.url_private,
+          created: file.created,
+          user: file.user,
+          channels: file.channels,
+        })),
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function infoAction(fileId: string, options: BotOption): Promise<void> {
+  try {
+    const client = await getClient(options)
+    const file = await client.getFileInfo(fileId)
+
+    console.log(
+      formatOutput(
+        {
+          id: file.id,
+          name: file.name,
+          title: file.title,
+          mimetype: file.mimetype,
+          size: file.size,
+          url_private: file.url_private,
+          created: file.created,
+          user: file.user,
+          channels: file.channels,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function downloadAction(fileId: string, outputPath: string | undefined, options: BotOption): Promise<void> {
+  try {
+    const client = await getClient(options)
+    const { buffer, file } = await client.downloadFile(fileId)
+
+    const safeName = basename(file.name.replace(/\\/g, '/'))
+    let destPath = outputPath ? resolve(outputPath) : resolve(safeName)
+    let isDirectory = false
+    try {
+      isDirectory = statSync(destPath).isDirectory()
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException
+      if (err.code !== 'ENOENT') {
+        throw error
+      }
+    }
+
+    if (isDirectory) {
+      destPath = join(destPath, safeName)
+    }
+
+    writeFileSync(destPath, buffer)
+
+    console.log(
+      formatOutput(
+        {
+          id: file.id,
+          name: file.name,
+          mimetype: file.mimetype,
+          size: file.size,
+          path: destPath,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function deleteAction(fileId: string, options: BotOption & { force?: boolean }): Promise<void> {
+  try {
+    if (!options.force) {
+      console.log(formatOutput({ warning: 'Use --force to confirm deletion', file_id: fileId }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await getClient(options)
+    await client.deleteFile(fileId)
+
+    console.log(formatOutput({ deleted: fileId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const fileCommand = new Command('file')
+  .description('File commands')
+  .addCommand(
+    new Command('upload')
+      .description('Upload file to a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<path>', 'File path')
+      .option('--filename <name>', 'Override filename')
+      .option('--thread <ts>', 'Upload as a reply to a thread')
+      .option('--title <title>', 'File title')
+      .option('--comment <text>', 'Initial comment posted with the file')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(uploadAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List files visible to the bot')
+      .option('--channel <id>', 'Filter by channel ID or name')
+      .option('--user <id>', 'Filter by user ID')
+      .option('--limit <n>', 'Number of files to fetch')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Show file details')
+      .argument('<file>', 'File ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction),
+  )
+  .addCommand(
+    new Command('download')
+      .description('Download a file by ID')
+      .argument('<file>', 'File ID')
+      .argument('[output-path]', 'Output file path or directory')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(downloadAction),
+  )
+  .addCommand(
+    new Command('delete')
+      .description("Delete a file (bot's own files only)")
+      .argument('<file>', 'File ID')
+      .option('--force', 'Skip confirmation')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction),
+  )

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

@@ -1,5 +1,6 @@
 export { authCommand } from './auth'
 export { channelCommand } from './channel'
+export { fileCommand } from './file'
 export { messageCommand } from './message'
 export { reactionCommand } from './reaction'
 export { userCommand } from './user'

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

@@ -98,6 +98,18 @@ async function deleteAction(channelInput: string, ts: string, options: BotOption
   }
 }
 
+async function typingAction(channelInput: string, threadTs: string, status: string, options: BotOption): Promise<void> {
+  try {
+    const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
+    await client.setAssistantStatus(channel, threadTs, status)
+
+    console.log(formatOutput({ channel, thread_ts: threadTs, status }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 async function repliesAction(
   channelInput: string,
   threadTs: string,
@@ -165,6 +177,16 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(deleteAction),
   )
+  .addCommand(
+    new Command('typing')
+      .description('Set typing status in an AI Assistant thread (e.g. "is typing...")')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<thread_ts>', 'Thread timestamp')
+      .argument('[status]', 'Status text (pass empty string to clear)', 'is typing...')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(typingAction),
+  )
   .addCommand(
     new Command('replies')
       .description('Get thread replies')

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 
-import { formatOutput } from '@/shared/utils/output'
+import { cliOutput } from '@/shared/utils/cli-output'
 
 import type { BotOption } from './shared'
 import { getClient } from './shared'
@@ -30,11 +30,6 @@ export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
   }
 }
 
-function cliOutput(result: WhoamiResult, pretty?: boolean): void {
-  console.log(formatOutput(result, pretty))
-  if (result.error) process.exit(1)
-}
-
 export const whoamiCommand = new Command('whoami')
   .description('Show current authenticated bot')
   .option('--bot <id>', 'Bot ID to use')