agent-messenger 2.18.0 → 2.19.1

package/src/platforms/discord/commands/reaction.test.ts

@@ -4,6 +4,12 @@ import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 import { addAction, listAction, removeAction } from './reaction'
 
+class ProcessExit extends Error {
+  constructor(readonly code?: string | number | null) {
+    super(`process.exit(${code})`)
+  }
+}
+
 let clientAddReactionSpy: ReturnType<typeof spyOn>
 let clientRemoveReactionSpy: ReturnType<typeof spyOn>
 let clientGetMessageSpy: ReturnType<typeof spyOn>
@@ -114,21 +120,20 @@ it('add: handles missing token gracefully', async () => {
 
   const consoleSpy = mock((_msg: string) => {})
   const originalLog = console.log
-  const originalExit = process.exit
-  let _exitCode = 0
-  process.exit = mock((code: number) => {
-    _exitCode = code
-  }) as any
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new ProcessExit(code)
+  })
 
   console.log = consoleSpy
 
   try {
-    await addAction('ch123', 'msg123', 'thumbsup', { pretty: false })
+    await expect(addAction('ch123', 'msg123', 'thumbsup', { pretty: false })).rejects.toThrow(ProcessExit)
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[0][0])
     expect(output.error).toBeDefined()
+    expect(exitSpy).toHaveBeenCalledWith(1)
   } finally {
     console.log = originalLog
-    process.exit = originalExit
+    exitSpy.mockRestore()
   }
 })

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

@@ -167,6 +167,23 @@ describe('DiscordBotClient', () => {
 
       expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Thread reply', thread_id: 'thread123' }))
     })
+
+    it('includes message_reference when reply_to is provided', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: 'Reply text',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
+      await client.sendMessage('ch1', 'Reply text', { reply_to: 'parent123' })
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({ content: 'Reply text', message_reference: { message_id: 'parent123' } }),
+      )
+    })
   })
 
   describe('editMessage', () => {

package/src/platforms/discordbot/client.ts

@@ -249,11 +249,18 @@ export class DiscordBotClient {
     return this.request<DiscordChannel>('GET', `/channels/${channelId}`)
   }
 
-  async sendMessage(channelId: string, content: string, options?: { thread_id?: string }): Promise<DiscordMessage> {
-    const body: Record<string, string> = { content }
+  async sendMessage(
+    channelId: string,
+    content: string,
+    options?: { thread_id?: string; reply_to?: string },
+  ): Promise<DiscordMessage> {
+    const body: Record<string, unknown> = { content }
     if (options?.thread_id) {
       body.thread_id = options.thread_id
     }
+    if (options?.reply_to) {
+      body.message_reference = { message_id: options.reply_to }
+    }
     return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, body)
   }
 

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', () => {
@@ -1208,6 +1265,45 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('merges CHATONROOM members when GETMEM returns a partial member list', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          members: [
+            {
+              userId: makeLong(42),
+              nickName: 'Alice',
+              type: 100,
+              profileImageUrl: 'https://kakao.com/p/alice.jpg',
+            },
+          ],
+          token: 0,
+        },
+      })
+      mockGetChatInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          status: 0,
+          m: [
+            { userId: makeLong(42), nickName: 'Alice From Room', type: 100 },
+            { userId: makeLong(43), nickName: 'Bob', type: 100 },
+            { userId: makeLong(44), nickName: 'Carol', type: 100 },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembers('100')
+
+      expect(members.map((member) => member.user_id)).toEqual(['42', '43', '44'])
+      expect(members[0].nickname).toBe('Alice')
+      expect(members[0].profile_image_url).toBe('https://kakao.com/p/alice.jpg')
+      expect(members[1].nickname).toBe('Bob')
+      expect(members[2].nickname).toBe('Carol')
+
+      client.close()
+    })
+
     it('returns empty array when GETMEM returns no members', async () => {
       mockGetAllMembers.mockResolvedValueOnce({ statusCode: 0, body: {} })
 

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'
 
@@ -426,6 +428,54 @@ function formatMember(member: Record<string, unknown>): KakaoMember {
   }
 }
 
+function memberIdKey(member: Record<string, unknown>): string | null {
+  if (member.userId === undefined || member.userId === null) return null
+  const key = longToString(member.userId)
+  return key === '0' ? null : key
+}
+
+function mergeMemberRecords(
+  primaryMembers: Array<Record<string, unknown>>,
+  fallbackMembers: Array<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+  const merged: Array<Record<string, unknown>> = []
+  const indexByUserId = new Map<string, number>()
+
+  const upsert = (member: Record<string, unknown>) => {
+    const userId = memberIdKey(member)
+    if (!userId) return
+
+    const existingIndex = indexByUserId.get(userId)
+    if (existingIndex === undefined) {
+      indexByUserId.set(userId, merged.length)
+      merged.push(member)
+      return
+    }
+
+    merged[existingIndex] = { ...member, ...merged[existingIndex] }
+  }
+
+  for (const member of primaryMembers) upsert(member)
+  for (const member of fallbackMembers) upsert(member)
+
+  return merged
+}
+
+function extractChatInfoMembers(body: unknown): Array<Record<string, unknown>> {
+  if (!body || typeof body !== 'object') return []
+
+  const record = body as Record<string, unknown>
+  if (Array.isArray(record.m)) {
+    return record.m as Array<Record<string, unknown>>
+  }
+
+  const chatInfo = record.chatInfo
+  if (!chatInfo || typeof chatInfo !== 'object') return []
+
+  const displayMembers = (chatInfo as Record<string, unknown>).displayMembers
+  return Array.isArray(displayMembers) ? (displayMembers as Array<Record<string, unknown>>) : []
+}
+
 function formatMessages(
   logs: Array<Record<string, unknown>>,
   count: number,
@@ -445,6 +495,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
@@ -860,7 +923,17 @@ export class KakaoTalkClient {
         const response = await session.getAllMembers(parsedChatId)
         assertLocoOk(response, 'GETMEM')
         const members = (response.body.members ?? []) as Array<Record<string, unknown>>
-        return members.map(formatMember)
+        let fallbackMembers: Array<Record<string, unknown>> = []
+        try {
+          // Some KakaoTalk rooms return only a subset from GETMEM even though
+          // CHATONROOM carries the full active member list in `m`.
+          const chatInfo = await session.getChatInfo(parsedChatId)
+          fallbackMembers = extractChatInfoMembers(chatInfo.body)
+        } catch {
+          fallbackMembers = []
+        }
+
+        return mergeMemberRecords(members, fallbackMembers).map(formatMember)
       } catch (error) {
         throw wrapError(error, 'get_members_failed')
       }
@@ -883,10 +956,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', () => {