agent-messenger 2.3.0 → 2.4.0

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

@@ -1,89 +1,73 @@
-import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
 import { addAction, removeAction } from './reaction'
 
-let clientAddReactionSpy: ReturnType<typeof spyOn>
-let clientRemoveReactionSpy: ReturnType<typeof spyOn>
-let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+let addReactionSpy: ReturnType<typeof spyOn>
+let removeReactionSpy: ReturnType<typeof spyOn>
+let getTokenWithExpirySpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  clientAddReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
-  clientRemoveReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
-  credManagerLoadConfigSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
-    current_account: 'work',
-    accounts: {
-      work: {
-        token: 'test-token',
-        account_type: 'work' as const,
-        current_team: null,
-        teams: {},
-      },
-    },
+  addReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
+  removeReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
+  getTokenWithExpirySpy = spyOn(TeamsCredentialManager.prototype, 'getTokenWithExpiry').mockImplementation(() =>
+    Promise.resolve({ token: 'test-token', tokenExpiresAt: undefined }),
+  )
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+    throw new Error(`process.exit(${_code})`)
   })
 })
 
 afterEach(() => {
-  clientAddReactionSpy?.mockRestore()
-  clientRemoveReactionSpy?.mockRestore()
-  credManagerLoadConfigSpy?.mockRestore()
+  addReactionSpy.mockRestore()
+  removeReactionSpy.mockRestore()
+  getTokenWithExpirySpy.mockRestore()
+  consoleLogSpy.mockRestore()
+  processExitSpy.mockRestore()
 })
 
 test('add: sends correct POST request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('remove: sends correct DELETE request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await removeAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('add: handles missing token gracefully', async () => {
-  credManagerLoadConfigSpy?.mockResolvedValue(null)
-
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  const originalExit = process.exit
-  process.exit = mock(() => {}) as any
-  console.log = consoleSpy
+  getTokenWithExpirySpy.mockImplementation(() => Promise.resolve(null))
 
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.error).toBeDefined()
-  } finally {
-    console.log = originalLog
-    process.exit = originalExit
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.error).toBeDefined()
+  expect(processExitSpy).toHaveBeenCalledWith(1)
 })

package/src/platforms/teams/commands/reaction.ts

@@ -20,6 +20,7 @@ export async function addAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
@@ -56,6 +57,7 @@ export async function removeAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })

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

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListChats = mock(() =>
+  Promise.resolve([
+    { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+    { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+  ]),
+)
+
+const mockSearchChats = mock(() =>
+  Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+)
+
+const mockGetChat = mock(() =>
+  Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+)
+
+const mockClient = {
+  listChats: mockListChats,
+  searchChats: mockSearchChats,
+  getChat: mockGetChat,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { chatCommand } from './chat'
+
+describe('chat commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListChats.mockReset()
+    mockListChats.mockImplementation(() =>
+      Promise.resolve([
+        { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+        { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+      ]),
+    )
+    mockSearchChats.mockReset()
+    mockSearchChats.mockImplementation(() =>
+      Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+    )
+    mockGetChat.mockReset()
+    mockGetChat.mockImplementation(() =>
+      Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listChats with default limit', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(20)
+    })
+
+    test('calls listChats with custom limit', async () => {
+      await chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(5)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('search subcommand', () => {
+    test('calls searchChats with query and default limit', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 20)
+    })
+
+    test('calls searchChats with query and custom limit', async () => {
+      await chatCommand.parseAsync(['search', 'General', '--limit', '3'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 3)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(1)
+    })
+  })
+
+  describe('get subcommand', () => {
+    test('calls getChat with chat reference', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(mockGetChat).toHaveBeenCalledWith('chat-1')
+    })
+
+    test('outputs JSON object to console', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe('chat-1')
+    })
+  })
+})

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

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListMessages = mock(() =>
+  Promise.resolve([
+    { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+    { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+  ]),
+)
+
+const mockSendMessage = mock(() =>
+  Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+)
+
+const mockClient = {
+  listMessages: mockListMessages,
+  sendMessage: mockSendMessage,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { messageCommand } from './message'
+
+describe('message commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListMessages.mockReset()
+    mockListMessages.mockImplementation(() =>
+      Promise.resolve([
+        { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+        { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+      ]),
+    )
+    mockSendMessage.mockReset()
+    mockSendMessage.mockImplementation(() =>
+      Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listMessages with chat reference and default limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 20)
+    })
+
+    test('calls listMessages with custom limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--limit', '10'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 10)
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('send subcommand', () => {
+    test('calls sendMessage with chat reference and text', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'Hello there')
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe(3)
+    })
+  })
+})

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

@@ -1,65 +1,74 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } 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',
+    roomId: 'room-1',
+    personId: 'person-1',
+    personEmail: 'alice@example.com',
+    personDisplayName: 'Alice',
+    isModerator: true,
+    created: '2024-01-01T00:00:00.000Z',
+  },
+  {
+    id: 'mem-2',
+    roomId: 'room-1',
+    personId: 'person-2',
+    personEmail: 'bob@example.com',
+    personDisplayName: 'Bob',
+    isModerator: false,
+    created: '2024-01-02T00:00:00.000Z',
+  },
+]
+
+const mockListMemberships = mock(() => Promise.resolve(mockMembers))
+const mockLogin = mock(() => Promise.resolve({ listMemberships: mockListMemberships }))
+
+mock.module('../client', () => ({
+  WebexClient: class {
+    login = mockLogin
+  },
+}))
+
 import { listAction } from './member'
 
+afterAll(() => {
+  mock.restore()
+})
+
 describe('member commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
-  let consoleErrorSpy: ReturnType<typeof spyOn>
-  let processExitSpy: ReturnType<typeof spyOn>
-  let stderrOutput: string
-  let origStderrWrite: typeof process.stderr.write
-  const mockMembers = [
-    {
-      id: 'mem-1',
-      roomId: 'room-1',
-      personId: 'person-1',
-      personEmail: 'alice@example.com',
-      personDisplayName: 'Alice',
-      isModerator: true,
-      created: '2024-01-01T00:00:00.000Z',
-    },
-    {
-      id: 'mem-2',
-      roomId: 'room-1',
-      personId: 'person-2',
-      personEmail: 'bob@example.com',
-      personDisplayName: 'Bob',
-      isModerator: false,
-      created: '2024-01-02T00:00:00.000Z',
-    },
-  ]
 
   beforeEach(() => {
-    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
-    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
-      throw new Error(`process.exit(${_code})`)
+    mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
+    mockLogin.mockReset().mockImplementation(() =>
+      Promise.resolve({ listMemberships: mockListMemberships }),
+    )
+    mockHandleError.mockReset().mockImplementation((err: Error) => {
+      throw err
     })
-    stderrOutput = ''
-    origStderrWrite = process.stderr.write
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      stderrOutput += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk)
-      return true
-    }) as typeof process.stderr.write
-    spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient() as any)
-    spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(mockMembers)
+
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
-    process.stderr.write = origStderrWrite
-    mock.restore()
+    consoleSpy.mockRestore()
   })
 
   test('listAction calls listMemberships with spaceId and outputs mapped members', async () => {
-    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
-      mockMembers,
-    )
-
     await listAction('room-1', {})
 
-    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: undefined })
+    expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: undefined })
     expect(consoleSpy).toHaveBeenCalledWith(
       JSON.stringify([
         {
@@ -83,30 +92,28 @@ describe('member commands', () => {
   })
 
   test('listAction passes limit option to listMemberships', async () => {
-    const listMembershipsSpy = spyOn(WebexClient.prototype, 'listMemberships').mockResolvedValue(
-      mockMembers,
-    )
-
     await listAction('room-1', { limit: 25 })
 
-    expect(listMembershipsSpy).toHaveBeenCalledWith('room-1', { max: 25 })
+    expect(mockListMemberships).toHaveBeenCalledWith('room-1', { max: 25 })
   })
 
   test('listAction handles not-authenticated case', async () => {
-    spyOn(WebexClient.prototype, 'login').mockRejectedValue(
-      new WebexError('No Webex credentials found.', 'no_credentials'),
-    )
+    mockLogin.mockImplementation(async () => {
+      throw new WebexError('No Webex credentials found.', 'no_credentials')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(stderrOutput).toContain('No Webex credentials found')
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   test('listAction handles API error', async () => {
-    spyOn(WebexClient.prototype, 'listMemberships').mockRejectedValue(new Error('API failure'))
+    mockListMemberships.mockImplementation(async () => {
+      throw new Error('API failure')
+    })
 
-    await expect(listAction('room-1', {})).rejects.toThrow('process.exit(1)')
+    await expect(listAction('room-1', {})).rejects.toThrow('API failure')
 
-    expect(processExitSpy).toHaveBeenCalledWith(1)
+    expect(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
   })
 })