agent-messenger 2.18.0 → 2.19.0

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

@@ -4,14 +4,15 @@ import { mkdir } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-const mockSendMessage = mock((_channelId: string, content: string, _options?: { thread_id?: string }) =>
-  Promise.resolve({
-    id: 'msg1',
-    channel_id: 'ch1',
-    content,
-    author: { id: 'bot1', username: 'testbot' },
-    timestamp: '2025-01-01T00:00:00.000Z',
-  }),
+const mockSendMessage = mock(
+  (_channelId: string, content: string, _options?: { thread_id?: string; reply_to?: string }) =>
+    Promise.resolve({
+      id: 'msg1',
+      channel_id: 'ch1',
+      content,
+      author: { id: 'bot1', username: 'testbot' },
+      timestamp: '2025-01-01T00:00:00.000Z',
+    }),
 )
 
 const mockGetMessages = mock((_channelId: string, _limit?: number) =>
@@ -127,7 +128,7 @@ describe('message commands', () => {
       expect(result.content).toBe('hello world')
       expect(result.author).toBe('testbot')
       expect(mockResolveChannel).toHaveBeenCalledWith('guild1', 'general')
-      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'hello world', { thread_id: undefined })
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'hello world', { thread_id: undefined, reply_to: undefined })
     })
 
     it('sends message to channel by ID', async () => {
@@ -135,7 +136,7 @@ describe('message commands', () => {
 
       expect(result.id).toBe('msg1')
       expect(mockResolveChannel).toHaveBeenCalledWith('guild1', '123456')
-      expect(mockSendMessage).toHaveBeenCalledWith('123456', 'hi', { thread_id: undefined })
+      expect(mockSendMessage).toHaveBeenCalledWith('123456', 'hi', { thread_id: undefined, reply_to: undefined })
     })
 
     it('sends message to thread', async () => {
@@ -145,7 +146,23 @@ describe('message commands', () => {
       })
 
       expect(result.id).toBe('msg1')
-      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'thread reply', { thread_id: 'thread123' })
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'thread reply', {
+        thread_id: 'thread123',
+        reply_to: undefined,
+      })
+    })
+
+    it('replies to a message', async () => {
+      const result = await sendAction('general', 'reply text', {
+        _credManager: manager,
+        reply: 'parent123',
+      })
+
+      expect(result.id).toBe('msg1')
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'reply text', {
+        thread_id: undefined,
+        reply_to: 'parent123',
+      })
     })
 
     it('returns error on channel not found', async () => {

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

@@ -28,7 +28,7 @@ interface MessageResult {
 export async function sendAction(
   channel: string,
   text: string,
-  options: BotOption & { thread?: string },
+  options: BotOption & { thread?: string; reply?: string },
 ): Promise<MessageResult> {
   try {
     const client = await getClient(options)
@@ -36,6 +36,7 @@ export async function sendAction(
     const channelId = await client.resolveChannel(serverId, channel)
     const message = await client.sendMessage(channelId, text, {
       thread_id: options.thread,
+      reply_to: options.reply,
     })
 
     return {
@@ -173,10 +174,11 @@ export const messageCommand = new Command('message')
       .argument('<channel>', 'Channel ID or name')
       .argument('<text>', 'Message text')
       .option('--thread <id>', 'Thread ID for replies')
+      .option('--reply <message-id>', 'Reply to a message by ID')
       .option('--bot <id>', 'Use specific bot')
       .option('--server <id>', 'Server ID')
       .option('--pretty', 'Pretty print JSON output')
-      .action(async (channel: string, text: string, opts: BotOption & { thread?: string }) => {
+      .action(async (channel: string, text: string, opts: BotOption & { thread?: string; reply?: string }) => {
         cliOutput(await sendAction(channel, text, opts), opts.pretty)
       }),
   )

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

@@ -3,20 +3,13 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramCredentialManager } from '../credential-manager'
+
 const mockGetAccount = mock(() => Promise.resolve(null))
 const mockListAccounts = mock(() => Promise.resolve([]))
 const mockSetCurrent = mock(() => Promise.resolve(true))
 const mockRemoveAccount = mock(() => Promise.resolve(true))
 
-mock.module('../credential-manager', () => ({
-  InstagramCredentialManager: class {
-    getAccount = mockGetAccount
-    listAccounts = mockListAccounts
-    setCurrent = mockSetCurrent
-    removeAccount = mockRemoveAccount
-  },
-}))
-
 import { authCommand } from './auth'
 
 function resetCommandState(cmd: Command): void {
@@ -33,6 +26,7 @@ function resetCommandState(cmd: Command): void {
 describe('auth commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  const managerSpies: ReturnType<typeof spyOn>[] = []
 
   beforeEach(() => {
     resetCommandState(authCommand)
@@ -42,6 +36,13 @@ describe('auth commands', () => {
     mockSetCurrent.mockReset()
     mockRemoveAccount.mockReset()
 
+    managerSpies.push(
+      spyOn(InstagramCredentialManager.prototype, 'getAccount').mockImplementation(mockGetAccount),
+      spyOn(InstagramCredentialManager.prototype, 'listAccounts').mockImplementation(mockListAccounts),
+      spyOn(InstagramCredentialManager.prototype, 'setCurrent').mockImplementation(mockSetCurrent),
+      spyOn(InstagramCredentialManager.prototype, 'removeAccount').mockImplementation(mockRemoveAccount),
+    )
+
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
@@ -51,6 +52,7 @@ describe('auth commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    for (const spy of managerSpies.splice(0)) spy.mockRestore()
     processExitSpy.mockRestore()
   })
 

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

@@ -3,6 +3,9 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+
 const mockListChats = mock(() =>
   Promise.resolve([
     { id: 'thread-1', title: 'Alice', last_message: 'Hi' },
@@ -17,12 +20,6 @@ const mockClient = {
   searchChats: mockSearchChats,
 }
 
-mock.module('./shared', () => ({
-  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-}))
-
 import { chatCommand } from './chat'
 
 function resetCommandState(cmd: Command): void {
@@ -39,6 +36,7 @@ function resetCommandState(cmd: Command): void {
 describe('chat commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  let withInstagramClientSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     resetCommandState(chatCommand)
@@ -56,6 +54,9 @@ describe('chat commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(async (_options, fn) => {
+      return fn(Object.assign(Object.create(InstagramClient.prototype), mockClient) as InstagramClient)
+    })
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit called')
     })
@@ -63,6 +64,7 @@ describe('chat commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    withInstagramClientSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 

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

@@ -3,6 +3,9 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+
 const mockGetMessages = mock(() => Promise.resolve([{ id: 'msg-1', text: 'Hello' }]))
 const mockSendMessage = mock(() => Promise.resolve({ id: 'msg-2', text: 'Sent' }))
 const mockSendMessageToUser = mock(() => Promise.resolve({ id: 'msg-3', text: 'Sent to user' }))
@@ -17,12 +20,6 @@ const mockClient = {
   searchUsers: mockSearchUsers,
 }
 
-mock.module('./shared', () => ({
-  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-}))
-
 import { messageCommand } from './message'
 
 function resetCommandState(cmd: Command): void {
@@ -39,6 +36,7 @@ function resetCommandState(cmd: Command): void {
 describe('message commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  let withInstagramClientSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     resetCommandState(messageCommand)
@@ -57,6 +55,9 @@ describe('message commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(async (_options, fn) => {
+      return fn(Object.assign(Object.create(InstagramClient.prototype), mockClient) as InstagramClient)
+    })
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit called')
     })
@@ -64,6 +65,7 @@ describe('message commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    withInstagramClientSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 

package/src/platforms/kakaotalk/client.test.ts

@@ -13,6 +13,7 @@ const mockGetAllMembers = mock(() => Promise.resolve({}))
 const mockGetMembersByIds = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
+const mockSendReply = mock(() => Promise.resolve({}))
 const mockMarkRead = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
 const mockOnClose = mock((_handler: () => void) => {})
@@ -30,6 +31,7 @@ mock.module('./protocol/session', () => ({
     getMembersByIds = mockGetMembersByIds
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
+    sendReply = mockSendReply
     markRead = mockMarkRead
     close = mockClose
     onClose = mockOnClose
@@ -52,6 +54,7 @@ function resetAllMocks() {
   mockGetMembersByIds.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
+  mockSendReply.mockReset()
   mockMarkRead.mockReset()
   mockClose.mockReset()
   mockOnClose.mockReset()
@@ -972,6 +975,60 @@ describe('KakaoTalkClient', () => {
 
       client.close()
     })
+
+    it('routes to sendReply with a built reply extra when replyTo is given', async () => {
+      // given
+      mockSendReply.mockResolvedValueOnce({ statusCode: 0, body: { logId: makeLong(50), sendAt: 1700000100 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      const result = await client.sendMessage('100', 'replying', {
+        replyTo: { log_id: '42', author_id: 7, message: 'original', type: 1 },
+      })
+
+      // then
+      expect(mockSendMessage).not.toHaveBeenCalled()
+      expect(mockSendReply).toHaveBeenCalledTimes(1)
+      const [, text, extra] = mockSendReply.mock.calls[0] as [unknown, string, Record<string, unknown>]
+      expect(text).toBe('replying')
+      expect(extra).toEqual({
+        attach_only: false,
+        attach_type: 1,
+        src_logId: '42',
+        src_userId: 7,
+        src_message: 'original',
+        src_type: 1,
+        src_mentions: [],
+        mentions: [],
+      })
+      expect(result).toEqual({
+        success: true,
+        status_code: 0,
+        chat_id: '100',
+        log_id: '50',
+        sent_at: 1700000100,
+      })
+
+      client.close()
+    })
+
+    it('mirrors the source message type into attach_type/src_type', async () => {
+      // given
+      mockSendReply.mockResolvedValueOnce({ statusCode: 0, body: { logId: makeLong(51), sendAt: 1700000101 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when — replying to a photo (type 2)
+      await client.sendMessage('100', 'nice pic', {
+        replyTo: { log_id: '99', author_id: 3, message: 'photo', type: 2 },
+      })
+
+      // then
+      const [, , extra] = mockSendReply.mock.calls[0] as [unknown, string, Record<string, unknown>]
+      expect(extra.attach_type).toBe(2)
+      expect(extra.src_type).toBe(2)
+
+      client.close()
+    })
   })
 
   describe('markRead', () => {

package/src/platforms/kakaotalk/client.ts

@@ -23,6 +23,8 @@ import {
   type KakaoMessage,
   type KakaoMultiPhotoExtra,
   type KakaoProfile,
+  type KakaoReplyExtra,
+  type KakaoReplyTarget,
   type KakaoSendResult,
 } from './types'
 
@@ -445,6 +447,19 @@ function formatMessages(
   }))
 }
 
+function buildReplyExtra(target: KakaoReplyTarget): KakaoReplyExtra {
+  return {
+    attach_only: false,
+    attach_type: target.type,
+    src_logId: target.log_id,
+    src_userId: target.author_id,
+    src_message: target.message,
+    src_type: target.type,
+    src_mentions: [],
+    mentions: [],
+  }
+}
+
 export class KakaoTalkClient {
   private oauthToken: string | null = null
   private userId: string | null = null
@@ -883,10 +898,16 @@ export class KakaoTalkClient {
     })
   }
 
-  async sendMessage(chatId: string, text: string): Promise<KakaoSendResult> {
+  async sendMessage(chatId: string, text: string, options?: { replyTo?: KakaoReplyTarget }): Promise<KakaoSendResult> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
-        const response = await session.sendMessage(parseLong(chatId), text)
+        const response = options?.replyTo
+          ? await session.sendReply(
+              parseLong(chatId),
+              text,
+              buildReplyExtra(options.replyTo) as unknown as Record<string, unknown>,
+            )
+          : await session.sendMessage(parseLong(chatId), text)
 
         return {
           success: response.statusCode === 0,

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

@@ -112,6 +112,48 @@ describe('message commands', () => {
         expect.any(Function),
       )
     })
+
+    it('resolves --reply-to from chat history and sends a quoted reply', async () => {
+      // given
+      mockGetMessages.mockImplementation(() =>
+        Promise.resolve([
+          { log_id: '10', type: 1, author_id: 5, author_name: null, message: 'earlier', attachment: null, sent_at: 1 },
+          { log_id: '42', type: 2, author_id: 7, author_name: null, message: 'target', attachment: null, sent_at: 2 },
+        ]),
+      )
+
+      // when
+      await messageCommand.parseAsync(['send', 'chat-123', 'replying', '--reply-to', '42'], { from: 'user' })
+
+      // then
+      expect(mockGetMessages).toHaveBeenCalledWith('chat-123', { count: 100 })
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'replying', {
+        replyTo: { log_id: '42', author_id: 7, message: 'target', type: 2 },
+      })
+    })
+
+    it('errors when --reply-to log-id is not found in recent history', async () => {
+      // given
+      mockGetMessages.mockImplementation(() =>
+        Promise.resolve([
+          { log_id: '10', type: 1, author_id: 5, author_name: null, message: 'earlier', attachment: null, sent_at: 1 },
+        ]),
+      )
+      const exitSpy = mock((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+      process.exit = exitSpy as unknown as typeof process.exit
+
+      // when / then
+      try {
+        await messageCommand.parseAsync(['send', 'chat-123', 'replying', '--reply-to', '999'], { from: 'user' })
+      } catch {
+        // process.exit stub throws to abort the action
+      }
+
+      expect(mockSendMessage).not.toHaveBeenCalled()
+      expect(exitSpy).toHaveBeenCalled()
+    })
   })
 
   describe('mark-read', () => {

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,6 +7,12 @@ 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>
@@ -441,15 +447,17 @@ 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 stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
+      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 +467,17 @@ 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 stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
+      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 () => {