agent-messenger 2.18.0 → 2.19.1

package/src/platforms/kakaotalk/commands/message.ts

@@ -6,6 +6,7 @@ import { Command } from 'commander'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 
+import type { KakaoMessage, KakaoReplyTarget } from '../types'
 import { withKakaoClient } from './shared'
 
 async function listAction(
@@ -26,16 +27,45 @@ async function listAction(
 async function sendAction(
   chatId: string,
   text: string,
-  options: { account?: string; pretty?: boolean },
+  options: { account?: string; pretty?: boolean; replyTo?: string },
 ): Promise<void> {
   try {
-    const result = await withKakaoClient(options, (client) => client.sendMessage(chatId, text))
+    const result = await withKakaoClient(options, async (client) => {
+      if (options.replyTo === undefined) {
+        return client.sendMessage(chatId, text)
+      }
+
+      const target = await resolveReplyTarget(client, chatId, options.replyTo)
+      return client.sendMessage(chatId, text, { replyTo: target })
+    })
     console.log(formatOutput(result, options.pretty))
   } catch (error) {
     handleError(error as Error)
   }
 }
 
+// A reply attachment needs the source message's author, text, and type — not
+// just its log_id — so we look it up in the chat's recent history.
+async function resolveReplyTarget(
+  client: {
+    getMessages: (chatId: string, opts: { count: number }) => Promise<KakaoMessage[]>
+  },
+  chatId: string,
+  logId: string,
+): Promise<KakaoReplyTarget> {
+  const messages = await client.getMessages(chatId, { count: 100 })
+  const source = messages.find((m) => m.log_id === logId)
+  if (!source) {
+    throw new Error(`Reply target log-id ${logId} not found in the latest 100 messages of chat ${chatId}`)
+  }
+  return {
+    log_id: source.log_id,
+    author_id: source.author_id,
+    message: source.message,
+    type: source.type,
+  }
+}
+
 type UploadKind = 'auto' | 'photo' | 'video' | 'audio' | 'file' | 'multi'
 
 async function uploadAction(
@@ -122,6 +152,7 @@ export const messageCommand = new Command('message')
       .argument('<chat-id>', 'Chat room ID')
       .argument('<text>', 'Message text')
       .option('--account <id>', 'Use a specific KakaoTalk account')
+      .option('--reply-to <log-id>', 'Send as a quoted reply to this message log ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )

package/src/platforms/kakaotalk/index.ts

@@ -20,6 +20,8 @@ export type {
   KakaoMultiPhotoExtra,
   KakaoPhotoExtra,
   KakaoProfile,
+  KakaoReplyExtra,
+  KakaoReplyTarget,
   KakaoSendResult,
   KakaoTalkListenerEventMap,
   KakaoTalkPushEmoticonEvent,

package/src/platforms/kakaotalk/protocol/session.ts

@@ -1,6 +1,6 @@
 import { Binary, Long } from 'bson'
 
-import type { KakaoDeviceType } from '../types'
+import { KAKAO_MESSAGE_TYPE, type KakaoDeviceType } from '../types'
 import {
   BOOKING_HOST,
   BOOKING_PORT,
@@ -126,6 +126,20 @@ export class LocoSession {
     })
   }
 
+  // Quoted reply — a WRITE with message_type 26 (REPLY) whose `extra` JSON
+  // carries the source-message reference. The reply semantics ride entirely on
+  // `type` + `extra`; no extra top-level WRITE fields are needed.
+  async sendReply(chatId: Long, text: string, extra: Record<string, unknown>): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('WRITE', {
+      chatId,
+      msg: text,
+      type: KAKAO_MESSAGE_TYPE.REPLY,
+      noSeen: false,
+      extra: JSON.stringify(extra),
+    })
+  }
+
   // Sends a WRITE with non-text message_type plus the JSON-stringified `extra`
   // payload that KakaoTalk clients render as the attachment (photo, file, etc).
   // See types.ts → KakaoPhotoExtra / KakaoFileExtra for the per-type shape.

package/src/platforms/kakaotalk/types.ts

@@ -126,6 +126,7 @@ export const KAKAO_MESSAGE_TYPE = {
   VIDEO: 3,
   AUDIO: 5,
   FILE: 18,
+  REPLY: 26,
   MULTIPHOTO: 27,
 } as const
 
@@ -176,6 +177,29 @@ export interface KakaoMultiPhotoExtra {
   expire?: number
 }
 
+// REPLY (type 26) extra. Field names verified against storycraft/node-kakao
+// (src/chat/attachment/reply.ts) and jhleekr/kakao.py: `Id` fields are
+// camelCase (src_logId, NOT src_log_id), and src_mentions/mentions are
+// required even when empty.
+export interface KakaoReplyExtra {
+  attach_only: boolean
+  attach_type: number
+  src_logId: string
+  src_userId: number
+  src_message: string
+  src_type: number
+  src_mentions: unknown[]
+  mentions: unknown[]
+  src_linkId?: string
+}
+
+export interface KakaoReplyTarget {
+  log_id: string
+  author_id: number
+  message: string
+  type: number
+}
+
 export interface KakaoMarkReadResult {
   success: boolean
   status_code: number

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

@@ -7,10 +7,17 @@ import { WebexTokenExtractor } from '../token-extractor'
 import { WebexError } from '../types'
 import { extractAction, loginAction, logoutAction, statusAction } from './auth'
 
+class ProcessExit extends Error {
+  constructor(readonly code?: string | number | null) {
+    super(`process.exit(${code})`)
+  }
+}
+
 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
@@ -38,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)
@@ -441,15 +455,16 @@ 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'))
-      protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
-      await extractAction({ pretty: false })
+      await expect(extractAction({ pretty: false })).rejects.toThrow(ProcessExit)
 
-      const lastCall = consoleErrorSpy.mock.calls[consoleErrorSpy.mock.calls.length - 1]?.[0] as string | undefined
-      if (lastCall) {
-        const output = JSON.parse(lastCall)
-        expect(output.error).toContain('Network error')
-      }
+      const lastCall = stderrWriteSpy.mock.calls[stderrWriteSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Network error')
+      expect(exitSpy).toHaveBeenCalledWith(1)
     })
 
     it('rethrows non-expiry auth errors', async () => {
@@ -459,15 +474,16 @@ describe('auth commands', () => {
       })
       protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
       protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('Network error'))
-      protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
-      await extractAction({ pretty: false })
+      await expect(extractAction({ pretty: false })).rejects.toThrow(ProcessExit)
 
-      const lastCall = consoleErrorSpy.mock.calls[consoleErrorSpy.mock.calls.length - 1]?.[0] as string | undefined
-      if (lastCall) {
-        const output = JSON.parse(lastCall)
-        expect(output.error).toContain('Network error')
-      }
+      const lastCall = stderrWriteSpy.mock.calls[stderrWriteSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Network error')
+      expect(exitSpy).toHaveBeenCalledWith(1)
     })
 
     it('outputs no token found when extract returns null', async () => {

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

@@ -1,15 +1,8 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, it } 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',
@@ -31,32 +24,39 @@ const mockMembers = [
   },
 ]
 
-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 mockListMemberships: ReturnType<typeof spyOn>
+  let mockLogin: ReturnType<typeof spyOn>
   let consoleSpy: 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))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve({ listMemberships: mockListMemberships }))
-    mockHandleError.mockReset().mockImplementation((err: Error) => {
-      throw err
+    mockLogin = protoSpy('login').mockImplementation(async function (this: WebexClient) {
+      return this
     })
+    mockListMemberships = protoSpy('listMemberships').mockResolvedValue(mockMembers)
 
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
   })
 
   afterEach(() => {
     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 () => {
@@ -91,23 +91,19 @@ describe('member commands', () => {
     expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: 25 })
   })
 
-  it('throws when not authenticated', async () => {
-    mockLogin.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(mockHandleError).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(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })

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

@@ -1,15 +1,8 @@
-import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, it } 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 mockMessage = {
   id: 'msg_123',
   roomId: 'space_456',
@@ -30,51 +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,
-}
-
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 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 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' }))
-  mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
-  mockHandleError.mockReset().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' })
 
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
   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 () => {
@@ -96,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 () => {
-  mockLogin.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(mockHandleError).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,15 +1,8 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, it } 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 mockSpaces = [
   {
     id: 'space-1',
@@ -43,40 +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,
-}
-
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 import { snapshotAction } from './snapshot'
 
 describe('snapshot command', () => {
+  let mockLogin: ReturnType<typeof spyOn>
   let consoleSpy: 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))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
-    mockHandleError.mockReset().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)
 
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
   })
 
   afterEach(() => {
     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 () => {
@@ -112,13 +104,11 @@ describe('snapshot command', () => {
     expect(output.spaces[0].id).toBe('space-1')
   })
 
-  it('throws when not authenticated', async () => {
-    mockLogin.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(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })

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

@@ -1,15 +1,8 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, it } 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 mockSpaces = [
   {
     id: 'space-1',
@@ -42,35 +35,40 @@ const mockSpace = {
   creatorId: 'person-1',
 }
 
-const mockListSpaces = mock(() => Promise.resolve(mockSpaces))
-const mockGetSpace = mock(() => Promise.resolve(mockSpace))
-const mockLogin = mock(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 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 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))
-  mockLogin
-    .mockReset()
-    .mockImplementation(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
-  mockHandleError.mockReset().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)
 
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
   consoleLogSpy.mockRestore()
+  consoleErrorSpy.mockRestore()
+  processExitSpy.mockRestore()
+  for (const s of protoSpies) s.mockRestore()
+  protoSpies.length = 0
 })
 
 describe('listAction', () => {
@@ -137,15 +135,13 @@ describe('listAction', () => {
     )
   })
 
-  it('throws when not authenticated', async () => {
-    mockLogin.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(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })
 
@@ -200,14 +196,12 @@ describe('infoAction', () => {
     )
   })
 
-  it('throws when not authenticated', async () => {
-    mockLogin.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(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(processExitSpy).toHaveBeenCalledWith(1)
   })
 })