{children}
diff --git a/src/app/(app)/page.tsx b/src/app/(app)/page.tsx
index 3cd88fa..42fdbfd 100644
--- a/src/app/(app)/page.tsx
+++ b/src/app/(app)/page.tsx
@@ -1,12 +1,16 @@
import type { Metadata } from "next";
import { Karte } from "@/components/karte";
import { Status } from "@/components/status";
+import Link from "next/link";
import { seiteSchuetzen } from "@/server/auth/zugang";
+import { serverListe } from "@/server/services/server";
+import { ServerStatus } from "./server/server-status";
export const metadata: Metadata = { title: "Übersicht" };
export default async function Uebersicht() {
const benutzer = await seiteSchuetzen("lesen", "/");
+ const server = await serverListe();
return (
@@ -16,11 +20,32 @@ export default async function Uebersicht() {
-
- Noch kein Proxmox-Server angelegt.
-
+ Alle
+
+ }
+ >
+ {server.length === 0 ? (
+ Noch kein Proxmox-Server angelegt.
+ ) : (
+
Noch keine Deployments.
diff --git a/src/app/(app)/server/[name]/bearbeiten/page.tsx b/src/app/(app)/server/[name]/bearbeiten/page.tsx
new file mode 100644
index 0000000..658dafa
--- /dev/null
+++ b/src/app/(app)/server/[name]/bearbeiten/page.tsx
@@ -0,0 +1,21 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { prisma } from "@/lib/db";
+import { seiteSchuetzen } from "@/server/auth/zugang";
+import { serverSicht } from "@/server/services/server";
+import { ServerFormular } from "../../server-formular";
+
+export const metadata: Metadata = { title: "Server bearbeiten" };
+
+export default async function ServerBearbeiten({ params }: { params: Promise<{ name: string }> }) {
+ const { name } = await params;
+ await seiteSchuetzen("serverVerwalten", `/server/${name}/bearbeiten`);
+ const server = await prisma.server.findUnique({ where: { name } });
+ if (!server) notFound();
+ return (
+ {
+ return { title: (await params).name };
+}
+
+export default async function ServerDetail({ params }: { params: Promise<{ name: string }> }) {
+ const { name } = await params;
+ const benutzer = await seiteSchuetzen("lesen", `/server/${name}`);
+ const datensatz = await prisma.server.findUnique({ where: { name } });
+ if (!datensatz) notFound();
+ const server = serverSicht(datensatz);
+ const verwalten = darf(benutzer.rolle, "serverVerwalten");
+
+ return (
+ (null);
+
+ async function ausfuehren() {
+ if ((art === "loeschen" || erneuern) && !bestaetigen) {
+ setBestaetigen(true);
+ return;
+ }
+ setLaeuft(true);
+ setFehler(null);
+ try {
+ if (art === "loeschen") {
+ await apiAufruf("DELETE", `/api/v1/server/${name}`);
+ router.push("/server");
+ } else {
+ await apiAufruf("POST", `/api/v1/server/${name}/ssh`);
+ }
+ setBestaetigen(false);
+ router.refresh();
+ } catch (ursache) {
+ setFehler(ursache instanceof ApiFehler ? ursache.message : "Unerwarteter Fehler.");
+ } finally {
+ setLaeuft(false);
+ }
+ }
+
+ const text =
+ art === "loeschen"
+ ? bestaetigen
+ ? "Wirklich löschen"
+ : "Server löschen"
+ : erneuern
+ ? bestaetigen
+ ? "Neuen Schlüssel erzeugen – der alte wird ungültig"
+ : "Schlüssel erneuern"
+ : "Schlüssel erzeugen";
+
+ return (
+ (() => anfangswerte(server));
+ const [pruefung, setPruefung] = useState(null);
+ const [prueft, setPrueft] = useState<"zertifikat" | "verbindung" | null>(null);
+ const [speichert, setSpeichert] = useState(false);
+ const [felder, setFelder] = useState>({});
+ const [meldung, setMeldung] = useState<{ text: string; hinweis?: string } | null>(null);
+
+ const setze = (feld: K, wert: Werte[K]) => {
+ setWerte((alt) => ({ ...alt, [feld]: wert }));
+ // Eine neue Adresse macht das gesehene Zertifikat und den Pin wertlos.
+ if (feld === "url") {
+ setPruefung(null);
+ setWerte((alt) => ({ ...alt, fingerabdruck: null }));
+ }
+ };
+
+ async function pruefen(was: "zertifikat" | "verbindung") {
+ setPrueft(was);
+ setMeldung(null);
+ try {
+ const ergebnis = await apiAufruf("POST", "/api/v1/server/pruefen", {
+ url: werte.url,
+ name: server?.name,
+ tokenId: was === "verbindung" ? werte.tokenId : undefined,
+ tokenGeheimnis: was === "verbindung" ? werte.tokenGeheimnis : undefined,
+ tlsPruefen: werte.tlsPruefen,
+ fingerabdruck: werte.fingerabdruck,
+ });
+ setPruefung(ergebnis);
+ // Ein vertrauenswürdiges Zertifikat (ACME) braucht keinen Pin – TLS-Prüfung genügt.
+ if (was === "zertifikat" && ergebnis.zertifikat?.vertraut && !werte.fingerabdruck) {
+ setWerte((alt) => ({ ...alt, tlsPruefen: true }));
+ }
+ } catch (fehler) {
+ setMeldung(fehlerText(fehler));
+ if (fehler instanceof ApiFehler) setFelder(fehler.felder);
+ } finally {
+ setPrueft(null);
+ }
+ }
+
+ async function speichern(ereignis: React.FormEvent) {
+ ereignis.preventDefault();
+ setSpeichert(true);
+ setFelder({});
+ setMeldung(null);
+ const rumpf = {
+ ...werte,
+ sshPort: Number(werte.sshPort),
+ templateVmidVon: Number(werte.templateVmidVon),
+ templateVmidBis: Number(werte.templateVmidBis),
+ gastVmidVon: Number(werte.gastVmidVon),
+ };
+ try {
+ const gespeichert = bearbeiten
+ ? await apiAufruf("PATCH", `/api/v1/server/${server!.name}`, rumpf)
+ : await apiAufruf("POST", "/api/v1/server", rumpf);
+ router.push(`/server/${gespeichert.name}`);
+ router.refresh();
+ } catch (fehler) {
+ setMeldung(fehlerText(fehler));
+ if (fehler instanceof ApiFehler) setFelder(fehler.felder);
+ } finally {
+ setSpeichert(false);
+ }
+ }
+
+ const zertifikat = pruefung?.zertifikat;
+ const gepinnt = Boolean(werte.fingerabdruck);
+
+ return (
+
+ );
+}
+
+function fehlerText(fehler: unknown): { text: string; hinweis?: string } {
+ if (fehler instanceof ApiFehler) return { text: fehler.message, hinweis: fehler.hinweis };
+ return { text: "Unerwarteter Fehler." };
+}
diff --git a/src/app/(app)/server/server-status.tsx b/src/app/(app)/server/server-status.tsx
new file mode 100644
index 0000000..79e98eb
--- /dev/null
+++ b/src/app/(app)/server/server-status.tsx
@@ -0,0 +1,13 @@
+import { Status } from "@/components/status";
+import type { ServerSicht } from "@/lib/schemas/server";
+
+/** Erreichbarkeit nach der letzten Prüfung – „ungeprüft“, solange es keine gab. */
+export function ServerStatus({ server }: { server: Pick }) {
+ if (server.erreichbar === null) return ungeprüft ;
+ if (!server.erreichbar) return nicht erreichbar ;
+ return (
+
+ PVE {server.pveVersion}
+
+ );
+}
diff --git a/src/app/api/v1/server/[name]/route.ts b/src/app/api/v1/server/[name]/route.ts
new file mode 100644
index 0000000..bfd01f4
--- /dev/null
+++ b/src/app/api/v1/server/[name]/route.ts
@@ -0,0 +1,29 @@
+import { NextResponse } from "next/server";
+import { aufruferAdresse } from "@/lib/adressen";
+import { api, jsonLesen } from "@/server/api";
+import { rechtErforderlich } from "@/server/auth/zugang";
+import { serverAendern, serverHolen, serverLoeschen, serverSicht } from "@/server/services/server";
+
+type Kontext = { params: Promise<{ name: string }> };
+
+export const GET = api(async (anfrage: Request, { params }: Kontext) => {
+ await rechtErforderlich(anfrage, "lesen");
+ return NextResponse.json(serverSicht(await serverHolen((await params).name)));
+});
+
+export const PATCH = api(async (anfrage: Request, { params }: Kontext) => {
+ const aufrufer = await rechtErforderlich(anfrage, "serverVerwalten");
+ const server = await serverAendern(
+ (await params).name,
+ await jsonLesen(anfrage),
+ aufrufer,
+ aufruferAdresse(anfrage.headers),
+ );
+ return NextResponse.json(server);
+});
+
+export const DELETE = api(async (anfrage: Request, { params }: Kontext) => {
+ const aufrufer = await rechtErforderlich(anfrage, "serverVerwalten");
+ await serverLoeschen((await params).name, aufrufer, aufruferAdresse(anfrage.headers));
+ return new NextResponse(null, { status: 204 });
+});
diff --git a/src/app/api/v1/server/[name]/ssh/route.ts b/src/app/api/v1/server/[name]/ssh/route.ts
new file mode 100644
index 0000000..36b88a2
--- /dev/null
+++ b/src/app/api/v1/server/[name]/ssh/route.ts
@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { aufruferAdresse } from "@/lib/adressen";
+import { api } from "@/server/api";
+import { rechtErforderlich } from "@/server/auth/zugang";
+import { sshSchluesselErzeugen } from "@/server/services/server";
+
+type Kontext = { params: Promise<{ name: string }> };
+
+/** Erzeugt oder erneuert das SSH-Schlüsselpaar; der private Teil verlässt den Server nie. */
+export const POST = api(async (anfrage: Request, { params }: Kontext) => {
+ const aufrufer = await rechtErforderlich(anfrage, "serverVerwalten");
+ return NextResponse.json(
+ await sshSchluesselErzeugen((await params).name, aufrufer, aufruferAdresse(anfrage.headers)),
+ );
+});
diff --git a/src/app/api/v1/server/pruefen/route.ts b/src/app/api/v1/server/pruefen/route.ts
new file mode 100644
index 0000000..ad033f9
--- /dev/null
+++ b/src/app/api/v1/server/pruefen/route.ts
@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { api, jsonLesen } from "@/server/api";
+import { rechtErforderlich } from "@/server/auth/zugang";
+import { serverPruefen } from "@/server/services/server";
+
+/**
+ * Prüft Angaben vor dem Speichern: Zertifikat zum Bestätigen holen, optional ein erster Aufruf.
+ * Nur für Admins – der Endpunkt baut Verbindungen zu beliebigen Adressen auf.
+ */
+export const POST = api(async (anfrage: Request) => {
+ await rechtErforderlich(anfrage, "serverVerwalten");
+ return NextResponse.json(await serverPruefen(await jsonLesen(anfrage)));
+});
diff --git a/src/app/api/v1/server/route.ts b/src/app/api/v1/server/route.ts
new file mode 100644
index 0000000..1deeb72
--- /dev/null
+++ b/src/app/api/v1/server/route.ts
@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { aufruferAdresse } from "@/lib/adressen";
+import { api, jsonLesen } from "@/server/api";
+import { rechtErforderlich } from "@/server/auth/zugang";
+import { serverAnlegen, serverListe } from "@/server/services/server";
+
+export const GET = api(async (anfrage: Request) => {
+ await rechtErforderlich(anfrage, "lesen");
+ return NextResponse.json(await serverListe());
+});
+
+export const POST = api(async (anfrage: Request) => {
+ const aufrufer = await rechtErforderlich(anfrage, "serverVerwalten");
+ const server = await serverAnlegen(await jsonLesen(anfrage), aufrufer, aufruferAdresse(anfrage.headers));
+ return NextResponse.json(server, { status: 201 });
+});
diff --git a/src/components/formular.tsx b/src/components/formular.tsx
new file mode 100644
index 0000000..2e848f6
--- /dev/null
+++ b/src/components/formular.tsx
@@ -0,0 +1,104 @@
+import { clsx } from "clsx";
+
+/**
+ * Formular-Bausteine: echtes `
- Server lassen sich anlegen, sobald die Server-Verwaltung (#002) fertig ist. -
+-
+ {server.map((eintrag) => (
+
-
+
+ {eintrag.titel}{" "}
+ {eintrag.name}
+
+
+
+ ))}
+
+
+ );
+}
diff --git a/src/app/(app)/server/[name]/page.tsx b/src/app/(app)/server/[name]/page.tsx
new file mode 100644
index 0000000..1b84432
--- /dev/null
+++ b/src/app/(app)/server/[name]/page.tsx
@@ -0,0 +1,103 @@
+import { Pencil } from "lucide-react";
+import type { Metadata } from "next";
+import Link from "next/link";
+import { notFound } from "next/navigation";
+import { Code } from "@/components/formular";
+import { Karte } from "@/components/karte";
+import { Status } from "@/components/status";
+import { prisma } from "@/lib/db";
+import { darf } from "@/server/auth/rechte";
+import { seiteSchuetzen } from "@/server/auth/zugang";
+import { serverSicht } from "@/server/services/server";
+import { ServerStatus } from "../server-status";
+import { ServerAktionen } from "./server-aktionen";
+
+export async function generateMetadata({ params }: { params: Promise<{ name: string }> }): Promise{server.titel} bearbeiten
+
+
+
+
+
+ {!server.sshAktiv ? (
+ Nicht genutzt. Deployments laufen dann nur über die API.
+ ) : server.sshOeffentlich ? (
+ SSH ist eingeschaltet, aber es gibt noch keinen Schlüssel.
+ )}
+ {verwalten && server.sshAktiv ? (
+
+
+ {verwalten ? (
+
+
+ ) : null}
+
+ );
+}
diff --git a/src/app/(app)/server/[name]/server-aktionen.tsx b/src/app/(app)/server/[name]/server-aktionen.tsx
new file mode 100644
index 0000000..f8bdee7
--- /dev/null
+++ b/src/app/(app)/server/[name]/server-aktionen.tsx
@@ -0,0 +1,78 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { Knopf } from "@/components/knopf";
+import { Status } from "@/components/status";
+import { apiAufruf, ApiFehler } from "@/lib/api-client";
+
+/** Schreibende Knöpfe der Serverseite. Löschen und Erneuern verlangen eine zweite Bestätigung. */
+export function ServerAktionen({
+ name,
+ art,
+ erneuern = false,
+}: {
+ name: string;
+ art: "ssh" | "loeschen";
+ erneuern?: boolean;
+}) {
+ const router = useRouter();
+ const [bestaetigen, setBestaetigen] = useState(false);
+ const [laeuft, setLaeuft] = useState(false);
+ const [fehler, setFehler] = useState
+
+ {verwalten ? (
+
+ Bearbeiten
+
+ ) : null}
+ {server.name}
+{server.titel}
+-
+
- Adresse +
- {server.url} +
- Token-ID +
- {server.tokenId} +
- TLS +
- + {server.fingerabdruck ? ( + + Fingerprint gepinnt{server.tlsPruefen ? " und Kette geprüft" : ""} + {server.fingerabdruck} + + ) : ( + "Kette gegen Systemzertifikate geprüft" + )} + +
- Templates +
- + {server.templateVmidVon}–{server.templateVmidBis} + +
- Gäste ab +
- {server.gastVmidVon} +
+
+ ) : (
+ + Diesen Schlüssel auf jedem Node für {server.sshBenutzer}{" "} + hinterlegen. Im Cluster genügt ein Node:{" "} + /root/.ssh/authorized_keys zeigt dort auf die gemeinsame + Datei in /etc/pve/priv/. +
+{`echo '${server.sshOeffentlich}' >> ~/.ssh/authorized_keys`}
+ + Host-Keys werden beim ersten Verbindungstest angezeigt und nach Bestätigung gepinnt (#003). +
+
+
+ ) : null}
+
+ {art === "loeschen" ? (
+
+ );
+}
diff --git a/src/app/(app)/server/neu/page.tsx b/src/app/(app)/server/neu/page.tsx
new file mode 100644
index 0000000..83924da
--- /dev/null
+++ b/src/app/(app)/server/neu/page.tsx
@@ -0,0 +1,15 @@
+import type { Metadata } from "next";
+import { seiteSchuetzen } from "@/server/auth/zugang";
+import { ServerFormular } from "../server-formular";
+
+export const metadata: Metadata = { title: "Server anlegen" };
+
+export default async function ServerNeu() {
+ await seiteSchuetzen("serverVerwalten", "/server/neu");
+ return (
+ + Entfernt nur den Eintrag in ProxDeploy. VMs und Container auf dem Server bleiben unberührt. +
+ ) : null} +
+
+ {laeuft ? "Bitte warten …" : text}
+
+ {bestaetigen ? (
+ setBestaetigen(false)}>
+ Abbrechen
+
+ ) : null}
+
+ {fehler ? {fehler} : null}
+
+
+ );
+}
diff --git a/src/app/(app)/server/page.tsx b/src/app/(app)/server/page.tsx
new file mode 100644
index 0000000..0016138
--- /dev/null
+++ b/src/app/(app)/server/page.tsx
@@ -0,0 +1,63 @@
+import { Plus } from "lucide-react";
+import type { Metadata } from "next";
+import Link from "next/link";
+import { Karte } from "@/components/karte";
+import { Status } from "@/components/status";
+import { darf } from "@/server/auth/rechte";
+import { seiteSchuetzen } from "@/server/auth/zugang";
+import { serverListe } from "@/server/services/server";
+import { ServerStatus } from "./server-status";
+
+export const metadata: Metadata = { title: "Server" };
+
+export default async function ServerSeite() {
+ const benutzer = await seiteSchuetzen("lesen", "/server");
+ const liste = await serverListe();
+ const verwalten = darf(benutzer.rolle, "serverVerwalten");
+
+ return (
+ Server anlegen
+
+
+
+
+ {liste.length === 0 ? (
+
+ Noch kein Server angelegt.
+ {!verwalten ?
+ ) : (
+
+ );
+}
diff --git a/src/app/(app)/server/server-formular.tsx b/src/app/(app)/server/server-formular.tsx
new file mode 100644
index 0000000..688fef0
--- /dev/null
+++ b/src/app/(app)/server/server-formular.tsx
@@ -0,0 +1,422 @@
+"use client";
+
+import { ShieldCheck } from "lucide-react";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { EINGABE_KLASSE, Feld, Schalter, beschreibung, Code } from "@/components/formular";
+import { Karte } from "@/components/karte";
+import { Knopf } from "@/components/knopf";
+import { Status } from "@/components/status";
+import { apiAufruf, ApiFehler } from "@/lib/api-client";
+import type { ServerSicht } from "@/lib/schemas/server";
+
+type Zertifikat = {
+ fingerabdruck: string;
+ subjekt: string;
+ aussteller: string;
+ gueltigBis: string;
+ alternativeNamen: string[];
+ vertraut: boolean;
+ fehlerGrund: string | null;
+};
+
+type PruefErgebnis = {
+ zertifikat: Zertifikat | null;
+ pinPasst: boolean | null;
+ verbindung:
+ | { ok: true; version: string; release: string }
+ | { ok: false; art: string; ursache: string; hinweis: string }
+ | null;
+};
+
+type Werte = {
+ name: string;
+ titel: string;
+ url: string;
+ tokenId: string;
+ tokenGeheimnis: string;
+ tlsPruefen: boolean;
+ fingerabdruck: string | null;
+ sshAktiv: boolean;
+ sshBenutzer: string;
+ sshPort: string;
+ templateVmidVon: string;
+ templateVmidBis: string;
+ gastVmidVon: string;
+};
+
+function anfangswerte(server?: ServerSicht): Werte {
+ return {
+ name: server?.name ?? "",
+ titel: server?.titel ?? "",
+ url: server?.url ?? "",
+ tokenId: server?.tokenId ?? "",
+ tokenGeheimnis: "",
+ tlsPruefen: server?.tlsPruefen ?? false,
+ fingerabdruck: server?.fingerabdruck ?? null,
+ sshAktiv: server?.sshAktiv ?? false,
+ sshBenutzer: server?.sshBenutzer ?? "root",
+ sshPort: String(server?.sshPort ?? 22),
+ templateVmidVon: String(server?.templateVmidVon ?? 9000),
+ templateVmidBis: String(server?.templateVmidBis ?? 9999),
+ gastVmidVon: String(server?.gastVmidVon ?? 100),
+ };
+}
+
+/**
+ * Anlegen und Bearbeiten eines Proxmox-Servers. Ablauf: Adresse → Zertifikat ansehen und
+ * bestätigen → Token → Verbindung prüfen → speichern. Speichern geht auch ohne erfolgreiche
+ * Prüfung (der Host kann gerade aus sein), aber nie ohne bestätigten Fingerprint oder TLS-Prüfung.
+ */
+export function ServerFormular({ server }: { server?: ServerSicht }) {
+ const router = useRouter();
+ const bearbeiten = Boolean(server);
+ const [werte, setWerte] = useState
+
+ {verwalten ? (
+
+ Server anlegen
+
+ ) : null}
+ Server
+Proxmox-VE-Hosts und -Cluster, auf die ProxDeploy ausrollt.
+Server legt ein Administrator an.
: null} +-
+ {liste.map((server) => (
+
-
+
+ ++++
{server.titel}
+{server.name}
++ {server.url}
+ +
+ ))}
+