AutoMod sichtbar machen: Treffer ins Protokoll, Regeln ins Panel

Discords eigener Filter arbeitet serverseitig und ohne Latenz — daran ist
nichts zu verbessern. Was fehlte, war die Sicht darauf: Treffer landeten nur
in Discords eigenem Kanal, und die Regeln pflegte man in einer ganz anderen
Oberflaeche als alles andere.

Jetzt spiegelt der Bot jeden Treffer als Embed ins Mod-Log — mit Nutzer,
Regel, Ausloeser, Massnahme, getroffenem Wort und gekuerztem Wortlaut, ohne
Erwaehnungen, die den Kanal anpingen. Im Panel steht unter Support jede Regel
mit Ausloeser, Massnahmen und der Zahl ausgenommener Rollen und Kanaele —
letzteres oft der Grund, warum eine Regel scheinbar nicht greift. Schalten
geht dort direkt.

Das Bearbeiten der Wortlisten bleibt bewusst in Discord; dort ist es gut
geloest, und ein zweiter Ort dafuer waere nur eine weitere Stelle, an der
etwas auseinanderlaeuft.

Dazu noetig: der Gateway-Intent AutoModerationExecution. Nicht privilegiert,
aber Discord schickt die Ereignisse nur an Bots mit "Server verwalten" —
fehlt das Recht, sagt das Panel es statt still leer zu bleiben.

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

src/bot/automod.js

@@ -0,0 +1,132 @@
+// AutoMod: Discords eigener Filter, sichtbar gemacht.
+//
+// Bewusst kein eigener Wortfilter. Discord filtert serverseitig, ohne Latenz
+// und ohne dass eine Nachricht erst bei uns ankommen muss — das kann kein Bot
+// besser. Was fehlt, ist die Sicht darauf: Treffer landen nur in Discords
+// eigenem Kanal, und die Regeln pflegt man in einer anderen Oberfläche als
+// alles andere.
+//
+// Deshalb hier zweierlei: Treffer ins Mod-Log spiegeln, und die Regeln im
+// Panel anzeigen und an-/abschalten. Das Bearbeiten der Wortlisten bleibt in
+// Discord — dort ist es gut gelöst.
+import { Events } from 'discord.js';
+import {
+    AutoModerationRuleTriggerType as Trigger,
+    AutoModerationActionType as Aktion,
+    AutoModerationRuleKeywordPresetType as Preset,
+} from 'discord.js';
+import { moduleEnabled } from '../modules.js';
+import { modlogChannelId } from '../runtime-settings.js';
+import { brandEmbed } from '../embeds.js';
+
+const AUSLOESER = {
+    [Trigger.Keyword]: 'Eigene Wörter',
+    [Trigger.Spam]: 'Spam-Erkennung',
+    [Trigger.KeywordPreset]: 'Discords Wortlisten',
+    [Trigger.MentionSpam]: 'Erwähnungs-Spam',
+    [Trigger.MemberProfile]: 'Profil-Inhalte',
+};
+
+const AKTIONEN = {
+    [Aktion.BlockMessage]: 'Nachricht blockiert',
+    [Aktion.SendAlertMessage]: 'Meldung an Team',
+    [Aktion.Timeout]: 'Auszeit',
+    [Aktion.BlockMemberInteraction]: 'Interaktion blockiert',
+};
+
+const PRESETS = {
+    [Preset.Profanity]: 'Schimpfwörter',
+    [Preset.SexualContent]: 'Sexuelle Inhalte',
+    [Preset.Slurs]: 'Beleidigungen',
+};
+
+const zaehl = (n, eins, viele) => `${n} ${n === 1 ? eins : viele}`;
+
+/** Eine Regel so beschreiben, dass man sie ohne Discord-Vorwissen versteht */
+export function regelBeschreiben(regel) {
+    const md = regel.triggerMetadata ?? {};
+    const details = [];
+    if (md.keywordFilter?.length) details.push(zaehl(md.keywordFilter.length, 'Wort', 'Wörter'));
+    if (md.regexPatterns?.length) details.push(zaehl(md.regexPatterns.length, 'Muster', 'Muster'));
+    if (md.presets?.length) details.push(md.presets.map((p) => PRESETS[p] ?? p).join(', '));
+    if (md.mentionTotalLimit) details.push(`ab ${md.mentionTotalLimit} Erwähnungen`);
+    if (md.allowList?.length) details.push(zaehl(md.allowList.length, 'erlaubtes Wort', 'erlaubte Wörter'));
+
+    return {
+        id: regel.id,
+        name: regel.name,
+        aktiv: regel.enabled,
+        ausloeser: AUSLOESER[regel.triggerType] ?? `Typ ${regel.triggerType}`,
+        details,
+        aktionen: (regel.actions ?? []).map((a) => AKTIONEN[a.type] ?? `Typ ${a.type}`),
+        // Rollen und Kanäle, die ausgenommen sind — oft der Grund, warum eine
+        // Regel scheinbar nicht greift
+        ausnahmen: {
+            rollen: regel.exemptRoles?.size ?? 0,
+            kanaele: regel.exemptChannels?.size ?? 0,
+        },
+    };
+}
+
+/** Alle Regeln der Guild holen — leer, wenn keine Guild oder keine Rechte */
+export async function listRules(client, guildId) {
+    const guild = guildId ? client.guilds.cache.get(guildId) : client.guilds.cache.first();
+    if (!guild) return { ok: false, grund: 'Kein Server verbunden', regeln: [] };
+    try {
+        const regeln = await guild.autoModerationRules.fetch();
+        return { ok: true, regeln: [...regeln.values()].map(regelBeschreiben) };
+    } catch (error) {
+        // Häufigster Fall: dem Bot fehlt „Server verwalten"
+        return { ok: false, grund: error.message, regeln: [] };
+    }
+}
+
+/** Regel an- oder abschalten */
+export async function setRuleEnabled(client, guildId, ruleId, aktiv, durch) {
+    const guild = guildId ? client.guilds.cache.get(guildId) : client.guilds.cache.first();
+    if (!guild) throw new Error('Kein Server verbunden');
+    const regel = await guild.autoModerationRules.fetch(ruleId);
+    await regel.edit({ enabled: Boolean(aktiv), reason: `Über das Panel durch ${durch}` });
+    return regelBeschreiben(await guild.autoModerationRules.fetch(ruleId));
+}
+
+export function registerAutoMod(client) {
+    client.on(Events.AutoModerationActionExecution, async (treffer) => {
+        try {
+            if (!moduleEnabled('automod')) return;
+            const channelId = modlogChannelId();
+            if (!channelId) return;
+            const channel = await client.channels.fetch(channelId).catch(() => null);
+            if (!channel?.isTextBased()) return;
+
+            const regelName = treffer.autoModerationRule?.name ?? `Regel ${treffer.ruleId}`;
+            const embed = brandEmbed(client, 'AUTOMOD', { secondary: true })
+                .setTitle('🛑 AutoMod hat eingegriffen')
+                .setDescription(
+                    `**${treffer.user?.username ?? treffer.userId}** `
+                    + `(<@${treffer.userId}>)${treffer.channelId ? ` in <#${treffer.channelId}>` : ''}`
+                )
+                .addFields(
+                    { name: 'Regel', value: regelName, inline: true },
+                    { name: 'Auslöser', value: AUSLOESER[treffer.ruleTriggerType] ?? '—', inline: true },
+                    { name: 'Maßnahme', value: AKTIONEN[treffer.action?.type] ?? '—', inline: true },
+                );
+
+            if (treffer.matchedKeyword) {
+                embed.addFields({ name: 'Treffer', value: `\`${treffer.matchedKeyword}\``, inline: true });
+            }
+            if (treffer.content) {
+                // Der Wortlaut gehört ins Protokoll, aber gekürzt und ohne
+                // Erwähnungen, die den Kanal anpingen
+                embed.addFields({
+                    name: 'Nachricht',
+                    value: treffer.content.slice(0, 500),
+                });
+            }
+
+            await channel.send({ embeds: [embed], allowedMentions: { parse: [] } }).catch(() => {});
+        } catch (error) {
+            console.error('[automod]', error);
+        }
+    });
+}

src/bot/client.js

@@ -9,6 +9,7 @@ import { archiveDevlogMessage, removeDevlog } from './devlog-archive.js';
 import { registerCommunityListeners } from './community.js';
 import { registerModTools } from './mod-tools.js';
 import { registerAntiRaid } from './anti-raid.js';
+import { registerAutoMod } from './automod.js';
 import { registerMetadata, startLinkedRoles } from './linked-roles.js';
 import { registerLevels } from './levels.js';
 import { registerPresence } from './presence.js';
@@ -66,6 +67,9 @@ export async function startBot() {
             // Temp-Voice (Join to Create) + Event-Ankündigungen
             GatewayIntentBits.GuildVoiceStates,
             GatewayIntentBits.GuildScheduledEvents,
+            // AutoMod-Treffer mitbekommen. Nicht privilegiert, aber Discord
+            // schickt die Ereignisse nur an Bots mit „Server verwalten".
+            GatewayIntentBits.AutoModerationExecution,
         ],
         // Partials: Delete/Reaction-Events für ungecachte Nachrichten + DM-Kanäle
         partials: [Partials.Message, Partials.Reaction, Partials.Channel],
@@ -376,6 +380,7 @@ export async function startBot() {
     registerModTools(client);
     // Vor den anderen Beitritts-Handlern egal — die Erkennung zaehlt nur mit
     registerAntiRaid(client);
+    registerAutoMod(client);
     registerLevels(client);
     registerPresence(client);
     registerExtras(client);