agent-messenger 2.19.0 → 2.19.1

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

@@ -17,6 +17,7 @@ describe('auth commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
   let consoleErrorSpy: ReturnType<typeof spyOn>
   let execSpy: ReturnType<typeof spyOn>
+  let stderrWriteSpy: ReturnType<typeof spyOn>
   const protoSpies: ReturnType<typeof spyOn>[] = []
   let originalStdinTTY: boolean | undefined
   let originalStdoutTTY: boolean | undefined
@@ -44,16 +45,23 @@ describe('auth commands', () => {
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
     consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
     execSpy = spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
+    stderrWriteSpy = spyOn(process.stderr, 'write').mockImplementation(() => true)
     originalStdinTTY = process.stdin.isTTY
     originalStdoutTTY = process.stdout.isTTY
     // Default to interactive TTY for existing tests; non-interactive tests override.
     setTTY(true)
+    // Fail loudly instead of running the real 300s network polling loop; tests that
+    // exercise the Device Grant flow override this with a resolved value.
+    protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken').mockImplementation(() => {
+      throw new Error('Unexpected real device polling in test')
+    })
   })
 
   afterEach(() => {
     consoleSpy.mockRestore()
     consoleErrorSpy.mockRestore()
     execSpy.mockRestore()
+    stderrWriteSpy.mockRestore()
     for (const s of protoSpies) s.mockRestore()
     protoSpies.length = 0
     setTTY(originalStdinTTY)
@@ -447,7 +455,6 @@ describe('auth commands', () => {
       protoSpy(WebexCredentialManager.prototype, 'refreshToken').mockResolvedValue(null)
       protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
       protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('Network error'))
-      const stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
       const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
         throw new ProcessExit(code)
       })
@@ -467,7 +474,6 @@ describe('auth commands', () => {
       })
       protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
       protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('Network error'))
-      const stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
       const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
         throw new ProcessExit(code)
       })

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

@@ -1,6 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
-
-import * as errorHandler from '@/shared/utils/error-handler'
+import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
 import { WebexError } from '../types'
@@ -26,31 +24,39 @@ const mockMembers = [
   },
 ]
 
-const mockListMemberships = mock(() => Promise.resolve(mockMembers))
-
 import { listAction } from './member'
 
 describe('member commands', () => {
+  let mockListMemberships: ReturnType<typeof spyOn>
+  let mockLogin: ReturnType<typeof spyOn>
   let consoleSpy: ReturnType<typeof spyOn>
-  let loginSpy: ReturnType<typeof spyOn>
-  let handleErrorSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+  const protoSpies: ReturnType<typeof spyOn>[] = []
+
+  function protoSpy(method: keyof WebexClient) {
+    const s = spyOn(WebexClient.prototype, method as never)
+    protoSpies.push(s)
+    return s
+  }
 
   beforeEach(() => {
-    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
-    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
-      throw err
+    mockLogin = protoSpy('login').mockImplementation(async function (this: WebexClient) {
+      return this
     })
+    mockListMemberships = protoSpy('listMemberships').mockResolvedValue(mockMembers)
 
-    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
-      Object.assign(new WebexClient(), { listMemberships: mockListMemberships }),
-    )
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
   })
 
   afterEach(() => {
-    loginSpy.mockRestore()
-    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+    processExitSpy.mockRestore()
+    for (const s of protoSpies) s.mockRestore()
+    protoSpies.length = 0
   })
 
   it('calls listMemberships with spaceId and outputs mapped members', async () => {
@@ -85,23 +91,19 @@ describe('member commands', () => {
     expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: 25 })
   })
 
-  it('throws when not authenticated', async () => {
-    loginSpy.mockImplementation(async () => {
-      throw new WebexError('No Webex credentials found.', 'no_credentials')
-    })
+  it('exits with code 1 when not authenticated', async () => {
+    mockLogin.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
-    await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
+    await listAction('room-1', {})
 
-    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 
-  it('throws on API error', async () => {
-    mockListMemberships.mockImplementation(async () => {
-      throw new Error('API failure')
-    })
+  it('exits with code 1 on API error', async () => {
+    mockListMemberships.mockRejectedValue(new Error('API failure'))
 
-    await expect(listAction('room-1', {})).rejects.toThrow('API failure')
+    await listAction('room-1', {})
 
-    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(Error))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })

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

@@ -1,6 +1,4 @@
-import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
-
-import * as errorHandler from '@/shared/utils/error-handler'
+import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
 import { WebexError } from '../types'
@@ -25,47 +23,48 @@ const mockMessage2 = {
   created: '2025-01-29T10:01:00.000Z',
 }
 
-const mockSendMessage = mock(() => Promise.resolve(mockMessage))
-const mockSendDirectMessage = mock(() => Promise.resolve(mockMessage))
-const mockListMessages = mock(() => Promise.resolve([mockMessage, mockMessage2]))
-const mockGetMessage = mock(() => Promise.resolve(mockMessage))
-const mockDeleteMessage = mock(() => Promise.resolve(undefined))
-const mockEditMessage = mock(() => Promise.resolve({ ...mockMessage, text: 'Updated message' }))
-
-const mockClient = {
-  sendMessage: mockSendMessage,
-  sendDirectMessage: mockSendDirectMessage,
-  listMessages: mockListMessages,
-  getMessage: mockGetMessage,
-  deleteMessage: mockDeleteMessage,
-  editMessage: mockEditMessage,
-}
-
 import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
+let mockSendMessage: ReturnType<typeof spyOn>
+let mockSendDirectMessage: ReturnType<typeof spyOn>
+let mockListMessages: ReturnType<typeof spyOn>
+let mockGetMessage: ReturnType<typeof spyOn>
+let mockDeleteMessage: ReturnType<typeof spyOn>
+let mockEditMessage: ReturnType<typeof spyOn>
+let mockLogin: ReturnType<typeof spyOn>
 let consoleLogSpy: ReturnType<typeof spyOn>
-let loginSpy: ReturnType<typeof spyOn>
-let handleErrorSpy: ReturnType<typeof spyOn>
+let consoleErrorSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+const protoSpies: ReturnType<typeof spyOn>[] = []
+
+function protoSpy(method: keyof WebexClient) {
+  const s = spyOn(WebexClient.prototype, method as never)
+  protoSpies.push(s)
+  return s
+}
 
 beforeEach(() => {
-  mockSendMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
-  mockSendDirectMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
-  mockListMessages.mockReset().mockImplementation(() => Promise.resolve([mockMessage, mockMessage2]))
-  mockGetMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
-  mockDeleteMessage.mockReset().mockImplementation(() => Promise.resolve(undefined))
-  mockEditMessage.mockReset().mockImplementation(() => Promise.resolve({ ...mockMessage, text: 'Updated message' }))
-  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
-    throw err
+  mockLogin = protoSpy('login').mockImplementation(async function (this: WebexClient) {
+    return this
   })
+  mockSendMessage = protoSpy('sendMessage').mockResolvedValue(mockMessage)
+  mockSendDirectMessage = protoSpy('sendDirectMessage').mockResolvedValue(mockMessage)
+  mockListMessages = protoSpy('listMessages').mockResolvedValue([mockMessage, mockMessage2])
+  mockGetMessage = protoSpy('getMessage').mockResolvedValue(mockMessage)
+  mockDeleteMessage = protoSpy('deleteMessage').mockResolvedValue(undefined)
+  mockEditMessage = protoSpy('editMessage').mockResolvedValue({ ...mockMessage, text: 'Updated message' })
 
-  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
-  loginSpy.mockRestore()
-  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
+  consoleErrorSpy.mockRestore()
+  processExitSpy.mockRestore()
+  for (const s of protoSpies) s.mockRestore()
+  protoSpies.length = 0
 })
 
 it('calls sendMessage with correct args and outputs result', async () => {
@@ -87,14 +86,13 @@ it('passes markdown option when --markdown flag is set on send', async () => {
   expect(mockSendMessage).toHaveBeenCalledWith('space_456', '**bold**', { markdown: true })
 })
 
-it('throws when not authenticated on send', async () => {
-  loginSpy.mockImplementation(async () => {
-    throw new WebexError('No Webex credentials found.', 'no_credentials')
-  })
+it('exits with code 1 when not authenticated on send', async () => {
+  mockLogin.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
-  await expect(sendAction('space_456', 'Hello', { pretty: false })).rejects.toThrow('No Webex credentials found.')
+  await sendAction('space_456', 'Hello', { pretty: false })
 
-  expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
+  expect(mockSendMessage).not.toHaveBeenCalled()
+  expect(processExitSpy).toHaveBeenCalledWith(1)
 })
 
 it('calls sendDirectMessage with email and text', async () => {

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

@@ -1,6 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
-
-import * as errorHandler from '@/shared/utils/error-handler'
+import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
 import { WebexError } from '../types'
@@ -38,36 +36,39 @@ const mockMyMemberships = [
   },
 ]
 
-const mockListSpaces = mock(() => Promise.resolve(mockSpaces as any))
-const mockListMyMemberships = mock(() => Promise.resolve(mockMyMemberships as any))
-
-const mockClient = {
-  listSpaces: mockListSpaces,
-  listMyMemberships: mockListMyMemberships,
-}
-
 import { snapshotAction } from './snapshot'
 
 describe('snapshot command', () => {
+  let mockLogin: ReturnType<typeof spyOn>
   let consoleSpy: ReturnType<typeof spyOn>
-  let loginSpy: ReturnType<typeof spyOn>
-  let handleErrorSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+  const protoSpies: ReturnType<typeof spyOn>[] = []
+
+  function protoSpy(method: keyof WebexClient) {
+    const s = spyOn(WebexClient.prototype, method as never)
+    protoSpies.push(s)
+    return s
+  }
 
   beforeEach(() => {
-    mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces as any))
-    mockListMyMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMyMemberships as any))
-    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
-      throw err
+    mockLogin = protoSpy('login').mockImplementation(async function (this: WebexClient) {
+      return this
     })
+    protoSpy('listSpaces').mockResolvedValue(mockSpaces as any)
+    protoSpy('listMyMemberships').mockResolvedValue(mockMyMemberships as any)
 
-    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
   })
 
   afterEach(() => {
-    loginSpy.mockRestore()
-    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+    processExitSpy.mockRestore()
+    for (const s of protoSpies) s.mockRestore()
+    protoSpies.length = 0
   })
 
   it('returns spaces with id and title only in brief mode', async () => {
@@ -103,13 +104,11 @@ describe('snapshot command', () => {
     expect(output.spaces[0].id).toBe('space-1')
   })
 
-  it('throws when not authenticated', async () => {
-    loginSpy.mockImplementation(async () => {
-      throw new WebexError('No Webex credentials found.', 'no_credentials')
-    })
+  it('exits with code 1 when not authenticated', async () => {
+    mockLogin.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
-    await expect(snapshotAction({})).rejects.toThrow('No Webex credentials found.')
+    await snapshotAction({})
 
-    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })

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

@@ -1,6 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
-
-import * as errorHandler from '@/shared/utils/error-handler'
+import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test'
 
 import { WebexClient } from '../client'
 import { WebexError } from '../types'
@@ -37,32 +35,40 @@ const mockSpace = {
   creatorId: 'person-1',
 }
 
-const mockListSpaces = mock(() => Promise.resolve(mockSpaces))
-const mockGetSpace = mock(() => Promise.resolve(mockSpace))
-
 import { infoAction, listAction } from './space'
 
+let mockListSpaces: ReturnType<typeof spyOn>
+let mockGetSpace: ReturnType<typeof spyOn>
+let mockLogin: ReturnType<typeof spyOn>
 let consoleLogSpy: ReturnType<typeof spyOn>
-let loginSpy: ReturnType<typeof spyOn>
-let handleErrorSpy: ReturnType<typeof spyOn>
+let consoleErrorSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+const protoSpies: ReturnType<typeof spyOn>[] = []
+
+function protoSpy(method: keyof WebexClient) {
+  const s = spyOn(WebexClient.prototype, method as never)
+  protoSpies.push(s)
+  return s
+}
 
 beforeEach(() => {
-  mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces))
-  mockGetSpace.mockReset().mockImplementation(() => Promise.resolve(mockSpace))
-  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
-    throw err
+  mockLogin = protoSpy('login').mockImplementation(async function (this: WebexClient) {
+    return this
   })
+  mockListSpaces = protoSpy('listSpaces').mockResolvedValue(mockSpaces)
+  mockGetSpace = protoSpy('getSpace').mockResolvedValue(mockSpace)
 
-  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
-    Object.assign(new WebexClient(), { listSpaces: mockListSpaces, getSpace: mockGetSpace }),
-  )
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
-  loginSpy.mockRestore()
-  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
+  consoleErrorSpy.mockRestore()
+  processExitSpy.mockRestore()
+  for (const s of protoSpies) s.mockRestore()
+  protoSpies.length = 0
 })
 
 describe('listAction', () => {
@@ -129,15 +135,13 @@ describe('listAction', () => {
     )
   })
 
-  it('throws when not authenticated', async () => {
-    loginSpy.mockImplementation(async () => {
-      throw new WebexError('No Webex credentials found.', 'no_credentials')
-    })
+  it('exits with code 1 when not authenticated', async () => {
+    mockLogin.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
-    await expect(listAction({})).rejects.toThrow('No Webex credentials found.')
+    await listAction({})
 
     expect(mockListSpaces).not.toHaveBeenCalled()
-    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })
 
@@ -192,14 +196,12 @@ describe('infoAction', () => {
     )
   })
 
-  it('throws when not authenticated', async () => {
-    loginSpy.mockImplementation(async () => {
-      throw new WebexError('No Webex credentials found.', 'no_credentials')
-    })
+  it('exits with code 1 when not authenticated', async () => {
+    mockLogin.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
-    await expect(infoAction('space-1', {})).rejects.toThrow('No Webex credentials found.')
+    await infoAction('space-1', {})
 
     expect(mockGetSpace).not.toHaveBeenCalled()
-    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })

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

@@ -23,7 +23,9 @@ let consoleLogSpy: ReturnType<typeof spyOn>
 let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new 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)

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)