Merge pull request #11 from Daniel-Ric/feature/2026-02-03/enhance-tool-with-ip-lookup-options-yxm4e0

Selection-Menüs in-place rendern

Author: Daniel-Ric

internal/cli/cli.go

@@ -17,8 +17,7 @@ type App struct {
 
 func NewApp() *App {
 	return &App{
-		inputTimeout:  3 * time.Second,
-		lookupTimeout: 45 * time.Second,
+		inputTimeout: 3 * time.Second,
 	}
 }
 
@@ -308,23 +307,21 @@ func (a *App) executeDirect(config DirectConfig) error {
 }
 
 func (a *App) executeLookup(config LookupConfig) error {
-	ctx, cancel := context.WithTimeout(context.Background(), a.lookupTimeout)
-	defer cancel()
+	ctx := context.Background()
 
 	resultText, err := withSpinner("IP Lookup", "Domains werden überprüft", 120*time.Millisecond, func() (string, error) {
 		result, lookupErr := ping.LookupDomains(ctx, ping.LookupConfig{
-			Edition:        config.Edition,
-			Port:           config.Port,
-			BaseHost:       config.BaseHost,
-			Subdomains:     config.Subdomains,
-			DomainEndings:  config.Endings,
-			Concurrency:    24,
-			PerHostTimeout: 2 * time.Second,
+			Edition:       config.Edition,
+			Port:          config.Port,
+			BaseHost:      config.BaseHost,
+			Subdomains:    config.Subdomains,
+			DomainEndings: config.Endings,
+			Concurrency:   24,
 		})
-		if lookupErr != nil && !errors.Is(lookupErr, context.DeadlineExceeded) {
+		if lookupErr != nil {
 			return "", lookupErr
 		}
-		return formatLookupResult(result, errors.Is(lookupErr, context.DeadlineExceeded)), nil
+		return formatLookupResult(result), nil
 	})
 	if err != nil {
 		return err
@@ -342,13 +339,10 @@ func (a *App) askAgain() (bool, error) {
 	return index == 0, nil
 }
 
-func formatLookupResult(result ping.LookupResult, timedOut bool) string {
+func formatLookupResult(result ping.LookupResult) string {
 	var builder strings.Builder
 	builder.WriteString(fmt.Sprintf("Kombinationen geprüft: %d/%d\n", result.Completed, result.Attempts))
 	builder.WriteString(fmt.Sprintf("Treffer: %d\n", len(result.Matches)))
-	if timedOut {
-		builder.WriteString("Hinweis: Zeitlimit erreicht, Ergebnisse können unvollständig sein.\n")
-	}
 	builder.WriteString("\n")
 
 	if len(result.Matches) == 0 {

internal/cli/ui.go

@@ -65,7 +65,7 @@ func selectOption(title string, options []string) (int, error) {
 	defer restore(fd, state)
 
 	selected := 0
-	renderMenu(title, options, selected, "")
+	lines := renderMenuBlock(title, options, selected, "", true)
 
 	reader := bufio.NewReader(os.Stdin)
 	for {
@@ -81,12 +81,12 @@ func selectOption(title string, options []string) (int, error) {
 			if selected > 0 {
 				selected--
 			}
-			renderMenu(title, options, selected, "")
+			lines = updateMenu(title, options, selected, "", lines)
 		case 's', 'j':
 			if selected < len(options)-1 {
 				selected++
 			}
-			renderMenu(title, options, selected, "")
+			lines = updateMenu(title, options, selected, "", lines)
 		case 13, 10:
 			clearScreen()
 			return selected, nil
@@ -105,7 +105,7 @@ func selectOption(title string, options []string) (int, error) {
 					selected++
 				}
 			}
-			renderMenu(title, options, selected, "")
+			lines = updateMenu(title, options, selected, "", lines)
 		case 0, 224:
 			code, err := reader.ReadByte()
 			if err != nil {
@@ -117,7 +117,7 @@ func selectOption(title string, options []string) (int, error) {
 			if code == 80 && selected < len(options)-1 {
 				selected++
 			}
-			renderMenu(title, options, selected, "")
+			lines = updateMenu(title, options, selected, "", lines)
 		}
 	}
 }
@@ -141,22 +141,50 @@ func readEscapeSequence(reader *bufio.Reader) (string, error) {
 	return string([]byte{b1, b2}), nil
 }
 
-func renderMenu(title string, options []string, selected int, hint string) {
-	clearScreen()
-	fmt.Println(style(title, colorAccent))
-	fmt.Println()
+func renderMenuBlock(title string, options []string, selected int, hint string, clear bool) int {
+	if clear {
+		clearScreen()
+	}
+	lines := 0
+	lines += printLine(style(title, colorAccent))
+	lines += printLine("")
 	for i, option := range options {
 		if i == selected {
-			fmt.Printf("%s %s\n", style(">", colorAccent+colorBold), style(option, colorBold))
+			lines += printLine(fmt.Sprintf("%s %s", style(">", colorAccent+colorBold), style(option, colorBold)))
 			continue
 		}
-		fmt.Printf("  %s\n", option)
+		lines += printLine(fmt.Sprintf("  %s", option))
 	}
-	fmt.Println()
+	lines += printLine("")
 	if hint == "" {
 		hint = "Pfeiltasten (oder W/S), Enter zum Bestätigen"
 	}
-	fmt.Println(style(hint, colorDim))
+	lines += printLine(style(hint, colorDim))
+	return lines
+}
+
+func updateMenu(title string, options []string, selected int, hint string, lines int) int {
+	if lines > 0 {
+		moveCursorUp(lines)
+	}
+	return renderMenuBlock(title, options, selected, hint, false)
+}
+
+func printLine(value string) int {
+	clearLine()
+	fmt.Println(value)
+	return 1
+}
+
+func clearLine() {
+	fmt.Print("\r\033[K")
+}
+
+func moveCursorUp(lines int) {
+	if lines <= 0 {
+		return
+	}
+	fmt.Printf("\033[%dA", lines)
 }
 
 func clearScreen() {
@@ -198,17 +226,31 @@ func withSpinner(title, message string, tick time.Duration, action func() (strin
 		}{result: result, err: err}
 	}()
 
+	clearScreen()
+	fmt.Println(style(title, colorAccent))
+	fmt.Println()
+
 	frames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
 	ticker := time.NewTicker(tick)
 	defer ticker.Stop()
 
 	frame := 0
+	lastLen := 0
 	for {
 		select {
 		case res := <-resultCh:
+			if lastLen > 0 {
+				fmt.Print("\r", strings.Repeat(" ", lastLen), "\r")
+			}
+			fmt.Println()
 			return res.result, res.err
 		case <-ticker.C:
-			renderSpinnerPage(title, message, frames[frame])
+			line := fmt.Sprintf("%s %s", style(message, colorDim), style(frames[frame], colorAccent))
+			if lastLen > 0 && len(line) < lastLen {
+				line += strings.Repeat(" ", lastLen-len(line))
+			}
+			fmt.Print("\r", line)
+			lastLen = len(line)
 			frame = (frame + 1) % len(frames)
 		}
 	}

internal/ping/lookup.go

@@ -6,17 +6,15 @@ import (
 	"strings"
 	"sync"
 	"sync/atomic"
-	"time"
 )
 
 type LookupConfig struct {
-	Edition        Edition
-	Port           int
-	BaseHost       string
-	Subdomains     []string
-	DomainEndings  []string
-	Concurrency    int
-	PerHostTimeout time.Duration
+	Edition       Edition
+	Port          int
+	BaseHost      string
+	Subdomains    []string
+	DomainEndings []string
+	Concurrency   int
 }
 
 type LookupMatch struct {
@@ -49,11 +47,6 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 	if concurrency <= 0 {
 		concurrency = 16
 	}
-	perHostTimeout := config.PerHostTimeout
-	if perHostTimeout <= 0 {
-		perHostTimeout = 2 * time.Second
-	}
-
 	total := len(subdomains) * len(endings)
 	if total == 0 {
 		return LookupResult{}, fmt.Errorf("keine kombinationen verfügbar")
@@ -73,9 +66,7 @@ func LookupDomains(ctx context.Context, config LookupConfig) (LookupResult, erro
 			default:
 			}
 
-			hostCtx, cancel := context.WithTimeout(ctx, perHostTimeout)
-			res, err := Execute(hostCtx, config.Edition, host, config.Port)
-			cancel()
+			res, err := Execute(ctx, config.Edition, host, config.Port)
 			atomic.AddInt64(&completed, 1)
 			if err != nil {
 				continue