agent-messenger 2.19.0 → 2.19.2

package/src/platforms/line/listener.ts

@@ -2,7 +2,6 @@ import { EventEmitter } from 'events'
 
 import type { LineClient } from './client'
 import type { LineListenerEventMap, LinePushGenericEvent, LinePushMessageEvent } from './types'
-import { LineError } from './types'
 
 const RECONNECT_BASE_DELAY = 1_000
 const RECONNECT_MAX_DELAY = 30_000
@@ -61,59 +60,13 @@ export class LineListener {
       await this.lineClient.login()
       if (!this.running) return
 
-      const internalClient = (this.lineClient as any).client
-      if (!internalClient) {
-        throw new LineError('not_connected', 'Failed to get internal LINE client')
-      }
-
+      const profile = await this.lineClient.getProfile()
+      if (!this.running) return
       this.abortController = new AbortController()
-
-      internalClient.on('message', (msg: any) => {
-        try {
-          const toType = msg.raw.toType
-          const isGroupOrRoom = toType === 'GROUP' || toType === 'ROOM' || toType === 0 || toType === 1
-          const chatId = isGroupOrRoom ? msg.to.id : msg.isMyMessage ? msg.to.id : msg.from.id
-
-          const event: LinePushMessageEvent = {
-            type: 'message',
-            chat_id: chatId,
-            message_id: String(msg.raw.id),
-            author_id: msg.from.id,
-            text: msg.text ?? null,
-            content_type: String(msg.raw.contentType ?? 'NONE'),
-            sent_at: new Date(Number(msg.raw.createdTime)).toISOString(),
-          }
-          this.emitter.emit('message', event)
-          this.emitter.emit('line_event', { ...event })
-        } catch (error) {
-          this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
-        }
-      })
-
-      internalClient.on('event', (op: any) => {
-        const event: LinePushGenericEvent = {
-          type: String(op.type ?? 'unknown'),
-          ...(op.revision !== undefined && { revision: String(op.revision) }),
-          ...(op.createdTime !== undefined && {
-            created_time: new Date(Number(op.createdTime)).toISOString(),
-          }),
-        }
-        this.emitter.emit('line_event', event)
-      })
-
-      internalClient.listen({ signal: this.abortController.signal })?.catch((error: unknown) => {
-        if (!this.running) return
-        const err = error instanceof Error ? error : new Error(String(error))
-        if (err.name === 'AbortError') return
-        this.emitter.emit('error', err)
-        this.emitter.emit('disconnected')
-        this.scheduleReconnect()
-      })
-
       this.reconnectAttempts = 0
-
-      const profile = await internalClient.base.talk.getProfile()
       this.emitter.emit('connected', { account_id: profile.mid })
+
+      void this.pump(this.abortController.signal)
     } catch (error) {
       this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
       if (this.running) {
@@ -122,6 +75,58 @@ export class LineListener {
     }
   }
 
+  private async pump(signal: AbortSignal): Promise<void> {
+    try {
+      for await (const event of this.lineClient.streamEvents(signal)) {
+        if (event.kind === 'message') {
+          this.emitMessage(event.message)
+        } else {
+          this.emitOperation(event.op)
+        }
+      }
+    } catch (error) {
+      if (!this.running || signal.aborted) return
+      const err = error instanceof Error ? error : new Error(String(error))
+      if (err.name === 'AbortError') return
+      this.emitter.emit('error', err)
+      this.emitter.emit('disconnected')
+      this.scheduleReconnect()
+    }
+  }
+
+  private emitMessage(msg: any): void {
+    try {
+      const toType = msg.raw.toType
+      const isGroupOrRoom = toType === 'GROUP' || toType === 'ROOM' || toType === 0 || toType === 1
+      const chatId = isGroupOrRoom ? msg.to.id : msg.isMyMessage ? msg.to.id : msg.from.id
+
+      const event: LinePushMessageEvent = {
+        type: 'message',
+        chat_id: chatId,
+        message_id: String(msg.raw.id),
+        author_id: msg.from.id,
+        text: msg.text ?? null,
+        content_type: String(msg.raw.contentType ?? 'NONE'),
+        sent_at: new Date(Number(msg.raw.createdTime)).toISOString(),
+      }
+      this.emitter.emit('message', event)
+      this.emitter.emit('line_event', { ...event })
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+    }
+  }
+
+  private emitOperation(op: any): void {
+    const event: LinePushGenericEvent = {
+      type: String(op.type ?? 'unknown'),
+      ...(op.revision !== undefined && { revision: String(op.revision) }),
+      ...(op.createdTime !== undefined && {
+        created_time: new Date(Number(op.createdTime)).toISOString(),
+      }),
+    }
+    this.emitter.emit('line_event', event)
+  }
+
   private scheduleReconnect(): void {
     this.clearTimers()
     const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)

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 () => {