agent-messenger 2.20.5 → 2.22.0

package/src/platforms/webexbot/client.test.ts

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+
+import { WebexBotClient } from './client'
+
+describe('WebexBotClient', () => {
+  const originalFetch = globalThis.fetch
+  let fetchCalls: Array<{ url: string; options?: RequestInit }> = []
+  let fetchResponses: Response[] = []
+  let fetchIndex = 0
+
+  beforeEach(() => {
+    fetchCalls = []
+    fetchResponses = []
+    fetchIndex = 0
+    ;(globalThis as { fetch: unknown }).fetch = async (
+      url: string | URL | Request,
+      options?: RequestInit,
+    ): Promise<Response> => {
+      fetchCalls.push({ url: url.toString(), options })
+      const response = fetchResponses[fetchIndex]
+      fetchIndex++
+      if (!response) {
+        throw new Error('No mock response configured')
+      }
+      return response
+    }
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  const mockResponse = (body: unknown, status = 200) => {
+    fetchResponses.push(
+      new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    )
+  }
+
+  describe('listMessages', () => {
+    it('limits group-space history to messages that mention the bot', async () => {
+      mockResponse({ id: 'group-room', title: 'Team', type: 'group' })
+      mockResponse({ items: [{ id: 'msg-1', roomId: 'group-room', roomType: 'group' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const messages = await client.listMessages('group-room', { max: 5 })
+
+      expect(messages).toHaveLength(1)
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/rooms/group-room')
+
+      const messagesUrl = new URL(fetchCalls[1].url)
+      expect(messagesUrl.origin + messagesUrl.pathname).toBe('https://webexapis.com/v1/messages')
+      expect(messagesUrl.searchParams.get('roomId')).toBe('group-room')
+      expect(messagesUrl.searchParams.get('max')).toBe('5')
+      expect(messagesUrl.searchParams.get('mentionedPeople')).toBe('me')
+    })
+
+    it('does not add mentionedPeople for direct spaces', async () => {
+      mockResponse({ id: 'direct-room', title: 'DM', type: 'direct' })
+      mockResponse({ items: [{ id: 'msg-1', roomId: 'direct-room', roomType: 'direct' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.listMessages('direct-room', { max: 5 })
+
+      const messagesUrl = new URL(fetchCalls[1].url)
+      expect(messagesUrl.searchParams.get('roomId')).toBe('direct-room')
+      expect(messagesUrl.searchParams.get('mentionedPeople')).toBeNull()
+    })
+  })
+
+  describe('sendMessage threading', () => {
+    it('includes parentId in the request body when threading', async () => {
+      mockResponse({ id: 'msg-1', roomId: 'room-1', roomType: 'group' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage('room-1', 'reply text', { parentId: 'parent-1' })
+
+      const body = JSON.parse(fetchCalls[0].options?.body as string)
+      expect(body.roomId).toBe('room-1')
+      expect(body.text).toBe('reply text')
+      expect(body.parentId).toBe('parent-1')
+    })
+  })
+
+  describe('listReplies', () => {
+    it('queries messages filtered by parentId', async () => {
+      mockResponse({ items: [{ id: 'reply-1', roomId: 'room-1', roomType: 'group', parentId: 'parent-1' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const replies = await client.listReplies('room-1', 'parent-1', { max: 10 })
+
+      expect(replies).toHaveLength(1)
+      const url = new URL(fetchCalls[0].url)
+      expect(url.searchParams.get('roomId')).toBe('room-1')
+      expect(url.searchParams.get('parentId')).toBe('parent-1')
+      expect(url.searchParams.get('max')).toBe('10')
+    })
+  })
+
+  describe('getPerson', () => {
+    it('fetches a person by id', async () => {
+      mockResponse({ id: 'person-1', emails: ['a@b.com'], displayName: 'Alice', type: 'person' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const person = await client.getPerson('person-1')
+
+      expect(person.displayName).toBe('Alice')
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/people/person-1')
+    })
+  })
+
+  describe('uploadFile', () => {
+    it('posts multipart form data to messages', async () => {
+      mockResponse({
+        id: 'msg-1',
+        roomId: 'room-1',
+        roomType: 'group',
+        files: ['https://webexapis.com/v1/contents/c1'],
+      })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const message = await client.uploadFile(
+        'room-1',
+        { content: new Blob(['hello']), filename: 'note.txt' },
+        { text: 'see attached' },
+      )
+
+      expect(message.files).toEqual(['https://webexapis.com/v1/contents/c1'])
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/messages')
+      expect(fetchCalls[0].options?.method).toBe('POST')
+      const body = fetchCalls[0].options?.body as FormData
+      expect(body).toBeInstanceOf(FormData)
+      expect(body.get('roomId')).toBe('room-1')
+      expect(body.get('text')).toBe('see attached')
+    })
+  })
+
+  describe('downloadContent', () => {
+    it('returns binary data with filename parsed from Content-Disposition', async () => {
+      fetchResponses.push(
+        new Response('binary-bytes', {
+          status: 200,
+          headers: {
+            'Content-Disposition': 'attachment; filename="report.pdf"',
+            'Content-Type': 'application/pdf',
+          },
+        }),
+      )
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('https://webexapis.com/v1/contents/c1')
+
+      expect(result.filename).toBe('report.pdf')
+      expect(result.contentType).toBe('application/pdf')
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/contents/c1')
+    })
+
+    it('builds the contents URL from a bare content id', async () => {
+      fetchResponses.push(new Response('data', { status: 200, headers: {} }))
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('abc123')
+
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/contents/abc123')
+      expect(result.filename).toBe('abc123')
+    })
+
+    it('refuses to download from a non-Webex host', async () => {
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+
+      await expect(client.downloadContent('https://attacker.example/file')).rejects.toThrow(/untrusted/i)
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('refuses to download over plain http from the Webex host', async () => {
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+
+      await expect(client.downloadContent('http://webexapis.com/v1/contents/c1')).rejects.toThrow(/untrusted/i)
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('sanitizes a path-traversal filename from Content-Disposition', async () => {
+      fetchResponses.push(
+        new Response('data', {
+          status: 200,
+          headers: { 'Content-Disposition': 'attachment; filename="../../etc/passwd"' },
+        }),
+      )
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('https://webexapis.com/v1/contents/c1')
+
+      expect(result.filename).toBe('passwd')
+    })
+  })
+})

package/src/platforms/webexbot/client.ts

@@ -0,0 +1,113 @@
+import { WebexClient } from '../webex/client'
+import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from '../webex/types'
+import { WebexBotError } from './types'
+
+export class WebexBotClient {
+  private client = new WebexClient()
+  private token: string | null = null
+
+  async login(credentials?: { token: string }): Promise<this> {
+    if (credentials) {
+      if (!credentials.token) {
+        throw new WebexBotError('Token is required', 'missing_token')
+      }
+      this.token = credentials.token
+      await this.client.login({ token: credentials.token })
+      return this
+    }
+
+    const { WebexBotCredentialManager } = await import('./credential-manager')
+    const credManager = new WebexBotCredentialManager()
+    const creds = await credManager.getCredentials()
+    if (!creds?.token) {
+      throw new WebexBotError('No Webex bot credentials found. Run "auth set <token>" first.', 'no_credentials')
+    }
+    return this.login({ token: creds.token })
+  }
+
+  getToken(): string {
+    if (!this.token) {
+      throw new WebexBotError('Not authenticated. Call .login() first.', 'not_authenticated')
+    }
+    return this.token
+  }
+
+  async testAuth(): Promise<WebexPerson> {
+    return this.client.testAuth()
+  }
+
+  async listSpaces(options?: { type?: string; max?: number }): Promise<WebexSpace[]> {
+    return this.client.listSpaces(options)
+  }
+
+  async getSpace(spaceId: string): Promise<WebexSpace> {
+    return this.client.getSpace(spaceId)
+  }
+
+  async sendMessage(
+    roomId: string,
+    text: string,
+    options?: { markdown?: boolean; parentId?: string; files?: string[] },
+  ): Promise<WebexMessage> {
+    return this.client.sendMessage(roomId, text, options)
+  }
+
+  async sendDirectMessage(personEmail: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
+    return this.client.sendDirectMessage(personEmail, text, options)
+  }
+
+  async listMessages(roomId: string, options?: { max?: number; parentId?: string }): Promise<WebexMessage[]> {
+    const space = await this.client.getSpace(roomId)
+    const messageOptions = space.type === 'group' ? { ...options, mentionedPeople: 'me' } : options
+    return this.client.listMessages(roomId, messageOptions)
+  }
+
+  async listReplies(roomId: string, parentId: string, options?: { max?: number }): Promise<WebexMessage[]> {
+    return this.client.listMessages(roomId, { ...options, parentId })
+  }
+
+  async getMessage(messageId: string): Promise<WebexMessage> {
+    return this.client.getMessage(messageId)
+  }
+
+  async deleteMessage(messageId: string): Promise<void> {
+    return this.client.deleteMessage(messageId)
+  }
+
+  async editMessage(
+    messageId: string,
+    roomId: string,
+    text: string,
+    options?: { markdown?: boolean },
+  ): Promise<WebexMessage> {
+    return this.client.editMessage(messageId, roomId, text, options)
+  }
+
+  async listPeople(options?: { email?: string; displayName?: string; max?: number }): Promise<WebexPerson[]> {
+    return this.client.listPeople(options)
+  }
+
+  async getPerson(personId: string): Promise<WebexPerson> {
+    return this.client.getPerson(personId)
+  }
+
+  async listMyMemberships(options?: { max?: number }): Promise<WebexMembership[]> {
+    return this.client.listMyMemberships(options)
+  }
+
+  async listMemberships(roomId: string, options?: { max?: number }): Promise<WebexMembership[]> {
+    return this.client.listMemberships(roomId, options)
+  }
+
+  async uploadFile(
+    roomId: string,
+    file: { content: Blob; filename: string },
+    options?: { text?: string; markdown?: boolean; parentId?: string },
+  ): Promise<WebexMessage> {
+    return this.client.uploadFile(roomId, file, options)
+  }
+
+  async downloadContent(contentRef: string): Promise<{ data: ArrayBuffer; filename: string; contentType: string }> {
+    return this.client.downloadContent(contentRef)
+  }
+}

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()
+  })
+})