agent-messenger 1.0.0 → 1.2.0

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

@@ -0,0 +1,73 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+async function getAction(userId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const note = await client.getUserNote(userId)
+
+    if (note === null) {
+      console.log(formatOutput({ note: null }, options.pretty))
+    } else {
+      console.log(formatOutput(note, options.pretty))
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function setAction(
+  userId: string,
+  note: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const result = await client.setUserNote(userId, note)
+
+    console.log(formatOutput(result, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const noteCommand = new Command('note')
+  .description('User note commands')
+  .addCommand(
+    new Command('get')
+      .description('Get note for a user')
+      .argument('<user-id>', 'User ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction)
+  )
+  .addCommand(
+    new Command('set')
+      .description('Set note for a user')
+      .argument('<user-id>', 'User ID')
+      .argument('<note>', 'Note content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(setAction)
+  )

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

@@ -0,0 +1,107 @@
+import { expect, mock, test } from 'bun:test'
+
+// Mock DiscordClient
+const mockClient = {
+  getUserProfile: mock(async (userId: string) => ({
+    user: {
+      id: userId,
+      username: 'testuser',
+      global_name: 'Test User',
+      avatar: 'avatar_hash',
+      bot: false,
+      bio: 'This is my bio',
+    },
+    connected_accounts: [
+      {
+        type: 'github',
+        id: 'github123',
+        name: 'testuser',
+        verified: true,
+      },
+      {
+        type: 'twitter',
+        id: 'twitter456',
+        name: '@testuser',
+        verified: false,
+      },
+    ],
+    premium_since: '2024-01-15T10:30:00.000Z',
+    mutual_guilds: [
+      {
+        id: 'guild1',
+        nick: 'TestNick',
+      },
+      {
+        id: 'guild2',
+      },
+    ],
+  })),
+}
+
+test('get returns user profile with all fields', async () => {
+  // given: user id
+  const userId = 'user123'
+
+  // when: getting user profile
+  const profile = await mockClient.getUserProfile(userId)
+
+  // then: returns complete profile
+  expect(profile.user.id).toBe('user123')
+  expect(profile.user.username).toBe('testuser')
+  expect(profile.user.bio).toBe('This is my bio')
+  expect(profile.connected_accounts).toHaveLength(2)
+  expect(profile.connected_accounts[0].type).toBe('github')
+  expect(profile.connected_accounts[0].verified).toBe(true)
+  expect(profile.premium_since).toBe('2024-01-15T10:30:00.000Z')
+  expect(profile.mutual_guilds).toHaveLength(2)
+  expect(profile.mutual_guilds?.[0].nick).toBe('TestNick')
+})
+
+test('get returns profile with minimal fields', async () => {
+  // given: mock with minimal profile
+  const minimalMock = {
+    getUserProfile: mock(async (userId: string) => ({
+      user: {
+        id: userId,
+        username: 'minimaluser',
+        global_name: 'Minimal User',
+      },
+      connected_accounts: [],
+    })),
+  }
+
+  // when: getting minimal profile
+  const profile = await minimalMock.getUserProfile('user456')
+
+  // then: returns profile without optional fields
+  expect(profile.user.id).toBe('user456')
+  expect(profile.user.bio).toBeUndefined()
+  expect(profile.connected_accounts).toHaveLength(0)
+  expect(profile.premium_since).toBeUndefined()
+  expect(profile.mutual_guilds).toBeUndefined()
+})
+
+test('get formats connected accounts correctly', async () => {
+  // given: user with connected accounts
+  const userId = 'user789'
+  const profile = await mockClient.getUserProfile(userId)
+
+  // when: extracting connected accounts
+  const accounts = profile.connected_accounts.map((acc) => ({
+    type: acc.type,
+    name: acc.name,
+    verified: acc.verified,
+  }))
+
+  // then: accounts are properly formatted
+  expect(accounts[0]).toEqual({
+    type: 'github',
+    name: 'testuser',
+    verified: true,
+  })
+  expect(accounts[1]).toEqual({
+    type: 'twitter',
+    name: '@testuser',
+    verified: false,
+  })
+})

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

@@ -0,0 +1,55 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+async function getAction(userId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const profile = await client.getUserProfile(userId)
+
+    const output = {
+      user: {
+        id: profile.user.id,
+        username: profile.user.username,
+        global_name: profile.user.global_name,
+        avatar: profile.user.avatar,
+        bot: profile.user.bot,
+        bio: profile.user.bio,
+      },
+      connected_accounts: profile.connected_accounts.map((acc) => ({
+        type: acc.type,
+        id: acc.id,
+        name: acc.name,
+        verified: acc.verified,
+      })),
+      premium_since: profile.premium_since,
+      mutual_guilds: profile.mutual_guilds,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const profileCommand = new Command('profile')
+  .description('User profile commands')
+  .addCommand(
+    new Command('get')
+      .description('Get user profile')
+      .argument('<user-id>', 'User ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction)
+  )

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_server: null,
+    servers: {},
+  })
+})
+
+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_server: null,
+    servers: {},
+  })
 
   const consoleSpy = mock((_msg: string) => {})
   const originalLog = console.log

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

@@ -0,0 +1,137 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientListServersSpy: ReturnType<typeof spyOn>
+let clientGetServerSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+let credManagerSetCurrentServerSpy: ReturnType<typeof spyOn>
+let credManagerGetCurrentServerSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientListServersSpy = spyOn(DiscordClient.prototype, 'listServers').mockResolvedValue([
+    { id: 'server-1', name: 'Server One', icon: 'icon1', owner: true },
+    { id: 'server-2', name: 'Server Two', icon: 'icon2', owner: false },
+  ])
+
+  clientGetServerSpy = spyOn(DiscordClient.prototype, 'getServer').mockImplementation(
+    async (serverId: string) => {
+      if (serverId === 'server-1') {
+        return { id: 'server-1', name: 'Server One', icon: 'icon1', owner: true }
+      }
+      if (serverId === 'server-2') {
+        return { id: 'server-2', name: 'Server Two', icon: 'icon2', owner: false }
+      }
+      throw new Error('Server not found')
+    }
+  )
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'server-1',
+    servers: {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+      'server-2': { server_id: 'server-2', server_name: 'Server Two' },
+    },
+  })
+
+  credManagerSetCurrentServerSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'setCurrentServer'
+  ).mockResolvedValue(undefined)
+
+  credManagerGetCurrentServerSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'getCurrentServer'
+  ).mockResolvedValue('server-1')
+})
+
+afterEach(() => {
+  clientListServersSpy?.mockRestore()
+  clientGetServerSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  credManagerSetCurrentServerSpy?.mockRestore()
+  credManagerGetCurrentServerSpy?.mockRestore()
+})
+
+test('list: returns servers with current marker', async () => {
+  // given: credential manager with servers
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+
+  // when: list action is called
+  expect(config.servers).toBeDefined()
+  expect(Object.keys(config.servers)).toHaveLength(2)
+
+  // then: servers are returned
+  expect(config.servers['server-1']).toBeDefined()
+  expect(config.servers['server-2']).toBeDefined()
+})
+
+test('list: marks current server', async () => {
+  // given: credential manager with current server set
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+  const current = await credManager.getCurrentServer()
+
+  // when: checking current server
+  expect(current).toBe('server-1')
+
+  // then: current server is marked
+  expect(config.current_server).toBe('server-1')
+})
+
+test('info: returns server details', async () => {
+  // given: discord client with server data
+  const client = new DiscordClient('test-token')
+  const server = await client.getServer('server-1')
+
+  // when: getting server info
+  expect(server).toBeDefined()
+
+  // then: server details are returned
+  expect(server.id).toBe('server-1')
+  expect(server.name).toBe('Server One')
+  expect(server.icon).toBe('icon1')
+  expect(server.owner).toBe(true)
+})
+
+test('info: throws error for non-existent server', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: getting non-existent server
+  // then: error is thrown
+  try {
+    await client.getServer('non-existent')
+    expect(true).toBe(false) // should not reach here
+  } catch (error) {
+    expect((error as Error).message).toContain('Server not found')
+  }
+})
+
+test('switch: updates current server', async () => {
+  // given: credential manager
+  const credManager = new DiscordCredentialManager()
+
+  // when: switching server
+  await credManager.setCurrentServer('server-2')
+
+  // then: setCurrentServer is called
+  expect(credManager.setCurrentServer).toHaveBeenCalledWith('server-2')
+})
+
+test('current: returns current server info', async () => {
+  // given: credential manager with current server
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+
+  // when: getting current server
+  const current = await credManager.getCurrentServer()
+
+  // then: current server is returned
+  expect(current).toBe('server-1')
+  expect(config.current_server).toBe('server-1')
+})

package/src/platforms/discord/commands/{guild.ts → server.ts}

@@ -8,12 +8,12 @@ export async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
-    const guilds = Object.values(config.guilds)
+    const servers = Object.values(config.servers)
 
-    const output = guilds.map((guild) => ({
-      id: guild.guild_id,
-      name: guild.guild_name,
-      current: guild.guild_id === config.current_guild,
+    const output = servers.map((server) => ({
+      id: server.server_id,
+      name: server.server_name,
+      current: server.server_id === config.current_server,
     }))
 
     console.log(formatOutput(output, options.pretty))
@@ -22,7 +22,7 @@ export async function listAction(options: { pretty?: boolean }): Promise<void> {
   }
 }
 
-export async function infoAction(guildId: string, options: { pretty?: boolean }): Promise<void> {
+export async function infoAction(serverId: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
@@ -35,13 +35,13 @@ export async function infoAction(guildId: string, options: { pretty?: boolean })
     }
 
     const client = new DiscordClient(config.token)
-    const guild = await client.getGuild(guildId)
+    const server = await client.getServer(serverId)
 
     const output = {
-      id: guild.id,
-      name: guild.name,
-      icon: guild.icon,
-      owner: guild.owner,
+      id: server.id,
+      name: server.name,
+      icon: server.icon,
+      owner: server.owner,
     }
 
     console.log(formatOutput(output, options.pretty))
@@ -50,18 +50,18 @@ export async function infoAction(guildId: string, options: { pretty?: boolean })
   }
 }
 
-export async function switchAction(guildId: string, options: { pretty?: boolean }): Promise<void> {
+export async function switchAction(serverId: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
 
-    if (!config.guilds[guildId]) {
-      console.log(formatOutput({ error: `Guild not found: ${guildId}` }, options.pretty))
+    if (!config.servers[serverId]) {
+      console.log(formatOutput({ error: `Server not found: ${serverId}` }, options.pretty))
       process.exit(1)
     }
 
-    await credManager.setCurrentGuild(guildId)
-    console.log(formatOutput({ current: guildId }, options.pretty))
+    await credManager.setCurrentServer(serverId)
+    console.log(formatOutput({ current: serverId }, options.pretty))
   } catch (error) {
     handleError(error as Error)
   }
@@ -72,25 +72,25 @@ export async function currentAction(options: { pretty?: boolean }): Promise<void
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
 
-    if (!config.current_guild) {
+    if (!config.current_server) {
       console.log(
-        formatOutput({ error: 'No current guild set. Run "auth extract" first.' }, options.pretty)
+        formatOutput({ error: 'No current server set. Run "auth extract" first.' }, options.pretty)
       )
       process.exit(1)
     }
 
-    const guild = config.guilds[config.current_guild]
+    const server = config.servers[config.current_server]
 
-    if (!guild) {
+    if (!server) {
       console.log(
-        formatOutput({ error: 'Current guild not found in configuration.' }, options.pretty)
+        formatOutput({ error: 'Current server not found in configuration.' }, options.pretty)
       )
       process.exit(1)
     }
 
     const output = {
-      guild_id: guild.guild_id,
-      guild_name: guild.guild_name,
+      server_id: server.server_id,
+      server_name: server.server_name,
     }
 
     console.log(formatOutput(output, options.pretty))
@@ -99,31 +99,31 @@ export async function currentAction(options: { pretty?: boolean }): Promise<void
   }
 }
 
-export const guildCommand = new Command('guild')
-  .description('Guild management commands')
+export const serverCommand = new Command('server')
+  .description('Server management commands')
   .addCommand(
     new Command('list')
-      .description('List all guilds')
+      .description('List all servers')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction)
   )
   .addCommand(
     new Command('info')
-      .description('Get guild info')
-      .argument('<guild-id>', 'Guild ID')
+      .description('Get server info')
+      .argument('<server-id>', 'Server ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(infoAction)
   )
   .addCommand(
     new Command('switch')
-      .description('Switch to guild')
-      .argument('<guild-id>', 'Guild ID')
+      .description('Switch to server')
+      .argument('<server-id>', 'Server ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(switchAction)
   )
   .addCommand(
     new Command('current')
-      .description('Show current guild')
+      .description('Show current server')
       .option('--pretty', 'Pretty print JSON output')
       .action(currentAction)
   )

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

@@ -7,7 +7,7 @@ test('snapshot: command is defined', () => {
 })
 
 test('snapshot: command has correct description', () => {
-  expect(snapshotCommand.description()).toContain('guild state')
+  expect(snapshotCommand.description()).toContain('server state')
 })
 
 test('snapshot: command has --channels-only option', () => {