Raid-Sperre von Hand setzen, aufheben oder nachsehen

Der fehlende Befehl zum Raid-Schutz. Drei Unterbefehle:

  status  ist gerade gesperrt, und wie lange noch
  an      jetzt sperren — fuer die Welle, die man kommen sieht
  aus     sofort aufheben — fuer den Fehlalarm um drei Uhr nachts

Rechte: ManageGuild, weil die Sperre genau das anfasst — Verifizierung und
Invites. Antworten sind ephemeral.

Die Sperr-Massnahmen sind in dichtmachen() herausgezogen, damit automatisch
und von Hand denselben Weg nehmen und sich nicht auseinanderentwickeln. Die
Meldung sagt jeweils dazu, wodurch sie ausgeloest wurde und wer es war.

Ist der Raid-Schutz ausgeschaltet, verweist der Befehl aufs Panel statt
stillschweigend nichts zu tun.

Dazu: der Befehl steht auf der oeffentlichen Befehls-Seite, in beiden
Sprachen, und die Zahl auf der Produktseite geht von 16 auf 17.

Geprueft: 17 Befehle laden, keine doppelten Namen, Rechte-Bitmaske 32
(ManageGuild), alle neuen Exporte vorhanden, kein Sprachschluessel fehlt.

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

src/bot/anti-raid.js

@@ -50,18 +50,26 @@ async function melden(client, titel, text) {
 }
 
 export function istGesperrt() {
-    const bis = getSetting(BIS);
-    return Boolean(bis) && new Date(bis).getTime() > jetzt();
+    return sperrStand().gesperrt;
 }
 
-/** Server dichtmachen. Gibt zurück, was tatsächlich griff. */
-async function sperren(client, guild, anzahl, fenster) {
+/** Läuft gerade eine Sperre, und bis wann? */
+export function sperrStand() {
+    const bis = getSetting(BIS);
+    const ms = bis ? new Date(bis).getTime() : 0;
+    return { gesperrt: ms > jetzt(), bis: ms || null };
+}
+
+/**
+ * Die eigentlichen Maßnahmen. Von Hand und automatisch nehmen denselben Weg,
+ * damit sich die beiden nicht auseinanderentwickeln.
+ * @returns {Promise<{getan: string[], minuten: number}>}
+ */
+async function dichtmachen(client, guild, grund) {
     const minuten = tuning('raid_lockdown');
     const vorher = guild.verificationLevel;
     const getan = [];
 
-    const grund = `Anti-Raid: ${anzahl} Beitritte in ${fenster} s`;
-
     if (vorher < GuildVerificationLevel.High) {
         const ok = await guild.setVerificationLevel(GuildVerificationLevel.High, grund)
             .then(() => true)
@@ -81,20 +89,45 @@ async function sperren(client, guild, anzahl, fenster) {
     setSetting(VORHER, String(vorher));
     setSetting(BIS, new Date(jetzt() + minuten * 60000).toISOString());
     planeAufhebung(client, minuten * 60000);
+    return { getan, minuten };
+}
+
+/** Automatisch, weil das Beitritts-Fenster übergelaufen ist */
+async function sperren(client, guild, anzahl, fenster) {
+    const { getan, minuten } = await dichtmachen(client, guild, `Anti-Raid: ${anzahl} Beitritte in ${fenster} s`);
 
     await melden(
         client,
         '🚨 Raid-Verdacht — Server gesperrt',
         `**${anzahl} Beitritte in ${fenster} Sekunden.**\n\n`
         + (getan.length ? `${getan.map((g) => `• ${g}`).join('\n')}\n\n` : '_Keine Maßnahme griff — fehlen dem Bot Rechte?_\n\n')
-        + `Wird in **${minuten} Minuten** automatisch aufgehoben.\n`
+        + `Wird in **${minuten} Minuten** automatisch aufgehoben, `
+        + 'vorher mit `/raid aus`.\n'
         + 'Es wurde niemand gekickt oder gebannt.'
     );
     console.warn(`[antiraid] Sperre aktiv: ${anzahl} Beitritte in ${fenster}s`);
 }
 
-/** Sperre zurücknehmen — auch beim Start, falls über einen Neustart hinweg */
-export async function entsperren(client, { melde = true } = {}) {
+/** Von Hand über /raid an — für die Welle, die man kommen sieht */
+export async function sperrenVonHand(client, guild, durch) {
+    const { getan, minuten } = await dichtmachen(client, guild, `Raid-Sperre von Hand durch ${durch}`);
+
+    await melden(
+        client,
+        '🔒 Server von Hand gesperrt',
+        `Ausgelöst von **${durch}**.\n\n`
+        + (getan.length ? `${getan.map((g) => `• ${g}`).join('\n')}\n\n` : '_Keine Maßnahme griff — fehlen dem Bot Rechte?_\n\n')
+        + `Läuft nach **${minuten} Minuten** aus, vorher mit \`/raid aus\`.`
+    );
+    console.warn(`[antiraid] Sperre von Hand durch ${durch}`);
+    return { getan, minuten };
+}
+
+/**
+ * Sperre zurücknehmen — vom Timer, von /raid aus, oder beim Start, wenn eine
+ * Sperre einen Neustart überlebt hat.
+ */
+export async function entsperren(client, { melde = true, durch = null } = {}) {
     if (!getSetting(BIS)) return false;
 
     const guild = client.guilds.cache.first();
@@ -120,9 +153,10 @@ export async function entsperren(client, { melde = true } = {}) {
 
     if (melde) {
         await melden(client, '✅ Sperre aufgehoben',
-            getan.length ? getan.map((g) => `• ${g}`).join('\n') : 'Nichts zurückzunehmen.');
+            (durch ? `Von Hand durch **${durch}**.\n\n` : '')
+            + (getan.length ? getan.map((g) => `• ${g}`).join('\n') : 'Nichts zurückzunehmen.'));
     }
-    console.log('[antiraid] Sperre aufgehoben');
+    console.log(`[antiraid] Sperre aufgehoben${durch ? ` (durch ${durch})` : ''}`);
     return true;
 }