Add thread and reaction support to Matrix (home-assistant#147165)

Co-authored-by: Paarth Shah <[email protected]>

Author: decompil3d

homeassistant/components/matrix/__init__.py

@@ -8,11 +8,11 @@
 import mimetypes
 import os
 import re
-from typing import Final, NewType, Required, TypedDict
+from typing import Any, Final, NewType, Required, TypedDict
 
 import aiofiles.os
 from nio import AsyncClient, Event, MatrixRoom
-from nio.events.room_events import RoomMessageText
+from nio.events.room_events import ReactionEvent, RoomMessageText
 from nio.responses import (
     ErrorResponse,
     JoinError,
@@ -44,7 +44,17 @@
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.json import JsonObjectType, load_json_object
 
-from .const import ATTR_FORMAT, ATTR_IMAGES, CONF_ROOMS_REGEX, DOMAIN, FORMAT_HTML
+from .const import (
+    ATTR_FORMAT,
+    ATTR_IMAGES,
+    ATTR_MESSAGE_ID,
+    ATTR_REACTION,
+    ATTR_ROOM,
+    ATTR_THREAD_ID,
+    CONF_ROOMS_REGEX,
+    DOMAIN,
+    FORMAT_HTML,
+)
 from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
@@ -56,6 +66,7 @@
 CONF_COMMANDS: Final = "commands"
 CONF_WORD: Final = "word"
 CONF_EXPRESSION: Final = "expression"
+CONF_REACTION: Final = "reaction"
 
 CONF_USERNAME_REGEX = "^@[^:]*:.*"
 
@@ -66,6 +77,7 @@
 
 WordCommand = NewType("WordCommand", str)
 ExpressionCommand = NewType("ExpressionCommand", re.Pattern)
+ReactionCommand = NewType("ReactionCommand", str)
 RoomAlias = NewType("RoomAlias", str)  # Starts with "#"
 RoomID = NewType("RoomID", str)  # Starts with "!"
 RoomAnyID = RoomID | RoomAlias
@@ -78,20 +90,22 @@ class ConfigCommand(TypedDict, total=False):
     rooms: list[RoomID]  # CONF_ROOMS
     word: WordCommand  # CONF_WORD
     expression: ExpressionCommand  # CONF_EXPRESSION
+    reaction: ReactionCommand  # CONF_REACTION
 
 
 COMMAND_SCHEMA = vol.All(
     vol.Schema(
         {
             vol.Exclusive(CONF_WORD, "trigger"): cv.string,
             vol.Exclusive(CONF_EXPRESSION, "trigger"): cv.is_regex,
+            vol.Exclusive(CONF_REACTION, "trigger"): cv.string,
             vol.Required(CONF_NAME): cv.string,
             vol.Optional(CONF_ROOMS): vol.All(
                 cv.ensure_list, [cv.matches_regex(CONF_ROOMS_REGEX)]
             ),
         }
     ),
-    cv.has_at_least_one_key(CONF_WORD, CONF_EXPRESSION),
+    cv.has_at_least_one_key(CONF_WORD, CONF_EXPRESSION, CONF_REACTION),
 )
 
 CONFIG_SCHEMA = vol.Schema(
@@ -167,6 +181,7 @@ def __init__(
         self._listening_rooms: dict[RoomAnyID, RoomID] = {}
         self._word_commands: dict[RoomID, dict[WordCommand, ConfigCommand]] = {}
         self._expression_commands: dict[RoomID, list[ConfigCommand]] = {}
+        self._reaction_commands: dict[RoomID, dict[ReactionCommand, ConfigCommand]] = {}
         self._unparsed_commands = commands
 
         async def stop_client(event: HassEvent) -> None:
@@ -189,7 +204,9 @@ async def handle_startup(event: HassEvent) -> None:
             await self._client.sync(timeout=30_000)
             _LOGGER.debug("Finished initial sync for %s", self._mx_id)
 
-            self._client.add_event_callback(self._handle_room_message, RoomMessageText)
+            self._client.add_event_callback(
+                self._handle_room_message, (ReactionEvent, RoomMessageText)
+            )
 
             _LOGGER.debug("Starting sync_forever for %s", self._mx_id)
             self.hass.async_create_background_task(
@@ -210,11 +227,15 @@ def _load_commands(self, commands: list[ConfigCommand]) -> None:
             else:
                 command[CONF_ROOMS] = list(self._listening_rooms.values())
 
-            # COMMAND_SCHEMA guarantees that exactly one of CONF_WORD and CONF_EXPRESSION are set.
+            # COMMAND_SCHEMA guarantees that exactly one of CONF_WORD, CONF_EXPRESSION, or CONF_REACTION are set.
             if (word_command := command.get(CONF_WORD)) is not None:
                 for room_id in command[CONF_ROOMS]:
                     self._word_commands.setdefault(room_id, {})
                     self._word_commands[room_id][word_command] = command
+            elif (reaction_command := command.get(CONF_REACTION)) is not None:
+                for room_id in command[CONF_ROOMS]:
+                    self._reaction_commands.setdefault(room_id, {})
+                    self._reaction_commands[room_id][reaction_command] = command
             else:
                 for room_id in command[CONF_ROOMS]:
                     self._expression_commands.setdefault(room_id, [])
@@ -223,15 +244,33 @@ def _load_commands(self, commands: list[ConfigCommand]) -> None:
     async def _handle_room_message(self, room: MatrixRoom, message: Event) -> None:
         """Handle a message sent to a Matrix room."""
         # Corresponds to message type 'm.text' and NOT other RoomMessage subtypes, like 'm.notice' and 'm.emote'.
-        if not isinstance(message, RoomMessageText):
+        if not isinstance(message, (RoomMessageText, ReactionEvent)):
             return
         # Don't respond to our own messages.
         if message.sender == self._mx_id:
             return
-        _LOGGER.debug("Handling message: %s", message.body)
 
         room_id = RoomID(room.room_id)
 
+        if isinstance(message, ReactionEvent):
+            # Handle reactions
+            reaction = message.key
+            _LOGGER.debug("Handling reaction: %s", reaction)
+            if command := self._reaction_commands.get(room_id, {}).get(reaction):
+                message_data = {
+                    "command": command[CONF_NAME],
+                    "sender": message.sender,
+                    "room": room_id,
+                    "event_id": message.reacts_to,
+                    "args": {
+                        "reaction": message.key,
+                    },
+                }
+                self.hass.bus.async_fire(EVENT_MATRIX_COMMAND, message_data)
+            return
+
+        _LOGGER.debug("Handling message: %s", message.body)
+
         if message.body.startswith("!"):
             # Could trigger a single-word command.
             pieces = message.body.split()
@@ -242,8 +281,12 @@ async def _handle_room_message(self, room: MatrixRoom, message: Event) -> None:
                     "command": command[CONF_NAME],
                     "sender": message.sender,
                     "room": room_id,
+                    "event_id": message.event_id,
                     "args": pieces[1:],
+                    "thread_parent": self._get_thread_parent(message)
+                    or message.event_id,
                 }
+
                 self.hass.bus.async_fire(EVENT_MATRIX_COMMAND, message_data)
 
         # After single-word commands, check all regex commands in the room.
@@ -255,10 +298,28 @@ async def _handle_room_message(self, room: MatrixRoom, message: Event) -> None:
                 "command": command[CONF_NAME],
                 "sender": message.sender,
                 "room": room_id,
+                "event_id": message.event_id,
                 "args": match.groupdict(),
+                "thread_parent": self._get_thread_parent(message) or message.event_id,
             }
+
             self.hass.bus.async_fire(EVENT_MATRIX_COMMAND, message_data)
 
+    def _get_thread_parent(self, message: RoomMessageText) -> str | None:
+        """Get the thread parent ID from a message, or None if not in a thread."""
+        match message.source:
+            case {
+                "content": {
+                    "m.relates_to": {
+                        "rel_type": "m.thread",
+                        "event_id": str() as event_id,
+                    }
+                }
+            }:
+                return event_id
+            case _:
+                return None
+
     async def _resolve_room_alias(
         self, room_alias_or_id: RoomAnyID
     ) -> dict[RoomAnyID, RoomID]:
@@ -432,7 +493,7 @@ async def _handle_multi_room_send(
         )
 
     async def _send_image(
-        self, image_path: str, target_rooms: Sequence[RoomAnyID]
+        self, image_path: str, target_rooms: Sequence[RoomAnyID], thread_id: str | None
     ) -> None:
         """Upload an image, then send it to all target_rooms."""
         _is_allowed_path = await self.hass.async_add_executor_job(
@@ -480,6 +541,9 @@ async def _send_image(
             "url": response.content_uri,
         }
 
+        if thread_id is not None:
+            content["m.relates_to"] = {"event_id": thread_id, "rel_type": "m.thread"}
+
         await self._handle_multi_room_send(
             target_rooms=target_rooms, message_type="m.room.message", content=content
         )
@@ -488,9 +552,19 @@ async def _send_message(
         self, message: str, target_rooms: list[RoomAnyID], data: dict | None
     ) -> None:
         """Send a message to the Matrix server."""
-        content = {"msgtype": "m.text", "body": message}
-        if data is not None and data.get(ATTR_FORMAT) == FORMAT_HTML:
-            content |= {"format": "org.matrix.custom.html", "formatted_body": message}
+        content: dict[str, Any] = {"msgtype": "m.text", "body": message}
+        if data is not None:
+            thread_id: str | None = data.get(ATTR_THREAD_ID)
+            if data.get(ATTR_FORMAT) == FORMAT_HTML:
+                content |= {
+                    "format": "org.matrix.custom.html",
+                    "formatted_body": message,
+                }
+            if thread_id is not None:
+                content["m.relates_to"] = {
+                    "event_id": thread_id,
+                    "rel_type": "m.thread",
+                }
 
         await self._handle_multi_room_send(
             target_rooms=target_rooms, message_type="m.room.message", content=content
@@ -503,16 +577,42 @@ async def _send_message(
         ):
             image_tasks = [
                 self.hass.async_create_task(
-                    self._send_image(image_path, target_rooms), eager_start=False
+                    self._send_image(
+                        image_path, target_rooms, data.get(ATTR_THREAD_ID)
+                    ),
+                    eager_start=False,
                 )
                 for image_path in image_paths
             ]
             await asyncio.wait(image_tasks)
 
+    async def _send_reaction(
+        self, reaction: str, target_room: RoomAnyID, message_id: str
+    ) -> None:
+        """Send a reaction to the Matrix server."""
+        content = {
+            "m.relates_to": {
+                "event_id": message_id,
+                "key": reaction,
+                "rel_type": "m.annotation",
+            }
+        }
+        await self._handle_room_send(
+            target_room=target_room, message_type="m.reaction", content=content
+        )
+
     async def handle_send_message(self, service: ServiceCall) -> None:
         """Handle the send_message service."""
         await self._send_message(
             service.data[ATTR_MESSAGE],
             service.data[ATTR_TARGET],
             service.data.get(ATTR_DATA),
         )
+
+    async def handle_send_reaction(self, service: ServiceCall) -> None:
+        """Handle the react service."""
+        await self._send_reaction(
+            service.data[ATTR_REACTION],
+            service.data[ATTR_ROOM],
+            service.data[ATTR_MESSAGE_ID],
+        )

homeassistant/components/matrix/const.py

@@ -3,11 +3,17 @@
 DOMAIN = "matrix"
 
 SERVICE_SEND_MESSAGE = "send_message"
+SERVICE_REACT = "react"
 
 FORMAT_HTML = "html"
 FORMAT_TEXT = "text"
 
 ATTR_FORMAT = "format"  # optional message format
 ATTR_IMAGES = "images"  # optional images
+ATTR_THREAD_ID = "thread_id"  # optional thread id
+
+ATTR_REACTION = "reaction"  # reaction
+ATTR_ROOM = "room"  # room id
+ATTR_MESSAGE_ID = "message_id"  # message id
 
 CONF_ROOMS_REGEX = "^[!|#][^:]*:.*"

homeassistant/components/matrix/icons.json

@@ -1,5 +1,8 @@
 {
   "services": {
+    "react": {
+      "service": "mdi:emoticon"
+    },
     "send_message": {
       "service": "mdi:matrix"
     }

homeassistant/components/matrix/services.py

@@ -13,10 +13,15 @@
 from .const import (
     ATTR_FORMAT,
     ATTR_IMAGES,
+    ATTR_MESSAGE_ID,
+    ATTR_REACTION,
+    ATTR_ROOM,
+    ATTR_THREAD_ID,
     CONF_ROOMS_REGEX,
     DOMAIN,
     FORMAT_HTML,
     FORMAT_TEXT,
+    SERVICE_REACT,
     SERVICE_SEND_MESSAGE,
 )
 
@@ -36,20 +41,35 @@
                 MESSAGE_FORMATS
             ),
             vol.Optional(ATTR_IMAGES): vol.All(cv.ensure_list, [cv.string]),
+            vol.Optional(ATTR_THREAD_ID): cv.string,
         },
         vol.Required(ATTR_TARGET): vol.All(
             cv.ensure_list, [cv.matches_regex(CONF_ROOMS_REGEX)]
         ),
     }
 )
 
+SERVICE_SCHEMA_REACT = vol.Schema(
+    {
+        vol.Required(ATTR_REACTION): cv.string,
+        vol.Required(ATTR_ROOM): cv.matches_regex(CONF_ROOMS_REGEX),
+        vol.Required(ATTR_MESSAGE_ID): cv.string,
+    }
+)
+
 
 async def _handle_send_message(call: ServiceCall) -> None:
     """Handle the send_message service call."""
     matrix_bot: MatrixBot = call.hass.data[DOMAIN]
     await matrix_bot.handle_send_message(call)
 
 
+async def _handle_react(call: ServiceCall) -> None:
+    """Handle the react service call."""
+    matrix_bot: MatrixBot = call.hass.data[DOMAIN]
+    await matrix_bot.handle_send_reaction(call)
+
+
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the Matrix bot component."""
@@ -60,3 +80,10 @@ def async_setup_services(hass: HomeAssistant) -> None:
         _handle_send_message,
         schema=SERVICE_SCHEMA_SEND_MESSAGE,
     )
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_REACT,
+        _handle_react,
+        schema=SERVICE_SCHEMA_REACT,
+    )