Merge development v4.2.0

.env.example

@@ -3,3 +3,4 @@ LOG_URL=https://logviewername.herokuapp.com/
 GUILD_ID=1234567890
 OWNERS=Owner1ID,Owner2ID,Owner3ID
 CONNECTION_URI=mongodb+srv://mongodburi
+DISABLE_AUTOUPDATES=true

.gitattributes

@@ -0,0 +1 @@
+* text=auto

CHANGELOG.md

@@ -6,6 +6,39 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 This project mostly adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html);
 however, insignificant breaking changes do not guarantee a major version bump, see the reasoning [here](https://github.com/modmail-dev/modmail/issues/319). If you're a plugin developer, note the "BREAKING" section.
 
+# v4.2.0
+
+Upgraded discord.py to version 2.6.3, added support for CV2.
+Forwarded messages now properly show in threads, rather than showing as an empty embed.
+
+### Fixed
+- Make Modmail keep working when typing is disabled due to an outage caused by Discord.
+- Resolved an issue where forwarded messages appeared as empty embeds.
+- Fixed internal message handling and restoration processes.
+- Eliminated duplicate logs and notes.
+- Addressed inconsistent use of `logkey` after ticket restoration.
+- Fixed issues with identifying the user who sent internal messages.
+- Solved an ancient bug where closing with words like `evening` wouldn't work.
+- Fixed the command from being included in the reply  in rare conditions.
+
+### Added
+Commands:
+* `snooze`: Initiates a snooze action.
+* `snoozed`: Displays snoozed items.
+* `unsnooze`: Reverses the snooze action.
+* `clearsnoozed`: Clears all snoozed items.
+
+Configuration Options:
+* `max_snooze_time`: Sets the maximum duration for snooze.
+* `snooze_title`: Customizes the title for snooze notifications.
+* `snooze_text`: Customizes the text for snooze notifications.
+* `unsnooze_text`: Customizes the text for unsnooze notifications.
+* `unsnooze_notify_channel`: Specifies the channel for unsnooze notifications.
+* `thread_min_characters`: Minimum number of characters required.
+* `thread_min_characters_title`: Title shown when the message is too short.
+* `thread_min_characters_response`: Response shown to the user if their message is too short.
+* `thread_min_characters_footer`: Footer displaying the minimum required characters.
+
 # v4.1.2
 
 ### Fixed

Pipfile

@@ -8,11 +8,12 @@ bandit = ">=1.7.5"
 black = "==23.11.0"
 pylint = "==3.0.2"
 typing-extensions = "==4.8.0"
+tomli = "==2.2.1"  # Needed for black on Python < 3.11
 
 [packages]
 aiohttp = "==3.9.0"
 colorama = "==0.4.6"
-"discord.py" = {version = "==2.3.2", extras = ["speed"]}
+"discord.py" = {version = "==2.6.3", extras = ["speed"]}
 emoji = "==2.8.0"
 isodate = "==0.6.1"
 motor = "==3.3.2"

bot.py

@@ -1,4 +1,4 @@
-__version__ = "4.1.2"
+__version__ = "4.2.0"
 
 
 import asyncio
@@ -48,7 +48,15 @@
 )
 from core.thread import ThreadManager
 from core.time import human_timedelta
-from core.utils import extract_block_timestamp, normalize_alias, parse_alias, truncate, tryint, human_join
+from core.utils import (
+    extract_block_timestamp,
+    normalize_alias,
+    parse_alias,
+    truncate,
+    tryint,
+    human_join,
+    extract_forwarded_content,
+)
 
 logger = getLogger(__name__)
 
@@ -879,10 +887,182 @@ async def process_dm_modmail(self, message: discord.Message) -> None:
             return
         sent_emoji, blocked_emoji = await self.retrieve_emoji()
 
+        # Handle forwarded messages (Discord forwards)
+        # See: https://discord.com/developers/docs/resources/message#message-reference-content-attribution-forwards
+        # 1. Multi-forward (message_snapshots)
+        if hasattr(message, "flags") and getattr(message.flags, "has_snapshot", False):
+            if hasattr(message, "message_snapshots") and message.message_snapshots:
+                thread = await self.threads.find(recipient=message.author)
+                if thread is None:
+                    delta = await self.get_thread_cooldown(message.author)
+                    if delta:
+                        await message.channel.send(
+                            embed=discord.Embed(
+                                title=self.config["cooldown_thread_title"],
+                                description=self.config["cooldown_thread_response"].format(delta=delta),
+                                color=self.error_color,
+                            )
+                        )
+                        return
+                    if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+                        embed = discord.Embed(
+                            title=self.config["disabled_new_thread_title"],
+                            color=self.error_color,
+                            description=self.config["disabled_new_thread_response"],
+                        )
+                        embed.set_footer(
+                            text=self.config["disabled_new_thread_footer"],
+                            icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                        )
+                        logger.info(
+                            "A new thread was blocked from %s due to disabled Modmail.", message.author
+                        )
+                        await self.add_reaction(message, blocked_emoji)
+                        return await message.channel.send(embed=embed)
+                    thread = await self.threads.create(message.author, message=message)
+                else:
+                    if self.config["dm_disabled"] == DMDisabled.ALL_THREADS:
+                        embed = discord.Embed(
+                            title=self.config["disabled_current_thread_title"],
+                            color=self.error_color,
+                            description=self.config["disabled_current_thread_response"],
+                        )
+                        embed.set_footer(
+                            text=self.config["disabled_current_thread_footer"],
+                            icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                        )
+                        logger.info("A message was blocked from %s due to disabled Modmail.", message.author)
+                        await self.add_reaction(message, blocked_emoji)
+                        return await message.channel.send(embed=embed)
+                # Extract forwarded content using utility function
+                combined_content = extract_forwarded_content(message) or "[Forwarded message with no content]"
+
+                class ForwardedMessage:
+                    def __init__(self, original_message, forwarded_content):
+                        self.author = original_message.author
+                        self.content = forwarded_content
+                        self.attachments = []
+                        self.stickers = []
+                        self.created_at = original_message.created_at
+                        self.embeds = []
+                        self.id = original_message.id
+                        self.flags = original_message.flags
+                        self.message_snapshots = original_message.message_snapshots
+                        self.type = getattr(original_message, "type", None)
+
+                forwarded_msg = ForwardedMessage(message, combined_content)
+                await thread.send(forwarded_msg)
+                await self.add_reaction(message, sent_emoji)
+                self.dispatch("thread_reply", thread, False, message, False, False)
+                return
+            else:
+                message.content = "[Forwarded message with no content]"
+        # 2. Single-message forward (MessageType.forward)
+        elif getattr(message, "type", None) == getattr(discord.MessageType, "forward", None):
+            # Check for message.reference and its type
+            ref = getattr(message, "reference", None)
+            if ref and getattr(ref, "type", None) == getattr(discord, "MessageReferenceType", None).forward:
+                # Try to fetch the referenced message
+                ref_msg = None
+                try:
+                    if ref.resolved:
+                        ref_msg = ref.resolved
+                    elif ref.message_id and ref.channel_id:
+                        channel = self.get_channel(ref.channel_id) or (
+                            await self.fetch_channel(ref.channel_id)
+                        )
+                        ref_msg = await channel.fetch_message(ref.message_id)
+                except Exception:
+                    ref_msg = None
+                if ref_msg:
+                    # Forward the referenced message as if it was sent
+                    thread = await self.threads.find(recipient=message.author)
+                    if thread is None:
+                        delta = await self.get_thread_cooldown(message.author)
+                        if delta:
+                            await message.channel.send(
+                                embed=discord.Embed(
+                                    title=self.config["cooldown_thread_title"],
+                                    description=self.config["cooldown_thread_response"].format(delta=delta),
+                                    color=self.error_color,
+                                )
+                            )
+                            return
+                        if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+                            embed = discord.Embed(
+                                title=self.config["disabled_new_thread_title"],
+                                color=self.error_color,
+                                description=self.config["disabled_new_thread_response"],
+                            )
+                            embed.set_footer(
+                                text=self.config["disabled_new_thread_footer"],
+                                icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                            )
+                            logger.info(
+                                "A new thread was blocked from %s due to disabled Modmail.", message.author
+                            )
+                            await self.add_reaction(message, blocked_emoji)
+                            return await message.channel.send(embed=embed)
+                        thread = await self.threads.create(message.author, message=message)
+                    else:
+                        if self.config["dm_disabled"] == DMDisabled.ALL_THREADS:
+                            embed = discord.Embed(
+                                title=self.config["disabled_current_thread_title"],
+                                color=self.error_color,
+                                description=self.config["disabled_current_thread_response"],
+                            )
+                            embed.set_footer(
+                                text=self.config["disabled_current_thread_footer"],
+                                icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                            )
+                            logger.info(
+                                "A message was blocked from %s due to disabled Modmail.", message.author
+                            )
+                            await self.add_reaction(message, blocked_emoji)
+                            return await message.channel.send(embed=embed)
+
+                    # Create a forwarded message wrapper to preserve forward info
+                    class ForwardedMessage:
+                        def __init__(self, original_message, ref_message):
+                            self.author = original_message.author
+                            # Use the utility function to extract content or fallback to ref message content
+                            extracted_content = extract_forwarded_content(original_message)
+                            self.content = (
+                                extracted_content
+                                or ref_message.content
+                                or "[Forwarded message with no text content]"
+                            )
+                            self.attachments = getattr(ref_message, "attachments", [])
+                            self.stickers = getattr(ref_message, "stickers", [])
+                            self.created_at = original_message.created_at
+                            self.embeds = getattr(ref_message, "embeds", [])
+                            self.id = original_message.id
+                            self.type = getattr(original_message, "type", None)
+                            self.reference = original_message.reference
+
+                    forwarded_msg = ForwardedMessage(message, ref_msg)
+                    await thread.send(forwarded_msg)
+                    await self.add_reaction(message, sent_emoji)
+                    self.dispatch("thread_reply", thread, False, message, False, False)
+                    return
+                else:
+                    message.content = "[Forwarded message with no content]"
+
         if message.type not in [discord.MessageType.default, discord.MessageType.reply]:
             return
 
         thread = await self.threads.find(recipient=message.author)
+        if thread and thread.snoozed:
+            await thread.restore_from_snooze()
+            self.threads.cache[thread.id] = thread
+            # Update the DB with the new channel_id after restoration
+            if thread.channel:
+                await self.api.logs.update_one(
+                    {"recipient.id": str(thread.id)}, {"$set": {"channel_id": str(thread.channel.id)}}
+                )
+        # Re-fetch the thread object to ensure channel is valid
+        thread = await self.threads.find(recipient=message.author)
+
         if thread is None:
             delta = await self.get_thread_cooldown(message.author)
             if delta:
@@ -1156,6 +1336,19 @@ async def on_message(self, message):
                 content = ""
             await self.mention_channel.send(content=content, embed=em)
 
+        # --- MODERATOR-ONLY MESSAGE LOGGING ---
+        # If a moderator sends a message directly in a thread channel (not via modmail command), log it
+        if not message.author.bot and not isinstance(message.channel, discord.DMChannel):
+            thread = await self.threads.find(channel=message.channel)
+            if thread is not None:
+                ctxs = await self.get_contexts(message)
+                is_command = any(ctx.command for ctx in ctxs)
+                if not is_command:
+                    # Only log if not a command
+                    perms = message.channel.permissions_for(message.author)
+                    if perms.manage_messages or perms.administrator:
+                        await self.api.append_log(message, type_="internal")
+
         await self.process_commands(message)
 
     async def process_commands(self, message):
@@ -1193,8 +1386,6 @@ async def process_commands(self, message):
                     or self.config.get("plain_reply_without_command")
                 ):
                     await thread.reply(message, anonymous=anonymous, plain=plain)
-                else:
-                    await self.api.append_log(message, type_="internal")
             elif ctx.invoked_with:
                 exc = commands.CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with))
                 self.dispatch("command_error", ctx, exc)
@@ -1212,7 +1403,10 @@ async def on_typing(self, channel, user, _):
             thread = await self.threads.find(recipient=user)
 
             if thread:
-                await thread.channel.typing()
+                try:
+                    await thread.channel.typing()
+                except Exception:
+                    pass
         else:
             if not self.config.get("mod_typing"):
                 return
@@ -1222,7 +1416,10 @@ async def on_typing(self, channel, user, _):
                 for user in thread.recipients:
                     if await self.is_blocked(user):
                         continue
-                    await user.typing()
+                    try:
+                        await user.typing()
+                    except Exception:
+                        pass
 
     async def handle_reaction_events(self, payload):
         user = self.get_user(payload.user_id)
@@ -1529,7 +1726,10 @@ async def on_command_error(
                 return
 
         if isinstance(exception, (commands.BadArgument, commands.BadUnionArgument)):
-            await context.typing()
+            try:
+                await context.typing()
+            except Exception:
+                pass
             await context.send(embed=discord.Embed(color=self.error_color, description=str(exception)))
         elif isinstance(exception, commands.CommandNotFound):
             logger.warning("CommandNotFound: %s", exception)
@@ -1820,7 +2020,7 @@ def main():
         sys.exit(0)
 
     # check discord version
-    discord_version = "2.3.2"
+    discord_version = "2.6.3"
     if discord.__version__ != discord_version:
         logger.error(
             "Dependencies are not updated, run pipenv install. discord.py version expected %s, received %s",