feat(cli): proxdeploy in Go

Befehle login, servers, distros, profiles, presets, vm, lxc, template list|build, batch, status, logs --follow, cancel. Renderer im Aufbau der Vorgabe (zeichengenau per Golden-File), 24-bit/256/ohne Farbe, --ascii, --quiet, --json, --dry-run; live im Terminal, zeilenweise ohne. SSE mit Wiederverbinden und Polling als Rückfall. Typen aus openapi.json per oapi-codegen; Release-Builds per cli/bauen.sh.

Refs #013

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

cli/internal/ausgabe/darstellung.go

@@ -0,0 +1,231 @@
+package ausgabe
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/mattn/go-runewidth"
+)
+
+// Phase, wie sie gezeigt wird – Felder kommen unverändert aus der API.
+type Phase struct {
+	Titel   string
+	Status  string // OFFEN, LAEUFT, ERLEDIGT, FEHLER, UEBERSPRUNGEN
+	Detail  string
+	Ursache string
+	Hinweis string
+	// Laufzeit der laufenden Phase (nur bei LAEUFT).
+	Laufzeit time.Duration
+}
+
+// Box ist die Abschlussbox; Zeilen sind [Bezeichnung, Wert].
+type Box struct {
+	Ok     bool
+	Titel  string
+	Dauer  string
+	Zeilen [][2]string
+}
+
+// Aufruf ist ein geplanter Proxmox-Aufruf im Dry-Run.
+type Aufruf struct {
+	Methode   string
+	Pfad      string
+	Parameter map[string]any
+}
+
+// Dauer wie in Web-GUI und Engine: „18s“, „1m 12s“, „1h 03m“.
+func Dauer(d time.Duration) string {
+	s := int((d + 500*time.Millisecond) / time.Second)
+	if s < 0 {
+		s = 0
+	}
+	switch {
+	case s < 60:
+		return fmt.Sprintf("%ds", s)
+	case s < 3600:
+		return fmt.Sprintf("%dm %02ds", s/60, s%60)
+	default:
+		return fmt.Sprintf("%dh %02dm", s/3600, (s%3600)/60)
+	}
+}
+
+// Kopf: „⬡ ProxDeploy v1.0 · Server rz1 · …“ – Prox in Paper, Deploy fett in Teal, Rest Muted.
+func (s Stil) Kopf(version, kopf string, trocken bool) string {
+	var b strings.Builder
+	if !s.ASCII {
+		b.WriteString(s.Muted("⬡ "))
+	}
+	b.WriteString(s.Paper("Prox"))
+	b.WriteString(s.TealFett("Deploy"))
+	rest := " v" + version
+	if kopf != "" {
+		rest += " · " + kopf
+	}
+	b.WriteString(s.Muted(rest))
+	if trocken {
+		b.WriteString(s.AmberFett(" · DRY-RUN"))
+	}
+	return b.String()
+}
+
+// Spaltenbreite der Phasennamen: längster Name + 2, mindestens 14 (wie die Web-GUI).
+func Spaltenbreite(phasen []Phase) int {
+	breite := 12
+	for _, p := range phasen {
+		if w := runewidth.StringWidth(p.Titel); w > breite {
+			breite = w
+		}
+	}
+	return breite + 2
+}
+
+// PhasenZeilen setzt jede Phase als Zeile: Symbol, Name in fester Breite, Detail in Muted. Bei
+// Fehler Ursache in Rot und darunter der Hinweis. `takt` dreht den Spinner der laufenden Phase.
+func (s Stil) PhasenZeilen(phasen []Phase, takt int) []string {
+	return s.PhasenZeilenMit(phasen, Spaltenbreite(phasen), takt)
+}
+
+// PhasenZeilenMit setzt mit fester Spaltenbreite – live bleibt sie so stabil, auch wenn noch nicht
+// alle Phasen sichtbar sind.
+func (s Stil) PhasenZeilenMit(phasen []Phase, breite, takt int) []string {
+	einzug := strings.Repeat(" ", runewidth.StringWidth(s.symbol("OFFEN"))+1+breite)
+	var zeilen []string
+	for _, p := range phasen {
+		symbol := s.symbol(p.Status)
+		if p.Status == "LAEUFT" && !s.ASCII {
+			symbol = spinner[takt%len(spinner)]
+		}
+		titel := p.Titel + strings.Repeat(" ", breite-runewidth.StringWidth(p.Titel))
+		var z strings.Builder
+		switch p.Status {
+		case "ERLEDIGT":
+			z.WriteString(s.Teal(symbol) + " " + s.Paper(titel))
+		case "LAEUFT":
+			z.WriteString(s.Amber(symbol) + " " + s.Paper(titel))
+		case "FEHLER":
+			z.WriteString(s.Rot(symbol) + " " + s.Paper(titel))
+		default:
+			z.WriteString(s.Muted(symbol) + " " + s.Muted(titel))
+		}
+		switch p.Status {
+		case "FEHLER":
+			z.WriteString(s.Rot(erste(p.Ursache, p.Detail)))
+			zeilen = append(zeilen, strings.TrimRight(z.String(), " "))
+			if p.Hinweis != "" {
+				zeilen = append(zeilen, einzug+s.Muted("→ "+p.Hinweis))
+			}
+			continue
+		case "LAEUFT":
+			text := Dauer(p.Laufzeit)
+			if p.Detail != "" {
+				text = p.Detail + " … " + text
+			}
+			z.WriteString(s.Muted(text))
+		default:
+			z.WriteString(s.Muted(p.Detail))
+		}
+		zeilen = append(zeilen, strings.TrimRight(z.String(), " "))
+	}
+	return zeilen
+}
+
+func erste(werte ...string) string {
+	for _, w := range werte {
+		if w != "" {
+			return w
+		}
+	}
+	return ""
+}
+
+// Mindestbreite der Box innen (zwischen den Rahmenstrichen) – wie im Mockup.
+const boxMindestbreite = 38
+
+// BoxZeilen setzt die Abschlussbox: Rahmen Teal (Erfolg) oder Rot, Breite aus dem Inhalt.
+func (s Stil) BoxZeilen(b Box) []string {
+	rahmen := s.Teal
+	kopfSymbol := "●"
+	if !b.Ok {
+		rahmen = s.Rot
+		kopfSymbol = "✗"
+	}
+	if s.ASCII {
+		kopfSymbol = map[bool]string{true: "[OK]", false: "[!!]"}[b.Ok]
+	}
+	type zeile struct{ roh, farbig string }
+	kopf := kopfSymbol + " " + b.Titel
+	kopfFarbig := rahmen(kopfSymbol) + " " + s.Fett(b.Titel)
+	if b.Dauer != "" {
+		kopf += "  ·  " + b.Dauer
+		kopfFarbig += s.Muted("  ·  " + b.Dauer)
+	}
+	inhalt := []zeile{{kopf, kopfFarbig}}
+
+	label := 7
+	for _, z := range b.Zeilen {
+		if w := runewidth.StringWidth(z[0]); w > label {
+			label = w
+		}
+	}
+	label += 2
+	for _, z := range b.Zeilen {
+		name := z[0] + strings.Repeat(" ", label-runewidth.StringWidth(z[0]))
+		inhalt = append(inhalt, zeile{name + z[1], s.Muted(name) + s.Paper(z[1])})
+	}
+
+	breite := boxMindestbreite
+	for _, z := range inhalt {
+		if w := runewidth.StringWidth(z.roh) + 4; w > breite {
+			breite = w
+		}
+	}
+	ol, or, ul, ur, h, v := "┌", "┐", "└", "┘", "─", "│"
+	if s.ASCII {
+		ol, or, ul, ur, h, v = "+", "+", "+", "+", "-", "|"
+	}
+	zeilen := []string{rahmen(ol + strings.Repeat(h, breite) + or)}
+	for _, z := range inhalt {
+		luecke := breite - 1 - runewidth.StringWidth(z.roh)
+		zeilen = append(zeilen, rahmen(v)+" "+z.farbig+strings.Repeat(" ", luecke)+rahmen(v))
+	}
+	zeilen = append(zeilen, rahmen(ul+strings.Repeat(h, breite)+ur))
+	return zeilen
+}
+
+// AufrufZeilen: jeder geplante Aufruf als „→ POST /pfad k=v …“, lange Werte gekürzt wie im Web.
+func (s Stil) AufrufZeilen(aufrufe []Aufruf) []string {
+	pfeil := "→ "
+	if s.ASCII {
+		pfeil = "-> "
+	}
+	var zeilen []string
+	for _, a := range aufrufe {
+		z := s.Amber(pfeil) + s.Paper(a.Methode+" "+a.Pfad)
+		if len(a.Parameter) > 0 {
+			namen := make([]string, 0, len(a.Parameter))
+			for n := range a.Parameter {
+				namen = append(namen, n)
+			}
+			sort.Strings(namen)
+			teile := make([]string, 0, len(namen))
+			for _, n := range namen {
+				teile = append(teile, n+"="+kuerzen(fmt.Sprint(a.Parameter[n]), 60))
+			}
+			z += " " + s.Muted(strings.Join(teile, " "))
+		}
+		zeilen = append(zeilen, z)
+	}
+	return zeilen
+}
+
+func kuerzen(text string, hoechstens int) string {
+	// Eine Zeile je Aufruf: Umbrüche (z. B. in der Beschreibung) sichtbar, aber einzeilig.
+	text = strings.NewReplacer("\r\n", "⏎", "\n", "⏎").Replace(text)
+	r := []rune(text)
+	if len(r) <= hoechstens {
+		return text
+	}
+	return string(r[:hoechstens-3]) + "…"
+}

cli/internal/ausgabe/darstellung_test.go

@@ -0,0 +1,118 @@
+package ausgabe
+
+import (
+	"flag"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+var aktualisieren = flag.Bool("update", false, "Golden-Dateien neu schreiben")
+
+// Die Beispielausgabe aus der Vorgabe.
+var mockPhasen = []Phase{
+	{Titel: "Prüfungen", Status: "ERLEDIGT", Detail: "VMID 120 frei · local-zfs · vmbr0 VLAN 20"},
+	{Titel: "Klonen", Status: "ERLEDIGT", Detail: "full clone 9013 → 120 · Disk auf 40G"},
+	{Titel: "cloud-init", Status: "ERLEDIGT", Detail: "user florian · SSH-Key · Profile base, docker"},
+	{Titel: "Start", Status: "ERLEDIGT", Detail: "VM 120 läuft"},
+	{Titel: "Guest-Agent", Status: "ERLEDIGT", Detail: "antwortet nach 18s"},
+	{Titel: "Provisionierung", Status: "LAEUFT", Detail: "cloud-init läuft", Laufzeit: 72 * time.Second},
+}
+
+var mockBox = Box{
+	Ok:    true,
+	Titel: "web01 bereit",
+	Dauer: "1m 54s",
+	Zeilen: [][2]string{
+		{"VMID", "120"},
+		{"IP", "10.0.20.15"},
+		{"Profile", "base, docker"},
+		{"SSH", "ssh florian@10.0.20.15"},
+	},
+}
+
+func mockAusgabe(s Stil) string {
+	zeilen := []string{s.Kopf("1.0", "Server rz1 · Node pve01 · Debian 13 (Template 9013)", false), ""}
+	zeilen = append(zeilen, s.PhasenZeilen(mockPhasen, 0)...)
+	zeilen = append(zeilen, "")
+	zeilen = append(zeilen, s.BoxZeilen(mockBox)...)
+	return strings.Join(zeilen, "\n") + "\n"
+}
+
+func golden(t *testing.T, name, ist string) {
+	t.Helper()
+	pfad := filepath.Join("testdata", name)
+	if *aktualisieren {
+		if err := os.WriteFile(pfad, []byte(ist), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	soll, err := os.ReadFile(pfad)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ist != string(soll) {
+		t.Errorf("%s weicht ab.\n--- soll\n%s\n--- ist\n%s", name, soll, ist)
+	}
+}
+
+// Ohne Farbe muss die Ausgabe zeichengenau dem Mockup der Vorgabe entsprechen.
+// mockup.txt ist von Hand aus der Vorgabe übernommen und wird nie mit -update überschrieben.
+func TestMockupZeichengenau(t *testing.T) {
+	soll, err := os.ReadFile(filepath.Join("testdata", "mockup.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ist := mockAusgabe(Stil{}); ist != string(soll) {
+		t.Errorf("weicht vom Mockup ab.\n--- soll\n%s\n--- ist\n%s", soll, ist)
+	}
+}
+
+func TestFarbenUndAscii(t *testing.T) {
+	golden(t, "mockup-24bit.golden", mockAusgabe(Stil{Farbe: Echtfarben}))
+	golden(t, "mockup-256.golden", mockAusgabe(Stil{Farbe: Farben256}))
+	golden(t, "mockup-ascii.golden", mockAusgabe(Stil{ASCII: true}))
+}
+
+func TestFehlerUndDryRun(t *testing.T) {
+	s := Stil{}
+	zeilen := []string{s.Kopf("1.0", "Server rz1 · Node pve01 · Debian 13", true), ""}
+	zeilen = append(zeilen, s.PhasenZeilen([]Phase{
+		{Titel: "Prüfungen", Status: "ERLEDIGT", Detail: "VMID 120 frei"},
+		{Titel: "Template", Status: "UEBERSPRUNGEN", Detail: "vorhanden (9013)"},
+		{Titel: "Klonen", Status: "FEHLER", Ursache: "Storage local-zfs ist voll.", Hinweis: "Anderen Storage wählen."},
+	}, 0)...)
+	zeilen = append(zeilen, "")
+	zeilen = append(zeilen, s.AufrufZeilen([]Aufruf{
+		{Methode: "POST", Pfad: "/nodes/pve01/qemu/9013/clone", Parameter: map[string]any{"newid": 120, "full": 1, "name": "web01"}},
+		{Methode: "PUT", Pfad: "/nodes/pve01/qemu/120/config", Parameter: map[string]any{"sshkeys": strings.Repeat("A", 80), "description": "Zeile 1\nZeile 2"}},
+	})...)
+	zeilen = append(zeilen, "")
+	zeilen = append(zeilen, s.BoxZeilen(Box{
+		Titel: "web01 fehlgeschlagen", Dauer: "12s",
+		Zeilen: [][2]string{{"Phase", "Klonen"}, {"Ursache", "Storage local-zfs ist voll."}, {"Hinweis", "Anderen Storage wählen und die VM mit einem sehr langen Hinweis neu ausrollen."}},
+	})...)
+	golden(t, "fehler-dryrun.golden", strings.Join(zeilen, "\n")+"\n")
+}
+
+func TestDauer(t *testing.T) {
+	for d, soll := range map[time.Duration]string{
+		0: "0s", 18 * time.Second: "18s", 72 * time.Second: "1m 12s", 65 * time.Second: "1m 05s",
+		3780 * time.Second: "1h 03m", 1499 * time.Millisecond: "1s",
+	} {
+		if ist := Dauer(d); ist != soll {
+			t.Errorf("Dauer(%v) = %q, soll %q", d, ist, soll)
+		}
+	}
+}
+
+func TestXterm256(t *testing.T) {
+	// Teal #2DD4BF → 43 (#00d7af), Paper #E6EDF3 → 254 (Graustufe #e4e4e4), Rot #F87171 → 203 (#ff5f5f).
+	for f, soll := range map[rgb]int{teal: 43, paper: 254, rot: 203} {
+		if ist := xterm256(f); ist != soll {
+			t.Errorf("xterm256(%v) = %d, soll %d", f, ist, soll)
+		}
+	}
+}

cli/internal/ausgabe/stil.go

@@ -0,0 +1,147 @@
+// Package ausgabe rendert die CLI-Ausgabe im Aufbau der Vorgabe: Kopfzeile, Phasen, Abschlussbox.
+// Alle Texte kommen aus der Engine; hier wird nur gesetzt und gefärbt.
+package ausgabe
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+// Farbmodus: 24-bit, 256 Farben oder keine.
+type Farbmodus int
+
+const (
+	Aus Farbmodus = iota
+	Farben256
+	Echtfarben
+)
+
+// Die Markenfarben (siehe README, Abschnitt Branding).
+type rgb struct{ r, g, b uint8 }
+
+var (
+	paper = rgb{0xE6, 0xED, 0xF3}
+	muted = rgb{0x8B, 0x98, 0xA5}
+	teal  = rgb{0x2D, 0xD4, 0xBF}
+	amber = rgb{0xF5, 0xB8, 0x41}
+	rot   = rgb{0xF8, 0x71, 0x71}
+)
+
+// Stil legt fest, wie gesetzt wird: Farben und ob nur ASCII-Symbole erlaubt sind.
+type Stil struct {
+	Farbe Farbmodus
+	ASCII bool
+}
+
+// FarbmodusErmitteln: aus bei NO_COLOR, --no-color oder ohne Terminal; sonst 24-bit, wenn das
+// Terminal es meldet (COLORTERM), sonst 256 Farben.
+func FarbmodusErmitteln(keineFarbe, istTerminal bool) Farbmodus {
+	if keineFarbe || !istTerminal {
+		return Aus
+	}
+	if _, gesetzt := os.LookupEnv("NO_COLOR"); gesetzt {
+		return Aus
+	}
+	if os.Getenv("TERM") == "dumb" {
+		return Aus
+	}
+	switch strings.ToLower(os.Getenv("COLORTERM")) {
+	case "truecolor", "24bit":
+		return Echtfarben
+	}
+	return Farben256
+}
+
+func (s Stil) faerben(f rgb, fett bool, text string) string {
+	if s.Farbe == Aus || text == "" {
+		return text
+	}
+	var code string
+	switch s.Farbe {
+	case Echtfarben:
+		code = fmt.Sprintf("38;2;%d;%d;%d", f.r, f.g, f.b)
+	default:
+		code = fmt.Sprintf("38;5;%d", xterm256(f))
+	}
+	if fett {
+		code = "1;" + code
+	}
+	return "\x1b[" + code + "m" + text + "\x1b[0m"
+}
+
+func (s Stil) Paper(t string) string    { return s.faerben(paper, false, t) }
+func (s Stil) Fett(t string) string     { return s.faerben(paper, true, t) }
+func (s Stil) Muted(t string) string    { return s.faerben(muted, false, t) }
+func (s Stil) Teal(t string) string     { return s.faerben(teal, false, t) }
+func (s Stil) TealFett(t string) string { return s.faerben(teal, true, t) }
+func (s Stil) Amber(t string) string    { return s.faerben(amber, false, t) }
+func (s Stil) AmberFett(t string) string {
+	return s.faerben(amber, true, t)
+}
+func (s Stil) Rot(t string) string { return s.faerben(rot, false, t) }
+
+// xterm256 wählt die nächste Farbe aus Würfel (16–231) oder Graustufen (232–255).
+func xterm256(f rgb) int {
+	stufen := []int{0, 95, 135, 175, 215, 255}
+	naechste := func(wert uint8) int {
+		beste, abstand := 0, 1<<30
+		for i, s := range stufen {
+			d := int(wert) - s
+			if d*d < abstand {
+				beste, abstand = i, d*d
+			}
+		}
+		return beste
+	}
+	r, g, b := naechste(f.r), naechste(f.g), naechste(f.b)
+	wuerfel := 16 + 36*r + 6*g + b
+	dw := quadAbstand(f, stufen[r], stufen[g], stufen[b])
+
+	grau := (int(f.r) + int(f.g) + int(f.b)) / 3
+	gi := (grau - 8) / 10
+	if gi < 0 {
+		gi = 0
+	} else if gi > 23 {
+		gi = 23
+	}
+	gw := 8 + gi*10
+	if quadAbstand(f, gw, gw, gw) < dw {
+		return 232 + gi
+	}
+	return wuerfel
+}
+
+func quadAbstand(f rgb, r, g, b int) int {
+	dr, dg, db := int(f.r)-r, int(f.g)-g, int(f.b)-b
+	return dr*dr + dg*dg + db*db
+}
+
+// Symbole je Status, mit ASCII-Ersatz (--ascii).
+func (s Stil) symbol(status string) string {
+	if s.ASCII {
+		switch status {
+		case "ERLEDIGT":
+			return "[OK]"
+		case "LAEUFT":
+			return "[..]"
+		case "FEHLER":
+			return "[!!]"
+		default:
+			return "[--]"
+		}
+	}
+	switch status {
+	case "ERLEDIGT":
+		return "✓"
+	case "LAEUFT":
+		return "◐"
+	case "FEHLER":
+		return "✗"
+	default:
+		return "○"
+	}
+}
+
+// Spinner für die laufende Phase: ◐◓◑◒.
+var spinner = []string{"◐", "◓", "◑", "◒"}

cli/internal/ausgabe/testdata/fehler-dryrun.golden

@@ -0,0 +1,16 @@
+⬡ ProxDeploy v1.0 · Server rz1 · Node pve01 · Debian 13 · DRY-RUN
+
+✓ Prüfungen     VMID 120 frei
+○ Template      vorhanden (9013)
+✗ Klonen        Storage local-zfs ist voll.
+                → Anderen Storage wählen.
+
+→ POST /nodes/pve01/qemu/9013/clone full=1 name=web01 newid=120
+→ PUT /nodes/pve01/qemu/120/config description=Zeile 1⏎Zeile 2 sshkeys=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA…
+
+┌───────────────────────────────────────────────────────────────────────────────────────────┐
+│ ✗ web01 fehlgeschlagen  ·  12s                                                            │
+│ Phase    Klonen                                                                           │
+│ Ursache  Storage local-zfs ist voll.                                                      │
+│ Hinweis  Anderen Storage wählen und die VM mit einem sehr langen Hinweis neu ausrollen.   │
+└───────────────────────────────────────────────────────────────────────────────────────────┘

cli/internal/ausgabe/testdata/mockup-24bit.golden

@@ -0,0 +1,16 @@
+⬡ ProxDeploy v1.0 · Server rz1 · Node pve01 · Debian 13 (Template 9013)
+
+✓ Prüfungen        VMID 120 frei · local-zfs · vmbr0 VLAN 20
+✓ Klonen           full clone 9013 → 120 · Disk auf 40G
+✓ cloud-init       user florian · SSH-Key · Profile base, docker
+✓ Start            VM 120 läuft
+✓ Guest-Agent      antwortet nach 18s
+◐ Provisionierung  cloud-init läuft … 1m 12s
+
+┌──────────────────────────────────────┐
+│ ● web01 bereit  ·  1m 54s            │
+│ VMID     120                         │
+│ IP       10.0.20.15                  │
+│ Profile  base, docker                │
+│ SSH      ssh florian@10.0.20.15      │
+└──────────────────────────────────────┘

cli/internal/ausgabe/testdata/mockup-256.golden

@@ -0,0 +1,16 @@
+⬡ ProxDeploy v1.0 · Server rz1 · Node pve01 · Debian 13 (Template 9013)
+
+✓ Prüfungen        VMID 120 frei · local-zfs · vmbr0 VLAN 20
+✓ Klonen           full clone 9013 → 120 · Disk auf 40G
+✓ cloud-init       user florian · SSH-Key · Profile base, docker
+✓ Start            VM 120 läuft
+✓ Guest-Agent      antwortet nach 18s
+◐ Provisionierung  cloud-init läuft … 1m 12s
+
+┌──────────────────────────────────────┐
+│ ● web01 bereit  ·  1m 54s            │
+│ VMID     120                         │
+│ IP       10.0.20.15                  │
+│ Profile  base, docker                │
+│ SSH      ssh florian@10.0.20.15      │
+└──────────────────────────────────────┘

cli/internal/ausgabe/testdata/mockup-ascii.golden

@@ -0,0 +1,16 @@
+ProxDeploy v1.0 · Server rz1 · Node pve01 · Debian 13 (Template 9013)
+
+[OK] Prüfungen        VMID 120 frei · local-zfs · vmbr0 VLAN 20
+[OK] Klonen           full clone 9013 → 120 · Disk auf 40G
+[OK] cloud-init       user florian · SSH-Key · Profile base, docker
+[OK] Start            VM 120 läuft
+[OK] Guest-Agent      antwortet nach 18s
+[..] Provisionierung  cloud-init läuft … 1m 12s
+
++--------------------------------------+
+| [OK] web01 bereit  ·  1m 54s         |
+| VMID     120                         |
+| IP       10.0.20.15                  |
+| Profile  base, docker                |
+| SSH      ssh florian@10.0.20.15      |
++--------------------------------------+

cli/internal/ausgabe/testdata/mockup.txt

@@ -0,0 +1,16 @@
+⬡ ProxDeploy v1.0 · Server rz1 · Node pve01 · Debian 13 (Template 9013)
+
+✓ Prüfungen        VMID 120 frei · local-zfs · vmbr0 VLAN 20
+✓ Klonen           full clone 9013 → 120 · Disk auf 40G
+✓ cloud-init       user florian · SSH-Key · Profile base, docker
+✓ Start            VM 120 läuft
+✓ Guest-Agent      antwortet nach 18s
+◐ Provisionierung  cloud-init läuft … 1m 12s
+
+┌──────────────────────────────────────┐
+│ ● web01 bereit  ·  1m 54s            │
+│ VMID     120                         │
+│ IP       10.0.20.15                  │
+│ Profile  base, docker                │
+│ SSH      ssh florian@10.0.20.15      │
+└──────────────────────────────────────┘