agent-messenger 1.0.0 → 1.1.0

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

@@ -1,41 +1,57 @@
-import { expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 import { DiscordTokenExtractor } from '../token-extractor'
 
-// Mock modules
-mock.module('../token-extractor', () => ({
-  DiscordTokenExtractor: mock(() => ({
-    extract: mock(async () => ({
-      token: 'test-token-123',
-    })),
-  })),
-}))
+let extractorExtractSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let clientListGuildsSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+let credManagerSaveSpy: ReturnType<typeof spyOn>
+let credManagerClearTokenSpy: ReturnType<typeof spyOn>
 
-mock.module('../client', () => ({
-  DiscordClient: mock((_token: string) => ({
-    testAuth: mock(async () => ({
-      id: 'user-123',
-      username: 'testuser',
-    })),
-    listGuilds: mock(async () => [
-      { id: 'guild-1', name: 'Guild One' },
-      { id: 'guild-2', name: 'Guild Two' },
-    ]),
-  })),
-}))
+beforeEach(() => {
+  // Spy on DiscordTokenExtractor.prototype.extract
+  extractorExtractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue({
+    token: 'test-token-123',
+  })
 
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: null,
-      current_guild: null,
-      guilds: {},
-    })),
-    save: mock(async () => {}),
-    clearToken: mock(async () => {}),
-  })),
-}))
+  // Spy on DiscordClient.prototype methods
+  clientTestAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue({
+    id: 'user-123',
+    username: 'testuser',
+  })
+
+  clientListGuildsSpy = spyOn(DiscordClient.prototype, 'listGuilds').mockResolvedValue([
+    { id: 'guild-1', name: 'Guild One' },
+    { id: 'guild-2', name: 'Guild Two' },
+  ])
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: null,
+    current_guild: null,
+    guilds: {},
+  })
+
+  credManagerSaveSpy = spyOn(DiscordCredentialManager.prototype, 'save').mockResolvedValue(
+    undefined
+  )
+
+  credManagerClearTokenSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'clearToken'
+  ).mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  extractorExtractSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  clientListGuildsSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  credManagerSaveSpy?.mockRestore()
+  credManagerClearTokenSpy?.mockRestore()
+})
 
 test('extract: calls DiscordTokenExtractor', async () => {
   const extractor = new DiscordTokenExtractor()

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

@@ -1,15 +1,22 @@
-import { expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 import { DiscordClient } from '../client'
-
-// Mock modules
-mock.module('../client', () => ({
-  DiscordClient: mock((_token: string) => ({
-    listChannels: mock(async (guildId: string) => [
-      { id: 'ch-1', guild_id: guildId, name: 'general', type: 0, topic: 'General discussion' },
-      { id: 'ch-2', guild_id: guildId, name: 'announcements', type: 0, topic: 'Announcements' },
-      { id: 'ch-3', guild_id: guildId, name: 'voice-channel', type: 2, topic: null },
-    ]),
-    getChannel: mock(async (channelId: string) => {
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientListChannelsSpy: ReturnType<typeof spyOn>
+let clientGetChannelSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientListChannelsSpy = spyOn(DiscordClient.prototype, 'listChannels').mockResolvedValue([
+    { id: 'ch-1', guild_id: 'guild-1', name: 'general', type: 0, topic: 'General discussion' },
+    { id: 'ch-2', guild_id: 'guild-1', name: 'announcements', type: 0, topic: 'Announcements' },
+    { id: 'ch-3', guild_id: 'guild-1', name: 'voice-channel', type: 2, topic: undefined },
+  ])
+
+  clientGetChannelSpy = spyOn(DiscordClient.prototype, 'getChannel').mockImplementation(
+    async (channelId: string) => {
       if (channelId === 'ch-1') {
         return {
           id: 'ch-1',
@@ -29,37 +36,42 @@ mock.module('../client', () => ({
         }
       }
       throw new Error('Channel not found')
-    }),
-    getMessages: mock(async (channelId: string, _limit: number) => [
-      {
-        id: 'msg-1',
-        channel_id: channelId,
-        author: { id: 'user-1', username: 'alice' },
-        content: 'Hello world',
-        timestamp: '2024-01-29T10:00:00Z',
-      },
-      {
-        id: 'msg-2',
-        channel_id: channelId,
-        author: { id: 'user-2', username: 'bob' },
-        content: 'Hi there',
-        timestamp: '2024-01-29T09:00:00Z',
-      },
-    ]),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test-token',
-      current_guild: 'guild-1',
-      guilds: {
-        'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
-      },
-    })),
-  })),
-}))
+    }
+  )
+
+  clientGetMessagesSpy = spyOn(DiscordClient.prototype, 'getMessages').mockResolvedValue([
+    {
+      id: 'msg-1',
+      channel_id: 'ch-1',
+      author: { id: 'user-1', username: 'alice' },
+      content: 'Hello world',
+      timestamp: '2024-01-29T10:00:00Z',
+    },
+    {
+      id: 'msg-2',
+      channel_id: 'ch-1',
+      author: { id: 'user-2', username: 'bob' },
+      content: 'Hi there',
+      timestamp: '2024-01-29T09:00:00Z',
+    },
+  ])
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_guild: 'guild-1',
+    guilds: {
+      'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientListChannelsSpy?.mockRestore()
+  clientGetChannelSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
 
 test('list: returns text channels (type=0) from guild', async () => {
   // given: discord client with channels

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

@@ -1,64 +1,51 @@
-import { beforeEach, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
 import { infoAction, listAction, uploadAction } from './file'
 
-mock.module('../client', () => ({
-  DiscordClient: mock(() => ({
-    uploadFile: mock(async () => ({
+let clientUploadFileSpy: ReturnType<typeof spyOn>
+let clientListFilesSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientUploadFileSpy = spyOn(DiscordClient.prototype, 'uploadFile').mockResolvedValue({
+    id: 'file_123',
+    filename: 'test.pdf',
+    size: 1024,
+    url: 'https://cdn.discordapp.com/attachments/123/456/test.pdf',
+    content_type: 'application/pdf',
+  })
+
+  clientListFilesSpy = spyOn(DiscordClient.prototype, 'listFiles').mockResolvedValue([
+    {
       id: 'file_123',
       filename: 'test.pdf',
       size: 1024,
       url: 'https://cdn.discordapp.com/attachments/123/456/test.pdf',
       content_type: 'application/pdf',
-    })),
-    listFiles: mock(async () => [
-      {
-        id: 'file_123',
-        filename: 'test.pdf',
-        size: 1024,
-        url: 'https://cdn.discordapp.com/attachments/123/456/test.pdf',
-        content_type: 'application/pdf',
-      },
-      {
-        id: 'file_124',
-        filename: 'image.png',
-        size: 2048,
-        url: 'https://cdn.discordapp.com/attachments/123/457/image.png',
-        content_type: 'image/png',
-      },
-    ]),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test_token',
-      current_guild: 'guild_123',
-      guilds: {},
-    })),
-  })),
-}))
-
-mock.module('../../../shared/utils/output', () => ({
-  formatOutput: (data: any, pretty?: boolean) => JSON.stringify(data, null, pretty ? 2 : 0),
-}))
-
-mock.module('../../../shared/utils/error-handler', () => ({
-  handleError: (error: Error) => {
-    console.error(error.message)
-  },
-}))
-
-mock.module('node:fs', () => ({
-  readFileSync: () => Buffer.from('test file content'),
-}))
-
-mock.module('node:path', () => ({
-  resolve: (path: string) => path,
-}))
+    },
+    {
+      id: 'file_124',
+      filename: 'image.png',
+      size: 2048,
+      url: 'https://cdn.discordapp.com/attachments/123/457/image.png',
+      content_type: 'image/png',
+    },
+  ])
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test_token',
+    current_guild: 'guild_123',
+    guilds: {},
+  })
+})
 
-beforeEach(() => {
-  mock.restore()
+afterEach(() => {
+  clientUploadFileSpy?.mockRestore()
+  clientListFilesSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
 })
 
 test('upload: sends multipart request and returns file info', async () => {

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

@@ -1,15 +1,22 @@
-import { expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 
-// Mock modules
-mock.module('../client', () => ({
-  DiscordClient: mock((_token: string) => ({
-    listGuilds: mock(async () => [
-      { id: 'guild-1', name: 'Guild One', icon: 'icon1', owner: true },
-      { id: 'guild-2', name: 'Guild Two', icon: 'icon2', owner: false },
-    ]),
-    getGuild: mock(async (guildId: string) => {
+let clientListGuildsSpy: ReturnType<typeof spyOn>
+let clientGetGuildSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+let credManagerSetCurrentGuildSpy: ReturnType<typeof spyOn>
+let credManagerGetCurrentGuildSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientListGuildsSpy = spyOn(DiscordClient.prototype, 'listGuilds').mockResolvedValue([
+    { id: 'guild-1', name: 'Guild One', icon: 'icon1', owner: true },
+    { id: 'guild-2', name: 'Guild Two', icon: 'icon2', owner: false },
+  ])
+
+  clientGetGuildSpy = spyOn(DiscordClient.prototype, 'getGuild').mockImplementation(
+    async (guildId: string) => {
       if (guildId === 'guild-1') {
         return { id: 'guild-1', name: 'Guild One', icon: 'icon1', owner: true }
       }
@@ -17,24 +24,37 @@ mock.module('../client', () => ({
         return { id: 'guild-2', name: 'Guild Two', icon: 'icon2', owner: false }
       }
       throw new Error('Guild not found')
-    }),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test-token',
-      current_guild: 'guild-1',
-      guilds: {
-        'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
-        'guild-2': { guild_id: 'guild-2', guild_name: 'Guild Two' },
-      },
-    })),
-    setCurrentGuild: mock(async () => {}),
-    getCurrentGuild: mock(async () => 'guild-1'),
-  })),
-}))
+    }
+  )
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_guild: 'guild-1',
+    guilds: {
+      'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
+      'guild-2': { guild_id: 'guild-2', guild_name: 'Guild Two' },
+    },
+  })
+
+  credManagerSetCurrentGuildSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'setCurrentGuild'
+  ).mockResolvedValue(undefined)
+
+  credManagerGetCurrentGuildSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'getCurrentGuild'
+  ).mockResolvedValue('guild-1')
+})
+
+afterEach(() => {
+  clientListGuildsSpy?.mockRestore()
+  clientGetGuildSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  credManagerSetCurrentGuildSpy?.mockRestore()
+  credManagerGetCurrentGuildSpy?.mockRestore()
+})
 
 test('list: returns guilds with current marker', async () => {
   // given: credential manager with guilds

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

@@ -1,64 +1,67 @@
-import { beforeEach, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
 import { deleteAction, getAction, listAction, sendAction } from './message'
 
-mock.module('../client', () => ({
-  DiscordClient: mock(() => ({
-    sendMessage: mock(async () => ({
+let clientSendMessageSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientDeleteMessageSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientSendMessageSpy = spyOn(DiscordClient.prototype, 'sendMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', username: 'testuser' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientGetMessagesSpy = spyOn(DiscordClient.prototype, 'getMessages').mockResolvedValue([
+    {
       id: 'msg_123',
       channel_id: 'ch_456',
       author: { id: 'user_789', username: 'testuser' },
       content: 'Hello world',
       timestamp: '2025-01-29T10:00:00Z',
-    })),
-    getMessages: mock(async () => [
-      {
-        id: 'msg_123',
-        channel_id: 'ch_456',
-        author: { id: 'user_789', username: 'testuser' },
-        content: 'Hello world',
-        timestamp: '2025-01-29T10:00:00Z',
-      },
-      {
-        id: 'msg_124',
-        channel_id: 'ch_456',
-        author: { id: 'user_789', username: 'testuser' },
-        content: 'Second message',
-        timestamp: '2025-01-29T10:01:00Z',
-      },
-    ]),
-    getMessage: mock(async () => ({
-      id: 'msg_123',
+    },
+    {
+      id: 'msg_124',
       channel_id: 'ch_456',
       author: { id: 'user_789', username: 'testuser' },
-      content: 'Hello world',
-      timestamp: '2025-01-29T10:00:00Z',
-    })),
-    deleteMessage: mock(async () => undefined),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test_token',
-      current_guild: 'guild_123',
-      guilds: {},
-    })),
-  })),
-}))
-
-mock.module('../../../shared/utils/output', () => ({
-  formatOutput: (data: any, pretty?: boolean) => JSON.stringify(data, null, pretty ? 2 : 0),
-}))
-
-mock.module('../../../shared/utils/error-handler', () => ({
-  handleError: (error: Error) => {
-    console.error(error.message)
-  },
-}))
+      content: 'Second message',
+      timestamp: '2025-01-29T10:01:00Z',
+    },
+  ])
+
+  clientGetMessageSpy = spyOn(DiscordClient.prototype, 'getMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', username: 'testuser' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientDeleteMessageSpy = spyOn(DiscordClient.prototype, 'deleteMessage').mockResolvedValue(
+    undefined
+  )
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test_token',
+    current_guild: 'guild_123',
+    guilds: {},
+  })
+})
 
-beforeEach(() => {
-  mock.restore()
+afterEach(() => {
+  clientSendMessageSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  clientDeleteMessageSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
 })
 
 test('send: returns message with id', async () => {

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

@@ -1,38 +1,53 @@
-import { expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
 import { addAction, listAction, removeAction } from './reaction'
 
-// Mock modules
-mock.module('../client', () => ({
-  DiscordClient: mock(() => ({
-    addReaction: mock(async () => {}),
-    removeReaction: mock(async () => {}),
-    getMessage: mock(async () => ({
-      id: 'msg123',
-      channel_id: 'ch123',
-      author: { id: 'user123', username: 'testuser' },
-      content: 'test message',
-      timestamp: '2024-01-01T00:00:00Z',
-      reactions: [
-        {
-          emoji: { name: 'thumbsup', id: undefined },
-          count: 2,
-        },
-        {
-          emoji: { name: 'heart', id: undefined },
-          count: 1,
-        },
-      ],
-    })),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test-token',
-    })),
-  })),
-}))
+let clientAddReactionSpy: ReturnType<typeof spyOn>
+let clientRemoveReactionSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientAddReactionSpy = spyOn(DiscordClient.prototype, 'addReaction').mockResolvedValue(undefined)
+
+  clientRemoveReactionSpy = spyOn(DiscordClient.prototype, 'removeReaction').mockResolvedValue(
+    undefined
+  )
+
+  clientGetMessageSpy = spyOn(DiscordClient.prototype, 'getMessage').mockResolvedValue({
+    id: 'msg123',
+    channel_id: 'ch123',
+    author: { id: 'user123', username: 'testuser' },
+    content: 'test message',
+    timestamp: '2024-01-01T00:00:00Z',
+    reactions: [
+      {
+        emoji: { name: 'thumbsup', id: undefined },
+        count: 2,
+      },
+      {
+        emoji: { name: 'heart', id: undefined },
+        count: 1,
+      },
+    ],
+  } as any)
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_guild: null,
+    guilds: {},
+  })
+})
+
+afterEach(() => {
+  clientAddReactionSpy?.mockRestore()
+  clientRemoveReactionSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
 
 test('add: sends correct PUT request with emoji', async () => {
   const consoleSpy = mock((_msg: string) => {})
@@ -91,15 +106,12 @@ test('list: extracts reactions from message', async () => {
 })
 
 test('add: handles missing token gracefully', async () => {
-  const credManagerMock = mock(() => ({
-    load: mock(async () => ({
-      token: null,
-    })),
-  }))
-
-  mock.module('../credential-manager', () => ({
-    DiscordCredentialManager: credManagerMock,
-  }))
+  // Temporarily override the credential manager spy to return null token
+  credManagerLoadSpy?.mockResolvedValue({
+    token: null,
+    current_guild: null,
+    guilds: {},
+  })
 
   const consoleSpy = mock((_msg: string) => {})
   const originalLog = console.log

package/src/platforms/discord/commands/user.ts

@@ -3,6 +3,7 @@ import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import type { DiscordUser } from '../types'
 
 async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -56,7 +57,17 @@ async function infoAction(userId: string, options: { pretty?: boolean }): Promis
     }
 
     const client = new DiscordClient(config.token)
-    const user = await client.getUser(userId)
+
+    // Check if requesting current user - use @me endpoint (works with user tokens)
+    const me = await client.testAuth()
+    let user: DiscordUser
+
+    if (userId === me.id) {
+      user = me
+    } else {
+      // For other users, try the regular endpoint (requires bot token)
+      user = await client.getUser(userId)
+    }
 
     const output = {
       id: user.id,