agent-messenger 2.20.5 → 2.22.0

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'

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

@@ -0,0 +1,234 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { EventEmitter } from 'events'
+
+import type {
+  DecryptedMessage,
+  HandlerStatus,
+  MercuryActivity,
+  WebexMessageHandlerConfig,
+  WebexMessageHandlerEvents,
+} from 'webex-message-handler'
+
+import { WebexBotListener } from './listener'
+
+const STATUS: HandlerStatus = {
+  status: 'connected',
+  webSocketOpen: true,
+  kmsInitialized: true,
+  deviceRegistered: true,
+  reconnectAttempt: 0,
+}
+
+const RAW_ACTIVITY: MercuryActivity = {
+  id: 'activity-123',
+  verb: 'post',
+  actor: { id: 'person-123', objectType: 'person', emailAddress: 'user@example.com' },
+  object: { id: 'object-123', objectType: 'comment', displayName: 'hello' },
+  target: { id: 'room-123', objectType: 'conversation' },
+  published: '2024-01-01T00:00:00Z',
+}
+
+const MESSAGE: DecryptedMessage = {
+  id: 'message-123',
+  roomId: 'room-123',
+  personId: 'person-123',
+  personEmail: 'user@example.com',
+  text: 'hello',
+  created: '2024-01-01T00:00:00Z',
+  mentionedPeople: [],
+  mentionedGroups: [],
+  files: [],
+  raw: RAW_ACTIVITY,
+}
+
+class FakeWebexMessageHandler extends EventEmitter {
+  connect = mock(() => Promise.resolve())
+  disconnect = mock(() => Promise.resolve())
+  connected = true
+
+  status(): HandlerStatus {
+    return STATUS
+  }
+
+  override on<K extends keyof WebexMessageHandlerEvents>(event: K, listener: WebexMessageHandlerEvents[K]): this {
+    return super.on(event, listener)
+  }
+
+  override off<K extends keyof WebexMessageHandlerEvents>(event: K, listener: WebexMessageHandlerEvents[K]): this {
+    return super.off(event, listener)
+  }
+
+  override once<K extends keyof WebexMessageHandlerEvents>(event: K, listener: WebexMessageHandlerEvents[K]): this {
+    return super.once(event, listener)
+  }
+}
+
+describe('WebexBotListener', () => {
+  it('bridges handler message events and webex_event', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+    const messageCreated = mock((_event: DecryptedMessage) => undefined)
+    const webexEvent = mock((_event: DecryptedMessage) => undefined)
+    listener.on('message_created', messageCreated)
+    listener.on('webex_event', webexEvent)
+
+    await listener.start()
+    handler.emit('message:created', MESSAGE)
+
+    expect(messageCreated).toHaveBeenCalledWith(MESSAGE)
+    expect(webexEvent).toHaveBeenCalledWith(MESSAGE)
+  })
+
+  it('stop calls handler disconnect', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+
+    await listener.start()
+    await listener.stop()
+
+    expect(handler.disconnect).toHaveBeenCalled()
+  })
+
+  it('start is idempotent', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+
+    await listener.start()
+    await listener.start()
+
+    expect(handler.connect).toHaveBeenCalledTimes(1)
+  })
+
+  it('start rethrows and resets state when connect fails, allowing retry', async () => {
+    const failing = new FakeWebexMessageHandler()
+    failing.connect = mock(() => Promise.reject(new Error('device registration failed')))
+    const ok = new FakeWebexMessageHandler()
+    const handlers = [failing, ok]
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handlers.shift()!,
+    })
+
+    await expect(listener.start()).rejects.toThrow('device registration failed')
+    expect(failing.disconnect).toHaveBeenCalled()
+
+    await listener.start()
+    expect(ok.connect).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not throw when handler emits error with no error listener', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+    listener.on('message_created', () => undefined)
+
+    await listener.start()
+
+    expect(() => handler.emit('error', new Error('boom'))).not.toThrow()
+  })
+
+  it('ignores stale handler events after stop', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+    const messageCreated = mock((_event: DecryptedMessage) => undefined)
+    listener.on('message_created', messageCreated)
+
+    await listener.start()
+    await listener.stop()
+    handler.emit('message:created', MESSAGE)
+
+    expect(messageCreated).not.toHaveBeenCalled()
+  })
+
+  it('start-stop-start does not cross-talk between handlers', async () => {
+    const first = new FakeWebexMessageHandler()
+    const second = new FakeWebexMessageHandler()
+    const handlers = [first, second]
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handlers.shift()!,
+    })
+    const messageCreated = mock((_event: DecryptedMessage) => undefined)
+    listener.on('message_created', messageCreated)
+
+    await listener.start()
+    await listener.stop()
+    await listener.start()
+
+    first.emit('message:created', MESSAGE)
+    expect(messageCreated).not.toHaveBeenCalled()
+
+    second.emit('message:created', MESSAGE)
+    expect(messageCreated).toHaveBeenCalledTimes(1)
+  })
+
+  it('preserves disconnected reason', async () => {
+    const handler = new FakeWebexMessageHandler()
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+    const disconnected = mock((_reason: string) => undefined)
+    listener.on('disconnected', disconnected)
+
+    await listener.start()
+    handler.emit('disconnected', 'network lost')
+
+    expect(disconnected).toHaveBeenCalledWith('network lost')
+  })
+
+  it('concurrent start() calls share the same connect failure', async () => {
+    const handler = new FakeWebexMessageHandler()
+    handler.connect = mock(() => Promise.reject(new Error('connect failed')))
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+
+    const first = listener.start()
+    const second = listener.start()
+    const firstResult = first.then(
+      () => 'ok',
+      (e: Error) => e.message,
+    )
+    const secondResult = second.then(
+      () => 'ok',
+      (e: Error) => e.message,
+    )
+
+    expect(await firstResult).toBe('connect failed')
+    expect(await secondResult).toBe('connect failed')
+    expect(handler.connect).toHaveBeenCalledTimes(1)
+  })
+
+  it('disconnects a handler whose connect resolves after stop', async () => {
+    const handler = new FakeWebexMessageHandler()
+    let resolveConnect: () => void = () => undefined
+    handler.connect = mock(() => new Promise<void>((resolve) => (resolveConnect = resolve)))
+    const client = { getToken: () => 'token123' }
+    const listener = new WebexBotListener(client, {
+      _handlerFactory: (_config: WebexMessageHandlerConfig) => handler,
+    })
+
+    const starting = listener.start()
+    const stopping = listener.stop()
+    resolveConnect()
+    await Promise.all([starting, stopping])
+
+    expect(handler.disconnect).toHaveBeenCalled()
+  })
+})