agent-messenger 2.0.0 → 2.2.0

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,105 @@
+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>
+  let stderrOutput: string
+  let origStderrWrite: typeof process.stderr.write
+
+  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(() => {})
+    stderrOutput = ''
+    origStderrWrite = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
+      return true
+    }) as typeof process.stderr.write
+    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(() => {
+    process.stderr.write = origStderrWrite
+    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(stderrOutput).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,
+    })
+  })

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

@@ -0,0 +1,216 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { infoAction, listAction } from './space'
+
+const mockSpaces = [
+  {
+    id: 'space-1',
+    title: 'General',
+    type: 'group' as const,
+    isLocked: false,
+    lastActivity: '2024-01-02T00:00:00.000Z',
+    created: '2024-01-01T00:00:00.000Z',
+    creatorId: 'person-1',
+  },
+  {
+    id: 'space-2',
+    title: 'Direct with Alice',
+    type: 'direct' as const,
+    isLocked: false,
+    lastActivity: '2024-01-03T00:00:00.000Z',
+    created: '2024-01-01T00:00:00.000Z',
+    creatorId: 'person-2',
+  },
+]
+
+const mockSpace = {
+  id: 'space-1',
+  title: 'General',
+  type: 'group' as const,
+  isLocked: false,
+  teamId: 'team-abc',
+  lastActivity: '2024-01-02T00:00:00.000Z',
+  created: '2024-01-01T00:00:00.000Z',
+  creatorId: 'person-1',
+}
+
+let clientLoginSpy: ReturnType<typeof spyOn>
+let clientListSpacesSpy: ReturnType<typeof spyOn>
+let clientGetSpaceSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let consoleErrorSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+let stderrOutput: string
+let origStderrWrite: typeof process.stderr.write
+
+beforeEach(() => {
+  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+    new WebexClient() as InstanceType<typeof WebexClient>,
+  )
+
+  clientListSpacesSpy = spyOn(WebexClient.prototype, 'listSpaces').mockResolvedValue(mockSpaces)
+
+  clientGetSpaceSpy = spyOn(WebexClient.prototype, 'getSpace').mockResolvedValue(mockSpace)
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+    throw new Error(`process.exit(${_code})`)
+  })
+
+  stderrOutput = ''
+  origStderrWrite = process.stderr.write
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
+    return true
+  }) as typeof process.stderr.write
+})
+
+afterEach(() => {
+  process.stderr.write = origStderrWrite
+  clientLoginSpy?.mockRestore()
+  clientListSpacesSpy?.mockRestore()
+  clientGetSpaceSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  consoleErrorSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+describe('listAction', () => {
+  test('calls listSpaces and outputs mapped array', async () => {
+    await listAction({})
+
+    expect(clientListSpacesSpy).toHaveBeenCalled()
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify([
+        {
+          id: 'space-1',
+          title: 'General',
+          type: 'group',
+          lastActivity: '2024-01-02T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+        },
+        {
+          id: 'space-2',
+          title: 'Direct with Alice',
+          type: 'direct',
+          lastActivity: '2024-01-03T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+        },
+      ]),
+    )
+  })
+
+  test('passes type and limit options to listSpaces', async () => {
+    await listAction({ type: 'group', limit: 10 })
+
+    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: 'group', max: 10 })
+  })
+
+  test('passes undefined type and limit when not provided', async () => {
+    await listAction({})
+
+    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: undefined, max: undefined })
+  })
+
+  test('outputs pretty-printed JSON when pretty is true', async () => {
+    await listAction({ pretty: true })
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        [
+          {
+            id: 'space-1',
+            title: 'General',
+            type: 'group',
+            lastActivity: '2024-01-02T00:00:00.000Z',
+            created: '2024-01-01T00:00:00.000Z',
+          },
+          {
+            id: 'space-2',
+            title: 'Direct with Alice',
+            type: 'direct',
+            lastActivity: '2024-01-03T00:00:00.000Z',
+            created: '2024-01-01T00:00:00.000Z',
+          },
+        ],
+        null,
+        2,
+      ),
+    )
+  })
+
+  test('not authenticated: outputs error and exits', async () => {
+    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+
+    await expect(listAction({})).rejects.toThrow('process.exit(1)')
+
+    expect(clientListSpacesSpy).not.toHaveBeenCalled()
+    expect(stderrOutput).toContain('No Webex credentials found')
+  })
+})
+
+describe('infoAction', () => {
+  test('calls getSpace with spaceId and outputs space details', async () => {
+    await infoAction('space-1', {})
+
+    expect(clientGetSpaceSpy).toHaveBeenCalledWith('space-1')
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify({
+        id: 'space-1',
+        title: 'General',
+        type: 'group',
+        isLocked: false,
+        teamId: 'team-abc',
+        lastActivity: '2024-01-02T00:00:00.000Z',
+        created: '2024-01-01T00:00:00.000Z',
+        creatorId: 'person-1',
+      }),
+    )
+  })
+
+  test('outputs null for teamId when not present', async () => {
+    const spaceWithoutTeam = { ...mockSpace, teamId: undefined }
+    clientGetSpaceSpy.mockResolvedValue(spaceWithoutTeam)
+
+    await infoAction('space-1', {})
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string) as {
+      teamId: null
+    }
+    expect(output.teamId).toBeNull()
+  })
+
+  test('outputs pretty-printed JSON when pretty is true', async () => {
+    await infoAction('space-1', { pretty: true })
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          id: 'space-1',
+          title: 'General',
+          type: 'group',
+          isLocked: false,
+          teamId: 'team-abc',
+          lastActivity: '2024-01-02T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+          creatorId: 'person-1',
+        },
+        null,
+        2,
+      ),
+    )
+  })
+
+  test('not authenticated: outputs error and exits', async () => {
+    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+
+    await expect(infoAction('space-1', {})).rejects.toThrow('process.exit(1)')
+
+    expect(clientGetSpaceSpy).not.toHaveBeenCalled()
+    expect(stderrOutput).toContain('No Webex credentials found')
+  })
+})

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

@@ -0,0 +1,74 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { WebexClient } from '../client'
+
+export async function listAction(options: {
+  type?: string
+  limit?: number
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const spaces = await client.listSpaces({ type: options.type, max: options.limit })
+    const output = spaces.map((s) => ({
+      id: s.id,
+      title: s.title,
+      type: s.type,
+      lastActivity: s.lastActivity,
+      created: s.created,
+    }))
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(
+  spaceId: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const space = await client.getSpace(spaceId)
+    const output = {
+      id: space.id,
+      title: space.title,
+      type: space.type,
+      isLocked: space.isLocked,
+      teamId: space.teamId || null,
+      lastActivity: space.lastActivity,
+      created: space.created,
+      creatorId: space.creatorId,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const spaceCommand = new Command('space')
+  .description('Space commands')
+  .addCommand(
+    new Command('list')
+      .description('List spaces')
+      .option('--type <type>', 'Filter by type (group or direct)')
+      .option('--limit <n>', 'Number of spaces to retrieve', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((options) =>
+        listAction({
+          type: options.type,
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        }),
+      ),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get space details')
+      .argument('<space-id>', 'Space ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction),
+  )