Fix: Remove sudo usage from auth detection to avoid password prompts

- Remove sudo cat attempt for reading pg_hba.conf
- Prevents password prompts when running as postgres via 'su postgres'
- Auth detection now relies on connection attempts when file is unreadable
- Fixes issue where returning to menu after restore triggers sudo prompt

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_14:33:12_UTC
-- **Git Commit**: 09a9177
+- **Build Time**: 2026-01-16_12:38:18_UTC
+- **Git Commit**: 510175f
 
 ## 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)
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, "sudo", "cat", path)
-		output, err := cmd.Output()
-		if err != nil {
+		// If we can't read the file, return unknown and let the connection determine auth
+		// This avoids sudo password prompts when running as postgres via su
 		return AuthUnknown
 	}
-		return parseHbaContent(string(output), user)
-	}
 	defer file.Close()
 
 	scanner := bufio.NewScanner(file)

internal/restore/engine.go

@@ -34,6 +34,10 @@ type ProgressCallback func(current, total int64, description string)
 // DatabaseProgressCallback is called with database count progress during cluster restore
 type DatabaseProgressCallback func(done, total int, dbName string)
 
+// DatabaseProgressWithTimingCallback is called with database progress including timing info
+// Parameters: done count, total count, database name, elapsed time for current restore phase, avg duration per DB
+type DatabaseProgressWithTimingCallback func(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration)
+
 // Engine handles database restore operations
 type Engine struct {
 	cfg              *config.Config
@@ -47,6 +51,7 @@ type Engine struct {
 	// TUI progress callback for detailed progress reporting
 	progressCallback         ProgressCallback
 	dbProgressCallback       DatabaseProgressCallback
+	dbProgressTimingCallback DatabaseProgressWithTimingCallback
 }
 
 // New creates a new restore engine
@@ -112,6 +117,11 @@ func (e *Engine) SetDatabaseProgressCallback(cb DatabaseProgressCallback) {
 	e.dbProgressCallback = cb
 }
 
+// SetDatabaseProgressWithTimingCallback sets a callback for database progress with timing info
+func (e *Engine) SetDatabaseProgressWithTimingCallback(cb DatabaseProgressWithTimingCallback) {
+	e.dbProgressTimingCallback = cb
+}
+
 // reportProgress safely calls the progress callback if set
 func (e *Engine) reportProgress(current, total int64, description string) {
 	if e.progressCallback != nil {
@@ -126,6 +136,13 @@ func (e *Engine) reportDatabaseProgress(done, total int, dbName string) {
 	}
 }
 
+// reportDatabaseProgressWithTiming safely calls the timing-aware callback if set
+func (e *Engine) reportDatabaseProgressWithTiming(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration) {
+	if e.dbProgressTimingCallback != nil {
+		e.dbProgressTimingCallback(done, total, dbName, phaseElapsed, avgPerDB)
+	}
+}
+
 // loggerAdapter adapts our logger to the progress.Logger interface
 type loggerAdapter struct {
 	logger logger.Logger
@@ -1037,6 +1054,11 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 	var successCount, failCount int32
 	var mu sync.Mutex // Protect shared resources (progress, logger)
 
+	// Timing tracking for restore phase progress
+	restorePhaseStart := time.Now()
+	var completedDBTimes []time.Duration // Track duration for each completed DB restore
+	var completedDBTimesMu sync.Mutex
+
 	// Create semaphore to limit concurrency
 	semaphore := make(chan struct{}, parallelism)
 	var wg sync.WaitGroup
@@ -1062,6 +1084,9 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 				}
 			}()
 
+			// Track timing for this database restore
+			dbRestoreStart := time.Now()
+
 			// Update estimator progress (thread-safe)
 			mu.Lock()
 			estimator.UpdateProgress(idx)
@@ -1074,12 +1099,26 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 
 			dbProgress := 15 + int(float64(idx)/float64(totalDBs)*85.0)
 
+			// Calculate average time per DB and report progress with timing
+			completedDBTimesMu.Lock()
+			var avgPerDB time.Duration
+			if len(completedDBTimes) > 0 {
+				var totalDuration time.Duration
+				for _, d := range completedDBTimes {
+					totalDuration += d
+				}
+				avgPerDB = totalDuration / time.Duration(len(completedDBTimes))
+			}
+			phaseElapsed := time.Since(restorePhaseStart)
+			completedDBTimesMu.Unlock()
+
 			mu.Lock()
 			statusMsg := fmt.Sprintf("Restoring database %s (%d/%d)", dbName, idx+1, totalDBs)
 			e.progress.Update(statusMsg)
 			e.log.Info("Restoring database", "name", dbName, "file", dumpFile, "progress", dbProgress)
-			// Report database progress for TUI
+			// Report database progress for TUI (both callbacks)
 			e.reportDatabaseProgress(idx, totalDBs, dbName)
+			e.reportDatabaseProgressWithTiming(idx, totalDBs, dbName, phaseElapsed, avgPerDB)
 			mu.Unlock()
 
 			// STEP 1: Drop existing database completely (clean slate)
@@ -1144,6 +1183,12 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 				return
 			}
 
+			// Track completed database restore duration for ETA calculation
+			dbRestoreDuration := time.Since(dbRestoreStart)
+			completedDBTimesMu.Lock()
+			completedDBTimes = append(completedDBTimes, dbRestoreDuration)
+			completedDBTimesMu.Unlock()
+
 			atomic.AddInt32(&successCount, 1)
 		}(dbIndex, entry.Name())
 

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))
-		} else if m.result != "" {
-			// Parse and display result cleanly
-			lines := strings.Split(m.result, "\n")
-			for _, line := range lines {
-				line = strings.TrimSpace(line)
-				if line != "" {
-					s.WriteString("  " + line + "\n")
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ╔══════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ║              [FAIL] BACKUP FAILED                        ║"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ╚══════════════════════════════════════════════════════════╝"))
+			s.WriteString("\n\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

@@ -57,6 +57,10 @@ type RestoreExecutionModel struct {
 	dbTotal int
 	dbDone  int
 
+	// Timing info for database restore phase (ETA calculation)
+	dbPhaseElapsed time.Duration // Elapsed time since restore phase started
+	dbAvgPerDB     time.Duration // Average time per database restore
+
 	// Results
 	done       bool
 	cancelling bool // True when user has requested cancellation
@@ -136,6 +140,10 @@ type sharedProgressState struct {
 	dbTotal int
 	dbDone  int
 
+	// Timing info for database restore phase
+	dbPhaseElapsed time.Duration // Elapsed time since restore phase started
+	dbAvgPerDB     time.Duration // Average time per database restore
+
 	// Rolling window for speed calculation
 	speedSamples []restoreSpeedSample
 }
@@ -163,12 +171,12 @@ func clearCurrentRestoreProgress() {
 	currentRestoreProgressState = nil
 }
 
-func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64) {
+func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64, dbPhaseElapsed, dbAvgPerDB time.Duration) {
 	currentRestoreProgressMu.Lock()
 	defer currentRestoreProgressMu.Unlock()
 
 	if currentRestoreProgressState == nil {
-		return 0, 0, "", false, 0, 0, 0
+		return 0, 0, "", false, 0, 0, 0, 0, 0
 	}
 
 	currentRestoreProgressState.mu.Lock()
@@ -179,7 +187,8 @@ func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description strin
 
 	return currentRestoreProgressState.bytesTotal, currentRestoreProgressState.bytesDone,
 		currentRestoreProgressState.description, currentRestoreProgressState.hasUpdate,
-		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed
+		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed,
+		currentRestoreProgressState.dbPhaseElapsed, currentRestoreProgressState.dbAvgPerDB
 }
 
 // calculateRollingSpeed calculates speed from recent samples (last 5 seconds)
@@ -304,6 +313,21 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.bytesDone = 0
 		})
 
+		// Set up timing-aware database progress callback for cluster restore ETA
+		engine.SetDatabaseProgressWithTimingCallback(func(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration) {
+			progressState.mu.Lock()
+			defer progressState.mu.Unlock()
+			progressState.dbDone = done
+			progressState.dbTotal = total
+			progressState.description = fmt.Sprintf("Restoring %s", dbName)
+			progressState.dbPhaseElapsed = phaseElapsed
+			progressState.dbAvgPerDB = avgPerDB
+			progressState.hasUpdate = true
+			// Clear byte progress when switching to db progress
+			progressState.bytesTotal = 0
+			progressState.bytesDone = 0
+		})
+
 		// Store progress state in a package-level variable for the ticker to access
 		// This is a workaround because tea messages can't be sent from callbacks
 		setCurrentRestoreProgress(progressState)
@@ -357,7 +381,7 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.elapsed = time.Since(m.startTime)
 
 			// Poll shared progress state for real-time updates
-			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed := getCurrentRestoreProgress()
+			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed, dbPhaseElapsed, dbAvgPerDB := getCurrentRestoreProgress()
 			if hasUpdate && bytesTotal > 0 {
 				m.bytesTotal = bytesTotal
 				m.bytesDone = bytesDone
@@ -370,9 +394,11 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.phase = "Extracting"
 				m.progress = int((bytesDone * 100) / bytesTotal)
 			} else if hasUpdate && dbTotal > 0 {
-				// Database count progress for cluster restore
+				// Database count progress for cluster restore with timing
 				m.dbTotal = dbTotal
 				m.dbDone = dbDone
+				m.dbPhaseElapsed = dbPhaseElapsed
+				m.dbAvgPerDB = dbAvgPerDB
 				m.showBytes = false
 				m.status = fmt.Sprintf("Restoring database %d of %d...", dbDone+1, dbTotal)
 				m.phase = "Restore"
@@ -518,21 +544,70 @@ 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("\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("  ───────────────────────────────────────────────────────────"))
+		s.WriteString("\n\n")
 		s.WriteString(infoStyle.Render("  [KEYS]  Press Enter to continue"))
 	} else {
 		// Show progress
@@ -549,13 +624,13 @@ func (m RestoreExecutionModel) View() string {
 			s.WriteString(renderDetailedProgressBarWithSpeed(m.bytesDone, m.bytesTotal, m.speed))
 			s.WriteString("\n\n")
 		} else if m.dbTotal > 0 {
-			// Database count progress for cluster restore
+			// Database count progress for cluster restore with timing
 			spinner := m.spinnerFrames[m.spinnerFrame]
 			s.WriteString(fmt.Sprintf("Status: %s %s\n", spinner, m.status))
 			s.WriteString("\n")
 
-			// Show database progress bar
-			s.WriteString(renderDatabaseProgressBar(m.dbDone, m.dbTotal))
+			// Show database progress bar with timing and ETA
+			s.WriteString(renderDatabaseProgressBarWithTiming(m.dbDone, m.dbTotal, m.dbPhaseElapsed, m.dbAvgPerDB))
 			s.WriteString("\n\n")
 		} else {
 			// Show status with rotating spinner (for phases without detailed progress)
@@ -678,6 +753,55 @@ func renderDatabaseProgressBar(done, total int) string {
 	return s.String()
 }
 
+// renderDatabaseProgressBarWithTiming renders a progress bar for database count with timing and ETA
+func renderDatabaseProgressBarWithTiming(done, total int, phaseElapsed, avgPerDB time.Duration) string {
+	var s strings.Builder
+
+	// Calculate percentage
+	percent := 0
+	if total > 0 {
+		percent = (done * 100) / total
+		if percent > 100 {
+			percent = 100
+		}
+	}
+
+	// Render progress bar
+	width := 30
+	filled := (percent * width) / 100
+	barFilled := strings.Repeat("█", filled)
+	barEmpty := strings.Repeat("░", width-filled)
+
+	s.WriteString(successStyle.Render("["))
+	s.WriteString(successStyle.Render(barFilled))
+	s.WriteString(infoStyle.Render(barEmpty))
+	s.WriteString(successStyle.Render("]"))
+
+	// Count and percentage
+	s.WriteString(fmt.Sprintf("  %3d%%  %d / %d databases", percent, done, total))
+
+	// Timing and ETA
+	if phaseElapsed > 0 {
+		s.WriteString(fmt.Sprintf("  [%s", FormatDurationShort(phaseElapsed)))
+
+		// Calculate ETA based on average time per database
+		if avgPerDB > 0 && done < total {
+			remainingDBs := total - done
+			eta := time.Duration(remainingDBs) * avgPerDB
+			s.WriteString(fmt.Sprintf(" / ETA: %s", FormatDurationShort(eta)))
+		} else if done > 0 && done < total {
+			// Fallback: estimate ETA from overall elapsed time
+			avgElapsed := phaseElapsed / time.Duration(done)
+			remainingDBs := total - done
+			eta := time.Duration(remainingDBs) * avgElapsed
+			s.WriteString(fmt.Sprintf(" / ETA: ~%s", FormatDurationShort(eta)))
+		}
+		s.WriteString("]")
+	}
+
+	return s.String()
+}
+
 // formatDuration formats duration in human readable format
 func formatDuration(d time.Duration) string {
 	if d < time.Minute {