Improve hostname visibility and harden the ProxSave cloud relay

.github/workflows/codecov.yml

@@ -18,7 +18,18 @@ jobs:
         with:
           go-version-file: 'go.mod'
 
+      - name: Resolve coverage toolchain
+        run: |
+          TOOLCHAIN_FROM_MOD=$(awk '/^toolchain /{print $2}' go.mod)
+          if [ -n "$TOOLCHAIN_FROM_MOD" ]; then
+            echo "COVER_GOTOOLCHAIN=${TOOLCHAIN_FROM_MOD}+auto" >> "$GITHUB_ENV"
+          else
+            echo "COVER_GOTOOLCHAIN=auto" >> "$GITHUB_ENV"
+          fi
+
       - name: Run tests with coverage
+        env:
+          GOTOOLCHAIN: ${{ env.COVER_GOTOOLCHAIN }}
         run: |
           go test $(go list ./... | grep -v -E '/cmd/|/pbs$|/bech32$|^github.com/tis24dev/proxsave$') -coverprofile=coverage.out
 

internal/orchestrator/additional_helpers_test.go

@@ -198,12 +198,14 @@ func TestApplyStorageStatsSimplePrimary(t *testing.T) {
 }
 
 func TestApplyStorageStatsGFSPrimary(t *testing.T) {
-	now := time.Now()
+	now := time.Now().UTC()
+	previousMonthBackup := time.Date(now.Year(), now.Month(), 1, now.Hour(), now.Minute(), now.Second(), now.Nanosecond(), time.UTC).Add(-24 * time.Hour)
+	previousYearBackup := time.Date(now.Year()-1, time.January, 15, now.Hour(), now.Minute(), now.Second(), now.Nanosecond(), time.UTC)
 	backups := []*types.BackupMetadata{
 		{Timestamp: now},                    // daily
 		{Timestamp: now.AddDate(0, 0, -8)},  // weekly
-		{Timestamp: now.AddDate(0, -1, -1)}, // monthly
-		{Timestamp: now.AddDate(-1, 0, 0)},  // yearly
+		{Timestamp: previousMonthBackup},    // monthly
+		{Timestamp: previousYearBackup},     // yearly
 	}
 	adapter := &StorageAdapter{
 		backend: &stubStorage{loc: storage.LocationPrimary, list: backups},
@@ -962,7 +964,7 @@ func TestPromptClusterRestoreMode(t *testing.T) {
 }
 
 func TestConfirmRestoreAction(t *testing.T) {
-	cand := &decryptCandidate{
+	cand := &backupCandidate{
 		Manifest: &backup.Manifest{
 			CreatedAt:   time.Now(),
 			ArchivePath: "test.tar",

internal/orchestrator/backup_candidate_display.go

@@ -0,0 +1,176 @@
+package orchestrator
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/tis24dev/proxsave/internal/backup"
+)
+
+const (
+	backupCandidateDisplayTimeLayout = "2006-01-02 15:04:05"
+	unknownBackupDateText            = "unknown date"
+	unknownBackupHostText            = "unknown host"
+	unknownBackupTargetText          = "UNKNOWN"
+)
+
+type backupCandidateDisplay struct {
+	Created     string
+	Hostname    string
+	Mode        string
+	Tool        string
+	Target      string
+	Compression string
+	Base        string
+	Summary     string
+}
+
+func describeBackupCandidate(cand *backupCandidate) backupCandidateDisplay {
+	display := backupCandidateDisplay{
+		Created:     formatBackupCandidateCreated(cand),
+		Hostname:    formatBackupCandidateHostname(cand),
+		Mode:        formatBackupCandidateMode(cand),
+		Tool:        formatBackupCandidateTool(cand),
+		Target:      formatBackupCandidateTarget(candidateManifest(cand)),
+		Compression: formatBackupCandidateCompression(cand),
+		Base:        backupCandidateBaseName(cand),
+	}
+	display.Summary = formatBackupCandidateSummary(display)
+	return display
+}
+
+func candidateManifest(cand *backupCandidate) *backup.Manifest {
+	if cand == nil {
+		return nil
+	}
+	return cand.Manifest
+}
+
+func formatBackupCandidateCreated(cand *backupCandidate) string {
+	manifest := candidateManifest(cand)
+	if manifest == nil || manifest.CreatedAt.IsZero() {
+		return unknownBackupDateText
+	}
+	return manifest.CreatedAt.Format(backupCandidateDisplayTimeLayout)
+}
+
+func formatBackupCandidateHostname(cand *backupCandidate) string {
+	manifest := candidateManifest(cand)
+	if manifest == nil {
+		return unknownBackupHostText
+	}
+	host := strings.TrimSpace(manifest.Hostname)
+	if host == "" {
+		return unknownBackupHostText
+	}
+	return host
+}
+
+func formatBackupCandidateMode(cand *backupCandidate) string {
+	manifest := candidateManifest(cand)
+	if manifest == nil {
+		return "UNKNOWN"
+	}
+	mode := strings.ToUpper(statusFromManifest(manifest))
+	if mode == "" {
+		return "UNKNOWN"
+	}
+	return mode
+}
+
+func formatBackupCandidateTool(cand *backupCandidate) string {
+	manifest := candidateManifest(cand)
+	if manifest == nil {
+		return "Tool unknown"
+	}
+	version := strings.TrimSpace(manifest.ScriptVersion)
+	if version == "" {
+		return "Tool unknown"
+	}
+	if !strings.HasPrefix(strings.ToLower(version), "v") {
+		version = "v" + version
+	}
+	return "Tool " + version
+}
+
+func formatBackupCandidateTarget(manifest *backup.Manifest) string {
+	if manifest == nil {
+		return unknownBackupTargetText
+	}
+
+	targets := formatTargets(manifest)
+	targets = strings.TrimSpace(targets)
+	if targets == "" || targets == "unknown target" {
+		targets = unknownBackupTargetText
+	} else {
+		targets = strings.ToUpper(targets)
+	}
+
+	version := normalizeProxmoxVersion(manifest.ProxmoxVersion)
+	if version != "" {
+		targets = fmt.Sprintf("%s %s", targets, version)
+	}
+
+	if cluster := formatClusterMode(manifest.ClusterMode); cluster != "" {
+		targets = fmt.Sprintf("%s (%s)", targets, cluster)
+	}
+
+	return targets
+}
+
+func formatBackupCandidateCompression(cand *backupCandidate) string {
+	manifest := candidateManifest(cand)
+	if manifest == nil {
+		return ""
+	}
+	compression := strings.TrimSpace(manifest.CompressionType)
+	if compression == "" {
+		return ""
+	}
+	return strings.ToUpper(compression)
+}
+
+func backupCandidateBaseName(cand *backupCandidate) string {
+	if cand == nil {
+		return ""
+	}
+	base := strings.TrimSpace(cand.DisplayBase)
+	if base != "" {
+		return base
+	}
+
+	switch {
+	case strings.TrimSpace(cand.BundlePath) != "":
+		return filepath.Base(strings.TrimSpace(cand.BundlePath))
+	case strings.TrimSpace(cand.RawArchivePath) != "":
+		return filepath.Base(strings.TrimSpace(cand.RawArchivePath))
+	default:
+		return ""
+	}
+}
+
+func formatBackupCandidateSummary(display backupCandidateDisplay) string {
+	parts := make([]string, 0, 2)
+
+	if display.Hostname != "" && display.Hostname != unknownBackupHostText {
+		parts = append(parts, display.Hostname)
+	}
+
+	switch {
+	case display.Base != "" && display.Created != "" && display.Created != unknownBackupDateText:
+		parts = append(parts, fmt.Sprintf("%s (%s)", display.Base, display.Created))
+	case display.Base != "":
+		parts = append(parts, display.Base)
+	case display.Created != "" && display.Created != unknownBackupDateText:
+		parts = append(parts, display.Created)
+	}
+
+	if len(parts) == 0 {
+		if display.Hostname != "" {
+			return display.Hostname
+		}
+		return display.Created
+	}
+	return strings.Join(parts, " • ")
+}

internal/orchestrator/backup_candidate_display_test.go

@@ -0,0 +1,119 @@
+package orchestrator
+
+import (
+	"bufio"
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/tis24dev/proxsave/internal/backup"
+)
+
+func TestDescribeBackupCandidate_Full(t *testing.T) {
+	created := time.Date(2026, time.March, 22, 12, 21, 22, 0, time.UTC)
+	cand := &backupCandidate{
+		DisplayBase: "backup.tar.xz",
+		Manifest: &backup.Manifest{
+			CreatedAt:       created,
+			Hostname:        "node1.example.com",
+			EncryptionMode:  "age",
+			ScriptVersion:   "1.2.3",
+			ProxmoxTargets:  []string{"pve"},
+			ProxmoxVersion:  "8.0",
+			ClusterMode:     "cluster",
+			CompressionType: "xz",
+		},
+	}
+
+	display := describeBackupCandidate(cand)
+	if display.Created != "2026-03-22 12:21:22" {
+		t.Fatalf("Created=%q", display.Created)
+	}
+	if display.Hostname != "node1.example.com" {
+		t.Fatalf("Hostname=%q", display.Hostname)
+	}
+	if display.Mode != "ENCRYPTED" {
+		t.Fatalf("Mode=%q", display.Mode)
+	}
+	if display.Tool != "Tool v1.2.3" {
+		t.Fatalf("Tool=%q", display.Tool)
+	}
+	if display.Target != "PVE v8.0 (cluster)" {
+		t.Fatalf("Target=%q", display.Target)
+	}
+	if display.Compression != "XZ" {
+		t.Fatalf("Compression=%q", display.Compression)
+	}
+	if display.Summary != "node1.example.com • backup.tar.xz (2026-03-22 12:21:22)" {
+		t.Fatalf("Summary=%q", display.Summary)
+	}
+}
+
+func TestDescribeBackupCandidate_Fallbacks(t *testing.T) {
+	cand := &backupCandidate{
+		RawArchivePath: "/tmp/archive.tar.xz",
+		Manifest:       &backup.Manifest{},
+	}
+
+	display := describeBackupCandidate(cand)
+	if display.Created != unknownBackupDateText {
+		t.Fatalf("Created=%q, want %q", display.Created, unknownBackupDateText)
+	}
+	if display.Hostname != unknownBackupHostText {
+		t.Fatalf("Hostname=%q, want %q", display.Hostname, unknownBackupHostText)
+	}
+	if display.Mode != "PLAIN" {
+		t.Fatalf("Mode=%q, want %q", display.Mode, "PLAIN")
+	}
+	if display.Tool != "Tool unknown" {
+		t.Fatalf("Tool=%q, want %q", display.Tool, "Tool unknown")
+	}
+	if display.Target != unknownBackupTargetText {
+		t.Fatalf("Target=%q, want %q", display.Target, unknownBackupTargetText)
+	}
+	if display.Base != "archive.tar.xz" {
+		t.Fatalf("Base=%q, want %q", display.Base, "archive.tar.xz")
+	}
+	if display.Summary != "archive.tar.xz" {
+		t.Fatalf("Summary=%q, want %q", display.Summary, "archive.tar.xz")
+	}
+}
+
+func TestBackupSummaryForUI_UsesSharedDisplayModel(t *testing.T) {
+	created := time.Date(2026, time.March, 22, 12, 21, 22, 0, time.UTC)
+	cand := &backupCandidate{
+		DisplayBase: "backup.tar.xz",
+		Manifest: &backup.Manifest{
+			CreatedAt: created,
+			Hostname:  "node1.example.com",
+		},
+	}
+
+	if got := backupSummaryForUI(cand); got != "node1.example.com • backup.tar.xz (2026-03-22 12:21:22)" {
+		t.Fatalf("backupSummaryForUI()=%q", got)
+	}
+}
+
+func TestPromptCandidateSelection_PrintsHostname(t *testing.T) {
+	reader := bufio.NewReader(strings.NewReader("0\n"))
+	candidates := []*backupCandidate{
+		{
+			Manifest: &backup.Manifest{
+				CreatedAt:      time.Date(2026, time.March, 22, 12, 21, 22, 0, time.UTC),
+				Hostname:       "node1.example.com",
+				EncryptionMode: "age",
+				ScriptVersion:  "1.2.3",
+				ProxmoxType:    "pve",
+			},
+		},
+	}
+
+	stdout := captureCLIStdout(t, func() {
+		_, _ = promptCandidateSelection(context.Background(), reader, candidates)
+	})
+
+	if !strings.Contains(stdout, "Host node1.example.com") {
+		t.Fatalf("expected hostname in CLI output, got %q", stdout)
+	}
+}