agent-messenger 2.29.0 → 2.30.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)

package/src/platforms/discord/client.ts

@@ -242,6 +242,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}`)
   }

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/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(

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

@@ -165,17 +165,17 @@ describe('Message Commands', () => {
     })
   })
 
-  describe('message update', () => {
-    it('updates message text', async () => {
+  describe('message edit', () => {
+    it('edits message text', async () => {
       // Given: A channel, message ts, and new text
       const channel = 'C123'
       const ts = '1234567890.123456'
       const newText = 'Updated message'
 
-      // When: Updating message
+      // When: Editing message
       const result = await mockClient.updateMessage(channel, ts, newText)
 
-      // Then: Should return updated message
+      // Then: Should return edited message
       expect(result.ts).toBe(ts)
       expect(result.text).toBe(newText)
     })

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

@@ -114,7 +114,7 @@ async function getAction(channelInput: string, ts: string, options: { pretty?: b
   }
 }
 
-async function updateAction(
+async function editAction(
   channelInput: string,
   ts: string,
   text: string,
@@ -413,13 +413,13 @@ export const messageCommand = new Command('message')
       .action(getAction),
   )
   .addCommand(
-    new Command('update')
-      .description('Update message text')
+    new Command('edit')
+      .description('Edit message text')
       .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .argument('<text>', 'New message text')
       .option('--pretty', 'Pretty print JSON output')
-      .action(updateAction),
+      .action(editAction),
   )
   .addCommand(
     new Command('delete')

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

@@ -59,7 +59,7 @@ async function getAction(channelInput: string, ts: string, options: BotOption):
   }
 }
 
-async function updateAction(channelInput: string, ts: string, text: string, options: BotOption): Promise<void> {
+async function editAction(channelInput: string, ts: string, text: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
     const channel = await client.resolveChannel(channelInput)
@@ -158,14 +158,14 @@ export const messageCommand = new Command('message')
       .action(getAction),
   )
   .addCommand(
-    new Command('update')
-      .description('Update a message')
+    new Command('edit')
+      .description('Edit a message')
       .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .argument('<text>', 'New message text')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
-      .action(updateAction),
+      .action(editAction),
   )
   .addCommand(
     new Command('delete')

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

@@ -330,6 +330,30 @@ describe('TeamsClient', () => {
     })
   })
 
+  describe('editChatMessage', () => {
+    it('PUTs an HTML-escaped edit to a chat message', async () => {
+      mockResponse({ edittime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const message = await client.editChatMessage('19:1on1@unq.gbl.spaces', 'msg1', 'a <b> & c')
+
+      expect(message.id).toBe('msg1')
+      expect(message.content).toBe('a <b> & c')
+      expect(fetchCalls[0].url).toBe(
+        'https://msgapi.teams.live.com/v1/users/ME/conversations/19%3A1on1%40unq.gbl.spaces/messages/msg1',
+      )
+      expect(fetchCalls[0].options?.method).toBe('PUT')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: 'a &lt;b&gt; &amp; c',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
+  })
+
   describe('getTeam', () => {
     it('returns team info', async () => {
       mockResponse({ id: '111', name: 'Test Team', description: 'A test team' })

package/src/platforms/teams/client.ts

@@ -589,6 +589,34 @@ export class TeamsClient {
     return Array.from(teamsMap.values())
   }
 
+  // Realtime messages only carry a conversation id; a channel's parent teamId
+  // (== groupId) lives on the conversation, so the listener resolves it through
+  // this channelId -> teamId map.
+  async buildChannelTeamMap(): Promise<Map<string, string>> {
+    interface Conversation {
+      id: string
+      threadProperties?: {
+        groupId?: string
+        productThreadType?: string
+        threadType?: string
+      }
+    }
+    interface ConversationsResponse {
+      conversations: Conversation[]
+    }
+    const data = await this.request<ConversationsResponse>('GET', '/users/ME/conversations')
+
+    const channelToTeam = new Map<string, string>()
+    for (const conv of data.conversations ?? []) {
+      const tp = conv.threadProperties
+      if (!tp?.groupId) continue
+      if (!tp.productThreadType?.includes('Teams') && tp.threadType !== 'space') continue
+      channelToTeam.set(conv.id, tp.groupId)
+    }
+
+    return channelToTeam
+  }
+
   async listChats(): Promise<TeamsChat[]> {
     interface ConversationMessage {
       content?: string
@@ -685,6 +713,34 @@ export class TeamsClient {
     }
   }
 
+  async editChatMessage(chatId: string, messageId: string, content: string): Promise<TeamsMessage> {
+    interface EditResponse {
+      edittime?: string | number
+    }
+    const encodedChatId = encodeURIComponent(chatId)
+    const encodedMessageId = encodeURIComponent(messageId)
+    // Skype messaging backend requires skypeeditedid to duplicate the URL message id.
+    const response = await this.request<EditResponse>(
+      'PUT',
+      `/users/ME/conversations/${encodedChatId}/messages/${encodedMessageId}`,
+      {
+        content: escapeHtml(content),
+        messagetype: 'RichText/Html',
+        contenttype: 'text',
+        skypeeditedid: messageId,
+      },
+    )
+
+    const editTime = response?.edittime
+    return {
+      id: messageId,
+      channel_id: chatId,
+      author: { id: 'ME', displayName: 'Me' },
+      content,
+      timestamp: editTime ? new Date(Number(editTime) || editTime).toISOString() : new Date().toISOString(),
+    }
+  }
+
   async getTeam(teamId: string): Promise<TeamsTeam> {
     return this.request<TeamsTeam>('GET', `/csa/api/v1/teams/${teamId}`, undefined, CSA_API_BASE)
   }

package/src/platforms/teams/commands/chat.test.ts

@@ -2,11 +2,12 @@ import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
-import { historyAction, listAction, sendAction } from './chat'
+import { editAction, historyAction, listAction, sendAction } from './chat'
 
 let clientListChatsSpy: ReturnType<typeof spyOn>
 let clientGetChatMessagesSpy: ReturnType<typeof spyOn>
 let clientSendChatMessageSpy: ReturnType<typeof spyOn>
+let clientEditChatMessageSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
 const originalConsoleLog = console.log
 
@@ -34,6 +35,14 @@ beforeEach(() => {
     timestamp: '2025-01-29T10:00:00Z',
   })
 
+  clientEditChatMessageSpy = spyOn(TeamsClient.prototype, 'editChatMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: '19:1on1@unq.gbl.spaces',
+    author: { id: 'ME', displayName: 'Me' },
+    content: 'Edited content',
+    timestamp: '2025-01-29T10:05:00Z',
+  })
+
   credManagerLoadSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
     current_account: 'personal',
     accounts: {
@@ -51,6 +60,7 @@ afterEach(() => {
   clientListChatsSpy?.mockRestore()
   clientGetChatMessagesSpy?.mockRestore()
   clientSendChatMessageSpy?.mockRestore()
+  clientEditChatMessageSpy?.mockRestore()
   credManagerLoadSpy?.mockRestore()
   console.log = originalConsoleLog
 })
@@ -98,3 +108,15 @@ it('send: returns sent message', async () => {
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Hello world')
 })
+
+it('edit: edits a chat message and returns updated content', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content', { pretty: false })
+
+  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('Edited content')
+})

package/src/platforms/teams/commands/chat.ts

@@ -100,6 +100,41 @@ export async function sendAction(chatId: string, content: string, options: { pre
   }
 }
 
+export async function editAction(
+  chatId: string,
+  messageId: string,
+  content: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
+    const message = await client.editChatMessage(chatId, messageId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const chatCommand = new Command('chat')
   .description('Chat commands (1:1, group, and self chats)')
   .addCommand(
@@ -129,3 +164,12 @@ export const chatCommand = new Command('chat')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a message in a chat (your own messages only)')
+      .argument('<chat-id>', 'Chat ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<content>', 'New message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )

package/src/platforms/teams/index.ts

@@ -20,6 +20,7 @@ export type {
   TeamsCredentials,
   TeamsFile,
   TeamsListenerEventMap,
+  TeamsMention,
   TeamsMessage,
   TeamsRealtimeMessage,
   TeamsReaction,