agent-messenger 1.0.0 → 1.2.0

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

@@ -9,7 +9,7 @@ export async function listAction(options: { pretty?: boolean }): Promise<void> {
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
 
-    if (!config.token || !config.current_guild) {
+    if (!config.token || !config.current_server) {
       console.log(
         formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
       )
@@ -17,7 +17,7 @@ export async function listAction(options: { pretty?: boolean }): Promise<void> {
     }
 
     const client = new DiscordClient(config.token)
-    const channels = await client.listChannels(config.current_guild)
+    const channels = await client.listChannels(config.current_server)
 
     const textChannels = channels.filter((ch) => ch.type === 0)
 
@@ -54,7 +54,7 @@ export async function infoAction(channelId: string, options: { pretty?: boolean
       id: channel.id,
       name: channel.name,
       type: channel.type,
-      guild_id: channel.guild_id,
+      server_id: channel.guild_id,
       topic: channel.topic || null,
       parent_id: (channel as any).parent_id || null,
     }
@@ -101,7 +101,7 @@ export const channelCommand = new Command('channel')
   .description('Channel commands')
   .addCommand(
     new Command('list')
-      .description('List channels in current guild')
+      .description('List channels in current server')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction)
   )

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

@@ -0,0 +1,146 @@
+import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import type { DiscordDMChannel } from '../types'
+import { createAction, listAction } from './dm'
+
+let clientListDMChannelsSpy: ReturnType<typeof spyOn>
+let clientCreateDMSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+const mockChannels: DiscordDMChannel[] = [
+  {
+    id: '123',
+    type: 1,
+    recipients: [
+      {
+        id: '456',
+        username: 'testuser',
+      },
+    ],
+  },
+  {
+    id: '789',
+    type: 3,
+    name: 'Group Chat',
+    recipients: [
+      {
+        id: '111',
+        username: 'user1',
+      },
+      {
+        id: '222',
+        username: 'user2',
+      },
+    ],
+  },
+]
+
+beforeEach(() => {
+  clientListDMChannelsSpy = spyOn(DiscordClient.prototype, 'listDMChannels').mockResolvedValue(
+    mockChannels
+  )
+
+  clientCreateDMSpy = spyOn(DiscordClient.prototype, 'createDM').mockResolvedValue({
+    id: '999',
+    type: 1,
+    recipients: [
+      {
+        id: '456',
+        username: 'newuser',
+      },
+    ],
+  })
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: null,
+    servers: {},
+  })
+})
+
+afterEach(() => {
+  clientListDMChannelsSpy?.mockRestore()
+  clientCreateDMSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+describe('dm commands', () => {
+  describe('listAction', () => {
+    it('should list DM channels', async () => {
+      const consoleSpy = mock(() => {})
+      const originalLog = console.log
+      console.log = consoleSpy
+
+      await listAction({ pretty: false })
+
+      console.log = originalLog
+
+      expect(consoleSpy).toHaveBeenCalled()
+      expect(clientListDMChannelsSpy).toHaveBeenCalled()
+    })
+
+    it('should handle authentication error', async () => {
+      credManagerLoadSpy.mockResolvedValue({
+        token: '',
+        current_server: null,
+        servers: {},
+      })
+
+      const exitSpy = mock(() => {})
+      const originalExit = process.exit
+      process.exit = exitSpy as any
+
+      const consoleSpy = mock(() => {})
+      const originalLog = console.log
+      console.log = consoleSpy
+
+      await listAction({ pretty: false })
+
+      console.log = originalLog
+      process.exit = originalExit
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+  })
+
+  describe('createAction', () => {
+    it('should create a DM channel', async () => {
+      const consoleSpy = mock(() => {})
+      const originalLog = console.log
+      console.log = consoleSpy
+
+      await createAction('456', { pretty: false })
+
+      console.log = originalLog
+
+      expect(consoleSpy).toHaveBeenCalled()
+      expect(clientCreateDMSpy).toHaveBeenCalledWith('456')
+    })
+
+    it('should handle authentication error', async () => {
+      credManagerLoadSpy.mockResolvedValue({
+        token: '',
+        current_server: null,
+        servers: {},
+      })
+
+      const exitSpy = mock(() => {})
+      const originalExit = process.exit
+      process.exit = exitSpy as any
+
+      const consoleSpy = mock(() => {})
+      const originalLog = console.log
+      console.log = consoleSpy
+
+      await createAction('456', { pretty: false })
+
+      console.log = originalLog
+      process.exit = originalExit
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+  })
+})

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

@@ -0,0 +1,85 @@
+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'
+import type { DiscordDMChannel } from '../types'
+
+export async function listAction(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 channels = await client.listDMChannels()
+
+    const output = channels.map((channel: DiscordDMChannel) => ({
+      id: channel.id,
+      type: channel.type === 1 ? 'DM' : 'Group DM',
+      name: channel.name || null,
+      recipients: channel.recipients.map((user) => ({
+        id: user.id,
+        username: user.username,
+      })),
+      last_message_id: channel.last_message_id || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function createAction(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 channel = await client.createDM(userId)
+
+    const output = {
+      id: channel.id,
+      type: channel.type === 1 ? 'DM' : 'Group DM',
+      name: channel.name || null,
+      recipients: channel.recipients.map((user) => ({
+        id: user.id,
+        username: user.username,
+      })),
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const dmCommand = new Command('dm')
+  .description('DM channel commands')
+  .addCommand(
+    new Command('list')
+      .description('List DM channels')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('create')
+      .description('Create a DM channel')
+      .argument('<user-id>', 'User ID to create DM with')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction)
+  )

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_server: 'server_123',
+    servers: {},
+  })
+})
 
-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/friend.test.ts

@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientGetRelationshipsSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientGetRelationshipsSpy = spyOn(DiscordClient.prototype, 'getRelationships').mockResolvedValue([
+    {
+      id: 'rel-1',
+      type: 1,
+      user: {
+        id: 'user-1',
+        username: 'alice',
+        global_name: 'Alice Smith',
+        avatar: 'avatar-hash-1',
+      },
+      nickname: 'Ally',
+    },
+    {
+      id: 'rel-2',
+      type: 1,
+      user: {
+        id: 'user-2',
+        username: 'bob',
+        global_name: 'Bob Jones',
+        avatar: 'avatar-hash-2',
+      },
+    },
+    {
+      id: 'rel-3',
+      type: 3,
+      user: {
+        id: 'user-3',
+        username: 'charlie',
+        global_name: 'Charlie Brown',
+        avatar: 'avatar-hash-3',
+      },
+    },
+    {
+      id: 'rel-4',
+      type: 2,
+      user: {
+        id: 'user-4',
+        username: 'blocked_user',
+        avatar: 'avatar-hash-4',
+      },
+    },
+  ])
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: null,
+    servers: {},
+  })
+})
+
+afterEach(() => {
+  clientGetRelationshipsSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+test('list: returns all relationships', async () => {
+  // given: discord client with relationships
+  const client = new DiscordClient('test-token')
+  const relationships = await client.getRelationships()
+
+  // when: getting all relationships
+  expect(relationships).toBeDefined()
+
+  // then: all relationships are returned
+  expect(relationships).toHaveLength(4)
+})
+
+test('list: includes relationship metadata', async () => {
+  // given: discord client with relationships
+  const client = new DiscordClient('test-token')
+  const relationships = await client.getRelationships()
+
+  // when: checking relationship properties
+  const relationship = relationships[0]
+
+  // then: relationship has id, type, user
+  expect(relationship.id).toBeDefined()
+  expect(relationship.type).toBeDefined()
+  expect(relationship.user).toBeDefined()
+  expect(relationship.user.id).toBeDefined()
+  expect(relationship.user.username).toBeDefined()
+})
+
+test('list: filters friends (type=1)', async () => {
+  // given: discord client with relationships
+  const client = new DiscordClient('test-token')
+  const relationships = await client.getRelationships()
+
+  // when: filtering friends
+  const friends = relationships.filter((r) => r.type === 1)
+
+  // then: only friends are returned
+  expect(friends).toHaveLength(2)
+  expect(friends[0].user.username).toBe('alice')
+  expect(friends[1].user.username).toBe('bob')
+})
+
+test('list: includes optional nickname', async () => {
+  // given: discord client with relationships
+  const client = new DiscordClient('test-token')
+  const relationships = await client.getRelationships()
+
+  // when: checking for nickname
+  const withNickname = relationships.find((r) => r.nickname)
+  const withoutNickname = relationships.find((r) => !r.nickname && r.type === 1)
+
+  // then: nickname is optional
+  expect(withNickname?.nickname).toBe('Ally')
+  expect(withoutNickname?.nickname).toBeUndefined()
+})
+
+test('list: distinguishes relationship types', async () => {
+  // given: discord client with relationships
+  const client = new DiscordClient('test-token')
+  const relationships = await client.getRelationships()
+
+  // when: grouping by type
+  const friends = relationships.filter((r) => r.type === 1)
+  const blocked = relationships.filter((r) => r.type === 2)
+  const incoming = relationships.filter((r) => r.type === 3)
+
+  // then: types are correctly identified
+  expect(friends).toHaveLength(2)
+  expect(blocked).toHaveLength(1)
+  expect(incoming).toHaveLength(1)
+})

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

@@ -0,0 +1,45 @@
+import { Command } from 'commander'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+export const friendCommand = new Command('friend')
+  .description('Manage Discord relationships (friends)')
+  .addCommand(
+    new Command('list')
+      .description('List all relationships')
+      .option('--pretty', 'Pretty print output')
+      .action(async (options) => {
+        const credManager = new DiscordCredentialManager()
+        const config = await credManager.load()
+
+        if (!config.token) {
+          throw new Error('No Discord token found. Run auth extract first.')
+        }
+
+        const client = new DiscordClient(config.token)
+
+        const relationships = await client.getRelationships()
+
+        if (options.pretty) {
+          const typeNames: Record<number, string> = {
+            1: 'Friend',
+            2: 'Blocked',
+            3: 'Incoming Request',
+            4: 'Outgoing Request',
+          }
+
+          console.log(`\nRelationships (${relationships.length}):\n`)
+          for (const rel of relationships) {
+            const displayName = rel.user.global_name || rel.user.username
+            const nickname = rel.nickname ? ` (${rel.nickname})` : ''
+            const type = typeNames[rel.type] || `Type ${rel.type}`
+            console.log(`  ${displayName}${nickname} - ${type}`)
+            console.log(`    ID: ${rel.user.id}`)
+            console.log(`    Username: ${rel.user.username}`)
+            console.log()
+          }
+        } else {
+          console.log(JSON.stringify(relationships, null, 2))
+        }
+      })
+  )

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

@@ -1,8 +1,8 @@
 export { authCommand } from './auth'
 export { channelCommand } from './channel'
 export { fileCommand } from './file'
-export { guildCommand } from './guild'
 export { messageCommand } from './message'
 export { reactionCommand } from './reaction'
+export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
 export { userCommand } from './user'

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

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientSearchMembersSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientSearchMembersSpy = spyOn(DiscordClient.prototype, 'searchMembers').mockResolvedValue([
+    {
+      user: {
+        id: 'user-1',
+        username: 'alice',
+        global_name: 'Alice Smith',
+        avatar: 'avatar-hash-1',
+        bot: false,
+      },
+      nick: 'AliceNick',
+      roles: ['role-1', 'role-2'],
+      joined_at: '2024-01-15T10:00:00Z',
+      deaf: false,
+      mute: false,
+      flags: 0,
+    },
+    {
+      user: {
+        id: 'user-2',
+        username: 'alice_bot',
+        global_name: 'Alice Bot',
+        avatar: 'avatar-hash-2',
+        bot: true,
+      },
+      nick: undefined,
+      roles: ['role-3'],
+      joined_at: '2024-02-20T15:30:00Z',
+      deaf: false,
+      mute: false,
+      flags: 0,
+    },
+  ])
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'guild-1',
+    servers: {
+      'guild-1': { server_id: 'guild-1', server_name: 'Test Guild' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientSearchMembersSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+test('search: returns members matching query', async () => {
+  const client = new DiscordClient('test-token')
+  const members = await client.searchMembers('guild-1', 'alice', 10)
+
+  expect(members).toBeDefined()
+  expect(members).toHaveLength(2)
+  expect(members[0].user.username).toBe('alice')
+  expect(members[1].user.username).toBe('alice_bot')
+})
+
+test('search: includes member metadata', async () => {
+  const client = new DiscordClient('test-token')
+  const members = await client.searchMembers('guild-1', 'alice', 10)
+
+  const member = members[0]
+
+  expect(member.user).toBeDefined()
+  expect(member.user.id).toBe('user-1')
+  expect(member.user.username).toBe('alice')
+  expect(member.user.global_name).toBe('Alice Smith')
+  expect(member.nick).toBe('AliceNick')
+  expect(member.roles).toEqual(['role-1', 'role-2'])
+  expect(member.joined_at).toBe('2024-01-15T10:00:00Z')
+  expect(member.deaf).toBe(false)
+  expect(member.mute).toBe(false)
+  expect(member.flags).toBe(0)
+})
+
+test('search: respects limit parameter', async () => {
+  const client = new DiscordClient('test-token')
+
+  await client.searchMembers('guild-1', 'alice', 5)
+
+  expect(clientSearchMembersSpy).toHaveBeenCalledWith('guild-1', 'alice', 5)
+})
+
+test('search: uses default limit of 10', async () => {
+  const client = new DiscordClient('test-token')
+
+  const members = await client.searchMembers('guild-1', 'alice')
+
+  expect(members).toHaveLength(2)
+})