agent-messenger 2.0.0 → 2.1.0

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

@@ -0,0 +1,231 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
+
+let clientSendMessageSpy: ReturnType<typeof spyOn>
+let clientSendDirectMessageSpy: ReturnType<typeof spyOn>
+let clientListMessagesSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientDeleteMessageSpy: ReturnType<typeof spyOn>
+let clientEditMessageSpy: ReturnType<typeof spyOn>
+let clientLoginSpy: ReturnType<typeof spyOn>
+const originalConsoleLog = console.log
+const originalConsoleError = console.error
+
+const mockMessage = {
+  id: 'msg_123',
+  roomId: 'space_456',
+  roomType: 'group' as const,
+  text: 'Hello world',
+  personId: 'person_789',
+  personEmail: 'user@example.com',
+  created: '2025-01-29T10:00:00.000Z',
+}
+
+const mockMessage2 = {
+  id: 'msg_124',
+  roomId: 'space_456',
+  roomType: 'group' as const,
+  text: 'Second message',
+  personId: 'person_789',
+  personEmail: 'user@example.com',
+  created: '2025-01-29T10:01:00.000Z',
+}
+
+beforeEach(() => {
+  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+
+  clientSendMessageSpy = spyOn(WebexClient.prototype, 'sendMessage').mockResolvedValue(mockMessage)
+
+  clientSendDirectMessageSpy = spyOn(WebexClient.prototype, 'sendDirectMessage').mockResolvedValue(mockMessage)
+
+  clientListMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue([
+    mockMessage,
+    mockMessage2,
+  ])
+
+  clientGetMessageSpy = spyOn(WebexClient.prototype, 'getMessage').mockResolvedValue(mockMessage)
+
+  clientDeleteMessageSpy = spyOn(WebexClient.prototype, 'deleteMessage').mockResolvedValue(
+    undefined,
+  )
+
+  clientEditMessageSpy = spyOn(WebexClient.prototype, 'editMessage').mockResolvedValue({
+    ...mockMessage,
+    text: 'Updated message',
+  })
+})
+
+afterEach(() => {
+  clientLoginSpy?.mockRestore()
+  clientSendMessageSpy?.mockRestore()
+  clientSendDirectMessageSpy?.mockRestore()
+  clientListMessagesSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  clientDeleteMessageSpy?.mockRestore()
+  clientEditMessageSpy?.mockRestore()
+  console.log = originalConsoleLog
+  console.error = originalConsoleError
+})
+
+test('send: calls sendMessage with correct args and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('space_456', 'Hello world', { pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', 'Hello world', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('space_456')
+  expect(output).toContain('user@example.com')
+})
+
+test('send: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('space_456', '**bold**', { markdown: true, pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', '**bold**', { markdown: true })
+})
+
+test('send: not authenticated shows error', async () => {
+  clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+  const errorSpy = mock((_msg: string) => {})
+  console.error = errorSpy
+
+  const originalExit = process.exit
+  process.exit = mock((_code?: number) => {
+    throw new Error('process.exit called')
+  }) as never
+
+  try {
+    await sendAction('space_456', 'Hello', { pretty: false })
+  } catch {
+  } finally {
+    process.exit = originalExit
+  }
+
+  expect(errorSpy).toHaveBeenCalled()
+  const output = errorSpy.mock.calls[0][0]
+  expect(output).toContain('No Webex credentials found')
+})
+
+test('dm: calls sendDirectMessage with email and text', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await dmAction('alice@example.com', 'Hello!', { pretty: false })
+
+  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', 'Hello!', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('dm: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await dmAction('alice@example.com', '**bold**', { markdown: true, pretty: false })
+
+  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', '**bold**', {
+    markdown: true,
+  })
+})
+
+test('list: calls listMessages with limit and outputs array', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('space_456', { limit: 50, pretty: false })
+
+  expect(clientListMessagesSpy).toHaveBeenCalledWith('space_456', { max: 50 })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('msg_124')
+})
+
+test('get: calls getMessage with correct id and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await getAction('msg_123', { pretty: false })
+
+  expect(clientGetMessageSpy).toHaveBeenCalledWith('msg_123')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('user@example.com')
+})
+
+test('delete: with --force calls deleteMessage and outputs deleted id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('msg_123', { force: true, pretty: false })
+
+  expect(clientDeleteMessageSpy).toHaveBeenCalledWith('msg_123')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('deleted')
+  expect(output).toContain('msg_123')
+})
+
+test('delete: without --force shows warning and does not delete', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  const originalExit = process.exit
+  process.exit = mock((_code?: number) => {
+    throw new Error('process.exit called')
+  }) as never
+
+  try {
+    await deleteAction('msg_123', { force: false, pretty: false })
+  } catch {
+  } finally {
+    process.exit = originalExit
+  }
+
+  expect(clientDeleteMessageSpy).not.toHaveBeenCalled()
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('warning')
+  expect(output).toContain('--force')
+})
+
+test('edit: calls editMessage with roomId in args and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('msg_123', 'space_456', 'Updated message', { pretty: false })
+
+  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', 'Updated message', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('Updated message')
+})
+
+test('edit: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('msg_123', 'space_456', '**updated**', { markdown: true, pretty: false })
+
+  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', '**updated**', {
+    markdown: true,
+  })
+})

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

@@ -0,0 +1,204 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { WebexClient } from '../client'
+import type { WebexMessage } from '../types'
+
+export async function sendAction(
+  spaceId: string,
+  text: string,
+  options: { markdown?: boolean; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const message = await client.sendMessage(spaceId, text, { markdown: options.markdown })
+
+    const output = {
+      id: message.id,
+      roomId: message.roomId,
+      text: message.text,
+      personEmail: message.personEmail,
+      created: message.created,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(
+  spaceId: string,
+  options: { limit?: number; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const limit = options.limit ?? 50
+    const messages = await client.listMessages(spaceId, { max: limit })
+
+    const output = messages.map((msg: WebexMessage) => ({
+      id: msg.id,
+      roomId: msg.roomId,
+      text: msg.text,
+      personEmail: msg.personEmail,
+      created: msg.created,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function getAction(
+  messageId: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const message = await client.getMessage(messageId)
+
+    const output = {
+      id: message.id,
+      roomId: message.roomId,
+      text: message.text,
+      personEmail: message.personEmail,
+      created: message.created,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function deleteAction(
+  messageId: string,
+  options: { force?: boolean; pretty?: boolean },
+): Promise<void> {
+  try {
+    if (!options.force) {
+      console.log(
+        formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty),
+      )
+      process.exit(0)
+    }
+
+    const client = await new WebexClient().login()
+    await client.deleteMessage(messageId)
+
+    console.log(formatOutput({ deleted: messageId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function editAction(
+  messageId: string,
+  spaceId: string,
+  text: string,
+  options: { markdown?: boolean; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const message = await client.editMessage(messageId, spaceId, text, {
+      markdown: options.markdown,
+    })
+
+    const output = {
+      id: message.id,
+      roomId: message.roomId,
+      text: message.text,
+      personEmail: message.personEmail,
+      created: message.created,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function dmAction(
+  email: string,
+  text: string,
+  options: { markdown?: boolean; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const message = await client.sendDirectMessage(email, text, { markdown: options.markdown })
+
+    const output = {
+      id: message.id,
+      roomId: message.roomId,
+      text: message.text,
+      personEmail: message.personEmail,
+      created: message.created,
+    }
+
+    console.log(formatOutput(output, 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 a space')
+      .argument('<space-id>', 'Space/Room ID')
+      .argument('<text>', 'Message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )
+  .addCommand(
+    new Command('dm')
+      .description('Send a direct message by email')
+      .argument('<email>', 'Recipient email address')
+      .argument('<text>', 'Message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(dmAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List messages from a space')
+      .argument('<space-id>', 'Space/Room ID')
+      .option('--limit <n>', 'Number of messages to retrieve', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((spaceId: string, options: { limit: string; pretty?: boolean }) => {
+        return listAction(spaceId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      }),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single message by ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a message')
+      .argument('<message-id>', 'Message ID')
+      .option('--force', 'Skip confirmation')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction),
+  )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a message')
+      .argument('<message-id>', 'Message ID')
+      .argument('<space-id>', 'Space/Room ID (required by Webex API)')
+      .argument('<text>', 'New message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )

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

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { snapshotAction } from './snapshot'
+
+describe('snapshot command', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+
+  const mockSpaces = [
+    { id: 'space-1', title: 'General', type: 'group', isLocked: false, lastActivity: '2024-01-15T00:00:00.000Z', created: '2024-01-01T00:00:00.000Z', creatorId: 'person-1' },
+  ]
+
+  const mockMessages = [
+    { id: 'msg-1', roomId: 'space-1', roomType: 'group', text: 'Hello', personId: 'person-1', personEmail: 'alice@example.com', created: '2024-01-15T00:00:00.000Z' },
+  ]
+
+  const mockMembers = [
+    { id: 'mem-1', roomId: 'space-1', personId: 'person-1', personEmail: 'alice@example.com', personDisplayName: 'Alice', isModerator: true, created: '2024-01-01T00:00:00.000Z' },
+  ]
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+    spyOn(WebexClient.prototype, 'listSpaces').mockResolvedValue(mockSpaces as any)
+    spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue(mockMessages as any)
+    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers as any)
+  })
+
+  afterEach(() => { mock.restore() })
+
+  test('full snapshot includes spaces, recent_messages, members', async () => {
+    await snapshotAction({})
+
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
+    expect(output.spaces).toBeDefined()
+    expect(output.spaces[0].id).toBe('space-1')
+    expect(output.spaces[0].title).toBe('General')
+    expect(output.recent_messages).toBeDefined()
+    expect(output.recent_messages[0].id).toBe('msg-1')
+    expect(output.recent_messages[0].author).toBe('alice@example.com')
+    expect(output.members).toBeDefined()
+    expect(output.members[0].personEmail).toBe('alice@example.com')
+  })
+
+  test('--spaces-only includes only spaces (no messages, no members)', async () => {
+    await snapshotAction({ spacesOnly: true })
+
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
+    expect(output.spaces).toBeDefined()
+    expect(output.recent_messages).toBeUndefined()
+    expect(output.members).toBeUndefined()
+  })
+
+  test('--members-only includes only members (no spaces, no messages)', async () => {
+    await snapshotAction({ membersOnly: true })
+
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
+    expect(output.spaces).toBeUndefined()
+    expect(output.recent_messages).toBeUndefined()
+    expect(output.members).toBeDefined()
+    expect(output.members[0].personEmail).toBe('alice@example.com')
+  })
+
+  test('not authenticated outputs error', async () => {
+    spyOn(WebexClient.prototype, 'login').mockRejectedValue(
+      new WebexError('No Webex credentials found.', 'no_credentials'),
+    )
+
+    const originalExit = process.exit
+    process.exit = mock((_code?: number) => { throw new Error('process.exit called') }) as never
+
+    try {
+      await snapshotAction({})
+    } catch {
+    } finally {
+      process.exit = originalExit
+    }
+
+    expect(consoleErrorSpy).toHaveBeenCalled()
+    const output = consoleErrorSpy.mock.calls[0][0]
+    expect(output).toContain('No Webex credentials found')
+  })
+
+  test('passes limit option to listMessages', async () => {
+    const listMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue(mockMessages as any)
+
+    await snapshotAction({ limit: 5 })
+
+    expect(listMessagesSpy).toHaveBeenCalledWith('space-1', { max: 5 })
+  })
+})

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

@@ -0,0 +1,91 @@
+import { Command } from 'commander'
+import { parallelMap } from '@/shared/utils/concurrency'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { WebexClient } from '../client'
+import type { WebexSpace } from '../types'
+
+export async function snapshotAction(options: {
+  spacesOnly?: boolean
+  membersOnly?: boolean
+  limit?: number
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const messageLimit = options.limit || 20
+    const snapshot: Record<string, unknown> = {}
+
+    if (!options.membersOnly) {
+      const spaces = await client.listSpaces({ max: 50 })
+      snapshot.spaces = spaces.map((s) => ({
+        id: s.id,
+        title: s.title,
+        type: s.type,
+        lastActivity: s.lastActivity,
+      }))
+
+      if (!options.spacesOnly) {
+        const spaceMessages = await parallelMap(
+          spaces,
+          async (space: WebexSpace) => {
+            const messages = await client.listMessages(space.id, { max: messageLimit })
+            return messages.map((msg) => ({
+              ...msg,
+              space_title: space.title,
+            }))
+          },
+          5,
+        )
+
+        snapshot.recent_messages = spaceMessages.flat().map((msg) => ({
+          space_id: msg.roomId,
+          space_title: msg.space_title,
+          id: msg.id,
+          author: msg.personEmail,
+          text: msg.text || msg.markdown || '',
+          created: msg.created,
+        }))
+      }
+    }
+
+    if (!options.spacesOnly) {
+      // Get members for the first few spaces (avoid massive API calls)
+      const spaces = await client.listSpaces({ max: 10 })
+      const spaceMembers = await parallelMap(
+        spaces,
+        async (space: WebexSpace) => {
+          const members = await client.listMemberships(space.id, { max: 100 })
+          return members.map((m) => ({
+            space_id: space.id,
+            space_title: space.title,
+            personEmail: m.personEmail,
+            personDisplayName: m.personDisplayName,
+            isModerator: m.isModerator,
+          }))
+        },
+        5,
+      )
+      snapshot.members = spaceMembers.flat()
+    }
+
+    console.log(formatOutput(snapshot, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const snapshotCommand = new Command('snapshot')
+  .description('Get comprehensive workspace state for AI agents')
+  .option('--spaces-only', 'Include only spaces (exclude messages and members)')
+  .option('--members-only', 'Include only members (exclude spaces and messages)')
+  .option('--limit <n>', 'Number of recent messages per space (default: 20)', '20')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (options) => {
+    await snapshotAction({
+      spacesOnly: options.spacesOnly,
+      membersOnly: options.membersOnly,
+      limit: parseInt(options.limit, 10),
+      pretty: options.pretty,
+    })
+  })