DiscordBotLinuxMonitor 1.6.8__tar.gz → 1.7.0__tar.gz

{discordbotlinuxmonitor-1.6.8 → discordbotlinuxmonitor-1.7.0}/DiscordBotLinuxMonitor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DiscordBotLinuxMonitor
-Version: 1.6.8
+Version: 1.7.0
 Summary: From discord channels: Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)
 Home-page: https://github.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library
 Author: Quentin Comte-Gaz

{discordbotlinuxmonitor-1.6.8 → discordbotlinuxmonitor-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DiscordBotLinuxMonitor
-Version: 1.6.8
+Version: 1.7.0
 Summary: From discord channels: Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)
 Home-page: https://github.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library
 Author: Quentin Comte-Gaz

{discordbotlinuxmonitor-1.6.8 → discordbotlinuxmonitor-1.7.0}/discordbotlinuxmonitor/__main__.py

@@ -52,104 +52,162 @@ def main() -> None:
         await discord_bot_linux_monitor.on_ready()
 
     @discord_bot.tree.command(name="force_sync", description="[Private] 🔄 Force command synchronization 🔄")
+    @app_commands.checks.cooldown(3, 20.0)
     async def force_sync(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.force_sync(interaction)
 
     @discord_bot.tree.command(name="version", description="🤖 Show bot version 🤖")
+    @app_commands.checks.cooldown(3, 20.0)
     async def version(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.version(interaction)
 
     @discord_bot.tree.command(name="usage", description="📊 View disk space, CPU, RAM, ... 📊")
+    @app_commands.checks.cooldown(3, 20.0)
     async def usage(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.usage(interaction)
 
     @discord_bot.tree.command(name="os_infos", description="🖥️ View basic system information 🖥️")
+    @app_commands.checks.cooldown(3, 20.0)
     async def os_infos(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.os_infos(interaction)
 
     @discord_bot.tree.command(name="users", description="[Private] 👥 View connected users 👥")
+    @app_commands.checks.cooldown(3, 20.0)
     async def users(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.users(interaction)
 
     @discord_bot.tree.command(name="user_logins", description="[Private] 👥 View last user connections 👥")
+    @app_commands.checks.cooldown(3, 20.0)
     async def user_logins(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.user_logins(interaction)
 
     @discord_bot.tree.command(name="ping", description="🌐 Ping websites 🌐")
+    @app_commands.checks.cooldown(3, 20.0)
     async def ping(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.ping(interaction)
 
     @discord_bot.tree.command(name="websites", description="🌐 Check websites access (GET requests) 🌐")
+    @app_commands.checks.cooldown(3, 20.0)
     async def websites(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.websites(interaction)
 
     @discord_bot.tree.command(name="certificates", description="🔒 Check SSL certificates 🔒")
+    @app_commands.checks.cooldown(3, 20.0)
     async def certificates(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.certificates(interaction)
 
     @discord_bot.tree.command(name="reboot_server", description="[Private] 🔄 Restart the entire server 🔄")
+    @app_commands.checks.cooldown(1, 60.0)  # 1 use per 60 seconds - dangerous operation
     async def reboot(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.reboot(interaction)
 
     @discord_bot.tree.command(name="services_status", description="🩺 Check services are running 🩺")
+    @app_commands.checks.cooldown(3, 20.0)
     async def services_status(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.services_status(interaction)
 
     @discord_bot.tree.command(name="restart_all", description="🚀 Restart all services 🚀")
+    @app_commands.checks.cooldown(1, 30.0)  # 1 use per 30 seconds
     async def restart_all(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.restart_all(interaction)
 
     @discord_bot.tree.command(name="restart_service", description="🚀 Restart a service 🚀")
     @app_commands.autocomplete(service_name=discord_bot_linux_monitor.autocomplete_service_name)
+    @app_commands.checks.cooldown(3, 20.0)  # 3 uses per 20 seconds
     async def restart_service(interaction: discord.Interaction, service_name: str) -> None: # type: ignore
         await discord_bot_linux_monitor.restart_service(interaction, service_name)
 
     @discord_bot.tree.command(name="stop_service", description="🚫 Stop a service 🚫")
     @app_commands.autocomplete(service_name=discord_bot_linux_monitor.autocomplete_service_name)
+    @app_commands.checks.cooldown(3, 20.0)  # 3 uses per 20 seconds
     async def stop_service(interaction: discord.Interaction, service_name: str) -> None: # type: ignore
         await discord_bot_linux_monitor.stop_service(interaction, service_name)
 
     @discord_bot.tree.command(name="list_services", description="📋 List all available services 📋")
+    @app_commands.checks.cooldown(3, 20.0)
     async def list_services(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.list_services(interaction)
 
     @discord_bot.tree.command(name="ports", description="🔒 Check ports 🔒")
+    @app_commands.checks.cooldown(3, 20.0)
     async def ports(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.ports(interaction)
 
     @discord_bot.tree.command(name="list_processes", description="[Private] 📋 List active processes (ordered by RAM usage) 📋")
+    @app_commands.checks.cooldown(3, 20.0)
     async def list_processes(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.list_processes(interaction, order_by_ram=True)
 
     @discord_bot.tree.command(name="list_processes_by_cpu_usage", description="[Private] 📋 List active processes (ordered by CPU usage) 📋")
+    @app_commands.checks.cooldown(3, 20.0)
     async def list_processes_by_cpu_usage(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.list_processes(interaction, order_by_ram=False)
 
     @discord_bot.tree.command(name="kill_process", description="[Private] 🚫 Stop a process by PID 🚫")
+    @app_commands.checks.cooldown(3, 20.0)
     async def kill_process(interaction: discord.Interaction, pid: int) -> None: # type: ignore
         await discord_bot_linux_monitor.kill_process(interaction, pid)
 
     @discord_bot.tree.command(name="clear_channel_messages", description="[Private] 🧹 Remove all messages from a channel 🧹")
+    @app_commands.checks.cooldown(1, 120.0)  # 1 use per 120 seconds (2 minutes) - very destructive
     async def clear_channel_messages(interaction: discord.Interaction, channel: discord.TextChannel) -> None: # type: ignore
         await discord_bot_linux_monitor.clear_channel_messages(interaction, channel)
 
     @discord_bot.tree.command(name="list_clearable_channels", description="[Private] 🧹 List text channels and bot clear permissions 🧹")
+    @app_commands.checks.cooldown(3, 20.0)
     async def list_clearable_channels(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.list_clearable_channels(interaction)
 
     @discord_bot.tree.command(name="list_commands", description="📋 List all available commands 📋")
+    @app_commands.checks.cooldown(3, 20.0)
     async def list_commands(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.list_commands(interaction)
 
+    @discord_bot.tree.command(name="help", description="🔍 Show Discord bot commands with info and cooldowns 🔍")
+    @app_commands.checks.cooldown(3, 20.0)
+    async def help_command(interaction: discord.Interaction, command_name: str = "") -> None: # type: ignore
+        await discord_bot_linux_monitor.show_help(interaction, command_name)
+
+    @discord_bot.tree.command(name="list_periodic_channels_cleanup", description="🧹 Show auto-cleanup channel configuration and permission status 🧹")
+    @app_commands.checks.cooldown(3, 20.0)
+    async def list_periodic_channels_cleanup(interaction: discord.Interaction) -> None: # type: ignore
+        await discord_bot_linux_monitor.show_list_periodic_channels_cleanup(interaction)
+
     @discord_bot.tree.command(name="execute_command", description="🚀 Execute a command (optional parameters) 🚀")
     @app_commands.autocomplete(command_name=discord_bot_linux_monitor.autocomplete_command_name)
+    @app_commands.checks.cooldown(3, 20.0)  # 3 uses per 20 seconds
     async def execute_command(interaction: discord.Interaction, command_name: str, parameters: str = "") -> None: # type: ignore
         await discord_bot_linux_monitor.execute_command(interaction, command_name=command_name, parameters=parameters)
 
     @discord_bot.tree.command(name="execute_all_commands", description="🚀 Execute all commands 🚀")
+    @app_commands.checks.cooldown(1, 60.0)  # 1 use per 60 seconds
     async def execute_all_commands(interaction: discord.Interaction) -> None: # type: ignore
         await discord_bot_linux_monitor.execute_all_commands(interaction)
 
+    @discord_bot.tree.error
+    async def on_app_command_error(interaction: discord.Interaction, error: app_commands.AppCommandError) -> None: # type: ignore
+        """Handle cooldown and other command errors gracefully."""
+        if isinstance(error, app_commands.CommandOnCooldown):
+            retry_after = error.retry_after
+            await interaction.response.send_message(
+                content=f"⏳ This command is on cooldown. Please wait {retry_after:.1f} seconds before using it again.",
+                ephemeral=True
+            )
+        elif isinstance(error, app_commands.MissingPermissions):
+            await interaction.response.send_message(
+                content="❌ You don't have permission to use this command.",
+                ephemeral=True
+            )
+        else:
+            logging.error(msg=f"Unhandled command error: {error}")
+            try:
+                await interaction.response.send_message(
+                    content="❌ An unexpected error occurred. Please try again later.",
+                    ephemeral=True
+                )
+            except discord.InteractionResponded:
+                logging.warning(msg="Interaction already responded when handling error")
+
     #endregion
 
     # Start the discord bot

{discordbotlinuxmonitor-1.6.8 → discordbotlinuxmonitor-1.7.0}/discordbotlinuxmonitor/discordbotlinuxmonitor.py

@@ -33,7 +33,7 @@ __email__ = "quentin@comte-gaz.com"
 __license__ = "MIT License"
 __copyright__ = "Copyright Quentin Comte-Gaz (2026)"
 __python_version__ = "3.+"
-__version__ = "1.6.8 (2026/08/29)"
+__version__ = "1.7.0 (2026/08/29)"
 __status__ = "Usable for any Linux project"
 
 # pyright: reportMissingTypeStubs=false
@@ -44,13 +44,76 @@ from discord.app_commands.models import AppCommand
 from discord import app_commands
 from discord.ext import commands
 import json
-from typing import List, Union, Awaitable, Callable, Any, Dict, Optional
+from typing import List, Union, Awaitable, Callable, Any, Dict, Optional, Tuple
 from datetime import datetime, timedelta, timezone
 
 import asyncio
-
+import functools
+import time
 import logging
 
+
+class ConfirmationView(discord.ui.View):
+    """Confirmation dialog for dangerous commands."""
+    def __init__(self, timeout: float = 30.0):
+        super().__init__(timeout=timeout)
+        self.confirmed: bool = False
+
+    @discord.ui.button(label="✅ Confirm", style=discord.ButtonStyle.red)
+    async def confirm_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+        self.confirmed = True
+        await interaction.response.defer()
+        self.stop()
+
+    @discord.ui.button(label="❌ Cancel", style=discord.ButtonStyle.gray)
+    async def cancel_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+        self.confirmed = False
+        await interaction.response.defer()
+        self.stop()
+
+    async def on_timeout(self) -> None:
+        self.confirmed = False
+
+
+class PaginationView(discord.ui.View):
+    """Pagination view for long messages with prev/next buttons."""
+    def __init__(self, chunks: List[str], timeout: float = 180.0):
+        super().__init__(timeout=timeout)
+        self.chunks = chunks
+        self.current_page: int = 0
+        self.total_pages: int = len(chunks)
+        self.message: Optional[discord.Message] = None
+        self._update_button_states()
+
+    def _update_button_states(self) -> None:
+        """Update button disabled states based on current page."""
+        self.prev_button.disabled = self.current_page <= 0
+        self.next_button.disabled = self.current_page >= self.total_pages - 1
+
+    @discord.ui.button(label="◀️ Previous", style=discord.ButtonStyle.gray)
+    async def prev_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+        if self.current_page > 0:
+            self.current_page -= 1
+            self._update_button_states()
+            await interaction.response.defer()
+            if self.message:
+                await self.message.edit(view=self)
+
+    @discord.ui.button(label="▶️ Next", style=discord.ButtonStyle.gray)
+    async def next_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+        if self.current_page < self.total_pages - 1:
+            self.current_page += 1
+            self._update_button_states()
+            await interaction.response.defer()
+            if self.message:
+                await self.message.edit(view=self)
+
+    async def on_timeout(self) -> None:
+        """Disable buttons after timeout."""
+        for item in self.children:
+            item.disabled = True
+
+
 class DiscordBotLinuxMonitor:
 
     #region Initialization
@@ -74,6 +137,9 @@ class DiscordBotLinuxMonitor:
         self.force_sync_on_startup: bool = force_sync_on_startup
         intents: discord.Intents = discord.Intents.default()
         self.bot = commands.Bot(command_prefix=self.command_prefix, intents=intents)
+        
+        # Initialize cleanup task
+        self.cleanup_task: Optional[asyncio.Task] = None
 
     def _init_and_check_configuration(self) -> None:
         """
@@ -166,6 +232,47 @@ class DiscordBotLinuxMonitor:
 
     #region Private methods
 
+    def _get_utc_timestamp(self) -> str:
+        """Get current timestamp in UTC with timezone info."""
+        return datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
+
+    def _log_command_audit(self, user: discord.User, guild: Optional[discord.Guild], channel: Optional[discord.TextChannel], command: str, details: str = "") -> None:
+        """Log command execution for audit trail."""
+        timestamp = self._get_utc_timestamp()
+        guild_name = guild.name if guild else "Unknown"
+        channel_name = channel.name if channel else "Unknown"
+        details_str = f" | {details}" if details else ""
+        logging.info(msg=f"[AUDIT] {timestamp} | User: {user} (ID: {user.id}) | Guild: {guild_name} | Channel: #{channel_name} | Command: {command}{details_str}")
+
+    @functools.lru_cache(maxsize=128)
+    def _get_cached_command_names(self, is_private: bool) -> List[Tuple[str, str]]:
+        """Cache command names permanently since they never change at runtime."""
+        return self.monitoring.get_command_names(is_private=is_private)
+
+    @functools.lru_cache(maxsize=128)
+    def _get_cached_service_names(self, is_private: bool) -> List[Tuple[str, str]]:
+        """Cache service names permanently since they never change at runtime."""
+        return self.monitoring.get_service_names(is_private=is_private)
+
+    def _is_periodic_cleanup_enabled(self) -> bool:
+        """Check if periodic channel cleanup is enabled in config."""
+        cleanup_config = self.config.get('periodic_channel_cleanup', {})  # type: ignore
+        return cleanup_config.get('enabled', False)
+
+    def _get_cleanup_interval(self) -> float:
+        """Get the interval (in seconds) between cleanup cycles."""
+        cleanup_config = self.config.get('periodic_channel_cleanup', {})  # type: ignore
+        return float(cleanup_config.get('duration_in_sec_wait_between_each_execution', 604800))
+
+    def _get_cleanup_initial_delay(self) -> float:
+        """Get the initial delay (in seconds) before first cleanup execution."""
+        cleanup_config = self.config.get('periodic_channel_cleanup', {})  # type: ignore
+        return float(cleanup_config.get('duration_in_sec_before_first_execution', 604800))
+
+    def _should_cleanup_start_immediately(self) -> bool:
+        """Check if cleanup should start immediately (duration = 0)."""
+        return self._get_cleanup_initial_delay() == 0
+
     def _check_if_valid_guild(self, guild: Union[None,discord.Guild]) -> bool:
         if guild is None:
             return False
@@ -325,7 +432,7 @@ class DiscordBotLinuxMonitor:
 
         embed.add_field(name="🕗 Last deleted message", value=(last_deleted_preview if last_deleted_preview != "" else "N/A")[:1024], inline=False)
 
-        embed.set_footer(text=f"Bot v{__version__} • Last update: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        embed.set_footer(text=f"Bot v{__version__} • Last update: {self._get_utc_timestamp()}")
         return embed
 
     def _infer_embed_color(self, text: str, is_error: bool = False) -> "discord.Color":
@@ -339,7 +446,7 @@ class DiscordBotLinuxMonitor:
     def _build_result_embed(self, title: str, description: str, color: "discord.Color") -> "discord.Embed":
         embed = discord.Embed(title=title[:256], color=color)
         embed.description = (description if description.strip() != "" else "No answer.")[:4096]
-        embed.set_footer(text=f"Bot v{__version__} • {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        embed.set_footer(text=f"Bot v{__version__} • {self._get_utc_timestamp()}")
         return embed
 
     def _split_text_for_embed(self, text: str, max_length: int = 4000) -> List[str]:
@@ -355,21 +462,87 @@ class DiscordBotLinuxMonitor:
             chunks.append(remaining)
         return chunks
 
-    async def _interaction_followup_send_embed(self, interaction: discord.Interaction, title: str, msg: str, icon: str = "", is_error: bool = False, ephemeral: bool = False) -> None:
+    async def _interaction_followup_send_embed(self, interaction: discord.Interaction, title: str, msg: str, icon: str = "", is_error: bool = False, ephemeral: bool = False, enable_pagination: bool = True) -> None:
+        """Send an embed message via interaction followup. Handles pagination for long messages."""
         if msg is None or msg.strip() == "":
             msg = "No answer."
 
-        logging.info(msg=f"Sending embed follow-up '{title}':\n{msg}")
+        # Only log info for non-error responses to reduce log spam
+        if not is_error:
+            logging.info(msg=f"Sending embed follow-up '{title}'")
 
         color: "discord.Color" = self._infer_embed_color(text=msg, is_error=is_error)
         display_title: str = f"{icon} {title}".strip()
         chunks: List[str] = self._split_text_for_embed(text=msg)
 
         try:
-            for index, chunk in enumerate(chunks):
-                page_title: str = display_title if len(chunks) == 1 else f"{display_title} ({index + 1}/{len(chunks)})"
-                embed: "discord.Embed" = self._build_result_embed(title=page_title, description=chunk, color=color)
-                await interaction.followup.send(embed=embed, ephemeral=ephemeral)
+            # If single chunk or pagination disabled, send normally
+            if len(chunks) <= 1 or not enable_pagination:
+                for index, chunk in enumerate(chunks):
+                    page_title: str = display_title if len(chunks) == 1 else f"{display_title} ({index + 1}/{len(chunks)})"
+                    embed: "discord.Embed" = self._build_result_embed(title=page_title, description=chunk, color=color)
+                    try:
+                        await interaction.followup.send(embed=embed, ephemeral=ephemeral)
+                    except discord.InteractionResponded:
+                        logging.debug(msg=f"Interaction already responded for {title}")
+                        return
+            else:
+                # Multiple chunks: use pagination
+                class PaginatedEmbedView(discord.ui.View):
+                    def __init__(self, paginator_self, chunks: List[str], title_template: str, color: discord.Color, ephemeral: bool):
+                        super().__init__(timeout=180.0)
+                        self.paginator = paginator_self
+                        self.chunks = chunks
+                        self.title_template = title_template
+                        self.color = color
+                        self.current_page = 0
+                        self.message: Optional[discord.Message] = None
+                        self.ephemeral = ephemeral
+                        self._update_buttons()
+
+                    def _update_buttons(self) -> None:
+                        self.prev_btn.disabled = self.current_page <= 0
+                        self.next_btn.disabled = self.current_page >= len(self.chunks) - 1
+
+                    async def _update_embed(self, interaction: discord.Interaction) -> None:
+                        chunk = self.chunks[self.current_page]
+                        page_title = f"{self.title_template} ({self.current_page + 1}/{len(self.chunks)})"
+                        embed = self.paginator._build_result_embed(title=page_title, description=chunk, color=self.color)
+                        await interaction.response.defer()
+                        if self.message:
+                            await self.message.edit(embed=embed, view=self)
+
+                    @discord.ui.button(label="◀️", style=discord.ButtonStyle.gray)
+                    async def prev_btn(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+                        if self.current_page > 0:
+                            self.current_page -= 1
+                            self._update_buttons()
+                            await self._update_embed(interaction)
+
+                    @discord.ui.button(label="▶️", style=discord.ButtonStyle.gray)
+                    async def next_btn(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
+                        if self.current_page < len(self.chunks) - 1:
+                            self.current_page += 1
+                            self._update_buttons()
+                            await self._update_embed(interaction)
+
+                    async def on_timeout(self) -> None:
+                        for item in self.children:
+                            item.disabled = True
+                        if self.message:
+                            try:
+                                await self.message.edit(view=self)
+                            except Exception:
+                                pass
+
+                view = PaginatedEmbedView(self, chunks, display_title, color, ephemeral)
+                embed = self._build_result_embed(title=f"{display_title} (1/{len(chunks)})", description=chunks[0], color=color)
+                try:
+                    view.message = await interaction.followup.send(embed=embed, view=view, ephemeral=ephemeral)
+                except discord.InteractionResponded:
+                    logging.debug(msg=f"Interaction already responded for {title}")
+                    return
+
         except Exception as e:
             logging.error(msg=f"Error while sending embed follow-up message: {e}")
 
@@ -439,6 +612,97 @@ class DiscordBotLinuxMonitor:
                     continue
                 raise
 
+    async def _setup_periodic_cleanup_task(self) -> None:
+        """Setup and start the periodic channel cleanup task."""
+        if not self._is_periodic_cleanup_enabled():
+            logging.info(msg="Periodic channel cleanup is disabled in config")
+            return
+
+        logging.info(msg="Setting up periodic channel cleanup task")
+        self.cleanup_task = asyncio.create_task(self._periodic_cleanup_loop())
+
+    async def _periodic_cleanup_loop(self) -> None:
+        """Loop that periodically cleans configured channels."""
+        await self.bot.wait_until_ready()
+        
+        # Wait before first execution if not immediate
+        if not self._should_cleanup_start_immediately():
+            initial_delay = self._get_cleanup_initial_delay()
+            logging.info(msg=f"Periodic cleanup scheduled for {self._format_duration(initial_delay)} from now")
+            await asyncio.sleep(initial_delay)
+        
+        while True:
+            try:
+                for guild in self.bot.guilds:
+                    if guild.id == self.server_id:
+                        await self._execute_cleanup_cycle(guild)
+            except Exception as e:
+                logging.error(msg=f"Error in cleanup loop: {e}")
+            
+            interval = self._get_cleanup_interval()
+            await asyncio.sleep(interval)
+
+    async def _execute_cleanup_cycle(self, guild: discord.Guild) -> None:
+        """Execute cleanup for all configured channels."""
+        cleanup_config = self.config.get('periodic_channel_cleanup', {})  # type: ignore
+        channels_config = cleanup_config.get('channels', [])
+        
+        if not channels_config:
+            return
+        
+        logging.info(msg=f"Starting periodic cleanup cycle for {len(channels_config)} channels")
+        
+        for channel_config in channels_config:
+            try:
+                channel_name = channel_config.get('channel_name')
+                min_days = channel_config.get('min_days_to_keep', 7)
+                description = channel_config.get('description', '')
+                
+                if not channel_name:
+                    logging.warning(msg="Cleanup config entry missing 'channel_name'")
+                    continue
+                
+                channel = discord.utils.get(guild.text_channels, name=channel_name)
+                if not channel:
+                    logging.warning(msg=f"Cleanup channel '{channel_name}' not found in guild")
+                    continue
+                
+                # Check permissions
+                bot_member = guild.me
+                if bot_member is None:
+                    logging.warning(msg="Unable to resolve bot member for cleanup")
+                    continue
+                
+                permissions = channel.permissions_for(bot_member)
+                if not permissions.manage_messages or not permissions.read_message_history:
+                    logging.warning(msg=f"Bot missing permissions for cleanup in channel '{channel_name}'")
+                    continue
+                
+                cutoff_date = datetime.now(timezone.utc) - timedelta(days=min_days)
+                deleted_count = 0
+                
+                async for message in channel.history(oldest_first=False):
+                    if message.created_at < cutoff_date:
+                        try:
+                            await self._delete_message_with_rate_limit_retry(
+                                message=message,
+                                reason=f"Periodic cleanup - keeping messages newer than {min_days} days"
+                            )
+                            deleted_count += 1
+                        except Exception as e:
+                            logging.warning(msg=f"Failed to delete message in cleanup: {e}")
+                            # Continue with next message
+                            continue
+                
+                log_msg = f"Periodic cleanup #{channel_name}: Deleted {deleted_count} messages (kept last {min_days} days)"
+                if description:
+                    log_msg += f" - {description}"
+                logging.info(msg=log_msg)
+                
+            except Exception as e:
+                logging.error(msg=f"Error cleaning up channel '{channel_config.get('channel_name', 'unknown')}': {e}")
+                continue
+
     #endregion
 
     #region BOT COMMANDS AND EVENTS DEFINITIONS
@@ -560,6 +824,9 @@ class DiscordBotLinuxMonitor:
             if self.force_sync_on_startup:
                 await self._force_sync()
 
+        # Setup periodic channel cleanup task
+        await self._setup_periodic_cleanup_task()
+
     async def force_sync(self, interaction: discord.Interaction) -> None:
         if not self._check_if_valid_guild(guild=interaction.guild):
             return
@@ -586,9 +853,9 @@ class DiscordBotLinuxMonitor:
             return
 
         out_msg: str = (
-            f"🤖 Bot version: {__version__}\n"
-            f"� Linux Monitor library version: {self.monitoring.get_raw_version()}\n"
-            f"�🐍 Python compatibility: {__python_version__}"
+            f"🤖 Discord bot version: {__version__}\n"
+            f"- Linux Monitor library version: {self.monitoring.get_raw_version()}\n"
+            f"- 🐍 Python compatibility: {__python_version__}"
         )
         embed = self._build_result_embed(title="🤖 Bot Version", description=out_msg, color=discord.Color.blurple())
         await interaction.response.send_message(embed=embed, ephemeral=True)
@@ -767,10 +1034,28 @@ class DiscordBotLinuxMonitor:
             await interaction.response.send_message(content="❌ Public channels do not allow this command.", ephemeral=True)
             return
 
-        # Say to the user that the command is being processed
-        await interaction.response.defer()
+        # Show confirmation dialog
+        await interaction.response.defer(ephemeral=True)
+
+        view = ConfirmationView()
+        confirmation_msg = await interaction.followup.send(
+            content="⚠️ **DANGEROUS OPERATION** ⚠️\n\nYou are about to reboot the entire server. This will disconnect all users and services!\n\nAre you sure?",
+            view=view,
+            ephemeral=True
+        )
+
+        await view.wait()
+
+        if not view.confirmed:
+            await confirmation_msg.edit(content="❌ Server reboot cancelled.", view=None)
+            self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "reboot", "CANCELLED")
+            return
+
+        # Log the audit trail
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "reboot", "CONFIRMED")
 
         try:
+            await confirmation_msg.edit(content="⏳ Rebooting server...", view=None)
             out_msg: str = await self.monitoring.reboot_server()
             await self._interaction_followup_send_embed(interaction=interaction, title="Server Reboot", icon="🔁", msg=out_msg)
 
@@ -805,6 +1090,9 @@ class DiscordBotLinuxMonitor:
         if not (await self._is_bot_channel_interaction(interaction=interaction, send_message_if_not_bot=True)):
             return
 
+        # Log the audit trail
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "restart_all")
+
         # Say to the user that the command is being processed
         await interaction.response.defer()
 
@@ -826,6 +1114,9 @@ class DiscordBotLinuxMonitor:
         if not (await self._is_bot_channel_interaction(interaction=interaction, send_message_if_not_bot=True)):
             return
 
+        # Log the audit trail
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "restart_service", f"service={service_name}")
+
         # Indiquer que la commande est en cours de traitement
         await interaction.response.defer()
 
@@ -848,6 +1139,9 @@ class DiscordBotLinuxMonitor:
         if not (await self._is_bot_channel_interaction(interaction=interaction, send_message_if_not_bot=True)):
             return
 
+        # Log the audit trail
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "stop_service", f"service={service_name}")
+
         # Indiquer que la commande est en cours de traitement
         await interaction.response.defer()
 
@@ -937,6 +1231,9 @@ class DiscordBotLinuxMonitor:
             await interaction.response.send_message(content="❌ Public channels do not allow this command.", ephemeral=True)
             return
 
+        # Log the audit trail
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "kill_process", f"pid={pid}")
+
         # Indiquer que la commande est en cours de traitement
         await interaction.response.defer()
 
@@ -978,6 +1275,9 @@ class DiscordBotLinuxMonitor:
 
         await interaction.response.defer(ephemeral=True)
 
+        # Log the audit trail for this destructive action
+        self._log_command_audit(interaction.user, interaction.guild, interaction.channel, "clear_channel_messages", f"target_channel=#{channel.name}")
+
         deleted_count: int = 0
         rate_limit_retries: int = 0
         delete_reason: str = f"Requested by {interaction.user} from private channel"
@@ -1191,6 +1491,200 @@ class DiscordBotLinuxMonitor:
             logging.exception(msg=out_msg)
             await self._interaction_followup_send_embed(interaction=interaction, title="Available Commands", icon="📖", msg=out_msg, is_error=True)
 
+    async def show_list_periodic_channels_cleanup(self, interaction: discord.Interaction) -> None:
+        """Show auto-cleanup channel configuration and permission status."""
+        if not self._check_if_valid_guild(guild=interaction.guild):
+            return
+        if not (await self._is_bot_channel_interaction(interaction=interaction, send_message_if_not_bot=True)):
+            return
+        if not self._is_private_channel(channel=interaction.channel):  # type: ignore
+            await interaction.response.send_message(content="❌ This command is only available in private channels.", ephemeral=True)
+            return
+
+        await interaction.response.defer()
+
+        try:
+            # Check if cleanup is enabled
+            if not self._is_periodic_cleanup_enabled():
+                await self._interaction_followup_send_embed(
+                    interaction=interaction,
+                    title="Channel Auto-Cleanup Configuration",
+                    icon="🧹",
+                    msg="⚠️ **Periodic channel cleanup is DISABLED** in config"
+                )
+                return
+
+            cleanup_config = self.config.get('periodic_channel_cleanup', {})  # type: ignore
+            channels_config = cleanup_config.get('channels', [])
+
+            if not channels_config:
+                await self._interaction_followup_send_embed(
+                    interaction=interaction,
+                    title="Channel Auto-Cleanup Configuration",
+                    icon="🧹",
+                    msg="⚠️ **No channels configured** for auto-cleanup"
+                )
+                return
+
+            guild = interaction.guild
+            bot_member = guild.me if guild else None
+            
+            lines = [
+                f"**Status**: ✅ Enabled",
+                f"**Next Cleanup**: {self._format_duration(self._get_cleanup_initial_delay())} from bot start",
+                f"**Cleanup Interval**: Every {self._format_duration(self._get_cleanup_interval())}",
+                "",
+                "**Configured Channels**:",
+                ""
+            ]
+
+            for idx, channel_config in enumerate(channels_config, 1):
+                channel_name = channel_config.get('channel_name', 'unknown')
+                min_days = channel_config.get('min_days_to_keep', 7)
+                description = channel_config.get('description', '')
+
+                # Find channel
+                channel = discord.utils.get(guild.text_channels, name=channel_name) if guild else None
+                channel_status = "✅" if channel else "❌"
+
+                # Check permissions if channel exists
+                perms_status = "✅"
+                perms_details = []
+                if channel and bot_member:
+                    permissions = channel.permissions_for(bot_member)
+                    if not permissions.manage_messages:
+                        perms_status = "❌"
+                        perms_details.append("missing `manage_messages`")
+                    if not permissions.read_message_history:
+                        perms_status = "❌"
+                        perms_details.append("missing `read_message_history`")
+                elif channel and not bot_member:
+                    perms_status = "⚠️"
+                    perms_details.append("bot member not found")
+                elif not channel:
+                    perms_status = "N/A"
+                    perms_details.append("channel not found")
+
+                # Build channel line
+                channel_line = f"**{idx}. {channel_status} #{channel_name}**"
+                if description:
+                    channel_line += f"\n   📝 {description}"
+                channel_line += f"\n   🕐 Keep messages: Last {min_days} days"
+                channel_line += f"\n   🔐 Permissions: {perms_status}"
+                if perms_details:
+                    channel_line += f" ({', '.join(perms_details)})"
+
+                lines.append(channel_line)
+                lines.append("")
+
+            # Summary
+            summary_icon = "✅"
+            all_ok = all(
+                discord.utils.get(guild.text_channels, name=ch.get('channel_name', '')) and
+                (guild.me and 
+                 guild.me.permissions_for(discord.utils.get(guild.text_channels, name=ch.get('channel_name', ''))).manage_messages and
+                 guild.me.permissions_for(discord.utils.get(guild.text_channels, name=ch.get('channel_name', ''))).read_message_history)
+                for ch in channels_config
+            )
+            if not all_ok:
+                summary_icon = "⚠️"
+
+            lines.append(f"**Overall Status**: {summary_icon} " + ("All channels properly configured" if all_ok else "Some issues need attention"))
+
+            msg = "\n".join(lines)
+            is_error = not all_ok
+            
+            await self._interaction_followup_send_embed(
+                interaction=interaction,
+                title="Channel Auto-Cleanup Configuration",
+                icon="🧹",
+                msg=msg,
+                is_error=is_error
+            )
+
+        except Exception as e:
+            out_msg = f"**Internal error checking cleanup configuration**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_embed(
+                interaction=interaction,
+                title="Channel Auto-Cleanup Configuration",
+                icon="🧹",
+                msg=out_msg,
+                is_error=True
+            )
+
+    async def show_help(self, interaction: discord.Interaction, command_name: str = "") -> None:
+        """Show help for Discord bot commands with cooldown info."""
+        if not self._check_if_valid_guild(guild=interaction.guild):
+            return
+        if not (await self._is_bot_channel_interaction(interaction=interaction, send_message_if_not_bot=True)):
+            return
+
+        await interaction.response.defer()
+
+        try:
+            # Get all commands from the bot tree
+            commands_list: List[str] = []
+            
+            # Command metadata with descriptions, cooldowns, and requirements
+            command_info = {
+                "force_sync": {"desc": "🔄 Force command synchronization", "cooldown": "3/20s", "private": True},
+                "version": {"desc": "🤖 Show bot version", "cooldown": "3/20s", "private": False},
+                "usage": {"desc": "📊 View disk space, CPU, RAM", "cooldown": "3/20s", "private": False},
+                "os_infos": {"desc": "🖥️ View basic system info", "cooldown": "3/20s", "private": False},
+                "users": {"desc": "👥 View connected users (private)", "cooldown": "3/20s", "private": True},
+                "user_logins": {"desc": "👥 View last user connections (private)", "cooldown": "3/20s", "private": True},
+                "ping": {"desc": "🌐 Ping websites", "cooldown": "3/20s", "private": False},
+                "websites": {"desc": "🌐 Check website access", "cooldown": "3/20s", "private": False},
+                "certificates": {"desc": "🔒 Check SSL certificates", "cooldown": "3/20s", "private": False},
+                "reboot_server": {"desc": "🔄 Restart the entire server (private, requires confirmation)", "cooldown": "1/60s", "private": True},
+                "services_status": {"desc": "🩺 Check services status", "cooldown": "3/20s", "private": False},
+                "restart_all": {"desc": "🚀 Restart all services", "cooldown": "1/30s", "private": False},
+                "restart_service": {"desc": "🚀 Restart a specific service", "cooldown": "3/20s", "private": False},
+                "stop_service": {"desc": "🛑 Stop a service", "cooldown": "3/20s", "private": False},
+                "list_services": {"desc": "📋 List all services", "cooldown": "3/20s", "private": False},
+                "ports": {"desc": "🔒 Check ports", "cooldown": "3/20s", "private": False},
+                "list_processes": {"desc": "📋 List processes by RAM (private)", "cooldown": "3/20s", "private": True},
+                "list_processes_by_cpu_usage": {"desc": "📋 List processes by CPU (private)", "cooldown": "3/20s", "private": True},
+                "kill_process": {"desc": "☠️ Kill process by PID (private)", "cooldown": "3/20s", "private": True},
+                "clear_channel_messages": {"desc": "🧹 Clear channel messages (private, destructive)", "cooldown": "1/120s", "private": True},
+                "list_clearable_channels": {"desc": "🧹 Show clearable channels (private)", "cooldown": "3/20s", "private": True},
+                "list_commands": {"desc": "📋 List Linux monitor commands", "cooldown": "3/20s", "private": False},
+                "execute_command": {"desc": "🚀 Execute a Linux command", "cooldown": "3/20s", "private": False},
+                "execute_all_commands": {"desc": "🚀 Execute all Linux commands", "cooldown": "1/60s", "private": False},
+                "help": {"desc": "🔍 Show this help message", "cooldown": "3/20s", "private": False},
+                "list_periodic_channels_cleanup": {"desc": "🧹 Show auto-cleanup channel configuration and permission status", "cooldown": "3/20s", "private": True},
+            }
+
+            # Filter commands based on channel privacy
+            is_private_channel = self._is_private_channel(channel=interaction.channel)  # type: ignore
+            filtered_commands = {k: v for k, v in command_info.items() if v.get("private", False) == is_private_channel or not v.get("private", False)}
+            
+            # Filter by command name if provided
+            if command_name:
+                command_name_lower = command_name.lower()
+                matching_cmds = {k: v for k, v in filtered_commands.items() if command_name_lower in k.lower()}
+                if not matching_cmds:
+                    out_msg = f"❌ No commands found matching '{command_name}'"
+                    await self._interaction_followup_send_embed(interaction=interaction, title="Help", icon="🔍", msg=out_msg)
+                    return
+                command_info = matching_cmds
+            else:
+                command_info = filtered_commands
+
+            # Build help text
+            out_msg = ""
+            for cmd, info in sorted(command_info.items()):
+                private_indicator = "🔒 Private" if info["private"] else "🌐 Public"
+                out_msg += f"**/{cmd}** — {info['desc']}\n"
+                out_msg += f"  └─ {private_indicator} | ⏳ Cooldown: {info['cooldown']}\n\n"
+
+            await self._interaction_followup_send_embed(interaction=interaction, title="Discord Bot Commands Help", icon="🔍", msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving help**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_embed(interaction=interaction, title="Help", icon="🔍", msg=out_msg, is_error=True)
+
 
     async def autocomplete_command_name(self, interaction: discord.Interaction, current: str) -> List["app_commands.Choice[str]"]:
         # Suggest the configured command names so the user picks from a list instead of typing them.
@@ -1198,7 +1692,7 @@ class DiscordBotLinuxMonitor:
             is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
             current_lower: str = current.lower()
             choices: List["app_commands.Choice[str]"] = []
-            for command_name, display_name in self.monitoring.get_command_names(is_private=is_private):
+            for command_name, display_name in self._get_cached_command_names(is_private=is_private):
                 if current_lower == "" or current_lower in command_name.lower() or current_lower in display_name.lower():
                     label: str = f"{command_name} — {display_name}"
                     choices.append(app_commands.Choice(name=label[:100], value=command_name))
@@ -1215,7 +1709,7 @@ class DiscordBotLinuxMonitor:
             is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
             current_lower: str = current.lower()
             choices: List["app_commands.Choice[str]"] = []
-            for service_name, display_name in self.monitoring.get_service_names(is_private=is_private):
+            for service_name, display_name in self._get_cached_service_names(is_private=is_private):
                 if current_lower == "" or current_lower in service_name.lower() or current_lower in display_name.lower():
                     label: str = f"{service_name} — {display_name}"
                     choices.append(app_commands.Choice(name=label[:100], value=service_name))

{discordbotlinuxmonitor-1.6.8 → discordbotlinuxmonitor-1.7.0}/setup.py

@@ -6,7 +6,7 @@ with io.open(file='README.md', mode='r', encoding='utf-8') as readme_file:
 
 setup(
     name="DiscordBotLinuxMonitor",
-    version="1.6.8",
+    version="1.7.0",
     description="From discord channels: Get information and warning status of Linux server like service, port, ping, ssl certificate, disk/folder/cpu/ram/swap usage, ip connection, ... (Python and shell library, Linux ONLY)",
     long_description=readme,
     long_description_content_type="text/markdown",