Fix: Critical bug - cluster restore showing success with 0 databases restored

CRITICAL FIXES:
- Add check for successCount == 0 to properly fail when no databases restored
- Fix tryRestartPostgreSQL to use non-interactive sudo (-n flag)
- Add 10-second timeout per restart attempt to prevent blocking
- Try pg_ctl directly for postgres user (no sudo needed)
- Set stdin to nil to prevent sudo from waiting for password input

This fixes the issue where cluster restore showed success but no databases
were actually restored due to sudo blocking on password prompts.

bin/README.md

@@ -4,8 +4,8 @@ This directory contains pre-compiled binaries for the DB Backup Tool across mult
 
 ## Build Information
 - **Version**: 3.42.34
-- **Build Time**: 2026-01-15_17:50:35_UTC
+- **Build Time**: 2026-01-16_12:52:56_UTC
-- **Git Commit**: 4938dc1
+- **Git Commit**: 62ddc57
 
 ## Recent Updates (v1.1.0)
 - ✅ Fixed TUI progress display with line-by-line output

internal/auth/helper.go

@@ -84,20 +84,14 @@ func findHbaFileViaPostgres() string {
 
 // parsePgHbaConf parses pg_hba.conf and returns the authentication method
 func parsePgHbaConf(path string, user string) AuthMethod {
-	// Try with sudo if we can't read directly
+	// Try to read the file directly - do NOT use sudo as it triggers password prompts
+	// If we can't read pg_hba.conf, we'll rely on connection attempts to determine auth
 	file, err := os.Open(path)
 	if err != nil {
-		// Try with sudo (with timeout)
+		// If we can't read the file, return unknown and let the connection determine auth
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		// This avoids sudo password prompts when running as postgres via su
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, "sudo", "cat", path)
-		output, err := cmd.Output()
-		if err != nil {
 		return AuthUnknown
 	}
-		return parseHbaContent(string(output), user)
-	}
 	defer file.Close()
 
 	scanner := bufio.NewScanner(file)

internal/restore/engine.go

@@ -1201,6 +1201,17 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 	successCountFinal := int(atomic.LoadInt32(&successCount))
 	failCountFinal := int(atomic.LoadInt32(&failCount))
 
+	// CRITICAL: Check if no databases were restored at all
+	if successCountFinal == 0 {
+		e.progress.Fail(fmt.Sprintf("Cluster restore FAILED: 0 of %d databases restored", totalDBs))
+		operation.Fail("No databases were restored")
+
+		if failCountFinal > 0 && restoreErrors != nil {
+			return fmt.Errorf("cluster restore failed: all %d database(s) failed:\n%s", failCountFinal, restoreErrors.Error())
+		}
+		return fmt.Errorf("cluster restore failed: no databases were restored (0 of %d total). Check PostgreSQL logs for details", totalDBs)
+	}
+
 	if failCountFinal > 0 {
 		// Format multi-error with detailed output
 		restoreErrors.ErrorFormat = func(errs []error) string {
@@ -2058,36 +2069,43 @@ func (e *Engine) boostPostgreSQLSettings(ctx context.Context, lockBoostValue int
 
 // tryRestartPostgreSQL attempts to restart PostgreSQL using various methods
 // Returns true if restart was successful
+// IMPORTANT: Uses short timeouts and non-interactive sudo to avoid blocking on password prompts
 func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
 	e.progress.Update("Attempting PostgreSQL restart for lock settings...")
 
-	// Method 1: systemctl (most common on modern Linux)
+	// Use short timeout for each restart attempt (don't block on sudo password prompts)
-	cmd := exec.CommandContext(ctx, "sudo", "systemctl", "restart", "postgresql")
+	runWithTimeout := func(args ...string) bool {
-	if err := cmd.Run(); err == nil {
+		cmdCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		cmd := exec.CommandContext(cmdCtx, args[0], args[1:]...)
+		// Set stdin to /dev/null to prevent sudo from waiting for password
+		cmd.Stdin = nil
+		return cmd.Run() == nil
+	}
+
+	// Method 1: systemctl (most common on modern Linux) - use sudo -n for non-interactive
+	if runWithTimeout("sudo", "-n", "systemctl", "restart", "postgresql") {
 		return true
 	}
 
 	// Method 2: systemctl with version suffix (e.g., postgresql-15)
 	for _, ver := range []string{"17", "16", "15", "14", "13", "12"} {
-		cmd = exec.CommandContext(ctx, "sudo", "systemctl", "restart", "postgresql-"+ver)
+		if runWithTimeout("sudo", "-n", "systemctl", "restart", "postgresql-"+ver) {
-		if err := cmd.Run(); err == nil {
 			return true
 		}
 	}
 
 	// Method 3: service command (older systems)
-	cmd = exec.CommandContext(ctx, "sudo", "service", "postgresql", "restart")
+	if runWithTimeout("sudo", "-n", "service", "postgresql", "restart") {
-	if err := cmd.Run(); err == nil {
 		return true
 	}
 
-	// Method 4: pg_ctl as postgres user
+	// Method 4: pg_ctl as postgres user (if we ARE postgres user, no sudo needed)
-	cmd = exec.CommandContext(ctx, "sudo", "-u", "postgres", "pg_ctl", "restart", "-D", "/var/lib/postgresql/data", "-m", "fast")
+	if runWithTimeout("pg_ctl", "restart", "-D", "/var/lib/postgresql/data", "-m", "fast") {
-	if err := cmd.Run(); err == nil {
 		return true
 	}
 
-	// Method 5: Try common PGDATA paths
+	// Method 5: Try common PGDATA paths with pg_ctl directly (for postgres user)
 	pgdataPaths := []string{
 		"/var/lib/pgsql/data",
 		"/var/lib/pgsql/17/data",
@@ -2098,8 +2116,7 @@ func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
 		"/var/lib/postgresql/15/main",
 	}
 	for _, pgdata := range pgdataPaths {
-		cmd = exec.CommandContext(ctx, "sudo", "-u", "postgres", "pg_ctl", "restart", "-D", pgdata, "-m", "fast")
+		if runWithTimeout("pg_ctl", "restart", "-D", pgdata, "-m", "fast") {
-		if err := cmd.Run(); err == nil {
 			return true
 		}
 	}

internal/tui/backup_exec.go

@@ -380,22 +380,83 @@ func (m BackupExecutionModel) View() string {
 			s.WriteString("\n  [KEY]  Press Ctrl+C or ESC to cancel\n")
 		}
 	} else {
-		s.WriteString(fmt.Sprintf("  %s\n\n", m.status))
+		// Show completion summary with detailed stats
-
 		if m.err != nil {
-			s.WriteString(fmt.Sprintf("  [FAIL] Error: %v\n", m.err))
+			s.WriteString("\n")
-		} else if m.result != "" {
+			s.WriteString(errorStyle.Render("  ╔══════════════════════════════════════════════════════════╗"))
-			// Parse and display result cleanly
+			s.WriteString("\n")
-			lines := strings.Split(m.result, "\n")
+			s.WriteString(errorStyle.Render("  ║              [FAIL] BACKUP FAILED                        ║"))
-			for _, line := range lines {
+			s.WriteString("\n")
-				line = strings.TrimSpace(line)
+			s.WriteString(errorStyle.Render("  ╚══════════════════════════════════════════════════════════╝"))
-				if line != "" {
+			s.WriteString("\n\n")
-					s.WriteString("  " + line + "\n")
+			s.WriteString(errorStyle.Render(fmt.Sprintf("    Error: %v", m.err)))
+			s.WriteString("\n")
+		} else {
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ╔══════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ║           [OK] BACKUP COMPLETED SUCCESSFULLY             ║"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ╚══════════════════════════════════════════════════════════╝"))
+			s.WriteString("\n\n")
+
+			// Summary section
+			s.WriteString(infoStyle.Render("    ─── Summary ─────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			// Backup type specific info
+			switch m.backupType {
+			case "cluster":
+				s.WriteString("      Type:          Cluster Backup\n")
+				if m.dbTotal > 0 {
+					s.WriteString(fmt.Sprintf("      Databases:     %d backed up\n", m.dbTotal))
 				}
+			case "single":
+				s.WriteString("      Type:          Single Database Backup\n")
+				s.WriteString(fmt.Sprintf("      Database:      %s\n", m.databaseName))
+			case "sample":
+				s.WriteString("      Type:          Sample Backup\n")
+				s.WriteString(fmt.Sprintf("      Database:      %s\n", m.databaseName))
+				s.WriteString(fmt.Sprintf("      Sample Ratio:  %d\n", m.ratio))
 			}
+
+			s.WriteString("\n")
+
+			// Timing section
+			s.WriteString(infoStyle.Render("    ─── Timing ──────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			elapsed := time.Since(m.startTime)
+			s.WriteString(fmt.Sprintf("      Total Time:    %s\n", formatBackupDuration(elapsed)))
+
+			if m.backupType == "cluster" && m.dbTotal > 0 {
+				avgPerDB := elapsed / time.Duration(m.dbTotal)
+				s.WriteString(fmt.Sprintf("      Avg per DB:    %s\n", formatBackupDuration(avgPerDB)))
 			}
-		s.WriteString("\n  [KEY]  Press Enter or ESC to return to menu\n")
+
+			s.WriteString("\n")
+			s.WriteString(infoStyle.Render("    ─────────────────────────────────────────────────────────"))
+			s.WriteString("\n")
+		}
+
+		s.WriteString("\n")
+		s.WriteString("  [KEY]  Press Enter or ESC to return to menu\n")
 	}
 
 	return s.String()
 }
+
+// formatBackupDuration formats duration in human readable format
+func formatBackupDuration(d time.Duration) string {
+	if d < time.Minute {
+		return fmt.Sprintf("%.1fs", d.Seconds())
+	}
+	if d < time.Hour {
+		minutes := int(d.Minutes())
+		seconds := int(d.Seconds()) % 60
+		return fmt.Sprintf("%dm %ds", minutes, seconds)
+	}
+	hours := int(d.Hours())
+	minutes := int(d.Minutes()) % 60
+	return fmt.Sprintf("%dh %dm", hours, minutes)
+}

internal/tui/restore_exec.go

@@ -544,22 +544,71 @@ func (m RestoreExecutionModel) View() string {
 	s.WriteString("\n")
 
 	if m.done {
-		// Show result
+		// Show result with comprehensive summary
 		if m.err != nil {
-			s.WriteString(errorStyle.Render("[FAIL] Restore Failed"))
+			s.WriteString(errorStyle.Render("╔══════════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("║              [FAIL] RESTORE FAILED                           ║"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("╚══════════════════════════════════════════════════════════════╝"))
 			s.WriteString("\n\n")
-			s.WriteString(errorStyle.Render(fmt.Sprintf("Error: %v", m.err)))
+			s.WriteString(errorStyle.Render(fmt.Sprintf("  Error: %v", m.err)))
 			s.WriteString("\n")
 		} else {
-			s.WriteString(successStyle.Render("[OK] Restore Completed Successfully"))
+			s.WriteString(successStyle.Render("╔══════════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("║           [OK] RESTORE COMPLETED SUCCESSFULLY                ║"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("╚══════════════════════════════════════════════════════════════╝"))
 			s.WriteString("\n\n")
-			s.WriteString(successStyle.Render(m.result))
+
+			// Summary section
+			s.WriteString(infoStyle.Render("  ─── Summary ───────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			// Archive info
+			s.WriteString(fmt.Sprintf("    Archive:       %s\n", m.archive.Name))
+			if m.archive.Size > 0 {
+				s.WriteString(fmt.Sprintf("    Archive Size:  %s\n", FormatBytes(m.archive.Size)))
+			}
+
+			// Restore type specific info
+			if m.restoreType == "restore-cluster" {
+				s.WriteString(fmt.Sprintf("    Type:          Cluster Restore\n"))
+				if m.dbTotal > 0 {
+					s.WriteString(fmt.Sprintf("    Databases:     %d restored\n", m.dbTotal))
+				}
+				if m.cleanClusterFirst && len(m.existingDBs) > 0 {
+					s.WriteString(fmt.Sprintf("    Cleaned:       %d existing database(s) dropped\n", len(m.existingDBs)))
+				}
+			} else {
+				s.WriteString(fmt.Sprintf("    Type:          Single Database Restore\n"))
+				s.WriteString(fmt.Sprintf("    Target DB:     %s\n", m.targetDB))
+			}
+
 			s.WriteString("\n")
 		}
 
-		s.WriteString(fmt.Sprintf("\nElapsed Time: %s\n", formatDuration(m.elapsed)))
+		// Timing section
+		s.WriteString(infoStyle.Render("  ─── Timing ────────────────────────────────────────────────"))
+		s.WriteString("\n\n")
+		s.WriteString(fmt.Sprintf("    Total Time:    %s\n", formatDuration(m.elapsed)))
+
+		// Calculate and show throughput if we have size info
+		if m.archive.Size > 0 && m.elapsed.Seconds() > 0 {
+			throughput := float64(m.archive.Size) / m.elapsed.Seconds()
+			s.WriteString(fmt.Sprintf("    Throughput:    %s/s (average)\n", FormatBytes(int64(throughput))))
+		}
+
+		if m.dbTotal > 0 && m.err == nil {
+			avgPerDB := m.elapsed / time.Duration(m.dbTotal)
+			s.WriteString(fmt.Sprintf("    Avg per DB:    %s\n", formatDuration(avgPerDB)))
+		}
+
 		s.WriteString("\n")
-		s.WriteString(infoStyle.Render("[KEYS]  Press Enter to continue"))
+		s.WriteString(infoStyle.Render("  ───────────────────────────────────────────────────────────"))
+		s.WriteString("\n\n")
+		s.WriteString(infoStyle.Render("  [KEYS]  Press Enter to continue"))
 	} else {
 		// Show progress
 		s.WriteString(fmt.Sprintf("Phase: %s\n", m.phase))