agent-messenger 1.0.0 → 1.1.0

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

@@ -0,0 +1,188 @@
+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 { TeamsMessage } from '../types'
+
+export async function sendAction(
+  teamId: string,
+  channelId: string,
+  content: 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 message = await client.sendMessage(teamId, channelId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      author: message.author.displayName,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(
+  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 limit = options.limit || 50
+    const messages = await client.getMessages(teamId, channelId, limit)
+
+    const output = messages.map((msg: TeamsMessage) => ({
+      id: msg.id,
+      content: msg.content,
+      author: msg.author.displayName,
+      timestamp: msg.timestamp,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function getAction(
+  teamId: string,
+  channelId: string,
+  messageId: 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 message = await client.getMessage(teamId, channelId, messageId)
+
+    if (!message) {
+      console.log(formatOutput({ error: `Message not found: ${messageId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      author: message.author.displayName,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function deleteAction(
+  teamId: string,
+  channelId: string,
+  messageId: string,
+  options: { force?: boolean; 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)
+    }
+
+    if (!options.force) {
+      console.log(
+        formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty)
+      )
+      process.exit(0)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    await client.deleteMessage(teamId, channelId, messageId)
+
+    console.log(formatOutput({ deleted: messageId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send message to channel')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<content>', 'Message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('List messages from channel')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--limit <n>', 'Number of messages to retrieve', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((teamId: string, channelId: string, options: any) => {
+        return listAction(teamId, channelId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single message by ID')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction)
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete message')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--force', 'Skip confirmation')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction)
+  )

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

@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import { addAction, removeAction } from './reaction'
+
+let clientAddReactionSpy: ReturnType<typeof spyOn>
+let clientRemoveReactionSpy: ReturnType<typeof spyOn>
+let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientAddReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
+  clientRemoveReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(
+    undefined
+  )
+  credManagerLoadConfigSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'loadConfig'
+  ).mockResolvedValue({
+    token: 'test-token',
+    current_team: null,
+    teams: {},
+  })
+})
+
+afterEach(() => {
+  clientAddReactionSpy?.mockRestore()
+  clientRemoveReactionSpy?.mockRestore()
+  credManagerLoadConfigSpy?.mockRestore()
+})
+
+test('add: sends correct POST request with emoji', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  try {
+    await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.success).toBe(true)
+    expect(output.team_id).toBe('team123')
+    expect(output.channel_id).toBe('ch123')
+    expect(output.message_id).toBe('msg123')
+    expect(output.emoji).toBe('like')
+  } finally {
+    console.log = originalLog
+  }
+})
+
+test('remove: sends correct DELETE request with emoji', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  try {
+    await removeAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.success).toBe(true)
+    expect(output.team_id).toBe('team123')
+    expect(output.channel_id).toBe('ch123')
+    expect(output.message_id).toBe('msg123')
+    expect(output.emoji).toBe('like')
+  } finally {
+    console.log = originalLog
+  }
+})
+
+test('add: handles missing token gracefully', async () => {
+  credManagerLoadConfigSpy?.mockResolvedValue(null)
+
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  const originalExit = process.exit
+  process.exit = mock(() => {}) as any
+  console.log = consoleSpy
+
+  try {
+    await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.error).toBeDefined()
+  } finally {
+    console.log = originalLog
+    process.exit = originalExit
+  }
+})

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

@@ -0,0 +1,104 @@
+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 addAction(
+  teamId: string,
+  channelId: string,
+  messageId: string,
+  emoji: 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)
+    await client.addReaction(teamId, channelId, messageId, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          team_id: teamId,
+          channel_id: channelId,
+          message_id: messageId,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function removeAction(
+  teamId: string,
+  channelId: string,
+  messageId: string,
+  emoji: 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)
+    await client.removeReaction(teamId, channelId, messageId, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          team_id: teamId,
+          channel_id: channelId,
+          message_id: messageId,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const reactionCommand = new Command('reaction')
+  .description('Reaction commands')
+  .addCommand(
+    new Command('add')
+      .description('Add emoji reaction to message')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<emoji>', 'Emoji name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction)
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove emoji reaction from message')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<emoji>', 'Emoji name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction)
+  )

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

@@ -0,0 +1,35 @@
+import { expect, test } from 'bun:test'
+import { snapshotCommand } from './snapshot'
+
+test('snapshot: command is defined', () => {
+  expect(snapshotCommand).toBeDefined()
+  expect(snapshotCommand.name()).toBe('snapshot')
+})
+
+test('snapshot: command has correct description', () => {
+  expect(snapshotCommand.description()).toContain('team state')
+})
+
+test('snapshot: command has --channels-only option', () => {
+  const options = snapshotCommand.options
+  const channelsOnlyOption = options.find((opt) => opt.long === '--channels-only')
+  expect(channelsOnlyOption).toBeDefined()
+})
+
+test('snapshot: command has --users-only option', () => {
+  const options = snapshotCommand.options
+  const usersOnlyOption = options.find((opt) => opt.long === '--users-only')
+  expect(usersOnlyOption).toBeDefined()
+})
+
+test('snapshot: command has --limit option', () => {
+  const options = snapshotCommand.options
+  const limitOption = options.find((opt) => opt.long === '--limit')
+  expect(limitOption).toBeDefined()
+})
+
+test('snapshot: command has --team-id option', () => {
+  const options = snapshotCommand.options
+  const teamIdOption = options.find((opt) => opt.long === '--team-id')
+  expect(teamIdOption).toBeDefined()
+})

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

@@ -0,0 +1,115 @@
+import { Command } from 'commander'
+import { parallelMap } from '../../../shared/utils/concurrency'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import type { TeamsChannel } from '../types'
+
+export async function snapshotAction(options: {
+  channelsOnly?: boolean
+  usersOnly?: boolean
+  limit?: number
+  teamId?: string
+  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 teamId = options.teamId || config.current_team
+    if (!teamId) {
+      console.log(
+        formatOutput(
+          { error: 'No current team set. Run "team switch" first or use --team-id.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const messageLimit = options.limit || 20
+
+    const snapshot: Record<string, unknown> = {}
+
+    const team = await client.getTeam(teamId)
+    snapshot.team = {
+      id: team.id,
+      name: team.name,
+      description: team.description,
+    }
+
+    if (!options.usersOnly) {
+      const channels = await client.listChannels(teamId)
+
+      snapshot.channels = channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        type: ch.type,
+      }))
+
+      if (!options.channelsOnly) {
+        const channelMessages = await parallelMap(
+          channels,
+          async (channel: TeamsChannel) => {
+            const messages = await client.getMessages(teamId, channel.id, messageLimit)
+            return messages.map((msg) => ({
+              ...msg,
+              channel_name: channel.name,
+            }))
+          },
+          5
+        )
+
+        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+          channel_id: msg.channel_id,
+          channel_name: msg.channel_name,
+          id: msg.id,
+          author: msg.author.displayName,
+          content: msg.content,
+          timestamp: msg.timestamp,
+        }))
+      }
+    }
+
+    if (!options.channelsOnly) {
+      const users = await client.listUsers(teamId)
+
+      snapshot.members = users.map((u) => ({
+        id: u.id,
+        displayName: u.displayName,
+        email: u.email || null,
+      }))
+    }
+
+    console.log(formatOutput(snapshot, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const snapshotCommand = new Command()
+  .name('snapshot')
+  .description('Get comprehensive team state for AI agents')
+  .option('--channels-only', 'Include only channels (exclude messages and members)')
+  .option('--users-only', 'Include only members (exclude channels and messages)')
+  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .option('--team-id <id>', 'Team ID (defaults to current team)')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (options) => {
+    await snapshotAction({
+      channelsOnly: options.channelsOnly,
+      usersOnly: options.usersOnly,
+      limit: parseInt(options.limit, 10),
+      teamId: options.teamId,
+      pretty: options.pretty,
+    })
+  })

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

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+let clientListTeamsSpy: ReturnType<typeof spyOn>
+let clientGetTeamSpy: ReturnType<typeof spyOn>
+let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+let credManagerSetCurrentTeamSpy: ReturnType<typeof spyOn>
+let credManagerGetCurrentTeamSpy: ReturnType<typeof spyOn>
+let credManagerSaveConfigSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientListTeamsSpy = spyOn(TeamsClient.prototype, 'listTeams').mockResolvedValue([
+    { id: 'team-1', name: 'Team One', description: 'First team' },
+    { id: 'team-2', name: 'Team Two', description: 'Second team' },
+  ])
+
+  clientGetTeamSpy = spyOn(TeamsClient.prototype, 'getTeam').mockImplementation(
+    async (teamId: string) => {
+      if (teamId === 'team-1') {
+        return { id: 'team-1', name: 'Team One', description: 'First team' }
+      }
+      if (teamId === 'team-2') {
+        return { id: 'team-2', name: 'Team Two', description: 'Second team' }
+      }
+      throw new Error('Team not found')
+    }
+  )
+
+  credManagerLoadConfigSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'loadConfig'
+  ).mockResolvedValue({
+    token: 'test-token',
+    current_team: 'team-1',
+    teams: {
+      'team-1': { team_id: 'team-1', team_name: 'Team One' },
+      'team-2': { team_id: 'team-2', team_name: 'Team Two' },
+    },
+  })
+
+  credManagerSetCurrentTeamSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'setCurrentTeam'
+  ).mockResolvedValue(undefined)
+
+  credManagerGetCurrentTeamSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'getCurrentTeam'
+  ).mockResolvedValue({ team_id: 'team-1', team_name: 'Team One' })
+
+  credManagerSaveConfigSpy = spyOn(
+    TeamsCredentialManager.prototype,
+    'saveConfig'
+  ).mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  clientListTeamsSpy?.mockRestore()
+  clientGetTeamSpy?.mockRestore()
+  credManagerLoadConfigSpy?.mockRestore()
+  credManagerSetCurrentTeamSpy?.mockRestore()
+  credManagerGetCurrentTeamSpy?.mockRestore()
+  credManagerSaveConfigSpy?.mockRestore()
+})
+
+test('list: returns teams with current marker', async () => {
+  // given: credential manager with teams
+  const credManager = new TeamsCredentialManager()
+  const config = await credManager.loadConfig()
+
+  // when: checking teams
+  expect(config?.teams).toBeDefined()
+  expect(Object.keys(config!.teams)).toHaveLength(2)
+
+  // then: teams are returned
+  expect(config!.teams['team-1']).toBeDefined()
+  expect(config!.teams['team-2']).toBeDefined()
+})
+
+test('list: marks current team', async () => {
+  // given: credential manager with current team set
+  const credManager = new TeamsCredentialManager()
+  const config = await credManager.loadConfig()
+  const current = await credManager.getCurrentTeam()
+
+  // when: checking current team
+  expect(current?.team_id).toBe('team-1')
+
+  // then: current team is marked
+  expect(config!.current_team).toBe('team-1')
+})
+
+test('info: returns team details', async () => {
+  // given: teams client with team data
+  const client = new TeamsClient('test-token')
+  const team = await client.getTeam('team-1')
+
+  // when: getting team info
+  expect(team).toBeDefined()
+
+  // then: team details are returned
+  expect(team.id).toBe('team-1')
+  expect(team.name).toBe('Team One')
+  expect(team.description).toBe('First team')
+})
+
+test('info: throws error for non-existent team', async () => {
+  // given: teams client
+  const client = new TeamsClient('test-token')
+
+  // when: getting non-existent team
+  // then: error is thrown
+  try {
+    await client.getTeam('non-existent')
+    expect(true).toBe(false)
+  } catch (error) {
+    expect((error as Error).message).toContain('Team not found')
+  }
+})
+
+test('switch: updates current team', async () => {
+  // given: credential manager
+  const credManager = new TeamsCredentialManager()
+
+  // when: switching team
+  await credManager.setCurrentTeam('team-2', 'Team Two')
+
+  // then: setCurrentTeam is called
+  expect(credManager.setCurrentTeam).toHaveBeenCalledWith('team-2', 'Team Two')
+})
+
+test('current: returns current team info', async () => {
+  // given: credential manager with current team
+  const credManager = new TeamsCredentialManager()
+  const config = await credManager.loadConfig()
+
+  // when: getting current team
+  const current = await credManager.getCurrentTeam()
+
+  // then: current team is returned
+  expect(current?.team_id).toBe('team-1')
+  expect(config!.current_team).toBe('team-1')
+})
+
+test('remove: removes team from config', async () => {
+  // given: credential manager with teams
+  const credManager = new TeamsCredentialManager()
+  const config = await credManager.loadConfig()
+
+  // when: removing team
+  delete config!.teams['team-2']
+  await credManager.saveConfig(config!)
+
+  // then: saveConfig is called
+  expect(credManager.saveConfig).toHaveBeenCalled()
+})