whatsapp-pi 1.0.60 → 1.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatsapp-pi",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "type": "module",
   "description": "WhatsApp integration extension for Pi",
   "main": "whatsapp-pi.ts",

package/src/i18n.ts

@@ -189,6 +189,11 @@ const fallback = {
     "incoming.media.contact": "[Contact]",
     "incoming.media.location": "[Location]",
     "incoming.media.unsupported": "[Unsupported Message Type: {typeName}]",
+    "incoming.media.reaction": "{emoji} Reacted to message",
+    "incoming.media.reactionRemoved": "Removed reaction",
+    "tool.sendReaction.label": "Send WhatsApp Reaction",
+    "tool.sendReaction.description": "React to a WhatsApp message with an emoji",
+    "tool.sendReaction.error.invalidEmoji": "Invalid emoji provided",
     "incoming.media.audioTranscribing": "[WhatsApp-Pi] Transcribing audio from {pushName}...",
     "incoming.media.audioTranscribed": "[Transcribed Audio]: {transcription}",
     "incoming.media.imageDownloading": "[WhatsApp-Pi] Downloading image from {pushName}...",
@@ -387,6 +392,11 @@ const translations: Record<Locale, Partial<Record<Key, string>>> = {
         "incoming.media.documentDownloading": "[WhatsApp-Pi] Baixando documento de {pushName}: {fileName}...",
         "incoming.media.documentSaved": "[WhatsApp-Pi] Documento salvo em {relativePath} ({size} bytes)",
         "incoming.media.documentReceived": "[Documento recebido: {fileName}]",
+        "incoming.media.reaction": "{emoji} Reagiu à mensagem",
+        "incoming.media.reactionRemoved": "Reação removida",
+        "tool.sendReaction.label": "Enviar Reação no WhatsApp",
+        "tool.sendReaction.description": "Reagir a uma mensagem do WhatsApp com um emoji",
+        "tool.sendReaction.error.invalidEmoji": "Emoji inválido",
         "incoming.media.documentMimeType": "Tipo MIME: {mimeType}",
         "incoming.media.documentSize": "Tamanho: {size}",
         "incoming.media.documentLocation": "Local: {relativePath}",
@@ -531,6 +541,11 @@ const translations: Record<Locale, Partial<Record<Key, string>>> = {
         "session.manager.failedSaveConfig": "Error al guardar config:",
         "session.manager.invalidNumber": "[SessionManager] Intento de añadir número inválido:",
         "session.manager.failedDeleteAuthState": "Error al eliminar el estado de autenticación:",
+        "incoming.media.reaction": "{emoji} Reaccionó al mensaje",
+        "incoming.media.reactionRemoved": "Reacción eliminada",
+        "tool.sendReaction.label": "Enviar Reacción en WhatsApp",
+        "tool.sendReaction.description": "Reaccionar a un mensaje de WhatsApp con un emoji",
+        "tool.sendReaction.error.invalidEmoji": "Emoji inválido",
     },
     fr: {
         "tool.label": "Envoyer un message WhatsApp",

package/src/services/incoming-message.resolver.ts

@@ -9,6 +9,7 @@ export type IncomingResolution =
     | { kind: 'contact'; text: string }
     | { kind: 'location'; text: string }
     | { kind: 'system'; text: string }
+    | { kind: 'reaction'; text: string; reactionMessage: any }
     | { kind: 'unsupported'; text: string };
 
 const protocolTypes: Record<number, keyof typeof protocolLabels> = {
@@ -146,5 +147,21 @@ export const extractIncomingText = (message: any): IncomingResolution => {
         return { kind: 'text', text: resolved.templateButtonReplyMessage.selectedDisplayText };
     }
 
+    if (resolved?.reactionMessage) {
+        const emoji = resolved.reactionMessage.text;
+        if (emoji) {
+            return {
+                kind: 'reaction',
+                text: t('incoming.media.reaction', { emoji }),
+                reactionMessage: resolved.reactionMessage
+            };
+        }
+        return {
+            kind: 'reaction',
+            text: t('incoming.media.reactionRemoved'),
+            reactionMessage: resolved.reactionMessage
+        };
+    }
+
     return { kind: 'unsupported', text: t('incoming.media.unsupported', { typeName }) };
 };

package/src/services/reaction.sender.ts

@@ -0,0 +1,65 @@
+import { t } from '../i18n.js';
+
+export interface SendReactionOptions {
+    jid: string;
+    messageId: string;
+    emoji: string;
+}
+
+export interface SendReactionResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+
+// Socket interface that matches what we need from Baileys
+interface ReactionSocket {
+    sendMessage: (jid: string, content: { react: { text: string; key: { remoteJid: string; id: string; fromMe: boolean } } }) => Promise<{ key?: { id?: string | null } } | undefined>;
+}
+
+export class ReactionSender {
+    constructor(private socket: ReactionSocket | null) {}
+
+    async sendReaction(options: SendReactionOptions): Promise<SendReactionResult> {
+        if (!this.socket) {
+            return { success: false, error: t('service.whatsapp.notConnected') };
+        }
+
+        // Validate emoji (must be single emoji or empty string to remove)
+        if (!this.isValidEmoji(options.emoji)) {
+            return { success: false, error: t('tool.sendReaction.error.invalidEmoji') };
+        }
+
+        try {
+            const result = await this.socket.sendMessage(options.jid, {
+                react: {
+                    text: options.emoji,
+                    key: {
+                        remoteJid: options.jid,
+                        id: options.messageId,
+                        fromMe: false
+                    }
+                }
+            });
+
+            return {
+                success: true,
+                messageId: result?.key?.id ?? undefined
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+
+    private isValidEmoji(emoji: string): boolean {
+        // Allow empty string (removes reaction)
+        if (emoji === '') return true;
+        // Check if single emoji using Unicode emoji regex
+        // This matches single Unicode emojis including variation selectors
+        const emojiRegex = /^(\p{Emoji_Presentation}|\p{Emoji}\uFE0F)$/u;
+        return emojiRegex.test(emoji);
+    }
+}

package/src/services/whatsapp.service.ts

@@ -185,11 +185,27 @@ export class WhatsAppService {
         return value;
     }
 
-    private normalizeRecipientJid(jid: string): string {
-        if (jid.includes('@')) return jid;
-        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
-        return `${digits}@s.whatsapp.net`;
-    }
+    private normalizeRecipientJid(jid: string): string {
+        if (jid.includes('@')) return jid;
+        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
+        return `${digits}@s.whatsapp.net`;
+    }
+
+    public resolveOutboundRecipientJid(recipient: string): string {
+        if (SessionManager.isGroupJid(recipient)) {
+            return recipient;
+        }
+
+        const senderNumber = this.normalizeContactNumber(recipient.split('@')[0]);
+        const allowedContact = this.sessionManager.getAllowedContact(recipient)
+            ?? this.sessionManager.getAllowedContact(senderNumber);
+
+        if (allowedContact?.sendNumber) {
+            return this.normalizeRecipientJid(allowedContact.sendNumber);
+        }
+
+        return this.normalizeRecipientJid(recipient);
+    }
 
     private normalizeJidForComparison(jid: string): string {
         const [localPart, domain = ''] = jid.split('@');
@@ -653,27 +669,29 @@ export class WhatsAppService {
         }
     }
 
-    async sendMessage(jid: string, text: string) {
-        // Ensure we show the typing indicator before sending
-        await this.sendPresence(jid, 'composing');
-
-        const result = await this.messageSender.send({
-            recipientJid: jid,
-            text: text
-        });
-
-        // After sending, we can stop the typing indicator
-        await this.sendPresence(jid, 'paused');
-
-        if (!result.success) {
-            console.error(t('service.whatsapp.failedSendMessage', { jid, error: result.error ?? t('message.sender.unknownError') }));
-        }
-
-        return result;
-    }
-
-    async sendMenuMessage(jid: string, text: string) {
-        const normalizedJid = this.normalizeRecipientJid(jid);
+    async sendMessage(jid: string, text: string) {
+        const recipientJid = this.resolveOutboundRecipientJid(jid);
+
+        // Ensure we show the typing indicator before sending
+        await this.sendPresence(recipientJid, 'composing');
+
+        const result = await this.messageSender.send({
+            recipientJid,
+            text: text
+        });
+
+        // After sending, we can stop the typing indicator
+        await this.sendPresence(recipientJid, 'paused');
+
+        if (!result.success) {
+            console.error(t('service.whatsapp.failedSendMessage', { jid: recipientJid, error: result.error ?? t('message.sender.unknownError') }));
+        }
+
+        return result;
+    }
+
+    async sendMenuMessage(jid: string, text: string) {
+        const normalizedJid = this.resolveOutboundRecipientJid(jid);
         const socket = this.getActiveSocket();
 
         if (!socket) {

package/src/ui/message-reply.view.ts

@@ -41,13 +41,21 @@ const buildReplyWidget = (selectedMessage: SelectedMessageContext): string[] =>
     ];
 };
 
-const buildReplyTitle = (selectedMessage: SelectedMessageContext): string => {
+const buildReplyTitle = (selectedMessage: SelectedMessageContext): string => {
     const sender = selectedMessage.senderName
         ? `${selectedMessage.senderName} (${selectedMessage.senderNumber})`
         : selectedMessage.senderNumber;
 
-    return truncateToWidth(`${t('message.reply.title')} ${sender}`, 120);
-};
+    return truncateToWidth(`${t('message.reply.title')} ${sender}`, 120);
+};
+
+const toRecentSenderNumber = (recipientJid: string): string => {
+    if (recipientJid.endsWith('@g.us')) {
+        return recipientJid;
+    }
+
+    return `+${recipientJid.split('@')[0]}`;
+};
 
 export async function showMessageReplyView(
     ctx: MessageReplyContext,
@@ -70,24 +78,27 @@ export async function showMessageReplyView(
                 continue;
             }
 
-            const draft: ReplyDraft = {
-                text,
-                targetMessageId: props.selectedMessage.messageId,
-                targetConversation: props.selectedMessage.senderNumber
-            };
-
-            const result: ReplySendResult = await props.whatsappService.sendMenuMessage(
-                props.selectedMessage.senderNumber,
-                draft.text
-            );
-
-            if (result.success) {
-                await props.recentsService.recordMessage({
-                    messageId: result.messageId ?? `${Date.now()}`,
-                    senderNumber: props.selectedMessage.senderNumber,
-                    senderName: props.selectedMessage.senderName,
-                    text: draft.text,
-                    direction: 'outgoing',
+            const draft: ReplyDraft = {
+                text,
+                targetMessageId: props.selectedMessage.messageId,
+                targetConversation: props.selectedMessage.senderNumber
+            };
+            const recipientJid = props.whatsappService.resolveOutboundRecipientJid(
+                props.selectedMessage.senderNumber
+            );
+
+            const result: ReplySendResult = await props.whatsappService.sendMenuMessage(
+                recipientJid,
+                draft.text
+            );
+
+            if (result.success) {
+                await props.recentsService.recordMessage({
+                    messageId: result.messageId ?? `${Date.now()}`,
+                    senderNumber: toRecentSenderNumber(recipientJid),
+                    senderName: props.selectedMessage.senderName,
+                    text: draft.text,
+                    direction: 'outgoing',
                     timestamp: Date.now()
                 });
                 ctx.ui.notify(t('message.reply.sent', { preview: buildPreview(props.selectedMessage.text) }), 'info');

package/whatsapp-pi.ts

@@ -8,6 +8,7 @@ import { AudioService } from './src/services/audio.service.js';
 import { extractIncomingText } from './src/services/incoming-message.resolver.js';
 import { IncomingMediaService } from './src/services/incoming-media.service.js';
 import { WhatsAppPiLogger } from './src/services/whatsapp-pi.logger.js';
+import { ReactionSender } from './src/services/reaction.sender.js';
 import { initI18n, t } from './src/i18n.js';
 
 const shutdownState = globalThis as typeof globalThis & {
@@ -208,6 +209,14 @@ export default function (pi: ExtensionAPI) {
     // Track whether send_wa_message tool already sent a reply this turn
     let toolSentToJid: string | null = null;
 
+    const toRecentSenderNumber = (recipientJid: string): string => {
+        if (recipientJid.endsWith('@g.us')) {
+            return recipientJid;
+        }
+
+        return `+${recipientJid.split('@')[0]}`;
+    };
+
     // Handle incoming messages by injecting them as user prompts
     whatsappService.setMessageCallback(async (m) => {
         const msg = m.messages?.[0];
@@ -318,16 +327,15 @@ export default function (pi: ExtensionAPI) {
                 formattedMessage
             ].join('\n'));
 
-            const result = await whatsappService.sendMessage(resolvedJid, params.message);
+            const outboundJid = whatsappService.resolveOutboundRecipientJid(resolvedJid);
+            const result = await whatsappService.sendMessage(outboundJid, params.message);
 
             if (result.success) {
                 // Mark that tool already sent to this JID — prevents message_end from re-sending
-                toolSentToJid = resolvedJid;
-                const isGroupJid = resolvedJid.endsWith('@g.us');
-                const senderNumber = isGroupJid ? resolvedJid : `+${resolvedJid.split('@')[0]}`;
+                toolSentToJid = outboundJid;
                 await recentsService.recordMessage({
                     messageId: result.messageId!,
-                    senderNumber,
+                    senderNumber: toRecentSenderNumber(outboundJid),
                     text: params.message,
                     direction: 'outgoing',
                     timestamp: Date.now()
@@ -355,6 +363,44 @@ export default function (pi: ExtensionAPI) {
         }
     });
 
+    // Register send_reaction tool (LLM-callable)
+    pi.registerTool({
+        name: "send_reaction",
+        label: t("tool.sendReaction.label"),
+        description: t("tool.sendReaction.description"),
+        promptSnippet: "send_reaction(jid, messageId, emoji) - React to a WhatsApp message with an emoji. The 'jid' is the chat JID (e.g. 5511999998888@s.whatsapp.net), 'messageId' is the ID of the message to react to, and 'emoji' is the emoji to react with (e.g., 👍, ❤️, 😂).",
+        parameters: Type.Object({
+            jid: Type.String({ description: "WhatsApp JID of the chat (e.g. 5511999998888@s.whatsapp.net or 120363012345@g.us)" }),
+            messageId: Type.String({ description: "ID of the message to react to" }),
+            emoji: Type.String({ description: "Emoji to react with (e.g., 👍, ❤️, 😂). Use empty string to remove reaction." })
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            // Get socket from WhatsApp service
+            const socket = whatsappService.getSocket();
+            if (!socket) {
+                return {
+                    isError: true,
+                    details: undefined,
+                    content: [{ type: "text" as const, text: JSON.stringify({ success: false, error: t("service.whatsapp.notConnected") }) }]
+                };
+            }
+
+            // Create sender with the socket
+            const sender = new ReactionSender(socket as any);
+            const result = await sender.sendReaction({
+                jid: params.jid,
+                messageId: params.messageId,
+                emoji: params.emoji
+            });
+
+            return {
+                isError: !result.success,
+                details: undefined,
+                content: [{ type: "text" as const, text: JSON.stringify({ success: result.success, messageId: result.messageId, error: result.error }) }]
+            };
+        }
+    });
+
     // Suppress automatic message_end reply when tool already sent
     // This is checked by the message_end handler below
 
@@ -380,7 +426,7 @@ export default function (pi: ExtensionAPI) {
         if (sessionManager.getStatus() !== 'connected') return;
         const lastJid = whatsappService.getLastRemoteJid();
         if (lastJid) {
-            await whatsappService.sendPresence(lastJid, 'composing');
+            await whatsappService.sendPresence(whatsappService.resolveOutboundRecipientJid(lastJid), 'composing');
         }
     });
 
@@ -392,20 +438,23 @@ export default function (pi: ExtensionAPI) {
         if (message.role === "assistant") {
             const lastJid = whatsappService.getLastRemoteJid();
             const text = message.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+            const outboundJid = lastJid
+                ? whatsappService.resolveOutboundRecipientJid(lastJid)
+                : null;
 
             // Skip if send_wa_message tool already sent a reply to this JID
-            if (toolSentToJid === lastJid) {
+            if (toolSentToJid === outboundJid) {
                 toolSentToJid = null;
                 return;
             }
 
-            if (lastJid && text) {
+            if (outboundJid && text) {
                 try {
-                    const result = await whatsappService.sendMessage(lastJid, text);
+                    const result = await whatsappService.sendMessage(outboundJid, text);
                     if (result.success) {
                         await recentsService.recordMessage({
                             messageId: result.messageId ?? `${Date.now()}`,
-                            senderNumber: `+${lastJid.split('@')[0]}`,
+                            senderNumber: toRecentSenderNumber(outboundJid),
                             text,
                             direction: 'outgoing',
                             timestamp: Date.now()