agent-messenger 1.0.0 → 1.2.0

package/src/platforms/discord/cli.ts

@@ -6,9 +6,9 @@ import {
   authCommand,
   channelCommand,
   fileCommand,
-  guildCommand,
   messageCommand,
   reactionCommand,
+  serverCommand,
   snapshotCommand,
   userCommand,
 } from './commands'
@@ -20,10 +20,10 @@ program
   .description('CLI tool for Discord communication')
   .version(pkg.version)
   .option('--pretty', 'Pretty-print JSON output')
-  .option('--guild <id>', 'Use specific guild')
+  .option('--server <id>', 'Use specific server')
 
 program.addCommand(authCommand)
-program.addCommand(guildCommand)
+program.addCommand(serverCommand)
 program.addCommand(channelCommand)
 program.addCommand(fileCommand)
 program.addCommand(messageCommand)

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

@@ -90,37 +90,37 @@ describe('DiscordClient', () => {
     })
   })
 
-  describe('listGuilds', () => {
-    test('returns list of guilds', async () => {
+  describe('listServers', () => {
+    test('returns list of servers', async () => {
       mockResponse([
-        { id: '111', name: 'Guild One' },
-        { id: '222', name: 'Guild Two' },
+        { id: '111', name: 'Server One' },
+        { id: '222', name: 'Server Two' },
       ])
 
       const client = new DiscordClient('test-token')
-      const guilds = await client.listGuilds()
+      const servers = await client.listServers()
 
-      expect(guilds).toHaveLength(2)
-      expect(guilds[0].name).toBe('Guild One')
+      expect(servers).toHaveLength(2)
+      expect(servers[0].name).toBe('Server One')
       expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/users/@me/guilds')
     })
   })
 
-  describe('getGuild', () => {
-    test('returns guild info', async () => {
-      mockResponse({ id: '111', name: 'Test Guild' })
+  describe('getServer', () => {
+    test('returns server info', async () => {
+      mockResponse({ id: '111', name: 'Test Server' })
 
       const client = new DiscordClient('test-token')
-      const guild = await client.getGuild('111')
+      const server = await client.getServer('111')
 
-      expect(guild.id).toBe('111')
-      expect(guild.name).toBe('Test Guild')
+      expect(server.id).toBe('111')
+      expect(server.name).toBe('Test Server')
       expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/111')
     })
   })
 
   describe('listChannels', () => {
-    test('returns list of channels for guild', async () => {
+    test('returns list of channels for server', async () => {
       mockResponse([
         { id: 'ch1', guild_id: '111', name: 'general', type: 0 },
         { id: 'ch2', guild_id: '111', name: 'random', type: 0 },
@@ -257,7 +257,7 @@ describe('DiscordClient', () => {
   })
 
   describe('listUsers', () => {
-    test('returns list of guild members', async () => {
+    test('returns list of server members', async () => {
       mockResponse([
         { user: { id: 'u1', username: 'user1' } },
         { user: { id: 'u2', username: 'user2' } },

package/src/platforms/discord/client.ts

@@ -1,9 +1,20 @@
+import { readFile } from 'node:fs/promises'
+import { getDiscordHeaders } from './super-properties'
 import type {
   DiscordChannel,
+  DiscordDMChannel,
   DiscordFile,
   DiscordGuild,
+  DiscordGuildMember,
+  DiscordMention,
   DiscordMessage,
+  DiscordRelationship,
+  DiscordSearchOptions,
+  DiscordSearchResponse,
+  DiscordSearchResult,
   DiscordUser,
+  DiscordUserNote,
+  DiscordUserProfile,
 } from './types'
 
 export class DiscordError extends Error {
@@ -99,10 +110,7 @@ export class DiscordClient {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       await this.waitForRateLimit(bucketKey)
 
-      const headers: Record<string, string> = {
-        Authorization: this.token,
-        'Content-Type': 'application/json',
-      }
+      const headers: Record<string, string> = getDiscordHeaders(this.token)
 
       const options: RequestInit = {
         method,
@@ -110,6 +118,7 @@ export class DiscordClient {
       }
 
       if (body !== undefined) {
+        headers['Content-Type'] = 'application/json'
         options.body = JSON.stringify(body)
       }
 
@@ -154,11 +163,10 @@ export class DiscordClient {
 
     await this.waitForRateLimit(bucketKey)
 
+    const headers = getDiscordHeaders(this.token)
     const response = await fetch(url, {
       method: 'POST',
-      headers: {
-        Authorization: this.token,
-      },
+      headers,
       body: formData,
     })
 
@@ -179,16 +187,16 @@ export class DiscordClient {
     return this.request<DiscordUser>('GET', '/users/@me')
   }
 
-  async listGuilds(): Promise<DiscordGuild[]> {
+  async listServers(): Promise<DiscordGuild[]> {
     return this.request<DiscordGuild[]>('GET', '/users/@me/guilds')
   }
 
-  async getGuild(guildId: string): Promise<DiscordGuild> {
-    return this.request<DiscordGuild>('GET', `/guilds/${guildId}`)
+  async getServer(serverId: string): Promise<DiscordGuild> {
+    return this.request<DiscordGuild>('GET', `/guilds/${serverId}`)
   }
 
-  async listChannels(guildId: string): Promise<DiscordChannel[]> {
-    return this.request<DiscordChannel[]>('GET', `/guilds/${guildId}/channels`)
+  async listChannels(serverId: string): Promise<DiscordChannel[]> {
+    return this.request<DiscordChannel[]>('GET', `/guilds/${serverId}/channels`)
   }
 
   async getChannel(channelId: string): Promise<DiscordChannel> {
@@ -227,13 +235,19 @@ export class DiscordClient {
     )
   }
 
-  async listUsers(guildId: string): Promise<DiscordUser[]> {
+  async ackMessage(channelId: string, messageId: string): Promise<void> {
+    return this.request<void>('POST', `/channels/${channelId}/messages/${messageId}/ack`, {
+      token: null,
+    })
+  }
+
+  async listUsers(serverId: string): Promise<DiscordUser[]> {
     interface GuildMember {
       user: DiscordUser
     }
     const members = await this.request<GuildMember[]>(
       'GET',
-      `/guilds/${guildId}/members?limit=1000`
+      `/guilds/${serverId}/members?limit=1000`
     )
     return members.map((m) => m.user)
   }
@@ -243,12 +257,11 @@ export class DiscordClient {
   }
 
   async uploadFile(channelId: string, filePath: string): Promise<DiscordFile> {
-    const file = Bun.file(filePath)
+    const fileBuffer = await readFile(filePath)
     const filename = filePath.split('/').pop() || 'file'
-    const blob = await file.arrayBuffer()
 
     const formData = new FormData()
-    formData.append('files[0]', new Blob([blob]), filename)
+    formData.append('files[0]', new Blob([fileBuffer]), filename)
 
     interface MessageWithAttachments extends DiscordMessage {
       attachments: DiscordFile[]
@@ -278,4 +291,137 @@ export class DiscordClient {
     }
     return files
   }
+
+  async listDMChannels(): Promise<DiscordDMChannel[]> {
+    return this.request<DiscordDMChannel[]>('GET', '/users/@me/channels')
+  }
+
+  async createDM(userId: string): Promise<DiscordDMChannel> {
+    return this.request<DiscordDMChannel>('POST', '/users/@me/channels', {
+      recipient_id: userId,
+    })
+  }
+
+  async getMentions(options?: { limit?: number; guildId?: string }): Promise<DiscordMention[]> {
+    const params = new URLSearchParams()
+    params.set('limit', (options?.limit ?? 25).toString())
+    params.set('roles', 'true')
+    params.set('everyone', 'true')
+
+    if (options?.guildId) {
+      params.set('guild_id', options.guildId)
+    }
+
+    return this.request<DiscordMention[]>('GET', `/users/@me/mentions?${params.toString()}`)
+  }
+
+  async getUserNote(userId: string): Promise<DiscordUserNote | null> {
+    try {
+      return await this.request<DiscordUserNote>('GET', `/users/@me/notes/${userId}`)
+    } catch (error) {
+      if (error instanceof DiscordError && error.code === 'http_404') {
+        return null
+      }
+      throw error
+    }
+  }
+
+  async setUserNote(userId: string, note: string): Promise<DiscordUserNote> {
+    return this.request<DiscordUserNote>('PUT', `/users/@me/notes/${userId}`, { note })
+  }
+
+  async getRelationships(): Promise<DiscordRelationship[]> {
+    return this.request<DiscordRelationship[]>('GET', '/users/@me/relationships')
+  }
+
+  async searchMembers(
+    guildId: string,
+    query: string,
+    limit: number = 10
+  ): Promise<DiscordGuildMember[]> {
+    const params = new URLSearchParams()
+    params.set('query', query)
+    params.set('limit', limit.toString())
+
+    return this.request<DiscordGuildMember[]>(
+      'GET',
+      `/guilds/${guildId}/members/search?${params.toString()}`
+    )
+  }
+
+  async searchMessages(
+    guildId: string,
+    query: string,
+    options: DiscordSearchOptions = {}
+  ): Promise<{ results: DiscordSearchResult[]; total: number }> {
+    const params = new URLSearchParams()
+    params.set('content', query)
+
+    if (options.channelId) {
+      params.set('channel_id', options.channelId)
+    }
+    if (options.authorId) {
+      params.set('author_id', options.authorId)
+    }
+    if (options.has) {
+      params.set('has', options.has)
+    }
+    if (options.sortBy) {
+      params.set('sort_by', options.sortBy)
+    }
+    if (options.sortOrder) {
+      params.set('sort_order', options.sortOrder)
+    }
+    if (options.limit !== undefined) {
+      params.set('limit', Math.max(1, Math.min(options.limit, 25)).toString())
+    }
+    if (options.offset !== undefined) {
+      params.set('offset', options.offset.toString())
+    }
+
+    const response = await this.request<DiscordSearchResponse>(
+      'GET',
+      `/guilds/${guildId}/messages/search?${params.toString()}`
+    )
+
+    const results = response.messages
+      .flat()
+      .filter((msg) => msg.hit)
+      .map((msg) => ({
+        id: msg.id,
+        channel_id: msg.channel_id,
+        guild_id: msg.guild_id,
+        content: msg.content,
+        author: msg.author,
+        timestamp: msg.timestamp,
+        hit: msg.hit,
+      }))
+
+    return {
+      results,
+      total: response.total_results,
+    }
+  }
+
+  async getUserProfile(userId: string): Promise<DiscordUserProfile> {
+    return this.request<DiscordUserProfile>('GET', `/users/${userId}/profile`)
+  }
+
+  async createThread(
+    channelId: string,
+    name: string,
+    options?: {
+      auto_archive_duration?: number
+      rate_limit_per_user?: number
+    }
+  ): Promise<DiscordChannel> {
+    return this.request<DiscordChannel>('POST', `/channels/${channelId}/threads`, {
+      name,
+      ...options,
+    })
+  }
+
+  async archiveThread(threadId: string, archived: boolean = true): Promise<DiscordChannel> {
+    return this.request<DiscordChannel>('PATCH', `/channels/${threadId}`, { archived })
+  }
 }

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 clientListServersSpy: 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',
+  })
+
+  clientListServersSpy = spyOn(DiscordClient.prototype, 'listServers').mockResolvedValue([
+    { id: 'server-1', name: 'Server One' },
+    { id: 'server-2', name: 'Server Two' },
+  ])
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: null,
+    current_server: null,
+    servers: {},
+  })
+
+  credManagerSaveSpy = spyOn(DiscordCredentialManager.prototype, 'save').mockResolvedValue(
+    undefined
+  )
+
+  credManagerClearTokenSpy = spyOn(
+    DiscordCredentialManager.prototype,
+    'clearToken'
+  ).mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  extractorExtractSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  clientListServersSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  credManagerSaveSpy?.mockRestore()
+  credManagerClearTokenSpy?.mockRestore()
+})
 
 test('extract: calls DiscordTokenExtractor', async () => {
   const extractor = new DiscordTokenExtractor()
@@ -51,11 +67,11 @@ test('extract: validates token with DiscordClient', async () => {
   expect(authInfo.id).toBe('user-123')
 })
 
-test('extract: discovers guilds', async () => {
+test('extract: discovers servers', async () => {
   const client = new DiscordClient('test-token-123')
-  const guilds = await client.listGuilds()
-  expect(guilds).toHaveLength(2)
-  expect(guilds[0].id).toBe('guild-1')
+  const servers = await client.listServers()
+  expect(servers).toHaveLength(2)
+  expect(servers[0].id).toBe('server-1')
 })
 
 test('logout: clears credentials', async () => {
@@ -68,5 +84,5 @@ test('status: returns auth state', async () => {
   const credManager = new DiscordCredentialManager()
   const config = await credManager.load()
   expect(config.token).toBeNull()
-  expect(config.current_guild).toBeNull()
+  expect(config.current_server).toBeNull()
 })

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

@@ -61,20 +61,20 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
 
       if (options.debug) {
         console.error(`[debug] ✓ Token valid for user: ${authInfo.username}`)
-        console.error(`[debug] Discovering guilds...`)
+        console.error(`[debug] Discovering servers...`)
       }
 
-      const guilds = await client.listGuilds()
+      const servers = await client.listServers()
 
       if (options.debug) {
-        console.error(`[debug] ✓ Found ${guilds.length} guild(s)`)
+        console.error(`[debug] ✓ Found ${servers.length} server(s)`)
       }
 
-      if (guilds.length === 0) {
+      if (servers.length === 0) {
         console.log(
           formatOutput(
             {
-              error: 'No guilds found. Make sure you are a member of at least one Discord server.',
+              error: 'No servers found. Make sure you are a member of at least one Discord server.',
             },
             options.pretty
           )
@@ -83,19 +83,19 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       }
 
       const credManager = new DiscordCredentialManager()
-      const guildMap: Record<string, { guild_id: string; guild_name: string }> = {}
+      const serverMap: Record<string, { server_id: string; server_name: string }> = {}
 
-      for (const guild of guilds) {
-        guildMap[guild.id] = {
-          guild_id: guild.id,
-          guild_name: guild.name,
+      for (const server of servers) {
+        serverMap[server.id] = {
+          server_id: server.id,
+          server_name: server.name,
         }
       }
 
       const config = {
         token: extracted.token,
-        current_guild: guilds[0].id,
-        guilds: guildMap,
+        current_server: servers[0].id,
+        servers: serverMap,
       }
 
       await credManager.save(config)
@@ -105,8 +105,8 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       }
 
       const output = {
-        guilds: guilds.map((g) => `${g.id}/${g.name}`),
-        current: guilds[0].id,
+        servers: servers.map((g) => `${g.id}/${g.name}`),
+        current: servers[0].id,
       }
 
       console.log(formatOutput(output, options.pretty))
@@ -173,8 +173,8 @@ export async function statusAction(options: { pretty?: boolean }): Promise<void>
     const output = {
       authenticated: valid,
       user: authInfo?.username,
-      current_guild: config.current_guild,
-      guilds_count: Object.keys(config.guilds).length,
+      current_server: config.current_server,
+      servers_count: Object.keys(config.servers).length,
     }
 
     console.log(formatOutput(output, options.pretty))

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,42 +36,47 @@ 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' },
-      },
-    })),
-  })),
-}))
-
-test('list: returns text channels (type=0) from guild', async () => {
+    }
+  )
+
+  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_server: 'server-1',
+    servers: {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientListChannelsSpy?.mockRestore()
+  clientGetChannelSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+test('list: returns text channels (type=0) from server', async () => {
   // given: discord client with channels
   const client = new DiscordClient('test-token')
-  const channels = await client.listChannels('guild-1')
+  const channels = await client.listChannels('server-1')
 
   // when: filtering text channels
   const textChannels = channels.filter((ch) => ch.type === 0)
@@ -78,7 +90,7 @@ test('list: returns text channels (type=0) from guild', async () => {
 test('list: includes channel metadata', async () => {
   // given: discord client with channels
   const client = new DiscordClient('test-token')
-  const channels = await client.listChannels('guild-1')
+  const channels = await client.listChannels('server-1')
   const textChannels = channels.filter((ch) => ch.type === 0)
 
   // when: checking channel properties