agent-messenger 2.18.0 → 2.19.1

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
-import * as clientModule from '../client'
+import { WebexClient } from '../client'
 import { WebexError } from '../types'
 import { whoamiCommand } from './whoami'
 
@@ -17,27 +17,23 @@ const mockUser = {
   created: '2024-01-01T00:00:00.000Z',
 }
 
-const makeFakeClient = () => ({
-  login: async function (this: unknown) {
-    return this
-  },
-  testAuth: async () => mockUser,
-})
-
-let webexClientSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let testAuthSpy: ReturnType<typeof spyOn>
 let consoleLogSpy: ReturnType<typeof spyOn>
 let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  webexClientSpy = spyOn(clientModule, 'WebexClient').mockImplementation(
-    makeFakeClient as unknown as typeof clientModule.WebexClient,
-  )
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockImplementation(async function (this: WebexClient) {
+    return this
+  })
+  testAuthSpy = spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockUser)
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
   processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
-  webexClientSpy?.mockRestore()
+  loginSpy?.mockRestore()
+  testAuthSpy?.mockRestore()
   consoleLogSpy?.mockRestore()
   processExitSpy?.mockRestore()
 })
@@ -102,15 +98,7 @@ it('whoami outputs pretty-printed JSON when --pretty flag is passed', async () =
 
 it('whoami exits with code 1 when not authenticated', async () => {
   // given: no credentials
-  webexClientSpy.mockImplementation(
-    () =>
-      ({
-        login: async () => {
-          throw new WebexError('No Webex credentials found.', 'no_credentials')
-        },
-        testAuth: async () => mockUser,
-      }) as unknown as clientModule.WebexClient,
-  )
+  loginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
   // when: running whoami
   await whoamiCommand.parseAsync([], { from: 'user' })

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

@@ -8,6 +8,7 @@ import { WebexCredentialManager } from './credential-manager'
 describe('WebexCredentialManager', () => {
   let tempDir: string
   let credManager: WebexCredentialManager
+  const realFetch = globalThis.fetch
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'webex-cred-test-'))
@@ -16,6 +17,8 @@ describe('WebexCredentialManager', () => {
 
   afterEach(async () => {
     await rm(tempDir, { recursive: true, force: true })
+    // Guarantee fetch restoration even if a test throws before its own restore line.
+    globalThis.fetch = realFetch
   })
 
   it('loadConfig returns null when no file exists', async () => {

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

@@ -2,12 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 
 const originalConsoleLog = console.log
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: (err: Error) => {
-    throw err
-  },
-}))
-
 const mockGetAccount = mock(() => Promise.resolve(null))
 const mockListAccounts = mock(() => Promise.resolve([]))
 const mockSetCurrent = mock(() => Promise.resolve(false))
@@ -46,6 +40,7 @@ import { authCommand } from './auth'
 
 describe('auth commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
   let processExitSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
@@ -73,14 +68,14 @@ describe('auth commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
-    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-      throw new Error(`process.exit(${_code})`)
-    })
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
     processExitSpy.mockClear()
   })
 
   afterEach(() => {
     console.log = originalConsoleLog
+    consoleErrorSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 
@@ -153,7 +148,7 @@ describe('auth commands', () => {
     it('outputs error and exits when account not found', async () => {
       mockSetCurrent.mockImplementation(() => Promise.resolve(false))
 
-      await expect(authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' })).rejects.toThrow('process.exit(1)')
+      await authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -185,7 +180,7 @@ describe('auth commands', () => {
     it('outputs error and exits when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(authCommand.parseAsync(['status'], { from: 'user' })).rejects.toThrow('process.exit(1)')
+      await authCommand.parseAsync(['status'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -217,9 +212,7 @@ describe('auth commands', () => {
     it('outputs error for specific missing account', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(authCommand.parseAsync(['status', '--account', 'missing-id'], { from: 'user' })).rejects.toThrow(
-        'process.exit(1)',
-      )
+      await authCommand.parseAsync(['status', '--account', 'missing-id'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -241,8 +234,9 @@ describe('auth commands', () => {
       )
       mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
 
-      await expect(authCommand.parseAsync(['logout'], { from: 'user' })).rejects.toThrow('process.exit(0)')
+      await authCommand.parseAsync(['logout'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockRemoveAccount).toHaveBeenCalledWith('plus-12025551234')
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.success).toBe(true)
@@ -253,7 +247,7 @@ describe('auth commands', () => {
     it('outputs error and exits when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(authCommand.parseAsync(['logout'], { from: 'user' })).rejects.toThrow('process.exit(1)')
+      await authCommand.parseAsync(['logout'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -273,8 +267,9 @@ describe('auth commands', () => {
       mockConnect.mockImplementation(() => Promise.reject(new Error('Connection failed')))
       mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
 
-      await expect(authCommand.parseAsync(['logout'], { from: 'user' })).rejects.toThrow('process.exit(0)')
+      await authCommand.parseAsync(['logout'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockRemoveAccount).toHaveBeenCalledWith('plus-12025551234')
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.success).toBe(true)
@@ -295,10 +290,9 @@ describe('auth commands', () => {
       })
       mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
 
-      await expect(
-        authCommand.parseAsync(['logout', '--account', 'plus-19995551234'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await authCommand.parseAsync(['logout', '--account', 'plus-19995551234'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockRemoveAccount).toHaveBeenCalledWith('plus-19995551234')
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.success).toBe(true)

package/src/platforms/whatsapp/commands/chat.test.ts

@@ -2,12 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 
 const originalConsoleLog = console.log
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: (err: Error) => {
-    throw err
-  },
-}))
-
 const mockGetAccount = mock(() =>
   Promise.resolve({
     account_id: 'plus-12025551234',
@@ -69,6 +63,7 @@ import { chatCommand } from './chat'
 
 describe('chat commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
   let processExitSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
@@ -118,21 +113,22 @@ describe('chat commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
-    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-      throw new Error(`process.exit(${_code})`)
-    })
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
     processExitSpy.mockClear()
   })
 
   afterEach(() => {
     console.log = originalConsoleLog
+    consoleErrorSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 
   describe('list', () => {
     it('lists chats with default limit', async () => {
-      await expect(chatCommand.parseAsync(['list'], { from: 'user' })).rejects.toThrow('process.exit(0)')
+      await chatCommand.parseAsync(['list'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockListChats).toHaveBeenCalledWith(20)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output).toHaveLength(1)
@@ -141,25 +137,23 @@ describe('chat commands', () => {
     })
 
     it('respects --limit option', async () => {
-      await expect(chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' })).rejects.toThrow(
-        'process.exit(0)',
-      )
+      await chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockListChats).toHaveBeenCalledWith(5)
     })
 
     it('passes account option to credential manager', async () => {
-      await expect(chatCommand.parseAsync(['list', '--account', 'my-account'], { from: 'user' })).rejects.toThrow(
-        'process.exit(0)',
-      )
+      await chatCommand.parseAsync(['list', '--account', 'my-account'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetAccount).toHaveBeenCalledWith('my-account')
     })
 
     it('exits with error when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(chatCommand.parseAsync(['list'], { from: 'user' })).rejects.toThrow('process.exit(1)')
+      await chatCommand.parseAsync(['list'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
     })
@@ -167,8 +161,9 @@ describe('chat commands', () => {
 
   describe('search', () => {
     it('searches chats by query', async () => {
-      await expect(chatCommand.parseAsync(['search', 'Bob'], { from: 'user' })).rejects.toThrow('process.exit(0)')
+      await chatCommand.parseAsync(['search', 'Bob'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockSearchChats).toHaveBeenCalledWith('Bob', 20)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output).toHaveLength(1)
@@ -177,18 +172,16 @@ describe('chat commands', () => {
     })
 
     it('respects --limit option', async () => {
-      await expect(chatCommand.parseAsync(['search', 'Alice', '--limit', '3'], { from: 'user' })).rejects.toThrow(
-        'process.exit(0)',
-      )
+      await chatCommand.parseAsync(['search', 'Alice', '--limit', '3'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockSearchChats).toHaveBeenCalledWith('Alice', 3)
     })
 
     it('passes account option to credential manager', async () => {
-      await expect(
-        chatCommand.parseAsync(['search', 'test', '--account', 'my-account'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await chatCommand.parseAsync(['search', 'test', '--account', 'my-account'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetAccount).toHaveBeenCalledWith('my-account')
     })
   })

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

@@ -2,12 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 
 const originalConsoleLog = console.log
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: (err: Error) => {
-    throw err
-  },
-}))
-
 const mockGetAccount = mock(() =>
   Promise.resolve({
     account_id: 'plus-12025551234',
@@ -69,6 +63,7 @@ import { messageCommand } from './message'
 
 describe('message commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
   let processExitSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
@@ -118,23 +113,22 @@ describe('message commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
-    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-      throw new Error(`process.exit(${_code})`)
-    })
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
     processExitSpy.mockClear()
   })
 
   afterEach(() => {
     console.log = originalConsoleLog
+    consoleErrorSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 
   describe('list', () => {
     it('fetches messages for a chat', async () => {
-      await expect(messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' })).rejects.toThrow(
-        'process.exit(0)',
-      )
+      await messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetMessages).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 25)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output).toHaveLength(1)
@@ -143,27 +137,25 @@ describe('message commands', () => {
     })
 
     it('respects --limit option', async () => {
-      await expect(
-        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--limit', '10'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--limit', '10'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetMessages).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 10)
     })
 
     it('passes account option to credential manager', async () => {
-      await expect(
-        messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--account', 'my-account'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net', '--account', 'my-account'], {
+        from: 'user',
+      })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetAccount).toHaveBeenCalledWith('my-account')
     })
 
     it('exits with error when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' })).rejects.toThrow(
-        'process.exit(1)',
-      )
+      await messageCommand.parseAsync(['list', '12025551234@s.whatsapp.net'], { from: 'user' })
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
     })
@@ -171,10 +163,9 @@ describe('message commands', () => {
 
   describe('send', () => {
     it('sends a message to a chat', async () => {
-      await expect(
-        messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hello world'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hello world'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockSendMessage).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'Hello world')
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.id).toBe('msg-2')
@@ -182,22 +173,20 @@ describe('message commands', () => {
     })
 
     it('passes account option to credential manager', async () => {
-      await expect(
-        messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hi', '--account', 'my-account'], {
-          from: 'user',
-        }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['send', '12025551234@s.whatsapp.net', 'Hi', '--account', 'my-account'], {
+        from: 'user',
+      })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetAccount).toHaveBeenCalledWith('my-account')
     })
   })
 
   describe('react', () => {
     it('sends a reaction to a message', async () => {
-      await expect(
-        messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'], { from: 'user' }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'], { from: 'user' })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockSendReaction).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-1', '👍', undefined)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.success).toBe(true)
@@ -207,22 +196,23 @@ describe('message commands', () => {
     })
 
     it('passes --from-me flag to sendReaction', async () => {
-      await expect(
-        messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '❤️', '--from-me'], {
-          from: 'user',
-        }),
-      ).rejects.toThrow('process.exit(0)')
+      await messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '❤️', '--from-me'], {
+        from: 'user',
+      })
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockSendReaction).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-1', '❤️', true)
     })
 
     it('passes account option to credential manager', async () => {
-      await expect(
-        messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '👍', '--account', 'my-account'], {
+      await messageCommand.parseAsync(
+        ['react', '12025551234@s.whatsapp.net', 'msg-1', '👍', '--account', 'my-account'],
+        {
           from: 'user',
-        }),
-      ).rejects.toThrow('process.exit(0)')
+        },
+      )
 
+      expect(processExitSpy).toHaveBeenCalledWith(0)
       expect(mockGetAccount).toHaveBeenCalledWith('my-account')
     })
   })

package/src/shared/chromium/browsers.ts

@@ -75,7 +75,7 @@ export function discoverBrowserProfileDirs(browserBase: string): string[] {
   dirs.push(join(browserBase, 'Default'))
   if (!existsSync(browserBase)) return dirs
   try {
-    const entries = readdirSync(browserBase, { withFileTypes: true })
+    const entries = readdirSync(browserBase, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
     for (const entry of entries) {
       if (!entry.isDirectory()) continue
       if (!/^Profile \d+$/i.test(entry.name)) continue

package/src/test-setup.ts

@@ -0,0 +1,5 @@
+import { afterEach, mock } from 'bun:test'
+
+afterEach(() => {
+  mock.restore()
+})

package/tsconfig.json

@@ -38,5 +38,5 @@
     "noFallthroughCasesInSwitch": true
   },
   "include": ["src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*-test.ts"]
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*-test.ts", "src/test-setup.ts"]
 }