agent-messenger 1.15.0 → 2.1.0

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

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import * as childProcess from 'node:child_process'
+
+import { WebexClient } from '../client'
+import { WebexCredentialManager } from '../credential-manager'
+import { loginAction, logoutAction, statusAction } from './auth'
+
+describe('auth commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let _consoleErrorSpy: ReturnType<typeof spyOn>
+  const mockPerson = {
+    id: 'person-1',
+    displayName: 'Test User',
+    emails: ['test@example.com'],
+    orgId: 'org-1',
+    type: 'person' as const,
+    created: '2024-01-01T00:00:00.000Z',
+  }
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    _consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
+  })
+
+  afterEach(() => {
+    mock.restore()
+  })
+
+  describe('loginAction with --token', () => {
+    test('authenticates with provided token (bot token flow)', async () => {
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+
+      await loginAction({ token: 'bot-token-123', pretty: false })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.authenticated).toBe(true)
+      expect(output.user.displayName).toBe('Test User')
+    })
+
+    test('saves tokenType as manual with expiresAt 0', async () => {
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      const saveSpy = spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+
+      await loginAction({ token: 'bot-token-123', pretty: false })
+
+      const savedConfig = saveSpy.mock.calls[0][0] as { tokenType: string; expiresAt: number; refreshToken: string }
+      expect(savedConfig.tokenType).toBe('manual')
+      expect(savedConfig.expiresAt).toBe(0)
+      expect(savedConfig.refreshToken).toBe('')
+    })
+  })
+
+  describe('loginAction with --client-id and --client-secret', () => {
+    test('uses provided credentials for Device Grant flow', async () => {
+      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+        deviceCode: 'd',
+        userCode: 'u',
+        verificationUri: 'https://v',
+        verificationUriComplete: 'https://vc',
+        expiresIn: 300,
+        interval: 0.01,
+      })
+      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+        accessToken: 'at',
+        refreshToken: 'rt',
+        expiresAt: Date.now() + 3600000,
+      })
+      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
+
+      expect(WebexCredentialManager.prototype.requestDeviceCode).toHaveBeenCalledWith('my-id')
+      expect(WebexCredentialManager.prototype.pollDeviceToken).toHaveBeenCalledWith('d', 0.01, 300, 'my-id', 'my-secret')
+    })
+
+    test('saves tokenType as oauth in config', async () => {
+      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+        deviceCode: 'd',
+        userCode: 'u',
+        verificationUri: 'https://v',
+        verificationUriComplete: 'https://vc',
+        expiresIn: 300,
+        interval: 0.01,
+      })
+      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+        accessToken: 'at',
+        refreshToken: 'rt',
+        expiresAt: Date.now() + 3600000,
+      })
+      const saveSpy = spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
+
+      const savedConfig = saveSpy.mock.calls[0][0] as { tokenType: string }
+      expect(savedConfig.tokenType).toBe('oauth')
+    })
+
+    test('saves clientId and clientSecret in config', async () => {
+      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+        deviceCode: 'd',
+        userCode: 'u',
+        verificationUri: 'https://v',
+        verificationUriComplete: 'https://vc',
+        expiresIn: 300,
+        interval: 0.01,
+      })
+      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+        accessToken: 'at',
+        refreshToken: 'rt',
+        expiresAt: Date.now() + 3600000,
+      })
+      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
+
+      const savedConfig = (WebexCredentialManager.prototype.saveConfig as ReturnType<typeof spyOn>).mock.calls[0][0] as { clientId: string; clientSecret: string }
+      expect(savedConfig.clientId).toBe('my-id')
+      expect(savedConfig.clientSecret).toBe('my-secret')
+    })
+  })
+
+  describe('statusAction', () => {
+    test('shows authenticated status when token is valid', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await statusAction({ pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.authenticated).toBe(true)
+      expect(output.user.displayName).toBe('Test User')
+    })
+
+    test('shows not authenticated when no token', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue(null)
+      const exitSpy = spyOn(process, 'exit').mockImplementation(() => undefined as never)
+
+      await statusAction({ pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Not authenticated')
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+
+    test('shows not authenticated when token validation fails', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('invalid-token')
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('401 Unauthorized'))
+
+      await statusAction({ pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.authenticated).toBe(false)
+    })
+
+    test('loads config for stored client credentials', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+        accessToken: 'at',
+        refreshToken: 'rt',
+        expiresAt: Date.now() + 3600000,
+        clientId: 'stored-id',
+        clientSecret: 'stored-secret',
+      })
+      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await statusAction({ pretty: false })
+
+      expect(WebexCredentialManager.prototype.getToken).toHaveBeenCalledWith('stored-id', 'stored-secret')
+    })
+  })
+
+  describe('logoutAction', () => {
+    test('clears credentials when authenticated', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+        accessToken: 'token',
+        refreshToken: 'refresh',
+        expiresAt: Date.now() + 3600000,
+      })
+      const clearSpy = spyOn(WebexCredentialManager.prototype, 'clearCredentials').mockResolvedValue(undefined)
+
+      await logoutAction({ pretty: false })
+
+      expect(clearSpy).toHaveBeenCalled()
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.success).toBe(true)
+    })
+
+    test('shows error when not authenticated', async () => {
+      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      const exitSpy = spyOn(process, 'exit').mockImplementation(() => undefined as never)
+
+      await logoutAction({ pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Not authenticated')
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+  })
+})

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

@@ -0,0 +1,180 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { getWebexAppCredentials } from '../app-config'
+import { WebexClient } from '../client'
+import { WebexCredentialManager } from '../credential-manager'
+
+interface ResolvedCredentials {
+  clientId: string
+  clientSecret: string
+}
+
+async function openBrowser(url: string): Promise<void> {
+  const { exec } = await import('node:child_process')
+  const command =
+    process.platform === 'darwin'
+      ? `open "${url}"`
+      : process.platform === 'win32'
+        ? `start "" "${url}"`
+        : `xdg-open "${url}"`
+  exec(command)
+}
+
+async function resolveClientCredentials(options: {
+  clientId?: string
+  clientSecret?: string
+}): Promise<ResolvedCredentials> {
+  // 1. CLI flags
+  if (options.clientId || options.clientSecret) {
+    if (!options.clientId || !options.clientSecret) {
+      throw new Error('Both --client-id and --client-secret must be provided together.')
+    }
+    return { clientId: options.clientId, clientSecret: options.clientSecret }
+  }
+
+  // 2. Env vars → 3. Built-in defaults (always resolves)
+  return getWebexAppCredentials()
+}
+
+export async function loginAction(options: { token?: string; clientId?: string; clientSecret?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new WebexCredentialManager()
+
+    if (options.token) {
+      const client = await new WebexClient().login({ token: options.token })
+      const person = await client.testAuth()
+      await credManager.saveConfig({
+        accessToken: options.token,
+        refreshToken: '',
+        expiresAt: 0,
+        tokenType: 'manual',
+      })
+      console.log(
+        formatOutput(
+          {
+            user: { id: person.id, displayName: person.displayName, emails: person.emails },
+            authenticated: true,
+          },
+          options.pretty,
+        ),
+      )
+      return
+    }
+
+    const { clientId, clientSecret } = await resolveClientCredentials(options)
+
+    const device = await credManager.requestDeviceCode(clientId)
+
+    console.error(`Open this URL and enter the code: ${device.verificationUri}`)
+    console.error(`Code: ${device.userCode}`)
+    console.error('')
+    await openBrowser(device.verificationUriComplete)
+    console.error('Waiting for authorization...')
+
+    const config = await credManager.pollDeviceToken(
+      device.deviceCode,
+      device.interval,
+      device.expiresIn,
+      clientId,
+      clientSecret,
+    )
+
+    await credManager.saveConfig({ ...config, clientId, clientSecret, tokenType: 'oauth' })
+
+    const client = await new WebexClient().login({ token: config.accessToken })
+    const person = await client.testAuth()
+
+    console.log(
+      formatOutput(
+        {
+          user: { id: person.id, displayName: person.displayName, emails: person.emails },
+          authenticated: true,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function statusAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new WebexCredentialManager()
+    const config = await credManager.loadConfig()
+    const token = await credManager.getToken(config?.clientId, config?.clientSecret)
+
+    if (!token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty),
+      )
+      process.exit(1)
+      return
+    }
+
+    try {
+      const client = await new WebexClient().login({ token })
+      const person = await client.testAuth()
+      console.log(
+        formatOutput(
+          {
+            authenticated: true,
+            user: { id: person.id, displayName: person.displayName, emails: person.emails },
+          },
+          options.pretty,
+        ),
+      )
+    } catch {
+      console.log(formatOutput({ authenticated: false, user: null }, options.pretty))
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function logoutAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new WebexCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth login" first.' }, options.pretty),
+      )
+      process.exit(1)
+      return
+    }
+
+    await credManager.clearCredentials()
+    console.log(formatOutput({ removed: 'webex', success: true }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Authentication commands')
+  .addCommand(
+    new Command('login')
+      .description('Login to Webex')
+      .option('--token <token>', 'Use a bot token or personal access token directly')
+      .option('--client-id <id>', 'Webex Integration client ID')
+      .option('--client-secret <secret>', 'Webex Integration client secret')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(loginAction),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction),
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Logout from Webex')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction),
+  )

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

@@ -0,0 +1,5 @@
+export { authCommand } from './auth'
+export { memberCommand } from './member'
+export { messageCommand } from './message'
+export { snapshotAction, snapshotCommand } from './snapshot'
+export { spaceCommand } from './space'

package/src/platforms/webex/commands/member.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { listAction } from './member'
+
+describe('member commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+  const mockMembers = [
+    {
+      id: 'mem-1',
+      roomId: 'room-1',
+      personId: 'person-1',
+      personEmail: 'alice@example.com',
+      personDisplayName: 'Alice',
+      isModerator: true,
+      created: '2024-01-01T00:00:00.000Z',
+    },
+    {
+      id: 'mem-2',
+      roomId: 'room-1',
+      personId: 'person-2',
+      personEmail: 'bob@example.com',
+      personDisplayName: 'Bob',
+      isModerator: false,
+      created: '2024-01-02T00:00:00.000Z',
+    },
+  ]
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+      throw new Error(`process.exit(${_code})`)
+    })
+    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers)
+  })
+
+  afterEach(() => {
+    mock.restore()
+  })
+
+  test('listAction calls listMemberships with spaceId and outputs mapped members', async () => {
+    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
+      mockMembers,
+    )
+
+    await listAction('room-1', {})
+
+    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: undefined })
+    expect(consoleSpy).toHaveBeenCalledWith(
+      JSON.stringify([
+        {
+          id: 'mem-1',
+          personId: 'person-1',
+          personEmail: 'alice@example.com',
+          personDisplayName: 'Alice',
+          isModerator: true,
+          created: '2024-01-01T00:00:00.000Z',
+        },
+        {
+          id: 'mem-2',
+          personId: 'person-2',
+          personEmail: 'bob@example.com',
+          personDisplayName: 'Bob',
+          isModerator: false,
+          created: '2024-01-02T00:00:00.000Z',
+        },
+      ]),
+    )
+  })
+
+  test('listAction passes limit option to listMemberships', async () => {
+    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
+      mockMembers,
+    )
+
+    await listAction('room-1', { limit: 25 })
+
+    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: 25 })
+  })
+
+  test('listAction handles not-authenticated case', async () => {
+    spyOn(WebexClient.prototype, 'login').mockRejectedValue(
+      new WebexError('No Webex credentials found.', 'no_credentials'),
+    )
+
+    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No Webex credentials found'))
+  })
+
+  test('listAction handles API error', async () => {
+    spyOn(WebexClient.prototype, 'listMemberships').mockRejectedValue(new Error('API failure'))
+
+    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+
+    expect(processExitSpy).toHaveBeenCalledWith(1)
+  })
+})

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

@@ -0,0 +1,45 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { WebexClient } from '../client'
+
+export async function listAction(
+  spaceId: string,
+  options: { limit?: number; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const members = await client.listMemberships(spaceId, { max: options.limit })
+
+    const output = members.map((m) => ({
+      id: m.id,
+      personId: m.personId,
+      personEmail: m.personEmail,
+      personDisplayName: m.personDisplayName,
+      isModerator: m.isModerator,
+      created: m.created,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const memberCommand = new Command('member')
+  .description('Member commands')
+  .addCommand(
+    new Command('list')
+      .description('List members of a space')
+      .argument('<space-id>', 'Space ID')
+      .option('--limit <n>', 'Number of members to retrieve', '100')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((spaceId, options) =>
+        listAction(spaceId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        }),
+      ),
+  )