agent-messenger 2.0.0 → 2.1.0

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

@@ -0,0 +1,206 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
+import { infoAction, listAction } from './space'
+
+const mockSpaces = [
+  {
+    id: 'space-1',
+    title: 'General',
+    type: 'group' as const,
+    isLocked: false,
+    lastActivity: '2024-01-02T00:00:00.000Z',
+    created: '2024-01-01T00:00:00.000Z',
+    creatorId: 'person-1',
+  },
+  {
+    id: 'space-2',
+    title: 'Direct with Alice',
+    type: 'direct' as const,
+    isLocked: false,
+    lastActivity: '2024-01-03T00:00:00.000Z',
+    created: '2024-01-01T00:00:00.000Z',
+    creatorId: 'person-2',
+  },
+]
+
+const mockSpace = {
+  id: 'space-1',
+  title: 'General',
+  type: 'group' as const,
+  isLocked: false,
+  teamId: 'team-abc',
+  lastActivity: '2024-01-02T00:00:00.000Z',
+  created: '2024-01-01T00:00:00.000Z',
+  creatorId: 'person-1',
+}
+
+let clientLoginSpy: ReturnType<typeof spyOn>
+let clientListSpacesSpy: ReturnType<typeof spyOn>
+let clientGetSpaceSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let consoleErrorSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientLoginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+    new WebexClient() as InstanceType<typeof WebexClient>,
+  )
+
+  clientListSpacesSpy = spyOn(WebexClient.prototype, 'listSpaces').mockResolvedValue(mockSpaces)
+
+  clientGetSpaceSpy = spyOn(WebexClient.prototype, 'getSpace').mockResolvedValue(mockSpace)
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+    throw new Error(`process.exit(${_code})`)
+  })
+})
+
+afterEach(() => {
+  clientLoginSpy?.mockRestore()
+  clientListSpacesSpy?.mockRestore()
+  clientGetSpaceSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  consoleErrorSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+describe('listAction', () => {
+  test('calls listSpaces and outputs mapped array', async () => {
+    await listAction({})
+
+    expect(clientListSpacesSpy).toHaveBeenCalled()
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify([
+        {
+          id: 'space-1',
+          title: 'General',
+          type: 'group',
+          lastActivity: '2024-01-02T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+        },
+        {
+          id: 'space-2',
+          title: 'Direct with Alice',
+          type: 'direct',
+          lastActivity: '2024-01-03T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+        },
+      ]),
+    )
+  })
+
+  test('passes type and limit options to listSpaces', async () => {
+    await listAction({ type: 'group', limit: 10 })
+
+    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: 'group', max: 10 })
+  })
+
+  test('passes undefined type and limit when not provided', async () => {
+    await listAction({})
+
+    expect(clientListSpacesSpy).toHaveBeenCalledWith({ type: undefined, max: undefined })
+  })
+
+  test('outputs pretty-printed JSON when pretty is true', async () => {
+    await listAction({ pretty: true })
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        [
+          {
+            id: 'space-1',
+            title: 'General',
+            type: 'group',
+            lastActivity: '2024-01-02T00:00:00.000Z',
+            created: '2024-01-01T00:00:00.000Z',
+          },
+          {
+            id: 'space-2',
+            title: 'Direct with Alice',
+            type: 'direct',
+            lastActivity: '2024-01-03T00:00:00.000Z',
+            created: '2024-01-01T00:00:00.000Z',
+          },
+        ],
+        null,
+        2,
+      ),
+    )
+  })
+
+  test('not authenticated: outputs error and exits', async () => {
+    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+
+    await expect(listAction({})).rejects.toThrow('process.exit(1)')
+
+    expect(clientListSpacesSpy).not.toHaveBeenCalled()
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No Webex credentials found'))
+  })
+})
+
+describe('infoAction', () => {
+  test('calls getSpace with spaceId and outputs space details', async () => {
+    await infoAction('space-1', {})
+
+    expect(clientGetSpaceSpy).toHaveBeenCalledWith('space-1')
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify({
+        id: 'space-1',
+        title: 'General',
+        type: 'group',
+        isLocked: false,
+        teamId: 'team-abc',
+        lastActivity: '2024-01-02T00:00:00.000Z',
+        created: '2024-01-01T00:00:00.000Z',
+        creatorId: 'person-1',
+      }),
+    )
+  })
+
+  test('outputs null for teamId when not present', async () => {
+    const spaceWithoutTeam = { ...mockSpace, teamId: undefined }
+    clientGetSpaceSpy.mockResolvedValue(spaceWithoutTeam)
+
+    await infoAction('space-1', {})
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string) as {
+      teamId: null
+    }
+    expect(output.teamId).toBeNull()
+  })
+
+  test('outputs pretty-printed JSON when pretty is true', async () => {
+    await infoAction('space-1', { pretty: true })
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          id: 'space-1',
+          title: 'General',
+          type: 'group',
+          isLocked: false,
+          teamId: 'team-abc',
+          lastActivity: '2024-01-02T00:00:00.000Z',
+          created: '2024-01-01T00:00:00.000Z',
+          creatorId: 'person-1',
+        },
+        null,
+        2,
+      ),
+    )
+  })
+
+  test('not authenticated: outputs error and exits', async () => {
+    clientLoginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
+
+    await expect(infoAction('space-1', {})).rejects.toThrow('process.exit(1)')
+
+    expect(clientGetSpaceSpy).not.toHaveBeenCalled()
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No Webex credentials found'))
+  })
+})

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

@@ -0,0 +1,74 @@
+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(options: {
+  type?: string
+  limit?: number
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const spaces = await client.listSpaces({ type: options.type, max: options.limit })
+    const output = spaces.map((s) => ({
+      id: s.id,
+      title: s.title,
+      type: s.type,
+      lastActivity: s.lastActivity,
+      created: s.created,
+    }))
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(
+  spaceId: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const space = await client.getSpace(spaceId)
+    const output = {
+      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,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const spaceCommand = new Command('space')
+  .description('Space commands')
+  .addCommand(
+    new Command('list')
+      .description('List spaces')
+      .option('--type <type>', 'Filter by type (group or direct)')
+      .option('--limit <n>', 'Number of spaces to retrieve', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((options) =>
+        listAction({
+          type: options.type,
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        }),
+      ),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get space details')
+      .argument('<space-id>', 'Space ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction),
+  )

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

@@ -0,0 +1,314 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { WebexCredentialManager } from './credential-manager'
+
+describe('WebexCredentialManager', () => {
+  let tempDir: string
+  let credManager: WebexCredentialManager
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'webex-cred-test-'))
+    credManager = new WebexCredentialManager(tempDir)
+  })
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true })
+    mock.restore()
+  })
+
+  test('loadConfig returns null when no file exists', async () => {
+    expect(await credManager.loadConfig()).toBeNull()
+  })
+
+  test('saveConfig + loadConfig round trip with OAuth tokens', async () => {
+    const config = {
+      accessToken: 'test-access-token',
+      refreshToken: 'test-refresh-token',
+      expiresAt: Date.now() + 3600000,
+    }
+    await credManager.saveConfig(config)
+    const loaded = await credManager.loadConfig()
+    expect(loaded).toEqual(config)
+  })
+
+  test('getToken returns accessToken when not expired', async () => {
+    await credManager.saveConfig({
+      accessToken: 'valid-token',
+      refreshToken: 'refresh',
+      expiresAt: Date.now() + 3600000, // 1 hour from now
+    })
+    const token = await credManager.getToken()
+    expect(token).toBe('valid-token')
+  })
+
+  test('getToken returns null when expired and no refresh available', async () => {
+    await credManager.saveConfig({
+      accessToken: 'expired-token',
+      refreshToken: 'bad-refresh',
+      expiresAt: Date.now() - 1000, // Already expired
+    })
+    const token = await credManager.getToken()
+    expect(token).toBeNull()
+  })
+
+  test('getToken auto-refreshes expired token', async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: 'new-access-token',
+            refresh_token: 'new-refresh-token',
+            expires_in: 3600,
+          }),
+          { status: 200 },
+        ),
+      ),
+    ) as typeof fetch
+
+    await credManager.saveConfig({
+      accessToken: 'expired-token',
+      refreshToken: 'valid-refresh',
+      expiresAt: Date.now() - 1000,
+      clientId: 'test-client-id',
+      clientSecret: 'test-client-secret',
+    })
+
+    const token = await credManager.getToken()
+    expect(token).toBe('new-access-token')
+
+    // Verify updated config was saved
+    const config = await credManager.loadConfig()
+    expect(config?.accessToken).toBe('new-access-token')
+    expect(config?.refreshToken).toBe('new-refresh-token')
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('requestDeviceCode calls device authorize endpoint', async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            device_code: 'device-123',
+            user_code: '123456',
+            verification_uri: 'https://login-k.webex.com/verify',
+            verification_uri_complete: 'https://login-k.webex.com/verify?userCode=abc',
+            expires_in: 300,
+            interval: 2,
+          }),
+          { status: 200 },
+        ),
+      ),
+    ) as typeof fetch
+
+    const result = await credManager.requestDeviceCode('test-client-id')
+    expect(result.deviceCode).toBe('device-123')
+    expect(result.userCode).toBe('123456')
+    expect(result.verificationUri).toBe('https://login-k.webex.com/verify')
+    expect(result.interval).toBe(2)
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('requestDeviceCode throws on failure', async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('{"error":"invalid_client"}', { status: 400 })),
+    ) as typeof fetch
+
+    await expect(credManager.requestDeviceCode('test-client-id')).rejects.toThrow('Device authorization failed')
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('pollDeviceToken polls until authorized', async () => {
+    const originalFetch = globalThis.fetch
+    let callCount = 0
+    globalThis.fetch = mock(() => {
+      callCount++
+      if (callCount <= 2) {
+        return Promise.resolve(new Response('', { status: 428 }))
+      }
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: 'device-access-token',
+            refresh_token: 'device-refresh-token',
+            expires_in: 3600,
+          }),
+          { status: 200 },
+        ),
+      )
+    }) as typeof fetch
+
+    const config = await credManager.pollDeviceToken('device-123', 0.01, 30, 'test-client-id', 'test-client-secret')
+    expect(config.accessToken).toBe('device-access-token')
+    expect(config.refreshToken).toBe('device-refresh-token')
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('clearCredentials removes the file', async () => {
+    await credManager.saveConfig({
+      accessToken: 'token',
+      refreshToken: 'refresh',
+      expiresAt: Date.now() + 3600000,
+    })
+    await credManager.clearCredentials()
+    expect(await credManager.loadConfig()).toBeNull()
+  })
+
+  test('clearCredentials does nothing when no file', async () => {
+    await credManager.clearCredentials() // Should not throw
+  })
+
+  test('credentials file has 0o600 permissions', async () => {
+    await credManager.saveConfig({
+      accessToken: 'token',
+      refreshToken: 'refresh',
+      expiresAt: Date.now() + 3600000,
+    })
+    const { stat } = await import('node:fs/promises')
+    const credPath = join(tempDir, 'webex-credentials.json')
+    const stats = await stat(credPath)
+    const mode = stats.mode & 0o777
+    expect(mode).toBe(0o600)
+  })
+
+  test('pollDeviceToken with undefined clientSecret uses empty Basic auth', async () => {
+    const originalFetch = globalThis.fetch
+    let capturedAuth: string | null = null
+    globalThis.fetch = mock((url: string, init?: RequestInit) => {
+      capturedAuth = (init?.headers as Record<string, string>)?.Authorization ?? null
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: 'token',
+            refresh_token: 'refresh',
+            expires_in: 3600,
+          }),
+          { status: 200 },
+        ),
+      )
+    }) as typeof fetch
+
+    await credManager.pollDeviceToken('device-123', 0.01, 30, 'test-client-id')
+    expect(capturedAuth).toBe(`Basic ${btoa('test-client-id:')}`)
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('pollDeviceToken does not auto-save config', async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: 'token',
+            refresh_token: 'refresh',
+            expires_in: 3600,
+          }),
+          { status: 200 },
+        ),
+      ),
+    ) as typeof fetch
+
+    await credManager.pollDeviceToken('device-123', 0.01, 30, 'test-client-id', 'test-client-secret')
+
+    const loaded = await credManager.loadConfig()
+    expect(loaded).toBeNull()
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('getToken returns null when expired and no client credentials available', async () => {
+    await credManager.saveConfig({
+      accessToken: 'expired-token',
+      refreshToken: 'valid-refresh',
+      expiresAt: Date.now() - 1000,
+    })
+
+    const token = await credManager.getToken()
+    expect(token).toBeNull()
+  })
+
+  test('getToken returns manual token without attempting refresh', async () => {
+    await credManager.saveConfig({
+      accessToken: 'my-bot-token',
+      refreshToken: '',
+      expiresAt: 0,
+      tokenType: 'manual',
+    })
+
+    const token = await credManager.getToken()
+    expect(token).toBe('my-bot-token')
+  })
+
+  test('getToken uses stored clientId/clientSecret for refresh', async () => {
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: 'refreshed-token',
+            refresh_token: 'new-refresh',
+            expires_in: 3600,
+          }),
+          { status: 200 },
+        ),
+      ),
+    ) as typeof fetch
+
+    await credManager.saveConfig({
+      accessToken: 'expired-token',
+      refreshToken: 'valid-refresh',
+      expiresAt: Date.now() - 1000,
+      clientId: 'stored-client-id',
+      clientSecret: 'stored-client-secret',
+    })
+
+    const token = await credManager.getToken()
+    expect(token).toBe('refreshed-token')
+
+    globalThis.fetch = originalFetch
+  })
+
+  test('saveConfig persists clientId and clientSecret', async () => {
+    await credManager.saveConfig({
+      accessToken: 'token',
+      refreshToken: 'refresh',
+      expiresAt: Date.now() + 3600000,
+      clientId: 'my-client-id',
+      clientSecret: 'my-client-secret',
+    })
+
+    const loaded = await credManager.loadConfig()
+    expect(loaded?.clientId).toBe('my-client-id')
+    expect(loaded?.clientSecret).toBe('my-client-secret')
+  })
+
+  test('loadConfig backward compat — old config without clientId/clientSecret', async () => {
+    // Write raw JSON without clientId/clientSecret fields
+    const credPath = join(tempDir, 'webex-credentials.json')
+    await writeFile(
+      credPath,
+      JSON.stringify({
+        accessToken: 'old-token',
+        refreshToken: 'old-refresh',
+        expiresAt: Date.now() + 3600000,
+      }),
+      'utf-8',
+    )
+
+    const loaded = await credManager.loadConfig()
+    expect(loaded).not.toBeNull()
+    expect(loaded?.accessToken).toBe('old-token')
+    expect(loaded?.clientId).toBeUndefined()
+    expect(loaded?.clientSecret).toBeUndefined()
+  })
+})