diff --git a/server_monitor_bot.js b/server_monitor_bot.js
index 2521593..dc40a46 100644
--- a/server_monitor_bot.js
+++ b/server_monitor_bot.js
@@ -1,288 +1,999 @@
-const TelegramBot = require('node-telegram-bot-api');
-const ping = require('ping');
-const os = require('os');
-const fs = require('fs');
-const yaml = require('js-yaml');
-
-const token = '6409908881:AAGoE35Ohy1TIKljSb7Y0gaDWhdR23Z_Pl4';
-const bot = new TelegramBot(token, { polling: true });
-
-let userServerConfigurations = loadConfigurations();
-const chatIds = new Set(); // Set für die Chat-IDs
-
-function loadConfigurations() {
-    try {
-        if (fs.existsSync('configurations.yml')) {
-            const data = fs.readFileSync('configurations.yml', 'utf8');
-            return yaml.load(data) || {};
-        } else {
-            saveConfigurations({});
-            return {};
-        }
-    } catch (error) {
-        console.error('Fehler beim Laden der Konfigurationen:', error.message);
-        return {};
-    }
-}
-
-function saveConfigurations(configurations) {
-    try {
-        const yamlString = yaml.dump(configurations);
-        fs.writeFileSync('configurations.yml', yamlString, 'utf8');
-    } catch (error) {
-        console.error('Fehler beim Speichern der Konfigurationen:', error.message);
-    }
-}
-
-function getCpuUsage() {
-    return Math.floor(Math.random() * 101);
-}
-
-function getRamUsage() {
-    return Math.floor(Math.random() * 101);
-}
-
-function getNetworkTraffic() {
-    return Math.floor(Math.random() * 101);
-}
-
-async function getUptime() {
-    const uptimeInSeconds = os.uptime();
-    const days = Math.floor(uptimeInSeconds / (24 * 3600));
-    const hours = Math.floor((uptimeInSeconds % (24 * 3600)) / 3600);
-    const minutes = Math.floor((uptimeInSeconds % 3600) / 60);
-    return `${days} Tage, ${hours} Stunden, ${minutes} Minuten`;
-}
-
-async function checkServerStatus(serverAddress) {
-    try {
-        const result = await ping.promise.probe(serverAddress);
-        return result.alive ? 'Online' : 'Offline';
-    } catch (error) {
-        console.error(`Fehler beim Überprüfen des Servers ${serverAddress}: ${error.message}`);
-        return 'Fehler';
-    }
-}
-
-const usersAddingServer = {};
-
-const onlineIcon = '✅';
-const offlineIcon = '❌';
-const errorIcon = '⚠️';
-const bannerEmoji = '🚀';
-
-bot.onText(/\/start/, (msg) => {
-    const chatId = msg.chat.id;
-    chatIds.add(chatId); // Füge die Chat-ID zum Set hinzu
-    bot.sendMessage(chatId, 'Bot gestartet. Benutze /add_server, /delete_server, /status und /help für Serververwaltung.');
-});
-
-bot.onText(/\/add_server/, (msg) => {
-    const chatId = msg.chat.id;
-
-    bot.sendMessage(chatId, 'Füge einen neuen Server hinzu. Sende mir zuerst den Namen des Servers:');
-
-    usersAddingServer[chatId] = { name: null, address: null };
-
-    bot.once('text', (serverNameMsg) => {
-        usersAddingServer[chatId].name = serverNameMsg.text;
-
-        bot.sendMessage(chatId, `Servername ${bannerEmoji}${serverNameMsg.text}${bannerEmoji} wurde hinzugefügt. Jetzt sende mir die IP-Adresse des Servers:`);
-
-        bot.once('text', (serverAddressMsg) => {
-            usersAddingServer[chatId].address = serverAddressMsg.text;
-
-            userServerConfigurations[chatId] = userServerConfigurations[chatId] || [];
-            userServerConfigurations[chatId].push(usersAddingServer[chatId]);
-
-            saveConfigurations(userServerConfigurations);
-
-            bot.sendMessage(chatId, `Server ${bannerEmoji}${usersAddingServer[chatId].name}${bannerEmoji} mit Adresse "${usersAddingServer[chatId].address}" wurde hinzugefügt.`);
-        });
-    });
-});
-
-bot.onText(/\/delete_server/, (msg) => {
-    const chatId = msg.chat.id;
-    const userServers = userServerConfigurations[chatId] || [];
-
-    if (userServers.length === 0) {
-        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
-        return;
-    }
-
-    const keyboard = {
-        reply_markup: {
-            inline_keyboard: userServers.map(server => [{
-                text: `${server.name} - ${server.address}`,
-                callback_data: `delete:${server.name}:${server.address}`
-            }])
-        }
-    };
-
-    bot.sendMessage(chatId, 'Wähle einen Server zum Löschen aus:', keyboard);
-});
-
-bot.on('callback_query', (query) => {
-    const chatId = query.message.chat.id;
-    const [action, serverName, serverAddress] = query.data.split(':');
-
-    if (action === 'delete') {
-        userServerConfigurations[chatId] = (userServerConfigurations[chatId] || []).filter(server => !(server.name === serverName && server.address === serverAddress));
-
-        saveConfigurations(userServerConfigurations);
-
-        bot.answerCallbackQuery(query.id, `Server ${bannerEmoji}${serverName}${bannerEmoji} mit Adresse "${serverAddress}" wurde gelöscht.`);
-    } else if (action === 'details') {
-        showServerDetails(chatId, serverName, serverAddress);
-    }
-});
-
-bot.onText(/\/status/, async (msg) => {
-    const chatId = msg.chat.id;
-    const userServers = userServerConfigurations[chatId] || [];
-
-    if (userServers.length === 0) {
-        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
-        return;
-    }
-
-    let statusMessage = 'Server Status:\n';
-
-    for (const serverConfig of userServers) {
-        const serverName = serverConfig.name;
-        const serverAddress = serverConfig.address;
-
-        try {
-            const serverStatus = await checkServerStatus(serverAddress);
-
-            const statusIcon = serverStatus === 'Online' ? '✅' : serverStatus === 'Offline' ? '❌' : '⚠️';
-
-            statusMessage += `
-*Server:* ${bannerEmoji}${serverName}${bannerEmoji} ${statusIcon} ${serverStatus}
-`;
-        } catch (error) {
-            console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
-            statusMessage += `Fehler beim Überprüfen des Servers ${bannerEmoji}${serverName}${bannerEmoji}. ${errorIcon}\n`;
-        }
-    }
-
-    const options = {
-        parse_mode: 'Markdown',
-        reply_markup: {
-            inline_keyboard: [
-                [{
-                    text: 'Details',
-                    callback_data: 'details'
-                }]
-            ]
-        }
-    };
-
-    bot.sendMessage(chatId, statusMessage, options);
-});
-
-async function showServerDetails(chatId, serverName, serverAddress) {
-    const detailsMessage = `
-*Details für Server ${bannerEmoji}${serverName}${bannerEmoji}* 
-*Uptime:* ${await getUptime()}
-*CPU-Auslastung:* ${getCpuUsage()}%
-*RAM-Auslastung:* ${getRamUsage()}%
-*Netzwerk-Traffic:* ${getNetworkTraffic()}%
-*IP/Adresse:* ${serverAddress}
-`;
-
-    const options = {
-        parse_mode: 'Markdown',
-    };
-
-    bot.sendMessage(chatId, detailsMessage, options);
-}
-
-bot.on('callback_query', async (query) => {
-    const chatId = query.message.chat.id;
-    const [action, serverName, serverAddress] = query.data.split(':');
-
-    if (action === 'details') {
-        const userServers = userServerConfigurations[chatId] || [];
-
-        if (userServers.length === 0) {
-            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
-            return;
-        }
-
-        const keyboard = {
-            reply_markup: {
-                inline_keyboard: userServers.map(server => [{
-                    text: `${server.name}} - ${server.address}`,
-                    callback_data: `details:${server.name}:${server.address}`
-                }])
-            }
-        };
-
-        bot.sendMessage(chatId, 'Wähle einen Server für Details aus:', keyboard);
-    } else if (action === 'details') {
-        showServerDetails(chatId, serverName);
-    }
-});
-
-bot.onText(/\/help/, (msg) => {
-    const chatId = msg.chat.id;
-    const helpMessage = `
-    Verfügbare Befehle:
-    - /add_server: Fügt einen neuen Server hinzu.
-    - /delete_server: Löscht einen vorhandenen Server.
-    - /status: Zeigt den Status der konfigurierten Server an.
-    - /help: Zeigt diese Hilfe an.
-    `;
-    bot.sendMessage(chatId, helpMessage);
-});
-
-// Intervall für die Serverüberprüfung
-const checkIntervalMinutes = 2;
-const checkIntervalMilliseconds = checkIntervalMinutes * 60 * 1000;
-
-setInterval(async () => {
-    await checkAndSendServerStatus();
-}, checkIntervalMilliseconds);
-
-async function checkAndSendServerStatus() {
-    // Iteriere über alle gespeicherten Chat-IDs
-    for (const chatId of chatIds) {
-        const userServers = userServerConfigurations[chatId] || [];
-
-        if (userServers.length === 0) {
-            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
-            continue;
-        }
-
-        let statusMessage = 'Automatischer Statusbericht:\n';
-
-        for (const serverConfig of userServers) {
-            const serverName = serverConfig.name;
-            const serverAddress = serverConfig.address;
-
-            try {
-                const serverStatus = await checkServerStatus(serverAddress);
-
-                if (serverStatus === 'Offline') {
-                    const statusIcon = '❌';
-                    statusMessage += `
-*Server:* ${bannerEmoji}${serverName}${bannerEmoji} ${statusIcon} ${serverStatus}
-`;
-                }
-            } catch (error) {
-                console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
-                statusMessage += `Fehler beim Überprüfen des Servers ${bannerEmoji}${serverName}${bannerEmoji}. ⚠️\n`;
-            }
-        }
-
-        if (statusMessage.includes('❌')) {
-            const options = {
-                parse_mode: 'Markdown',
-            };
-
-            bot.sendMessage(chatId, statusMessage, options);
-        }
-    }
-}
+const TelegramBot = require('node-telegram-bot-api');
+const ping = require('ping');
+const os = require('os');
+const fs = require('fs');
+const yaml = require('js-yaml');
+require('dotenv').config();
+const serverNotificationState = {};
+const logDirectory = 'logs/';
+let usersAddingServer = {};
+let isShowingDetails = false;
+const botStartTime = new Date();
+
+
+const developerChatIds = process.env.DEVELOPER_CHAT_IDS.split(',');
+const token = process.env.TELEGRAM_BOT_TOKEN;
+const tgId = process.env.TG_ID;
+const bot = new TelegramBot(token, { polling: true });
+
+// Überprüfen, ob die TG_ID-Umgebungsvariable vorhanden ist
+if (!tgId) {
+    const errorMessage = 'Fehler: TG_ID-Umgebungsvariable nicht festgelegt. Der Bot wird nicht gestartet.';
+    console.error(errorMessage);
+    sendErrorNotification(developerChatIds[0], errorMessage);
+    process.exit(1);
+}
+
+// Überprüfen, ob die TG_ID sich geändert hat
+if (tgId !== '5507179337') {
+    const errorMessage = 'Fehler: Der Bot wird nicht gestartet.';
+    console.error(errorMessage);
+    sendErrorNotification(developerChatIds[0], errorMessage);
+    process.exit(1);
+}
+
+// Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
+function isDeveloperChat(chatId) {
+    return developerChatIds.includes(chatId.toString());
+}
+
+const activeUserIds = new Set();
+
+const monitoredServers = [];
+
+// Lese die Konfigurationsdatei
+try {
+    const configContent = fs.readFileSync('configurations.yml', 'utf8');
+    const config = yaml.load(configContent);
+
+    // Überprüfe, ob es eine Server-Konfiguration gibt
+    if (config) {
+        // Füge die überwachten Server zur Liste hinzu
+        Object.values(config).forEach(serverList => {
+            monitoredServers.push(...serverList);
+        });
+    }
+} catch (error) {
+    console.error('Fehler beim Lesen der Konfigurationsdatei:', error.message);
+}
+
+// Event-Handler für den Befehl /stats
+bot.onText(/\/stats/, (msg) => {
+    const chatId = msg.chat.id;
+
+    if (isDeveloperChat(chatId)) {
+        if (!activeUserIds.has(chatId)) {
+            activeUserIds.add(chatId);
+        }
+
+        try {
+            // Gesamtanzahl der überwachten Server
+            const serverCount = getServerCount(); // Funktion, die die Anzahl der überwachten Server zurückgibt
+
+            // Anzahl der Fehler im error.log
+            const errorCount = getErrorCount(); // Funktion, die die Anzahl der Fehler im error.log zurückgibt
+
+            // Bot Uptime in Stunden
+            const uptime = getBotUptime(); // Funktion, die die Bot-Uptime in Stunden zurückgibt
+
+            // Anzahl der Benutzer, die diesen Bot nutzen
+            const totalUserCount = getTotalUserCount();
+
+            // Version des Telegram Bot API-Pakets
+            const telegramBotApiVersion = getTelegramBotApiVersion();
+
+            // Nachricht mit den Statistiken senden
+            bot.sendMessage(chatId, `
+            Gesamtanzahl der überwachten Server: ${serverCount}
+            Anzahl der Fehler im error.log: ${errorCount}
+            Bot Uptime: ${uptime.days} Tage, ${uptime.hours} Stunden und ${uptime.minutes} Minuten
+            Anzahl der Benutzer: ${totalUserCount}
+            Telegram Bot API-Version: ${telegramBotApiVersion}
+            `);
+        } catch (error) {
+            console.error('Fehler beim Abrufen der Statistiken:', error.message);
+            bot.sendMessage(chatId, 'Fehler beim Abrufen der Statistiken. Bitte versuche es später erneut.');
+        }
+    } else {
+        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
+    }
+});
+
+// Funktion, um die Anzahl der überwachten Server zu erhalten
+function getServerCount() {
+    return monitoredServers.length;
+}
+
+// Funktion, um die Anzahl der Fehler im error.log zu erhalten
+function getErrorCount() {
+    try {
+        const errorLogContent = fs.readFileSync('error.log', 'utf8');
+        const errorLines = errorLogContent.split('\n');
+        return errorLines.length;
+    } catch (error) {
+        console.error('Fehler beim Lesen der error.log-Datei:', error.message);
+        return 'Fehler beim Lesen der Log-Datei';
+    }
+}
+
+// Funktion, um die Bot-Uptime in Tagen, Stunden und Minuten zu erhalten
+function getBotUptime() {
+    const uptimeMilliseconds = new Date() - botStartTime; // botStartTime sollte irgendwo definiert und beim Bot-Start festgelegt sein
+
+    // Berechne Tage, Stunden und Minuten
+    const days = Math.floor(uptimeMilliseconds / (1000 * 60 * 60 * 24));
+    const hours = Math.floor((uptimeMilliseconds % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+    const minutes = Math.floor((uptimeMilliseconds % (1000 * 60 * 60)) / (1000 * 60));
+
+    return { days, hours, minutes };
+}
+
+
+// Pfad zur user_information.yml
+const userInformationPath = 'user_information.yml';
+
+// Funktion, um die Gesamtanzahl der Benutzer-IDs in der user_information.yml zu erhalten
+function getTotalUserCount() {
+    try {
+        // Lese den Inhalt der Datei
+        const userInformationContent = fs.readFileSync(userInformationPath, 'utf8');
+
+        // Parsen des YAML-Inhalts
+        const userInformation = yaml.load(userInformationContent);
+
+        // Prüfe, ob die Benutzerinformation ein Objekt ist
+        if (typeof userInformation === 'object' && userInformation !== null) {
+            // Zähle die Gesamtanzahl der Benutzer-IDs
+            const totalUserCount = Object.keys(userInformation).length;
+            return `${totalUserCount}`;
+        } else {
+            console.error('Ungültiges Format der Benutzerinformation.');
+            return 'Fehler bei der Verarbeitung der Benutzerinformation';
+        }
+    } catch (error) {
+        console.error('Fehler beim Lesen der Benutzerinformation:', error.message);
+        return 'Fehler beim Lesen der Benutzerinformation';
+    }
+}
+
+// Beispielaufruf
+console.log(getTotalUserCount());
+
+            // Funktion, um die Version des Telegram Bot API-Pakets zu erhalten
+function getTelegramBotApiVersion() {
+    try {
+        // Lese den Inhalt der package.json-Datei
+        const packageJsonContent = fs.readFileSync('package.json', 'utf8');
+
+        // Parsen des JSON-Inhalts
+        const packageJson = JSON.parse(packageJsonContent);
+
+        // Gib die Version des Telegram Bot API-Pakets zurück
+        return packageJson.dependencies['node-telegram-bot-api'];
+    } catch (error) {
+        console.error('Fehler beim Lesen der package.json-Datei:', error.message);
+        return 'Fehler beim Lesen der package.json-Datei';
+    }
+}
+
+// Funktion zum Speichern von Benutzerinformationen
+function saveUserInformation(userId, username) {
+    try {
+        let userInformation = {};
+
+        if (fs.existsSync(userInformationPath)) {
+            const data = fs.readFileSync(userInformationPath, 'utf8');
+            userInformation = yaml.load(data) || {};
+        }
+
+        userInformation[`user${userId}`] = {
+            id: userId,
+            name: username
+        };
+
+        const yamlString = yaml.dump(userInformation);
+        fs.writeFileSync(userInformationPath, yamlString, 'utf8');
+    } catch (error) {
+        console.error('Fehler beim Speichern von Benutzerinformationen:', error.message);
+    }
+}
+
+// Funktion zum Initialisieren beim Start des Bots
+function initialize() {
+    // Stelle sicher, dass die Datei existiert oder erstelle sie
+    const userInformationPath = 'user_information.yml';
+
+    if (!fs.existsSync(userInformationPath)) {
+        fs.writeFileSync(userInformationPath, '', 'utf8');
+    }
+}
+
+// Rufe die Initialisierungsfunktion auf
+initialize();
+
+bot.onText(/\/user_id/, (msg) => {
+    const chatId = msg.chat.id;
+
+    // Überprüfen, ob der Benutzer Entwickler ist
+    if (!isDeveloperChat(chatId)) {
+        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
+        return;
+    }
+
+    try {
+        // Lade Benutzerinformationen aus der user_information.yml-Datei
+        const userInformation = loadUserInformation();
+
+        // Überprüfen, ob Benutzerinformationen vorhanden sind
+        if (Object.keys(userInformation).length === 0) {
+            bot.sendMessage(chatId, 'Keine Benutzerinformationen gefunden.');
+            return;
+        }
+
+        // Konvertiere Benutzerinformationen in eine Liste von Benutzernamen und IDs
+        const userList = Object.keys(userInformation).map(key => {
+            const user = userInformation[key];
+            return `${user.name} - ${user.id}`;
+        });
+
+        // Sende die Liste der Benutzerinformationen
+        bot.sendMessage(chatId, 'Benutzerinformationen:\n' + userList.join('\n'));
+    } catch (error) {
+        console.error('Fehler beim Abrufen von Benutzerinformationen:', error.message);
+        bot.sendMessage(chatId, 'Fehler beim Abrufen von Benutzerinformationen.');
+    }
+});
+
+function loadUserInformation() {
+    try {
+        const userInformationPath = './user_information.yml';
+        const data = fs.readFileSync(userInformationPath, 'utf8');
+        return yaml.load(data) || {};
+    } catch (error) {
+        console.error('Fehler beim Laden der Benutzerinformationen:', error.message);
+        return {};
+    }
+}
+
+// Event-Handler für das Hinzufügen und Entfernen von Benutzern
+bot.on('message', (msg) => {
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+
+    // Überprüfe, ob die Benutzer-ID bereits gespeichert wurde
+    if (!activeUserIds.has(chatId)) {
+        activeUserIds.add(chatId);
+
+        // Speichere Benutzerinformationen
+        saveUserInformation(userId.toString(), `@${msg.from.username}`);
+    }
+
+    if (!activeUserIds.has(chatId)) {
+        activeUserIds.add(chatId);
+    }
+});
+
+bot.on('polling_error', (error) => {
+    console.error(`Polling error: ${error.message}`);
+});
+
+function escapeMarkdown(text) {
+    
+    return text.replace(/[_*[\]()~`>#+-=|{}.!]/g, '\\$&');
+}
+
+function getBotInfo() {
+    const botInfo = {
+        name: 'Server Monitoring',
+        version: '1.0.0',
+        author: 'M_Viper',
+        license: 'MIT',
+    };
+    
+
+    const infoMessage = `
+Bot Information:
+- *Name:* ${escapeMarkdown(botInfo.name)}
+- *Version:* ${escapeMarkdown(botInfo.version)}
+- *Author:* ${escapeMarkdown(botInfo.author)}
+- *License:* ${escapeMarkdown(botInfo.license)}
+Bot wurde am 22.01.2024 erstellt.
+    `;
+
+    console.log(infoMessage);
+
+    return infoMessage;
+}
+
+bot.onText(/\/user_id (.+)/, (msg, match) => {
+    const chatId = msg.chat.id;
+
+    // Überprüfen, ob der Benutzer Entwickler ist
+    if (!isDeveloperChat(chatId)) {
+        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
+        return;
+    }
+
+    const targetUsername = match[1];
+
+    // Überprüfen, ob der Benutzer existiert
+    bot.getChat(targetUsername)
+        .then(user => {
+            const userId = user.id;
+            bot.sendMessage(chatId, `Die ID des Benutzers @${targetUsername} ist: ${userId}`);
+        })
+        .catch(error => {
+            bot.sendMessage(chatId, `Der Benutzer @${targetUsername} existiert nicht.`);
+        });
+});
+
+bot.onText(/\/user_delete (.+)/, (msg, match) => {
+    const chatId = msg.chat.id;
+
+    // Überprüfen, ob der Benutzer Entwickler ist
+    if (!isDeveloperChat(chatId)) {
+        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
+        return;
+    }
+
+    const targetUserId = match[1];
+
+    // Überprüfen, ob der Benutzer existiert und Server hinzugefügt hat
+    if (!targetUserId || !userServerConfigurations[targetUserId]) {
+        bot.sendMessage(chatId, `Der Benutzer mit ID ${targetUserId} existiert nicht oder hat keine Server hinzugefügt.`);
+        return;
+    }
+
+    // Lösche alle Server des Zielbenutzers
+    delete userServerConfigurations[targetUserId];
+    saveConfigurations(userServerConfigurations);
+
+    bot.sendMessage(chatId, `Alle Server des Benutzers mit ID ${targetUserId} wurden gelöscht.`);
+});
+
+bot.onText(/\/info/, (msg) => {
+    const chatId = msg.chat.id;
+    const infoMessage = getBotInfo();
+
+    const options = {
+        parse_mode: 'Markdown',
+    };
+
+    bot.sendMessage(chatId, infoMessage, options);
+});
+
+// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
+bot.on('polling_error', (error) => {
+    console.error(`Polling error: ${error.message}`);
+    sendErrorNotification(developerChatId, `Polling error: ${error.message}`);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled rejection:', reason);
+    sendErrorNotification(developerChatId, `Unhandled rejection: ${reason}`);
+});
+
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught exception:', error);
+    sendErrorNotification(developerChatId, `Uncaught exception: ${error}`);
+});
+
+// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
+bot.on('polling_error', (error) => {
+    console.error(`Polling error: ${error.message}`);
+    sendErrorNotification(developerChatId, `Polling error: ${error.message}`);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled rejection:', reason);
+    sendErrorNotification(developerChatId, `Unhandled rejection: ${reason}`);
+});
+
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught exception:', error);
+    sendErrorNotification(developerChatId, `Uncaught exception: ${error}`);
+});
+
+// Funktion zum Senden von Fehlerbenachrichtigungen und Erstellen des Fehlerprotokolls
+function sendErrorNotification(chatId, errorMessage) {
+    const errorNotification = `❗️ *Fehler im Bot:*\n\n\`\`\`${errorMessage}\`\`\``;
+
+    bot.sendMessage(chatId, errorNotification, { parse_mode: 'Markdown' });
+
+    // Fehlerprotokoll erstellen
+    const logFilePath = 'error.log';
+    const formattedDate = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
+    const logEntry = `[${formattedDate}] ${errorMessage}\n`;
+
+    fs.appendFile(logFilePath, logEntry, (err) => {
+        if (err) {
+            console.error(`Fehler beim Schreiben in das Fehlerprotokoll: ${err.message}`);
+        }
+    });
+}
+
+const errorLogPath = 'error.log';
+fs.openSync(errorLogPath, 'a');
+
+bot.onText(/\/error/, (msg) => {
+    const chatId = msg.chat.id;
+
+    // Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
+    if (!isDeveloperChat(chatId)) {
+        bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
+        return;
+    }
+
+    try {
+        const logFileName = 'error.log';
+        const logFilePath = logDirectory + logFileName;
+
+        if (fs.existsSync(logFilePath)) {
+            const logContent = fs.readFileSync(logFilePath, 'utf8');
+            const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);
+
+            if (logEntries.length > 0) {
+                const logMessage = `Die letzten 8 Fehlerprotokolle:\n\n${logEntries.join('\n')}`;
+                bot.sendMessage(chatId, logMessage);
+            } else {
+                bot.sendMessage(chatId, 'Keine Fehlerprotokolle vorhanden.');
+            }
+        } else {
+            bot.sendMessage(chatId, 'Kein Fehlerprotokoll vorhanden. Es wurden noch keine Fehler protokolliert.');
+        }
+    } catch (error) {
+        console.error(`Fehler beim Lesen des Fehlerprotokolls: ${error.message}`);
+        bot.sendMessage(chatId, 'Fehler beim Lesen des Fehlerprotokolls.');
+    }
+});
+
+
+function createLogEntry(action, serverName, serverAddress) {
+    const currentDate = new Date();
+    const formattedDate = currentDate.toISOString().replace(/T/, ' ').replace(/\..+/, '');
+
+    const logEntry = `[${formattedDate}] Action: ${action}, Server Name: ${serverName}, Server Address: ${serverAddress}\n`;
+
+    return logEntry;
+}
+
+function writeToLog(userId, logEntry) {
+    const logFileName = `user_${userId}_log.txt`;
+    const logFilePath = logDirectory + logFileName;
+
+    try {
+        if (!fs.existsSync(logDirectory)) {
+            fs.mkdirSync(logDirectory);
+        }
+
+        // Lese vorhandene Logeinträge
+        let existingLogEntries = [];
+        if (fs.existsSync(logFilePath)) {
+            const existingLogContent = fs.readFileSync(logFilePath, 'utf8');
+            existingLogEntries = existingLogContent.split('\n').filter(entry => entry.trim() !== '');
+        }
+
+        // Füge neuen Eintrag hinzu
+        existingLogEntries.push(logEntry);
+
+        // Entferne Einträge älter als 7 Tage
+        const currentTime = Date.now();
+        const sevenDaysAgo = currentTime - 7 * 24 * 60 * 60 * 1000;
+        existingLogEntries = existingLogEntries.filter(entry => {
+            const entryTimestamp = new Date(entry.split(']')[0].replace('[', '')).getTime();
+            return entryTimestamp >= sevenDaysAgo;
+        });
+
+        // Schreibe die neuen Logeinträge
+        fs.writeFileSync(logFilePath, existingLogEntries.join('\n'), 'utf8');
+    } catch (error) {
+        console.error(`Fehler beim Schreiben des Logs: ${error.message}`);
+    }
+}
+
+let userServerConfigurations = loadConfigurations();
+const chatIds = new Set();
+
+function loadConfigurations() {
+    try {
+        if (fs.existsSync('configurations.yml')) {
+            const data = fs.readFileSync('configurations.yml', 'utf8');
+            return yaml.load(data) || {};
+        } else {
+            saveConfigurations({});
+            return {};
+        }
+    } catch (error) {
+        console.error('Fehler beim Laden der Konfigurationen:', error.message);
+        return {};
+    }
+}
+
+function saveConfigurations(configurations) {
+    try {
+        const yamlString = yaml.dump(configurations);
+        fs.writeFileSync('configurations.yml', yamlString, 'utf8');
+    } catch (error) {
+        console.error('Fehler beim Speichern der Konfigurationen:', error.message);
+    }
+}
+
+function getCpuUsage() {
+    return Math.floor(Math.random() * 101);
+}
+
+function getRamUsage() {
+    return Math.floor(Math.random() * 101);
+}
+
+function getNetworkTraffic() {
+    return Math.floor(Math.random() * 101);
+}
+
+async function getUptime() {
+    const uptimeInSeconds = os.uptime();
+    const days = Math.floor(uptimeInSeconds / (24 * 3600));
+    const hours = Math.floor((uptimeInSeconds % (24 * 3600)) / 3600);
+    const minutes = Math.floor((uptimeInSeconds % 3600) / 60);
+    return `${days} Tage, ${hours} Stunden, ${minutes} Minuten`;
+}
+
+async function checkServerStatus(serverAddress) {
+    try {
+        const result = await ping.promise.probe(serverAddress);
+        return result.alive ? 'Online' : 'Offline';
+    } catch (error) {
+        console.error(`Fehler beim Überprüfen des Servers ${serverAddress}: ${error.message}`);
+        return 'Fehler';
+    }
+}
+
+const onlineIcon = '✅';
+const offlineIcon = '❌';
+const errorIcon = '⚠️';
+const bannerEmoji = '🚀';
+
+
+
+
+
+function sendStatusMessage(chatId, serverName, serverStatus) {
+    const statusIcon = serverStatus === 'Online' ? onlineIcon : offlineStatus === 'Offline' ? offlineIcon : errorIcon;
+
+    const statusMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}.`;
+
+    bot.sendMessage(chatId, statusMessage);
+}
+
+bot.onText(/\/uptime/, async (msg) => {
+    const chatId = msg.chat.id;
+    const uptime = await getUptime();
+    bot.sendMessage(chatId, `Bot Uptime: ${uptime}`);
+});
+
+bot.onText(/\/start/, (msg) => {
+    const chatId = msg.chat.id;
+
+    // Überprüfen, ob der Befehl /start_notifications verwendet wurde
+    if (!msg.text.includes('/start_notifications')) {
+        // Senden Sie die Nachricht nur, wenn der Befehl /start_notifications nicht verwendet wurde
+        bot.sendMessage(chatId, 'Bot gestartet. Benutze /add_server, /delete_server, /status und /help für die Serververwaltung.');
+    }
+
+    chatIds.add(chatId);
+});
+
+bot.onText(/\/start_notifications/, (msg) => {
+    const chatId = msg.chat.id;
+    startNotifications(chatId);
+});
+
+function startNotifications(chatId) {
+    const userServers = userServerConfigurations[chatId] || [];
+
+    if (userServers.length === 0) {
+        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+        return;
+    }
+
+    userServers.forEach(serverConfig => {
+        const serverAddress = serverConfig.address;
+        serverNotificationState[serverAddress] = true;
+    });
+
+    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden aktiviert.');
+}
+
+bot.onText(/\/stop_notifications/, (msg) => {
+    const chatId = msg.chat.id;
+    stopNotifications(chatId);
+});
+
+function stopNotifications(chatId) {
+    const userServers = userServerConfigurations[chatId] || [];
+
+    if (userServers.length === 0) {
+        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+        return;
+    }
+
+    userServers.forEach(serverConfig => {
+        const serverAddress = serverConfig.address;
+        serverNotificationState[serverAddress] = false;
+    });
+
+    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
+}
+
+bot.onText(/\/status/, async (msg) => {
+    const chatId = msg.chat.id;
+    const userServers = userServerConfigurations[chatId] || [];
+
+    if (userServers.length === 0) {
+        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+        return;
+    }
+
+    let statusMessage = 'Server Status:\n';
+
+    for (const serverConfig of userServers) {
+        const serverName = serverConfig.name;
+        const serverAddress = serverConfig.address;
+
+        try {
+            const serverStatus = await checkServerStatus(serverAddress);
+
+            const statusIcon = serverStatus === 'Online' ? '✅' : serverStatus === 'Offline' ? '❌' : '⚠️';
+            const notificationEnabled = serverNotificationState[serverAddress];
+
+            statusMessage += `
+*Server:* ${bannerEmoji}${serverName}${bannerEmoji} ${statusIcon} ${serverStatus}
+*Benachrichtigungen:* ${notificationEnabled ? 'Aktiviert' : 'Deaktiviert'}
+\n`;
+        } catch (error) {
+            console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
+            statusMessage += `Fehler beim Überprüfen des Servers ${bannerEmoji}${serverName}${bannerEmoji}. ${errorIcon}\n`;
+        }
+    }
+
+    // Füge hier den Benachrichtigungsstatus direkt unterhalb der Serverliste hinzu
+    const notificationStatusMessage = 'Benachrichtigungen für alle Server sind ' +
+        (Object.values(serverNotificationState).every((status) => status) ? 'aktiviert.' : 'deaktiviert.');
+
+    statusMessage += `\n${notificationStatusMessage}`;
+
+    const options = {
+        parse_mode: 'Markdown',
+        reply_markup: {
+            inline_keyboard: [
+                [{
+                    text: 'Details',
+                    callback_data: 'details'
+                }]
+            ]
+        }
+    };
+
+    bot.sendMessage(chatId, statusMessage, options);
+});
+
+bot.onText(/\/add_server/, (msg) => {
+    const chatId = msg.chat.id;
+
+    bot.sendMessage(chatId, 'Füge einen neuen Server hinzu. Sende mir zuerst den Namen des Servers:');
+
+    // Verwendung der Variable usersAddingServer
+    usersAddingServer[chatId] = { name: null, address: null };
+
+    bot.once('text', (serverNameMsg) => {
+        usersAddingServer[chatId].name = serverNameMsg.text;
+
+        bot.sendMessage(chatId, `Servername ${bannerEmoji}${serverNameMsg.text}${bannerEmoji} wurde hinzugefügt. Jetzt sende mir die IP-Adresse des Servers:`);
+
+        bot.once('text', (serverAddressMsg) => {
+            usersAddingServer[chatId].address = serverAddressMsg.text;
+
+            userServerConfigurations[chatId] = userServerConfigurations[chatId] || [];
+            userServerConfigurations[chatId].push(usersAddingServer[chatId]);
+
+            saveConfigurations(userServerConfigurations);
+
+            const logEntry = createLogEntry('Add Server', usersAddingServer[chatId].name, usersAddingServer[chatId].address);
+            writeToLog(chatId, logEntry);
+
+            bot.sendMessage(chatId, `Server ${bannerEmoji}${usersAddingServer[chatId].name}${bannerEmoji} mit Adresse "${usersAddingServer[chatId].address}" wurde hinzugefügt.`);
+        });
+    });
+});
+
+bot.onText(/\/delete_server/, (msg) => {
+    const chatId = msg.chat.id;
+    const userServers = userServerConfigurations[chatId] || [];
+
+    if (userServers.length === 0) {
+        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+        return;
+    }
+
+    const keyboard = {
+        reply_markup: {
+            inline_keyboard: userServers.map(server => [{
+                text: `${server.name} - ${server.address}`,
+                callback_data: `delete:${server.name}:${server.address}`
+            }])
+        }
+    };
+
+    bot.sendMessage(chatId, 'Wähle einen Server zum Löschen aus:', keyboard);
+});
+
+bot.on('callback_query', (query) => {
+    const chatId = query.message.chat.id;
+    const [action, serverName, serverAddress] = query.data.split(':');
+
+    if (action === 'delete') {
+        userServerConfigurations[chatId] = (userServerConfigurations[chatId] || []).filter(server => !(server.name === serverName && server.address === serverAddress));
+
+        saveConfigurations(userServerConfigurations);
+
+        const logEntry = createLogEntry('Delete Server', serverName, serverAddress);
+        writeToLog(chatId, logEntry);
+
+        bot.answerCallbackQuery({ callback_query_id: query.id, text: `Server ${bannerEmoji}${serverName}${bannerEmoji} mit Adresse "${serverAddress}" wurde gelöscht.` });
+    } else if (action === 'stop_notifications') {
+        if (serverAddress) {
+            serverNotificationState[serverAddress] = false;
+
+            const logEntry = createLogEntry('Stop Notifications', '', serverAddress);
+            writeToLog(chatId, logEntry);
+
+            bot.answerCallbackQuery({ callback_query_id: query.id, text: `Benachrichtigungen für Server mit Adresse "${serverAddress}" gestoppt.` });
+        } else {
+            console.error('Ungültige Anfrage: serverAddress ist undefined.');
+            bot.answerCallbackQuery({ callback_query_id: query.id, text: 'Fehler: Server-Adresse ist undefiniert.' });
+        }
+    } else if (action === 'details_server') {
+        showServerDetails(chatId, serverName, serverAddress);
+    }
+});
+
+bot.onText(/\/log/, (msg) => {
+    const chatId = msg.chat.id;
+
+    try {
+        const logFileName = `user_${chatId}_log.txt`;
+        const logFilePath = logDirectory + logFileName;
+
+        if (fs.existsSync(logFilePath)) {
+            const logContent = fs.readFileSync(logFilePath, 'utf8');
+            const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);
+
+            if (logEntries.length > 0) {
+                const logMessage = `Die letzten 8 Logeinträge:\n\n${logEntries.join('\n')}`;
+                bot.sendMessage(chatId, logMessage);
+            } else {
+                bot.sendMessage(chatId, 'Keine Logeinträge vorhanden.');
+            }
+        } else {
+            bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
+        }
+    } catch (error) {
+        console.error(`Fehler beim Lesen des Logs: ${error.message}`);
+        bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
+    }
+});
+
+bot.onText(/\/save_log/, (msg) => {
+    console.log('In /save_log');
+    const chatId = msg.chat.id;
+
+    try {
+        const logFileName = `user_${chatId}_log.txt`;
+        const logFilePath = logDirectory + logFileName;
+
+        if (fs.existsSync(logFilePath)) {
+            // Hier direkt den Dateipfad zur Logdatei verwenden
+            bot.sendDocument(chatId, logFilePath, { caption: 'Hier ist Ihre Logdatei.' });
+        } else {
+            bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
+        }
+    } catch (error) {
+        console.error(`Fehler beim Lesen des Logs: ${error.message}`);
+        bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
+    }
+});
+
+function sendStatusNotification(chatId, serverName, serverStatus, serverAddress) {
+    const statusIcon = serverStatus === 'Online' ? onlineIcon : serverStatus === 'Offline' ? offlineIcon : errorIcon;
+
+    const inlineKeyboard = [[
+        {
+            text: 'Details anzeigen',
+            callback_data: `details_server:${serverName}:${serverAddress}`
+        },
+        
+    ]];
+
+    const options = {
+        parse_mode: 'Markdown',
+        reply_markup: {
+            inline_keyboard: inlineKeyboard
+        }
+    };
+
+    const notificationMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}. Benachrichtigungen aktiviert.`;
+
+    bot.sendMessage(chatId, notificationMessage, options);
+}
+
+function stopNotifications(chatId) {
+    const userServers = userServerConfigurations[chatId] || [];
+
+    if (userServers.length === 0) {
+        bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+        return;
+    }
+
+    userServers.forEach(serverConfig => {
+        const serverAddress = serverConfig.address;
+        serverNotificationState[serverAddress] = false;
+    });
+
+    bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
+}
+
+async function showServerDetails(chatId, serverName, serverAddress) {
+    console.log(`showServerDetails called for ${serverName}`);
+
+    if (isShowingDetails) {
+        console.log('Details are already being shown.');
+        return;
+    }
+
+    isShowingDetails = true;
+
+    try {
+        const detailsMessage = `
+*Details für Server ${bannerEmoji}${serverName}${bannerEmoji}* 
+*Uptime:* ${await getUptime()}
+*CPU-Auslastung:* ${getCpuUsage()}%
+*RAM-Auslastung:* ${getRamUsage()}%
+*Netzwerk-Traffic:* ${getNetworkTraffic()}%
+*IP/Adresse:* ${serverAddress}
+`;
+
+        const options = {
+            parse_mode: 'Markdown',
+        };
+
+        await bot.sendMessage(chatId, detailsMessage, options);
+    } catch (error) {
+        console.error(`Fehler beim Anzeigen der Serverdetails: ${error.message}`);
+        await bot.sendMessage(chatId, 'Fehler beim Anzeigen der Serverdetails.');
+    } finally {
+        isShowingDetails = false;
+    }
+}
+
+bot.on('callback_query', async (query) => {
+    const chatId = query.message.chat.id;
+    const [action, ...params] = query.data.split(':');
+
+    if (action === 'details_server') {
+        showServerDetails(chatId, ...params);
+    } else {
+        const userServers = userServerConfigurations[chatId] || [];
+
+        if (userServers.length === 0) {
+            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+            return;
+        }
+
+        const keyboard = {
+            reply_markup: {
+                inline_keyboard: userServers.map(server => [{
+                    text: `${server.name} - ${server.address}`,
+                    callback_data: `details_server:${server.name}:${server.address}`
+                }])
+            }
+        };
+
+        bot.sendMessage(chatId, 'Wähle einen Server für Details aus:', keyboard);
+    }
+});
+
+
+
+bot.onText(/\/help/, (msg) => {
+    const chatId = msg.chat.id;
+
+    let helpMessage = `
+    Verfügbare Befehle:
+- /add_server: Fügt einen neuen Server hinzu.
+- /delete_server: Löscht einen vorhandenen Server.
+- /status: Zeigt den Status der konfigurierten Server an.
+- /start_notifications: Startet Benachrichtigungen für alle Server.
+- /stop_notifications: Stoppt Benachrichtigungen für alle Server.
+- /log: Zeigt die letzten 8 Logeinträge.
+- /save_log: Speichert und sendet die letzten 8 Logeinträge als Datei.
+- /uptime: Zeigt die aktuelle Betriebszeit des Bots an.
+- /info: Zeigt Informationen über den Bot an.
+`;
+
+if (isDeveloperChat(chatId)) {
+    helpMessage += '\n\n*Entwickler Befehle:*\n' +
+                   '- /error: Zeigt den error Log an\n' +
+                   '- /stats: Zeigt an, wie viele Personen den Bot nutzen\n' +
+                   '- /user_id Zeigt eine Liste von Usern an die den Bot nutzen\n' +
+                   `- /user_delete "ID" löscht alle Server des Benutzer`;
+}
+
+    bot.sendMessage(chatId, helpMessage);
+});
+
+const checkIntervalMinutes = 2;
+const checkIntervalMilliseconds = checkIntervalMinutes * 60 * 1000;
+
+const offlineNotificationIntervalMinutes = 360; // Ändern Sie nach Bedarf
+const offlineNotificationIntervalMilliseconds = offlineNotificationIntervalMinutes * 60 * 1000;
+
+const lastOfflineNotificationTime = new Map();
+
+setInterval(async () => {
+    await checkAndSendServerStatus();
+}, checkIntervalMilliseconds);
+
+async function checkAndSendServerStatus() {
+    for (const chatId of chatIds) {
+        const userServers = userServerConfigurations[chatId] || [];
+
+        if (userServers.length === 0) {
+            bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
+            continue;
+        }
+
+        for (const serverConfig of userServers) {
+            const serverName = serverConfig.name;
+            const serverAddress = serverConfig.address;
+
+            try {
+                const serverStatus = await checkServerStatus(serverAddress);
+                const offlineStatus = serverStatus === 'Offline';
+
+                if (offlineStatus) {
+                    const statusIcon = '❌';
+                    const notificationEnabled = serverNotificationState[serverAddress];
+
+                    if (notificationEnabled) {
+                        const lastNotificationTime = lastOfflineNotificationTime.get(serverAddress) || 0;
+                        const currentTime = Date.now();
+
+                        // Überprüfen, ob die Benachrichtigung bereits innerhalb des Intervalls gesendet wurde
+                        if (currentTime - lastNotificationTime >= offlineNotificationIntervalMilliseconds) {
+                            console.log(`Benachrichtigung wird gesendet für Server: ${serverName}`);
+                            const inlineKeyboard = [];
+
+                            
+
+                            const options = {
+                                parse_mode: 'Markdown',
+                                reply_markup: {
+                                    inline_keyboard: inlineKeyboard
+                                }
+                            };
+
+                            sendStatusNotification(chatId, serverName, serverStatus, serverAddress);
+                            lastOfflineNotificationTime.set(serverAddress, currentTime);
+                        } else {
+                            console.log(`Offline-Benachrichtigung für Server "${serverName}" wird aufgrund des Zeitintervalls übersprungen.`);
+                        }
+                    } else {
+                        console.log(`Benachrichtigungen für Server "${serverName}" sind deaktiviert.`);
+                    }
+                }
+            } catch (error) {
+                console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
+            }
+        }
+    }
+}