agent-messenger 2.20.4 → 2.21.0

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

@@ -0,0 +1,185 @@
+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'
+
+import type { WebexPerson } from '../../webex/types'
+
+const mockTestAuth = mock(() =>
+  Promise.resolve({
+    id: 'bot123',
+    emails: ['bot@example.com'],
+    displayName: 'Test Bot',
+    orgId: 'org123',
+    type: 'bot' as const,
+    created: '2024-01-01T00:00:00Z',
+  }),
+)
+
+mock.module('../client', () => ({
+  WebexBotClient: class MockWebexBotClient {
+    async login(_credentials?: { token: string }): Promise<this> {
+      return this
+    }
+    testAuth = mockTestAuth
+  },
+}))
+
+import { WebexBotCredentialManager } from '../credential-manager'
+import { clearAction, listAction, removeAction, setAction, statusAction, useAction } from './auth'
+
+describe('webexbot auth commands', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `webexbot-auth-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_WEBEXBOT_TOKEN
+    mockTestAuth.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  it('validates and stores bot token with default bot_id from auth', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await setAction('token123', { _credManager: manager })
+
+    expect(result.success).toBe(true)
+    expect(result.bot_id).toBe('bot123')
+    expect(result.bot_name).toBe('Test Bot')
+
+    const creds = await manager.getCredentials()
+    expect(creds?.token).toBe('token123')
+    expect(creds?.bot_id).toBe('bot123')
+  })
+
+  it('uses --bot flag as bot_id', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await setAction('token123', { bot: 'mybot', _credManager: manager })
+
+    expect(result.bot_id).toBe('mybot')
+    const creds = await manager.getCredentials('mybot')
+    expect(creds?.token).toBe('token123')
+  })
+
+  it('rejects user tokens', async () => {
+    mockTestAuth.mockImplementationOnce(() =>
+      Promise.resolve({
+        id: 'user123',
+        emails: ['user@example.com'],
+        displayName: 'Test User',
+        orgId: 'org123',
+        type: 'person',
+        created: '2024-01-01T00:00:00Z',
+      } satisfies WebexPerson),
+    )
+
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await setAction('token123', { _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('not a bot token')
+  })
+
+  it('handles client errors', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('Invalid token')))
+
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await setAction('invalid', { _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('Invalid token')
+  })
+
+  it('clearAction removes all stored credentials', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token123', bot_id: 'mybot', bot_name: 'My Bot' })
+
+    const result = await clearAction({ _credManager: manager })
+
+    expect(result.success).toBe(true)
+    expect(await manager.getCredentials()).toBeNull()
+  })
+
+  it('statusAction returns no credentials when none set', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await statusAction({ _credManager: manager })
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toBeDefined()
+  })
+
+  it('statusAction returns valid status for current bot', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token123', bot_id: 'mybot', bot_name: 'My Bot' })
+
+    const result = await statusAction({ _credManager: manager })
+
+    expect(result.valid).toBe(true)
+    expect(result.bot_id).toBe('bot123')
+    expect(result.bot_name).toBe('Test Bot')
+  })
+
+  it('statusAction returns invalid when token test fails', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('Unauthorized')))
+
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'invalid-token', bot_id: 'mybot', bot_name: 'My Bot' })
+
+    const result = await statusAction({ _credManager: manager })
+
+    expect(result.valid).toBe(false)
+  })
+
+  it('listAction returns all stored bots', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token1', bot_id: 'bot1', bot_name: 'Bot 1' })
+    await manager.setCredentials({ token: 'token2', bot_id: 'bot2', bot_name: 'Bot 2' })
+
+    const result = await listAction({ _credManager: manager })
+
+    expect(result.bots).toHaveLength(2)
+    expect(result.bots?.find((b) => b.bot_id === 'bot2')?.is_current).toBe(true)
+  })
+
+  it('useAction switches current bot', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token1', bot_id: 'bot1', bot_name: 'Bot 1' })
+    await manager.setCredentials({ token: 'token2', bot_id: 'bot2', bot_name: 'Bot 2' })
+
+    const result = await useAction('bot1', { _credManager: manager })
+
+    expect(result.success).toBe(true)
+    expect(result.bot_id).toBe('bot1')
+  })
+
+  it('useAction returns error for unknown bot', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+
+    const result = await useAction('nonexistent', { _credManager: manager })
+    expect(result.error).toBeDefined()
+  })
+
+  it('removeAction removes a stored bot', async () => {
+    const manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token1', bot_id: 'bot1', bot_name: 'Bot 1' })
+
+    const result = await removeAction('bot1', { _credManager: manager })
+
+    expect(result.success).toBe(true)
+    expect(await manager.getCredentials('bot1')).toBeNull()
+  })
+})

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

@@ -0,0 +1,210 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+import { formatOutput } from '@/shared/utils/output'
+
+import { WebexBotClient } from '../client'
+import { WebexBotCredentialManager } from '../credential-manager'
+
+interface ActionOptions {
+  pretty?: boolean
+  bot?: string
+  _credManager?: WebexBotCredentialManager
+}
+
+interface ActionResult {
+  success?: boolean
+  error?: string
+  bot_id?: string
+  bot_name?: string
+  valid?: boolean
+  bots?: Array<{
+    bot_id: string
+    bot_name: string
+    is_current: boolean
+  }>
+}
+
+export async function setAction(token: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const client = await new WebexBotClient().login({ token })
+    const authInfo = await client.testAuth()
+
+    if (authInfo.type !== 'bot') {
+      return { error: 'Token is not a bot token. Use agent-webex for user tokens.' }
+    }
+
+    const botId = options.bot || authInfo.id || 'default'
+    const botName = authInfo.displayName || botId
+
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    await credManager.setCredentials({
+      token,
+      bot_id: botId,
+      bot_name: botName,
+    })
+
+    return {
+      success: true,
+      bot_id: botId,
+      bot_name: botName,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function clearAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    await credManager.clearCredentials()
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function statusAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    const creds = await credManager.getCredentials(options.bot)
+
+    if (!creds) {
+      return {
+        valid: false,
+        error: options.bot
+          ? `Bot "${options.bot}" not found. Run "auth list" to see available bots.`
+          : 'No credentials configured. Run "auth set <token>" first.',
+      }
+    }
+
+    let valid = false
+    let authInfo: { id: string; displayName: string; type: 'person' | 'bot' } | null = null
+
+    try {
+      const client = await new WebexBotClient().login({ token: creds.token })
+      authInfo = await client.testAuth()
+      valid = authInfo.type === 'bot'
+    } catch {
+      valid = false
+    }
+
+    return {
+      valid,
+      bot_id: authInfo?.id ?? creds.bot_id,
+      bot_name: authInfo?.displayName ?? creds.bot_name,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function listAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    const all = await credManager.listAll()
+
+    return {
+      bots: all.map((b) => ({
+        bot_id: b.bot_id,
+        bot_name: b.bot_name,
+        is_current: b.is_current,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function useAction(botId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    const found = await credManager.setCurrent(botId)
+
+    if (!found) {
+      return { error: `Bot "${botId}" not found. Run "auth list" to see available bots.` }
+    }
+
+    const creds = await credManager.getCredentials()
+    return {
+      success: true,
+      bot_id: creds?.bot_id,
+      bot_name: creds?.bot_name,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function removeAction(botId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new WebexBotCredentialManager()
+    const removed = await credManager.removeBot(botId)
+
+    if (!removed) {
+      return { error: `Bot "${botId}" not found. Run "auth list" to see available bots.` }
+    }
+
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Bot authentication commands')
+  .addCommand(
+    new Command('set')
+      .description('Set bot token')
+      .argument('<token>', 'Bot token')
+      .option('--bot <id>', 'Bot identifier for switching later')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (token: string, opts: { bot?: string; pretty?: boolean }) => {
+        cliOutput(await setAction(token, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('clear')
+      .description('Clear all stored credentials')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await clearAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--bot <id>', 'Check specific bot (default: current)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { bot?: string; pretty?: boolean }) => {
+        const result = await statusAction(opts)
+        console.log(formatOutput(result, opts.pretty))
+        if (!result.valid) process.exit(1)
+      }),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List all stored bots')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Switch active bot')
+      .argument('<bot>', 'Bot ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (botId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await useAction(botId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove a stored bot')
+      .argument('<bot>', 'Bot ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (botId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await removeAction(botId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,6 @@
+export { authCommand } from './auth'
+export { listenCommand } from './listen'
+export { memberCommand } from './member'
+export { messageCommand } from './message'
+export { spaceCommand } from './space'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'bun:test'
+
+import { parseEvents } from './listen'
+
+describe('webexbot listen parseEvents', () => {
+  it('returns defaults when no filter is given', () => {
+    const events = parseEvents(undefined)
+    expect(events).toContain('message_created')
+    expect(events).toContain('error')
+  })
+
+  it('accepts known event names', () => {
+    expect(parseEvents('message_created,disconnected')).toEqual(['message_created', 'disconnected'])
+  })
+
+  it('throws on unknown event names and lists supported events', () => {
+    expect(() => parseEvents('message_created,mesage_deleted')).toThrow(/Unknown event\(s\): mesage_deleted/)
+    expect(() => parseEvents('bogus')).toThrow(/Supported events:/)
+  })
+})

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

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import { WebexBotListener } from '../listener'
+import type { WebexBotListenerEventMap } from '../types'
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+type ListenEvent = keyof WebexBotListenerEventMap
+
+const SUPPORTED_EVENTS = new Set<ListenEvent>([
+  'message_created',
+  'message_updated',
+  'message_deleted',
+  'membership_created',
+  'attachment_action',
+  'room_created',
+  'room_updated',
+  'webex_event',
+  'connected',
+  'reconnecting',
+  'disconnected',
+  'error',
+])
+
+const DEFAULT_EVENTS: ListenEvent[] = [
+  'message_created',
+  'message_updated',
+  'message_deleted',
+  'membership_created',
+  'attachment_action',
+  'connected',
+  'reconnecting',
+  'disconnected',
+  'error',
+]
+
+interface ListenOptions extends BotOption {
+  events?: string
+}
+
+function printEvent(type: string, payload: unknown, pretty?: boolean): void {
+  const line = payload === undefined ? { type } : { type, payload }
+  console.log(JSON.stringify(line, null, pretty ? 2 : undefined))
+}
+
+export function parseEvents(events?: string): ListenEvent[] {
+  if (!events) return DEFAULT_EVENTS
+
+  const tokens = events
+    .split(',')
+    .map((event) => event.trim())
+    .filter((event) => event.length > 0)
+
+  const unknown = tokens.filter((event) => !SUPPORTED_EVENTS.has(event as ListenEvent))
+  if (unknown.length > 0) {
+    const supported = [...SUPPORTED_EVENTS].join(', ')
+    throw new Error(`Unknown event(s): ${unknown.join(', ')}. Supported events: ${supported}`)
+  }
+
+  return tokens as ListenEvent[]
+}
+
+export async function listenAction(options: ListenOptions): Promise<void> {
+  let events: ListenEvent[]
+  try {
+    events = parseEvents(options.events)
+  } catch (error) {
+    cliOutput({ error: (error as Error).message }, options.pretty, true)
+    return
+  }
+
+  const client = await getClient(options)
+  const listener = new WebexBotListener(client)
+
+  for (const event of events) {
+    if (event === 'error') {
+      listener.on(event, (error) => printEvent(event, { message: error.message, name: error.name }, options.pretty))
+      continue
+    }
+    listener.on(event, (payload) => printEvent(event, payload, options.pretty))
+  }
+
+  process.once('SIGINT', () => {
+    void listener.stop().finally(() => process.exit(0))
+  })
+
+  try {
+    await listener.start()
+  } catch (error) {
+    printEvent('error', { message: (error as Error).message, name: (error as Error).name }, options.pretty)
+    process.exit(1)
+  }
+}
+
+export const listenCommand = new Command('listen')
+  .description('Listen for real-time Webex bot events')
+  .option('--events <list>', 'Comma-separated event filter')
+  .option('--bot <id>', 'Use specific bot')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: ListenOptions) => {
+    await listenAction(opts)
+  })

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

@@ -0,0 +1,51 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface MemberResult {
+  members?: Array<{
+    id: string
+    personId: string
+    personEmail: string
+    personDisplayName: string
+    isModerator: boolean
+    created: string
+  }>
+  error?: string
+}
+
+export async function listAction(space: string, options: BotOption & { max?: string }): Promise<MemberResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 100
+    const members = await client.listMemberships(space, { max })
+
+    return {
+      members: members.map((m) => ({
+        id: m.id,
+        personId: m.personId,
+        personEmail: m.personEmail,
+        personDisplayName: m.personDisplayName,
+        isModerator: m.isModerator,
+        created: m.created,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const memberCommand = new Command('member').description('Member commands').addCommand(
+  new Command('list')
+    .description('List members of a space')
+    .argument('<space>', 'Space ID')
+    .option('--max <n>', 'Number of members to retrieve', '100')
+    .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)
+    }),
+)