agent-messenger 1.0.0 → 1.1.0

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

@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+let clientListChannelsSpy: ReturnType<typeof spyOn>
+let clientGetChannelSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientListChannelsSpy = spyOn(TeamsClient.prototype, 'listChannels').mockResolvedValue([
+    { id: 'ch-1', team_id: 'team-1', name: 'General', type: 'standard' },
+    { id: 'ch-2', team_id: 'team-1', name: 'Announcements', type: 'standard' },
+  ])
+
+  clientGetChannelSpy = spyOn(TeamsClient.prototype, 'getChannel').mockImplementation(
+    async (teamId: string, channelId: string) => {
+      if (channelId === 'ch-1') {
+        return { id: 'ch-1', team_id: teamId, name: 'General', type: 'standard' }
+      }
+      if (channelId === 'ch-2') {
+        return { id: 'ch-2', team_id: teamId, name: 'Announcements', type: 'standard' }
+      }
+      throw new Error('Channel not found')
+    }
+  )
+
+  clientGetMessagesSpy = spyOn(TeamsClient.prototype, 'getMessages').mockResolvedValue([
+    {
+      id: 'msg-1',
+      channel_id: 'ch-1',
+      author: { id: 'user-1', displayName: 'Alice' },
+      content: 'Hello world',
+      timestamp: '2024-01-29T10:00:00Z',
+    },
+    {
+      id: 'msg-2',
+      channel_id: 'ch-1',
+      author: { id: 'user-2', displayName: 'Bob' },
+      content: 'Hi there',
+      timestamp: '2024-01-29T09:00:00Z',
+    },
+  ])
+
+  credManagerLoadConfigSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'loadConfig'
+  ).mockResolvedValue({
+    token: 'test-token',
+    current_team: 'team-1',
+    teams: {
+      'team-1': { team_id: 'team-1', team_name: 'Team One' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientListChannelsSpy?.mockRestore()
+  clientGetChannelSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  credManagerLoadConfigSpy?.mockRestore()
+})
+
+test('list: returns channels from team', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+
+  // when
+  const channels = await client.listChannels('team-1')
+
+  // then
+  expect(channels).toHaveLength(2)
+  expect(channels[0].name).toBe('General')
+  expect(channels[1].name).toBe('Announcements')
+})
+
+test('list: includes channel metadata', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+  const channels = await client.listChannels('team-1')
+
+  // when
+  const channel = channels[0]
+
+  // then
+  expect(channel.id).toBeDefined()
+  expect(channel.name).toBeDefined()
+  expect(channel.type).toBeDefined()
+  expect(channel.team_id).toBe('team-1')
+})
+
+test('info: returns channel details', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+
+  // when
+  const channel = await client.getChannel('team-1', 'ch-1')
+
+  // then
+  expect(channel.id).toBe('ch-1')
+  expect(channel.name).toBe('General')
+  expect(channel.type).toBe('standard')
+})
+
+test('info: throws error for non-existent channel', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+
+  // when/then
+  try {
+    await client.getChannel('team-1', 'non-existent')
+    expect(true).toBe(false)
+  } catch (error) {
+    expect((error as Error).message).toContain('Channel not found')
+  }
+})
+
+test('history: returns messages', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+
+  // when
+  const messages = await client.getMessages('team-1', 'ch-1', 50)
+
+  // then
+  expect(messages).toHaveLength(2)
+  expect(messages[0].id).toBe('msg-1')
+  expect(messages[0].author.displayName).toBe('Alice')
+  expect(messages[1].id).toBe('msg-2')
+  expect(messages[1].author.displayName).toBe('Bob')
+})
+
+test('history: includes message metadata', async () => {
+  // given
+  const client = new TeamsClient('test-token')
+  const messages = await client.getMessages('team-1', 'ch-1', 50)
+
+  // when
+  const message = messages[0]
+
+  // then
+  expect(message.id).toBeDefined()
+  expect(message.content).toBeDefined()
+  expect(message.author).toBeDefined()
+  expect(message.author.displayName).toBeDefined()
+  expect(message.timestamp).toBeDefined()
+})

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

@@ -0,0 +1,129 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+export async function listAction(teamId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const channels = await client.listChannels(teamId)
+
+    const output = channels.map((ch) => ({
+      id: ch.id,
+      name: ch.name,
+      type: ch.type,
+      team_id: ch.team_id,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(
+  teamId: string,
+  channelId: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const channel = await client.getChannel(teamId, channelId)
+
+    const output = {
+      id: channel.id,
+      name: channel.name,
+      type: channel.type,
+      team_id: channel.team_id,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function historyAction(
+  teamId: string,
+  channelId: string,
+  options: { limit?: number; pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const messages = await client.getMessages(teamId, channelId, options.limit || 50)
+
+    const output = messages.map((msg) => ({
+      id: msg.id,
+      author: msg.author.displayName,
+      content: msg.content,
+      timestamp: msg.timestamp,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const channelCommand = new Command('channel')
+  .description('Channel commands')
+  .addCommand(
+    new Command('list')
+      .description('List channels in a team')
+      .argument('<team-id>', 'Team ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get channel info')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('history')
+      .description('Get channel message history')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--limit <n>', 'Number of messages to fetch', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((teamId, channelId, options) => {
+        return historyAction(teamId, channelId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )

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

@@ -0,0 +1,88 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import { infoAction, listAction, uploadAction } from './file'
+
+let clientUploadFileSpy: ReturnType<typeof spyOn>
+let clientListFilesSpy: ReturnType<typeof spyOn>
+let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+const originalConsoleLog = console.log
+
+beforeEach(() => {
+  clientUploadFileSpy = spyOn(TeamsClient.prototype, 'uploadFile').mockResolvedValue({
+    id: 'file_123',
+    name: 'test.pdf',
+    size: 1024,
+    url: 'https://teams.microsoft.com/files/123/test.pdf',
+    contentType: 'application/pdf',
+  })
+
+  clientListFilesSpy = spyOn(TeamsClient.prototype, 'listFiles').mockResolvedValue([
+    {
+      id: 'file_123',
+      name: 'test.pdf',
+      size: 1024,
+      url: 'https://teams.microsoft.com/files/123/test.pdf',
+      contentType: 'application/pdf',
+    },
+    {
+      id: 'file_124',
+      name: 'image.png',
+      size: 2048,
+      url: 'https://teams.microsoft.com/files/124/image.png',
+      contentType: 'image/png',
+    },
+  ])
+
+  credManagerLoadConfigSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'loadConfig'
+  ).mockResolvedValue({
+    token: 'test_token',
+    current_team: 'team_123',
+    teams: { team_123: { team_id: 'team_123', team_name: 'Test Team' } },
+  })
+})
+
+afterEach(() => {
+  clientUploadFileSpy?.mockRestore()
+  clientListFilesSpy?.mockRestore()
+  credManagerLoadConfigSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('upload: sends multipart request and returns file info', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await uploadAction('team_123', 'ch_456', '/path/to/test.pdf', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('test.pdf')
+})
+
+test('list: returns files in channel', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('team_123', 'ch_456', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('file_124')
+})
+
+test('info: returns single file details', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await infoAction('team_123', 'ch_456', 'file_123', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('test.pdf')
+})

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

@@ -0,0 +1,144 @@
+import { resolve } from 'node:path'
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import type { TeamsFile } from '../types'
+
+export async function uploadAction(
+  teamId: string,
+  channelId: string,
+  path: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const filePath = resolve(path)
+    const file = await client.uploadFile(teamId, channelId, filePath)
+
+    const output = {
+      id: file.id,
+      name: file.name,
+      size: file.size,
+      url: file.url,
+      content_type: file.contentType || null,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(
+  teamId: string,
+  channelId: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const files = await client.listFiles(teamId, channelId)
+
+    const output = files.map((file: TeamsFile) => ({
+      id: file.id,
+      name: file.name,
+      size: file.size,
+      url: file.url,
+      content_type: file.contentType || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(
+  teamId: string,
+  channelId: string,
+  fileId: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const files = await client.listFiles(teamId, channelId)
+    const fileData = files.find((f) => f.id === fileId)
+
+    if (!fileData) {
+      console.log(formatOutput({ error: `File not found: ${fileId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      id: fileData.id,
+      name: fileData.name,
+      size: fileData.size,
+      url: fileData.url,
+      content_type: fileData.contentType || null,
+    }
+
+    console.log(formatOutput(output, 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 channel')
+      .argument('<team>', 'team ID')
+      .argument('<channel>', 'channel ID')
+      .argument('<path>', 'file path')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(uploadAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('list files in channel')
+      .argument('<team>', 'team ID')
+      .argument('<channel>', 'channel ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('show file details')
+      .argument('<team>', 'team ID')
+      .argument('<channel>', 'channel ID')
+      .argument('<file>', 'file ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )

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

@@ -0,0 +1,12 @@
+/**
+ * Command registry for Teams CLI
+ */
+
+export { authCommand } from './auth'
+export { channelCommand } from './channel'
+export { fileCommand } from './file'
+export { messageCommand } from './message'
+export { reactionCommand } from './reaction'
+export { snapshotAction, snapshotCommand } from './snapshot'
+export { teamCommand } from './team'
+export { userCommand } from './user'

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

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import { deleteAction, getAction, listAction, sendAction } from './message'
+
+let clientSendMessageSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientDeleteMessageSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+const originalConsoleLog = console.log
+
+beforeEach(() => {
+  clientSendMessageSpy = spyOn(TeamsClient.prototype, 'sendMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', displayName: 'Test User' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientGetMessagesSpy = spyOn(TeamsClient.prototype, 'getMessages').mockResolvedValue([
+    {
+      id: 'msg_123',
+      channel_id: 'ch_456',
+      author: { id: 'user_789', displayName: 'Test User' },
+      content: 'Hello world',
+      timestamp: '2025-01-29T10:00:00Z',
+    },
+    {
+      id: 'msg_124',
+      channel_id: 'ch_456',
+      author: { id: 'user_789', displayName: 'Test User' },
+      content: 'Second message',
+      timestamp: '2025-01-29T10:01:00Z',
+    },
+  ])
+
+  clientGetMessageSpy = spyOn(TeamsClient.prototype, 'getMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', displayName: 'Test User' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientDeleteMessageSpy = spyOn(TeamsClient.prototype, 'deleteMessage').mockResolvedValue(
+    undefined
+  )
+
+  credManagerLoadSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+    token: 'test_token',
+    current_team: 'team_123',
+    teams: { team_123: { team_id: 'team_123', team_name: 'Test Team' } },
+  })
+})
+
+afterEach(() => {
+  clientSendMessageSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  clientDeleteMessageSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('send: returns message with id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', 'Hello world', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('list: returns array of messages', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('team_123', 'ch_456', { limit: 50, pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('msg_124')
+})
+
+test('get: returns single message', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await getAction('team_123', 'ch_456', 'msg_123', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('delete: returns success', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('team_123', 'ch_456', 'msg_123', { force: true, pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('deleted')
+})