feat(katalog): Profil-Editor mit Live-Prüfung und Skriptvorschau

Admins legen eigene Profile als YAML an; geprüft wird beim Tippen gegen
dasselbe Schema wie der Katalog, dazu eine Vorschau des erzeugten
Skripts. Katalogprofile bleiben schreibgeschützt und lassen sich als
Kopie bearbeiten. Ein Profil, das ein anderes voraussetzt, lässt sich
nicht löschen.

Closes #011

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

src/server/services/katalog.ts

@@ -1,11 +1,15 @@
 import { join } from "node:path";
 import type { Prisma } from "@/generated/prisma/client";
-import { katalogLaden, type KatalogFehler } from "@/engine/katalog/laden";
+import { adapterFuer, bekannteFamilien } from "@/engine/adapter";
+import { katalogLaden, yamlPruefen, type KatalogFehler } from "@/engine/katalog/laden";
+import { ProfilSchema } from "@/engine/katalog/schema";
+import { profileAufloesen } from "@/engine/profile/aufloesen";
+import { profileRendern } from "@/engine/profile/rendern";
 import type { Distribution, Profil } from "@/engine/katalog/schema";
 import { prisma } from "@/lib/db";
 import { logger } from "@/lib/logger";
 import type { Aufrufer } from "@/server/auth/zugang";
-import { nichtGefunden } from "@/server/fehler";
+import { AnwendungsFehler, nichtGefunden } from "@/server/fehler";
 import { protokollieren } from "@/server/services/protokoll";
 
 /** Wo der Katalog liegt: im Repo und im Image unter ./catalog, überschreibbar für Tests. */
@@ -209,3 +213,160 @@ export async function profilAktivSetzen(id: string, aktiv: boolean, aufrufer: Au
     );
   });
 }
+
+// ── Eigene Profile (#011) ───────────────────────────────────────────────────────────────────────
+
+export type ProfilPruefung =
+  { ok: true; profil: Profil; vorschau: string | null } | { ok: false; fehler: string[] };
+
+/**
+ * Prüft ein Profil aus dem Editor: YAML, Schema, Voraussetzungen. Mit Vorschau des erzeugten
+ * Skripts für die erste Distribution der Familie, damit man sieht, was im Gast ankommt.
+ */
+export async function profilPruefen(quelltext: string): Promise<ProfilPruefung> {
+  const geprueft = yamlPruefen(quelltext, ProfilSchema);
+  if (!geprueft.ok) return { ok: false, fehler: geprueft.fehler };
+  const profil = geprueft.eintrag;
+  const alle = new Map(
+    (await prisma.profil.findMany({ where: { entferntAm: null } })).map((p) => [
+      p.id,
+      p.definition as Profil,
+    ]),
+  );
+  alle.set(profil.id, profil);
+  const fehler: string[] = [];
+  for (const familie of Object.keys(profil.families)) {
+    if (!adapterFuer(familie))
+      fehler.push(
+        `families.${familie}: Für diese Familie gibt es keinen Adapter (bekannt: ${bekannteFamilien().join(", ")}).`,
+      );
+  }
+  const familie = Object.keys(profil.families).find((f) => adapterFuer(f));
+  let vorschau: string | null = null;
+  if (familie) {
+    const aufgeloest = profileAufloesen([profil.id], alle, familie, {
+      // Für die Vorschau Pflichtvariablen mit einem Platzhalter füllen.
+      [profil.id]: Object.fromEntries(
+        profil.variables.filter((v) => v.required).map((v) => [v.name, `<${v.name}>`]),
+      ),
+    });
+    if (!aufgeloest.ok) {
+      fehler.push(...aufgeloest.fehler.map((f) => `${f.profil}: ${f.meldung}`));
+    } else {
+      const distro = (await distributionenListe({ nurAktive: true })).find((d) => d.familie === familie);
+      try {
+        vorschau =
+          profileRendern(
+            aufgeloest.profile.filter((p) => p.profil.id === profil.id),
+            adapterFuer(familie)!,
+            {
+              os: distro?.definition.os ?? { id: familie, version_id: "0" },
+              gast: { name: "beispiel", benutzer: "benutzer", typ: "vm" },
+            },
+          ).abschnitte[0]?.skript ?? null;
+      } catch (ursache) {
+        fehler.push(ursache instanceof Error ? ursache.message : String(ursache));
+      }
+    }
+  }
+  return fehler.length > 0 ? { ok: false, fehler } : { ok: true, profil, vorschau };
+}
+
+export async function profilSpeichern(
+  quelltext: string,
+  aufrufer: Aufrufer,
+  ip: string | null,
+  bisherigeId?: string,
+): Promise<ProfilSicht> {
+  const pruefung = await profilPruefen(quelltext);
+  if (!pruefung.ok)
+    throw new AnwendungsFehler(
+      400,
+      "ungueltig",
+      pruefung.fehler.join(" "),
+      "Fehlerstellen im Editor beheben.",
+    );
+  const { profil } = pruefung;
+  const vorhanden = await prisma.profil.findUnique({ where: { id: profil.id } });
+  if (bisherigeId && bisherigeId !== profil.id) {
+    throw new AnwendungsFehler(
+      400,
+      "ungueltig",
+      "Die id eines Profils lässt sich nicht ändern.",
+      "Als neues Profil mit anderer id speichern.",
+    );
+  }
+  if (vorhanden && (vorhanden.herkunft === "KATALOG" || !bisherigeId) && !vorhanden.entferntAm) {
+    throw new AnwendungsFehler(
+      409,
+      "vergeben",
+      vorhanden.herkunft === "KATALOG"
+        ? `„${profil.id}“ ist ein Katalogprofil.`
+        : `Ein Profil „${profil.id}“ gibt es schon.`,
+      vorhanden.herkunft === "KATALOG"
+        ? "Für eine eigene Fassung eine andere id wählen, z. B. docker-eigen."
+        : undefined,
+    );
+  }
+  const daten = {
+    name: profil.name,
+    beschreibung: profil.description ?? null,
+    familien: Object.keys(profil.families),
+    herkunft: "EIGEN" as const,
+    definition: profil as unknown as Prisma.InputJsonValue,
+    quelltext,
+    entferntAm: null,
+    geaendertVonId: aufrufer.benutzer.id,
+  };
+  await prisma.$transaction(async (tx) => {
+    await tx.profil.upsert({ where: { id: profil.id }, create: { id: profil.id, ...daten }, update: daten });
+    await protokollieren(
+      {
+        benutzerId: aufrufer.benutzer.id,
+        quelle: aufrufer.quelle,
+        aktion: bisherigeId ? "Profil geändert" : "Profil angelegt",
+        ziel: `profil:${profil.id}`,
+        ip,
+      },
+      tx,
+    );
+  });
+  return (await profileListe()).find((p) => p.id === profil.id)!;
+}
+
+export async function profilLoeschen(id: string, aufrufer: Aufrufer, ip: string | null): Promise<void> {
+  const profil = await prisma.profil.findUnique({ where: { id } });
+  if (!profil || profil.entferntAm) throw nichtGefunden(`Das Profil „${id}“`);
+  if (profil.herkunft === "KATALOG") {
+    throw new AnwendungsFehler(
+      409,
+      "katalog",
+      "Katalogprofile lassen sich nicht löschen.",
+      "Deaktivieren oder die YAML-Datei aus catalog/profiles entfernen.",
+    );
+  }
+  const abhaengig = (await prisma.profil.findMany({ where: { entferntAm: null } })).filter((p) =>
+    (p.definition as Profil).requires?.includes(id),
+  );
+  if (abhaengig.length > 0) {
+    throw new AnwendungsFehler(
+      409,
+      "benutzt",
+      `${abhaengig.map((p) => p.id).join(", ")} setzt „${id}“ voraus.`,
+    );
+  }
+  await prisma.$transaction(async (tx) => {
+    // Aufträge nennen Profile nur beim Namen – löschen ist sicher, der Verlauf bleibt lesbar.
+    await tx.profil.delete({ where: { id } });
+    await protokollieren(
+      {
+        benutzerId: aufrufer.benutzer.id,
+        quelle: aufrufer.quelle,
+        aktion: "Profil gelöscht",
+        ziel: `profil:${id}`,
+        ip,
+      },
+      tx,
+    );
+  });
+}