agent-messenger 2.29.1 → 2.30.0

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

@@ -9,9 +9,12 @@ const mockListMessages = mock(() =>
 
 const mockSendMessage = mock(() => Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }))
 
+const mockEditMessage = mock(() => Promise.resolve({ id: 3, text: 'Edited message', sender_id: 'user-1', date: 3000 }))
+
 const mockClient = {
   listMessages: mockListMessages,
   sendMessage: mockSendMessage,
+  editMessage: mockEditMessage,
 }
 
 mock.module('./shared', () => ({
@@ -36,6 +39,10 @@ describe('message commands', () => {
     mockSendMessage.mockImplementation(() =>
       Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
     )
+    mockEditMessage.mockReset()
+    mockEditMessage.mockImplementation(() =>
+      Promise.resolve({ id: 3, text: 'Edited message', sender_id: 'user-1', date: 3000 }),
+    )
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
     processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
   })
@@ -86,4 +93,35 @@ describe('message commands', () => {
       expect(parsed.id).toBe(3)
     })
   })
+
+  describe('edit subcommand', () => {
+    it('calls editMessage with chat reference, numeric message id, and text', async () => {
+      await messageCommand.parseAsync(['edit', 'chat-123', '3', 'Edited message'], { from: 'user' })
+
+      expect(mockEditMessage).toHaveBeenCalledWith('chat-123', 3, 'Edited message')
+    })
+
+    it('outputs the edited message as JSON', async () => {
+      await messageCommand.parseAsync(['edit', 'chat-123', '3', 'Edited message'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed.text).toBe('Edited message')
+    })
+
+    it('rejects non-decimal, unsafe, or non-positive message ids', async () => {
+      const invalidIds = ['not-a-number', '1e3', '0x10', '0', '9007199254740993']
+
+      for (const invalidId of invalidIds) {
+        mockEditMessage.mockClear()
+        processExitSpy.mockClear()
+
+        await messageCommand.parseAsync(['edit', 'chat-123', invalidId, 'text'], { from: 'user' })
+
+        expect(mockEditMessage).not.toHaveBeenCalled()
+        expect(processExitSpy).toHaveBeenCalledWith(1)
+      }
+    })
+  })
 })

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

@@ -30,6 +30,35 @@ async function sendAction(
   }
 }
 
+async function editAction(
+  reference: string,
+  messageId: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const trimmedMessageId = messageId.trim()
+    const parsedMessageId = Number.parseInt(trimmedMessageId, 10)
+    if (!/^\d+$/.test(trimmedMessageId) || !Number.isSafeInteger(parsedMessageId) || parsedMessageId <= 0) {
+      console.log(
+        formatOutput(
+          { error: 'Invalid message ID. Provide the numeric message ID from "message list".' },
+          options.pretty,
+        ),
+      )
+      process.exit(1)
+      return
+    }
+
+    const message = await withTelegramClient(options, async (client) =>
+      client.editMessage(reference, parsedMessageId, text),
+    )
+    console.log(formatOutput(message, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const messageCommand = new Command('message')
   .description('Telegram message commands')
   .addCommand(
@@ -50,3 +79,13 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a text message (your own messages only, within 48h)')
+      .argument('<chat>', 'Chat ID, @username, or title')
+      .argument('<message-id>', 'Message ID')
+      .argument('<text>', 'New message text')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )

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

@@ -61,7 +61,7 @@ export async function sendAction(
   }
 }
 
-export async function updateAction(
+export async function editAction(
   chat: string,
   messageId: string,
   text: string,
@@ -162,7 +162,7 @@ export const messageCommand = new Command('message')
       ),
   )
   .addCommand(
-    new Command('update')
+    new Command('edit')
       .description("Edit a message (bot's own messages only)")
       .argument('<chat>', 'Chat ID or @username')
       .argument('<message-id>', 'Message ID')
@@ -177,7 +177,7 @@ export const messageCommand = new Command('message')
           text: string,
           opts: BotOption & { parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
         ) => {
-          cliOutput(await updateAction(chat, messageId, text, opts), opts.pretty)
+          cliOutput(await editAction(chat, messageId, text, opts), opts.pretty)
         },
       ),
   )

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'bun:test'
+
+import type { WAMessage } from '@whiskeysockets/baileys'
+
+import { summarizeMessage } from '@/platforms/whatsapp/client'
+
+describe('summarizeMessage', () => {
+  it('summarizes a plain text message', () => {
+    const msg = {
+      key: { id: 'msg-1', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_000,
+      message: { conversation: 'Hello' },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.id).toBe('msg-1')
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Hello')
+  })
+
+  it('unwraps a Baileys edit protocolMessage to the edited content', () => {
+    const msg = {
+      key: { id: 'msg-2', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_100,
+      message: {
+        protocolMessage: {
+          type: 14,
+          editedMessage: { conversation: 'Edited text' },
+        },
+      },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.id).toBe('msg-2')
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Edited text')
+  })
+
+  it('unwraps an edit that uses extendedTextMessage', () => {
+    const msg = {
+      key: { id: 'msg-3', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_200,
+      message: {
+        protocolMessage: {
+          type: 14,
+          editedMessage: { extendedTextMessage: { text: 'Edited via extended' } },
+        },
+      },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Edited via extended')
+  })
+})

package/src/platforms/whatsapp/client.ts

@@ -48,11 +48,15 @@ function resolveJid(input: string): string {
   return `${digits}@s.whatsapp.net`
 }
 
-function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
+export function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
   const jid = msg.key.remoteJid ?? ''
   const isGroup = jid.endsWith('@g.us')
   const from = msg.key.fromMe ? '' : isGroup ? (msg.key.participant ?? msg.participant ?? jid) : jid
 
+  // Baileys wraps an edit as a protocolMessage whose editedMessage holds the new
+  // content; unwrap it so the summary reflects the edited text and type.
+  const content = msg.message?.protocolMessage?.editedMessage ?? msg.message
+
   return {
     id: msg.key.id ?? '',
     chat_id: jid,
@@ -60,8 +64,8 @@ function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
     from_name: msg.pushName ?? undefined,
     timestamp: new Date(toTimestampMs(msg.messageTimestamp)).toISOString(),
     is_outgoing: Boolean(msg.key.fromMe),
-    type: getMessageType(msg.message),
-    text: extractMessageText(msg.message),
+    type: getMessageType(content),
+    text: extractMessageText(content),
   }
 }
 
@@ -660,6 +664,22 @@ export class WhatsAppClient {
     })
   }
 
+  async editMessage(jid: string, messageId: string, text: string): Promise<WhatsAppMessageSummary> {
+    if (!this.sock) throw new WhatsAppError('Not connected', 'not_connected')
+
+    const resolvedJid = resolveJid(jid)
+    const result = await this.sock.sendMessage(resolvedJid, {
+      text,
+      edit: { remoteJid: resolvedJid, fromMe: true, id: messageId },
+    })
+
+    if (!result) {
+      throw new WhatsAppError('Failed to edit message', 'edit_failed')
+    }
+
+    return summarizeMessage(result)
+  }
+
   async close(): Promise<void> {
     try {
       await this.saveStore()

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

@@ -42,6 +42,16 @@ const mockSendMessage = mock(() =>
   }),
 )
 
+const mockEditMessage = mock(() =>
+  Promise.resolve({
+    id: 'msg-2',
+    text: 'Edited text',
+    from: 'me@s.whatsapp.net',
+    timestamp: 3000,
+    fromMe: true,
+  }),
+)
+
 const mockSendReaction = mock(() => Promise.resolve())
 const mockConnect = mock(() => Promise.resolve())
 const mockClose = mock(() => Promise.resolve())
@@ -55,6 +65,7 @@ mock.module('../client', () => ({
     close = mockClose
     getMessages = mockGetMessages
     sendMessage = mockSendMessage
+    editMessage = mockEditMessage
     sendReaction = mockSendReaction
   },
 }))
@@ -71,6 +82,7 @@ describe('message commands', () => {
     mockEnsureAccountPaths.mockReset()
     mockGetMessages.mockReset()
     mockSendMessage.mockReset()
+    mockEditMessage.mockReset()
     mockSendReaction.mockReset()
     mockConnect.mockReset()
     mockClose.mockReset()
@@ -107,6 +119,15 @@ describe('message commands', () => {
         fromMe: true,
       }),
     )
+    mockEditMessage.mockImplementation(() =>
+      Promise.resolve({
+        id: 'msg-2',
+        text: 'Edited text',
+        from: 'me@s.whatsapp.net',
+        timestamp: 3000,
+        fromMe: true,
+      }),
+    )
     mockSendReaction.mockImplementation(() => Promise.resolve())
     mockConnect.mockImplementation(() => Promise.resolve())
     mockClose.mockImplementation(() => Promise.resolve())
@@ -182,6 +203,28 @@ describe('message commands', () => {
     })
   })
 
+  describe('edit', () => {
+    it('edits a message in a chat', async () => {
+      await messageCommand.parseAsync(['edit', '12025551234@s.whatsapp.net', 'msg-2', 'Edited text'], { from: 'user' })
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockEditMessage).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-2', 'Edited text')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.id).toBe('msg-2')
+      expect(output.text).toBe('Edited text')
+    })
+
+    it('passes account option to credential manager', async () => {
+      await messageCommand.parseAsync(
+        ['edit', '12025551234@s.whatsapp.net', 'msg-2', 'Edited text', '--account', 'my-account'],
+        { from: 'user' },
+      )
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+  })
+
   describe('react', () => {
     it('sends a reaction to a message', async () => {
       await messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'], { from: 'user' })

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

@@ -29,6 +29,21 @@ async function sendAction(chat: string, text: string, options: { account?: strin
   }
 }
 
+async function editAction(
+  chat: string,
+  messageId: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const message = await withWhatsAppClient(options, (client) => client.editMessage(chat, messageId, text))
+    console.log(formatOutput(message, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 async function reactAction(
   chat: string,
   messageId: string,
@@ -64,6 +79,16 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit one of your own messages (within ~15 minutes)')
+      .argument('<chat>', 'Chat JID or phone number')
+      .argument('<message-id>', 'Message ID to edit')
+      .argument('<text>', 'New message text')
+      .option('--account <id>', 'Use a specific WhatsApp account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )
   .addCommand(
     new Command('react')
       .description('React to a message with an emoji')