Advanced-Community-Bot/community/bot.py

# kickbot - a maubot plugin to track user activity and remove inactive users from rooms/spaces.

from typing import Awaitable, Type, Optional, Tuple
import json
import time
import re
import fnmatch
import asyncio

from mautrix.client import Client, InternalEventType, MembershipEventDispatcher, SyncStream
from mautrix.types import (Event, StateEvent, EventID, UserID, FileInfo, EventType,
                            MediaMessageEventContent, ReactionEvent, RedactionEvent, RoomID,
                            RoomAlias, PowerLevelStateEventContent, MessageType, PaginationDirection)
from mautrix.errors import MNotFound
from mautrix.util.config import BaseProxyConfig, ConfigUpdateHelper
from maubot import Plugin, MessageEvent
from maubot.handlers import command, event
BAN_STATE_EVENT = EventType.find("m.policy.rule.user", EventType.Class.STATE)

# database table related things
from .db import upgrade_table



class Config(BaseProxyConfig):
    def do_update(self, helper: ConfigUpdateHelper) -> None:
        helper.copy("sleep")
        helper.copy("welcome_sleep")
        helper.copy("admins")
        helper.copy("moderators")
        helper.copy("parent_room")
        helper.copy("track_users")
        helper.copy("track_messages")
        helper.copy("track_reactions")
        helper.copy("warn_threshold_days")
        helper.copy("kick_threshold_days")
        helper.copy("encrypt")
        helper.copy("invitees")
        helper.copy("notification_room")
        helper.copy("join_notification_message")
        helper.copy_dict("greeting_rooms")
        helper.copy_dict("greetings")
        helper.copy("censor")
        helper.copy("uncensor_pl")
        helper.copy("censor_wordlist")
        helper.copy("censor_wordlist_instaban")
        helper.copy("censor_files")
        helper.copy("banlists")
        helper.copy("proactive_banning")
        helper.copy("redact_on_ban")


class CommunityBot(Plugin):

    _redaction_tasks: asyncio.Task = None

    async def start(self) -> None:
        await super().start()
        self.config.load_and_update()
        self.client.add_dispatcher(MembershipEventDispatcher)
        # Start background redaction task
        self._redaction_tasks = asyncio.create_task(self._redaction_loop())

    async def stop(self) -> None:
        if self._redaction_tasks:
            self._redaction_tasks.cancel()
        await super().stop()

    async def _redaction_loop(self) -> None:
        while True:
            try:
                # Get all rooms with pending redactions
                rooms = await self.database.fetch(
                    "SELECT DISTINCT room_id FROM redaction_tasks"
                )
                for room in rooms:
                    await self.redact_messages(room['room_id'])
                await asyncio.sleep(60)  # Run every minute
            except asyncio.CancelledError:
                break
            except Exception as e:
                self.log.error(f"Error in redaction loop: {e}")
                await asyncio.sleep(60)  # Wait a minute before retrying on error

    async def do_sync(self) -> None:
        if not self.config["track_users"]:
            return "user tracking is disabled"

        space_members_obj = await self.client.get_joined_members(self.config["parent_room"])
        space_members_list = space_members_obj.keys()
        table_users = await self.database.fetch("SELECT mxid FROM user_events")
        table_user_list = [ row["mxid"] for row in table_users ]
        untracked_users = set(space_members_list) - set(table_user_list)
        non_space_members = set(table_user_list) - set(space_members_list)
        results = {}
        results['added'] = []
        results['dropped'] = []
        try:
            for user in untracked_users:
                now = int(time.time() * 1000)
                q = """
                    INSERT INTO user_events (mxid, last_message_timestamp)
                    VALUES ($1, $2)
                    """
                await self.database.execute(q, user, now)
                results['added'].append(user)
                self.log.info(f"{user} inserted into activity tracking table")
            for user in non_space_members:
                await self.database.execute("DELETE FROM user_events WHERE mxid = $1", user)
                self.log.info(f"{user} is not a space member, dropped from activity tracking table")
                results['dropped'].append(user)

        except Exception as e:
            self.log.exception(e)

        return results

    async def get_space_roomlist(self) -> None:
        space = self.config["parent_room"]
        rooms = []
        state = await self.client.get_state(space)
        for evt in state:
            if evt.type == EventType.SPACE_CHILD:
                # only look for rooms that include a via path, otherwise they
                # are not really in the space!
                if evt.content and evt.content.via:
                    rooms.append(evt.state_key)
        return rooms

    async def generate_report(self) -> None:
        now = int(time.time() * 1000)
        warn_days_ago = (now - (1000 * 60 * 60 * 24 * self.config["warn_threshold_days"]))
        kick_days_ago = (now - (1000 * 60 * 60 * 24 * self.config["kick_threshold_days"]))
        warn_q = """
            SELECT mxid FROM user_events WHERE last_message_timestamp <= $1 AND 
            last_message_timestamp >= $2
            AND (ignore_inactivity < 1 OR ignore_inactivity IS NULL)
            """
        kick_q = """
            SELECT mxid FROM user_events WHERE last_message_timestamp <= $1
            AND (ignore_inactivity < 1 OR ignore_inactivity IS NULL)
            """
        ignored_q = """
            SELECT mxid FROM user_events WHERE ignore_inactivity = 1
            """
        warn_inactive_results = await self.database.fetch(warn_q, warn_days_ago, kick_days_ago)
        kick_inactive_results = await self.database.fetch(kick_q, kick_days_ago)
        ignored_results = await self.database.fetch(ignored_q)
        report = {}
        report["warn_inactive"] = [ row["mxid"] for row in warn_inactive_results ] or ["none"]
        report["kick_inactive"] = [ row["mxid"] for row in kick_inactive_results ] or ["none"]
        report["ignored"] = [ row["mxid"] for row in ignored_results ] or ["none"]

        return report

    def flag_message(self, msg):
        if msg.content.msgtype in [MessageType.FILE, MessageType.IMAGE, MessageType.VIDEO]:
            return self.config['censor_files']

        for w in self.config['censor_wordlist']:
            try:
                if bool(re.search(w, msg.content.body, re.IGNORECASE)):
                    #self.log.debug(f"DEBUG message flagged for censorship")
                    return True
                else:
                    pass
            except Exception as e:
                self.log.error(f"Could not parse message for flagging: {e}")

    def flag_instaban(self, msg):
        for w in self.config['censor_wordlist_instaban']:
            try:
                if bool(re.search(w, msg.content.body, re.IGNORECASE)):
                    #self.log.debug(f"DEBUG message flagged for instaban")
                    return True
                else:
                    pass
            except Exception as e:
                self.log.error(f"Could not parse message for flagging: {e}")


    def censor_room(self, msg):
        if isinstance(self.config['censor'], bool):
            #self.log.debug(f"DEBUG message will be redacted because censoring is enabled")
            return self.config['censor']
        elif isinstance(self.config['censor'], list):
            if msg.room_id in self.config['censor']:
                #self.log.debug(f"DEBUG message will be redacted because censoring is enabled for THIS room")
                return True
        else:
            return False

    async def check_if_banned(self, userid):
        # fetch banlist data
        is_banned = False
        myrooms = await self.client.get_joined_rooms()
        banlist_roomids = await self.get_banlist_roomids()
        
        for list_id in banlist_roomids:
            if list_id not in myrooms:
                self.log.error(f"Bot must be in {list_id} before attempting to use it as a banlist.")
                pass

            #self.log.debug(f"DEBUG looking up state in {list_id}")
            list_state = await self.client.get_state(list_id)
            #self.log.debug(f"DEBUG state found: {list_state}")
            try:
                user_policies = list(filter(lambda p : p.type.t=='m.policy.rule.user', list_state))
                #self.log.debug(f"DEBUG user policies found: {user_policies}")
            except Exception as e:
                self.log.error(e)

            for rule in user_policies:
                #self.log.debug(f"Checking match of user {userid} in banlist {l} for {rule['content']}")
                try:
                    if bool(fnmatch.fnmatch(userid, rule["content"]["entity"])) and \
                            bool(re.search('ban$', rule["content"]["recommendation"])):
                        #self.log.debug(f"DEBUG user {userid} matches ban rule {rule['content']['entity']}!")
                        return True
                    else:
                        pass
                except Exception as e:
                    self.log.debug(f"Found something funny in the banlist {list_id} for {rule['content']}: {e}")
                    pass
        # if we haven't exited by now, we must not be banned!
        return is_banned
    
    async def get_messages_to_redact(self, room_id, mxid):
        try:
            messages = await self.client.get_messages(
                room_id,
                limit=100,
                filter_json={
                    "senders": [mxid],
                    "not_types": ["m.room.redaction"]
                },
                direction=PaginationDirection.BACKWARD
            )
            # Filter out events with empty content
            filtered_events = [event for event in messages.events if event.content and event.content.serialize()]
            self.log.debug(f"DEBUG found {len(filtered_events)} messages to redact in {room_id} (after filtering empty content)")
            return filtered_events
        except Exception as e:
            self.log.error(f"Error getting messages to redact: {e}")
            return []
    
    async def redact_messages(self, room_id):
        counters = {'success': 0, 'failure': 0}
        sleep_time = self.config['sleep']
        events = await self.database.fetch(
            "SELECT event_id FROM redaction_tasks WHERE room_id = $1",
            room_id
        )
        for event in events:
            try:
                await self.client.redact(room_id, event['event_id'], reason="content removed")
                counters['success'] += 1
                await self.database.execute(
                    "DELETE FROM redaction_tasks WHERE event_id = $1",
                    event['event_id']
                )
                await asyncio.sleep(sleep_time)
            except Exception as e:
                if "Too Many Requests" in str(e):
                    self.log.warning(f"Rate limited while redacting messages in {room_id}, will try again in next loop")
                    return counters
                self.log.error(f"Failed to redact message: {e}")
                counters['failure'] += 1
                await asyncio.sleep(sleep_time)
        return counters

    async def check_bot_permissions(self, room_id: str, evt: MessageEvent = None, required_permissions: list[str] = None) -> tuple[bool, str, dict]:
        """Check if the bot has necessary permissions in a room.
        
        Args:
            room_id: The ID of the room to check permissions in
            evt: Optional MessageEvent for progress updates
            required_permissions: List of specific permissions to check. If None, checks basic room access.
            
        Returns:
            tuple: (bool, str, dict) - (has_permissions, error_message, permission_details)
        """
        try:
            # Check if bot is in the room
            try:
                await self.client.get_state_event(room_id, EventType.ROOM_MEMBER, self.client.mxid)
            except MNotFound:
                return False, "Bot is not a member of this room", {}

            # Get power levels
            power_levels = await self.client.get_state_event(room_id, EventType.ROOM_POWER_LEVELS)
            bot_level = power_levels.users.get(self.client.mxid, power_levels.users_default)
            
            # Define required power levels for different actions
            permission_requirements = {
                "redact": power_levels.redact,
                "kick": power_levels.kick,
                "ban": power_levels.ban,
                "invite": power_levels.invite,
                "tombstone": power_levels.events.get("m.room.tombstone", power_levels.events_default),
                "power_levels": power_levels.events.get("m.room.power_levels", power_levels.events_default),
                "state": power_levels.state_default
            }
            
            # Check each required permission
            permission_status = {}
            if required_permissions:
                for perm in required_permissions:
                    if perm in permission_requirements:
                        required_level = permission_requirements[perm]
                        permission_status[perm] = {
                            "has_permission": bot_level >= required_level,
                            "required_level": required_level,
                            "bot_level": bot_level
                        }
            
            # If no specific permissions requested, just check basic access
            if not required_permissions:
                if bot_level < 50:  # Basic moderator level
                    return False, "Bot does not have sufficient power level (needs at least moderator level)", permission_status
                return True, "", permission_status
            
            # Check if all requested permissions are granted
            missing_permissions = [perm for perm, status in permission_status.items() 
                                 if not status["has_permission"]]
            
            if missing_permissions:
                error_msg = "Bot is missing required permissions: " + ", ".join(missing_permissions)
                return False, error_msg, permission_status
            
            return True, "", permission_status

        except Exception as e:
            error_msg = f"Failed to check bot permissions: {e}"
            self.log.error(error_msg)
            if evt:
                await evt.respond(error_msg)
            return False, error_msg, {}

    async def do_archive_room(self, room_id: str, evt: MessageEvent = None, replacement_room: str = "") -> bool:
        """Handle common room archival activities like removing from space, removing aliases, and setting tombstone.
        
        Args:
            room_id: The ID of the room to archive
            evt: Optional MessageEvent for progress updates
            replacement_room: Optional room ID to point to in the tombstone event
            
        Returns:
            bool: True if all operations succeeded, False otherwise
        """
        try:
            # Check permissions for all required operations
            has_perms, error_msg, _ = await self.check_bot_permissions(
                room_id, 
                evt,
                ["state", "tombstone", "power_levels"]
            )
            if not has_perms:
                if evt:
                    await evt.respond(f"Cannot archive room: {error_msg}")
                return False

            # Try to remove the room from the space first
            self.log.debug(f"DEBUG removing space state reference from {room_id}")
            await self.client.send_state_event(
                room_id=room_id,
                event_type="m.space.parent",
                content={},  # Empty content removes the state
                state_key=self.config["parent_room"]
            )
            self.log.info(f"Removed parent space reference from room {room_id}")

            # Remove the child reference from the space
            self.log.debug(f"DEBUG removing child state reference from {self.config['parent_room']}")
            await self.client.send_state_event(
                self.config["parent_room"], 
                event_type="m.space.child",
                content={},  # Empty content removes the state
                state_key=room_id
            )
            self.log.info(f"Removed child room reference from space {self.config['parent_room']}")

            # Remove room aliases to release them
            await self.remove_room_aliases(room_id, evt)

            # Send the tombstone
            tombstone_content = {
                "body": "This room has been archived." if not replacement_room else "This room has been replaced. Please join the new room.",
                "replacement_room": replacement_room
            }
            await self.client.send_state_event(
                room_id=room_id,
                event_type=EventType.ROOM_TOMBSTONE,
                content=tombstone_content
            )
            self.log.info(f"Successfully added tombstone to room {room_id}")
            
            return True

        except Exception as e:
            error_msg = f"Failed to archive room: {e}"
            self.log.error(error_msg)
            if evt:
                await evt.respond(error_msg)
            return False

    async def remove_room_aliases(self, room_id: str, evt: MessageEvent = None) -> list:
        """Remove all aliases from a room.
        
        Args:
            room_id: The ID of the room whose aliases to remove
            evt: Optional MessageEvent for progress updates
            
        Returns:
            list: List of aliases that were successfully removed
        """
        removed_aliases = []

        try:
            aliases = await self.client.get_state_event(
                room_id=room_id,
                event_type=EventType.ROOM_CANONICAL_ALIAS
            )
        except Exception as e:
            self.log.warning(f"Failed to get room alias state event, skipping: {e}")
            return removed_aliases
        
        if aliases.alt_aliases:
            for alias in aliases.alt_aliases:
                try:
                    await self.client.remove_room_alias(
                        alias_localpart=alias.split(':')[0].lstrip('#'),
                    )
                    self.log.info(f"Removed alias {alias} from room {room_id}")
                    removed_aliases.append(alias)
                except Exception as e:
                    self.log.warning(f"Failed to remove alias {alias}: {e}")

        if aliases.canonical_alias:
            try:
                await self.client.remove_room_alias(
                    alias_localpart=aliases.canonical_alias.split(':')[0].lstrip('#'),
                )
                self.log.info(f"Removed canonical alias {aliases.canonical_alias} from room {room_id}")
                removed_aliases.append(aliases.canonical_alias)
            except Exception as e:
                self.log.warning(f"Failed to remove canonical alias: {e}")

        return removed_aliases

    async def ban_this_user(self, user, reason="banned", all_rooms=False):
        roomlist = await self.get_space_roomlist()
        # don't forget to kick from the space itself
        roomlist.append(self.config["parent_room"])
        ban_event_map = {'ban_list':{}, 'error_list':{}}

        ban_event_map['ban_list'][user] = []
        for room in roomlist:
            try:
                roomname = None
                roomnamestate = await self.client.get_state_event(room, 'm.room.name')
                roomname = roomnamestate['name']

                # ban user even if they're not in the room!
                if all_rooms:
                    pass
                else:
                    await self.client.get_state_event(room, EventType.ROOM_MEMBER, user)

                await self.client.ban_user(room, user, reason=reason)
                if roomname:
                    ban_event_map['ban_list'][user].append(roomname)
                else:
                    ban_event_map['ban_list'][user].append(room)
                time.sleep(self.config['sleep'])
            except MNotFound:
                pass
            except Exception as e:
                self.log.warning(e)
                ban_event_map['error_list'][user] = []
                ban_event_map['error_list'][user].append(roomname or room)

            if self.config["redact_on_ban"]:
                messages = await self.get_messages_to_redact(room, user)
                # Queue messages for redaction
                for msg in messages:
                    await self.database.execute(
                        "INSERT INTO redaction_tasks (event_id, room_id) VALUES ($1, $2)",
                        msg.event_id,
                        room
                    )
                self.log.info(f"Queued {len(messages)} messages for redaction in {roomname or room}")

        return ban_event_map

    async def get_banlist_roomids(self):
        banlist_roomids = []
        for l in self.config['banlists']:
            #self.log.debug(f"DEBUG getting banlist {l}")
            if l.startswith('#'):
                try:
                    l_id = await self.client.resolve_room_alias(l)
                    list_id = l_id["room_id"]
                    time.sleep(self.config['sleep'])
                    #self.log.debug(f"DEBUG banlist id resolves to: {list_id}")
                except:
                    self.log.error(f"Banlist fetching failed for {l}")
                    return
            else:
                list_id = l

            banlist_roomids.append(list_id)

        return banlist_roomids


    @event.on(BAN_STATE_EVENT)
    async def check_ban_event(self, evt:StateEvent) -> None:
        if not self.config["proactive_banning"]:
            return

        banlist_roomids = await self.get_banlist_roomids()
        # we only care about ban events in rooms in the banlist
        if evt.room_id not in banlist_roomids:
            return
        else:
            try:
                entity = evt.content["entity"]
                recommendation = evt.content["recommendation"]
                self.log.debug(f"DEBUG new ban rule found: {entity} should have action {recommendation}")
                if bool(re.search(r"[*?]", entity)):
                    self.log.debug(f"DEBUG ban rule appears to be glob pattern, skipping proactive measures.")
                    return
                if bool(re.search('ban$', recommendation)):
                    await self.ban_this_user(entity)
            except Exception as e:
                self.log.error(e)

        
    @event.on(InternalEventType.JOIN)
    async def newjoin(self, evt:StateEvent) -> None:
        if evt.source & SyncStream.STATE:
            return
        else:
            on_banlist = await self.check_if_banned(evt.sender)
            if on_banlist:
                #self.log.debug(f"DEBUG user is on banlist!")
                # ban this account in managed rooms, don't bother with anything else
                await self.ban_this_user(evt.sender)
                return
            # passive sync of tracking db
            if evt.room_id == self.config['parent_room']:
                await self.do_sync()
            # greeting activities
            room_id = str(evt.room_id)
            if room_id in self.config["greeting_rooms"]:
                # just in case we got here even if the person is on the banlists
                if on_banlist:
                    return
                greeting_map = self.config['greetings']
                greeting_name = self.config['greeting_rooms'][room_id]
                nick = self.client.parse_user_id(evt.sender)[0]
                pill = '<a href="https://matrix.to/#/{mxid}">{nick}</a>'.format(mxid=evt.sender, nick=nick)
                if greeting_name != "none":
                    greeting = greeting_map[greeting_name].format(user=pill)
                    time.sleep(self.config['welcome_sleep'])
                    await self.client.send_notice(evt.room_id, html=greeting) 
                else:
                    pass
                if self.config["notification_room"]:
                    roomnamestate = await self.client.get_state_event(evt.room_id, 'm.room.name')
                    roomname = roomnamestate['name']
                    notification_message = self.config['join_notification_message'].format(user=evt.sender, 
                                                                                      room=roomname)
                    await self.client.send_notice(self.config["notification_room"], html=notification_message)

    @event.on(EventType.ROOM_MESSAGE)
    async def update_message_timestamp(self, evt: MessageEvent) -> None:
        power_levels = await self.client.get_state_event(evt.room_id, EventType.ROOM_POWER_LEVELS)
        user_level = power_levels.get_user_level(evt.sender)
        #self.log.debug(f"DEBUGDEBUG user {evt.sender} has power level {user_level}")
        if self.flag_message(evt):
            # do we need to redact?
            if evt.sender not in self.config['admins'] and \
                    evt.sender not in self.config['moderators'] and \
                    user_level < self.config['uncensor_pl'] and \
                    evt.sender != self.client.mxid and \
                    self.censor_room(evt):
                try:
                    await self.client.redact(evt.room_id, evt.event_id, reason="message flagged")
                except Exception as e:
                    self.log.error(f"Flagged message could not be redacted: {e}")
        if evt.content.msgtype in {MessageType.TEXT, MessageType.NOTICE, MessageType.EMOTE}:
            if self.flag_instaban(evt):
                # do we need to redact?
                if evt.sender not in self.config['admins'] and \
                        evt.sender not in self.config['moderators'] and \
                        user_level < self.config['uncensor_pl'] and \
                        evt.sender != self.client.mxid and \
                        self.censor_room(evt):
                    try:
                        await self.client.redact(evt.room_id, evt.event_id, reason="message flagged")
                    except Exception as e:
                        self.log.error(f"Flagged message could not be redacted: {e}")
                        
                    await self.ban_this_user(evt.sender, all_rooms=True)

        if not self.config["track_messages"] or not self.config["track_users"]:
            pass
        else:
            rooms_to_manage = await self.get_space_roomlist()
            # only attempt to track rooms in the space, ignore any other rooms
            # the bot may happen to be in line banlist policy rooms etc.
            if evt.room_id not in rooms_to_manage:
                return
            else:
                q = """
                    INSERT INTO user_events(mxid, last_message_timestamp) 
                    VALUES ($1, $2)
                    ON CONFLICT(mxid)
                    DO UPDATE SET last_message_timestamp=$2
                """
                await self.database.execute(q, evt.sender, evt.timestamp)

    @event.on(EventType.REACTION)
    async def update_reaction_timestamp(self, evt: MessageEvent) -> None:
        if not self.config["track_reactions"] or not self.config["track_users"]:
            pass
        else:
            rooms_to_manage = await self.get_space_roomlist()
            # only attempt to track rooms in the space, ignore any other rooms
            # the bot may happen to be in line banlist policy rooms etc.
            if evt.room_id not in rooms_to_manage:
                return
            else:
                q = """
                    INSERT INTO user_events(mxid, last_message_timestamp) 
                    VALUES ($1, $2)
                    ON CONFLICT(mxid)
                    DO UPDATE SET last_message_timestamp=$2
                """
                await self.database.execute(q, evt.sender, evt.timestamp)

    @command.new("community", help="manage rooms and members of a space")
    async def community(self) -> None:
        pass

    @community.subcommand("bancheck", help="check subscribed banlists for a user's mxid")
    @command.argument("mxid", "full matrix ID", required=True)
    async def check_banlists(self, evt: MessageEvent, mxid: UserID) -> None:
        ban_status = await self.check_if_banned(mxid)
        await evt.reply(f"user on banlist: {ban_status}")


    @community.subcommand("sync", help="update the activity tracker with the current space members \
            in case they are missing")
    async def sync_space_members(self, evt: MessageEvent) -> None:
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not self.config["track_users"]:
                await evt.respond("user tracking is disabled")
                return

            results = await self.do_sync()

            added_str = "<br />".join(results['added'])
            dropped_str = "<br />".join(results['dropped'])
            await evt.respond(f"Added: {added_str}<br /><br />Dropped: {dropped_str}", allow_html=True)
        else:
            await evt.reply("lol you don't have permission to do that")


    @community.subcommand("ignore", help="exclude a specific matrix ID from inactivity tracking")
    @command.argument("mxid", "full matrix ID", required=True)
    async def ignore_inactivity(self, evt: MessageEvent, mxid: UserID) -> None:
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not self.config["track_users"]:
                await evt.reply("user tracking is disabled")
                return

            try:
                Client.parse_user_id(mxid)
                await self.database.execute("UPDATE user_events SET ignore_inactivity = 1 WHERE \
                        mxid = $1", mxid)
                self.log.info(f"{mxid} set to ignore inactivity")
                await evt.react("✅")
            except Exception as e:
                await evt.respond(f"{e}")
        else:
            await evt.reply("lol you don't have permission to set that")

    @community.subcommand("unignore", help="re-enable activity tracking for a specific matrix ID")
    @command.argument("mxid", "full matrix ID", required=True)
    async def unignore_inactivity(self, evt: MessageEvent, mxid: UserID) -> None:
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not self.config["track_users"]:
                await evt.reply("user tracking is disabled")
                return

            try:
                Client.parse_user_id(mxid)
                await self.database.execute("UPDATE user_events SET ignore_inactivity = 0 WHERE \
                        mxid = $1", mxid)
                self.log.info(f"{mxid} set to track inactivity")
                await evt.react("✅")
            except Exception as e:
                await evt.respond(f"{e}")
        else:
            await evt.reply("lol you don't have permission to set that")

    @community.subcommand("report", help='generate a list of matrix IDs that have been inactive')
    async def get_report(self, evt: MessageEvent) -> None:
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not self.config["track_users"]:
                await evt.reply("user tracking is disabled")
                return

            sync_results = await self.do_sync()
            report = await self.generate_report()
            await evt.respond(f"<p><b>Users inactive for between {self.config['warn_threshold_days']} and \
                    {self.config['kick_threshold_days']} days:</b><br /> \
                    {'<br />'.join(report['warn_inactive'])} <br /></p>\
                    <p><b>Users inactive for at least {self.config['kick_threshold_days']} days:</b><br /> \
                    {'<br />'.join(report['kick_inactive'])} <br /></p> \
                    <p><b>Ignored users:</b><br /> \
                    {'<br />'.join(report['ignored'])}</p>", \
                    allow_html=True)


    @community.subcommand("purge", help='kick users for excessive inactivity')
    async def kick_users(self, evt: MessageEvent) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            msg = await evt.respond("starting the purge...")
            report = await self.generate_report()
            purgeable = report['kick_inactive']
            roomlist = await self.get_space_roomlist()
            # don't forget to kick from the space itself
            roomlist.append(self.config["parent_room"])
            purge_list = {}
            error_list = {}

            for user in purgeable:
                purge_list[user] = []
                for room in roomlist:
                    try:
                        roomname = None
                        roomnamestate = await self.client.get_state_event(room, 'm.room.name')
                        roomname = roomnamestate['name']

                        await self.client.get_state_event(room, EventType.ROOM_MEMBER, user)
                        await self.client.kick_user(room, user, reason='inactivity')
                        if roomname:
                            purge_list[user].append(roomname)
                        else:
                            purge_list[user].append(room)
                        time.sleep('sleep')
                    except MNotFound:
                        pass
                    except Exception as e:
                        self.log.warning(e)
                        error_list[user] = []
                        error_list[user].append(roomname or room)


            results = "the following users were purged:<p><code>{purge_list}</code></p>the following errors were \
                    recorded:<p><code>{error_list}</code></p>".format(purge_list=purge_list, error_list=error_list)
            await evt.respond(results, allow_html=True, edits=msg)
        
            # sync our database after we've made changes to room memberships
            await self.do_sync()

        else:
            await evt.reply("lol you don't have permission to do that")


    @community.subcommand("kick", help='kick a specific user from the community and all rooms')
    @command.argument("mxid", "full matrix ID", required=True)
    async def kick_user(self, evt: MessageEvent, mxid: UserID) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            user = mxid
            msg = await evt.respond("starting the purge...")
            roomlist = await self.get_space_roomlist()
            # don't forget to kick from the space itself
            roomlist.append(self.config["parent_room"])
            purge_list = {}
            error_list = {}

            purge_list[user] = []
            for room in roomlist:
                try:
                    roomname = None
                    roomnamestate = await self.client.get_state_event(room, 'm.room.name')
                    roomname = roomnamestate['name']

                    await self.client.get_state_event(room, EventType.ROOM_MEMBER, user)
                    await self.client.kick_user(room, user, reason='kicked')
                    if roomname:
                        purge_list[user].append(roomname)
                    else:
                        purge_list[user].append(room)
                    time.sleep(self.config['sleep'])
                except MNotFound:
                    pass
                except Exception as e:
                    self.log.warning(e)
                    error_list[user] = []
                    error_list[user].append(roomname or room)


            results = "the following users were kicked:<p><code>{purge_list}</code></p>the following errors were \
                    recorded:<p><code>{error_list}</code></p>".format(purge_list=purge_list, error_list=error_list)
            await evt.respond(results, allow_html=True, edits=msg)
        
            # sync our database after we've made changes to room memberships
            await self.do_sync()

        else:
            await evt.reply("lol you don't have permission to do that")


    @community.subcommand("ban", help='kick and ban a specific user from the community and all rooms')
    @command.argument("mxid", "full matrix ID", required=True)
    async def ban_user(self, evt: MessageEvent, mxid: UserID) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            user = mxid
            msg = await evt.respond("starting the ban...")
            results_map = await self.ban_this_user(user, all_rooms=True)


            results = "the following users were kicked and banned:<p><code>{ban_list}</code></p>the following errors were \
                    recorded:<p><code>{error_list}</code></p>".format(ban_list=results_map['ban_list'],
                                                                      error_list=results_map['error_list'])
            await evt.respond(results, allow_html=True, edits=msg)
        
            # sync our database after we've made changes to room memberships
            await self.do_sync()

        else:
            await evt.reply("lol you don't have permission to do that")


    @community.subcommand("unban", help='unban a specific user from the community and all rooms')
    @command.argument("mxid", "full matrix ID", required=True)
    async def unban_user(self, evt: MessageEvent, mxid: UserID) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            user = mxid
            msg = await evt.respond("starting the unban...")
            roomlist = await self.get_space_roomlist()
            # don't forget to kick from the space itself
            roomlist.append(self.config["parent_room"])
            unban_list = {}
            error_list = {}

            unban_list[user] = []
            for room in roomlist:
                try:
                    roomname = None
                    roomnamestate = await self.client.get_state_event(room, 'm.room.name')
                    roomname = roomnamestate['name']

                    await self.client.get_state_event(room, EventType.ROOM_MEMBER, user)
                    await self.client.unban_user(room, user, reason='unbanned')
                    if roomname:
                        unban_list[user].append(roomname)
                    else:
                        unban_list[user].append(room)
                    time.sleep(self.config['sleep'])
                except MNotFound:
                    pass
                except Exception as e:
                    self.log.warning(e)
                    error_list[user] = []
                    error_list[user].append(roomname or room)


            results = "the following users were unbanned:<p><code>{unban_list}</code></p>the following errors were \
                    recorded:<p><code>{error_list}</code></p>".format(unban_list=unban_list, error_list=error_list)
            await evt.respond(results, allow_html=True, edits=msg)
        
            # sync our database after we've made changes to room memberships
            await self.do_sync()

        else:
            await evt.reply("lol you don't have permission to do that")

    @community.subcommand("redact", help="redact messages from a specific user (optionally in a specific room)")
    @command.argument("mxid", "full matrix ID", required=True)
    @command.argument("room", "room ID", required=False)
    async def mark_for_redaction(self, evt: MessageEvent, mxid: UserID, room: str) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if room:
                if room.startswith('#'):
                    room_id = await self.client.resolve_room_alias(room)
                    room_id = room_id["room_id"]
                else:
                    room_id = room
            else:
                room_id = evt.room_id

            # get list of messages to redact in this room
            messages = await self.get_messages_to_redact(room_id, mxid)
            for msg in messages:
                await self.database.execute(
                    "INSERT INTO redaction_tasks (event_id, room_id) VALUES ($1, $2)",
                    msg.event_id,
                    room_id
                )
            await evt.respond(f"Queued {len(messages)} messages for redaction in {room_id}")
        else:
            await evt.reply("lol you don't have permission to do that")

    async def create_room(self, roomname: str, evt: MessageEvent = None) -> None:
        """Create a new room and add it to the parent space.
        
        Args:
            roomname: The name for the new room
            evt: Optional MessageEvent for progress updates. If provided, will send status messages.
            
        Returns:
            tuple: (room_id, room_alias) if successful, None if failed
        """
        encrypted_flag_regex = re.compile(r'(\s+|^)-+encrypt(ed)?\s?')
        force_encryption = bool(encrypted_flag_regex.search(roomname))
        try:
            if force_encryption:
                roomname = encrypted_flag_regex.sub('', roomname)
            sanitized_name = re.sub(r"[^a-zA-Z0-9]", '', roomname).lower()
            invitees = self.config['invitees']
            parent_room = self.config['parent_room']
            server = self.client.parse_user_id(self.client.mxid)[1]
            
            # Set bot PL higher than admin so we can kick old admins if needed
            pl_override = {"users": {self.client.mxid: 1000}}
            for u in self.config['admins']:
                pl_override["users"][u] = 100
            for u in self.config['moderators']:
                pl_override["users"][u] = 50

            if evt:
                mymsg = await evt.respond(f"creating {sanitized_name}, give me a minute...")
            
            room_id = await self.client.create_room(
                alias_localpart=sanitized_name,
                name=roomname,
                invitees=invitees,
                power_level_override=pl_override
            )
            await asyncio.sleep(self.config['sleep'])

            if evt:
                await evt.respond(f"updating room states...", edits=mymsg)

            # Set up room state events
            parent_event_content = json.dumps({'auto_join': False, 'suggested': False, 'via': [server]})
            child_event_content = json.dumps({'canonical': True, 'via': [server]})
            join_rules_content = json.dumps({
                'join_rule': 'restricted',
                'allow': [{'type': 'm.room_membership', 'room_id': parent_room}]
            })

            await self.client.send_state_event(parent_room, 'm.space.child', parent_event_content, state_key=room_id)
            await asyncio.sleep(self.config['sleep'])
            await self.client.send_state_event(room_id, 'm.space.parent', child_event_content, state_key=parent_room)
            await asyncio.sleep(self.config['sleep'])
            await self.client.send_state_event(room_id, 'm.room.join_rules', join_rules_content, state_key="")
            await asyncio.sleep(self.config['sleep'])

            if self.config["encrypt"] or force_encryption:
                encryption_content = json.dumps({"algorithm": "m.megolm.v1.aes-sha2"})
                await self.client.send_state_event(room_id, 'm.room.encryption', encryption_content, state_key="")
                if evt:
                    await evt.respond(f"encrypting room...", edits=mymsg)
                await asyncio.sleep(self.config['sleep'])

            if evt:
                await evt.respond(f"room created and updated, alias is #{sanitized_name}:{server}", edits=mymsg)

            return room_id, f"#{sanitized_name}:{server}"

        except Exception as e:
            if evt:
                await evt.respond(f"i tried, but something went wrong: \"{e}\"", edits=mymsg)
            self.log.error(f"Failed to create room: {e}")
            return None

    @community.subcommand("createroom", help="create a new room titled <roomname> and add it to the parent space. \
                          optionally include `--encrypt` to encrypt it regardless of the default settings.")
    @command.argument("roomname", pass_raw=True, required=True)
    async def create_that_room(self, evt: MessageEvent, roomname: str) -> None:
        if (roomname == "help") or len(roomname) == 0:
            await evt.reply('pass me a room name (like "cool topic") and i will create it and add it to the space. \
                            use `--encrypt` to ensure it is encrypted at creation time even if that isnt my default \
                            setting.')
        else:
            if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
                await self.create_room(roomname, evt)
            else:
                await evt.reply("you're not the boss of me!")

    @community.subcommand("archive", help="archive a room")
    @command.argument("room", required=False)
    async def archive_room(self, evt: MessageEvent, room: str) -> None:
        await evt.mark_read()

        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not room:
                room_id = evt.room_id
                self.log.debug(f"DEBUG room we are archiving is {room_id}")
            elif room and room.startswith('#'):
                try:
                    self.log.debug(f"DEBUG trying to resolve alias {room}")
                    room_id = await self.client.resolve_room_alias(room)
                    room_id = room_id["room_id"]
                    self.log.debug(f"DEBUG room we are archiving is {room_id}")
                except Exception as e:
                    evt.reply("i couldn't resolve that alias, sorry")
                    self.log.error(f"error resolving alias {room}: {e}")
                    return
            elif room and room.startswith('!'):
                room_id = room
                self.log.debug(f"DEBUG room we are archiving is {room_id}")
            else:
                evt.reply("i don't recognize that room, sorry")
                return

            success = await self.do_archive_room(room_id, evt)
            
            # Only try to respond if we're not archiving the room we're in
            if success and room_id != evt.room_id:
                await evt.respond("Room has been archived.")

    @community.subcommand("replaceroom", help="replace a room with a new one")
    @command.argument("room", required=False)
    async def replace_room(self, evt: MessageEvent, room: str) -> None:
        await evt.mark_read()

        if evt.sender in self.config["admins"] or evt.sender in self.config["moderators"]:
            if not room:
                room = evt.room_id
            # first we need to get relevant room state of the room we want to replace
            # this includes the room name, alias, and join rules
            if room.startswith('#'):
                room_id = await self.client.resolve_room_alias(room)
                room_id = room_id["room_id"]
            else:
                room_id = room

            # Check bot permissions in the old room
            has_perms, error_msg, _ = await self.check_bot_permissions(
                room_id, 
                evt,
                ["state", "tombstone", "power_levels"]
            )
            if not has_perms:
                await evt.respond(f"Cannot replace room: {error_msg}")
                return

            # Get the room name from the state event
            try:
                room_name_event = await self.client.get_state_event(room_id, EventType.ROOM_NAME)
                room_name = room_name_event.name
            except Exception as e:
                self.log.warning(f"Failed to get room name: {e}")
                #await evt.respond("Could not find room name in state events")
                pass

            # get the room topic from the state event
            try:
                room_topic_event = await self.client.get_state_event(room_id, EventType.ROOM_TOPIC)
                room_topic = room_topic_event.topic
            except Exception as e:
                self.log.warning(f"Failed to get room topic: {e}")
                pass

            # Get list of aliases to transfer while removing them from the old room
            aliases_to_transfer = await self.remove_room_aliases(room_id, evt)

            # Now we can start the process of replacing the room
            # First we need to create the new room. this will create the initial alias,
            # as well as bot defaults such as power levels, initial invitations, encryption,
            # and space membership
            new_room_id, new_room_alias = await self.create_room(room_name, evt)
            if not new_room_id:
                await evt.respond("Failed to create new room")
                return

            # Check bot permissions in the new room
            has_perms, error_msg, _ = await self.check_bot_permissions(
                new_room_id, 
                evt,
                ["state", "tombstone", "power_levels"]
            )
            if not has_perms:
                await evt.respond(f"Created new room but cannot complete replacement: {error_msg}")
                return

            # Transfer the aliases to the new room
            for alias in aliases_to_transfer:
                localpart = alias.split(':')[0][1:]  # Remove # and get localpart
                server = alias.split(':')[1]
                try:
                    await self.client.add_room_alias(new_room_id, localpart)
                    self.log.info(f"Successfully transferred alias {alias} to new room {new_room_id}")
                except Exception as e:
                    # If transfer failed, try to create a modified alias
                    modified_alias = f"{localpart}NEW"
                    try:
                        await self.client.add_room_alias(new_room_id, modified_alias)
                        self.log.info(f"Successfully transferred modified alias {modified_alias} to new room {new_room_id}")
                    except Exception as e2:
                        self.log.error(f"Failed to transfer modified alias {modified_alias}: {e2}")

            # Get the room avatar from the old room
            try:
                old_room_avatar = await self.client.get_state_event(room_id, EventType.ROOM_AVATAR)
                if old_room_avatar and old_room_avatar.url:
                    # Set the same avatar in the new room
                    await self.client.send_state_event(
                        new_room_id,
                        EventType.ROOM_AVATAR,
                        {"url": old_room_avatar.url}
                    )
                    self.log.info(f"Successfully copied room avatar to new room {new_room_id}")
            except Exception as e:
                self.log.error(f"Failed to copy room avatar to new room: {e}")
                #await evt.respond(f"Failed to copy room avatar to new room: {e}")

            # Set the room topic in the new room
            try:
                await self.client.send_state_event(
                    new_room_id,
                    EventType.ROOM_TOPIC,
                    {"topic": room_topic}
                )
                self.log.info(f"Successfully copied room topic to new room {new_room_id}")
            except Exception as e:
                self.log.error(f"Failed to copy room topic to new room: {e}")
                #await evt.respond(f"Failed to copy room topic to new room: {e}")
            

            # Archive the old room with a pointer to the new room
            success = await self.do_archive_room(room_id, evt, new_room_id)
            if not success:
                await evt.respond("Failed to archive old room, but new room has been created")

    @community.subcommand("guests", help="generate a list of members in a room who are not members of the parent space")
    @command.argument("room", required=False)
    async def get_guestlist(self, evt: MessageEvent, room: str) -> None:
        space_members_obj = await self.client.get_joined_members(self.config["parent_room"])
        space_members_list = space_members_obj.keys()
        room_id = None
        if room:
            if room.startswith('#'):
                try:
                    thatroom_id = await self.client.resolve_room_alias(room)
                    room_id = thatroom_id["room_id"]
                except:
                    evt.reply("i don't recognize that room, sorry")
                    return
            else:
                room_id = room
        else:
            room_id = evt.room_id
        room_members_obj = await self.client.get_joined_members(room_id)
        room_members_list = room_members_obj.keys()

        # find the non-space members in the room member list
        try:
            guest_list = set(room_members_list) - set(space_members_list)
            if len(guest_list) == 0:
                guest_list = ["None"]
            await evt.reply(f"<b>Guests in this room are:</b><br /> \
                    {'<br />'.join(guest_list)}", allow_html=True)
        except Exception as e:
            await evt.respond(f"something went wrong: {e}")

    @community.subcommand("roomid", help="return the matrix room ID of this, or a given, room")
    @command.argument("room", required=False)
    async def get_roomid(self, evt: MessageEvent, room: str) -> None:
        room_id = None
        if room:
            if room.startswith('#'):
                try:
                    thatroom_id = await self.client.resolve_room_alias(room)
                    room_id = thatroom_id["room_id"]
                except:
                    evt.reply("i don't recognize that room, sorry")
                    return
            else:
                room_id = room
        else:
            room_id = evt.room_id
        try:
            await evt.reply(f"Room ID is: {room_id}")
        except Exception as e:
            await evt.respond(f"something went wrong: {e}")

    @community.subcommand("setpower", help="set power levels according to the community configuration")
    async def set_powerlevels(self, evt: MessageEvent,) -> None:
        await evt.mark_read()
        if evt.sender in self.config["admins"]:
            msg = await evt.respond("truing up power levels, this could take a minute...")
            admins = self.config['admins']
            moderators = self.config['moderators']
            roomlist = await self.get_space_roomlist()
            # don't forget to include the space itself
            roomlist.append(self.config["parent_room"])
            success_list = []
            error_list = []
            adminpl = 100
            modpl = 50
            defaultpl = 0

            for room in roomlist:
                # need to get and evaluate the current state that contains powerlevels first
                current_pl = await self.client.get_state_event(room, 'm.room.power_levels')
                users = current_pl['users'].serialize()
                updated_user_map = dict(users)
                try:
                    roomname = None
                    roomnamestate = await self.client.get_state_event(room, 'm.room.name')
                    roomname = roomnamestate['name']
                except Exception as e:
                    self.log.warning(e)

                # update our powerlevel map values
                for user in admins:
                    updated_user_map[user] = adminpl
                for user in moderators:
                    updated_user_map[user] = modpl

                # revoke values for people no longer in the config
                for user in users.keys():
                    if ( user not in admins and 
                            user not in moderators and 
                            updated_user_map[user] > defaultpl and 
                            user != self.client.mxid ):
                        del updated_user_map[user]


                # and send the new state event back to the room
                new_pl = current_pl
                new_pl['users'] = updated_user_map
                try:
                    #self.log.debug(f"DEBUG sending finalized PL map to room {room}: {updated_user_map}")
                    await self.client.send_state_event(room, 'm.room.power_levels', new_pl)
                    success_list.append(roomname or room)
                except Exception as e:
                    self.log.warning(e)
                    error_list.append(roomname or room)

                time.sleep(self.config['sleep'])

            results = "the following rooms were updated:<p><code>{success_list}</code></p>the following errors were \
                    recorded:<p><code>{error_list}</code></p>".format(success_list=success_list, error_list=error_list)
            await evt.respond(results, allow_html=True, edits=msg)
        
            # sync our database after we've made changes to room memberships
            await self.do_sync()

        else:
            await evt.reply("lol you don't have permission to do that")

    


    @classmethod
    def get_db_upgrade_table(cls) -> None:
        return upgrade_table

    @classmethod
    def get_config_class(cls) -> Type[BaseProxyConfig]:
        return Config