v0.12.7: mandatory HDD backup, pre-dump, restore for all apps

Fix 1: HDD data backup is now mandatory for all deployed apps.
resolveAppBackupPaths() iterates ListDeployedStacks() directly — no
longer reads GetAppBackupMap() or checks the Enabled flag. DiscoverAppData()
drops backupPrefs parameter; BackupEnabled is set from HasHDDData.
Five dead settings methods removed: IsAppBackupEnabled, SetAppBackup,
GetAppBackupMap, SetAppBackupBulk, GetAppBackupPrefs.

Fix 2: Cross-drive backup now triggers a fresh DB dump (DumpStackDB)
before running. DBDumper interface added to crossdrive.go; Manager
implements it; SetDBDumper wired in main.go. Non-fatal — proceeds with
user data backup even if DB dump fails.

Fix 3: Restore dropdown shows ALL deployed apps (not just HDD+enabled).
restore.go rewritten: always restores config+DB, adds user data if hasHDD.
UI shows restore type banner (full / config+DB / config only) with
color-coded styling. Snapshot API clarified for non-HDD apps.

Fix 4: "Docker kötetek" → "Konfiguráció" — named volumes are not in
the restic backup paths; compose files + app.yaml are what's backed up.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

controller/internal/backup/backup.go

@@ -425,24 +425,18 @@ func (m *Manager) GetStackHDDMounts(name string) []string {
 	return m.stackProvider.GetStackHDDMounts(name)
 }
 
-// resolveAppBackupPaths returns HDD paths for all enabled app backups.
+// resolveAppBackupPaths returns HDD paths for ALL deployed apps.
+// User data backup is mandatory — every app with HDD mounts is included.
 func (m *Manager) resolveAppBackupPaths() []string {
-	if m.stackProvider == nil || m.settings == nil {
-		return nil
-	}
-	appBackupMap := m.settings.GetAppBackupMap()
-	if len(appBackupMap) == 0 {
+	if m.stackProvider == nil {
 		return nil
 	}
 
 	var paths []string
 	seen := make(map[string]bool)
 
-	for stackName, enabled := range appBackupMap {
-		if !enabled {
-			continue
-		}
-		hddMounts := m.stackProvider.GetStackHDDMounts(stackName)
+	for _, stack := range m.stackProvider.ListDeployedStacks() {
+		hddMounts := m.stackProvider.GetStackHDDMounts(stack.Name)
 		for _, mount := range hddMounts {
 			if seen[mount] {
 				continue
@@ -450,13 +444,58 @@ func (m *Manager) resolveAppBackupPaths() []string {
 			if _, err := os.Stat(mount); err == nil {
 				paths = append(paths, mount)
 				seen[mount] = true
-				m.logger.Printf("[DEBUG] Including app data: %s (from %s)", mount, stackName)
+				m.logger.Printf("[DEBUG] Including app data: %s (from %s)", mount, stack.Name)
 			}
 		}
 	}
 	return paths
 }
 
+// DumpStackDB runs a database dump for containers belonging to a specific stack.
+// Used by cross-drive backup to ensure DB state matches user data.
+func (m *Manager) DumpStackDB(ctx context.Context, stackName string) error {
+	dbs, err := DiscoverDatabases(ctx, m.logger)
+	if err != nil {
+		return fmt.Errorf("database discovery failed: %w", err)
+	}
+
+	var stackDBs []DiscoveredDB
+	for _, db := range dbs {
+		if db.StackName == stackName {
+			stackDBs = append(stackDBs, db)
+		}
+	}
+	if len(stackDBs) == 0 {
+		m.logger.Printf("[DEBUG] No databases found for stack %s — skipping pre-backup dump", stackName)
+		return nil
+	}
+
+	m.logger.Printf("[INFO] Running pre-backup DB dump for %s (%d database(s))", stackName, len(stackDBs))
+	results := DumpAll(ctx, stackDBs, m.cfg.Paths.DBDumpDir, m.logger)
+
+	for _, r := range results {
+		if r.Error != nil {
+			return fmt.Errorf("DB dump failed for %s: %w", r.DB.ContainerName, r.Error)
+		}
+		m.logger.Printf("[INFO] Pre-backup DB dump OK: %s (%s)", r.DB.ContainerName, humanizeBytes(r.Size))
+
+		// Persist validation to settings
+		if m.settings != nil && r.FilePath != "" {
+			filename := filepath.Base(r.FilePath)
+			cache := settings.DBValidationCache{
+				ValidatedAt: time.Now().Format(time.RFC3339),
+				TableCount:  r.Validation.TableCount,
+				HasHeader:   r.Validation.Valid,
+			}
+			if !r.Validation.Valid {
+				cache.Error = r.Validation.Error
+			}
+			_ = m.settings.SetDBValidation(filename, cache)
+		}
+	}
+	return nil
+}
+
 func shouldPrune(schedule string) bool {
 	loc, err := time.LoadLocation("Europe/Budapest")
 	if err != nil {
@@ -542,10 +581,9 @@ func (m *Manager) RefreshCache(nextDBDump, nextBackup time.Time) {
 		status.DiscoveredDBs = dbs
 	}
 
-	// Discover app data (for per-app backup toggles)
+	// Discover app data — all deployed stacks, backup is mandatory
 	if m.stackProvider != nil {
-		backupPrefs := m.settings.GetAppBackupMap()
-		status.AppDataInfo = DiscoverAppData(m.stackProvider, backupPrefs, status.DiscoveredDBs)
+		status.AppDataInfo = DiscoverAppData(m.stackProvider, status.DiscoveredDBs)
 
 		// Include enabled app backup paths in the displayed BackupPaths
 		appPaths := m.resolveAppBackupPaths()