modmail update QOL

CHANGELOG.md

@@ -9,7 +9,7 @@ however, insignificant breaking changes do not guarantee a major version bump, s
 # 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.
+Forwarded messages now properly show in threads, rather then showing as an empty embed.
 
 ### Fixed
 - Make Modmail keep working when typing is disabled due to an outage caused by Discord.
@@ -18,7 +18,7 @@ Forwarded messages now properly show in threads, rather than showing as an empty
 - 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.
+- Solved an ancient bug where closing with words like `evening` wouldnt work.
 - Fixed the command from being included in the reply  in rare conditions.
 
 ### Added
@@ -29,16 +29,39 @@ Commands:
 * `clearsnoozed`: Clears all snoozed items.
 
 Configuration Options:
-* `max_snooze_time`: Sets the maximum duration for snooze.
+* `snooze_default_duration`: 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.
+* `unsnooze_history_limit`: Limits the number of messages replayed when unsnoozing (genesis message and notes are always shown).
+* `snooze_behavior`: Choose between `delete` (legacy) or `move` behavior for snoozing.
+* `snoozed_category_id`: Target category for `move` snoozing; required when `snooze_behavior` is `move`.
 * `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.
 
+Features:
+* Thread-creation menu: Adds an interactive select step before a thread channel is created.
+  * Commands:
+    * `threadmenu toggle`: Enable/disable the menu.
+    * `threadmenu show`: List current top-level options.
+    * `threadmenu option add`: Interactive wizard to create an option.
+    * `threadmenu option edit/remove/show`: Manage or inspect an existing option.
+    * `threadmenu submenu create/delete/list/show`: Manage submenus.
+    * `threadmenu submenu option add/edit/remove`: Manage options inside a submenu.
+  * Configuration / Behavior:
+    * Per-option `category` targeting when creating a thread; falls back to `main_category_id` if invalid/missing.
+    * Optional selection logging (`thread_creation_menu_selection_log`) posts the chosen option in the new thread.
+    * Anonymous prompt support (`thread_creation_menu_anonymous_menu`).
+
+
+Behavioral changes:
+- When `snooze_behavior` is set to `move`, the snoozed category now has a hard limit of 49 channels. New snoozes are blocked once it’s full until space is freed.
+- When switching `snooze_behavior` to `move` via `?config set`, the bot reminds admins to set `snoozed_category_id` if it’s missing.
+- Thread-creation menu options & submenu options now support an optional per-option `category` target. The interactive wizards (`threadmenu option add` / `threadmenu submenu option add`) and edit commands allow specifying or updating a category. If the stored category is missing or invalid at selection time, channel creation automatically falls back to `main_category_id`.
+
 # v4.1.2
 
 ### Fixed

bot.py

@@ -84,12 +84,13 @@ def __init__(self):
         self.session = None
         self._api = None
         self.formatter = SafeFormatter()
-        self.loaded_cogs = ["cogs.modmail", "cogs.plugins", "cogs.utility"]
+        self.loaded_cogs = ["cogs.modmail", "cogs.plugins", "cogs.utility", "cogs.threadmenu"]
         self._connected = None
         self.start_time = discord.utils.utcnow()
         self._started = False
 
         self.threads = ThreadManager(self)
+        self._message_queues = {}  # User ID -> asyncio.Queue for message ordering
 
         log_dir = os.path.join(temp_dir, "logs")
         if not os.path.exists(log_dir):
@@ -590,7 +591,7 @@ async def on_ready(self):
             )
 
         for log in await self.api.get_open_logs():
-            if self.get_channel(int(log["channel_id"])) is None:
+            if log.get("channel_id") is None or self.get_channel(int(log["channel_id"])) is None:
                 logger.debug("Unable to resolve thread with channel %s.", log["channel_id"])
                 log_data = await self.api.post_log(
                     log["channel_id"],
@@ -880,6 +881,36 @@ async def add_reaction(
                 return False
         return True
 
+    async def _queue_dm_message(self, message: discord.Message) -> None:
+        """Queue DM messages to ensure they're processed in order per user."""
+        user_id = message.author.id
+
+        if user_id not in self._message_queues:
+            self._message_queues[user_id] = asyncio.Queue()
+            # Start processing task for this user
+            self.loop.create_task(self._process_user_messages(user_id))
+
+        await self._message_queues[user_id].put(message)
+
+    async def _process_user_messages(self, user_id: int) -> None:
+        """Process messages for a specific user in order."""
+        queue = self._message_queues[user_id]
+
+        while True:
+            try:
+                # Wait for a message with timeout to clean up inactive queues
+                message = await asyncio.wait_for(queue.get(), timeout=300)  # 5 minutes
+                await self.process_dm_modmail(message)
+                queue.task_done()
+            except asyncio.TimeoutError:
+                # Clean up inactive queue
+                if queue.empty():
+                    self._message_queues.pop(user_id, None)
+                    break
+            except Exception as e:
+                logger.error(f"Error processing message for user {user_id}: {e}", exc_info=True)
+                queue.task_done()
+
     async def process_dm_modmail(self, message: discord.Message) -> None:
         """Processes messages sent to the bot."""
         blocked = await self._process_blocked(message)
@@ -1055,13 +1086,33 @@ def __init__(self, original_message, ref_message):
         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)}}
+            # No need to re-fetch the thread - it's already restored and cached properly
+
+        # If the previous thread was closed with delete_channel=True the channel object
+        # stored on the thread will now be invalid (deleted). In some rare race cases
+        # the thread can still be returned from the cache (or reconstructed) while the
+        # channel lookup returns None, causing downstream relay attempts to raise
+        # discord.NotFound ("Channel not found when trying to send message."). Treat
+        # this situation as "no active thread" so the user's new DM starts a fresh
+        # thread instead of silently failing.
+        try:
+            if (
+                thread
+                and thread.channel
+                and isinstance(thread.channel, discord.TextChannel)
+                and self.get_channel(getattr(thread.channel, "id", None)) is None
+            ):
+                logger.info(
+                    "Stale thread detected for %s (channel deleted). Purging cache entry and creating new thread.",
+                    message.author,
                 )
-        # Re-fetch the thread object to ensure channel is valid
-        thread = await self.threads.find(recipient=message.author)
+                # Best-effort removal; ignore if already gone.
+                self.threads.cache.pop(thread.id, None)
+                thread = None
+        except Exception:
+            # If any attribute access fails, fall back to treating it as closed.
+            self.threads.cache.pop(getattr(thread, "id", None), None)
+            thread = None
 
         if thread is None:
             delta = await self.get_thread_cooldown(message.author)
@@ -1090,6 +1141,9 @@ def __init__(self, original_message, ref_message):
                 return await message.channel.send(embed=embed)
 
             thread = await self.threads.create(message.author, message=message)
+            # If thread menu is enabled, thread creation is deferred until user selects an option.
+            if getattr(thread, "_pending_menu", False):
+                return
         else:
             if self.config["dm_disabled"] == DMDisabled.ALL_THREADS:
                 embed = discord.Embed(
@@ -1111,6 +1165,38 @@ def __init__(self, original_message, ref_message):
             except Exception:
                 logger.error("Failed to send message:", exc_info=True)
                 await self.add_reaction(message, blocked_emoji)
+
+                try:
+                    # Re-check channel existence
+                    if thread and thread.channel and isinstance(thread.channel, _d.TextChannel):
+                        if self.get_channel(thread.channel.id) is None:
+                            logger.info(
+                                "Relay failed due to deleted channel for %s; creating new thread.",
+                                message.author,
+                            )
+                            self.threads.cache.pop(thread.id, None)
+                            new_thread = await self.threads.create(message.author, message=message)
+                            if not getattr(new_thread, "_pending_menu", False) and not new_thread.cancelled:
+                                try:
+                                    await new_thread.send(message)
+                                except Exception:
+                                    logger.error(
+                                        "Failed to relay message after creating new thread:", exc_info=True
+                                    )
+                                else:
+                                    for user in new_thread.recipients:
+                                        if user != message.author:
+                                            try:
+                                                await new_thread.send(message, user)
+                                            except Exception:
+                                                logger.error(
+                                                    "Failed to send message to additional recipient:",
+                                                    exc_info=True,
+                                                )
+                                    await self.add_reaction(message, sent_emoji)
+                                    self.dispatch("thread_reply", new_thread, False, message, False, False)
+                except Exception:
+                    pass
             else:
                 for user in thread.recipients:
                     # send to all other recipients
@@ -1356,7 +1442,7 @@ async def process_commands(self, message):
             return
 
         if isinstance(message.channel, discord.DMChannel):
-            return await self.process_dm_modmail(message)
+            return await self._queue_dm_message(message)
 
         ctxs = await self.get_contexts(message)
         for ctx in ctxs:
@@ -1368,11 +1454,44 @@ async def process_commands(self, message):
                     )
                     checks.has_permissions(PermissionLevel.INVALID)(ctx.command)
 
+                # Check if thread is unsnoozing and queue command if so
+                thread = await self.threads.find(channel=ctx.channel)
+                if thread and thread._unsnoozing:
+                    queued = await thread.queue_command(ctx, ctx.command)
+                    if queued:
+                        # Send a brief acknowledgment that command is queued
+                        try:
+                            await ctx.message.add_reaction("⏳")
+                        except Exception:
+                            pass
+                        continue
+
                 await self.invoke(ctx)
                 continue
 
             thread = await self.threads.find(channel=ctx.channel)
             if thread is not None:
+                # If thread is snoozed (moved), auto-unsnooze when a mod sends a message directly in channel
+                try:
+                    behavior = (self.config.get("snooze_behavior") or "delete").lower()
+                except Exception:
+                    behavior = "delete"
+                if thread.snoozed and behavior == "move":
+                    if not thread.snooze_data:
+                        try:
+                            log_entry = await self.api.logs.find_one(
+                                {"recipient.id": str(thread.id), "snoozed": True}
+                            )
+                            if log_entry:
+                                thread.snooze_data = log_entry.get("snooze_data")
+                        except Exception:
+                            pass
+                    try:
+                        await thread.restore_from_snooze()
+                        # refresh local cache
+                        self.threads.cache[thread.id] = thread
+                    except Exception as e:
+                        logger.warning("Auto-unsnooze on direct message failed: %s", e)
                 anonymous = False
                 plain = False
                 if self.config.get("anon_reply_without_command"):
@@ -1541,6 +1660,19 @@ async def handle_react_to_contact(self, payload):
             )
             return await member.send(embed=embed)
 
+        # Check if user has a snoozed thread
+        existing_thread = await self.threads.find(recipient=member)
+        if existing_thread and existing_thread.snoozed:
+            # Unsnooze the thread
+            await existing_thread.restore_from_snooze()
+            self.threads.cache[existing_thread.id] = existing_thread
+            # Send notification to the thread channel
+            if existing_thread.channel:
+                await existing_thread.channel.send(
+                    f"ℹ️ {member.mention} reacted to contact and their snoozed thread has been unsnoozed."
+                )
+            return
+
         ctx = await self.get_context(message)
         await ctx.invoke(self.get_command("contact"), users=[member], manual_trigger=False)
 
@@ -1676,7 +1808,12 @@ async def on_message_delete(self, message):
             await thread.delete_message(message, note=False)
             embed = discord.Embed(description="Successfully deleted message.", color=self.main_color)
         except ValueError as e:
-            if str(e) not in {"DM message not found.", "Malformed thread message."}:
+            # Treat common non-fatal cases as benign: relay counterpart not present, note embeds, etc.
+            if str(e) not in {
+                "DM message not found.",
+                "Malformed thread message.",
+                "Thread message not found.",
+            }:
                 logger.debug("Failed to find linked message to delete: %s", e)
                 embed = discord.Embed(description="Failed to delete message.", color=self.error_color)
             else: