agent-messenger 2.20.5 → 2.22.0

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

@@ -0,0 +1,263 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { WebexMessage } from '../../webex/types'
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface MessageResult {
+  id?: string
+  roomId?: string
+  text?: string
+  markdown?: string
+  html?: string
+  personEmail?: string
+  created?: string
+  messages?: Array<{
+    id: string
+    roomId: string
+    text?: string
+    personEmail: string
+    created: string
+  }>
+  deleted?: string
+  error?: string
+}
+
+function formatMessage(message: WebexMessage): MessageResult {
+  return {
+    id: message.id,
+    roomId: message.roomId,
+    text: message.text,
+    markdown: message.markdown,
+    html: message.html,
+    personEmail: message.personEmail,
+    created: message.created,
+  }
+}
+
+export async function sendAction(
+  space: string,
+  text: string,
+  options: BotOption & { markdown?: boolean; parent?: string },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendMessage(space, text, { markdown: options.markdown, parentId: options.parent })
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function replyAction(
+  space: string,
+  parentId: string,
+  text: string,
+  options: BotOption & { markdown?: boolean },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendMessage(space, text, { markdown: options.markdown, parentId })
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function repliesAction(
+  space: string,
+  parentId: string,
+  options: BotOption & { max?: string },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 50
+    const messages = await client.listReplies(space, parentId, { max })
+
+    return {
+      messages: messages.map((msg) => ({
+        id: msg.id,
+        roomId: msg.roomId,
+        text: msg.text,
+        personEmail: msg.personEmail,
+        created: msg.created,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function dmAction(
+  email: string,
+  text: string,
+  options: BotOption & { markdown?: boolean },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendDirectMessage(email, text, { markdown: options.markdown })
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function listAction(space: string, options: BotOption & { max?: string }): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 50
+    const messages = await client.listMessages(space, { max })
+
+    return {
+      messages: messages.map((msg) => ({
+        id: msg.id,
+        roomId: msg.roomId,
+        text: msg.text,
+        personEmail: msg.personEmail,
+        created: msg.created,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function getAction(messageId: string, options: BotOption): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.getMessage(messageId)
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function deleteAction(messageId: string, options: BotOption): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    await client.deleteMessage(messageId)
+
+    return { deleted: messageId }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function editAction(
+  messageId: string,
+  space: string,
+  text: string,
+  options: BotOption & { markdown?: boolean },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.editMessage(messageId, space, text, { markdown: options.markdown })
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send a message to a space')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<text>', 'Message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--parent <id>', 'Reply within a thread (parent message ID)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, text: string, opts: BotOption & { markdown?: boolean; parent?: string }) => {
+        cliOutput(await sendAction(space, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('reply')
+      .description('Reply to a message in a thread')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<parent>', 'Parent message ID')
+      .argument('<text>', 'Reply text')
+      .option('--markdown', 'Send as markdown')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, parent: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+        cliOutput(await replyAction(space, parent, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('replies')
+      .description('List replies in a thread')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<parent>', 'Parent message ID')
+      .option('--max <n>', 'Number of replies to fetch', '50')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, parent: string, opts: BotOption & { max?: string }) => {
+        cliOutput(await repliesAction(space, parent, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('dm')
+      .description('Send a direct message by recipient email')
+      .argument('<email>', 'Recipient email address')
+      .argument('<text>', 'Message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (email: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+        cliOutput(await dmAction(email, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List messages in a space')
+      .argument('<space>', 'Space/Room ID')
+      .option('--max <n>', 'Number of messages to fetch', '50')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, opts: BotOption & { max?: string }) => {
+        cliOutput(await listAction(space, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single message')
+      .argument('<id>', 'Message ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (messageId: string, opts: BotOption) => {
+        cliOutput(await getAction(messageId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a message')
+      .argument('<id>', 'Message ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (messageId: string, opts: BotOption) => {
+        cliOutput(await deleteAction(messageId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a message')
+      .argument('<id>', 'Message ID')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<text>', 'New message text')
+      .option('--markdown', 'Send as markdown')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (messageId: string, space: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+        cliOutput(await editAction(messageId, space, text, opts), opts.pretty)
+      }),
+  )

package/src/platforms/webexbot/commands/shared.ts

@@ -0,0 +1,22 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import { WebexBotClient } from '../client'
+import { WebexBotCredentialManager } from '../credential-manager'
+
+export interface BotOption {
+  bot?: string
+  pretty?: boolean
+  _credManager?: WebexBotCredentialManager
+}
+
+export async function getClient(options: BotOption): Promise<WebexBotClient> {
+  const credManager = options._credManager ?? new WebexBotCredentialManager()
+  const creds = await credManager.getCredentials(options.bot)
+
+  if (!creds) {
+    console.log(formatOutput({ error: 'No credentials. Run "auth set <token>" first.' }, options.pretty))
+    process.exit(1)
+  }
+
+  return new WebexBotClient().login({ token: creds.token })
+}

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

@@ -0,0 +1,60 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface SnapshotResult {
+  bot?: {
+    id: string
+    displayName: string
+    emails: string[]
+  }
+  spaces?: Array<{
+    id: string
+    title: string
+    type?: 'group' | 'direct'
+    lastActivity?: string
+  }>
+  hint?: string
+  error?: string
+}
+
+export async function snapshotAction(options: BotOption & { full?: boolean; max?: string }): Promise<SnapshotResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 100
+
+    const [me, spaces] = await Promise.all([client.testAuth(), client.listSpaces({ max })])
+
+    const result: SnapshotResult = {
+      bot: {
+        id: me.id,
+        displayName: me.displayName,
+        emails: me.emails,
+      },
+      spaces: options.full
+        ? spaces.map((s) => ({ id: s.id, title: s.title, type: s.type, lastActivity: s.lastActivity }))
+        : spaces.map((s) => ({ id: s.id, title: s.title })),
+    }
+
+    if (!options.full) {
+      result.hint = "Use 'message list <space>' for messages, 'space info <space>' for details."
+    }
+
+    return result
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const snapshotCommand = new Command('snapshot')
+  .description('Workspace overview for AI agents (brief by default, --full for details)')
+  .option('--full', 'Include full space details')
+  .option('--max <n>', 'Number of spaces to retrieve', '100')
+  .option('--bot <id>', 'Use specific bot')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption & { full?: boolean; max?: string }) => {
+    cliOutput(await snapshotAction(opts), opts.pretty)
+  })

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

@@ -0,0 +1,88 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface SpaceResult {
+  id?: string
+  title?: string
+  type?: 'group' | 'direct'
+  isLocked?: boolean
+  teamId?: string | null
+  lastActivity?: string
+  created?: string
+  creatorId?: string
+  spaces?: Array<{
+    id: string
+    title: string
+    type: 'group' | 'direct'
+    lastActivity: string
+    created: string
+  }>
+  error?: string
+}
+
+export async function listAction(options: BotOption & { max?: string; type?: string }): Promise<SpaceResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 50
+    const spaces = await client.listSpaces({ type: options.type, max })
+
+    return {
+      spaces: spaces.map((s) => ({
+        id: s.id,
+        title: s.title,
+        type: s.type,
+        lastActivity: s.lastActivity,
+        created: s.created,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function infoAction(spaceId: string, options: BotOption): Promise<SpaceResult> {
+  try {
+    const client = await getClient(options)
+    const space = await client.getSpace(spaceId)
+    return {
+      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,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const spaceCommand = new Command('space')
+  .description('Space commands')
+  .addCommand(
+    new Command('list')
+      .description('List spaces')
+      .option('--max <n>', 'Number of spaces to retrieve', '50')
+      .option('--type <type>', 'Filter by type (group or direct)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: BotOption & { max?: string; type?: string }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get space details')
+      .argument('<id>', 'Space ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (spaceId: string, opts: BotOption) => {
+        cliOutput(await infoAction(spaceId, opts), opts.pretty)
+      }),
+  )

package/src/platforms/webexbot/commands/user.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockListPeople = mock(() =>
+  Promise.resolve([
+    {
+      id: 'p1',
+      emails: ['alice@example.com'],
+      displayName: 'Alice',
+      orgId: 'o1',
+      type: 'person' as const,
+      created: '',
+    },
+  ]),
+)
+
+const mockGetPerson = mock(() =>
+  Promise.resolve({
+    id: 'p1',
+    emails: ['alice@example.com'],
+    displayName: 'Alice',
+    orgId: 'o1',
+    type: 'person' as const,
+    created: '2024-01-01T00:00:00Z',
+  }),
+)
+
+mock.module('../client', () => ({
+  WebexBotClient: class MockWebexBotClient {
+    async login(): Promise<this> {
+      return this
+    }
+    listPeople = mockListPeople
+    getPerson = mockGetPerson
+  },
+}))
+
+import { WebexBotCredentialManager } from '../credential-manager'
+import { infoAction, listAction } from './user'
+
+describe('webexbot user commands', () => {
+  let tempDir: string
+  let manager: WebexBotCredentialManager
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `webexbot-user-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token123', bot_id: 'bot1', bot_name: 'Bot' })
+    mockListPeople.mockClear()
+    mockGetPerson.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+  })
+
+  it('lists people by email', async () => {
+    const result = await listAction({ _credManager: manager, email: 'alice@example.com' })
+
+    expect(result.users).toHaveLength(1)
+    expect(result.users?.[0].displayName).toBe('Alice')
+    expect(mockListPeople).toHaveBeenCalled()
+  })
+
+  it('gets a person by id', async () => {
+    const result = await infoAction('p1', { _credManager: manager })
+
+    expect(result.id).toBe('p1')
+    expect(result.displayName).toBe('Alice')
+  })
+})

package/src/platforms/webexbot/commands/user.ts

@@ -0,0 +1,98 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { WebexPerson } from '../../webex/types'
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface UserResult {
+  id?: string
+  emails?: string[]
+  displayName?: string
+  nickName?: string
+  firstName?: string
+  lastName?: string
+  avatar?: string
+  orgId?: string
+  type?: 'person' | 'bot'
+  created?: string
+  users?: Array<{
+    id: string
+    emails: string[]
+    displayName: string
+    type: 'person' | 'bot'
+  }>
+  error?: string
+}
+
+function formatPerson(person: WebexPerson): UserResult {
+  return {
+    id: person.id,
+    emails: person.emails,
+    displayName: person.displayName,
+    nickName: person.nickName,
+    firstName: person.firstName,
+    lastName: person.lastName,
+    avatar: person.avatar,
+    orgId: person.orgId,
+    type: person.type,
+    created: person.created,
+  }
+}
+
+export async function listAction(
+  options: BotOption & { email?: string; displayName?: string; max?: string },
+): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : undefined
+    const people = await client.listPeople({ email: options.email, displayName: options.displayName, max })
+
+    return {
+      users: people.map((p) => ({
+        id: p.id,
+        emails: p.emails,
+        displayName: p.displayName,
+        type: p.type,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function infoAction(personId: string, options: BotOption): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const person = await client.getPerson(personId)
+    return formatPerson(person)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const userCommand = new Command('user')
+  .description('User commands')
+  .addCommand(
+    new Command('list')
+      .description('Search people by email or display name')
+      .option('--email <email>', 'Filter by exact email')
+      .option('--display-name <name>', 'Filter by display name prefix')
+      .option('--max <n>', 'Number of users to retrieve')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: BotOption & { email?: string; displayName?: string; max?: string }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get details for a person')
+      .argument('<id>', 'Person ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (personId: string, opts: BotOption) => {
+        cliOutput(await infoAction(personId, opts), opts.pretty)
+      }),
+  )

package/src/platforms/webexbot/commands/whoami.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: string
+  emails?: string[]
+  displayName?: string
+  avatar?: string
+  orgId?: string
+  type?: 'person' | 'bot'
+  created?: string
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.testAuth()
+    return {
+      id: info.id,
+      emails: info.emails,
+      displayName: info.displayName,
+      avatar: info.avatar,
+      orgId: info.orgId,
+      type: info.type,
+      created: info.created,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--bot <id>', 'Bot ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })