agent-messenger 2.29.1 → 2.31.0

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

@@ -246,6 +246,28 @@ describe('DiscordClient', () => {
     })
   })
 
+  describe('editMessage', () => {
+    it('edits message with PATCH', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: 'Updated content',
+        timestamp: '2024-01-01T00:00:00.000Z',
+        edited_timestamp: '2024-01-01T00:05:00.000Z',
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const message = await client.editMessage('ch1', 'msg1', 'Updated content')
+
+      expect(message.content).toBe('Updated content')
+      expect(message.edited_timestamp).toBe('2024-01-01T00:05:00.000Z')
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages/msg1')
+      expect(fetchCalls[0].options?.method).toBe('PATCH')
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Updated content' }))
+    })
+  })
+
   describe('deleteMessage', () => {
     it('deletes message', async () => {
       mockResponse(null, 204)
@@ -425,6 +447,127 @@ describe('DiscordClient', () => {
     })
   })
 
+  describe('searchMessages', () => {
+    const searchResult = {
+      id: 'msg1',
+      channel_id: 'ch1',
+      guild_id: 'guild1',
+      author: { id: 'user1', username: 'user1' },
+      content: 'matching message',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      hit: true,
+    }
+
+    it('flattens grouped search results and keeps hits', async () => {
+      mockResponse({
+        doing_deep_historical_index: false,
+        total_results: 1,
+        messages: [[searchResult, { ...searchResult, id: 'context', hit: false }]],
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const result = await client.searchMessages('guild1', 'matching', { limit: 25 })
+
+      expect(result).toEqual({ results: [searchResult], total: 1 })
+      expect(fetchCalls[0].url).toBe(
+        'https://discord.com/api/v10/guilds/guild1/messages/search?content=matching&limit=25',
+      )
+    })
+
+    it('retries when the search index is not ready', async () => {
+      mockResponse(
+        {
+          message: 'Index not yet available. Try again later',
+          code: 110000,
+          documents_indexed: 0,
+          retry_after: 0,
+        },
+        202,
+      )
+      mockResponse({
+        doing_deep_historical_index: false,
+        total_results: 1,
+        messages: [[searchResult]],
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const startTime = Date.now()
+      const result = await client.searchMessages('guild1', 'matching')
+      const elapsed = Date.now() - startTime
+
+      expect(result).toEqual({ results: [searchResult], total: 1 })
+      expect(elapsed).toBeGreaterThanOrEqual(50)
+      expect(fetchCalls).toHaveLength(2)
+    })
+
+    it('throws a clear error when the search index remains unavailable', async () => {
+      for (let attempt = 0; attempt < 4; attempt++) {
+        mockResponse(
+          {
+            message: 'Index not yet available. Try again later',
+            code: 110000,
+            documents_indexed: 0,
+            retry_after: 0.001,
+          },
+          202,
+        )
+      }
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+
+      await expect(client.searchMessages('guild1', 'matching')).rejects.toThrow(
+        'Search index is not ready after retries',
+      )
+      expect(fetchCalls).toHaveLength(4)
+    })
+
+    it('rejects unexpected successful response payloads', async () => {
+      mockResponse(
+        {
+          message: 'Unexpected response',
+          code: 999999,
+          retry_after: 0,
+        },
+        202,
+      )
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+
+      try {
+        await client.searchMessages('guild1', 'matching')
+        throw new Error('Expected searchMessages to throw')
+      } catch (error) {
+        expect(error).toBeInstanceOf(DiscordError)
+        if (!(error instanceof DiscordError)) throw error
+        expect(error.code).toBe('invalid_search_response')
+      }
+      expect(fetchCalls).toHaveLength(1)
+    })
+
+    it('rejects malformed message and retry payloads', async () => {
+      mockResponse({ total_results: 1, messages: null })
+      mockResponse(
+        {
+          message: 'Index not yet available. Try again later',
+          code: 110000,
+          documents_indexed: 0,
+          retry_after: -1,
+        },
+        202,
+      )
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+
+      await expect(client.searchMessages('guild1', 'matching')).rejects.toThrow(
+        'Discord returned an invalid search response',
+      )
+      await expect(client.searchMessages('guild1', 'matching')).rejects.toThrow(
+        'Discord returned an invalid search response',
+      )
+      expect(fetchCalls).toHaveLength(2)
+    })
+  })
+
   describe('rate limiting', () => {
     it('waits when bucket is exhausted before making request', async () => {
       mockResponse({ id: '1', username: 'user1' }, 200, {

package/src/platforms/discord/client.ts

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises'
 
 import { getDiscordHeaders } from './super-properties'
+import { DiscordSearchIndexNotReadyResponseSchema, DiscordSearchResponseSchema } from './types'
 import type {
   DiscordChannel,
   DiscordDMChannel,
@@ -11,7 +12,6 @@ import type {
   DiscordMessage,
   DiscordRelationship,
   DiscordSearchOptions,
-  DiscordSearchResponse,
   DiscordSearchResult,
   DiscordUser,
   DiscordUserNote,
@@ -37,6 +37,7 @@ interface RateLimitBucket {
 const BASE_URL = 'https://discord.com/api/v10'
 const MAX_RETRIES = 3
 const BASE_BACKOFF_MS = 100
+const MAX_SEARCH_INDEX_RETRY_MS = 30_000
 
 export class DiscordClient {
   private token: string | null = null
@@ -242,6 +243,10 @@ export class DiscordClient {
     return this.request<DiscordMessage>('GET', `/channels/${channelId}/messages/${messageId}`)
   }
 
+  async editMessage(channelId: string, messageId: string, content: string): Promise<DiscordMessage> {
+    return this.request<DiscordMessage>('PATCH', `/channels/${channelId}/messages/${messageId}`, { content })
+  }
+
   async deleteMessage(channelId: string, messageId: string): Promise<void> {
     return this.request<void>('DELETE', `/channels/${channelId}/messages/${messageId}`)
   }
@@ -389,28 +394,50 @@ export class DiscordClient {
       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,
+    const path = `/guilds/${guildId}/messages/search?${params.toString()}`
+
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const response: unknown = await this.request('GET', path)
+      const searchResponse = DiscordSearchResponseSchema.safeParse(response)
+
+      if (searchResponse.success) {
+        const results = searchResponse.data.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: searchResponse.data.total_results,
+        }
+      }
+
+      const indexNotReadyResponse = DiscordSearchIndexNotReadyResponseSchema.safeParse(response)
+      if (!indexNotReadyResponse.success) {
+        throw new DiscordError('Discord returned an invalid search response', 'invalid_search_response')
+      }
+
+      if (attempt === MAX_RETRIES) {
+        throw new DiscordError('Search index is not ready after retries', 'search_index_not_ready')
+      }
+
+      const requestedDelayMs = indexNotReadyResponse.data.retry_after * 1000
+      const retryDelayMs = Math.min(
+        requestedDelayMs === 0 ? BASE_BACKOFF_MS : requestedDelayMs,
+        MAX_SEARCH_INDEX_RETRY_MS,
+      )
+      await this.sleep(retryDelayMs)
     }
+
+    throw new DiscordError('Search failed after retries', 'max_retries')
   }
 
   async getUserProfile(userId: string): Promise<DiscordUserProfile> {

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

@@ -2,11 +2,12 @@ import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
-import { ackAction, deleteAction, getAction, listAction, searchAction, sendAction } from './message'
+import { ackAction, deleteAction, editAction, getAction, listAction, searchAction, sendAction } from './message'
 
 let clientSendMessageSpy: ReturnType<typeof spyOn>
 let clientGetMessagesSpy: ReturnType<typeof spyOn>
 let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientEditMessageSpy: ReturnType<typeof spyOn>
 let clientDeleteMessageSpy: ReturnType<typeof spyOn>
 let clientAckMessageSpy: ReturnType<typeof spyOn>
 let clientSearchMessagesSpy: ReturnType<typeof spyOn>
@@ -47,6 +48,15 @@ beforeEach(() => {
     timestamp: '2025-01-29T10:00:00Z',
   })
 
+  clientEditMessageSpy = spyOn(DiscordClient.prototype, 'editMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', username: 'testuser' },
+    content: 'Updated content',
+    timestamp: '2025-01-29T10:00:00Z',
+    edited_timestamp: '2025-01-29T10:05:00Z',
+  })
+
   clientDeleteMessageSpy = spyOn(DiscordClient.prototype, 'deleteMessage').mockResolvedValue(undefined)
 
   clientAckMessageSpy = spyOn(DiscordClient.prototype, 'ackMessage').mockResolvedValue(undefined)
@@ -87,6 +97,7 @@ afterEach(() => {
   clientSendMessageSpy?.mockRestore()
   clientGetMessagesSpy?.mockRestore()
   clientGetMessageSpy?.mockRestore()
+  clientEditMessageSpy?.mockRestore()
   clientDeleteMessageSpy?.mockRestore()
   clientAckMessageSpy?.mockRestore()
   clientSearchMessagesSpy?.mockRestore()
@@ -127,6 +138,20 @@ it('get: returns single message', async () => {
   expect(output).toContain('msg_123')
 })
 
+it('edit: returns updated message', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('ch_456', 'msg_123', 'Updated content', { pretty: false })
+
+  expect(clientEditMessageSpy).toHaveBeenCalledWith('ch_456', 'msg_123', 'Updated content')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('Updated content')
+  expect(output).toContain('edited_timestamp')
+})
+
 it('delete: returns success', async () => {
   const consoleSpy = mock((_msg: string) => {})
   console.log = consoleSpy

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

@@ -121,6 +121,38 @@ export async function deleteAction(
   }
 }
 
+export async function editAction(
+  channelId: string,
+  messageId: string,
+  content: 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 = await new DiscordClient().login({ token: config.token })
+    const message = await client.editMessage(channelId, messageId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      author: message.author.username,
+      timestamp: message.timestamp,
+      edited_timestamp: message.edited_timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export async function ackAction(channelId: string, messageId: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
@@ -244,6 +276,15 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(deleteAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a message')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<content>', 'New message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )
   .addCommand(
     new Command('ack')
       .description('Mark message as read (acknowledge)')

package/src/platforms/discord/types.ts

@@ -109,6 +109,15 @@ export interface DiscordSearchResponse {
   messages: DiscordSearchResult[][]
 }
 
+export interface DiscordSearchIndexNotReadyResponse {
+  message: string
+  code: 110000
+  documents_indexed: number
+  retry_after: number
+}
+
+export type DiscordSearchApiResponse = DiscordSearchResponse | DiscordSearchIndexNotReadyResponse
+
 export interface DiscordSearchOptions {
   channelId?: string
   authorId?: string
@@ -267,6 +276,13 @@ export const DiscordSearchResponseSchema = z.object({
   messages: z.array(z.array(DiscordSearchResultSchema)),
 })
 
+export const DiscordSearchIndexNotReadyResponseSchema = z.object({
+  message: z.string(),
+  code: z.literal(110000),
+  documents_indexed: z.number(),
+  retry_after: z.number().nonnegative(),
+})
+
 export const DiscordCredentialsSchema = z.object({
   token: z.string(),
 })

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

@@ -82,7 +82,7 @@ mock.module('../client', () => ({
 }))
 
 import { DiscordBotCredentialManager } from '../credential-manager'
-import { deleteAction, getAction, listAction, repliesAction, sendAction, updateAction } from './message'
+import { deleteAction, editAction, getAction, listAction, repliesAction, sendAction } from './message'
 
 describe('message commands', () => {
   let tempDir: string
@@ -243,9 +243,9 @@ describe('message commands', () => {
     })
   })
 
-  describe('updateAction', () => {
-    it('updates a message', async () => {
-      const result = await updateAction('general', 'msg1', 'updated text', { _credManager: manager })
+  describe('editAction', () => {
+    it('edits a message', async () => {
+      const result = await editAction('general', 'msg1', 'updated text', { _credManager: manager })
 
       expect(result.id).toBe('msg1')
       expect(result.content).toBe('updated text')
@@ -254,7 +254,7 @@ describe('message commands', () => {
     })
 
     it('resolves channel name', async () => {
-      await updateAction('general', 'msg1', 'new', { _credManager: manager })
+      await editAction('general', 'msg1', 'new', { _credManager: manager })
 
       expect(mockResolveChannel).toHaveBeenCalledWith('guild1', 'general')
     })
@@ -262,7 +262,7 @@ describe('message commands', () => {
     it('returns error on failure', async () => {
       mockEditMessage.mockImplementationOnce(() => Promise.reject(new Error('Cannot edit')))
 
-      const result = await updateAction('general', 'msg1', 'new', { _credManager: manager })
+      const result = await editAction('general', 'msg1', 'new', { _credManager: manager })
 
       expect(result.error).toContain('Cannot edit')
     })

package/src/platforms/discordbot/commands/message.ts

@@ -95,7 +95,7 @@ export async function getAction(channel: string, messageId: string, options: Bot
   }
 }
 
-export async function updateAction(
+export async function editAction(
   channel: string,
   messageId: string,
   text: string,
@@ -207,8 +207,8 @@ export const messageCommand = new Command('message')
       }),
   )
   .addCommand(
-    new Command('update')
-      .description('Update a message')
+    new Command('edit')
+      .description('Edit a message')
       .argument('<channel>', 'Channel ID or name')
       .argument('<message-id>', 'Message ID')
       .argument('<text>', 'New message text')
@@ -216,7 +216,7 @@ export const messageCommand = new Command('message')
       .option('--server <id>', 'Server ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(async (channel: string, messageId: string, text: string, opts: BotOption) => {
-        cliOutput(await updateAction(channel, messageId, text, opts), opts.pretty)
+        cliOutput(await editAction(channel, messageId, text, opts), opts.pretty)
       }),
   )
   .addCommand(