agent-messenger 2.29.1 → 2.30.0

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.29.1
+version: 2.30.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:
@@ -251,6 +251,10 @@ agent-whatsapp message send +1234567890 "Hello!"
 agent-whatsapp message send 123456789-123345@g.us "Hello team!"
 agent-whatsapp message send +1234567890 "Hello!" --account <id>
 
+# Edit one of your own messages (within ~15 minutes)
+agent-whatsapp message edit <chat> <message-id> <text>
+agent-whatsapp message edit +1234567890 ABC123DEF456 "Updated text"
+
 # React to a message
 agent-whatsapp message react <chat> <message-id> <emoji>
 agent-whatsapp message react +1234567890 ABC123DEF456 "👍"
@@ -342,6 +346,26 @@ agent-whatsapp message list +1234567890 --limit 1
 agent-whatsapp message react +1234567890 <message-id> "👍"
 ```
 
+### Edit one of your own messages
+
+```bash
+# Get the message ID of a message you sent
+agent-whatsapp message list +1234567890 --limit 5
+
+# Edit it (only your own messages, within ~15 minutes)
+agent-whatsapp message edit +1234567890 <message-id> "Updated text"
+```
+
+The SDK exposes the same capability via `WhatsAppClient.editMessage`:
+
+```typescript
+import { WhatsAppClient } from 'agent-messenger/whatsapp'
+
+const client = await new WhatsAppClient().login()
+const sent = await client.sendMessage('+1234567890', 'Deploying…')
+await client.editMessage('+1234567890', sent.id, 'Deployed ✅')
+```
+
 ## Error Handling
 
 All commands return consistent error format:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.29.1
+version: 2.30.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

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

@@ -713,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/telegram/client.test.ts

@@ -235,3 +235,63 @@ describe('sendMessage confirmation', () => {
     expect(result.id).toBe(serverId)
   })
 })
+
+describe('editMessage', () => {
+  it('returns the edited message from the editMessageText response', async () => {
+    const events: any[] = []
+    let editRequest: any = null
+
+    const createClientId = mock(() => 1)
+    const send = mock((_clientId: number, request: any) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        events.push({
+          '@type': 'updateAuthorizationState',
+          authorization_state: { '@type': 'authorizationStateReady' },
+          '@extra': request['@extra'],
+        })
+      }
+
+      if (request['@type'] === 'getChat') {
+        events.push({ '@type': 'chat', id: 42, title: 'test', unread_count: 0, '@extra': request['@extra'] })
+      }
+
+      if (request['@type'] === 'editMessageText') {
+        editRequest = request
+        events.push({
+          '@type': 'message',
+          id: 555,
+          chat_id: 42,
+          date: 1_710_000_002,
+          is_outgoing: true,
+          sender_id: { '@type': 'messageSenderUser', user_id: 1 },
+          content: {
+            '@type': 'messageText',
+            text: { '@type': 'formattedText', text: 'edited text', entities: [] },
+          },
+          '@extra': request['@extra'],
+        })
+      }
+    })
+
+    const receive = mock(() => events.shift() ?? null)
+    const client = new (TelegramTdlibClient as unknown as new (
+      account: TelegramAccount,
+      paths: TelegramAccountPaths,
+      tdjson: any,
+    ) => TelegramTdlibClient)(mockAccount, mockPaths, {
+      createClientId,
+      send,
+      receive,
+      libraryPath: '/mock/lib',
+    })
+
+    const result = await client.editMessage('42', 555, 'edited text')
+
+    expect(result.id).toBe(555)
+    expect(result.text).toBe('edited text')
+    expect(editRequest.chat_id).toBe(42)
+    expect(editRequest.message_id).toBe(555)
+    expect(editRequest.input_message_content['@type']).toBe('inputMessageText')
+    expect(editRequest.input_message_content.text.text).toBe('edited text')
+  })
+})

package/src/platforms/telegram/client.ts

@@ -312,6 +312,30 @@ export class TelegramTdlibClient {
     return simplifyMessage(message, chat.id)
   }
 
+  async editMessage(reference: string, messageId: number, text: string): Promise<TelegramMessageSummary> {
+    await this.ensureReady()
+    const chat = await this.resolveChat(reference)
+
+    const message = (await this.call({
+      '@type': 'editMessageText',
+      chat_id: chat.id,
+      message_id: messageId,
+      reply_markup: null,
+      input_message_content: {
+        '@type': 'inputMessageText',
+        text: {
+          '@type': 'formattedText',
+          text,
+          entities: [],
+        },
+        link_preview_options: null,
+        clear_draft: false,
+      },
+    })) as TdMessage
+
+    return simplifyMessage(message, chat.id)
+  }
+
   private async ensureReady(): Promise<void> {
     const state = await this.connect()
     if (state?.['@type'] !== 'authorizationStateReady') {