Grundgerüst-Assistent: alle fehlenden Kanäle auf einmal

Der Einzelknopf war der Anfang; wer frisch startet, klickt sich damit
sechzehnmal durch. Der Assistent macht das in einem Durchlauf.

Erst eine Vorschau, bevor irgendetwas passiert: was neu entsteht, was schon
existiert und nur verknüpft wird, welche Kanäle privat werden und in welche
Kategorie alles kommt. Die Kategorie heißt wie die Marke und wird
wiederverwendet, wenn es sie schon gibt.

Der Plan ist nach Einstellung entdoppelt — Devlogs und Wochen-Rückblick
brauchen denselben Kanal, der soll nicht zweimal auftauchen. Rollen kommen
ohne Kategorie, die gibt es dort nicht.

Zwischen zwei Anlagen liegen 350 ms. Discord verträgt ein Dutzend
Kanal-Erstellungen am Stück schlecht, und ein Rate-Limit mitten im Lauf
wäre die unangenehmste Art zu scheitern.

Scheitert ein Schritt, laufen die übrigen weiter und das Ergebnis zeigt pro
Zeile, was passiert ist. Vorher hätte ein einzelner Fehler den Rest
verschluckt.

Im Test: 19 offene Punkte, Vorschau zeigt 16, danach bleiben 2 — die beiden
ohne Vorlage (Gitea-Token und Watchdog-Adressen), die sich nicht anlegen
lassen.

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

src/bot/server-setup.js

@@ -9,8 +9,13 @@
 // dessen Verlauf.
 import { ChannelType, PermissionFlagsBits } from 'discord.js';
 import { setSetting } from '../db.js';
-import { creationPlan } from '../modules.js';
-import { discordGuildId } from '../runtime-settings.js';
+import { creationPlan, MODULES, moduleEnabled, moduleMissing } from '../modules.js';
+import { discordGuildId, brandName } from '../runtime-settings.js';
+
+// Kurze Pause zwischen zwei Anlagen. Discord verträgt Bursts schlecht, und der
+// Assistent legt schnell ein Dutzend Kanäle an.
+const PAUSE_MS = 350;
+const warte = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /** Server, auf dem gearbeitet wird — konfigurierter, sonst der erste */
 function targetGuild(client) {
@@ -23,10 +28,11 @@ function targetGuild(client) {
  *
  * @param {import('discord.js').Client} client
  * @param {string} setting — z. B. 'devlog_channel_id'
+ * @param {{ parent?: object|null }} [opts] — Kategorie für neue Kanäle
  * @returns {Promise<{ id: string, name: string, art: 'kanal'|'rolle' }>}
  * @throws {Error} mit einer Meldung, die im Panel angezeigt werden kann
  */
-export async function createForSetting(client, setting) {
+export async function createForSetting(client, setting, { parent = null } = {}) {
     const plan = creationPlan(setting);
     if (!plan) throw new Error('Dafür gibt es keine Vorlage — bitte von Hand anlegen.');
 
@@ -80,6 +86,7 @@ export async function createForSetting(client, setting) {
     const channel = await guild.channels.create({
         name: plan.name,
         type: gewuenschterTyp,
+        parent: parent ?? undefined,
         topic: plan.sprache ? undefined : plan.topic,
         permissionOverwrites: overwrites.length ? overwrites : undefined,
         reason: 'Über das d4rkbot-Panel angelegt',
@@ -88,3 +95,96 @@ export async function createForSetting(client, setting) {
     setSetting(setting, channel.id);
     return { id: channel.id, name: channel.name, art: 'kanal', wiederverwendet: false };
 }
+
+/* ── Grundgerüst-Assistent ─────────────────────────── */
+
+/**
+ * Was der Assistent anlegen würde — für die Vorschau, bevor etwas passiert.
+ *
+ * Eine Einstellung kann von mehreren Modulen gebraucht werden (Devlogs und
+ * Wochen-Rückblick teilen sich den Devlog-Kanal), deshalb wird nach
+ * Einstellung entdoppelt.
+ */
+export function setupPlan(client) {
+    const guild = targetGuild(client);
+    const namen = new Set(
+        guild ? [...guild.channels.cache.values()].map((c) => c.name.toLowerCase()) : []
+    );
+    const rollennamen = new Set(
+        guild ? [...guild.roles.cache.values()].map((r) => r.name.toLowerCase()) : []
+    );
+
+    const gesehen = new Set();
+    const schritte = [];
+    for (const mod of MODULES) {
+        if (!moduleEnabled(mod.id)) continue;
+        for (const fehlt of moduleMissing(mod)) {
+            if (!fehlt.create || gesehen.has(fehlt.setting)) continue;
+            gesehen.add(fehlt.setting);
+            const rolle = Boolean(fehlt.create.rolle);
+            schritte.push({
+                setting: fehlt.setting,
+                label: fehlt.label,
+                name: fehlt.create.name,
+                art: rolle ? 'rolle' : 'kanal',
+                privat: Boolean(fehlt.create.privat),
+                sprache: Boolean(fehlt.create.sprache),
+                // Gleichnamiges vorhanden? Dann wird verknüpft statt angelegt.
+                vorhanden: (rolle ? rollennamen : namen).has(fehlt.create.name.toLowerCase()),
+                fuer: mod.name,
+            });
+        }
+    }
+    return schritte;
+}
+
+/**
+ * Alles aus dem Plan anlegen. Neue Kanäle landen in einer eigenen Kategorie,
+ * damit der Server danach nicht wie ein Sammelsurium aussieht.
+ *
+ * Ein Fehler bei einem Schritt bricht nicht ab — die restlichen werden
+ * versucht, und am Ende steht pro Zeile, was passiert ist.
+ *
+ * @returns {Promise<Array<{ setting, label, ok, name?, art?, wiederverwendet?, fehler? }>>}
+ */
+export async function runSetup(client, { kategorie } = {}) {
+    const schritte = setupPlan(client);
+    if (schritte.length === 0) return [];
+
+    const guild = targetGuild(client);
+    const me = guild?.members.me ?? await guild?.members.fetchMe().catch(() => null);
+    if (!guild || !me) throw new Error('Kein Discord-Server gefunden.');
+    if (!me.permissions.has(PermissionFlagsBits.ManageChannels)) {
+        throw new Error('Dem Bot fehlt das Recht „Kanäle verwalten".');
+    }
+
+    // Kategorie anlegen (oder eine gleichnamige wiederverwenden), aber nur wenn
+    // überhaupt Kanäle entstehen
+    const brauchtKategorie = schritte.some((s) => s.art === 'kanal' && !s.vorhanden);
+    const katName = (kategorie ?? brandName()).slice(0, 90);
+    let parent = null;
+    if (brauchtKategorie) {
+        parent = [...guild.channels.cache.values()].find(
+            (c) => c.type === ChannelType.GuildCategory && c.name.toLowerCase() === katName.toLowerCase()
+        ) ?? await guild.channels.create({
+            name: katName,
+            type: ChannelType.GuildCategory,
+            reason: 'Grundgerüst über das d4rkbot-Panel',
+        }).catch(() => null);
+    }
+
+    const ergebnisse = [];
+    for (const [i, schritt] of schritte.entries()) {
+        if (i > 0) await warte(PAUSE_MS);
+        try {
+            const res = await createForSetting(client, schritt.setting, { parent });
+            ergebnisse.push({ setting: schritt.setting, label: schritt.label, ok: true, ...res });
+        } catch (error) {
+            ergebnisse.push({
+                setting: schritt.setting, label: schritt.label, ok: false,
+                fehler: error.message || 'Fehlgeschlagen',
+            });
+        }
+    }
+    return ergebnisse;
+}

src/web/api.js

@@ -226,6 +226,30 @@ export function registerApiRoutes(app, client) {
         }
     });
 
+    // Grundgerüst: Vorschau, was der Assistent anlegen würde
+    app.get('/api/setup/plan', async (request, reply) => {
+        if (requireScope(request, reply, 'settings')) return;
+        const { setupPlan } = await import('../bot/server-setup.js');
+        return { schritte: setupPlan(client), kategorie: brandName() };
+    });
+
+    // … und ausführen
+    app.post('/api/setup/run', async (request, reply) => {
+        if (requireScope(request, reply, 'settings')) return;
+        const kategorie = String(request.body?.kategorie ?? '').trim() || undefined;
+        try {
+            const { runSetup } = await import('../bot/server-setup.js');
+            const ergebnisse = await runSetup(client, { kategorie });
+            const neu = ergebnisse.filter((r) => r.ok && !r.wiederverwendet).length;
+            logAudit(getSessionUser(request), 'grundgerüst angelegt', `${neu} neu, ${ergebnisse.length} gesamt`);
+            request.log.info(`Grundgerüst: ${neu} neu von ${ergebnisse.length} Schritten`);
+            return { ok: true, ergebnisse, modules: moduleStates(), settings: currentSettings() };
+        } catch (error) {
+            request.log.error({ err: error }, 'Grundgerüst fehlgeschlagen');
+            return reply.code(400).send({ error: error.message || 'Fehlgeschlagen' });
+        }
+    });
+
     // --- Stellwerte: Zahlen, die vorher fest im Code standen ---
 
     app.get('/api/tuning', async (request, reply) => {