feat(ausrollen): Public Keys mit Trockenlauf und Backup ausrollen (#016)

Zuweisungen von Public Keys an Hosts oder Hostgruppen, ein Trockenlauf
mit Diff je Ziel und das Ausrollen genau dieses Plans. Hat sich die
Datei oder das Soll seit dem Trockenlauf geaendert, bricht das Ziel
ab: es wird nie etwas anderes geschrieben, als jemand gesehen hat.

Auf dem Host geschieht alles als Zielbenutzer, mit Sicherung, Temp-
Datei, mv und 0700/0600; der Hash wird dort erneut geprueft. Der
Deployment-Key gehoert immer zum Soll des Anmeldebenutzers.

Integrationstests gegen echtes sshd, die Oberflaechenbausteine folgen
mit der Schluesselseite aus #012.

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

src/server/actions/verwendungen.ts

@@ -0,0 +1,96 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { z } from "@/lib/validierung";
+import { BestaetigungFehler, RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { akteurVon, textfeld, type FormularZustand } from "@/server/actions/formular";
+import {
+  VerwendungsFehler,
+  ausrollenStarten,
+  publicVerwendungAnlegen,
+  publicVerwendungEntfernen,
+  trockenlaufStarten,
+} from "@/server/services/verwendungen";
+
+/** Public-Key-Zuweisungen und Ausrollen (#016). Duenn: Recht, Eingabe, Service. */
+
+export type VorgangsAntwort = { readonly vorgangId?: string; readonly fehler?: string };
+
+function alsAntwort(fehler: unknown): { fehler: string } {
+  if (
+    fehler instanceof VerwendungsFehler ||
+    fehler instanceof RechteFehler ||
+    fehler instanceof BestaetigungFehler
+  ) {
+    return { fehler: fehler.message };
+  }
+  throw fehler;
+}
+
+export async function publicZuweisenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    const schluesselId = z.string().min(1).max(64).parse(textfeld(formular, "schluesselId"));
+    // „host:<id>“ oder „gruppe:<id>“ aus einer einzigen Auswahlliste.
+    const ziel = textfeld(formular, "ziel") ?? "";
+    const [art, id] = ziel.split(":");
+    if (!id || (art !== "host" && art !== "gruppe"))
+      return { feldfehler: { ziel: "Bitte ein Ziel wählen." } };
+    await publicVerwendungAnlegen(
+      {
+        schluesselId,
+        hostId: art === "host" ? id : null,
+        hostgruppeId: art === "gruppe" ? id : null,
+        zielbenutzer: (textfeld(formular, "zielbenutzer") ?? "").trim(),
+        optionen: textfeld(formular, "optionen") ?? null,
+      },
+      akteurVon(benutzer),
+    );
+    revalidatePath(`/schluessel/${schluesselId}`);
+    return {};
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function publicEntfernenAktion(
+  verwendungId: string,
+  schluesselId: string,
+): Promise<{ fehler?: string }> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    await publicVerwendungEntfernen(z.string().min(1).max(64).parse(verwendungId), akteurVon(benutzer));
+    revalidatePath(`/schluessel/${schluesselId}`);
+    return {};
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function trockenlaufAktion(schluesselId: string): Promise<VorgangsAntwort> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    return {
+      vorgangId: await trockenlaufStarten(
+        { schluesselId: z.string().min(1).max(64).parse(schluesselId) },
+        akteurVon(benutzer),
+      ),
+    };
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function ausrollenAktion(trockenlaufId: string): Promise<VorgangsAntwort> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    return {
+      vorgangId: await ausrollenStarten(z.string().min(1).max(64).parse(trockenlaufId), akteurVon(benutzer)),
+    };
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}