agent-messenger 2.3.0 → 2.5.0

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

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
 import * as childProcess from 'node:child_process'
 
 import { WebexClient } from '../client'
@@ -7,7 +7,9 @@ import { loginAction, logoutAction, statusAction } from './auth'
 
 describe('auth commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
-  let _consoleErrorSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+  let execSpy: ReturnType<typeof spyOn>
+  const protoSpies: ReturnType<typeof spyOn>[] = []
   const mockPerson = {
     id: 'person-1',
     displayName: 'Test User',
@@ -17,21 +19,31 @@ describe('auth commands', () => {
     created: '2024-01-01T00:00:00.000Z',
   }
 
+  function protoSpy<T extends object>(target: T, method: keyof T) {
+    const s = spyOn(target, method as any)
+    protoSpies.push(s)
+    return s
+  }
+
   beforeEach(() => {
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
-    _consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    execSpy = spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
   })
 
   afterEach(() => {
-    mock.restore()
+    consoleSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+    execSpy.mockRestore()
+    for (const s of protoSpies) s.mockRestore()
+    protoSpies.length = 0
   })
 
   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)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
 
       await loginAction({ token: 'bot-token-123', pretty: false })
 
@@ -43,9 +55,9 @@ describe('auth commands', () => {
     })
 
     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)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
 
       await loginAction({ token: 'bot-token-123', pretty: false })
 
@@ -58,7 +70,7 @@ describe('auth commands', () => {
 
   describe('loginAction with --client-id and --client-secret', () => {
     test('uses provided credentials for Device Grant flow', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -66,14 +78,14 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(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)
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
@@ -82,7 +94,7 @@ describe('auth commands', () => {
     })
 
     test('saves tokenType as oauth in config', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -90,14 +102,14 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(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)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
@@ -106,7 +118,7 @@ describe('auth commands', () => {
     })
 
     test('saves clientId and clientSecret in config', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -114,18 +126,18 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(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)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(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 }
+      const savedConfig = saveSpy.mock.calls[0][0] as { clientId: string; clientSecret: string }
       expect(savedConfig.clientId).toBe('my-id')
       expect(savedConfig.clientSecret).toBe('my-secret')
     })
@@ -133,10 +145,10 @@ describe('auth commands', () => {
 
   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)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await statusAction({ pretty: false })
 
@@ -147,9 +159,9 @@ describe('auth commands', () => {
     })
 
     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)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue(null)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
 
       await statusAction({ pretty: false })
 
@@ -160,10 +172,10 @@ describe('auth commands', () => {
     })
 
     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'))
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('invalid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('401 Unauthorized'))
 
       await statusAction({ pretty: false })
 
@@ -173,16 +185,16 @@ describe('auth commands', () => {
     })
 
     test('loads config for stored client credentials', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+      protoSpy(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)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await statusAction({ pretty: false })
 
@@ -192,12 +204,12 @@ describe('auth commands', () => {
 
   describe('logoutAction', () => {
     test('clears credentials when authenticated', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
         accessToken: 'token',
         refreshToken: 'refresh',
         expiresAt: Date.now() + 3600000,
       })
-      const clearSpy = spyOn(WebexCredentialManager.prototype, 'clearCredentials').mockResolvedValue(undefined)
+      const clearSpy = protoSpy(WebexCredentialManager.prototype, 'clearCredentials').mockResolvedValue(undefined)
 
       await logoutAction({ pretty: false })
 
@@ -208,8 +220,8 @@ describe('auth commands', () => {
     })
 
     test('shows error when not authenticated', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
-      const exitSpy = spyOn(process, 'exit').mockImplementation(() => undefined as never)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
 
       await logoutAction({ pretty: false })
 

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

@@ -3,3 +3,4 @@ export { memberCommand } from './member'
 export { messageCommand } from './message'
 export { snapshotAction, snapshotCommand } from './snapshot'
 export { spaceCommand } from './space'
+export { whoamiCommand } from './whoami'

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

@@ -1,65 +1,70 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
-import { WebexClient } from '../client'
 import { WebexError } from '../types'
+
+const mockHandleError = mock((err: Error) => {
+  throw err
+})
+
+mock.module('@/shared/utils/error-handler', () => ({
+  handleError: mockHandleError,
+}))
+
+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',
+  },
+]
+
+const mockListMemberships = mock(() => Promise.resolve(mockMembers))
+const mockLogin = mock(() => Promise.resolve({ listMemberships: mockListMemberships }))
+
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
+
 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})`)
+    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
+    mockLogin.mockReset().mockImplementation(() =>
+      Promise.resolve({ listMemberships: mockListMemberships }),
+    )
+    mockHandleError.mockReset().mockImplementation((err: Error) => {
+      throw err
     })
-    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)
+
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
-    process.stderr.write = origStderrWrite
-    mock.restore()
+    consoleSpy.mockRestore()
   })
 
   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(mockListMemberships).toHaveBeenCalledWith('room-1', { max: undefined })
     expect(consoleSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
@@ -83,30 +88,28 @@ describe('member commands', () => {
   })
 
   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 })
+    expect(mockListMemberships).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'),
-    )
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   test('listAction handles API error', async () => {
-    spyOn(WebexClient.prototype, 'listMemberships').mockRejectedValue(new Error('API failure'))
+    mockListMemberships.mockImplementation(async () => {
+      throw new Error('API failure')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('API failure')
 
-    expect(processExitSpy).toHaveBeenCalledWith(1)
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
   })
 })