agent-messenger 2.20.4 → 2.21.0

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

@@ -0,0 +1,197 @@
+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 },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendMessage(space, text, { markdown: options.markdown })
+
+    return formatMessage(message)
+  } 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('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+        cliOutput(await sendAction(space, text, 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/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/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)
+  })

package/src/platforms/webexbot/credential-manager.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { WebexBotCredentialManager } from './credential-manager'
+
+const CREDS_A = {
+  token: 'bot-token-a',
+  bot_id: 'bot-123',
+  bot_name: 'Bot A',
+}
+
+const CREDS_B = {
+  token: 'bot-token-b',
+  bot_id: 'bot-456',
+  bot_name: 'Bot B',
+}
+
+describe('WebexBotCredentialManager', () => {
+  let tempDir: string
+  let manager: WebexBotCredentialManager
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `webexbot-cred-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    manager = new WebexBotCredentialManager(tempDir)
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    delete process.env.E2E_WEBEXBOT_TOKEN
+  })
+
+  it('returns empty config when no file exists', async () => {
+    const config = await manager.load()
+
+    expect(config.current).toBeNull()
+    expect(config.bots).toEqual({})
+  })
+
+  it('persists config to file', async () => {
+    const config = {
+      current: { bot_id: 'bot-123' },
+      bots: {
+        'bot-123': { bot_id: 'bot-123', bot_name: 'Test Bot', token: 'test-token' },
+      },
+    }
+
+    await manager.save(config)
+    const loaded = await manager.load()
+
+    expect(loaded).toEqual(config)
+  })
+
+  it('returns null when no credentials exist', async () => {
+    expect(await manager.getCredentials()).toBeNull()
+  })
+
+  it('returns current bot credentials', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    const creds = await manager.getCredentials()
+
+    expect(creds).toEqual(CREDS_A)
+  })
+
+  it('returns specific bot by id', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    const creds = await manager.getCredentials('bot-123')
+
+    expect(creds).toEqual(CREDS_A)
+  })
+
+  it('returns null for non-existent bot id', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    const creds = await manager.getCredentials('nonexistent')
+
+    expect(creds).toBeNull()
+  })
+
+  it('env var takes precedence when no botId specified', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    process.env.E2E_WEBEXBOT_TOKEN = 'env-token'
+
+    const creds = await manager.getCredentials()
+
+    expect(creds).toEqual({ token: 'env-token', bot_id: 'env', bot_name: 'env' })
+  })
+
+  it('env var is ignored when botId explicitly provided', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    process.env.E2E_WEBEXBOT_TOKEN = 'env-token'
+
+    const creds = await manager.getCredentials('bot-123')
+
+    expect(creds).toEqual(CREDS_A)
+  })
+
+  it('stores multiple bots and sets latest as current', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    const config = await manager.load()
+    expect(Object.keys(config.bots)).toEqual(['bot-123', 'bot-456'])
+    expect(config.current).toEqual({ bot_id: 'bot-456' })
+  })
+
+  it('returns all bots with current flag', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    const all = await manager.listAll()
+
+    expect(all).toHaveLength(2)
+    expect(all.find((b) => b.bot_id === 'bot-123')?.is_current).toBe(false)
+    expect(all.find((b) => b.bot_id === 'bot-456')?.is_current).toBe(true)
+  })
+
+  it('switches current bot', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    const switched = await manager.setCurrent('bot-123')
+
+    expect(switched).toBe(true)
+    const creds = await manager.getCredentials()
+    expect(creds?.bot_id).toBe('bot-123')
+  })
+
+  it('returns false when switching to unknown bot', async () => {
+    expect(await manager.setCurrent('nonexistent')).toBe(false)
+  })
+
+  it('removes a bot by id', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    const removed = await manager.removeBot('bot-123')
+
+    expect(removed).toBe(true)
+    const config = await manager.load()
+    expect(Object.keys(config.bots)).toEqual(['bot-456'])
+  })
+
+  it('clears current when current bot is removed', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    await manager.removeBot('bot-123')
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+  })
+
+  it('clears all credentials', async () => {
+    await manager.setCredentials(CREDS_A)
+    await manager.setCredentials(CREDS_B)
+
+    await manager.clearCredentials()
+
+    const config = await manager.load()
+    expect(config.current).toBeNull()
+    expect(config.bots).toEqual({})
+  })
+
+  it('saves file with secure permissions', async () => {
+    await manager.setCredentials(CREDS_A)
+
+    const credPath = join(tempDir, 'webexbot-credentials.json')
+    const stats = await stat(credPath)
+
+    expect(stats.mode & 0o777).toBe(0o600)
+  })
+})

package/src/platforms/webexbot/credential-manager.ts

@@ -0,0 +1,149 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { getConfigDir } from '../../shared/utils/config-dir'
+import type { WebexBotConfig, WebexBotCredentials } from './types'
+import { WebexBotConfigSchema } from './types'
+
+export class WebexBotCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? getConfigDir()
+    this.credentialsPath = join(this.configDir, 'webexbot-credentials.json')
+  }
+
+  async load(): Promise<WebexBotConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, bots: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+
+    let json: unknown
+    try {
+      json = JSON.parse(content)
+    } catch {
+      return { current: null, bots: {} }
+    }
+
+    const parsed = WebexBotConfigSchema.safeParse(json)
+    if (!parsed.success) {
+      return { current: null, bots: {} }
+    }
+    return parsed.data
+  }
+
+  async save(config: WebexBotConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getCredentials(botId?: string): Promise<WebexBotCredentials | null> {
+    const envToken = process.env.E2E_WEBEXBOT_TOKEN
+
+    if (envToken && !botId) {
+      return {
+        token: envToken,
+        bot_id: 'env',
+        bot_name: 'env',
+      }
+    }
+
+    const config = await this.load()
+
+    if (botId) {
+      const bot = config.bots[botId]
+      if (!bot) return null
+      return {
+        token: bot.token,
+        bot_id: bot.bot_id,
+        bot_name: bot.bot_name,
+      }
+    }
+
+    if (!config.current) {
+      return null
+    }
+
+    const bot = config.bots[config.current.bot_id]
+    if (!bot) return null
+
+    return {
+      token: bot.token,
+      bot_id: bot.bot_id,
+      bot_name: bot.bot_name,
+    }
+  }
+
+  async setCredentials(creds: WebexBotCredentials): Promise<void> {
+    const config = await this.load()
+
+    config.bots[creds.bot_id] = {
+      bot_id: creds.bot_id,
+      bot_name: creds.bot_name,
+      token: creds.token,
+    }
+
+    config.current = {
+      bot_id: creds.bot_id,
+    }
+
+    await this.save(config)
+  }
+
+  async removeBot(botId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.bots[botId]) {
+      return false
+    }
+
+    delete config.bots[botId]
+
+    if (config.current?.bot_id === botId) {
+      config.current = null
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async setCurrent(botId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.bots[botId]) {
+      return false
+    }
+
+    config.current = {
+      bot_id: botId,
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async listAll(): Promise<Array<WebexBotCredentials & { is_current: boolean }>> {
+    const config = await this.load()
+    const results: Array<WebexBotCredentials & { is_current: boolean }> = []
+
+    for (const bot of Object.values(config.bots)) {
+      results.push({
+        token: bot.token,
+        bot_id: bot.bot_id,
+        bot_name: bot.bot_name,
+        is_current: config.current?.bot_id === bot.bot_id,
+      })
+    }
+
+    return results
+  }
+
+  async clearCredentials(): Promise<void> {
+    await this.save({ current: null, bots: {} })
+  }
+}

package/src/platforms/webexbot/index.ts

@@ -0,0 +1,8 @@
+export { WebexBotClient } from './client'
+export { WebexBotCredentialManager } from './credential-manager'
+export { WebexBotListener } from './listener'
+export type { WebexBotListenerOptions } from './listener'
+export type { WebexBotConfig, WebexBotCredentials, WebexBotEntry, WebexBotListenerEventMap } from './types'
+export { WebexBotConfigSchema, WebexBotCredentialsSchema, WebexBotEntrySchema, WebexBotError } from './types'
+export type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from '../webex/types'
+export { WebexMembershipSchema, WebexMessageSchema, WebexPersonSchema, WebexSpaceSchema } from '../webex/types'