agent-messenger 2.0.0 → 2.2.0

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

@@ -0,0 +1,243 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { info, debug } from '@/shared/utils/stderr'
+
+import { getWebexAppCredentials } from '../app-config'
+import { WebexClient } from '../client'
+import { WebexCredentialManager } from '../credential-manager'
+import { WebexTokenExtractor } from '../token-extractor'
+
+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)
+
+    info(`Open this URL and enter the code: ${device.verificationUri}`)
+    info(`Code: ${device.userCode}`)
+    info('')
+    await openBrowser(device.verificationUriComplete)
+    info('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 extractAction(options: { pretty?: boolean; debug?: boolean }): Promise<void> {
+  try {
+    const extractor = new WebexTokenExtractor(
+      undefined,
+      options.debug ? (msg) => debug(`[debug] ${msg}`) : undefined,
+    )
+
+    if (options.debug) {
+      debug('[debug] Searching browser profiles for Webex tokens...')
+    }
+
+    const extracted = await extractor.extract()
+
+    if (!extracted) {
+      console.log(
+        formatOutput(
+          {
+            error: 'No Webex token found in any browser. Make sure you are logged in to web.webex.com in Chrome, Edge, Arc, or Brave.',
+            hint: 'Run "auth login" for OAuth Device Grant flow, or --debug for more info.',
+          },
+          options.pretty,
+        ),
+      )
+      process.exit(1)
+      return
+    }
+
+    const client = await new WebexClient().login({ token: extracted.accessToken })
+    const person = await client.testAuth()
+
+    const credManager = new WebexCredentialManager()
+    await credManager.saveConfig({
+      accessToken: extracted.accessToken,
+      refreshToken: extracted.refreshToken ?? '',
+      expiresAt: extracted.expiresAt ?? 0,
+      tokenType: 'extracted',
+      deviceUrl: extracted.deviceUrl,
+    })
+
+    console.log(
+      formatOutput(
+        {
+          user: { id: person.id, displayName: person.displayName, emails: person.emails },
+          authenticated: true,
+          tokenType: 'extracted',
+        },
+        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('extract')
+      .description('Extract Webex token from browser (Chrome, Edge, Arc, Brave)')
+      .option('--pretty', 'Pretty print JSON output')
+      .option('--debug', 'Show debug output')
+      .action(extractAction),
+  )
+  .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,112 @@
+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>
+  let stderrOutput: string
+  let origStderrWrite: typeof process.stderr.write
+  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})`)
+    })
+    stderrOutput = ''
+    origStderrWrite = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
+      return true
+    }) as typeof process.stderr.write
+    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers)
+  })
+
+  afterEach(() => {
+    process.stderr.write = origStderrWrite
+    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(stderrOutput).toContain('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,
+        }),
+      ),
+  )

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

@@ -0,0 +1,235 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
+
+let clientSendMessageSpy: ReturnType<typeof spyOn>
+let clientSendDirectMessageSpy: ReturnType<typeof spyOn>
+let clientListMessagesSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientDeleteMessageSpy: ReturnType<typeof spyOn>
+let clientEditMessageSpy: ReturnType<typeof spyOn>
+let clientLoginSpy: ReturnType<typeof spyOn>
+const originalConsoleLog = console.log
+const originalConsoleError = console.error
+
+const mockMessage = {
+  id: 'msg_123',
+  roomId: 'space_456',
+  roomType: 'group' as const,
+  text: 'Hello world',
+  personId: 'person_789',
+  personEmail: 'user@example.com',
+  created: '2025-01-29T10:00:00.000Z',
+}
+
+const mockMessage2 = {
+  id: 'msg_124',
+  roomId: 'space_456',
+  roomType: 'group' as const,
+  text: 'Second message',
+  personId: 'person_789',
+  personEmail: 'user@example.com',
+  created: '2025-01-29T10:01:00.000Z',
+}
+
+beforeEach(() => {
+  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
+
+  clientSendMessageSpy = spyOn(WebexClient.prototype, 'sendMessage').mockResolvedValue(mockMessage)
+
+  clientSendDirectMessageSpy = spyOn(WebexClient.prototype, 'sendDirectMessage').mockResolvedValue(mockMessage)
+
+  clientListMessagesSpy = spyOn(WebexClient.prototype, 'listMessages').mockResolvedValue([
+    mockMessage,
+    mockMessage2,
+  ])
+
+  clientGetMessageSpy = spyOn(WebexClient.prototype, 'getMessage').mockResolvedValue(mockMessage)
+
+  clientDeleteMessageSpy = spyOn(WebexClient.prototype, 'deleteMessage').mockResolvedValue(
+    undefined,
+  )
+
+  clientEditMessageSpy = spyOn(WebexClient.prototype, 'editMessage').mockResolvedValue({
+    ...mockMessage,
+    text: 'Updated message',
+  })
+})
+
+afterEach(() => {
+  clientLoginSpy?.mockRestore()
+  clientSendMessageSpy?.mockRestore()
+  clientSendDirectMessageSpy?.mockRestore()
+  clientListMessagesSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  clientDeleteMessageSpy?.mockRestore()
+  clientEditMessageSpy?.mockRestore()
+  console.log = originalConsoleLog
+  console.error = originalConsoleError
+})
+
+test('send: calls sendMessage with correct args and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('space_456', 'Hello world', { pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', 'Hello world', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('space_456')
+  expect(output).toContain('user@example.com')
+})
+
+test('send: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('space_456', '**bold**', { markdown: true, pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('space_456', '**bold**', { markdown: true })
+})
+
+test('send: not authenticated shows error', async () => {
+  clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+
+  let stderrOutput = ''
+  const origWrite = process.stderr.write
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
+    return true
+  }) as typeof process.stderr.write
+
+  const originalExit = process.exit
+  process.exit = mock((_code?: number) => {
+    throw new Error('process.exit called')
+  }) as never
+
+  try {
+    await sendAction('space_456', 'Hello', { pretty: false })
+  } catch {
+  } finally {
+    process.exit = originalExit
+    process.stderr.write = origWrite
+  }
+
+  expect(stderrOutput).toContain('No Webex credentials found')
+})
+
+test('dm: calls sendDirectMessage with email and text', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await dmAction('alice@example.com', 'Hello!', { pretty: false })
+
+  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', 'Hello!', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('dm: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await dmAction('alice@example.com', '**bold**', { markdown: true, pretty: false })
+
+  expect(clientSendDirectMessageSpy).toHaveBeenCalledWith('alice@example.com', '**bold**', {
+    markdown: true,
+  })
+})
+
+test('list: calls listMessages with limit and outputs array', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('space_456', { limit: 50, pretty: false })
+
+  expect(clientListMessagesSpy).toHaveBeenCalledWith('space_456', { max: 50 })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('msg_124')
+})
+
+test('get: calls getMessage with correct id and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await getAction('msg_123', { pretty: false })
+
+  expect(clientGetMessageSpy).toHaveBeenCalledWith('msg_123')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('user@example.com')
+})
+
+test('delete: with --force calls deleteMessage and outputs deleted id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('msg_123', { force: true, pretty: false })
+
+  expect(clientDeleteMessageSpy).toHaveBeenCalledWith('msg_123')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('deleted')
+  expect(output).toContain('msg_123')
+})
+
+test('delete: without --force shows warning and does not delete', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  const originalExit = process.exit
+  process.exit = mock((_code?: number) => {
+    throw new Error('process.exit called')
+  }) as never
+
+  try {
+    await deleteAction('msg_123', { force: false, pretty: false })
+  } catch {
+  } finally {
+    process.exit = originalExit
+  }
+
+  expect(clientDeleteMessageSpy).not.toHaveBeenCalled()
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('warning')
+  expect(output).toContain('--force')
+})
+
+test('edit: calls editMessage with roomId in args and outputs result', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('msg_123', 'space_456', 'Updated message', { pretty: false })
+
+  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', 'Updated message', {
+    markdown: undefined,
+  })
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('Updated message')
+})
+
+test('edit: with --markdown passes markdown option', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('msg_123', 'space_456', '**updated**', { markdown: true, pretty: false })
+
+  expect(clientEditMessageSpy).toHaveBeenCalledWith('msg_123', 'space_456', '**updated**', {
+    markdown: true,
+  })
+})