Implement all non-premium commands as slash commands

Author: merlinfuchs

.gitignore

@@ -0,0 +1,3 @@
+.idea/
+__pycache__/
+.DS_Store

README.md

@@ -0,0 +1,4 @@
+# Command Worker
+
+Receives interaction data from discord and responds to them.
+Long running tasks are forwarded to one of the background workers using redis

bot.py

@@ -0,0 +1,123 @@
+from xenon import *
+from xenon.cmd import *
+import dc_interactions as dc
+from motor.motor_asyncio import AsyncIOMotorClient
+import aioredis
+import json
+from os import environ as env
+import random
+import asyncio
+import traceback
+import sys
+from datetime import datetime
+
+
+class Xenon(dc.InteractionBot):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs, ctx_klass=CustomContext)
+        self.mongo = AsyncIOMotorClient(env.get("MONGO_URL", "mongodb://localhost"))
+        self.db = self.mongo.xenon
+        self.redis = None
+        self.http = None
+        self.relay = None
+
+        self._receiver = aioredis.pubsub.Receiver()
+
+    async def on_command_error(self, ctx, e):
+        if isinstance(e, asyncio.CancelledError):
+            raise e
+
+        else:
+            tb = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+            print("Command Error:\n", tb, file=sys.stderr)
+
+            error_id = unique_id()
+            await self.redis.setex(f"cmd:errors:{error_id}", 60 * 60 * 24, json.dumps({
+                "command": ctx.command.full_name,
+                "timestamp": datetime.utcnow().timestamp(),
+                "author": ctx.author.id,
+                "traceback": tb
+            }))
+            await ctx.respond_with_source(**create_message(
+                "An unexpected error occurred. Please report this on the "
+                "[Support Server](https://xenon.bot/discord).\n\n"
+                f"**Error Code**: `{error_id.upper()}`",
+                f=Format.ERROR
+            ))
+
+    async def execute_command(self, command, payload, remaining_options):
+        await self.redis.hincrby("cmd:commands", command.full_name, 1)
+
+        # Global rate limits to prevent abuse
+        block_bucket = payload.guild_id or payload.member["user"]["id"]
+        is_blacklisted = await self.redis.exists(f"cmd:blacklist:{block_bucket}")
+        if is_blacklisted:
+            await self.redis.incr("cmd:commands:blocked")
+            await self.redis.setex(f"cmd:blacklist:{block_bucket}", random.randint(60 * 15, 60 * 60), 1)
+            return dc.InteractionResponse.message(**create_message(
+                "You are being **blocked from using Xenon commands** due to exceeding internal rate limits. "
+                "These rate limits are in place to protect our infrastructure. Please be patient and wait a few hours "
+                "before trying to run another command.",
+                embed=False,
+                f=Format.ERROR
+            ), ephemeral=True)
+
+        cmd_count = int(await self.redis.get(f"cmd:commands:{block_bucket}") or 0)
+        if cmd_count > 5:
+            await self.redis.setex(f"cmd:blacklist:{block_bucket}", random.randint(60 * 15, 60 * 60), 1)
+
+        else:
+            await self.redis.setex(f"cmd:commands:{block_bucket}", 2, cmd_count + 1)
+
+        # Apply morph
+        morph_target = await self.redis.get(f"cmd:morph:{payload.member['user']['id']}")
+        if morph_target is not None:
+            try:
+                member = await self.http.get_guild_member(payload.guild_id, morph_target.decode())
+            except rest.HTTPNotFound:
+                pass
+            else:
+                guild = await self.http.get_guild(payload.guild_id)
+                if guild.owner_id == member.id:
+                    perms = Permissions.all()
+
+                else:
+                    perms = Permissions.none()
+                    roles = sorted(guild.roles, key=lambda r: r.position)
+                    for role in roles:
+                        if role.id in member.roles:
+                            perms.value |= role.permissions.value
+
+                payload.morph_source = payload.member['user']['id']
+                payload.member = member.to_dict()
+                payload.member["permissions"] = perms.value
+
+        return await super().execute_command(command, payload, remaining_options)
+
+    async def gateway_subscriber(self):
+        await self.redis.subscribe(
+            self._receiver.channel("gateway:events:message_reaction_add")
+        )
+        async for channel, msg in self._receiver.iter():
+            event_name = channel.name.decode().replace("gateway:events:", "")
+            self.dispatch(event_name, json.loads(msg))
+
+    async def prepare(self):
+        self.redis = await aioredis.create_redis_pool(env.get("REDIS_URL", "redis://localhost"))
+
+        self.relay = com.Relay(self.redis)
+        self.relay.start_reader()
+
+        ratelimits = rest.RedisRatelimitHandler(self.redis)
+        self.http = rest.HTTPClient(self.token, ratelimits)
+
+        self.loop.create_task(self.gateway_subscriber())
+
+        await super().prepare()
+        # await self.flush_commands()
+        self.loop.create_task(self.push_commands())
+
+    def make_request(self, method, path, data=None, **params):
+        req = rest.Request(method, path, **params)
+        self.http.start_request(req, json=data)
+        return req

modules/admin.py

@@ -0,0 +1,260 @@
+import dc_interactions as dc
+from os import environ as env
+from xenon.cmd import *
+import inspect
+import textwrap
+import traceback
+import json
+from datetime import datetime
+
+ADMIN_GUILD_ID = env.get("ADMIN_GUILD_ID", "496683369665658880")
+
+
+class AdminModule(dc.Module):
+    @dc.Module.command(guild_id=ADMIN_GUILD_ID)
+    async def admin(self, ctx):
+        """
+        Manage the admin commands for a server
+        """
+
+    @admin.sub_command()
+    @checks.is_bot_owner
+    async def enable(self, ctx, guild_id=None):
+        """
+        Add the admin commands to a server
+        """
+        guild_id = guild_id or ctx.guild_id
+        await ctx.ack_with_source()
+
+        for command in self.commands:
+            if command.register:
+                continue
+
+            await self.bot.create_command(command, guild_id=guild_id)
+
+        await ctx.respond_with_source(**create_message(
+            f"Admin commands are now available on the server with the id `{guild_id}`",
+            f=Format.SUCCESS
+        ))
+
+    @admin.sub_command()
+    @checks.is_bot_owner
+    async def disable(self, ctx, guild_id=None):
+        """
+        Remove the admin commands from a server
+        """
+        guild_id = guild_id or ctx.guild_id
+        await ctx.ack_with_source()
+
+        existing_commands = await ctx.bot.fetch_commands(guild_id=guild_id)
+        for command in self.commands:
+            if command.register:
+                continue
+
+            for ex_cmd in existing_commands:
+                if ex_cmd["name"] == command.name:
+                    await self.bot.delete_command(ex_cmd["id"], guild_id=guild_id)
+
+        await ctx.respond_with_source(**create_message(
+            f"Admin commands are no longer available on the server with the id `{guild_id}`",
+            f=Format.SUCCESS
+        ))
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def maintenance(self, ctx):
+        """
+        Enable or disable the maintenance mode
+        """
+        current = await self.bot.redis.exists("cmd:maintenance")
+        if current:
+            await self.bot.redis.delete("cmd:maintenance")
+            await ctx.respond_with_source(**create_message(
+                "**Disabled maintenance** mode.",
+                f=Format.SUCCESS
+            ))
+
+        else:
+            await self.bot.redis.set("cmd:maintenance", "1")
+            await ctx.respond_with_source(**create_message(
+                "**Enabled maintenance** mode.",
+                f=Format.SUCCESS
+            ))
+
+    @dc.Module.command(register=False)
+    async def morph(self, ctx, user_id=None):
+        """
+        Morph into and execute commands as a different user
+        """
+        if user_id is None:
+            morph_source = getattr(ctx.payload, "morph_source", None)
+            if morph_source is None:
+                await ctx.respond_with_source(**create_message(
+                    "You are already executing commands as yourself.",
+                    f=Format.SUCCESS
+                ))
+                return
+
+            await ctx.bot.redis.delete(f"cmd:morph:{morph_source}")
+            await ctx.respond_with_source(**create_message(
+                "You are now executing commands as yourself.",
+                f=Format.SUCCESS
+            ))
+            return
+
+        check_result = await checks.is_bot_owner.run(ctx)
+        if check_result is not True:
+            return
+
+        await ctx.bot.redis.set(f"cmd:morph:{ctx.author.id}", user_id)
+        await ctx.respond_with_source(**create_message(
+            f"You are now executing commands as <@{user_id}>.",
+            f=Format.SUCCESS
+        ))
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def eval(self, ctx, expression):
+        """
+        Evaluate a python expression
+        """
+        if expression.startswith("await "):
+            expression = expression[6:]
+
+        try:
+            result = eval(expression)
+            if inspect.isawaitable(result):
+                result = await result
+
+        except Exception as e:
+            tb = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+            await ctx.respond_with_source(**create_message(
+                f"```py\n{tb[:1900]}```",
+                title="Eval Error",
+                f=Format.SUCCESS
+            ))
+
+        else:
+            await ctx.respond_with_source(**create_message(
+                f"```py\n{result}```",
+                title="Eval Result",
+                f=Format.SUCCESS
+            ))
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def exec(self, ctx, snippet):
+        """
+        Execute a python code snippet
+        """
+        if snippet.startswith('```') and snippet.endswith('```'):
+            snippet = '\n'.join(snippet.split('\n')[1:-1])
+
+        snippet = snippet.strip("` \n")
+        wrapped = f"async def func():\n{textwrap.indent(snippet, '    ')}"
+
+        env = {
+            "ctx": ctx,
+            "self": self,
+            "bot": ctx.bot,
+            "http": ctx.bot.http,
+            "redis": ctx.bot.redis
+        }
+
+        try:
+            exec(wrapped, env)
+            result = await env["func"]()
+
+        except Exception as e:
+            tb = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+            await ctx.respond_with_source(**create_message(
+                f"```py\n{tb[:1900]}```",
+                title="Exec Error",
+                f=Format.SUCCESS
+            ))
+
+        else:
+            await ctx.respond_with_source(**create_message(
+                f"```py\n{result}```",
+                title="Exec Result",
+                f=Format.SUCCESS
+            ))
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def redis(self, ctx, cmd):
+        """
+        Execute a redis command
+        """
+        result = await ctx.bot.redis.execute(*cmd.split(" "))
+        await ctx.respond_with_source(**create_message(
+            f"```py\n{result}\n```",
+            title="Redis Result",
+            f=Format.SUCCESS
+        ))
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def error(self, ctx, error_id: str.lower):
+        """
+        Show information about a command error
+        """
+        error = await ctx.bot.redis.get(f"cmd:errors:{error_id}")
+        if error is None:
+            await ctx.respond_with_source(**create_message(
+                f"**Unknown error** with the id `{error_id.upper()}`.",
+                f=Format.ERROR
+            ))
+            return
+
+        data = json.loads(error)
+        embeds = [{
+            "title": "Command Error",
+            "color": Format.ERROR.color,
+            "fields": [
+                {
+                    "name": "Command",
+                    "value": data["command"],
+                    "inline": True
+                },
+                {
+                    "name": "Author",
+                    "value": f"<@{data['author']}>",
+                    "inline": True
+                },
+                {
+                    "name": "Timestamp",
+                    "value": datetime_to_string(datetime.fromtimestamp(data["timestamp"])) + " UTC",
+                    "inline": True
+                }
+            ]
+        }]
+
+        current = ""
+        for line in data["traceback"].splitlines():
+            if (len(current) + len(line)) > 2000:
+                embeds.append({
+                    "color": Format.ERROR.color,
+                    "description": f"```py\n{current}```"
+                })
+                current = ""
+
+            else:
+                current += f"\n{line}"
+
+        if len(current) > 0:
+            embeds.append({
+                "color": Format.ERROR.color,
+                "description": f"```py\n{current}```"
+            })
+
+        while len(embeds) > 0:
+            await ctx.respond_with_source(embeds=embeds[:3])
+            embeds = embeds[3:]
+
+    @dc.Module.command(register=False)
+    @checks.is_bot_owner
+    async def blacklist(self, ctx):
+        """
+        Manage the blacklist
+        """