DiscordBotLinuxMonitor 1.0.1__py3-none-any.whl

DiscordBotLinuxMonitor-1.0.1.dist-info/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Quentin Comte-Gaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

DiscordBotLinuxMonitor-1.0.1.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.1
+Name: DiscordBotLinuxMonitor
+Version: 1.0.1
+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/Linux-Monitor-Python-Library
+Author: Quentin Comte-Gaz
+Author-email: quentin@comte-gaz.com
+License: MIT
+Keywords: discord bot warning info linux monitor monitoring server service port ping ssl certificate disk folder cpu ram swap usage ip connection
+Platform: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Networking :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Requires-Python: >=3.3
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: linuxmonitor
+Requires-Dist: discord.py
+Requires-Dist: typing
+Requires-Dist: asyncio
+
+# Discord Bot Linux Monitor (Python library)
+[![PyPI version](https://badge.fury.io/py/DiscordBotLinuxMonitor.svg)](https://pypi.org/project/DiscordBotLinuxMonitor/) [![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://github.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/blob/master/LICENSE.md) [![Donate](https://img.shields.io/badge/Donate-PayPal-blue.svg)](https://paypal.me/QuentinCG) [![Downloads](https://static.pepy.tech/badge/DiscordBotLinuxMonitor)](https://pepy.tech/project/DiscordBotLinuxMonitor) [![Downloads](https://static.pepy.tech/badge/DiscordBotLinuxMonitor/month)](https://pepy.tech/project/DiscordBotLinuxMonitor)
+
+## What is it
+
+This python library is designed to be used as a Linux service to monitor the Linux server manually with discord commands and to send warning or information of the Linux server status to a discord channel periodically (if relevant).
+
+It is possible to have separate 'private discord channel' and 'public discord channel' for:
+ - Sendind discord commands to the bot (visual example in next section)
+ - Getting periodic status of the Linux server (doing periodically some commands from next section)
+ - Getting warnings if there is an issue in the Linux server (periodic status check)
+
+Example of warning:
+  <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/warning_from_periodic_check.jpg" height="400">
+
+It is compatible with python 3+ and usable only on Linux.
+
+<img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/discord.png" width="300">
+
+## List of Discord commands:
+
+### Public and private discord channel commands
+Displayed infos are not the same if you do the command in private or public channel (all info are displayed in private channel, some are hidden from public channels)
+
+ - `/usage`: 📊 View disk space, CPU, RAM, ... 📊
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/usage.jpg" height="400">
+
+ - `/os_infos`: 🖥 View basic system information 🖥
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/os_infos.jpg" height="300">
+
+ - `/ping`: 🌐 Ping websites 🌐
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/ping.jpg" height="150">
+
+ - `/certificates`: 🔒 Check SSL certificates 🔒
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/certificates.jpg" height="400">
+
+ - `/services_status`: 🩺 Check services are running 🩺
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/services_status.jpg" height="150">
+
+ - `/restart_all`: 🚀 Restart all services 🚀
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/restart_all.jpg" height="150">
+
+ - `/restart_service {service_name}`: 🚀 Restart a service 🚀
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/restart_service.jpg" height="150">
+
+ - `/list_services`: 📋 List all available services 📋
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/list_services.jpg" height="150">
+
+ - `/ports`: 🔒 Check ports 🔒
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/ports.jpg" height="200">
+
+
+### Private discord channel commands:
+ - `/force_sync`: 🔄 Force discord command synchronization 🔄
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/force_sync.jpg" height="300">
+
+ - `/users`: 👥 View connected users 👥
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/users.jpg" height="150">
+
+ - `/user_logins`: 👥 View last user connections 👥
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/user_logins.jpg" height="150">
+
+ - `/reboot_server`: 🔄 Restart the entire server 🔄
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/reboot_server.jpg" height="100">
+
+ - `/list_processes`: 📋 List active processes 📋
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/list_processes.jpg" height="200">
+
+ - `/kill_process`: 🚫 Stop a process by PID 🚫
+ <img src="https://raw.githubusercontent.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/master/example/kill_process.jpg" height="200">
+
+## How to install (for first launch)
+
+  - Install package calling `python -m pip install discordbotlinuxmonitor` (or `python setup.py install` from the root of this repository)
+  - Copy and edit [config-example.json file](https://github.com/QuentinCG/Discord-Bot-Linux-Monitor-Python-Library/blob/master/config-example.json) depending on your need (on first launch, remove all `restart_command` from config file to prevent potential looping service restart issues on your server in case your config file is not well configured)
+  - Launch the lib for testing it works:
+```shell
+# Get help
+python3 -m discordbotlinuxmonitor --help
+# Use "--debug" to show more information during command
+# Use "--nodebug" to not show any warning information during command
+
+# Start the discord bot Linux monitor (First time)
+python3 -m discordbotlinuxmonitor --config_file config-example.json --force_sync_on_startup True --debug
+
+# Start the discord bot Linux monitor (after first time)
+python3 -m discordbotlinuxmonitor --config_file config-example.json --force_sync_on_startup False
+```
+  - Go to discord (restart discord if you were already in it)
+  - You should see welcome messages on channels you configured in the config file and be able to communicate with the bot using command defined in previous section
+
+
+## How to install this lib as a service (to keep it running in the Linux server as a monitor)
+
+  - Stop the discord bot and create a service to have it running even after computer reboot:
+```sh
+### Define all base info
+DISCORD_BOT_SERVICE_USER="discordbotlinuxmonitor"
+DISCORD_BOT_SERVICE_GROUP="discordbotlinuxmonitor"
+DISCORD_BOT_SERVICE_NAME="discord-bot"
+DISCORD_BOT_SERVICE_FILE="/etc/systemd/system/${DISCORD_BOT_SERVICE_NAME}.service"
+DISCORD_BOT_FOLDER="/opt/Discord/"
+
+### Add rights to user launching the library depending on what you want it to do ###
+# Only if this library should be able to reboot the server on demand:
+echo "$DISCORD_BOT_SERVICE_USER ALL=(ALL) NOPASSWD: /sbin/reboot" >> /etc/sudoers.d/$DISCORD_BOT_SERVICE_USER
+# Only if this library should be able to kill a process on demand:
+echo "$DISCORD_BOT_SERVICE_USER ALL=(ALL) NOPASSWD: /bin/kill" >> /etc/sudoers.d/$DISCORD_BOT_SERVICE_USER
+# Add also all processes added in your config JSON file you want the library to be able to execute
+# Example for the existing config-example.json file:
+echo "$DISCORD_BOT_SERVICE_USER ALL=(ALL) NOPASSWD: /bin/systemctl" >> /etc/sudoers.d/$DISCORD_BOT_SERVICE_USER
+echo "$DISCORD_BOT_SERVICE_USER ALL=(ALL) NOPASSWD: /etc/init.d/apache2" >> /etc/sudoers.d/$DISCORD_BOT_SERVICE_USER
+echo "$DISCORD_BOT_SERVICE_USER ALL=(ALL) NOPASSWD: /etc/init.d/mariadb" >> /etc/sudoers.d/$DISCORD_BOT_SERVICE_USER
+
+### Create a specific user and group to launch the discord bot service ###
+echo "Creating user $DISCORD_BOT_SERVICE_USER..."
+sudo useradd -r -s /usr/sbin/nologin $DISCORD_BOT_SERVICE_USER
+sudo mkdir -p /home/$DISCORD_BOT_SERVICE_USER
+sudo chown $DISCORD_BOT_SERVICE_USER:$DISCORD_BOT_SERVICE_GROUP /home/$DISCORD_BOT_SERVICE_USER
+sudo usermod -d /home/$DISCORD_BOT_SERVICE_USER $DISCORD_BOT_SERVICE_USER
+
+### Install DiscordBotLinuxMonitor lib for the user ###
+echo "Installing DiscordBotLinuxMonitor for user $DISCORD_BOT_SERVICE_USER..."
+sudo -u $DISCORD_BOT_SERVICE_USER -s
+python3 -m venv /home/$DISCORD_BOT_SERVICE_USER/venv
+source /home/$DISCORD_BOT_SERVICE_USER/venv/bin/activate
+python3 -m pip install discordbotlinuxmonitor
+deactivate
+exit
+
+# Create the Discord bot folder where you should put the json file
+sudo mkdir $DISCORD_BOT_FOLDER
+
+### Create a systemd service file for the Discord bot ###
+cat <<EOF > $DISCORD_BOT_SERVICE_FILE
+[Unit]
+Description=Discord Bot Linux Monitor Service
+After=network.target
+
+[Service]
+ExecStart=/home/$DISCORD_BOT_SERVICE_USER/venv/bin/python3 -m discordbotlinuxmonitor --config_file ${DISCORD_BOT_FOLDER}config.json
+WorkingDirectory=$DISCORD_BOT_FOLDER
+User=$DISCORD_BOT_SERVICE_USER
+Group=$DISCORD_BOT_SERVICE_GROUP
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+echo "Service file created at $DISCORD_BOT_SERVICE_FILE"
+
+### Reload systemd to recognize the new service ###
+echo "Reloading systemd..."
+sudo systemctl daemon-reload
+
+### Enable and start the service ###
+echo "Enabling and starting the Discord bot service..."
+sudo systemctl enable $DISCORD_BOT_SERVICE_NAME
+```
+ - Copy your config file into `$DISCORD_BOT_FOLDER/config.json`
+ - Launch the service: `sudo systemctl start $DISCORD_BOT_SERVICE_NAME`
+
+## License
+
+This project is under MIT license. This means you can use it as you want (just don't delete the library header).
+
+## Contribute
+
+If you want to add more examples or improve the library, just create a pull request with proper commit message and right wrapping.

DiscordBotLinuxMonitor-1.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+discordbotlinuxmonitor/__init__.py,sha256=YwLKm4ALTaT7YNOTCO3X3m6yDOpybb1r5MvOF6Bt_Lg,74
+discordbotlinuxmonitor/__main__.py,sha256=tOwcXUgZhtBDV9SzYButAsNdcux97vaKsoOXL9Xu13I,6138
+discordbotlinuxmonitor/discordbotlinuxmonitor.py,sha256=YE6tydHspmMlEUeFj7T6HljxkgtR0R4i_ULwaBgGqpo,42432
+DiscordBotLinuxMonitor-1.0.1.dist-info/LICENSE.md,sha256=nVjNnWWojuUQdnMdUf_YVeRMocBeapYhuLfIRQXXziI,1084
+DiscordBotLinuxMonitor-1.0.1.dist-info/METADATA,sha256=l0IyJh0R6YKQnFA86Oek6rqjJzVPfCMD6IB1Uqut5wU,10942
+DiscordBotLinuxMonitor-1.0.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+DiscordBotLinuxMonitor-1.0.1.dist-info/top_level.txt,sha256=xQ2GrL3jLRaO6NVSLrgtD3wGaqS7MeZzICTeqhyr5_w,23
+DiscordBotLinuxMonitor-1.0.1.dist-info/RECORD,,

DiscordBotLinuxMonitor-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

DiscordBotLinuxMonitor-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+discordbotlinuxmonitor

discordbotlinuxmonitor/__init__.py

@@ -0,0 +1 @@
+from .discordbotlinuxmonitor import DiscordBotLinuxMonitor # type: ignore

discordbotlinuxmonitor/__main__.py

@@ -0,0 +1,125 @@
+from .discordbotlinuxmonitor import DiscordBotLinuxMonitor
+
+import argparse
+import sys
+import logging
+
+import discord
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description='System Management Tool controled from Discord')
+
+    # Define available arguments
+    parser.add_argument('--config_file', type=str, required=True, help='Path to the configuration file (must be a JSON file)')
+    parser.add_argument('--force_sync_on_startup', type=bool, required=True, help='Force discord command synchronization on startup (do it only the first time, because after, you will have a discord command to do it if really needed)')
+
+    parser.add_argument('--debug', action='store_true', help='Enable debug mode')
+    parser.add_argument('--nodebug', action='store_true', help='Disable all logs')
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Enable or disable debug mode
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+    elif args.nodebug:
+        logging.getLogger().setLevel(logging.CRITICAL)
+    else:
+        # Default to warning
+        logging.getLogger().setLevel(logging.WARNING)
+
+    # Ensure the config file is provided
+    if not args.config_file:
+        print("Error: --config_file is required")
+        parser.print_help()
+        sys.exit(1)
+    config_file: str = args.config_file
+
+    # Ensure the force_sync_on_startup is provided
+    if not args.force_sync_on_startup:
+        print("Error: --force_sync_on_startup is required")
+        parser.print_help()
+        sys.exit(1)
+    force_sync_on_startup: bool = args.force_sync_on_startup
+
+    # Prepare the Discord bot (will throw an exception if the configuration is invalid)
+    discord_bot_linux_monitor = DiscordBotLinuxMonitor(config_file=config_file, force_sync_on_startup=force_sync_on_startup)
+    discord_bot = discord_bot_linux_monitor.bot
+
+    #region BOT COMMANDS AND EVENTS REGIRSTRATION
+
+    @discord_bot.event
+    async def on_ready() -> None: # type: ignore
+        await discord_bot_linux_monitor.on_ready()
+
+    @discord_bot.tree.command(name="force_sync", description="[Private] 🔄 Force command synchronization 🔄")
+    async def force_sync(interaction: discord.Interaction) -> None: # type: ignore
+        await discord_bot_linux_monitor.force_sync(interaction)
+
+    @discord_bot.tree.command(name="usage", description="📊 View disk space, CPU, RAM, ... 📊")
+    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 🖥️")
+    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 👥")
+    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 👥")
+    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 🌐")
+    async def ping(interaction: discord.Interaction) -> None: # type: ignore
+        await discord_bot_linux_monitor.ping(interaction)
+
+    @discord_bot.tree.command(name="certificates", description="🔒 Check SSL certificates 🔒")
+    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 🔄")
+    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 🩺")
+    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 🚀")
+    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 🚀")
+    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="list_services", description="📋 List all available services 📋")
+    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 🔒")
+    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 📋")
+    async def list_processes(interaction: discord.Interaction) -> None: # type: ignore
+        await discord_bot_linux_monitor.list_processes(interaction)
+
+    @discord_bot.tree.command(name="kill_process", description="[Private] 🚫 Stop a process by PID 🚫")
+    async def kill_process(interaction: discord.Interaction, pid: int) -> None: # type: ignore
+        await discord_bot_linux_monitor.kill_process(interaction, pid)
+
+    #endregion
+
+    # Start the discord bot
+    logging.info(msg="Starting the Discord bot...")
+    try:
+        discord_bot.run(token=discord_bot_linux_monitor.server_token)
+    except Exception as e:
+        logging.exception(msg=f"Error while running the bot: {e}")
+
+if __name__ == "__main__":
+    main()

discordbotlinuxmonitor/discordbotlinuxmonitor.py

@@ -0,0 +1,741 @@
+"""
+Discord bot to:
+    - monitor a Linux server and inform about its status (in case of issues or periodical info) through Discord channels
+    - execute commands from Discord channels
+
+Non exhaustive list of features (available by using it in shell or in python script):
+    - Do all checks bellow in a scheduled tasks and display the results only if there is an issue (only in console if using only the library)
+    - Do all checks bellow in a scheduled tasks and display the results every time (only in console if using only the library)
+
+    - Check CPU, RAM, SWAP, Temperature
+    - Check disk usage
+    - Check folder usage
+    - Check websites basic availability (ping)
+    - Check services status and restart them if needed
+    - Check certificates expiration and validity
+    - Check last user connections IPs
+    - Check uptime (to inform if the server has been rebooted)
+
+    - Get hostname, OS details, kernel version, server datetime, uptime
+    - Get connected users
+
+    - Get processes list (PID and name)
+    - Kill a process by PID
+
+    - Reboot server
+"""
+
+__author__ = 'Quentin Comte-Gaz'
+__email__ = "quentin@comte-gaz.com"
+__license__ = "MIT License"
+__copyright__ = "Copyright Quentin Comte-Gaz (2024)"
+__python_version__ = "3.+"
+__version__ = "1.0.1 (2024/09/14)"
+__status__ = "Usable for any Linux project"
+
+# pyright: reportMissingTypeStubs=false
+from linuxmonitor import LinuxMonitor
+
+import discord
+from discord.app_commands.models import AppCommand
+from discord.ext import commands
+import json
+from typing import List, Union, Awaitable, Callable
+
+import asyncio
+
+import logging
+
+class DiscordBotLinuxMonitor:
+
+    #region Initialization
+
+    def __init__(self, config_file: str, force_sync_on_startup: bool) -> None:
+        logging.debug(msg=f"Loading configuration file {config_file}...")
+        with open(file=config_file, mode='r') as file:
+            self.config = json.load(file)
+
+        # Check if the configuration is correct
+        self._init_and_check_configuration()
+
+        # Initialize the LinuxMonitor
+        self.monitoring = LinuxMonitor(
+                        config_file=config_file,
+                        allow_scheduled_tasks_check_for_issues=(self.channel_name_for_public_error_tasks != "" or self.channel_name_for_private_error_tasks != ""), # type: ignore
+                        allow_scheduled_task_show_info=(self.channel_name_for_public_infos_tasks != "" or self.channel_name_for_private_infos_tasks != "") # type: ignore
+                    )
+
+        # Initialize the bot
+        self.force_sync_on_startup: bool = force_sync_on_startup
+        self.MAX_LENGTH_OF_DISCORD_MESSAGE = 2000 # Forced by Discord API
+        intents: discord.Intents = discord.Intents.default()
+        self.bot = commands.Bot(command_prefix=self.command_prefix, intents=intents)
+
+    def _init_and_check_configuration(self) -> None:
+        """
+        Check if the JSON configuration file is correct for discord usage.
+        """
+        # Check if the configuration is a dictionary
+        if not isinstance(self.config, dict):
+            raise ValueError("The configuration must be a dictionary")
+
+        # Check if the configuration contains the necessary keys
+        if 'discord_config' not in self.config: # type: ignore
+            raise ValueError("The configuration must contain the 'discord_config' key")
+
+        # Get the discord configuration (check if it is a dictionary)
+        discord_config: Dict[str, Any] = self.config.get('discord_config', {}) # type: ignore
+        if not isinstance(discord_config, dict):
+            raise ValueError("The discord configuration (discord_config) must be a dictionary")
+
+        if 'server_id' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'server_id' key")
+        self.server_id: int = discord_config.get('server_id') # type: ignore
+
+        if 'server_token' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'server_token' key")
+        self.server_token: str = discord_config.get('server_token') # type: ignore
+
+        if 'command_prefix' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'command_prefix' key")
+        self.command_prefix: str = discord_config.get('command_prefix', "/") # type: ignore
+
+        if 'channel_name_for_private_commands' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_private_commands' key")
+        self.channel_name_for_private_commands: str = discord_config.get('channel_name_for_private_commands', "") # type: ignore
+
+        if 'channel_name_for_public_commands' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_public_commands' key")
+        self.channel_name_for_public_commands: str = discord_config.get('channel_name_for_public_commands', "") # type: ignore
+
+        if 'channel_name_for_private_error_tasks' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_private_error_tasks' key")
+        self.channel_name_for_private_error_tasks: str = discord_config.get('channel_name_for_private_error_tasks', "") # type: ignore
+
+        if 'channel_name_for_public_error_tasks' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_public_error_tasks' key")
+        self.channel_name_for_public_error_tasks: str = discord_config.get('channel_name_for_public_error_tasks', "") # type: ignore
+
+        if 'channel_name_for_private_infos_tasks' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_private_infos_tasks' key")
+        self.channel_name_for_private_infos_tasks: str = discord_config.get('channel_name_for_private_infos_tasks', "") # type: ignore
+
+        if 'channel_name_for_public_infos_tasks' not in discord_config:
+            raise ValueError("The basic configuration must contain the 'channel_name_for_public_infos_tasks' key")
+        self.channel_name_for_public_infos_tasks: str = discord_config.get('channel_name_for_public_infos_tasks', "") # type: ignore
+
+        if self.channel_name_for_private_commands != "": # type: ignore
+            if 'welcome_message_for_private_commands' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_private_commands' key")
+            self.welcome_message_for_private_commands: str = discord_config.get('welcome_message_for_private_commands', "") # type: ignore
+
+        if self.channel_name_for_public_commands != "": # type: ignore
+            if 'welcome_message_for_public_commands' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_public_commands' key")
+            self.welcome_message_for_public_commands: str = discord_config.get('welcome_message_for_public_commands', "") # type: ignore
+
+        if self.channel_name_for_private_error_tasks != "": # type: ignore
+            if 'welcome_message_for_private_error_tasks' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_private_error_tasks' key")
+            self.welcome_message_for_private_error_tasks: str = discord_config.get('welcome_message_for_private_error_tasks', "") # type: ignore
+
+        if self.channel_name_for_public_error_tasks != "": # type: ignore
+            if 'welcome_message_for_public_error_tasks' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_public_error_tasks' key")
+            self.welcome_message_for_public_error_tasks: str = discord_config.get('welcome_message_for_public_error_tasks', "") # type: ignore
+
+        if self.channel_name_for_private_infos_tasks != "": # type: ignore
+            if 'welcome_message_for_private_infos_tasks' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_private_infos_tasks' key")
+            self.welcome_message_for_private_infos_tasks: str = discord_config.get('welcome_message_for_private_infos_tasks', "") # type: ignore
+
+        if self.channel_name_for_public_infos_tasks != "": # type: ignore
+            if 'welcome_message_for_public_infos_tasks' not in discord_config:
+                raise ValueError("The basic configuration must contain the 'welcome_message_for_public_infos_tasks' key")
+            self.welcome_message_for_public_infos_tasks: str = discord_config.get('welcome_message_for_public_infos_tasks', "") # type: ignore
+
+        # Check that at least one channel is defined
+        if self.channel_name_for_private_commands == "" and self.channel_name_for_public_commands == "" and self.channel_name_for_private_error_tasks == "" and self.channel_name_for_public_error_tasks == "" and self.channel_name_for_private_infos_tasks == "" and self.channel_name_for_public_infos_tasks == "": # type: ignore
+            raise ValueError("At least one channel must be defined (private or public) in the configuration file, else there is no point to use this lib (channel_name_for_private_commands, channel_name_for_public_commands, channel_name_for_private_error_tasks, channel_name_for_public_error_tasks, channel_name_for_private_infos_tasks, channel_name_for_public_infos_tasks)")
+
+    #endregion
+
+    #region Private methods
+
+    def _check_if_valid_guild(self, guild: Union[None,discord.Guild]) -> bool:
+        if guild is None:
+            return False
+
+        # Be sure it is from the correct server
+        if guild.id != self.server_id:
+            logging.warning(msg=f"Message received from invalid guild '{guild.name}' (id: '{guild.id}'), IGNORING THIS MESSAGE.")
+            return False
+        return True
+
+    async def _is_bot_channel_interaction(self, interaction: discord.Interaction, send_message_if_not_bot: bool) -> bool:
+        res: bool = self._is_bot_channel(channel=interaction.channel) # type: ignore
+        if not res and send_message_if_not_bot:
+            await interaction.response.send_message(content=f"❌ This is not the right channel to send commands to the bot. You need to communicate in the private channel '{self.channel_name_for_private_commands}' or the public channel '{self.channel_name_for_public_commands}'.", ephemeral=True)
+        return res
+
+    def _is_bot_channel(self, channel) -> bool: # type: ignore
+        return self._is_private_channel(channel=channel) or self._is_public_channel(channel=channel) # type: ignore
+
+    def _is_private_channel(self, channel) -> bool: # type: ignore
+        if channel is None:
+            return False
+
+        if self.channel_name_for_private_commands == "":
+            return False
+
+        res: bool = (self.channel_name_for_private_commands == channel.name) # type: ignore
+        return res # type: ignore
+
+    def _is_public_channel(self, channel) -> bool: # type: ignore
+        if channel is None:
+            return False
+
+        if self._is_private_channel(channel=channel): # type: ignore
+            return False
+
+        if self.channel_name_for_public_commands == "":
+            return False
+
+        res: bool = (self.channel_name_for_public_commands == channel.name) # type: ignore
+        return res # type: ignore
+
+    async def _channel_send_no_limit(self, channel: discord.TextChannel, msg: str) -> None:
+        logging.info(msg=f"Sending message to channel '{channel.name}':\n{msg}")
+
+        while len(msg) > self.MAX_LENGTH_OF_DISCORD_MESSAGE:
+            # Find the last newline within the limit
+            split_point = msg.rfind('\n', 0, self.MAX_LENGTH_OF_DISCORD_MESSAGE)
+            if split_point == -1:  # No newline found, split at max_length
+                split_point = self.MAX_LENGTH_OF_DISCORD_MESSAGE
+
+            # Send the chunk and remove it from the message
+            await channel.send(content=msg[:split_point].rstrip())
+            msg = msg[split_point:].lstrip()
+
+        # Send the remaining message
+        if msg:
+            await channel.send(content=msg)
+
+    async def _interaction_followup_send_no_limit(self, interaction: discord.Interaction, msg: str) -> None:
+        logging.info(msg=f"Sending follow-up message:\n{msg}")
+
+        # Send the first chunk as a follow-up message
+        try:
+            if msg == "":
+                # Send generic interaction response if no message is returned
+                msg = "No answer."
+
+            if len(msg) > self.MAX_LENGTH_OF_DISCORD_MESSAGE:
+                # Find the last newline within the limit or just split at max_length
+                split_point = msg.rfind('\n', 0, self.MAX_LENGTH_OF_DISCORD_MESSAGE)
+                if split_point == -1:  # No newline found, split at max_length
+                    split_point = self.MAX_LENGTH_OF_DISCORD_MESSAGE
+
+                await interaction.followup.send(content=msg[:split_point].rstrip())
+                msg = msg[split_point:].lstrip()
+            else:
+                await interaction.followup.send(content=msg)
+                return  # Exit if the message fits within the limit
+
+        except Exception as e:
+            logging.error(msg=f"Error while sending follow-up message: {e}")
+            return
+
+        # Handle additional messages that exceed the initial follow-up limit
+        while len(msg) > self.MAX_LENGTH_OF_DISCORD_MESSAGE:
+            split_point = msg.rfind('\n', 0, self.MAX_LENGTH_OF_DISCORD_MESSAGE)
+            if split_point == -1:
+                split_point = self.MAX_LENGTH_OF_DISCORD_MESSAGE
+
+            try:
+                await interaction.channel.send(content=msg[:split_point].rstrip()) # type: ignore
+            except Exception as e:
+                logging.error(msg=f"Error while sending message to channel: {e}")
+
+            msg = msg[split_point:].lstrip()
+
+        # Send any remaining message directly to the channel
+        if msg:
+            try:
+                await interaction.channel.send(content=msg) # type: ignore
+            except Exception as e:
+                logging.error(msg=f"Error while sending message to channel: {e}")
+
+    async def _force_sync(self) -> str:
+        try:
+            logging.info(msg="Forcing the sync of the bot's commands...")
+            synced: List[AppCommand] = await self.bot.tree.sync()
+
+            out_msg: str = f"🔄 **Commands synchronized successfully** 🔄"
+            for s in synced:
+                out_msg += f"\n- `{s.name}`: {s.description}"
+
+            logging.info(msg=out_msg)
+            return out_msg
+        except Exception as e:
+            out_msg = f"**Internal error during command synchronization**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            return out_msg
+
+    #endregion
+
+    #region BOT COMMANDS AND EVENTS DEFINITIONS
+
+    async def on_ready(self) -> None:
+        logging.info(msg=f"Discord bot '{self.bot.user}' is ready.")
+        logging.info(msg=f"Connected to the following guilds (will check them): {[guild.name for guild in self.bot.guilds]}")
+        for guild in self.bot.guilds:
+            if guild.id == self.server_id:
+                # Found the correct guild
+                logging.info(msg=f"Bot '{self.bot.user}' is connected to the following wanted guild: '{guild.name}' (id: '{guild.id}')..")
+
+                public_channel_cmd_ready: bool = (self.channel_name_for_public_commands == "")
+                private_channel_cmd_ready: bool = (self.channel_name_for_private_commands == "")
+                public_channel_error_task_ready: bool = (self.channel_name_for_public_error_tasks == "")
+                private_channel_error_task_ready: bool = (self.channel_name_for_private_error_tasks == "")
+                public_channel_info_task_ready: bool = (self.channel_name_for_public_infos_tasks == "")
+                private_channel_info_task_ready: bool = (self.channel_name_for_private_infos_tasks == "")
+
+                for channel in guild.text_channels:
+                    if self.channel_name_for_public_commands != "" and channel.name == self.channel_name_for_public_commands:
+                        logging.info(msg="Found the public channel, it will be possible to do public commands.")
+                        public_channel_cmd_ready = True
+                        if self.welcome_message_for_public_commands != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_public_commands)
+
+                    if self.channel_name_for_private_commands != "" and channel.name == self.channel_name_for_private_commands:
+                        logging.info(msg="Found the private channel, it will be possible to do private commands.")
+                        private_channel_cmd_ready = True
+                        if self.welcome_message_for_private_commands != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_private_commands)
+
+                    if self.channel_name_for_public_error_tasks != "" and channel.name == self.channel_name_for_public_error_tasks:
+                        logging.info(msg="Found the public channel for error task, it will be possible to show public status issues if found periodically.")
+                        public_channel_error_task_ready = True
+
+                        if self.welcome_message_for_public_error_tasks != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_public_error_tasks)
+
+                        logging.info(msg=f"Activating automatic public follow and public service restart if down with '{self.bot.user}' and guild '{guild.name}' (id: '{guild.id}') on channel '{channel.name}' (id '{channel.id}').")
+                        public_channel_for_error_task: discord.TextChannel = channel
+                        send_message_public_error_task_func: Callable[[str], Awaitable[None]] = lambda msg: asyncio.create_task(self._channel_send_no_limit(channel=public_channel_for_error_task, msg=msg))
+
+                        # Start the public schedule task
+                        self.bot.loop.create_task(self.monitoring.schedule_task(handle_error_message=send_message_public_error_task_func, is_private=False))
+
+                    if self.channel_name_for_public_infos_tasks != "" and channel.name == self.channel_name_for_public_infos_tasks:
+                        logging.info(msg="Found the public channel for info task, it will be possible to show public info periodically.")
+                        public_channel_info_task_ready = True
+
+                        if self.welcome_message_for_public_infos_tasks != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_public_infos_tasks)
+
+                        logging.info(msg=f"Activating automatic public follow info with '{self.bot.user}' and guild '{guild.name}' (id: '{guild.id}') on channel '{channel.name}' (id '{channel.id}').")
+                        public_channel_for_info_task: discord.TextChannel = channel
+                        send_message_public_info_task_func: Callable[[str], Awaitable[None]] = lambda msg: asyncio.create_task(self._channel_send_no_limit(channel=public_channel_for_info_task, msg=msg))
+
+                        # Start the public schedule task
+                        self.bot.loop.create_task(self.monitoring.schedule_task_show_info(show_message=send_message_public_info_task_func, is_private=False))
+
+                    if self.channel_name_for_private_error_tasks != "" and channel.name == self.channel_name_for_private_error_tasks:
+                        logging.info(msg="Found the private channel for error task, it will be possible to show private and public status issues if found periodically.")
+                        private_channel_error_task_ready = True
+
+                        if self.welcome_message_for_private_error_tasks != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_private_error_tasks)
+
+                        logging.info(msg=f"Activating automatic private follow and public service restart if down with '{self.bot.user}' and guild '{guild.name}' (id: '{guild.id}') on channel '{channel.name}' (id '{channel.id}').")
+                        private_channel_for_error_task: discord.TextChannel = channel
+                        send_message_private_error_task_func: Callable[[str], Awaitable[None]] = lambda msg: asyncio.create_task(self._channel_send_no_limit(channel=private_channel_for_error_task, msg=msg))
+
+                        # Start the private schedule task
+                        self.bot.loop.create_task(self.monitoring.schedule_task(handle_error_message=send_message_private_error_task_func, is_private=True))
+
+                    if self.channel_name_for_private_infos_tasks != "" and channel.name == self.channel_name_for_private_infos_tasks:
+                        logging.info(msg="Found the private channel for info task, it will be possible to show private info periodically.")
+                        private_channel_info_task_ready = True
+
+                        if self.welcome_message_for_private_infos_tasks != "":
+                            await self._channel_send_no_limit(channel=channel, msg=self.welcome_message_for_private_infos_tasks)
+
+                        logging.info(msg=f"Activating automatic private follow info with '{self.bot.user}' and guild '{guild.name}' (id: '{guild.id}') on channel '{channel.name}' (id '{channel.id}').")
+                        private_channel_for_info_task: discord.TextChannel = channel
+                        send_message_private_info_task_func: Callable[[str], Awaitable[None]] = lambda msg: asyncio.create_task(self._channel_send_no_limit(channel=private_channel_for_info_task, msg=msg))
+
+                        # Start the private schedule task
+                        self.bot.loop.create_task(self.monitoring.schedule_task_show_info(show_message=send_message_private_info_task_func, is_private=True))
+
+                # Show a warning if a channel is not found and should be found
+                if not public_channel_cmd_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Public channel '{self.channel_name_for_public_commands}' not found in server: '{guild.name}', public commands will not be available.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                if not private_channel_cmd_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Private channel '{self.channel_name_for_private_commands}' not found in server: '{guild.name}', private commands will not be available.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                if not public_channel_error_task_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Public channel '{self.channel_name_for_public_error_tasks}' not found in server: '{guild.name}', public status issues will not be shown periodically if found.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                if not private_channel_error_task_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Private channel '{self.channel_name_for_private_error_tasks}' not found in server: '{guild.name}', private and public status issues will not be shown periodically if found.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                if not public_channel_info_task_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Public channel '{self.channel_name_for_public_infos_tasks}' not found in server: '{guild.name}', public info will not be shown periodically.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                if not private_channel_info_task_ready:
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    logging.critical(msg=f"Private channel '{self.channel_name_for_private_infos_tasks}' not found in server: '{guild.name}', private info will not be shown periodically.")
+                    logging.critical(msg=f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            else:
+                # Found an undesired guild, disconnect
+                logging.info(msg=f"Bot '{self.bot.user}' is connected to the following UNDESIRED guild: '{guild.name}' (id: '{guild.id}'), IGNORING THIS GUILD.")
+
+            # Sync the bot's commands globally
+            if self.force_sync_on_startup:
+                await self._force_sync()
+
+    async def force_sync(self, interaction: discord.Interaction) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        # Sync the bot's commands only on the 2 public and private channels
+        out_msg: str = await self._force_sync()
+
+        # Respond to the user
+        await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def usage(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.check_all_disk_usage(is_private=is_private, display_only_if_critical=False)
+
+            msg: str = self.monitoring.check_all_folder_usage(is_private=is_private, display_only_if_critical=False)
+            if msg != "":
+                if out_msg != "":
+                    out_msg += "\n"
+                out_msg += msg
+
+            if is_private:
+                out_msg += "\n"
+                out_msg += self.monitoring.check_cpu_usage(display_only_if_critical=False) + "\n"
+                out_msg += self.monitoring.check_ram_usage(display_only_if_critical=False) + "\n"
+                out_msg += self.monitoring.check_swap_usage(display_only_if_critical=False) + "\n"
+                out_msg += self.monitoring.check_cpu_temperature(display_only_if_critical=False) + "\n"
+                out_msg += self.monitoring.get_network_info()
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving usage info**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def os_infos(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            out_msg: str = self.monitoring.get_hostname() + "\n"
+            out_msg += self.monitoring.get_os_details() + "\n"
+            out_msg += self.monitoring.get_kernel_version() + "\n"
+            out_msg += self.monitoring.check_uptime(display_only_if_critical=False) + "\n"
+            out_msg += self.monitoring.get_server_datetime()
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving OS info**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def users(self, interaction: discord.Interaction) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            out_msg: str = self.monitoring.get_connected_users()
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving connected users**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def user_logins(self, interaction: discord.Interaction) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Récupérer les dernières connexions des utilisateurs
+            out_msg: str = self.monitoring.check_all_recent_user_logins(display_only_if_critical=False)
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+        except Exception as e:
+            out_msg = f"**Internal error retrieving last user connections**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def ping(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.ping_all_websites(is_private=is_private, display_only_if_critical=False)
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error during websites ping **:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def certificates(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.check_all_certificates(is_private=is_private, display_only_if_critical=False)
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error during SSL certificate checks **:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def reboot(self, interaction: discord.Interaction) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            out_msg: str = self.monitoring.reboot_server()
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+        except Exception as e:
+            out_msg = f"**Internal error during server reboot**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def services_status(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.check_all_services_status(is_private=is_private)
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error checking services are running**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def restart_all(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Say to the user that the command is being processed
+        await interaction.response.defer()
+
+        try:
+            # Restart all services and get the results
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.restart_all_services(is_private=is_private)
+
+            # Respond to the user
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error restarting all services**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def restart_service(self, interaction: discord.Interaction, service_name: str) -> None:
+        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
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Redémarrer le service et récupérer le message de sortie
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.restart_service(is_private=is_private, service_name=service_name)
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+        except Exception as e:
+            out_msg = f"**Internal error restarting service {service_name}**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def list_services(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Récupérer la liste des services
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.get_all_services_allowed_to_restart(is_private=is_private)
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving available services**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def ports(self, interaction: discord.Interaction) -> None:
+        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
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Récupérer le statut des ports
+            is_private: bool = self._is_private_channel(channel=interaction.channel) # type: ignore
+            out_msg: str = self.monitoring.check_all_ports(restart_if_down=True, is_private=is_private, display_only_if_critical=False)
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error checking ports**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def list_processes(self, interaction: discord.Interaction) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Récupérer la liste des processus actifs
+            out_msg: str = self.monitoring.get_ordered_processes()
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error retrieving active processes**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    async def kill_process(self, interaction: discord.Interaction, pid: int) -> None:
+        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="❌ Public channels do not allow this command.", ephemeral=True)
+            return
+
+        # Indiquer que la commande est en cours de traitement
+        await interaction.response.defer()
+
+        try:
+            # Arrêter le processus et récupérer le message de sortie
+            out_msg: str = self.monitoring.kill_process(pid=pid)
+
+            # Répondre à l'utilisateur
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+        except Exception as e:
+            out_msg = f"**Internal error stopping process of PID {pid}**:\n```sh\n{e}\n```"
+            logging.exception(msg=out_msg)
+            await self._interaction_followup_send_no_limit(interaction=interaction, msg=out_msg)
+
+    #endregion