Add animated lookup progress details

Author: Daniel-Ric

internal/cli/cli.go

@@ -355,7 +355,8 @@ func (a *App) executeDirect(config DirectConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), a.inputTimeout)
 	defer cancel()
 
-	resultText, err := withSpinner("Abfrage", func() string {
+	resultText, err := withSpinner("Abfrage", func(frame int) string {
+		_ = frame
 		return "Server wird abgefragt"
 	}, 120*time.Millisecond, func() (string, error) {
 		result, err := ping.Execute(ctx, config.Edition, config.Host, config.Port)
@@ -376,17 +377,11 @@ func (a *App) executeLookup(config LookupConfig) error {
 	ctx := context.Background()
 
 	var current atomic.Value
-	current.Store("Domains werden überprüft")
-	formatProgress := func(subdomain, ending string) string {
-		sub := subdomain
-		if sub == "" {
-			sub = "(keine)"
-		}
-		return fmt.Sprintf("Subdomain: %s | Endung: %s", sub, ending)
-	}
+	current.Store(ping.LookupProgress{})
 
-	resultText, err := withSpinner("IP Lookup", func() string {
-		return current.Load().(string)
+	resultText, err := withSpinner("IP Lookup", func(frame int) string {
+		progress := current.Load().(ping.LookupProgress)
+		return formatLookupProgress(progress, frame)
 	}, 120*time.Millisecond, func() (string, error) {
 		result, lookupErr := ping.LookupDomains(ctx, ping.LookupConfig{
 			Edition:       config.Edition,
@@ -395,8 +390,8 @@ func (a *App) executeLookup(config LookupConfig) error {
 			Subdomains:    config.Subdomains,
 			DomainEndings: config.Endings,
 			Concurrency:   24,
-			Progress: func(subdomain, ending string) {
-				current.Store(formatProgress(subdomain, ending))
+			Progress: func(progress ping.LookupProgress) {
+				current.Store(progress)
 			},
 		})
 		if lookupErr != nil {
@@ -412,6 +407,53 @@ func (a *App) executeLookup(config LookupConfig) error {
 	return nil
 }
 
+func formatLookupProgress(progress ping.LookupProgress, frame int) string {
+	if progress.Total == 0 {
+		return "Domains werden überprüft"
+	}
+	subdomain := progress.Subdomain
+	if subdomain == "" {
+		subdomain = "(keine)"
+	}
+	bar := buildProgressBar(progress.Completed, progress.Total, frame, 20)
+	percent := (float64(progress.Completed) / float64(progress.Total)) * 100
+	return fmt.Sprintf(
+		"%s %d/%d (%.0f%%) | Subdomain: %s | Endung: %s | Host: %s",
+		bar,
+		progress.Completed,
+		progress.Total,
+		percent,
+		subdomain,
+		progress.Ending,
+		progress.Host,
+	)
+}
+
+func buildProgressBar(completed, total, frame, width int) string {
+	if total <= 0 || width <= 0 {
+		return "[--------------------]"
+	}
+	if completed > total {
+		completed = total
+	}
+	filled := (completed * width) / total
+	if filled > width {
+		filled = width
+	}
+	bar := make([]rune, width)
+	for i := 0; i < width; i++ {
+		bar[i] = '░'
+	}
+	for i := 0; i < filled; i++ {
+		bar[i] = '█'
+	}
+	if completed < total && filled < width {
+		animation := []rune{'▏', '▎', '▍', '▌', '▋', '▊', '▉'}
+		bar[filled] = animation[frame%len(animation)]
+	}
+	return fmt.Sprintf("[%s]", string(bar))
+}
+
 func (a *App) askAgain() (bool, error) {
 	index, err := selectOption("Nächster Schritt", []string{"Neue Abfrage", "Beenden"})
 	if err != nil {

internal/cli/ui.go

@@ -213,7 +213,7 @@ func renderSpinnerPage(title, message, frame string) {
 	renderPage(title, []string{fmt.Sprintf("%s %s", style(message, colorDim), style(frame, colorAccent))})
 }
 
-func withSpinner(title string, message func() string, tick time.Duration, action func() (string, error)) (string, error) {
+func withSpinner(title string, message func(frame int) string, tick time.Duration, action func() (string, error)) (string, error) {
 	resultCh := make(chan struct {
 		result string
 		err    error
@@ -245,7 +245,7 @@ func withSpinner(title string, message func() string, tick time.Duration, action
 			fmt.Println()
 			return res.result, res.err
 		case <-ticker.C:
-			line := fmt.Sprintf("%s %s", style(message(), colorDim), style(frames[frame], colorAccent))
+			line := fmt.Sprintf("%s %s", style(message(frame), colorDim), style(frames[frame], colorAccent))
 			if lastLen > 0 && len(line) < lastLen {
 				line += strings.Repeat(" ", lastLen-len(line))
 			}

internal/ping/lookup.go

@@ -15,7 +15,7 @@ type LookupConfig struct {
 	Subdomains    []string
 	DomainEndings []string
 	Concurrency   int
-	Progress      func(subdomain, ending string)
+	Progress      func(progress LookupProgress)
 }
 
 type LookupMatch struct {
@@ -29,6 +29,15 @@ type LookupResult struct {
 	Completed int
 }
 
+type LookupProgress struct {
+	Subdomain string
+	Ending    string
+	Host      string
+	Attempt   int
+	Total     int
+	Completed int
+}
+
 func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, error) {
 	baseHost := strings.TrimSpace(config.BaseHost)
 	if baseHost == "" {
@@ -53,29 +62,46 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 		return LookupResult{}, fmt.Errorf("keine kombinationen verfügbar")
 	}
 
-	candidates := make(chan string, concurrency)
+	type lookupCandidate struct {
+		subdomain string
+		ending    string
+		host      string
+		attempt   int
+	}
+
+	candidates := make(chan lookupCandidate, concurrency)
 	results := make(chan LookupMatch, concurrency)
 	var completed int64
 
 	var wg sync.WaitGroup
 	worker := func() {
 		defer wg.Done()
-		for host := range candidates {
+		for candidate := range candidates {
 			select {
 			case <-ctx.Done():
 				return
 			default:
 			}
 
-			res, err := Execute(ctx, config.Edition, host, config.Port)
-			atomic.AddInt64(&completed, 1)
+			res, err := Execute(ctx, config.Edition, candidate.host, config.Port)
+			currentCompleted := int(atomic.AddInt64(&completed, 1))
+			if config.Progress != nil {
+				config.Progress(LookupProgress{
+					Subdomain: candidate.subdomain,
+					Ending:    candidate.ending,
+					Host:      candidate.host,
+					Attempt:   candidate.attempt,
+					Total:     total,
+					Completed: currentCompleted,
+				})
+			}
 			if err != nil {
 				continue
 			}
 			select {
 			case <-ctx.Done():
 				return
-			case results <- LookupMatch{Host: host, Result: res}:
+			case results <- LookupMatch{Host: candidate.host, Result: res}:
 			}
 		}
 	}
@@ -87,15 +113,20 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 
 	go func() {
 		defer close(candidates)
+		attempt := 0
 		for _, sub := range subdomains {
 			for _, ending := range endings {
-				if config.Progress != nil {
-					config.Progress(sub, ending)
-				}
+				attempt++
+				host := buildHost(sub, baseHost, ending)
 				select {
 				case <-ctx.Done():
 					return
-				case candidates <- buildHost(sub, baseHost, ending):
+				case candidates <- lookupCandidate{
+					subdomain: sub,
+					ending:    ending,
+					host:      host,
+					attempt:   attempt,
+				}:
 				}
 			}
 		}