errbot-backend-matrix 0.0.1__py3-none-any.whl

err_backend_matrix/__init__.py

@@ -0,0 +1,4 @@
+# Matrix Errbot backend plugin
+from .matrix import MatrixBackend
+
+__all__ = ["MatrixBackend"]

err_backend_matrix/err_backend_matrix.plug

@@ -0,0 +1,9 @@
+[Core]
+Name = Matrix
+Module = err_backend_matrix
+
+[Documentation]
+Description = A fully functional Errbot backend for Matrix using matrix-nio.
+
+[Python]
+Version = 3

err_backend_matrix/matrix.py

@@ -0,0 +1,344 @@
+import asyncio
+import logging
+from typing import Sequence
+
+from errbot.backends.base import AWAY, DND, OFFLINE, ONLINE, Identifier, Message, Presence
+from errbot.core import ErrBot
+from errbot.rendering import text, xhtml
+from nio import (
+    AsyncClient,
+    InviteMemberEvent,
+    LoginError,
+    MegolmEvent,
+    RoomCreateResponse,
+    RoomEncryptionEvent,
+    RoomMemberEvent,
+    RoomMessageText,
+    RoomPreset,
+    RoomResolveAliasResponse,
+    RoomSendResponse,
+    RoomTopicEvent,
+)
+
+from err_backend_matrix.person import MatrixPerson, MatrixRoomOccupant
+from err_backend_matrix.room import MatrixRoom
+
+log = logging.getLogger(__name__)
+
+
+class MatrixBackend(ErrBot):
+    """A fully functional Errbot backend for Matrix using matrix-nio."""
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.client = None
+        self.loop = None
+        self._dm_rooms = {}
+
+        # Markdown renderers
+        self.md_text = text()
+        self.md_xhtml = xhtml()
+
+        # Bot identity configuration
+        self.homeserver = self.bot_config.BOT_IDENTITY.get("homeserver", "https://matrix.org")
+        self.mxid = self.bot_config.BOT_IDENTITY.get("username")
+        self.password = self.bot_config.BOT_IDENTITY.get("password")
+        self.token = self.bot_config.BOT_IDENTITY.get("token")
+        self.device_id = self.bot_config.BOT_IDENTITY.get("device_id")
+        self.store_path = self.bot_config.BOT_IDENTITY.get("store_path")
+        self.ssl = self.bot_config.BOT_IDENTITY.get("ssl", True)
+        self.proxy = self.bot_config.BOT_IDENTITY.get("proxy")
+
+    def run_async_coroutine(self, coro):
+        """Helper to run a coroutine in the backend event loop."""
+        if self.loop and self.loop.is_running():
+            return asyncio.run_coroutine_threadsafe(coro, self.loop)
+        else:
+            new_loop = asyncio.new_event_loop()
+            try:
+                return new_loop.run_until_complete(coro)
+            finally:
+                new_loop.close()
+
+    def run_async_coroutine_sync(self, coro):
+        """Helper to run a coroutine in the backend loop and block for the result."""
+        if self.loop and self.loop.is_running():
+            future = asyncio.run_coroutine_threadsafe(coro, self.loop)
+            return future.result()
+        else:
+            new_loop = asyncio.new_event_loop()
+            try:
+                return new_loop.run_until_complete(coro)
+            finally:
+                new_loop.close()
+
+    def serve_once(self) -> bool:
+        log.info("Initializing Matrix backend connection...")
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+        self.client = AsyncClient(
+            homeserver=self.homeserver,
+            user=self.mxid,
+            device_id=self.device_id,
+            store_path=self.store_path,
+            ssl=self.ssl,
+            proxy=self.proxy,
+        )
+
+        try:
+            self.loop.run_until_complete(self.async_run())
+        except Exception:
+            log.exception("Matrix connection crashed:")
+            return False
+        finally:
+            log.info("Closing Matrix client and loop...")
+            self.loop.run_until_complete(self.client.close())
+            self.loop.close()
+            self.loop = None
+        return True
+
+    async def async_run(self):
+        log.info("Logging into Matrix...")
+        if self.token:
+            self.client.access_token = self.token
+            self.client.user_id = self.mxid
+            # Verify token
+            await self.client.whoami()
+        elif self.password:
+            res = await self.client.login(self.password)
+            if isinstance(res, LoginError):
+                raise Exception(f"Failed to log in to Matrix: {res.message}")
+        else:
+            raise Exception("No Matrix password or token configured in BOT_IDENTITY.")
+
+        log.info("Matrix login successful.")
+        self.bot_identifier = MatrixPerson(self.client.user_id)
+
+        # Register event callbacks
+        self.client.add_event_callback(self.on_room_message, RoomMessageText)
+        self.client.add_event_callback(self.on_room_member, RoomMemberEvent)
+        self.client.add_event_callback(self.on_room_topic, RoomTopicEvent)
+        self.client.add_event_callback(self.on_invite, InviteMemberEvent)
+        self.client.add_event_callback(self.on_megolm_event, MegolmEvent)
+        self.client.add_event_callback(self.on_room_encryption, RoomEncryptionEvent)
+
+        # Trigger Errbot connect callback
+        self.connect_callback()
+
+        # Initial sync to build rooms lists and fetch state
+        log.info("Syncing with homeserver...")
+        await self.client.sync(timeout=30000)
+        log.info("Initial sync complete. Ready for events.")
+
+        # Start listening for incoming events forever
+        await self.client.sync_forever(timeout=30000)
+
+    def on_room_message(self, room, event: RoomMessageText):
+        # Skip self-sent messages
+        if event.sender == self.client.user_id:
+            return
+
+        msg = Message(body=event.body)
+        msg.extras["event_id"] = event.event_id
+
+        # Look up display name from room user cache
+        sender_user = room.users.get(event.sender)
+        display_name = sender_user.name if sender_user else None
+
+        # Check if room is DM or MUC
+        is_dm = len(room.users) <= 2 and not room.canonical_alias
+
+        if is_dm:
+            msg.frm = MatrixPerson(event.sender, displayname=display_name)
+            msg.to = self.bot_identifier
+        else:
+            room_obj = MatrixRoom(room.room_id, self)
+            msg.frm = MatrixRoomOccupant(event.sender, room_obj, displayname=display_name)
+            msg.to = room_obj
+
+        # Extract mentions
+        mentioned = []
+        for word in event.body.split():
+            if word.startswith("@") and ":" in word:
+                clean_word = word.rstrip(".,:;!?")
+                try:
+                    mentioned.append(self.build_identifier(clean_word))
+                except Exception:
+                    log.debug(f"Failed to build identifier for clean_word: {clean_word}", exc_info=True)
+
+        # Trigger message callback
+        self.callback_message(msg)
+        if mentioned:
+            self.callback_mention(msg, mentioned)
+
+    def on_room_member(self, room, event: RoomMemberEvent):
+        if event.state_key == self.client.user_id:
+            # Self membership change
+            room_obj = MatrixRoom(room.room_id, self)
+            if event.membership == "join":
+                self.callback_room_joined(room_obj)
+            elif event.membership in ("leave", "ban"):
+                self.callback_room_left(room_obj)
+        else:
+            # Other membership changes mapping to presence
+            status = ONLINE if event.membership == "join" else OFFLINE
+            room_obj = MatrixRoom(room.room_id, self)
+            user_obj = MatrixRoomOccupant(event.state_key, room_obj)
+            presence = Presence(identifier=user_obj, status=status)
+            self.callback_presence(presence)
+
+    def on_room_topic(self, room, event: RoomTopicEvent):
+        room_obj = MatrixRoom(room.room_id, self)
+        self.callback_room_topic(room_obj)
+
+    def on_invite(self, room, event: InviteMemberEvent):
+        auto_join = self.bot_config.BOT_IDENTITY.get("auto_join_on_invite", True)
+        if auto_join:
+            log.info(f"Automatically joining room {room.room_id} after invite from {event.sender}")
+            self.run_async_coroutine(self.client.join(room.room_id))
+
+    def on_megolm_event(self, room, event: MegolmEvent):
+        log.warning(
+            f"Received encrypted MegolmEvent in room {room.room_id} that could not be decrypted. Session ID: {event.session_id}"
+        )
+
+    def on_room_encryption(self, room, event: RoomEncryptionEvent):
+        log.info(f"Room {room.room_id} is now encrypted using {event.algorithm}")
+
+    def send_message(self, msg: Message) -> None:
+        super().send_message(msg)
+        self.run_async_coroutine(self._async_send_message(msg))
+
+    async def _async_send_message(self, msg: Message):
+        if not self.client:
+            log.error("Matrix client not initialized; cannot send message.")
+            return
+
+        to_id = None
+        if msg.is_group:
+            room_str = str(msg.to)
+            if room_str.startswith("#"):
+                try:
+                    res = await self.client.room_resolve_alias(room_str)
+                    if isinstance(res, RoomResolveAliasResponse):
+                        to_id = res.room_id
+                    else:
+                        to_id = room_str
+                except Exception:
+                    to_id = room_str
+            else:
+                to_id = room_str
+        else:
+            # Resolving DM room
+            user_id = msg.to.userid
+            to_id = self._dm_rooms.get(user_id)
+            if not to_id:
+                # Scan rooms list
+                for r_id, r in self.client.rooms.items():
+                    if len(r.users) <= 2 and user_id in r.users:
+                        to_id = r_id
+                        self._dm_rooms[user_id] = to_id
+                        break
+
+                if not to_id:
+                    # Create DM
+                    log.info(f"Creating DM room with {user_id}")
+                    res = await self.client.room_create(
+                        is_direct=True, invite=[user_id], preset=RoomPreset.private_chat
+                    )
+                    if isinstance(res, RoomCreateResponse):
+                        to_id = res.room_id
+                        self._dm_rooms[user_id] = to_id
+                        log.info(f"Created DM room {to_id} with {user_id}")
+                    else:
+                        log.error(f"Failed to create DM room with {user_id}: {res}")
+                        return
+
+        if not to_id:
+            log.error("Could not resolve recipient ID.")
+            return
+
+        # Markdown body conversion
+        body_text = self.md_text.convert(msg.body)
+        body_html = self.md_xhtml.convert(msg.body)
+
+        content = {
+            "msgtype": "m.text",
+            "body": body_text,
+            "format": "org.matrix.custom.html",
+            "formatted_body": body_html,
+        }
+
+        # Rich thread/replies relations
+        if msg.parent and "event_id" in msg.parent.extras:
+            content["m.relates_to"] = {"m.in_reply_to": {"event_id": msg.parent.extras["event_id"]}}
+
+        try:
+            res = await self.client.room_send(room_id=to_id, message_type="m.room.message", content=content)
+            if isinstance(res, RoomSendResponse):
+                msg.extras["event_id"] = res.event_id
+        except Exception:
+            log.exception(f"Exception sending message to {to_id}:")
+
+    def change_presence(self, status: str = ONLINE, message: str = "") -> None:
+        if not self.client:
+            return
+
+        matrix_presence = "online"
+        if status == OFFLINE:
+            matrix_presence = "offline"
+        elif status in (AWAY, DND):
+            matrix_presence = "unavailable"
+
+        self.run_async_coroutine(self.client.set_presence(matrix_presence))
+
+    def build_identifier(self, text_representation: str) -> Identifier:
+        if text_representation.startswith("!") or text_representation.startswith("#"):
+            return MatrixRoom(text_representation, self)
+        else:
+            return MatrixPerson(text_representation)
+
+    def is_from_self(self, msg: Message) -> bool:
+        return msg.frm.person == self.client.user_id
+
+    def build_reply(self, msg: Message, text=None, private: bool = False, threaded: bool = False) -> Message:
+        reply = self.build_message(text or "")
+
+        if private:
+            if isinstance(msg.frm, MatrixRoomOccupant):
+                reply.to = MatrixPerson(msg.frm.userid)
+            else:
+                reply.to = msg.frm
+        else:
+            if msg.is_group:
+                reply.to = msg.to
+            else:
+                reply.to = msg.frm
+
+        if threaded:
+            reply.parent = msg
+
+        return reply
+
+    def prefix_groupchat_reply(self, message: Message, identifier: Identifier):
+        message.body = f"@{identifier.nick}: {message.body}"
+
+    def shutdown(self) -> None:
+        log.info("Shutting down Matrix backend...")
+        if self.client:
+            self.client.stop_sync_forever()
+        super().shutdown()
+
+    @property
+    def mode(self) -> str:
+        return "matrix"
+
+    @property
+    def rooms(self) -> Sequence[MatrixRoom]:
+        if not self.client:
+            return []
+        return [MatrixRoom(room_id, self) for room_id in self.client.rooms]
+
+    def query_room(self, room: str) -> MatrixRoom:
+        return MatrixRoom(room, self)

err_backend_matrix/person.py

@@ -0,0 +1,81 @@
+import logging
+
+from errbot.backends.base import Person, RoomOccupant
+
+log = logging.getLogger(__name__)
+
+
+class MatrixPerson(Person):
+    """This class describes a person on the Matrix network."""
+
+    def __init__(self, userid: str, displayname: str = None):
+        if not userid.startswith("@") or ":" not in userid:
+            log.warning(f"Matrix user ID format might be invalid: {userid}")
+
+        self._userid = userid
+        self._displayname = displayname
+
+    @property
+    def userid(self) -> str:
+        return self._userid
+
+    @property
+    def username(self) -> str:
+        if self._displayname:
+            return self._displayname
+        if self._userid.startswith("@") and ":" in self._userid:
+            return self._userid[1:].split(":")[0]
+        return self._userid
+
+    @property
+    def fullname(self) -> str:
+        return self._displayname or self.username
+
+    @property
+    def aclattr(self) -> str:
+        return self._userid
+
+    # Errbot Person expectations
+    person = aclattr
+    nick = username
+    client = userid
+
+    def __str__(self) -> str:
+        return self._userid
+
+    def __unicode__(self) -> str:
+        return self._userid
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, MatrixPerson):
+            return False
+        return self._userid == other._userid
+
+    def __hash__(self) -> int:
+        return hash(self._userid)
+
+
+class MatrixRoomOccupant(MatrixPerson, RoomOccupant):
+    """This class represents a person inside a Matrix Room."""
+
+    def __init__(self, userid: str, room, displayname: str = None):
+        super().__init__(userid, displayname=displayname)
+        self._room = room
+
+    @property
+    def room(self):
+        return self._room
+
+    def __str__(self) -> str:
+        return f"{self._room}/{self.username}"
+
+    def __unicode__(self) -> str:
+        return f"{self._room}/{self.username}"
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, MatrixRoomOccupant):
+            return False
+        return self.room == other.room and self.userid == other.userid
+
+    def __hash__(self) -> int:
+        return hash((self.userid, self.room))

err_backend_matrix/room.py

@@ -0,0 +1,147 @@
+import logging
+
+from errbot.backends.base import Room, RoomError
+
+log = logging.getLogger(__name__)
+
+
+class MatrixRoom(Room):
+    """This class represents a Multi-User Chatroom on Matrix."""
+
+    def __init__(self, room_id_or_alias: str, backend=None):
+        self._id_or_alias = room_id_or_alias
+        self._backend = backend
+
+    def __str__(self) -> str:
+        return self._id_or_alias
+
+    @property
+    def id(self) -> str:
+        return self._id_or_alias
+
+    @property
+    def aclattr(self) -> str:
+        return self._id_or_alias
+
+    @property
+    def name(self) -> str:
+        if self._backend is not None and self._backend.client is not None:
+            resolved_id = self.resolve_room_id()
+            room = self._backend.client.rooms.get(resolved_id)
+            if room and room.name:
+                return room.name
+        return self._id_or_alias
+
+    @property
+    def exists(self) -> bool:
+        if self._backend is not None and self._backend.client is not None:
+            resolved_id = self.resolve_room_id()
+            return resolved_id in self._backend.client.rooms
+        return False
+
+    @property
+    def joined(self) -> bool:
+        if self._backend is not None and self._backend.client is not None:
+            resolved_id = self.resolve_room_id()
+            return resolved_id in self._backend.client.rooms
+        return False
+
+    def join(self, username: str = None, password: str = None) -> None:
+        if self._backend is None:
+            raise RoomError("No backend associated with room")
+        self._backend.run_async_coroutine_sync(self._backend.client.join(self._id_or_alias))
+
+    def leave(self, reason: str = None) -> None:
+        if self._backend is None:
+            raise RoomError("No backend associated with room")
+        room_id = self.resolve_room_id()
+        if not room_id:
+            raise RoomError("Could not resolve room ID to leave")
+        self._backend.run_async_coroutine_sync(self._backend.client.room_leave(room_id))
+
+    def create(self) -> None:
+        if self._backend is None:
+            raise RoomError("No backend associated with room")
+        alias_localpart = None
+        if self._id_or_alias.startswith("#") and ":" in self._id_or_alias:
+            alias_localpart = self._id_or_alias[1:].split(":")[0]
+
+        self._backend.run_async_coroutine_sync(
+            self._backend.client.room_create(alias_localpart=alias_localpart, name=alias_localpart)
+        )
+
+    def destroy(self) -> None:
+        room_id = self.resolve_room_id()
+        if room_id:
+            self._backend.run_async_coroutine_sync(self._backend.client.room_leave(room_id))
+            self._backend.run_async_coroutine_sync(self._backend.client.room_forget(room_id))
+
+    @property
+    def topic(self) -> str:
+        if self._backend is not None and self._backend.client is not None:
+            room = self._backend.client.rooms.get(self.resolve_room_id())
+            if room:
+                return room.topic or ""
+        return ""
+
+    @topic.setter
+    def topic(self, topic: str) -> None:
+        if self._backend is None:
+            raise RoomError("No backend associated with room")
+        room_id = self.resolve_room_id()
+        if not room_id:
+            raise RoomError("Could not resolve room ID to set topic")
+        self._backend.run_async_coroutine_sync(
+            self._backend.client.room_put_state(room_id=room_id, event_type="m.room.topic", content={"topic": topic})
+        )
+
+    @property
+    def occupants(self) -> list:
+        if self._backend is None or self._backend.client is None:
+            return []
+        room_id = self.resolve_room_id()
+        if not room_id:
+            return []
+        room = self._backend.client.rooms.get(room_id)
+        if not room:
+            return []
+
+        from .person import MatrixRoomOccupant
+
+        return [MatrixRoomOccupant(user_id, self, displayname=user.name) for user_id, user in room.users.items()]
+
+    def invite(self, *args) -> None:
+        if self._backend is None:
+            raise RoomError("No backend associated with room")
+        room_id = self.resolve_room_id()
+        if not room_id:
+            raise RoomError("Could not resolve room ID to invite users")
+        for user in args:
+            user_id = str(user)
+            self._backend.run_async_coroutine_sync(self._backend.client.room_invite(room_id, user_id))
+
+    def resolve_room_id(self) -> str:
+        if self._id_or_alias.startswith("!"):
+            return self._id_or_alias
+        if self._backend is not None and self._backend.client is not None:
+            # Check standard room list
+            for room_id, room in self._backend.client.rooms.items():
+                if room.canonical_alias == self._id_or_alias:
+                    return room_id
+            # Fetch resolution via API
+            try:
+                res = self._backend.run_async_coroutine_sync(self._backend.client.room_resolve_alias(self._id_or_alias))
+                # In matrix-nio, RoomResolveAliasResponse has room_id
+                if res and hasattr(res, "room_id"):
+                    return res.room_id
+            except Exception:
+                log.debug(f"Failed to resolve room alias: {self._id_or_alias}", exc_info=True)
+        return self._id_or_alias
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, MatrixRoom):
+            return False
+        return self.resolve_room_id() == other.resolve_room_id()
+
+    def __hash__(self) -> int:
+        return hash(self.resolve_room_id())