agent-messenger 2.2.0 → 2.4.0

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

@@ -0,0 +1,139 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
+const mockListChannels = mock(() =>
+  Promise.resolve([
+    {
+      id: 'C123456',
+      name: 'general',
+      is_private: false,
+      is_archived: false,
+      created: 1609459200,
+      creator: 'U123',
+    },
+    {
+      id: 'C789012',
+      name: 'random',
+      is_private: false,
+      is_archived: false,
+      created: 1609459200,
+      creator: 'U123',
+    },
+  ]),
+)
+const mockGetChannelInfo = mock(() =>
+  Promise.resolve({
+    id: 'C123456',
+    name: 'general',
+    is_private: false,
+    is_archived: false,
+    created: 1609459200,
+    creator: 'U123',
+    topic: { value: 'General discussion', creator: 'U123', last_set: 1609459200 },
+    purpose: { value: 'Company-wide announcements', creator: 'U123', last_set: 1609459200 },
+  }),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    resolveChannel = mockResolveChannel
+    listChannels = mockListChannels
+    getChannelInfo = mockGetChannelInfo
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('channel commands', () => {
+  beforeEach(() => {
+    mockResolveChannel.mockClear()
+    mockListChannels.mockClear()
+    mockGetChannelInfo.mockClear()
+  })
+
+  describe('listChannels', () => {
+    test('returns list of channels', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channels = await client.listChannels()
+
+      // then
+      expect(channels).toHaveLength(2)
+      expect(channels[0].name).toBe('general')
+      expect(channels[1].name).toBe('random')
+    })
+
+    test('includes channel metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channels = await client.listChannels()
+      const channel = channels[0]
+
+      // then
+      expect(channel.id).toBeDefined()
+      expect(channel.name).toBeDefined()
+      expect(channel.is_private).toBe(false)
+      expect(channel.is_archived).toBe(false)
+      expect(channel.created).toBeDefined()
+    })
+
+    test('passes limit option', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listChannels({ limit: 50 })
+
+      // then
+      expect(mockListChannels).toHaveBeenCalledWith({ limit: 50 })
+    })
+  })
+
+  describe('getChannelInfo', () => {
+    test('returns channel details', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channel = await client.getChannelInfo('C123456')
+
+      // then
+      expect(channel.id).toBe('C123456')
+      expect(channel.name).toBe('general')
+      expect(channel.is_private).toBe(false)
+    })
+
+    test('includes topic and purpose', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channel = await client.getChannelInfo('C123456')
+
+      // then
+      expect(channel.topic?.value).toBe('General discussion')
+      expect(channel.purpose?.value).toBe('Company-wide announcements')
+    })
+  })
+
+  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/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')
+    })
+  })
+})