agent-messenger 2.3.0 → 2.5.0

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

@@ -0,0 +1,226 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
+const mockPostMessage = mock(() =>
+  Promise.resolve({
+    ts: '1234567890.000100',
+    text: 'Hello world',
+    type: 'message',
+    user: 'U123',
+  }),
+)
+const mockGetConversationHistory = mock(() =>
+  Promise.resolve([
+    { ts: '1234567890.000100', text: 'Hello', type: 'message', user: 'U123' },
+    { ts: '1234567890.000200', text: 'World', type: 'message', user: 'U456' },
+  ]),
+)
+const mockGetMessage = mock(() =>
+  Promise.resolve({
+    ts: '1234567890.000100',
+    text: 'Hello world',
+    type: 'message',
+    user: 'U123',
+  }),
+)
+const mockUpdateMessage = mock(() =>
+  Promise.resolve({
+    ts: '1234567890.000100',
+    text: 'Updated text',
+    type: 'message',
+    user: 'U123',
+  }),
+)
+const mockDeleteMessage = mock(() => Promise.resolve())
+const mockGetThreadReplies = mock(() =>
+  Promise.resolve([
+    { ts: '1234567890.000100', text: 'Thread reply 1', type: 'message', user: 'U123' },
+    { ts: '1234567890.000200', text: 'Thread reply 2', type: 'message', user: 'U456' },
+  ]),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    resolveChannel = mockResolveChannel
+    postMessage = mockPostMessage
+    getConversationHistory = mockGetConversationHistory
+    getMessage = mockGetMessage
+    updateMessage = mockUpdateMessage
+    deleteMessage = mockDeleteMessage
+    getThreadReplies = mockGetThreadReplies
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('message commands', () => {
+  beforeEach(() => {
+    mockResolveChannel.mockClear()
+    mockPostMessage.mockClear()
+    mockGetConversationHistory.mockClear()
+    mockGetMessage.mockClear()
+    mockUpdateMessage.mockClear()
+    mockDeleteMessage.mockClear()
+    mockGetThreadReplies.mockClear()
+  })
+
+  describe('postMessage', () => {
+    test('sends message to channel', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const result = await client.postMessage('C123456', 'Hello world')
+
+      // then
+      expect(result.ts).toBe('1234567890.000100')
+      expect(result.text).toBe('Hello world')
+      expect(result.type).toBe('message')
+    })
+
+    test('sends message with thread_ts', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.postMessage('C123456', 'Thread reply', { thread_ts: '1234567890.000100' })
+
+      // then
+      expect(mockPostMessage).toHaveBeenCalledWith('C123456', 'Thread reply', { thread_ts: '1234567890.000100' })
+    })
+  })
+
+  describe('getConversationHistory', () => {
+    test('returns messages from channel', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const messages = await client.getConversationHistory('C123456', { limit: 20 })
+
+      // then
+      expect(messages).toHaveLength(2)
+      expect(messages[0].text).toBe('Hello')
+      expect(messages[1].text).toBe('World')
+    })
+
+    test('passes limit option', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.getConversationHistory('C123456', { limit: 50 })
+
+      // then
+      expect(mockGetConversationHistory).toHaveBeenCalledWith('C123456', { limit: 50 })
+    })
+  })
+
+  describe('getMessage', () => {
+    test('returns single message by ts', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const message = await client.getMessage('C123456', '1234567890.000100')
+
+      // then
+      expect(message).not.toBeNull()
+      expect(message?.ts).toBe('1234567890.000100')
+      expect(message?.text).toBe('Hello world')
+    })
+
+    test('returns null when message not found', async () => {
+      // given
+      mockGetMessage.mockResolvedValueOnce(null)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const message = await client.getMessage('C123456', 'nonexistent.ts')
+
+      // then
+      expect(message).toBeNull()
+    })
+  })
+
+  describe('updateMessage', () => {
+    test('updates message text', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const result = await client.updateMessage('C123456', '1234567890.000100', 'Updated text')
+
+      // then
+      expect(result.ts).toBe('1234567890.000100')
+      expect(result.text).toBe('Updated text')
+    })
+
+    test('called with correct arguments', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.updateMessage('C123456', '1234567890.000100', 'New text')
+
+      // then
+      expect(mockUpdateMessage).toHaveBeenCalledWith('C123456', '1234567890.000100', 'New text')
+    })
+  })
+
+  describe('deleteMessage', () => {
+    test('deletes message by ts', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.deleteMessage('C123456', '1234567890.000100')
+
+      // then
+      expect(mockDeleteMessage).toHaveBeenCalledWith('C123456', '1234567890.000100')
+    })
+  })
+
+  describe('getThreadReplies', () => {
+    test('returns thread replies', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const replies = await client.getThreadReplies('C123456', '1234567890.000100', { limit: 100 })
+
+      // then
+      expect(replies).toHaveLength(2)
+      expect(replies[0].text).toBe('Thread reply 1')
+      expect(replies[1].text).toBe('Thread reply 2')
+    })
+
+    test('passes limit option', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.getThreadReplies('C123456', '1234567890.000100', { limit: 50 })
+
+      // then
+      expect(mockGetThreadReplies).toHaveBeenCalledWith('C123456', '1234567890.000100', { limit: 50 })
+    })
+  })
+
+  describe('resolveChannel', () => {
+    test('resolves channel name to ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channelId = await client.resolveChannel('general')
+
+      // then
+      expect(channelId).toBe('C123456')
+      expect(mockResolveChannel).toHaveBeenCalledWith('general')
+    })
+  })
+})

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

@@ -0,0 +1,90 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
+const mockAddReaction = mock(() => Promise.resolve())
+const mockRemoveReaction = mock(() => Promise.resolve())
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    resolveChannel = mockResolveChannel
+    addReaction = mockAddReaction
+    removeReaction = mockRemoveReaction
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('reaction commands', () => {
+  beforeEach(() => {
+    mockResolveChannel.mockClear()
+    mockAddReaction.mockClear()
+    mockRemoveReaction.mockClear()
+  })
+
+  describe('addReaction', () => {
+    test('adds emoji reaction to message', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.addReaction('C123456', '1234567890.000100', 'thumbsup')
+
+      // then
+      expect(mockAddReaction).toHaveBeenCalledWith('C123456', '1234567890.000100', 'thumbsup')
+    })
+
+    test('called with correct arguments', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.addReaction('C123456', '1234567890.000200', 'heart')
+
+      // then
+      expect(mockAddReaction).toHaveBeenCalledTimes(1)
+      expect(mockAddReaction).toHaveBeenCalledWith('C123456', '1234567890.000200', 'heart')
+    })
+  })
+
+  describe('removeReaction', () => {
+    test('removes emoji reaction from message', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.removeReaction('C123456', '1234567890.000100', 'thumbsup')
+
+      // then
+      expect(mockRemoveReaction).toHaveBeenCalledWith('C123456', '1234567890.000100', 'thumbsup')
+    })
+
+    test('called with correct arguments', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.removeReaction('C123456', '1234567890.000200', 'wave')
+
+      // then
+      expect(mockRemoveReaction).toHaveBeenCalledTimes(1)
+      expect(mockRemoveReaction).toHaveBeenCalledWith('C123456', '1234567890.000200', 'wave')
+    })
+  })
+
+  describe('resolveChannel', () => {
+    test('resolves channel name before reaction', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channelId = await client.resolveChannel('general')
+
+      // then
+      expect(channelId).toBe('C123456')
+      expect(mockResolveChannel).toHaveBeenCalledWith('general')
+    })
+  })
+})

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

@@ -0,0 +1,143 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockListUsers = mock(() =>
+  Promise.resolve([
+    {
+      id: 'U123',
+      name: 'alice',
+      real_name: 'Alice Smith',
+      is_admin: false,
+      is_owner: false,
+      is_bot: false,
+      is_app_user: false,
+      profile: { email: 'alice@example.com', title: 'Engineer' },
+    },
+    {
+      id: 'U456',
+      name: 'bob',
+      real_name: 'Bob Jones',
+      is_admin: true,
+      is_owner: false,
+      is_bot: false,
+      is_app_user: false,
+      profile: { email: 'bob@example.com', title: 'Manager' },
+    },
+  ]),
+)
+const mockGetUserInfo = mock(() =>
+  Promise.resolve({
+    id: 'U123',
+    name: 'alice',
+    real_name: 'Alice Smith',
+    is_admin: false,
+    is_owner: false,
+    is_bot: false,
+    is_app_user: false,
+    profile: {
+      email: 'alice@example.com',
+      phone: '+1-555-0100',
+      title: 'Engineer',
+      status_text: 'Working from home',
+    },
+  }),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    listUsers = mockListUsers
+    getUserInfo = mockGetUserInfo
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('user commands', () => {
+  beforeEach(() => {
+    mockListUsers.mockClear()
+    mockGetUserInfo.mockClear()
+  })
+
+  describe('listUsers', () => {
+    test('returns list of users', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const users = await client.listUsers()
+
+      // then
+      expect(users).toHaveLength(2)
+      expect(users[0].name).toBe('alice')
+      expect(users[1].name).toBe('bob')
+    })
+
+    test('includes user metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const users = await client.listUsers()
+      const user = users[0]
+
+      // then
+      expect(user.id).toBeDefined()
+      expect(user.name).toBeDefined()
+      expect(user.real_name).toBeDefined()
+      expect(user.is_bot).toBe(false)
+      expect(user.is_admin).toBe(false)
+    })
+
+    test('passes limit option', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listUsers({ limit: 50 })
+
+      // then
+      expect(mockListUsers).toHaveBeenCalledWith({ limit: 50 })
+    })
+  })
+
+  describe('getUserInfo', () => {
+    test('returns user details by ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const user = await client.getUserInfo('U123')
+
+      // then
+      expect(user.id).toBe('U123')
+      expect(user.name).toBe('alice')
+      expect(user.real_name).toBe('Alice Smith')
+    })
+
+    test('includes profile information', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const user = await client.getUserInfo('U123')
+
+      // then
+      expect(user.profile?.email).toBe('alice@example.com')
+      expect(user.profile?.title).toBe('Engineer')
+      expect(user.profile?.status_text).toBe('Working from home')
+    })
+
+    test('called with correct user ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.getUserInfo('U456')
+
+      // then
+      expect(mockGetUserInfo).toHaveBeenCalledWith('U456')
+    })
+  })
+})

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

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockTestAuth = mock(() =>
+  Promise.resolve({
+    user_id: 'U123',
+    team_id: 'T456',
+    bot_id: 'B789',
+    user: 'testbot',
+    team: 'Test Team',
+  }),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: any) {
+      return this
+    }
+    testAuth = mockTestAuth
+  },
+}))
+
+import { SlackBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `slackbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_SLACKBOT_TOKEN
+    mockTestAuth.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns auth info for current bot', async () => {
+    const manager = new SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'B789',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.user_id).toBe('U123')
+    expect(result.team_id).toBe('T456')
+    expect(result.bot_id).toBe('B789')
+    expect(result.user).toBe('testbot')
+    expect(result.team).toBe('Test Team')
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns auth info for specific --bot', async () => {
+    const manager = new SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    })
+
+    const result = await whoamiAction({ bot: 'deploy', _credManager: manager })
+
+    expect(result.user_id).toBe('U123')
+    expect(result.team_id).toBe('T456')
+    expect(mockTestAuth).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'B789',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})

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

@@ -0,0 +1,44 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  user_id?: string
+  team_id?: string
+  bot_id?: string
+  user?: string
+  team?: string
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.testAuth()
+    return {
+      user_id: info.user_id,
+      team_id: info.team_id,
+      bot_id: info.bot_id,
+      user: info.user,
+      team: info.team,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+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')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/platforms/teams/cli.ts

@@ -13,6 +13,7 @@ import {
   snapshotCommand,
   teamCommand,
   userCommand,
+  whoamiCommand,
 } from './commands'
 import { TeamsCredentialManager } from './credential-manager'
 import { ensureTeamsAuth } from './ensure-auth'
@@ -53,6 +54,7 @@ program.addCommand(messageCommand)
 program.addCommand(reactionCommand)
 program.addCommand(snapshotCommand)
 program.addCommand(userCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -10,3 +10,4 @@ export { reactionCommand } from './reaction'
 export { snapshotAction, snapshotCommand } from './snapshot'
 export { teamCommand } from './team'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'