agent-messenger 2.20.5 → 2.22.0

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/file.ts

@@ -0,0 +1,104 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { basename, resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface FileResult {
+  id?: string
+  roomId?: string
+  files?: string[]
+  created?: string
+  downloaded?: string
+  filename?: string
+  contentType?: string
+  size?: number
+  error?: string
+}
+
+export async function uploadAction(
+  space: string,
+  path: string,
+  options: BotOption & { text?: string; markdown?: boolean; parent?: string },
+): Promise<FileResult> {
+  try {
+    const client = await getClient(options)
+    const filePath = resolve(path)
+    const content = await readFile(filePath)
+    const message = await client.uploadFile(
+      space,
+      { content: new Blob([content]), filename: basename(filePath) },
+      { text: options.text, markdown: options.markdown, parentId: options.parent },
+    )
+
+    return {
+      id: message.id,
+      roomId: message.roomId,
+      files: message.files,
+      created: message.created,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function downloadAction(
+  contentRef: string,
+  output: string | undefined,
+  options: BotOption,
+): Promise<FileResult> {
+  try {
+    const client = await getClient(options)
+    const { data, filename, contentType } = await client.downloadContent(contentRef)
+    // When no explicit output is given, confine the server-provided name to cwd.
+    const outputPath = output ? resolve(output) : resolve(process.cwd(), basename(filename))
+    await writeFile(outputPath, Buffer.from(data))
+
+    return {
+      downloaded: outputPath,
+      filename,
+      contentType,
+      size: data.byteLength,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const fileCommand = new Command('file')
+  .description('File commands')
+  .addCommand(
+    new Command('upload')
+      .description('Upload a local file to a space')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<path>', 'Local file path')
+      .option('--text <text>', 'Optional message to send with the file')
+      .option('--markdown', 'Treat --text 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,
+          path: string,
+          opts: BotOption & { text?: string; markdown?: boolean; parent?: string },
+        ) => {
+          cliOutput(await uploadAction(space, path, opts), opts.pretty)
+        },
+      ),
+  )
+  .addCommand(
+    new Command('download')
+      .description('Download a file attachment by content URL or ID')
+      .argument('<content>', 'File content URL (from message.files) or content ID')
+      .argument('[output]', 'Output path (defaults to original filename)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (content: string, output: string | undefined, opts: BotOption) => {
+        cliOutput(await downloadAction(content, output, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,9 @@
+export { authCommand } from './auth'
+export { fileCommand } from './file'
+export { listenCommand } from './listen'
+export { memberCommand } from './member'
+export { messageCommand } from './message'
+export { snapshotCommand } from './snapshot'
+export { spaceCommand } from './space'
+export { userCommand } from './user'
+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)
+    }),
+)