Add Twitch identity auth and token validation to TwitchMonitor

- Added purge subcommands to admin command list
- Documented purge implementation details in AGENTS-BOT.md
- Listed Discord API constraints (100 message limit, 14 day filter)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.env.example

@@ -2,3 +2,6 @@ DISCORD_TOKEN=dein_bot_token
 CLIENT_ID=deine_client_id
 TWITCH_CLIENT_ID=deine_twitch_id
 TWITCH_CLIENT_SECRET=dein_twitch_secret
+TWITCH_USERNAME=dein_twitch_username
+TWITCH_OAUTH_TOKEN=oauth:xxxxxxxxxxxxxxxxxx
+BOT_OWNER_ID=deine_discord_user_id

.gitattributes

@@ -0,0 +1,7 @@
+* text=auto
+*.ts text eol=lf
+*.js text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf

AGENTS-BOT.md

@@ -12,9 +12,13 @@ The bot uses a **Modular Command & Event Loading** pattern with **ESM (ECMAScrip
 3. **Interface-Driven Commands:** All commands implement `Command` interface.
 4. **SQLite Database:** Persistent data storage with `better-sqlite3`.
 5. **Twitch Monitoring:** Periodic API polling with Stream ID tracking.
-6. **Reminder System:** Periodic reminder checking with target_time tracking.
+6. **TwitchMonitor IRC:** TMI.js-based IRC chat monitoring for mod events.
-7. **Auto-Response System:** Trigger word detection for automatic replies.
+7. **Reminder System:** Periodic reminder checking with target_time tracking.
-8. **Grouped Commands:** Admin/Owner/Trigger/Timer commands grouped under subcommands.
+8. **Auto-Response System:** Trigger word detection for automatic replies.
+9. **Welcome/Goodbye System:** Guild member add/remove events with customizable messages.
+10. **Logging System:** Configurable event logging (messages, roles, moderation, etc.).
+11. **Role Selection System:** Self-service role assignment via select menus.
+12. **Grouped Commands:** Admin/Owner/Trigger/Timer commands grouped under subcommands.
 
 ## 📁 Project Structure
 
@@ -28,18 +32,32 @@ pixelpoebel/
 │   │       ├── ping.ts
 │   │       ├── help.ts
 │   │       ├── twitch.ts
+│   │       ├── twitchmonitor.ts  # Twitch IRC chat monitoring
+│   │       ├── rolesetup.ts  # Self-service role selection
 │   │       ├── trigger.ts    # Auto-responses
-│   │       ├── timer.ts      # Reminders
+│   │       ├── timer.ts     # Reminders
-│   │       ├── admin.ts      # All admin subcommands
+│   │       ├── welcome.ts    # Welcome/Goodbye messages
-│   │       └── owner.ts      # All owner subcommands
+│   │       ├── log.ts       # Event logging
+│   │       ├── admin.ts     # All admin subcommands
+│   │       └── owner.ts     # All owner subcommands
 │   ├── events/
 │   │   ├── ready.ts
-│   │   └── interactionCreate.ts
+│   │   ├── interactionCreate.ts
+│   │   ├── messageCreate.ts         # Auto-response triggers
+│   │   ├── messageDelete.ts         # Deleted messages
+│   │   ├── messageUpdate.ts         # Edited messages
+│   │   ├── guildMemberAdd.ts        # Welcome messages
+│   │   ├── guildMemberRemove.ts     # Goodbye messages
+│   │   ├── guildMemberUpdate.ts     # Nickname/role changes
+│   │   ├── channelCreate.ts        # Channel create
+│   │   └── channelDelete.ts         # Channel delete
 │   └── structures/
 │       ├── ExtendedClient.ts
 │       ├── Command.ts
 │       ├── Database.ts
 │       ├── TwitchManager.ts
+│       ├── TwitchMonitor.ts
+│       ├── TwitchCache.ts
 │       ├── ReminderManager.ts
 │       └── Deployer.ts
 ├── data/                     # SQLite database (volume mounted)
@@ -47,7 +65,8 @@ pixelpoebel/
 ├── tsconfig.json
 ├── Dockerfile
 ├── docker-compose.yml
-└── .env.example
+├── .env.example
+└── .gitattributes
 ```
 
 ## 📝 Implementation Steps
@@ -88,6 +107,10 @@ CREATE TABLE guild_settings (
     prefix TEXT DEFAULT '!',
     mod_log_channel TEXT,
     welcome_channel TEXT,
+    welcome_message TEXT,
+    goodbye_message TEXT,
+    log_channel TEXT,
+    log_events TEXT DEFAULT 'messages,roles,nicks,channels,warns,mutes,kicks,bans',
     warn_threshold INTEGER DEFAULT 3,
     warn_action TEXT DEFAULT 'ban',
     warn_mute_duration INTEGER DEFAULT 1800
@@ -117,7 +140,7 @@ CREATE TABLE dm_users (
     last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
--- twitch_monitors
+-- twitch_monitors (Stream notifications)
 CREATE TABLE twitch_monitors (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     guild_id TEXT,
@@ -129,6 +152,16 @@ CREATE TABLE twitch_monitors (
     UNIQUE(guild_id, channel_name)
 );
 
+-- twitch_monitor_channels (IRC chat logging)
+CREATE TABLE twitch_monitor_channels (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    guild_id TEXT NOT NULL,
+    twitch_channel TEXT NOT NULL,
+    discord_channel_id TEXT NOT NULL,
+    webhook_url TEXT,
+    UNIQUE(guild_id, twitch_channel)
+);
+
 -- auto_responses
 CREATE TABLE auto_responses (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -148,6 +181,30 @@ CREATE TABLE reminders (
     target_time DATETIME,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
+
+-- role_categories
+CREATE TABLE role_categories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    guild_id TEXT NOT NULL,
+    channel_id TEXT NOT NULL,
+    message_id TEXT NOT NULL,
+    category_name TEXT NOT NULL,
+    max_roles INTEGER DEFAULT 0,
+    exclusive BOOLEAN DEFAULT 0,
+    remove_on_delete BOOLEAN DEFAULT 0,
+    UNIQUE(guild_id, category_name)
+);
+
+-- role_options
+CREATE TABLE role_options (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    category_id INTEGER NOT NULL,
+    label TEXT NOT NULL,
+    emoji TEXT,
+    role_id TEXT NOT NULL,
+    UNIQUE(category_id, role_id),
+    FOREIGN KEY (category_id) REFERENCES role_categories(id) ON DELETE CASCADE
+);
 ```
 
 ### 3. Key Components
@@ -227,8 +284,65 @@ export class ReminderManager {
 }
 ```
 
-### 5. Auto-Response (Trigger) System
+### 5. Welcome/Goodbye System
 
+**Variables in messages:** `{user}`, `{username}`, `{server}`, `{membercount}`
+
+**Auto-use Discord system channel if no custom channel set:**
+```typescript
+const channelId = settings?.welcome_channel || member.guild.systemChannelId;
+```
+
+### 6. Logging System
+
+**Events that can be logged:**
+- `messages` - Deleted and edited messages
+- `roles` - Role changes
+- `nicks` - Nickname changes
+- `channels` - Channel create/delete
+- `warns` - User warnings
+- `mutes` - User mutes
+- `kicks` - User kicks
+- `bans` - User bans
+
+**Log moderation action:**
+```typescript
+async function sendModerationLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    await (channel as any).send({ embeds: [embed] });
+}
+```
+
+### 7. Auto-Response (Trigger) System
+
+**Event Handler (`messageCreate.ts`):**
+```typescript
+// Listens for messages and checks against auto_responses
+// Ignores bots and DM messages
+const triggers = DB.all('SELECT * FROM auto_responses WHERE guild_id = ?', guildId);
+const contentLower = message.content.toLowerCase();
+
+for (const trigger of triggers) {
+    if (contentLower.includes(trigger.trigger_word.toLowerCase())) {
+        await message.channel.send(trigger.response_text);
+        return;
+    }
+}
+```
+
+**Command (`trigger.ts`):**
 ```typescript
 // Add trigger (admin only)
 DB.run('INSERT INTO auto_responses (guild_id, trigger_word, response_text) VALUES (?, ?, ?)',
@@ -241,7 +355,7 @@ DB.all('SELECT * FROM auto_responses WHERE guild_id = ? ORDER BY trigger_word AS
 DB.run('DELETE FROM auto_responses WHERE guild_id = ? AND trigger_word = ?', guildId, triggerWord);
 ```
 
-### 6. Twitch Monitoring with Stream ID
+### 8. Twitch Monitoring with Stream ID
 
 ```typescript
 // Stream ID tracking prevents duplicate notifications
@@ -255,12 +369,61 @@ if (wasOffline || (monitor.last_status === 'online' && isNewStream)) {
 }
 ```
 
-### 7. Configurable Warn System
+### 9. TwitchMonitor IRC Chat Logging
 
-**Database Schema:**
+**Overview:** Uses TMI.js to connect to Twitch IRC as a "lurker" (read-only) and logs moderation events to Discord via webhooks.
-- `warn_threshold`: Number of warns before action
+
-- `warn_action`: 'none', 'kick', 'mute', 'ban'
+**Architecture:**
-- `warn_mute_duration`: Duration in seconds for mute
+```typescript
+// Singleton pattern for IRC connection
+class TwitchMonitor {
+    private static instance: TwitchMonitor | null = null;
+    private client: tmi.Client;
+    private cache: TwitchCache;  // In-memory FIFO ring buffer (default: 1000 messages)
+    private monitors: Map<string, MonitorChannel>;
+}
+```
+
+**TwitchCache (In-Memory Ring Buffer):**
+```typescript
+interface ChatMessage {
+    channel: string;  // twitch channel
+    user: string;
+    text: string;
+    timestamp: number;
+    msgId: string;
+}
+
+class TwitchCache {
+    private buffer: ChatMessage[] = [];
+    private maxSize: number = 1000;
+
+    push(msg: ChatMessage): void { /* FIFO - shift oldest when full */ }
+    getLastN(user: string, channel: string, n: number): ChatMessage[] { /* for ban context */ }
+    getByMsgId(msgId: string): ChatMessage | undefined { /* for delete restore */ }
+}
+```
+
+**Events Logged:**
+| Event | Discord Embed |
+|-------|--------------|
+| `ban` | 🔨 Ban - mit letzten 5 Nachrichten als Kontext |
+| `timeout` | ⏱️ Timeout |
+| `messagedeleted` | 🗑️ Delete - ~~text~~ (aus Cache wiederhergestellt) |
+| `cheer` | 💰 Bits |
+| `subscription` | 🅿️ Sub |
+
+**Mod-Icon:** `https://static-cdn.jtvnw.net/jtv_user_pictures/a736384e-8a1d-40ed-8a7a-808a23a15476-profile_image-300x300.png`
+
+**Commands:**
+```typescript
+/twitchmonitor add <twitch_channel> <discord_channel>  // Admin
+/twitchmonitor remove <twitch_channel>                  // Admin
+/twitchmonitor list                                     // Public
+/twitchmonitor help                                     // Public
+```
+
+### 10. Configurable Warn System
 
 **Auto-Action Logic:**
 ```typescript
@@ -275,7 +438,7 @@ if (warnCount >= warnThreshold) {
 }
 ```
 
-### 8. Mute with Multiple Time Units
+### 10. Mute with Multiple Time Units
 
 ```typescript
 const unitSeconds: Record<string, number> = {
@@ -295,6 +458,65 @@ if (unit === 'perm') {
 }
 ```
 
+### 11. Purge Command (Message Deletion)
+
+**Subcommands:**
+- `purge amount <1-100>` - Delete X messages
+- `purge time <duration> <min|hour>` - Delete messages from last X time
+- `purge user <user> <1-100>` - Delete X messages from specific user
+- `purge all` - Delete all possible messages (max 100)
+
+**Discord API Constraints:**
+- Max 100 messages per bulk delete
+- Messages older than 14 days cannot be bulk deleted
+- Requires `ModerateMembers` permission
+
+```typescript
+// Filter messages older than 14 days (Discord API limit)
+const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+const filtered = messages.filter((m: any) => m.createdTimestamp > twoWeeksAgo);
+
+await channel.bulkDelete(filtered, true);
+```
+
+**Logging:** Purge actions are logged to the moderation log channel with event type `messages`.
+
+### 12. Role Selection System
+
+**Overview:** Self-service role assignment via Discord Select Menus. Users can choose roles from a dropdown message without needing admin intervention.
+
+**Admin Commands:**
+```typescript
+/rolesetup create <#channel> <category_name>  // Create new role selection message
+/rolesetup add <kategorie> <@rolle> [emoji]  // Add role option
+/rolesetup edit <kategorie> <@rolle> [new_emoji]  // Change emoji
+/rolesetup remove <kategorie> <@rolle>  // Remove role option
+/rolesetup delete <kategorie>  // Delete entire category
+/rolesetup config <kategorie> max:1 exclusive:true  // Configure settings
+/rolesetup list  // Show all configurations
+```
+
+**Config Options:**
+| Option | Default | Description |
+|--------|---------|-------------|
+| `max_roles` | 0 (unlimited) | Maximum roles a user can select from this category |
+| `exclusive` | false | If true, selecting a role removes other roles in this category |
+| `remove_on_delete` | false | Remove role from users when option is deleted |
+
+**User Interaction:**
+- User clicks on Select Menu dropdown
+- Role is added/removed based on config
+- Ephemeral confirmation message appears (auto-hides after 60s)
+
+**Database Schema:**
+- `role_categories`: Stores category settings (channel, message_id, config)
+- `role_options`: Stores individual role options with labels and emojis
+- CASCADE DELETE removes options when category is deleted
+
+**Role Validation:**
+- On bot startup, validates that all stored role IDs still exist in Discord
+- Missing roles are removed from database (and optionally from users)
+
 ## 🚀 Build & Deploy
 
 ```bash
@@ -319,6 +541,7 @@ docker-compose up -d --build
 4. **Twitch API:** Max 100 channels per request, batch properly.
 5. **Deploy:** Commands NOT auto-registered on start – use `/owner deploy`.
 6. **Ephemeral Replies:** Use `flags: [MessageFlags.Ephemeral]` instead of deprecated `ephemeral: true`.
+7. **Line Endings:** Use `.gitattributes` to ensure LF line endings for consistency.
 
 ## 📋 Command Summary
 
@@ -326,8 +549,12 @@ docker-compose up -d --build
 |---------|-------------|------------|
 | `/ping` | – | Public |
 | `/help` | – | Public |
-| `/twitch` | online, add, remove, list, help | Public/Admin |
+| `/twitch` | online, add, remove, list, listall, help | Public/Admin |
+| `/twitchmonitor` | add, remove, list, help | Admin |
+| `/rolesetup` | create, add, edit, remove, delete, config, list | Admin |
 | `/trigger` | add, remove, list, help | Public/Admin |
 | `/timer` | add, remove, list, listall, help | Public/Admin |
-| `/admin` | kick, warn, unwarn, mute, unmute, ban, unban, config, help | Admin |
+| `/welcome` | setchannel, add, remove, list, help | Admin |
+| `/log` | setchannel, enable, disable, list, help | Admin |
+| `/admin` | kick, warn, unwarn, mute, unmute, ban, unban, purge, config, help | Admin |
 | `/owner` | deploy, stats, servers, help | Owner |

README.md

@@ -16,8 +16,18 @@ DISCORD_TOKEN=dein_bot_token
 CLIENT_ID=deine_client_id
 TWITCH_CLIENT_ID=deine_twitch_id
 TWITCH_CLIENT_SECRET=dein_twitch_secret
+TWITCH_USERNAME=dein_twitch_username
+TWITCH_OAUTH_TOKEN=oauth:xxxxxxxxxxxxxxxxxx
+BOT_OWNER_ID=deine_discord_user_id
 ```
 
+### TwitchMonitor Setup
+1. **Twitch OAuth Token holen:** https://chatterino.com/client_login
+2. **Username:** Dein Twitch Username
+3. **Bot Owner ID:** Deine Discord User ID (für Fehlerbenachrichtigungen)
+
+> ⚠️ **Hinweis:** Der Twitch OAuth Token kann ungültig werden. In diesem Fall wirst du automatisch per Discord DM benachrichtigt.
+
 ## 🚀 Start
 
 ```bash
@@ -59,10 +69,8 @@ npm run deploy
 - `/twitch online <channel>` – Twitch-Status
 - `/twitch list` – Überwachte Kanäle
 - `/twitch help` – Twitch-Hilfe
-
+- `/timer list` – Timer dieses Kanals
-### Trigger (Auto-Antworten)
+- `/timer help` – Timer-Hilfe
-- `/trigger add <wort> <antwort>` – Trigger hinzufügen (Mod)
-- `/trigger remove <wort>` – Trigger entfernen (Mod)
 - `/trigger list` – Alle Trigger anzeigen
 - `/trigger help` – Trigger-Hilfe
 
@@ -73,9 +81,36 @@ npm run deploy
 - `/timer listall` – Alle Timer (Mod)
 - `/timer help` – Timer-Hilfe
 
+### Trigger (Auto-Antworten)
+- `/trigger add <wort> <antwort>` – Trigger hinzufügen (Mod)
+- `/trigger remove <wort>` – Trigger entfernen (Mod)
+- `/trigger list` – Alle Trigger anzeigen
+- `/trigger help` – Trigger-Hilfe
+
+### Twitch
+- `/twitch online <kanal>` – Prüft ob Kanal online ist
+- `/twitch add <streamer1, streamer2, ...>` – Streamer überwachen (Mod)
+- `/twitch remove <streamer1, streamer2, ...>` – Streamer entfernen (Mod)
+- `/twitch list` – Überwachte Kanäle
+- `/twitch listall` – Alle überwachten Streamer (Mod)
+- `/twitch help` – Twitch-Hilfe
+
+### TwitchMonitor (IRC Chat Logging)
+- `/twitchmonitor add <twitch> <discord>` – Twitch-Kanal zum IRC-Monitoring hinzufügen (Mod)
+- `/twitchmonitor remove <twitch>` – Kanal vom Monitoring entfernen (Mod)
+- `/twitchmonitor list` – Alle überwachten Twitch-Kanäle
+- `/twitchmonitor help` – Hilfe anzeigen
+
+### Rollen-Auswahl
+- `/rolesetup create <#kanal> <name>` – Rollen-Auswahl Message erstellen
+- `/rolesetup add <kategorie> <@rolle> [emoji]` – Rolle zur Auswahl hinzufügen
+- `/rolesetup edit <kategorie> <rolle> [neues_emoji]` – Emoji ändern
+- `/rolesetup remove <kategorie> <rolle>` – Rolle entfernen
+- `/rolesetup delete <kategorie>` – Kategorie löschen
+- `/rolesetup config <kategorie> max:1 exclusive:true` – Einstellungen
+- `/rolesetup list` – Alle Kategorien anzeigen
+
 ### Admin
-- `/twitch add <channel>` – Kanal überwachen
-- `/twitch remove <channel>` – Kanal entfernen
 - `/admin kick <user>` – Nutzer kicken
 - `/admin warn <user> <reason>` – Nutzer verwarnen
 - `/admin unwarn <user>` – Letzte Warnung entfernen
@@ -83,6 +118,10 @@ npm run deploy
 - `/admin unmute <user>` – Nutzer entmuten
 - `/admin ban <user>` – Nutzer bannen
 - `/admin unban <id>` – Nutzer entbannen
+- `/admin purge amount <1-100>` – X Nachrichten löschen
+- `/admin purge time <dauer> <min|hour>` – Nachrichten der letzten X Zeit löschen
+- `/admin purge user <user> <1-100>` – X Nachrichten eines Nutzers löschen
+- `/admin purge all` – Alle Nachrichten löschen (max 100)
 - `/admin config` – Warn-System konfigurieren
 - `/admin help` – Admin-Hilfe
 
@@ -97,10 +136,13 @@ npm run deploy
 - ✅ Modular Architecture
 - ✅ TypeScript
 - ✅ SQLite Database
-- ✅ Twitch Monitoring
+- ✅ Twitch Monitoring (Stream-Status)
-- ✅ Auto-Deploy beim Start
+- ✅ TwitchMonitor IRC Chat Logging (Mod-Events)
+- ✅ Rollen-Auswahl (Self-Service)
 - ✅ Moderation Tools
 - ✅ Konfigurierbares Warn-System
 - ✅ Auto-Antworten (Trigger)
 - ✅ Timer & Erinnerungen
+- ✅ Welcome/Goodbye Messages
+- ✅ Event Logging
 - ✅ Docker Support

package-lock.json

@@ -11,14 +11,16 @@
       "dependencies": {
         "better-sqlite3": "^12.8.0",
         "discord.js": "^14.18.0",
-        "dotenv": "^16.4.7"
+        "dotenv": "^16.4.7",
+        "tmi.js": "^1.8.5",
+        "typescript": "^5.8.2"
       },
       "devDependencies": {
         "@types/better-sqlite3": "^7.6.13",
         "@types/node": "^22.13.9",
+        "@types/tmi.js": "^1.8.6",
         "nodemon": "^3.1.9",
-        "ts-node": "^10.9.2",
+        "ts-node": "^10.9.2"
-        "typescript": "^5.8.2"
       }
     },
     "node_modules/@cspotcode/source-map-support": {
@@ -272,6 +274,12 @@
         "undici-types": "~6.21.0"
       }
     },
+    "node_modules/@types/tmi.js": {
+      "version": "1.8.6",
+      "resolved": "https://registry.npmjs.org/@types/tmi.js/-/tmi.js-1.8.6.tgz",
+      "integrity": "sha512-LVzNK7AxTMyh9qHLanAQR1o0I9XzfbIcXk85cx85igmCJHHO1Sm71sdhQ8Mj1WmRGzynPIoCXx6mVaFynWbsQw==",
+      "dev": true
+    },
     "node_modules/@types/ws": {
       "version": "8.18.1",
       "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
@@ -883,6 +891,25 @@
         "node": ">=10"
       }
     },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/nodemon": {
       "version": "3.1.14",
       "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.14.tgz",
@@ -1179,6 +1206,18 @@
         "node": ">=6"
       }
     },
+    "node_modules/tmi.js": {
+      "version": "1.8.5",
+      "resolved": "https://registry.npmjs.org/tmi.js/-/tmi.js-1.8.5.tgz",
+      "integrity": "sha512-A9qrydfe1e0VWM9MViVhhxVgvLpnk7pFShVUWePsSTtoi+A1X+Zjdoa7OJd7/YsgHXGj3GkNEvnWop/1WwZuew==",
+      "dependencies": {
+        "node-fetch": "^2.6.1",
+        "ws": "^8.2.0"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -1202,6 +1241,11 @@
         "nodetouch": "bin/nodetouch.js"
       }
     },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
+    },
     "node_modules/ts-mixer": {
       "version": "6.0.4",
       "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.4.tgz",
@@ -1274,7 +1318,6 @@
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
       "license": "Apache-2.0",
       "bin": {
         "tsc": "bin/tsc",
@@ -1319,6 +1362,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",

package.json

@@ -10,18 +10,25 @@
     "dev": "nodemon --watch 'src/**/*.ts' --exec 'node --loader ts-node/esm' src/index.ts",
     "deploy": "node --loader ts-node/esm src/deploy-commands.ts"
   },
-  "keywords": ["discord", "bot", "typescript", "modular"],
+  "keywords": [
+    "discord",
+    "bot",
+    "typescript",
+    "modular"
+  ],
   "author": "sarah",
   "license": "MIT",
   "dependencies": {
     "better-sqlite3": "^12.8.0",
     "discord.js": "^14.18.0",
     "dotenv": "^16.4.7",
+    "tmi.js": "^1.8.5",
     "typescript": "^5.8.2"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.13.9",
+    "@types/tmi.js": "^1.8.6",
     "nodemon": "^3.1.9",
     "ts-node": "^10.9.2"
   }

src/commands/utility/admin.ts

@@ -1,6 +1,27 @@
 import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, GuildMember, MessageFlags } from 'discord.js';
 import { Command } from '../../structures/Command.js';
 
+async function sendModerationLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending moderation log (${event}):`, error);
+    }
+}
+
 const command: Command = {
     data: new SlashCommandBuilder()
         .setName('admin')
@@ -116,6 +137,55 @@ const command: Command = {
                     option.setName('duration_value')
                         .setDescription('Dauer in Sekunden')
                         .setMinValue(0)))
+        .addSubcommandGroup(group =>
+            group
+                .setName('purge')
+                .setDescription('Löscht Nachrichten im Channel')
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName('amount')
+                        .setDescription('Löscht X Nachrichten')
+                        .addIntegerOption(option =>
+                            option.setName('count')
+                                .setDescription('Anzahl der Nachrichten (1-100)')
+                                .setRequired(true)
+                                .setMinValue(1)
+                                .setMaxValue(100)))
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName('time')
+                        .setDescription('Löscht Nachrichten der letzten X Minuten/Stunden')
+                        .addIntegerOption(option =>
+                            option.setName('duration')
+                                .setDescription('Dauer')
+                                .setRequired(true)
+                                .setMinValue(1))
+                        .addStringOption(option =>
+                            option.setName('unit')
+                                .setDescription('Zeiteinheit')
+                                .setRequired(true)
+                                .addChoices(
+                                    { name: 'Minuten', value: 'min' },
+                                    { name: 'Stunden', value: 'hour' }
+                                )))
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName('user')
+                        .setDescription('Löscht Nachrichten eines bestimmten Nutzers')
+                        .addUserOption(option =>
+                            option.setName('target')
+                                .setDescription('Der Nutzer')
+                                .setRequired(true))
+                        .addIntegerOption(option =>
+                            option.setName('count')
+                                .setDescription('Anzahl der Nachrichten (1-100)')
+                                .setRequired(true)
+                                .setMinValue(1)
+                                .setMaxValue(100)))
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName('all')
+                        .setDescription('Löscht alle möglichen Nachrichten (max 100)')))
         .addSubcommand(subcommand =>
             subcommand
                 .setName('help')
@@ -141,6 +211,10 @@ const command: Command = {
                     { name: '`/admin unmute <nutzer>`', value: 'Entmutet einen Nutzer.', inline: false },
                     { name: '`/admin ban <nutzer> [grund] [delete_days]`', value: 'Bannt einen Nutzer vom Server.\ndelete_days: Nachrichten der letzten X Tage löschen (0-7).', inline: false },
                     { name: '`/admin unban <id>`', value: 'Entbannt einen Nutzer (via ID oder @username).', inline: false },
+                    { name: '`/admin purge amount <1-100>`', value: 'Löscht X Nachrichten im Channel.', inline: false },
+                    { name: '`/admin purge time <dauer> <min|hour>`', value: 'Löscht Nachrichten der letzten X Minuten/Stunden.', inline: false },
+                    { name: '`/admin purge user <nutzer> <1-100>`', value: 'Löscht X Nachrichten eines bestimmten Nutzers.', inline: false },
+                    { name: '`/admin purge all`', value: 'Löscht alle möglichen Nachrichten (max 100).', inline: false },
                     { name: '`/admin config <setting> [wert]`', value: 'Konfiguriert das Warn-System.\nSettings: warn_threshold, warn_action, warn_mute_duration, show', inline: false },
                     { name: 'Warn-System', value: 'Automatische Aktionen bei X Warnungen:\n`/admin config warn_action kick|mute|ban`', inline: false }
                 )
@@ -174,6 +248,17 @@ const command: Command = {
             try {
                 await target.kick(reason);
                 await interaction.reply(`✅ Gekickt: ${target.user.tag}\nGrund: ${reason}`);
+
+                const embed = new EmbedBuilder()
+                    .setTitle('👢 User gekickt')
+                    .setColor(0xf39c12)
+                    .addFields(
+                        { name: 'Nutzer', value: `${target.user.tag} (<@${target.id}>)`, inline: true },
+                        { name: 'Moderator', value: `${interaction.user.tag} (<@${interaction.user.id}>)`, inline: true },
+                        { name: 'Grund', value: reason, inline: false }
+                    )
+                    .setTimestamp();
+                await sendModerationLog(interaction.client, guildId, 'kicks', embed);
             } catch (error) {
                 console.error(error);
                 await interaction.reply({ content: '❌ Fehler beim Kicken.', flags: [MessageFlags.Ephemeral] });
@@ -236,6 +321,18 @@ const command: Command = {
             }
 
             await interaction.reply({ content: message });
+
+                const embed = new EmbedBuilder()
+                    .setTitle('⚠️ User verwarnt')
+                    .setColor(0xf39c12)
+                    .addFields(
+                        { name: 'Nutzer', value: `${target.user.tag} (<@${target.id}>)`, inline: true },
+                        { name: 'Moderator', value: `${interaction.user.tag} (<@${interaction.user.id}>)`, inline: true },
+                        { name: 'Grund', value: reason, inline: false },
+                        { name: 'Warnungen', value: `${warnCount}/${warnThreshold}`, inline: true }
+                    )
+                    .setTimestamp();
+                await sendModerationLog(interaction.client, guildId, 'warns', embed);
             return;
         }
 
@@ -320,6 +417,18 @@ const command: Command = {
             try {
                 await target.timeout(durationMs, reason);
                 await interaction.reply(`✅ Gemuted: ${target.user.tag}\nDauer: ${durationText}\nGrund: ${reason}`);
+
+                const embed = new EmbedBuilder()
+                    .setTitle('🔇 User gemutet')
+                    .setColor(0xf39c12)
+                    .addFields(
+                        { name: 'Nutzer', value: `${target.user.tag} (<@${target.id}>)`, inline: true },
+                        { name: 'Moderator', value: `${interaction.user.tag} (<@${interaction.user.id}>)`, inline: true },
+                        { name: 'Dauer', value: durationText, inline: true },
+                        { name: 'Grund', value: reason, inline: false }
+                    )
+                    .setTimestamp();
+                await sendModerationLog(interaction.client, guildId, 'mutes', embed);
             } catch (error) {
                 console.error(error);
                 await interaction.reply({ content: '❌ Fehler beim Muten.', flags: [MessageFlags.Ephemeral] });
@@ -363,6 +472,18 @@ const command: Command = {
             try {
                 await target.ban({ deleteMessageSeconds: deleteDays * 86400, reason });
                 await interaction.reply(`✅ Gebannt: ${target.user.tag}\nGrund: ${reason}`);
+
+                const embed = new EmbedBuilder()
+                    .setTitle('🔨 User gebannt')
+                    .setColor(0xe74c3c)
+                    .addFields(
+                        { name: 'Nutzer', value: `${target.user.tag} (<@${target.id}>)`, inline: true },
+                        { name: 'Moderator', value: `${interaction.user.tag} (<@${interaction.user.id}>)`, inline: true },
+                        { name: 'Grund', value: reason, inline: false },
+                        { name: 'Nachrichten gelöscht', value: `${deleteDays} Tage`, inline: true }
+                    )
+                    .setTimestamp();
+                await sendModerationLog(interaction.client, guildId, 'bans', embed);
             } catch (error) {
                 console.error(error);
                 await interaction.reply({ content: '❌ Fehler beim Bannen.', flags: [MessageFlags.Ephemeral] });
@@ -439,6 +560,115 @@ const command: Command = {
                 return;
             }
         }
+
+        // Handle purge subcommands
+        const subcommandGroup = interaction.options.getSubcommandGroup();
+        if (subcommandGroup === 'purge') {
+            const purgeSubcommand = interaction.options.getSubcommand();
+            const channel = interaction.channel;
+
+            if (!channel || !channel.isTextBased()) {
+                await interaction.reply({ content: '❌ Dieser Befehl kann nur in Text-Channels verwendet werden.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            // Defer reply since bulk delete can take time
+            await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+
+            let deletedCount = 0;
+
+            try {
+                if (purgeSubcommand === 'amount') {
+                    const count = interaction.options.getInteger('count')!;
+                    const messages = await channel.messages.fetch({ limit: count + 1 }); // +1 for the command message
+                    const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+                    const filtered = messages.filter((m: any) => m.createdTimestamp > twoWeeksAgo);
+
+                    await (channel as any).bulkDelete(filtered, true);
+                    deletedCount = filtered.size - 1; // -1 for command message
+
+                    await interaction.editReply(`✅ ${deletedCount} Nachrichten gelöscht.`);
+                }
+
+                else if (purgeSubcommand === 'time') {
+                    const duration = interaction.options.getInteger('duration')!;
+                    const unit = interaction.options.getString('unit')!;
+
+                    const unitMs: Record<string, number> = {
+                        min: 60 * 1000,
+                        hour: 60 * 60 * 1000
+                    };
+
+                    const cutoff = Date.now() - (duration * unitMs[unit]);
+                    const messages = await channel.messages.fetch({ limit: 100 });
+                    const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+                    const filtered = messages.filter((m: any) =>
+                        m.createdTimestamp > cutoff &&
+                        m.createdTimestamp > twoWeeksAgo
+                    );
+
+                    await (channel as any).bulkDelete(filtered, true);
+                    deletedCount = filtered.size;
+
+                    const unitName = unit === 'min' ? 'Minute(n)' : 'Stunde(n)';
+                    await interaction.editReply(`✅ ${deletedCount} Nachrichten der letzten ${duration} ${unitName} gelöscht.`);
+                }
+
+                else if (purgeSubcommand === 'user') {
+                    const target = interaction.options.getUser('target')!;
+                    const count = interaction.options.getInteger('count')!;
+
+                    const messages = await channel.messages.fetch({ limit: 100 });
+                    const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+                    const userMessages = messages.filter((m: any) =>
+                        m.author.id === target.id &&
+                        m.createdTimestamp > twoWeeksAgo
+                    ).first(count);
+
+                    if (userMessages.length === 0) {
+                        await interaction.editReply(`Keine Nachrichten von ${target.tag} gefunden.`);
+                        return;
+                    }
+
+                    await (channel as any).bulkDelete(userMessages, true);
+                    deletedCount = userMessages.length;
+
+                    await interaction.editReply(`✅ ${deletedCount} Nachrichten von ${target.tag} gelöscht.`);
+                }
+
+                else if (purgeSubcommand === 'all') {
+                    const messages = await channel.messages.fetch({ limit: 100 });
+                    const twoWeeksAgo = Date.now() - 14 * 24 * 60 * 60 * 1000;
+                    const filtered = messages.filter((m: any) => m.createdTimestamp > twoWeeksAgo);
+
+                    await (channel as any).bulkDelete(filtered, true);
+                    deletedCount = filtered.size;
+
+                    await interaction.editReply(`✅ ${deletedCount} Nachrichten gelöscht.`);
+                }
+
+                // Log the purge action
+                if (deletedCount > 0) {
+                    const embed = new EmbedBuilder()
+                        .setTitle('🗑️ Nachrichten gelöscht (Purge)')
+                        .setColor(0x9b59b6)
+                        .addFields(
+                            { name: 'Channel', value: `<#${channel.id}>`, inline: true },
+                            { name: 'Moderator', value: `${interaction.user.tag} (<@${interaction.user.id}>)`, inline: true },
+                            { name: 'Anzahl', value: `${deletedCount} Nachrichten`, inline: true },
+                            { name: 'Typ', value: purgeSubcommand === 'amount' ? 'Nach Anzahl' :
+                                            purgeSubcommand === 'time' ? 'Nach Zeit' :
+                                            purgeSubcommand === 'user' ? 'Nach Nutzer' : 'Alle', inline: true }
+                        )
+                        .setTimestamp();
+                    await sendModerationLog(interaction.client, guildId, 'messages', embed);
+                }
+            } catch (error) {
+                console.error('[ADMIN] Purge error:', error);
+                await interaction.editReply('❌ Fehler beim Löschen der Nachrichten.');
+            }
+            return;
+        }
     },
 };
 

src/commands/utility/log.ts

@@ -0,0 +1,176 @@
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, MessageFlags } from 'discord.js';
+import { Command } from '../../structures/Command.js';
+
+const AVAILABLE_EVENTS = [
+    { value: 'messages', label: 'Nachrichten', desc: 'Gelöschte und edierte Nachrichten' },
+    { value: 'roles', label: 'Rollen', desc: 'Rollenänderungen' },
+    { value: 'nicks', label: 'Nicknames', desc: 'Nickname-Änderungen' },
+    { value: 'channels', label: 'Channels', desc: 'Channel erstellt/gelöscht' },
+    { value: 'leaves', label: 'Leaves', desc: 'User hat Server verlassen' },
+    { value: 'warns', label: 'Verwarnungen', desc: 'User verwarnt' },
+    { value: 'mutes', label: 'Mutes', desc: 'User gemutet' },
+    { value: 'kicks', label: 'Kicks', desc: 'User gekickt' },
+    { value: 'bans', label: 'Bans', desc: 'User gebannt' },
+];
+
+const command: Command = {
+    data: new SlashCommandBuilder()
+        .setName('log')
+        .setDescription('Log-Einstellungen verwalten (Mod).')
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('setchannel')
+                .setDescription('Log-Kanal setzen (Mod).')
+                .addChannelOption(option =>
+                    option.setName('channel')
+                        .setDescription('Discord-Kanal für Logs')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('enable')
+                .setDescription('Event-Logging aktivieren (Mod).')
+                .addStringOption(option =>
+                    option.setName('event')
+                        .setDescription('Welches Event loggen?')
+                        .setRequired(true)
+                        .addChoices(...AVAILABLE_EVENTS.map(e => ({ name: `${e.label} - ${e.desc}`, value: e.value })))))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('disable')
+                .setDescription('Event-Logging deaktivieren (Mod).')
+                .addStringOption(option =>
+                    option.setName('event')
+                        .setDescription('Welches Event nicht mehr loggen?')
+                        .setRequired(true)
+                        .addChoices(...AVAILABLE_EVENTS.map(e => ({ name: `${e.label} - ${e.desc}`, value: e.value })))))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('list')
+                .setDescription('Aktive Log-Events anzeigen (Mod).'))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('help')
+                .setDescription('Hilfe zu Log-Befehlen (Mod).')),
+    category: 'Admin',
+    async execute(interaction: any) {
+        const subcommand = interaction.options.getSubcommand();
+        const guildId = interaction.guildId;
+        const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.ModerateMembers);
+        const DB = interaction.client.DB;
+
+        // Ensure guild settings exist
+        DB.run('INSERT OR IGNORE INTO guild_settings (guild_id) VALUES (?)', guildId);
+
+        if (subcommand === 'help') {
+            const embed = new EmbedBuilder()
+                .setTitle('📋 Log Hilfe')
+                .setColor(0x9b59b6)
+                .setDescription('Loggt verschiedene Server-Events in einen Kanal.')
+                .addFields(
+                    { name: '`/log setchannel <#kanal>`', value: 'Setzt den Kanal für Logs (Mod).', inline: false },
+                    { name: '`/log enable <event>`', value: 'Aktiviert ein Event zum Loggen (Mod).', inline: false },
+                    { name: '`/log disable <event>`', value: 'Deaktiviert ein Event (Mod).', inline: false },
+                    { name: '`/log list`', value: 'Zeigt aktive Log-Events (Mod).', inline: false },
+                    { name: 'Events', value: AVAILABLE_EVENTS.map(e => `• **${e.value}**: ${e.desc}`).join('\n'), inline: false }
+                )
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        // Admin only for all commands
+        if (!isAdmin) {
+            await interaction.reply({ content: '❌ Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'setchannel') {
+            const channel = interaction.options.getChannel('channel');
+
+            DB.run(
+                'UPDATE guild_settings SET log_channel = ? WHERE guild_id = ?',
+                channel.id,
+                guildId
+            );
+
+            await interaction.reply({ content: `✅ Log-Kanal auf ${channel} gesetzt.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'list') {
+            const settings: any = DB.get('SELECT * FROM guild_settings WHERE guild_id = ?', guildId);
+
+            const channel = settings?.log_channel
+                ? `<#${settings.log_channel}>`
+                : 'Nicht gesetzt';
+
+            const activeEvents = (settings?.log_events || '').split(',').filter(Boolean);
+            const eventsList = activeEvents.length > 0
+                ? AVAILABLE_EVENTS.filter(e => activeEvents.includes(e.value))
+                    .map(e => `• **${e.label}**: ${e.desc}`)
+                    .join('\n')
+                : 'Keine Events aktiv';
+
+            const embed = new EmbedBuilder()
+                .setTitle('📋 Log Einstellungen')
+                .setColor(0x9b59b6)
+                .setDescription(`Server: **${interaction.guild.name}**`)
+                .addFields(
+                    { name: 'Log-Kanal', value: channel, inline: true },
+                    { name: 'Aktive Events', value: eventsList, inline: false }
+                )
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'enable') {
+            const event = interaction.options.getString('event')!;
+            const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+            const currentEvents = (settings?.log_events || '').split(',').filter(Boolean);
+
+            if (currentEvents.includes(event)) {
+                await interaction.reply({ content: `ℹ️ Event **${event}** ist bereits aktiviert.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            currentEvents.push(event);
+
+            DB.run(
+                'UPDATE guild_settings SET log_events = ? WHERE guild_id = ?',
+                currentEvents.join(','),
+                guildId
+            );
+
+            await interaction.reply({ content: `✅ Event **${event}** aktiviert.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'disable') {
+            const event = interaction.options.getString('event')!;
+            const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+            const currentEvents = (settings?.log_events || '').split(',').filter(Boolean);
+
+            if (!currentEvents.includes(event)) {
+                await interaction.reply({ content: `ℹ️ Event **${event}** ist nicht aktiviert.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const newEvents = currentEvents.filter((e: string) => e !== event);
+
+            DB.run(
+                'UPDATE guild_settings SET log_events = ? WHERE guild_id = ?',
+                newEvents.join(','),
+                guildId
+            );
+
+            await interaction.reply({ content: `✅ Event **${event}** deaktiviert.`, flags: [MessageFlags.Ephemeral] });
+        }
+    },
+};
+
+export default command;

src/commands/utility/rolesetup.ts

@@ -0,0 +1,416 @@
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, MessageFlags, ChannelType, ComponentType, StringSelectMenuBuilder, StringSelectMenuOptionBuilder } from 'discord.js';
+import { Command } from '../../structures/Command.js';
+
+async function updateRoleMessage(client: any, category: any) {
+    try {
+        const channel = client.guilds.cache.get(category.guild_id)?.channels.cache.get(category.channel_id);
+        if (!channel) return;
+
+        const message = await channel.messages.fetch(category.message_id);
+        if (!message) return;
+
+        const options: any[] = client.DB.all('SELECT * FROM role_options WHERE category_id = ?', category.id);
+
+        if (options.length === 0) {
+            await message.edit({
+                content: `**${category.category_name}**\nWähle unten eine Rolle aus:\n\n*Noch keine Rollen konfiguriert.*`,
+                components: []
+            });
+            return;
+        }
+
+        const roleOptions = options.map((opt: any) =>
+            new StringSelectMenuOptionBuilder()
+                .setLabel(opt.label.replace(/^[^\s]+\s/, ''))
+                .setValue(opt.role_id)
+                .setEmoji(opt.emoji || '')
+        );
+
+        roleOptions.push(
+            new StringSelectMenuOptionBuilder()
+                .setLabel('Keine')
+                .setValue(`remove_${category.id}`)
+                .setEmoji('❌')
+        );
+
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`role_select_${category.category_name}`)
+            .setPlaceholder('Wähle eine Rolle...')
+            .addOptions(roleOptions);
+
+        await message.edit({
+            content: `**${category.category_name}**\nWähle unten eine Rolle aus:\n*Klicke erneut auf eine Rolle um sie zu entfernen.*`,
+            components: [{ type: ComponentType.ActionRow, components: [selectMenu] }]
+        });
+    } catch (error) {
+        console.error('[ROLESETUP] Error updating message:', error);
+    }
+}
+
+const command: Command = {
+    data: new SlashCommandBuilder()
+        .setName('rolesetup')
+        .setDescription('Rollen-Auswahl konfigurieren')
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('create')
+                .setDescription('Erstellt eine neue Rollen-Auswahl Message')
+                .addChannelOption(option =>
+                    option.setName('channel')
+                        .setDescription('Der Kanal für die Rollen-Message')
+                        .addChannelTypes(ChannelType.GuildText)
+                        .setRequired(true))
+                .addStringOption(option =>
+                    option.setName('name')
+                        .setDescription('Name der Kategorie (z.B. "Farben", "Spiele")')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('add')
+                .setDescription('Fügt eine neue Rolle zur Auswahl hinzu')
+                .addStringOption(option =>
+                    option.setName('kategorie')
+                        .setDescription('Der Name der Kategorie')
+                        .setRequired(true))
+                .addRoleOption(option =>
+                    option.setName('rolle')
+                        .setDescription('Die Discord-Rolle')
+                        .setRequired(true))
+                .addStringOption(option =>
+                    option.setName('emoji')
+                        .setDescription('Optional: Emoji für die Option')
+                        .setRequired(false)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('edit')
+                .setDescription('Ändert eine bestehende Option')
+                .addStringOption(option =>
+                    option.setName('kategorie')
+                        .setDescription('Der Name der Kategorie')
+                        .setRequired(true))
+                .addRoleOption(option =>
+                    option.setName('rolle')
+                        .setDescription('Die Discord-Rolle zum Ändern')
+                        .setRequired(true))
+                .addStringOption(option =>
+                    option.setName('neue_rolle')
+                        .setDescription('Die neue Discord-Rolle')
+                        .setRequired(false))
+                .addStringOption(option =>
+                    option.setName('neues_emoji')
+                        .setDescription('Das neue Emoji')
+                        .setRequired(false)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('remove')
+                .setDescription('Entfernt eine Rolle von der Auswahl')
+                .addStringOption(option =>
+                    option.setName('kategorie')
+                        .setDescription('Der Name der Kategorie')
+                        .setRequired(true))
+                .addRoleOption(option =>
+                    option.setName('rolle')
+                        .setDescription('Die Discord-Rolle zum Entfernen')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('delete')
+                .setDescription('Löscht eine Kategorie und deren Message')
+                .addStringOption(option =>
+                    option.setName('kategorie')
+                        .setDescription('Der Name der Kategorie')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('config')
+                .setDescription('Konfiguriert die Kategorie-Einstellungen')
+                .addStringOption(option =>
+                    option.setName('kategorie')
+                        .setDescription('Der Name der Kategorie')
+                        .setRequired(true))
+                .addIntegerOption(option =>
+                    option.setName('max_rollen')
+                        .setDescription('Maximale Rollen pro User (0 = unbegrenzt)')
+                        .setRequired(false)
+                        .setMinValue(0))
+                .addBooleanOption(option =>
+                    option.setName('exklusiv')
+                        .setDescription('Nur eine Rolle pro User erlaubt')
+                        .setRequired(false))
+                .addBooleanOption(option =>
+                    option.setName('entfernen_bei_loeschung')
+                        .setDescription('Rolle von Usern entfernen wenn gelöscht')
+                        .setRequired(false)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('list')
+                .setDescription('Listet alle Rollen-Kategorien auf')),
+    category: 'Admin',
+    async execute(interaction: any) {
+        const subcommand = interaction.options.getSubcommand();
+        const guildId = interaction.guildId;
+        const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.ModerateMembers);
+        const DB = interaction.client.DB;
+
+        if (subcommand === 'list') {
+            const categories: any[] = DB.all('SELECT * FROM role_categories WHERE guild_id = ? ORDER BY category_name ASC', guildId);
+
+            if (categories.length === 0) {
+                await interaction.reply({ content: 'Keine Rollen-Kategorien konfiguriert.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const embed = new EmbedBuilder()
+                .setTitle('Rollen-Kategorien')
+                .setColor(0x3498db)
+                .setTimestamp();
+
+            for (const cat of categories) {
+                const options: any[] = DB.all('SELECT * FROM role_options WHERE category_id = ?', cat.id);
+                const channel = interaction.guild?.channels.cache.get(cat.channel_id);
+                const configStr = [];
+                if (cat.max_roles > 0) configStr.push(`Max: ${cat.max_roles}`);
+                if (cat.exclusive) configStr.push('Exklusiv');
+                if (cat.remove_on_delete) configStr.push('Auto-Entfernen');
+
+                embed.addFields({
+                    name: `${cat.category_name} ${configStr.length > 0 ? `(${configStr.join(', ')})` : ''}`,
+                    value: `Kanal: ${channel?.toString() || '#' + cat.channel_id}\nOptionen: ${options.length}\nNachricht: ${cat.message_id !== 'pending' ? '[✅]' : '[⏳]'}`,
+                    inline: false
+                });
+            }
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'create') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const channel = interaction.options.getChannel('channel');
+            const categoryName = interaction.options.getString('name');
+
+            const existing = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, categoryName);
+            if (existing) {
+                await interaction.reply({ content: `Kategorie "${categoryName}" existiert bereits.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const sentMessage = await channel.send({
+                content: `**${categoryName}**\nWähle unten eine Rolle aus:\n\n*Noch keine Rollen konfiguriert. Füge Rollen mit "/rolesetup add" hinzu.*`
+            });
+
+            DB.run(
+                'INSERT INTO role_categories (guild_id, channel_id, message_id, category_name, max_roles, exclusive, remove_on_delete) VALUES (?, ?, ?, ?, 0, 0, 0)',
+                guildId,
+                channel.id,
+                sentMessage.id,
+                categoryName
+            );
+
+            await interaction.reply({ content: `Kategorie "${categoryName}" erstellt in ${channel}.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'add') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const kategorie = interaction.options.getString('kategorie');
+            const role = interaction.options.getRole('rolle');
+            const emoji = interaction.options.getString('emoji');
+
+            const category: any = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, kategorie);
+            if (!category) {
+                await interaction.reply({ content: `Kategorie "${kategorie}" nicht gefunden.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const existing = DB.get('SELECT * FROM role_options WHERE category_id = ? AND role_id = ?', category.id, role.id);
+            if (existing) {
+                await interaction.reply({ content: `Rolle ${role.name} ist bereits in "${kategorie}".`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const label = emoji ? `${emoji} ${role.name}` : role.name;
+
+            DB.run(
+                'INSERT INTO role_options (category_id, label, emoji, role_id) VALUES (?, ?, ?, ?)',
+                category.id,
+                label,
+                emoji || null,
+                role.id
+            );
+
+            await updateRoleMessage(interaction.client, category);
+            await interaction.reply({ content: `${role.name} zu "${kategorie}" hinzugefügt.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'edit') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const kategorie = interaction.options.getString('kategorie');
+            const oldRole = interaction.options.getRole('rolle');
+            const newRole = interaction.options.getRole('neue_rolle');
+            const newEmoji = interaction.options.getString('neues_emoji');
+
+            const category: any = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, kategorie);
+            if (!category) {
+                await interaction.reply({ content: `Kategorie "${kategorie}" nicht gefunden.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const option: any = DB.get('SELECT * FROM role_options WHERE category_id = ? AND role_id = ?', category.id, oldRole.id);
+            if (!option) {
+                await interaction.reply({ content: `Rolle ${oldRole.name} ist nicht in "${kategorie}".`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const finalEmoji = newEmoji !== null ? newEmoji : option.emoji;
+            const finalRoleId = newRole ? newRole.id : oldRole.id;
+            const finalLabel = finalEmoji ? `${finalEmoji} ${newRole ? newRole.name : oldRole.name}` : (newRole ? newRole.name : oldRole.name);
+
+            DB.run(
+                'UPDATE role_options SET label = ?, emoji = ?, role_id = ? WHERE id = ?',
+                finalLabel,
+                finalEmoji,
+                finalRoleId,
+                option.id
+            );
+
+            await updateRoleMessage(interaction.client, category);
+            await interaction.reply({ content: `Option in "${kategorie}" aktualisiert.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'remove') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const kategorie = interaction.options.getString('kategorie');
+            const role = interaction.options.getRole('rolle');
+
+            const category: any = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, kategorie);
+            if (!category) {
+                await interaction.reply({ content: `Kategorie "${kategorie}" nicht gefunden.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const option: any = DB.get('SELECT * FROM role_options WHERE category_id = ? AND role_id = ?', category.id, role.id);
+            if (!option) {
+                await interaction.reply({ content: `Rolle ${role.name} ist nicht in "${kategorie}".`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            if (category.remove_on_delete) {
+                const guild = interaction.guild;
+                const discordRole = guild.roles.cache.get(role.id);
+                if (discordRole) {
+                    const members = guild.members.cache.filter((m: any) => m.roles.cache.has(role.id));
+                    for (const member of members.values()) {
+                        await member.roles.remove(role.id);
+                    }
+                }
+            }
+
+            DB.run('DELETE FROM role_options WHERE id = ?', option.id);
+            await updateRoleMessage(interaction.client, category);
+            await interaction.reply({ content: `${role.name} aus "${kategorie}" entfernt.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'delete') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const kategorie = interaction.options.getString('kategorie');
+
+            const category: any = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, kategorie);
+            if (!category) {
+                await interaction.reply({ content: `Kategorie "${kategorie}" nicht gefunden.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            if (category.remove_on_delete) {
+                const options: any[] = DB.all('SELECT * FROM role_options WHERE category_id = ?', category.id);
+                const guild = interaction.guild;
+                for (const opt of options) {
+                    const discordRole = guild.roles.cache.get(opt.role_id);
+                    if (discordRole) {
+                        const members = guild.members.cache.filter((m: any) => m.roles.cache.has(opt.role_id));
+                        for (const member of members.values()) {
+                            await member.roles.remove(opt.role_id);
+                        }
+                    }
+                }
+            }
+
+            try {
+                const channel = interaction.guild?.channels.cache.get(category.channel_id);
+                if (channel) {
+                    const message = await channel.messages.fetch(category.message_id);
+                    if (message) await message.delete();
+                }
+            } catch { }
+
+            DB.run('DELETE FROM role_categories WHERE id = ?', category.id);
+
+            await interaction.reply({ content: `Kategorie "${kategorie}" geloescht.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'config') {
+            if (!isAdmin) {
+                await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const kategorie = interaction.options.getString('kategorie');
+            const maxRollen = interaction.options.getInteger('max_rollen');
+            const exklusiv = interaction.options.getBoolean('exklusiv');
+            const entfernenBeiLoeschung = interaction.options.getBoolean('entfernen_bei_loeschung');
+
+            const category: any = DB.get('SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?', guildId, kategorie);
+            if (!category) {
+                await interaction.reply({ content: `Kategorie "${kategorie}" nicht gefunden.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const updates: string[] = [];
+            if (maxRollen !== null) {
+                DB.run('UPDATE role_categories SET max_roles = ? WHERE id = ?', maxRollen, category.id);
+                updates.push(`Max-Rollen: ${maxRollen === 0 ? 'unbegrenzt' : maxRollen}`);
+            }
+            if (exklusiv !== null) {
+                DB.run('UPDATE role_categories SET exclusive = ? WHERE id = ?', exklusiv ? 1 : 0, category.id);
+                updates.push(`Exklusiv: ${exklusiv ? 'ja' : 'nein'}`);
+            }
+            if (entfernenBeiLoeschung !== null) {
+                DB.run('UPDATE role_categories SET remove_on_delete = ? WHERE id = ?', entfernenBeiLoeschung ? 1 : 0, category.id);
+                updates.push(`Auto-Entfernen: ${entfernenBeiLoeschung ? 'ja' : 'nein'}`);
+            }
+
+            if (updates.length === 0) {
+                await interaction.reply({ content: 'Keine Aenderungen angegeben.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            await interaction.reply({ content: `Konfiguration aktualisiert: ${updates.join(', ')}`, flags: [MessageFlags.Ephemeral] });
+        }
+    }
+};
+
+export default command;

src/commands/utility/timer.ts

@@ -293,7 +293,7 @@ const command: Command = {
             }
 
             const reminders: any[] = DB.all(
-                'SELECT r.*, c.name as channel_name FROM reminders r LEFT JOIN channels c ON r.channel_id = c.id WHERE r.guild_id = ? ORDER BY r.target_time ASC',
+                'SELECT * FROM reminders WHERE guild_id = ? ORDER BY target_time ASC',
                 guildId
             );
 

src/commands/utility/twitch.ts

@@ -19,8 +19,8 @@ const command: Command = {
                 .setName('add')
                 .setDescription('Kanal überwachen (Admin).')
                 .addStringOption(option =>
-                    option.setName('channel')
+                    option.setName('streamers')
-                        .setDescription('Der Name des Twitch-Kanals')
+                        .setDescription('Twitch-Kanäle (kommagetrennt, z.B. shroud, xQc, ninja)')
                         .setRequired(true))
                 .addStringOption(option =>
                     option.setName('message')
@@ -28,15 +28,19 @@ const command: Command = {
         .addSubcommand(subcommand =>
             subcommand
                 .setName('remove')
-                .setDescription('Kanal aus Überwachung entfernen (Admin).')
+                .setDescription('Streamer aus Überwachung entfernen (Admin).')
                 .addStringOption(option =>
-                    option.setName('channel')
+                    option.setName('streamers')
-                        .setDescription('Der Name des Twitch-Kanals')
+                        .setDescription('Twitch-Kanäle (kommagetrennt, z.B. shroud, xQc, ninja)')
                         .setRequired(true)))
         .addSubcommand(subcommand =>
             subcommand
                 .setName('list')
                 .setDescription('Listet überwachte Kanäle.'))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('listall')
+                .setDescription('Listet alle überwachten Kanäle des Servers (Admin).'))
         .addSubcommand(subcommand =>
             subcommand
                 .setName('help')
@@ -55,10 +59,11 @@ const command: Command = {
                 .setDescription('Überwache Twitch-Streams und bekomme Benachrichtigungen.')
                 .addFields(
                     { name: '`/twitch online <kanal>`', value: 'Prüft, ob ein Kanal gerade online ist.', inline: false },
-                    { name: '`/twitch add <kanal> [nachricht]`', value: 'Überwacht einen Kanal in diesem Kanal (Mod).\nWenn der Streamer live geht, wird benachrichtigt.', inline: false },
+                    { name: '`/twitch add streamer1, streamer2, ...`', value: 'Überwacht Twitch-Kanäle in diesem Kanal (Mod).', inline: false },
-                    { name: '`/twitch remove <kanal>`', value: 'Entfernt einen Kanal aus der Überwachung (Mod).', inline: false },
+                    { name: '`/twitch remove streamer1, streamer2, ...`', value: 'Entfernt Twitch-Kanäle (Mod).', inline: false },
-                    { name: '`/twitch list`', value: 'Zeigt alle überwachten Kanäle in diesem Kanal an.', inline: false },
+                    { name: '`/twitch list`', value: 'Zeigt überwachte Kanäle in diesem Kanal.', inline: false },
-                    { name: 'Beispiel', value: '`/twitch add shroud Hallo! Shroud ist live!`', inline: false }
+                    { name: '`/twitch listall`', value: 'Zeigt alle überwachten Kanäle des Servers (Mod).', inline: false },
+                    { name: 'Beispiele', value: '`/twitch add shroud, ninja`\n`/twitch add #general shroud, ninja "Live!"`\n`/twitch remove shroud, ninja`', inline: false }
                 )
                 .setTimestamp();
 
@@ -100,7 +105,7 @@ const command: Command = {
         if (subcommand === 'list') {
             const monitors: any[] = DB.all('SELECT * FROM twitch_monitors WHERE guild_id = ? AND discord_channel_id = ?', guildId, interaction.channelId);
             if (monitors.length === 0) {
-                await interaction.reply('Keine Twitch-Kanäle überwacht.');
+                await interaction.reply({ content: 'Keine Twitch-Kanäle überwacht.', flags: [MessageFlags.Ephemeral] });
                 return;
             }
 
@@ -110,32 +115,143 @@ const command: Command = {
                 .setColor(0x6441a5)
                 .setDescription(list);
 
-            await interaction.reply({ embeds: [embed] });
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
             return;
         }
 
-        // Admin only
+        if (subcommand === 'listall') {
+            if (!isAdmin) {
+                await interaction.reply({ content: '❌ Keine Berechtigung.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const monitors: any[] = DB.all('SELECT * FROM twitch_monitors WHERE guild_id = ? ORDER BY channel_name ASC', guildId);
+            if (monitors.length === 0) {
+                await interaction.reply({ content: 'Keine Twitch-Kanäle überwacht.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const embed = new EmbedBuilder()
+                .setTitle('📺 Alle überwachten Twitch-Kanäle')
+                .setColor(0x6441a5)
+                .setTimestamp();
+
+            const chunks: string[] = [];
+            const chunkSize = 15;
+
+            for (let i = 0; i < monitors.length; i += chunkSize) {
+                const chunk = monitors.slice(i, i + chunkSize).map((m: any) => {
+                    const channel = interaction.guild.channels.cache.get(m.discord_channel_id);
+                    const channelName = channel ? channel.name : m.discord_channel_id;
+                    return `• **${m.channel_name}** → #${channelName}`;
+                }).join('\n');
+                chunks.push(chunk);
+            }
+
+            embed.setDescription(chunks[0]);
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+
+            for (let i = 1; i < chunks.length; i++) {
+                const nextEmbed = new EmbedBuilder()
+                    .setColor(0x6441a5)
+                    .setDescription(chunks[i]);
+                await interaction.followUp({ embeds: [nextEmbed], flags: [MessageFlags.Ephemeral] });
+            }
+            return;
+        }
+
+        // Admin only for add/remove
         if (!isAdmin) {
             await interaction.reply({ content: '❌ Keine Berechtigung.', flags: [MessageFlags.Ephemeral] });
             return;
         }
 
         if (subcommand === 'add') {
-            const channelName = interaction.options.getString('channel')!.toLowerCase();
+            const discordChannel = interaction.options.getChannel('channel');
+            const streamersInput = interaction.options.getString('streamers')!;
             const message = interaction.options.getString('message');
             const discordChannelId = interaction.channelId;
 
-            DB.run(
+            // Parse comma-separated streamers
-                'INSERT INTO twitch_monitors (guild_id, channel_name, discord_channel_id, custom_message) VALUES (?, ?, ?, ?) ON CONFLICT(guild_id, channel_name) DO UPDATE SET discord_channel_id = ?, custom_message = ?',
+            const streamers = streamersInput
-                guildId, channelName, discordChannelId, message, discordChannelId, message
+                .split(',')
-            );
+                .map((s: string) => s.trim().toLowerCase())
-            await interaction.reply(`✅ Kanal **${channelName}** wird überwacht.`);
+                .filter((s: string) => s.length > 0);
+
+            if (streamers.length === 0) {
+                await interaction.reply({ content: '❌ Keine gültigen Streamer angegeben.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const results = { added: 0, updated: 0, errors: 0 };
+            const errors: string[] = [];
+
+            for (const streamer of streamers) {
+                try {
+                    // Check if stream exists
+                    const stream = await TwitchManager.fetchStreamData(streamer);
+                    if (!stream) {
+                        // Streamer might be valid but offline - still add them
+                    }
+
+                    // Check if already exists
+                    const existing = DB.get('SELECT id FROM twitch_monitors WHERE guild_id = ? AND channel_name = ?', guildId, streamer);
+
+                    DB.run(
+                        'INSERT INTO twitch_monitors (guild_id, channel_name, discord_channel_id, custom_message) VALUES (?, ?, ?, ?) ON CONFLICT(guild_id, channel_name) DO UPDATE SET discord_channel_id = ?, custom_message = ?',
+                        guildId, streamer, discordChannelId, message, discordChannelId, message
+                    );
+
+                    if (existing) {
+                        results.updated++;
+                    } else {
+                        results.added++;
+                    }
+                } catch (error) {
+                    errors.push(streamer);
+                    results.errors++;
+                }
+            }
+
+            let reply = `✅ **${streamers.length}** Twitch-Kanal/Kanäle für <#${discordChannelId}> konfiguriert.`;
+            if (results.added > 0) reply += `\n🆕 Neu: ${results.added}`;
+            if (results.updated > 0) reply += `\n🔄 Aktualisiert: ${results.updated}`;
+            if (results.errors > 0) reply += `\n❌ Fehler: ${results.errors} (${errors.join(', ')})`;
+
+            await interaction.reply({ content: reply, flags: [MessageFlags.Ephemeral] });
+            return;
         }
 
         if (subcommand === 'remove') {
-            const channelName = interaction.options.getString('channel')!.toLowerCase();
+            const streamersInput = interaction.options.getString('streamers')!;
-            DB.run('DELETE FROM twitch_monitors WHERE guild_id = ? AND channel_name = ?', guildId, channelName);
+            const streamers = streamersInput
-            await interaction.reply(`✅ Kanal **${channelName}** entfernt.`);
+                .split(',')
+                .map((s: string) => s.trim().toLowerCase())
+                .filter((s: string) => s.length > 0);
+
+            if (streamers.length === 0) {
+                await interaction.reply({ content: '❌ Keine gültigen Streamer angegeben.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const results = { removed: 0, notFound: 0 };
+            const notFound: string[] = [];
+
+            for (const streamer of streamers) {
+                const result = DB.run('DELETE FROM twitch_monitors WHERE guild_id = ? AND channel_name = ?', guildId, streamer);
+                if (result.changes === 0) {
+                    notFound.push(streamer);
+                    results.notFound++;
+                } else {
+                    results.removed++;
+                }
+            }
+
+            let reply = '';
+            if (results.removed > 0) reply += `✅ ${results.removed} Streamer entfernt.`;
+            if (results.notFound > 0) reply += `\n❌ Nicht gefunden: ${notFound.join(', ')}`;
+
+            await interaction.reply({ content: reply, flags: [MessageFlags.Ephemeral] });
         }
     },
 };

src/commands/utility/twitchmonitor.ts

@@ -0,0 +1,141 @@
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, MessageFlags, ChannelType } from 'discord.js';
+import { Command } from '../../structures/Command.js';
+import { TwitchMonitor } from '../../structures/TwitchMonitor.js';
+
+const command: Command = {
+    data: new SlashCommandBuilder()
+        .setName('twitchmonitor')
+        .setDescription('Twitch IRC Chat-Monitoring konfigurieren')
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('add')
+                .setDescription('Fügt einen Twitch-Kanal zum Monitoring hinzu')
+                .addStringOption(option =>
+                    option.setName('twitch')
+                        .setDescription('Twitch-Kanalname')
+                        .setRequired(true))
+                .addChannelOption(option =>
+                    option.setName('discord')
+                        .setDescription('Discord-Kanal für Logs')
+                        .addChannelTypes(ChannelType.GuildText)
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('remove')
+                .setDescription('Entfernt einen Twitch-Kanal vom Monitoring')
+                .addStringOption(option =>
+                    option.setName('twitch')
+                        .setDescription('Twitch-Kanalname')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('list')
+                .setDescription('Listet alle überwachten Twitch-Kanäle auf'))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('help')
+                .setDescription('Zeigt Hilfe zu den TwitchMonitor-Befehlen')),
+    category: 'Admin',
+    async execute(interaction: any) {
+        const subcommand = interaction.options.getSubcommand();
+        const guildId = interaction.guildId;
+        const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.ModerateMembers);
+        const DB = interaction.client.DB;
+
+        if (subcommand === 'help') {
+            const embed = new EmbedBuilder()
+                .setTitle('TwitchMonitor Hilfe')
+                .setColor(0x9146ff)
+                .setDescription('Überwacht Twitch IRC-Chat für Moderations-Events.')
+                .addFields(
+                    { name: '/twitchmonitor add <twitch> <discord>', value: 'Kanal hinzufügen (Admin)', inline: false },
+                    { name: '/twitchmonitor remove <twitch>', value: 'Kanal entfernen (Admin)', inline: false },
+                    { name: '/twitchmonitor list', value: 'Alle überwachten Kanäle', inline: false }
+                )
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'list') {
+            const monitors: any[] = DB.all('SELECT * FROM twitch_monitor_channels WHERE guild_id = ? ORDER BY twitch_channel ASC', guildId);
+
+            if (monitors.length === 0) {
+                await interaction.reply({ content: 'Keine Twitch-Kanäle überwacht.', flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const embed = new EmbedBuilder()
+                .setTitle('TwitchMonitor Kanäle')
+                .setColor(0x9146ff)
+                .setDescription(monitors.map((m: any) =>
+                    `• **${m.twitch_channel}** → <#${m.discord_channel_id}>`
+                ).join('\n'))
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (!isAdmin) {
+            await interaction.reply({ content: 'Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'add') {
+            const twitchChannel = interaction.options.getString('twitch').toLowerCase().replace(/^@/, '');
+            const discordChannel = interaction.options.getChannel('discord');
+
+            const existing = DB.get('SELECT * FROM twitch_monitor_channels WHERE guild_id = ? AND twitch_channel = ?', guildId, twitchChannel);
+            if (existing) {
+                await interaction.reply({ content: `${twitchChannel} wird bereits überwacht.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            const webhook = await discordChannel.createWebhook({
+                name: `${twitchChannel} | Mod-Log`,
+                avatar: undefined,
+            }).catch(async () => {
+                const existing_webhook = await discordChannel.fetchWebhooks().then((webhooks: any) => 
+                    webhooks.find((w: any) => w.name?.includes(twitchChannel))
+                );
+                if (existing_webhook) return existing_webhook;
+                throw new Error('Could not create webhook');
+            });
+
+            DB.run(
+                'INSERT INTO twitch_monitor_channels (guild_id, twitch_channel, discord_channel_id, webhook_url) VALUES (?, ?, ?, ?)',
+                guildId,
+                twitchChannel,
+                discordChannel.id,
+                webhook.url
+            );
+
+            const monitor = TwitchMonitor.getInstance();
+            await monitor.addMonitor(guildId, twitchChannel, discordChannel.id, webhook.url);
+
+            await interaction.reply({ content: `${twitchChannel} wird jetzt überwacht.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'remove') {
+            const twitchChannel = interaction.options.getString('twitch').toLowerCase().replace(/^@/, '');
+
+            const monitor: any = DB.get('SELECT * FROM twitch_monitor_channels WHERE guild_id = ? AND twitch_channel = ?', guildId, twitchChannel);
+            if (!monitor) {
+                await interaction.reply({ content: `${twitchChannel} wird nicht überwacht.`, flags: [MessageFlags.Ephemeral] });
+                return;
+            }
+
+            DB.run('DELETE FROM twitch_monitor_channels WHERE guild_id = ? AND twitch_channel = ?', guildId, twitchChannel);
+
+            const twitchMonitor = TwitchMonitor.getInstance();
+            await twitchMonitor.removeMonitor(guildId, twitchChannel);
+
+            await interaction.reply({ content: `${twitchChannel} wurde entfernt.`, flags: [MessageFlags.Ephemeral] });
+        }
+    },
+};
+
+export default command;

src/commands/utility/welcome.ts

@@ -0,0 +1,158 @@
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, MessageFlags } from 'discord.js';
+import { Command } from '../../structures/Command.js';
+
+const command: Command = {
+    data: new SlashCommandBuilder()
+        .setName('welcome')
+        .setDescription('Willkommens- und Abschiedsnachrichten verwalten.')
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('setchannel')
+                .setDescription('Kanal für Willkommen/Abschied setzen (Mod).')
+                .addChannelOption(option =>
+                    option.setName('channel')
+                        .setDescription('Discord-Kanal')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('add')
+                .setDescription('Nachricht setzen (Mod).')
+                .addStringOption(option =>
+                    option.setName('type')
+                        .setDescription('Art der Nachricht')
+                        .setRequired(true)
+                        .addChoices(
+                            { name: 'Willkommen', value: 'welcome' },
+                            { name: 'Abschied', value: 'goodbye' }
+                        ))
+                .addStringOption(option =>
+                    option.setName('message')
+                        .setDescription('Die Nachricht. Variablen: {user}, {username}, {server}, {membercount}')
+                        .setRequired(true)))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('remove')
+                .setDescription('Nachricht entfernen (Mod).')
+                .addStringOption(option =>
+                    option.setName('type')
+                        .setDescription('Art der Nachricht')
+                        .setRequired(true)
+                        .addChoices(
+                            { name: 'Willkommen', value: 'welcome' },
+                            { name: 'Abschied', value: 'goodbye' }
+                        )))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('list')
+                .setDescription('Aktuelle Einstellungen anzeigen.'))
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('help')
+                .setDescription('Hilfe zu Welcome-Befehlen.')),
+    category: 'Admin',
+    async execute(interaction: any) {
+        const subcommand = interaction.options.getSubcommand();
+        const guildId = interaction.guildId;
+        const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.ModerateMembers);
+        const DB = interaction.client.DB;
+
+        // Ensure guild settings exist
+        DB.run('INSERT OR IGNORE INTO guild_settings (guild_id) VALUES (?)', guildId);
+
+        if (subcommand === 'help') {
+            const embed = new EmbedBuilder()
+                .setTitle('👋 Welcome Hilfe')
+                .setColor(0x2ecc71)
+                .setDescription('Begrüße neue Mitglieder oder verabschiede dich von ihnen.')
+                .addFields(
+                    { name: '`/welcome setchannel <#kanal>`', value: 'Setzt den Kanal für Willkommen/Abschied (Mod).\nStandard: Discord System-Channel.', inline: false },
+                    { name: '`/welcome add welcome <nachricht>`', value: 'Setzt die Willkommensnachricht (Mod).', inline: false },
+                    { name: '`/welcome add goodbye <nachricht>`', value: 'Setzt die Abschiedsnachricht (Mod).', inline: false },
+                    { name: '`/welcome remove welcome|goodbye`', value: 'Entfernt eine Nachricht (Mod).', inline: false },
+                    { name: '`/welcome list`', value: 'Zeigt aktuelle Einstellungen.', inline: false },
+                    { name: 'Variablen', value: '`{user}` - Nutzer erwähnen\n`{username}` - Nutzername\n`{server}` - Servername\n`{membercount}` - Mitgliederanzahl', inline: false },
+                    { name: 'Beispiel', value: '`/welcome add welcome Willkommen {user} auf {server}! Du bist der {membercount}. Nutzer.`', inline: false }
+                )
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'list') {
+            const settings: any = DB.get('SELECT * FROM guild_settings WHERE guild_id = ?', guildId);
+
+            const channel = settings?.welcome_channel
+                ? `<#${settings.welcome_channel}>`
+                : 'Nicht gesetzt';
+
+            const welcomeMsg = settings?.welcome_message || 'Nicht gesetzt';
+            const goodbyeMsg = settings?.goodbye_message || 'Nicht gesetzt';
+
+            const embed = new EmbedBuilder()
+                .setTitle('👋 Welcome Einstellungen')
+                .setColor(0x2ecc71)
+                .setDescription(`Server: **${interaction.guild.name}**`)
+                .addFields(
+                    { name: 'Kanal', value: channel, inline: true },
+                    { name: '👋 Willkommen', value: welcomeMsg, inline: false },
+                    { name: '👋 Abschied', value: goodbyeMsg, inline: false }
+                )
+                .setTimestamp();
+
+            await interaction.reply({ embeds: [embed], flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        // Admin only for modify commands
+        if (!isAdmin) {
+            await interaction.reply({ content: '❌ Keine Berechtigung. Moderatoren erforderlich.', flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'setchannel') {
+            const channel = interaction.options.getChannel('channel');
+
+            DB.run(
+                'UPDATE guild_settings SET welcome_channel = ? WHERE guild_id = ?',
+                channel.id,
+                guildId
+            );
+
+            await interaction.reply({ content: `✅ Kanal für Willkommen/Abschied auf ${channel} gesetzt.`, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'add') {
+            const type = interaction.options.getString('type') as 'welcome' | 'goodbye';
+            const message = interaction.options.getString('message')!;
+
+            const column = type === 'welcome' ? 'welcome_message' : 'goodbye_message';
+
+            DB.run(
+                `UPDATE guild_settings SET ${column} = ? WHERE guild_id = ?`,
+                message,
+                guildId
+            );
+
+            const label = type === 'welcome' ? 'Willkommensnachricht' : 'Abschiedsnachricht';
+            await interaction.reply({ content: `✅ ${label} gesetzt:\n\`\`\`\n${message}\n\`\`\``, flags: [MessageFlags.Ephemeral] });
+            return;
+        }
+
+        if (subcommand === 'remove') {
+            const type = interaction.options.getString('type') as 'welcome' | 'goodbye';
+            const column = type === 'welcome' ? 'welcome_message' : 'goodbye_message';
+
+            DB.run(
+                `UPDATE guild_settings SET ${column} = NULL WHERE guild_id = ?`,
+                guildId
+            );
+
+            const label = type === 'welcome' ? 'Willkommensnachricht' : 'Abschiedsnachricht';
+            await interaction.reply({ content: `✅ ${label} entfernt.`, flags: [MessageFlags.Ephemeral] });
+        }
+    },
+};
+
+export default command;

src/events/channelCreate.ts

@@ -0,0 +1,38 @@
+import { Events, GuildChannel, EmbedBuilder } from 'discord.js';
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+export default {
+    name: Events.ChannelCreate,
+    async execute(channel: GuildChannel) {
+        const embed = new EmbedBuilder()
+            .setTitle('📁 Channel erstellt')
+            .setColor(0x27ae60)
+            .addFields(
+                { name: 'Name', value: channel.name, inline: true },
+                { name: 'Typ', value: channel.type.toString(), inline: true }
+            )
+            .setTimestamp();
+
+        await sendLog(channel.client, channel.guild!.id, 'channels', embed);
+    },
+};

src/events/channelDelete.ts

@@ -0,0 +1,38 @@
+import { Events, GuildChannel, EmbedBuilder } from 'discord.js';
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+export default {
+    name: Events.ChannelDelete,
+    async execute(channel: GuildChannel) {
+        const embed = new EmbedBuilder()
+            .setTitle('📁 Channel gelöscht')
+            .setColor(0xe74c3c)
+            .addFields(
+                { name: 'Name', value: channel.name, inline: true },
+                { name: 'Typ', value: channel.type.toString(), inline: true }
+            )
+            .setTimestamp();
+
+        await sendLog(channel.client, channel.guild!.id, 'channels', embed);
+    },
+};

src/events/guildMemberAdd.ts

@@ -0,0 +1,34 @@
+import { Events, GuildMember, TextChannel, EmbedBuilder } from 'discord.js';
+
+export default {
+    name: Events.GuildMemberAdd,
+    async execute(member: GuildMember) {
+        const DB = (member.client as any).DB;
+        const guildId = member.guild.id;
+
+        const settings: any = DB.get('SELECT * FROM guild_settings WHERE guild_id = ?', guildId);
+
+        // Use custom channel or fall back to Discord's system channel
+        const channelId = settings?.welcome_channel || member.guild.systemChannelId;
+        if (!channelId || !settings?.welcome_message) {
+            return;
+        }
+
+        const channel = member.guild.channels.cache.get(channelId);
+        if (!channel || !channel.isTextBased()) {
+            return;
+        }
+
+        const message = settings.welcome_message
+            .replace(/{user}/g, `<@${member.id}>`)
+            .replace(/{username}/g, member.user.username)
+            .replace(/{server}/g, member.guild.name)
+            .replace(/{membercount}/g, member.guild.memberCount.toString());
+
+        try {
+            await (channel as TextChannel).send(message);
+        } catch (error) {
+            console.error('[WELCOME] Error sending welcome message:', error);
+        }
+    },
+};

src/events/guildMemberRemove.ts

@@ -0,0 +1,67 @@
+import { Events, GuildMember, TextChannel, EmbedBuilder } from 'discord.js';
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+export default {
+    name: Events.GuildMemberRemove,
+    async execute(member: GuildMember) {
+        const DB = (member.client as any).DB;
+        const guildId = member.guild.id;
+
+        // Log the leave event
+        const embed = new EmbedBuilder()
+            .setTitle('👋 User hat Server verlassen')
+            .setColor(0x95a5a6)
+            .addFields(
+                { name: 'User', value: `${member.user.tag} (<@${member.id}>)`, inline: true },
+                { name: 'Beitritt', value: member.joinedTimestamp ? `<t:${Math.floor(member.joinedTimestamp / 1000)}:R>` : 'Unbekannt', inline: true }
+            )
+            .setTimestamp();
+
+        await sendLog(member.client, guildId, 'leaves', embed);
+
+        // Send goodbye message if configured
+        const settings: any = DB.get('SELECT * FROM guild_settings WHERE guild_id = ?', guildId);
+
+        const channelId = settings?.welcome_channel || member.guild.systemChannelId;
+        if (!channelId || !settings?.goodbye_message) {
+            return;
+        }
+
+        const channel = member.guild.channels.cache.get(channelId);
+        if (!channel || !channel.isTextBased()) {
+            return;
+        }
+
+        const message = settings.goodbye_message
+            .replace(/{user}/g, `<@${member.id}>`)
+            .replace(/{username}/g, member.user.username)
+            .replace(/{server}/g, member.guild.name)
+            .replace(/{membercount}/g, member.guild.memberCount.toString());
+
+        try {
+            await (channel as TextChannel).send(message);
+        } catch (error) {
+            console.error('[WELCOME] Error sending goodbye message:', error);
+        }
+    },
+};

src/events/guildMemberUpdate.ts

@@ -0,0 +1,80 @@
+import { Events, GuildMember, EmbedBuilder } from 'discord.js';
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+// Guild Member Update (nickname + roles)
+export default {
+    name: Events.GuildMemberUpdate,
+    async execute(oldMember: GuildMember, newMember: GuildMember) {
+        const guildId = newMember.guild.id;
+
+        // Nickname change
+        if (oldMember.nickname !== newMember.nickname) {
+            const embed = new EmbedBuilder()
+                .setTitle('📝 Nickname geändert')
+                .setColor(0x3498db)
+                .addFields(
+                    { name: 'Nutzer', value: `${newMember.user.tag} (<@${newMember.id}>)`, inline: true }
+                )
+                .addFields(
+                    { name: 'Vorher', value: oldMember.nickname || newMember.user.username, inline: true },
+                    { name: 'Nachher', value: newMember.nickname || newMember.user.username, inline: true }
+                )
+                .setTimestamp();
+
+            await sendLog(newMember.client, guildId, 'nicks', embed);
+        }
+
+        // Role changes
+        const oldRoles = oldMember.roles.cache;
+        const newRoles = newMember.roles.cache;
+
+        const addedRoles = newRoles.filter(r => !oldRoles.has(r.id));
+        const removedRoles = oldRoles.filter(r => !newRoles.has(r.id));
+
+        for (const role of addedRoles) {
+            const embed = new EmbedBuilder()
+                .setTitle('🎭 Rolle hinzugefügt')
+                .setColor(0x27ae60)
+                .addFields(
+                    { name: 'Nutzer', value: `${newMember.user.tag} (<@${newMember.id}>)`, inline: true },
+                    { name: 'Rolle', value: `${role[1].name} (<@&${role[1].id}>)`, inline: true }
+                )
+                .setTimestamp();
+
+            await sendLog(newMember.client, guildId, 'roles', embed);
+        }
+
+        for (const role of removedRoles) {
+            const embed = new EmbedBuilder()
+                .setTitle('🎭 Rolle entfernt')
+                .setColor(0xe74c3c)
+                .addFields(
+                    { name: 'Nutzer', value: `${newMember.user.tag} (<@${newMember.id}>)`, inline: true },
+                    { name: 'Rolle', value: `${role[1].name} (<@&${role[1].id}>)`, inline: true }
+                )
+                .setTimestamp();
+
+            await sendLog(newMember.client, guildId, 'roles', embed);
+        }
+    },
+};

src/events/interactionCreate.ts

@@ -1,8 +1,109 @@
-import { Events, MessageFlags } from 'discord.js';
+import { Events, MessageFlags, ComponentType } from 'discord.js';
 
 export default {
     name: Events.InteractionCreate,
     async execute(interaction: any, client: any) {
+        if (interaction.isStringSelectMenu()) {
+            const customId = interaction.customId;
+
+            if (customId.startsWith('role_select_')) {
+                const categoryName = customId.replace('role_select_', '');
+                const selectedValue = interaction.values[0];
+                const member = interaction.member;
+                const guild = interaction.guild;
+
+                const category: any = client.DB.get(
+                    'SELECT * FROM role_categories WHERE guild_id = ? AND category_name = ?',
+                    guild.id,
+                    categoryName
+                );
+
+                if (!category) {
+                    await interaction.reply({ content: 'Kategorie nicht gefunden.', flags: [MessageFlags.Ephemeral] });
+                    return;
+                }
+
+                if (selectedValue.startsWith('remove_')) {
+                    const options: any[] = client.DB.all('SELECT * FROM role_options WHERE category_id = ?', category.id);
+                    let removedCount = 0;
+                    for (const opt of options) {
+                        if (member.roles.cache.has(opt.role_id)) {
+                            await member.roles.remove(opt.role_id);
+                            removedCount++;
+                        }
+                    }
+                    if (removedCount > 0) {
+                        await interaction.reply({
+                            content: `Alle Rollen aus "${categoryName}" wurden entfernt.`,
+                            flags: [MessageFlags.Ephemeral]
+                        });
+                    } else {
+                        await interaction.reply({
+                            content: `Du hast keine Rollen aus "${categoryName}".`,
+                            flags: [MessageFlags.Ephemeral]
+                        });
+                    }
+                    return;
+                }
+
+                const option: any = client.DB.get(
+                    'SELECT * FROM role_options WHERE category_id = ? AND role_id = ?',
+                    category.id,
+                    selectedValue
+                );
+
+                if (!option) {
+                    await interaction.reply({ content: 'Rolle nicht gefunden.', flags: [MessageFlags.Ephemeral] });
+                    return;
+                }
+
+                const discordRole = guild.roles.cache.get(selectedValue);
+                if (!discordRole) {
+                    await interaction.reply({ content: 'Diese Rolle existiert nicht mehr.', flags: [MessageFlags.Ephemeral] });
+                    return;
+                }
+
+                const hasRole = member.roles.cache.has(selectedValue);
+
+                if (category.exclusive) {
+                    const options: any[] = client.DB.all('SELECT * FROM role_options WHERE category_id = ?', category.id);
+                    for (const opt of options) {
+                        if (opt.role_id !== selectedValue && member.roles.cache.has(opt.role_id)) {
+                            await member.roles.remove(opt.role_id);
+                        }
+                    }
+                    await member.roles.add(selectedValue);
+                    await interaction.reply({
+                        content: `Du hast jetzt die Rolle ${option.emoji ? option.emoji + ' ' : ''}${discordRole.name}!`,
+                        flags: [MessageFlags.Ephemeral]
+                    });
+                } else {
+                    if (hasRole) {
+                        await member.roles.remove(selectedValue);
+                        await interaction.reply({
+                            content: `Die Rolle ${option.emoji ? option.emoji + ' ' : ''}${discordRole.name} wurde entfernt.`,
+                            flags: [MessageFlags.Ephemeral]
+                        });
+                    } else {
+                        const userRoles = member.roles.cache.filter((r: any) => !r.managed && r.id !== guild.id).size;
+                        if (category.max_roles > 0 && userRoles >= category.max_roles) {
+                            await interaction.reply({
+                                content: `Du kannst maximal ${category.max_roles} Rollen aus dieser Kategorie haben.`,
+                                flags: [MessageFlags.Ephemeral]
+                            });
+                            return;
+                        }
+                        await member.roles.add(selectedValue);
+                        await interaction.reply({
+                            content: `Du hast jetzt die Rolle ${option.emoji ? option.emoji + ' ' : ''}${discordRole.name}!`,
+                            flags: [MessageFlags.Ephemeral]
+                        });
+                    }
+                }
+                return;
+            }
+        }
+
         if (!interaction.isChatInputCommand()) return;
 
         const command = client.commands.get(interaction.commandName);

src/events/messageCreate.ts

@@ -0,0 +1,23 @@
+import { Events } from 'discord.js';
+
+export default {
+    name: Events.MessageCreate,
+    async execute(message: any, client: any) {
+        if (message.author.bot) return;
+        if (!message.guildId) return;
+
+        const triggers: any[] = client.DB.all(
+            'SELECT * FROM auto_responses WHERE guild_id = ?',
+            message.guildId
+        );
+
+        const contentLower = message.content.toLowerCase();
+
+        for (const trigger of triggers) {
+            if (contentLower.includes(trigger.trigger_word.toLowerCase())) {
+                await message.channel.send(trigger.response_text);
+                return;
+            }
+        }
+    },
+};

src/events/messageDelete.ts

@@ -0,0 +1,73 @@
+import { Events, Message, TextChannel, GuildChannel, AuditLogEvent, EmbedBuilder } from 'discord.js';
+
+function getLogChannel(client: any, guildId: string): TextChannel | null {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT * FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_channel) {
+        return null;
+    }
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(settings.log_channel);
+    if (!channel || !channel.isTextBased()) {
+        return null;
+    }
+
+    return channel as TextChannel;
+}
+
+function isEventEnabled(client: any, guildId: string, event: string): boolean {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) {
+        return false;
+    }
+
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    return activeEvents.includes(event);
+}
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    if (!isEventEnabled(client, guildId, event)) {
+        return;
+    }
+
+    const channel = getLogChannel(client, guildId);
+    if (!channel) {
+        return;
+    }
+
+    try {
+        await channel.send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+// Message Delete
+export default {
+    name: Events.MessageDelete,
+    async execute(message: Message) {
+        if (!message.guild || message.author.bot) return;
+
+        const embed = new EmbedBuilder()
+            .setTitle('🗑️ Nachricht gelöscht')
+            .setColor(0xe74c3c)
+            .addFields(
+                { name: 'Autor', value: `${message.author.tag} (<@${message.author.id}>)`, inline: true },
+                { name: 'Kanal', value: `<#${message.channelId}>`, inline: true }
+            )
+            .setTimestamp();
+
+        if (message.content) {
+            embed.addFields({ name: 'Inhalt', value: message.content.substring(0, 1024), inline: false });
+        }
+
+        if (message.attachments.size > 0) {
+            embed.addFields({ name: 'Anhänge', value: `${message.attachments.size} Datei(en)`, inline: true });
+        }
+
+        await sendLog(message.client, message.guildId!, 'messages', embed);
+    },
+};

src/events/messageUpdate.ts

@@ -0,0 +1,47 @@
+import { Events, Message, EmbedBuilder } from 'discord.js';
+
+async function sendLog(client: any, guildId: string, event: string, embed: EmbedBuilder) {
+    const DB = client.DB;
+    const settings: any = DB.get('SELECT log_events FROM guild_settings WHERE guild_id = ?', guildId);
+
+    if (!settings?.log_events) return;
+    const activeEvents = settings.log_events.split(',').filter(Boolean);
+    if (!activeEvents.includes(event)) return;
+
+    const logSettings: any = DB.get('SELECT log_channel FROM guild_settings WHERE guild_id = ?', guildId);
+    if (!logSettings?.log_channel) return;
+
+    const channel = client.guilds.cache.get(guildId)?.channels.cache.get(logSettings.log_channel);
+    if (!channel || !channel.isTextBased()) return;
+
+    try {
+        await (channel as any).send({ embeds: [embed] });
+    } catch (error) {
+        console.error(`[LOG] Error sending log (${event}):`, error);
+    }
+}
+
+// Message Update (Edit)
+export default {
+    name: Events.MessageUpdate,
+    async execute(oldMessage: Message, newMessage: Message) {
+        if (!newMessage.guild || newMessage.author?.bot) return;
+        if (!oldMessage.content || !newMessage.content) return;
+        if (oldMessage.content === newMessage.content) return;
+
+        const embed = new EmbedBuilder()
+            .setTitle('✏️ Nachricht editiert')
+            .setColor(0xf39c12)
+            .addFields(
+                { name: 'Autor', value: `${newMessage.author.tag} (<@${newMessage.author.id}>)`, inline: true },
+                { name: 'Kanal', value: `<#${newMessage.channelId}>`, inline: true }
+            )
+            .addFields(
+                { name: 'Vorher', value: oldMessage.content.substring(0, 1024), inline: false },
+                { name: 'Nachher', value: newMessage.content.substring(0, 1024), inline: false }
+            )
+            .setTimestamp();
+
+        await sendLog(newMessage.client, newMessage.guildId!, 'messages', embed);
+    },
+};

src/events/ready.ts

@@ -1,10 +1,76 @@
 import { Events } from 'discord.js';
+import { TwitchMonitor } from '../structures/TwitchMonitor.js';
+
+async function validateRoles(client: any) {
+    const categories: any[] = client.DB.all('SELECT * FROM role_categories');
+    let removedCount = 0;
+
+    for (const category of categories) {
+        const guild = client.guilds.cache.get(category.guild_id);
+        if (!guild) continue;
+
+        const options: any[] = client.DB.all('SELECT * FROM role_options WHERE category_id = ?', category.id);
+        const validOptions: any[] = [];
+
+        for (const option of options) {
+            const roleExists = guild.roles.cache.has(option.role_id);
+            if (roleExists) {
+                validOptions.push(option);
+            } else {
+                if (category.remove_on_delete) {
+                    const members = guild.members.cache.filter((m: any) => m.roles.cache.has(option.role_id));
+                    for (const member of members.values()) {
+                        await member.roles.remove(option.role_id);
+                    }
+                }
+                removedCount++;
+            }
+        }
+
+        if (validOptions.length === 0 && options.length > 0) {
+            console.log(`[ROLESETUP] Category "${category.category_name}" has no valid roles left. Consider deleting it.`);
+        }
+    }
+
+    if (removedCount > 0) {
+        console.log(`[ROLESETUP] Removed ${removedCount} invalid role options from database.`);
+    }
+}
+
+async function initTwitchMonitor(client: any) {
+    if (!process.env.TWITCH_OAUTH_TOKEN || !process.env.TWITCH_USERNAME) {
+        console.warn('[TWITCH] Missing TWITCH_OAUTH_TOKEN or TWITCH_USERNAME - moderation events will not be received');
+        return;
+    }
+
+    const monitors: any[] = client.DB.all('SELECT * FROM twitch_monitor_channels');
+
+    if (monitors.length === 0) {
+        console.log('[TWITCH] No channels to monitor.');
+        return;
+    }
+
+    const monitor = TwitchMonitor.getInstance();
+    monitor.setDiscordClient(client);
+
+    for (const m of monitors) {
+        const webhookExists = m.webhook_url && m.webhook_url.length > 0;
+        if (webhookExists) {
+            await monitor.addMonitor(m.guild_id, m.twitch_channel, m.discord_channel_id, m.webhook_url);
+        }
+    }
+
+    await monitor.connect();
+}
 
 export default {
     name: Events.ClientReady,
     once: true,
-    execute(client: any) {
+    async execute(client: any) {
         console.log(`[READY] Logged in as ${client.user.tag}`);
         console.log(`[READY] Serving ${client.guilds.cache.size} servers`);
+
+        await validateRoles(client);
+        await initTwitchMonitor(client);
     },
 };

src/structures/Database.ts

@@ -25,6 +25,10 @@ export class DB {
                 prefix TEXT DEFAULT '!',
                 mod_log_channel TEXT,
                 welcome_channel TEXT,
+                welcome_message TEXT,
+                goodbye_message TEXT,
+                log_channel TEXT,
+                log_events TEXT DEFAULT 'messages,roles,nicks,channels,moderation',
                 warn_threshold INTEGER DEFAULT 3,
                 warn_action TEXT DEFAULT 'ban',
                 warn_mute_duration INTEGER DEFAULT 1800
@@ -61,7 +65,7 @@ export class DB {
             )
         `).run();
 
-        // Twitch Monitors
+        // Twitch Monitors (Stream notifications)
         db.prepare(`
             CREATE TABLE IF NOT EXISTS twitch_monitors (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -75,6 +79,18 @@ export class DB {
             )
         `).run();
 
+        // Twitch Monitor Channels (IRC chat logging)
+        db.prepare(`
+            CREATE TABLE IF NOT EXISTS twitch_monitor_channels (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                guild_id TEXT NOT NULL,
+                twitch_channel TEXT NOT NULL,
+                discord_channel_id TEXT NOT NULL,
+                webhook_url TEXT,
+                UNIQUE(guild_id, twitch_channel)
+            )
+        `).run();
+
         // Auto Responses
         db.prepare(`
             CREATE TABLE IF NOT EXISTS auto_responses (
@@ -99,6 +115,51 @@ export class DB {
             )
         `).run();
 
+        // Role Categories
+        db.prepare(`
+            CREATE TABLE IF NOT EXISTS role_categories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                guild_id TEXT NOT NULL,
+                channel_id TEXT NOT NULL,
+                message_id TEXT NOT NULL,
+                category_name TEXT NOT NULL,
+                max_roles INTEGER DEFAULT 0,
+                exclusive BOOLEAN DEFAULT 0,
+                remove_on_delete BOOLEAN DEFAULT 0,
+                UNIQUE(guild_id, category_name)
+            )
+        `).run();
+
+        // Role Options
+        db.prepare(`
+            CREATE TABLE IF NOT EXISTS role_options (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                category_id INTEGER NOT NULL,
+                label TEXT NOT NULL,
+                emoji TEXT,
+                role_id TEXT NOT NULL,
+                UNIQUE(category_id, role_id),
+                FOREIGN KEY (category_id) REFERENCES role_categories(id) ON DELETE CASCADE
+            )
+        `).run();
+
+        // Migration: Add missing columns to existing guild_settings
+        const columns = db.prepare("PRAGMA table_info(guild_settings)").all() as any[];
+        const columnNames = columns.map((c: any) => c.name);
+
+        if (!columnNames.includes('welcome_message')) {
+            db.prepare('ALTER TABLE guild_settings ADD COLUMN welcome_message TEXT').run();
+        }
+        if (!columnNames.includes('goodbye_message')) {
+            db.prepare('ALTER TABLE guild_settings ADD COLUMN goodbye_message TEXT').run();
+        }
+        if (!columnNames.includes('log_channel')) {
+            db.prepare('ALTER TABLE guild_settings ADD COLUMN log_channel TEXT').run();
+        }
+        if (!columnNames.includes('log_events')) {
+            db.prepare('ALTER TABLE guild_settings ADD COLUMN log_events TEXT DEFAULT \'messages,roles,nicks,channels,leaves,warns,mutes,kicks,bans\'').run();
+        }
+
         console.log('[DATABASE] Initialization complete.');
     }
 

src/structures/TwitchCache.ts

@@ -0,0 +1,41 @@
+export interface ChatMessage {
+    channel: string;
+    user: string;
+    text: string;
+    timestamp: number;
+    msgId: string;
+}
+
+export class TwitchCache {
+    private buffer: ChatMessage[] = [];
+    private maxSize: number;
+
+    constructor(maxSize: number = 1000) {
+        this.maxSize = maxSize;
+    }
+
+    push(msg: ChatMessage): void {
+        if (this.buffer.length >= this.maxSize) {
+            this.buffer.shift();
+        }
+        this.buffer.push(msg);
+    }
+
+    getLastN(user: string, channel: string, n: number): ChatMessage[] {
+        return this.buffer
+            .filter(m => m.user.toLowerCase() === user.toLowerCase() && m.channel === channel)
+            .slice(-n);
+    }
+
+    getByMsgId(msgId: string): ChatMessage | undefined {
+        return this.buffer.find(m => m.msgId === msgId);
+    }
+
+    clear(): void {
+        this.buffer = [];
+    }
+
+    get size(): number {
+        return this.buffer.length;
+    }
+}

src/structures/TwitchMonitor.ts

@@ -0,0 +1,307 @@
+import tmi, { Client, ChatUserstate, DeleteUserstate, SubMethods, SubUserstate } from 'tmi.js';
+import { EmbedBuilder, WebhookClient } from 'discord.js';
+import { TwitchCache, ChatMessage } from './TwitchCache.js';
+
+const MOD_ICON = 'https://static-cdn.jtvnw.net/jtv_user_pictures/a736384e-8a1d-40ed-8a7a-808a23a15476-profile_image-300x300.png';
+const TOKEN_CHECK_INTERVAL = 5 * 60 * 1000;
+const TOKEN_CHECK_MAX_FAILURES = 3;
+const TOKEN_CHECK_RETRY_DELAY = 30 * 1000;
+
+interface MonitorChannel {
+    guildId: string;
+    twitchChannel: string;
+    discordChannelId: string;
+    webhookUrl: string;
+}
+
+export class TwitchMonitor {
+    private static instance: TwitchMonitor | null = null;
+    private client: Client | null = null;
+    private cache: TwitchCache;
+    private monitors: Map<string, MonitorChannel> = new Map();
+    private webhookClients: Map<string, WebhookClient> = new Map();
+    private tokenFailureCount = 0;
+    private tokenCheckInterval: NodeJS.Timeout | null = null;
+    private isTokenInvalid = false;
+
+    private constructor() {
+        this.cache = new TwitchCache(1000);
+    }
+
+    static getInstance(): TwitchMonitor {
+        if (!TwitchMonitor.instance) {
+            TwitchMonitor.instance = new TwitchMonitor();
+        }
+        return TwitchMonitor.instance;
+    }
+
+    private getOAuthToken(): string {
+        const token = process.env.TWITCH_OAUTH_TOKEN || '';
+        return token.startsWith('oauth:') ? token : 'oauth:' + token;
+    }
+
+    private async notifyOwner(message: string): Promise<void> {
+        const ownerId = process.env.BOT_OWNER_ID;
+        if (!ownerId) return;
+
+        try {
+            const { Client: DiscordClient } = await import('discord.js');
+            const client = TwitchMonitor.getInstance();
+            const discordClient = (client as any).discordClient;
+            if (!discordClient) return;
+
+            const owner = await discordClient.users.fetch(ownerId).catch(() => null);
+            if (owner) {
+                await owner.send(`⚠️ **TwitchMonitor Warning**\n${message}`);
+            }
+        } catch (error) {
+            console.error('[TWITCH] Failed to notify owner:', error);
+        }
+    }
+
+    private startTokenValidation(): void {
+        this.tokenCheckInterval = setInterval(async () => {
+            if (this.isTokenInvalid) return;
+
+            const isConnected = this.client?.readyState() === 'OPEN';
+            
+            if (!isConnected) {
+                this.tokenFailureCount++;
+                console.warn(`[TWITCH] Connection check failed (${this.tokenFailureCount}/${TOKEN_CHECK_MAX_FAILURES})`);
+                
+                if (this.tokenFailureCount >= TOKEN_CHECK_MAX_FAILURES) {
+                    this.isTokenInvalid = true;
+                    console.error('[TWITCH] Token validation failed - stopping monitoring');
+                    this.notifyOwner('TwitchMonitor Token ungültig. Bitte neuen Token holen: https://chatterino.com/client_login');
+                    this.stopTokenValidation();
+                    this.disconnect();
+                } else {
+                    await new Promise(resolve => setTimeout(resolve, TOKEN_CHECK_RETRY_DELAY));
+                }
+            } else {
+                this.tokenFailureCount = 0;
+            }
+        }, TOKEN_CHECK_INTERVAL);
+    }
+
+    private stopTokenValidation(): void {
+        if (this.tokenCheckInterval) {
+            clearInterval(this.tokenCheckInterval);
+            this.tokenCheckInterval = null;
+        }
+    }
+
+    async connect(): Promise<void> {
+        if (this.client) return;
+
+        const channels = Array.from(this.monitors.values()).map(m => m.twitchChannel);
+
+        this.client = new Client({
+            options: {
+                debug: false,
+            },
+            identity: {
+                username: process.env.TWITCH_USERNAME,
+                password: this.getOAuthToken(),
+            },
+            channels: channels,
+        });
+
+        this.client.on('message', (channel: string, userstate: ChatUserstate, text: string, self: boolean) => {
+            if (self) return;
+            this.cache.push({
+                channel,
+                user: userstate['display-name'] || userstate.username || 'unknown',
+                text,
+                timestamp: Date.now(),
+                msgId: userstate.id || '',
+            });
+        });
+
+        this.client.on('messagedeleted', (channel: string, username: string, deletedMessage: string, userstate: DeleteUserstate) => {
+            const msgId = userstate['target-msg-id'] || '';
+            const cached = this.cache.getByMsgId(msgId);
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '🗑️ Nachricht gelöscht',
+                description: `**${username}** hat eine Nachricht gelöscht.\n\n${cached ? `~~${cached.text}~~` : `(Nachricht nicht im Cache)`}`,
+                color: 0xff0000,
+            });
+        });
+
+        this.client.on('ban', (channel: string, username: string, reason: string) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            const lastMessages = this.cache.getLastN(username, channel, 5);
+            const context = lastMessages.length > 0
+                ? `\n\n**Letzte Nachrichten:**\n${lastMessages.map(m => `• ${m.text}`).join('\n')}`
+                : '';
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '🔨 User gebannt',
+                description: `**${username}** wurde gebannt.\n${reason ? `Grund: *${reason}*` : ''}${context}`,
+                color: 0x8b0000,
+            });
+        });
+
+        this.client.on('timeout', (channel: string, username: string, reason: string) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '⏱️ User getimeouted',
+                description: `**${username}** wurde getimeouted.\n${reason ? `Grund: *${reason}*` : ''}`,
+                color: 0xffa500,
+            });
+        });
+
+        this.client.on('clearchat', (channel: string) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '🧹 Chat geleert',
+                description: `Der Chat in **${channel}** wurde geleert.`,
+                color: 0xffa500,
+            });
+        });
+
+        this.client.on('cheer', (channel: string, userstate: ChatUserstate, message: string) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            const amount = userstate.bits || 0;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '💰 Bit-Cheer',
+                description: `**${userstate['display-name'] || userstate.username}** hat ${amount} Bits gespendet!\n${message || ''}`,
+                color: 0x9b59b6,
+            });
+        });
+
+        this.client.on('subscription', (channel: string, username: string, methods: SubMethods, message: string, userstate: SubUserstate) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '🅿️ Subscription',
+                description: `**${username}** hat subscribed!${methods?.prime ? ' (Prime)' : ''}${message ? `\nNachricht: ${message}` : ''}`,
+                color: 0x9146ff,
+            });
+        });
+
+        this.client.on('resub', (channel: string, username: string, months: number, message: string, userstate: SubUserstate, methods: SubMethods) => {
+            const monitor = this.findMonitor(channel);
+            if (!monitor) return;
+
+            this.sendWebhook(monitor.webhookUrl, {
+                title: '🅿️ Resubscription',
+                description: `**${username}** resubbed für ${months} Monate!${methods?.prime ? ' (Prime)' : ''}\n${message || ''}`,
+                color: 0x9146ff,
+            });
+        });
+
+        this.client.on('disconnected', async () => {
+            console.warn('[TWITCH] Disconnected from IRC');
+            if (!this.isTokenInvalid) {
+                this.tokenFailureCount++;
+            }
+        });
+
+        this.client.on('reconnect', () => {
+            console.log('[TWITCH] Attempting to reconnect...');
+        });
+
+        try {
+            await this.client.connect();
+            console.log('[TWITCH] Monitor connected to IRC');
+            this.tokenFailureCount = 0;
+            this.startTokenValidation();
+        } catch (error) {
+            console.error('[TWITCH] Failed to connect:', error);
+            this.isTokenInvalid = true;
+            this.notifyOwner('TwitchMonitor: Verbindung fehlgeschlagen. Token prüfen.');
+        }
+    }
+
+    setDiscordClient(discordClient: any): void {
+        (this as any).discordClient = discordClient;
+    }
+
+    private findMonitor(channel: string): MonitorChannel | undefined {
+        const normalizedChannel = channel.startsWith('#') ? channel : `#${channel}`;
+        return Array.from(this.monitors.values()).find(
+            m => m.twitchChannel.toLowerCase() === normalizedChannel.toLowerCase() ||
+                 m.twitchChannel.toLowerCase() === channel.toLowerCase()
+        );
+    }
+
+    async addMonitor(guildId: string, twitchChannel: string, discordChannelId: string, webhookUrl: string): Promise<void> {
+        const normalizedChannel = twitchChannel.startsWith('#') ? twitchChannel : `#${twitchChannel}`;
+        const key = `${guildId}:${normalizedChannel}`;
+
+        this.monitors.set(key, {
+            guildId,
+            twitchChannel: normalizedChannel,
+            discordChannelId,
+            webhookUrl,
+        });
+
+        this.webhookClients.set(key, new WebhookClient({ url: webhookUrl }));
+
+        if (this.client) {
+            await this.client.join(normalizedChannel);
+        }
+    }
+
+    async removeMonitor(guildId: string, twitchChannel: string): Promise<void> {
+        const normalizedChannel = twitchChannel.startsWith('#') ? twitchChannel : `#${twitchChannel}`;
+        const key = `${guildId}:${normalizedChannel}`;
+        const monitor = this.monitors.get(key);
+
+        if (monitor && this.client) {
+            await this.client.part(normalizedChannel);
+        }
+
+        this.monitors.delete(key);
+        this.webhookClients.delete(key);
+    }
+
+    getMonitors(guildId?: string): MonitorChannel[] {
+        if (guildId) {
+            return Array.from(this.monitors.values()).filter(m => m.guildId === guildId);
+        }
+        return Array.from(this.monitors.values());
+    }
+
+    private async sendWebhook(webhookUrl: string, data: { title: string; description: string; color: number }): Promise<void> {
+        try {
+            const webhook = new WebhookClient({ url: webhookUrl });
+            const embed = new EmbedBuilder()
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setColor(data.color)
+                .setThumbnail(MOD_ICON)
+                .setTimestamp();
+
+            await webhook.send({ embeds: [embed] });
+        } catch (error) {
+            console.error('[TWITCH] Webhook send error:', error);
+        }
+    }
+
+    disconnect(): void {
+        this.stopTokenValidation();
+        if (this.client) {
+            this.client.disconnect();
+            this.client = null;
+        }
+        this.monitors.clear();
+        this.webhookClients.clear();
+        this.tokenFailureCount = 0;
+        this.isTokenInvalid = false;
+    }
+}