Add user friendly UI allowing to temporarily toggle port forwarding.

internal/forward/manager.go

@@ -259,9 +259,15 @@ func (m *Manager) startWorker(fwd config.Forward) error {
 	}
 
 	// Register with health checker
-	m.healthChecker.Register(fwd.ID(), fwd.LocalPort, func(forwardID string, status healthcheck.Status) {
+	m.healthChecker.Register(fwd.ID(), fwd.LocalPort, func(forwardID string, status healthcheck.Status, errorMsg string) {
 		if m.statusUI != nil {
 			m.statusUI.UpdateStatus(forwardID, string(status))
+			// Send error separately if there is one
+			if status == healthcheck.StatusUnhealthy && errorMsg != "" {
+				if ui, ok := m.statusUI.(interface{ SetError(id, msg string) }); ok {
+					ui.SetError(forwardID, errorMsg)
+				}
+			}
 		}
 	})
 
@@ -289,6 +295,9 @@ func (m *Manager) stopWorker(id string) error {
 	// Unregister from health checker
 	m.healthChecker.Unregister(id)
 
+	// Note: We DON'T call Remove() here anymore - keep it in the UI
+	// The UI will show it as disabled instead
+
 	// Stop the worker
 	worker.Stop()
 
@@ -334,3 +343,50 @@ func (m *Manager) getResourceForPort(forwards []config.Forward, port int) string
 	}
 	return "unknown"
 }
+
+// DisableForward temporarily stops a forward by ID
+func (m *Manager) DisableForward(id string) error {
+	if err := m.stopWorker(id); err != nil {
+		return err
+	}
+	log.Printf("Disabled: %s", id)
+	return nil
+}
+
+// EnableForward re-enables a previously disabled forward
+func (m *Manager) EnableForward(id string) error {
+	// Find the forward configuration in current config
+	if m.currentConfig == nil {
+		return fmt.Errorf("no configuration available")
+	}
+
+	forwards := m.currentConfig.GetAllForwards()
+	var targetFwd *config.Forward
+	for _, fwd := range forwards {
+		if fwd.ID() == id {
+			targetFwd = &fwd
+			break
+		}
+	}
+
+	if targetFwd == nil {
+		return fmt.Errorf("forward not found in configuration: %s", id)
+	}
+
+	// Check if already running
+	m.workersMu.RLock()
+	_, exists := m.workers[id]
+	m.workersMu.RUnlock()
+
+	if exists {
+		return fmt.Errorf("forward already enabled: %s", id)
+	}
+
+	// Start the worker
+	if err := m.startWorker(*targetFwd); err != nil {
+		return fmt.Errorf("failed to enable forward: %w", err)
+	}
+
+	log.Printf("Enabled: %s", id)
+	return nil
+}

internal/forward/worker.go

@@ -25,6 +25,7 @@ type ForwardWorker struct {
 	lastPod       string // Track the last pod we connected to
 	statusUI      StatusUpdater
 	healthChecker *healthcheck.Checker
+	startTime     time.Time // Track when the worker started
 }
 
 // NewForwardWorker creates a new ForwardWorker for a single forward configuration.
@@ -41,6 +42,7 @@ func NewForwardWorker(fwd config.Forward, portForwarder *k8s.PortForwarder, verb
 		verbose:       verbose,
 		statusUI:      statusUI,
 		healthChecker: healthChecker,
+		startTime:     time.Now(),
 	}
 }
 

internal/healthcheck/checker.go

@@ -24,10 +24,11 @@ type PortHealth struct {
 	LastCheck    time.Time
 	Status       Status
 	ErrorMessage string
+	RegisteredAt time.Time // When this port was registered
 }
 
 // StatusCallback is called when a port's health status changes
-type StatusCallback func(forwardID string, status Status)
+type StatusCallback func(forwardID string, status Status, errorMsg string)
 
 // Checker performs periodic health checks on local ports
 type Checker struct {
@@ -60,9 +61,10 @@ func (c *Checker) Register(forwardID string, port int, callback StatusCallback)
 	defer c.mu.Unlock()
 
 	c.ports[forwardID] = &PortHealth{
-		Port:      port,
-		LastCheck: time.Time{},
-		Status:    StatusStarting,
+		Port:         port,
+		LastCheck:    time.Time{},
+		Status:       StatusStarting,
+		RegisteredAt: time.Now(),
 	}
 	c.callbacks[forwardID] = callback
 
@@ -93,7 +95,7 @@ func (c *Checker) MarkReconnecting(forwardID string) {
 		// Notify if status changed
 		if oldStatus != StatusReconnect {
 			c.mu.Unlock()
-			c.notifyStatusChange(forwardID, StatusReconnect)
+			c.notifyStatusChange(forwardID, StatusReconnect, "")
 			c.mu.Lock()
 		}
 	}
@@ -112,7 +114,7 @@ func (c *Checker) MarkStarting(forwardID string) {
 		// Notify if status changed
 		if oldStatus != StatusStarting {
 			c.mu.Unlock()
-			c.notifyStatusChange(forwardID, StatusStarting)
+			c.notifyStatusChange(forwardID, StatusStarting, "")
 			c.mu.Lock()
 		}
 	}
@@ -129,6 +131,20 @@ func (c *Checker) GetStatus(forwardID string) (Status, bool) {
 	return StatusUnhealthy, false
 }
 
+// GetAllErrors returns all forwards with errors and their error messages
+func (c *Checker) GetAllErrors() map[string]string {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	errors := make(map[string]string)
+	for forwardID, health := range c.ports {
+		if health.Status == StatusUnhealthy && health.ErrorMessage != "" {
+			errors[forwardID] = health.ErrorMessage
+		}
+	}
+	return errors
+}
+
 // Stop stops all health checking
 func (c *Checker) Stop() {
 	c.cancel()
@@ -142,8 +158,7 @@ func (c *Checker) checkLoop(forwardID string) {
 	ticker := time.NewTicker(c.interval)
 	defer ticker.Stop()
 
-	// Initial check after a short delay to let port-forward establish
-	time.Sleep(2 * time.Second)
+	// Do immediate first check - grace period logic will handle early failures
 	c.checkPort(forwardID)
 
 	for {
@@ -175,6 +190,7 @@ func (c *Checker) checkPort(forwardID string) {
 	}
 	port := health.Port
 	oldStatus := health.Status
+	registeredAt := health.RegisteredAt
 	c.mu.RUnlock()
 
 	// Attempt to connect to the local port
@@ -188,7 +204,14 @@ func (c *Checker) checkPort(forwardID string) {
 	errorMsg := ""
 
 	if err != nil {
-		newStatus = StatusUnhealthy
+		// Grace period: if forward is less than 10 seconds old, keep it as "Starting"
+		// This avoids scary "Error" messages during initial connection attempts
+		timeSinceStart := time.Since(registeredAt)
+		if timeSinceStart < 10*time.Second {
+			newStatus = StatusStarting
+		} else {
+			newStatus = StatusUnhealthy
+		}
 		errorMsg = err.Error()
 	} else {
 		conn.Close()
@@ -205,17 +228,17 @@ func (c *Checker) checkPort(forwardID string) {
 
 	// Notify if status changed
 	if oldStatus != newStatus {
-		c.notifyStatusChange(forwardID, newStatus)
+		c.notifyStatusChange(forwardID, newStatus, errorMsg)
 	}
 }
 
 // notifyStatusChange calls the callback for a forward
-func (c *Checker) notifyStatusChange(forwardID string, status Status) {
+func (c *Checker) notifyStatusChange(forwardID string, status Status, errorMsg string) {
 	c.mu.RLock()
 	callback, exists := c.callbacks[forwardID]
 	c.mu.RUnlock()
 
 	if exists && callback != nil {
-		callback(forwardID, status)
+		callback(forwardID, status, errorMsg)
 	}
 }

internal/ui/bubbletea_ui.go

@@ -0,0 +1,429 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/nvm/kportal/internal/config"
+)
+
+// ForwardUpdateMsg is sent when a forward status changes
+type ForwardUpdateMsg struct {
+	ID     string
+	Status string
+}
+
+// ForwardErrorMsg is sent when a forward has an error
+type ForwardErrorMsg struct {
+	ID    string
+	Error string
+}
+
+// ForwardAddMsg is sent when a new forward is added
+type ForwardAddMsg struct {
+	ID      string
+	Forward *ForwardStatus
+}
+
+// ForwardRemoveMsg is sent when a forward is removed
+type ForwardRemoveMsg struct {
+	ID string
+}
+
+// BubbleTeaUI is a bubbletea-based terminal UI
+type BubbleTeaUI struct {
+	mu             sync.RWMutex
+	program        *tea.Program
+	forwards       map[string]*ForwardStatus
+	forwardOrder   []string
+	selectedIndex  int
+	disabledMap    map[string]bool
+	toggleCallback func(id string, enable bool)
+	version        string
+	errors         map[string]string // Track error messages by forward ID
+}
+
+// bubbletea model
+type model struct {
+	ui *BubbleTeaUI
+}
+
+// NewBubbleTeaUI creates a new bubbletea-based UI
+func NewBubbleTeaUI(toggleCallback func(id string, enable bool), version string) *BubbleTeaUI {
+	ui := &BubbleTeaUI{
+		forwards:       make(map[string]*ForwardStatus),
+		forwardOrder:   make([]string, 0),
+		selectedIndex:  0,
+		disabledMap:    make(map[string]bool),
+		toggleCallback: toggleCallback,
+		version:        version,
+		errors:         make(map[string]string),
+	}
+
+	return ui
+}
+
+// Start starts the bubbletea application
+func (ui *BubbleTeaUI) Start() error {
+	m := model{ui: ui}
+	ui.program = tea.NewProgram(m, tea.WithAltScreen())
+	_, err := ui.program.Run()
+	return err
+}
+
+// Stop stops the application
+func (ui *BubbleTeaUI) Stop() {
+	if ui.program != nil {
+		ui.program.Quit()
+	}
+}
+
+// AddForward adds a forward to display
+func (ui *BubbleTeaUI) AddForward(id string, fwd *config.Forward) {
+	ui.mu.Lock()
+
+	// Check if already exists (re-enabling case)
+	if existing, ok := ui.forwards[id]; ok {
+		existing.Status = "Starting"
+		ui.disabledMap[id] = false
+		ui.mu.Unlock()
+
+		if ui.program != nil {
+			ui.program.Send(ForwardUpdateMsg{ID: id, Status: "Starting"})
+		}
+		return
+	}
+
+	// Parse resource
+	resourceType := "pod"
+	resourceName := fwd.Resource
+	for idx := 0; idx < len(fwd.Resource); idx++ {
+		if fwd.Resource[idx] == '/' {
+			resourceType = fwd.Resource[:idx]
+			resourceName = fwd.Resource[idx+1:]
+			break
+		}
+	}
+
+	alias := fwd.Alias
+	if alias == "" {
+		alias = resourceName
+	}
+
+	status := &ForwardStatus{
+		Context:    fwd.GetContext(),
+		Namespace:  fwd.GetNamespace(),
+		Alias:      alias,
+		Type:       resourceType,
+		Resource:   resourceName,
+		RemotePort: fwd.Port,
+		LocalPort:  fwd.LocalPort,
+		Status:     "Starting",
+	}
+
+	ui.forwards[id] = status
+	ui.forwardOrder = append(ui.forwardOrder, id)
+	ui.mu.Unlock()
+
+	if ui.program != nil {
+		ui.program.Send(ForwardAddMsg{ID: id, Forward: status})
+	}
+}
+
+// UpdateStatus updates forward status
+func (ui *BubbleTeaUI) UpdateStatus(id string, status string) {
+	ui.mu.Lock()
+	if fwd, ok := ui.forwards[id]; ok {
+		fwd.Status = status
+	}
+	// Clear error if status is not Error
+	if status != "Error" {
+		delete(ui.errors, id)
+	}
+	ui.mu.Unlock()
+
+	if ui.program != nil {
+		ui.program.Send(ForwardUpdateMsg{ID: id, Status: status})
+	}
+}
+
+// SetError sets an error message for a forward
+func (ui *BubbleTeaUI) SetError(id, msg string) {
+	ui.mu.Lock()
+	ui.errors[id] = msg
+	ui.mu.Unlock()
+
+	if ui.program != nil {
+		ui.program.Send(ForwardErrorMsg{ID: id, Error: msg})
+	}
+}
+
+// Remove removes a forward
+func (ui *BubbleTeaUI) Remove(id string) {
+	ui.mu.Lock()
+	delete(ui.forwards, id)
+
+	// Remove from order
+	for i, fid := range ui.forwardOrder {
+		if fid == id {
+			ui.forwardOrder = append(ui.forwardOrder[:i], ui.forwardOrder[i+1:]...)
+			break
+		}
+	}
+	ui.mu.Unlock()
+
+	if ui.program != nil {
+		ui.program.Send(ForwardRemoveMsg{ID: id})
+	}
+}
+
+// Bubble Tea Model Implementation
+
+func (m model) Init() tea.Cmd {
+	return nil
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "q":
+			return m, tea.Quit
+		case "up", "k":
+			m.ui.moveSelection(-1)
+		case "down", "j":
+			m.ui.moveSelection(1)
+		case " ", "enter":
+			m.ui.toggleSelected()
+		}
+
+	case ForwardAddMsg:
+		// Already handled in AddForward, just trigger re-render
+		return m, nil
+
+	case ForwardUpdateMsg:
+		// Already handled in UpdateStatus, just trigger re-render
+		return m, nil
+
+	case ForwardErrorMsg:
+		// Already handled in SetError, just trigger re-render
+		return m, nil
+
+	case ForwardRemoveMsg:
+		// Already handled in Remove, just trigger re-render
+		return m, nil
+	}
+
+	return m, nil
+}
+
+func (m model) View() string {
+	m.ui.mu.RLock()
+	defer m.ui.mu.RUnlock()
+
+	var b strings.Builder
+
+	// Styles
+	titleStyle := lipgloss.NewStyle().
+		Bold(true).
+		Foreground(lipgloss.Color("220")).
+		Padding(0, 1)
+
+	headerStyle := lipgloss.NewStyle().
+		Bold(true).
+		Foreground(lipgloss.Color("220"))
+
+	separatorStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("240"))
+
+	selectedStyle := lipgloss.NewStyle().
+		Background(lipgloss.Color("240")).
+		Foreground(lipgloss.Color("230"))
+
+	disabledStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("240"))
+
+	activeStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("46"))
+
+	startingStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("220"))
+
+	errorStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("196"))
+
+	// Title with version
+	title := fmt.Sprintf("kportal v%s - Port Forwarding Status", m.ui.version)
+	b.WriteString(titleStyle.Render(title))
+	b.WriteString("\n\n")
+
+	// Header
+	header := fmt.Sprintf("%-15s %-18s %-20s %-10s %-21s %7s %7s  %s",
+		"CONTEXT", "NAMESPACE", "ALIAS", "TYPE", "RESOURCE", "REMOTE", "LOCAL", "STATUS")
+	b.WriteString(headerStyle.Render(header))
+	b.WriteString("\n")
+	b.WriteString(separatorStyle.Render(strings.Repeat("─", 120)))
+	b.WriteString("\n")
+
+	// No forwards
+	if len(m.ui.forwardOrder) == 0 {
+		b.WriteString(disabledStyle.Render("\nNo forwards configured\n"))
+	} else {
+		// Display forwards
+		for idx, id := range m.ui.forwardOrder {
+			fwd, ok := m.ui.forwards[id]
+			if !ok {
+				continue
+			}
+
+			isSelected := (idx == m.ui.selectedIndex)
+			isDisabled := m.ui.disabledMap[id]
+
+			// Selection indicator
+			indicator := "  "
+			if isSelected {
+				indicator = "> "
+			}
+
+			// Status icon and text
+			statusIcon := "● "
+			statusText := fwd.Status
+
+			if isDisabled {
+				statusIcon = "○ "
+				statusText = "Disabled"
+			} else {
+				switch fwd.Status {
+				case "Starting":
+					statusIcon = "○ "
+				case "Reconnecting":
+					statusIcon = "◐ "
+				case "Error":
+					statusIcon = "✗ "
+				}
+			}
+
+			// Format row
+			row := fmt.Sprintf("%s%-15s %-18s %-20s %-10s %-21s %7d %7d  %s%s",
+				indicator,
+				truncate(fwd.Context, 15),
+				truncate(fwd.Namespace, 18),
+				truncate(fwd.Alias, 20),
+				truncate(fwd.Type, 10),
+				truncate(fwd.Resource, 21),
+				fwd.RemotePort,
+				fwd.LocalPort,
+				statusIcon,
+				statusText)
+
+			// Apply styling
+			if isSelected {
+				row = selectedStyle.Render(row)
+			} else if isDisabled {
+				row = disabledStyle.Render(row)
+			} else {
+				// Color the status part
+				switch fwd.Status {
+				case "Active":
+					parts := strings.Split(row, statusIcon)
+					if len(parts) == 2 {
+						row = parts[0] + activeStyle.Render(statusIcon+statusText)
+					}
+				case "Starting", "Reconnecting":
+					parts := strings.Split(row, statusIcon)
+					if len(parts) == 2 {
+						row = parts[0] + startingStyle.Render(statusIcon+statusText)
+					}
+				case "Error":
+					parts := strings.Split(row, statusIcon)
+					if len(parts) == 2 {
+						row = parts[0] + errorStyle.Render(statusIcon+statusText)
+					}
+				}
+			}
+
+			b.WriteString(row)
+			b.WriteString("\n")
+		}
+	}
+
+	// Footer
+	b.WriteString("\n")
+	footerStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
+	keyStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("220"))
+
+	footer := fmt.Sprintf("%s/%s: Navigate  %s: Toggle  %s: Quit  │  Total: %d",
+		keyStyle.Render("↑↓"),
+		keyStyle.Render("jk"),
+		keyStyle.Render("Space"),
+		keyStyle.Render("q"),
+		len(m.ui.forwardOrder))
+
+	b.WriteString(footerStyle.Render(footer))
+
+	// Display errors if any
+	if len(m.ui.errors) > 0 {
+		b.WriteString("\n\n")
+		errorHeaderStyle := lipgloss.NewStyle().
+			Bold(true).
+			Foreground(lipgloss.Color("196"))
+
+		b.WriteString(errorHeaderStyle.Render("Errors:"))
+		b.WriteString("\n")
+
+		for id, errMsg := range m.ui.errors {
+			// Find the forward to display its alias
+			if fwd, ok := m.ui.forwards[id]; ok {
+				errorLineStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("196"))
+				line := fmt.Sprintf("  • %s: %s", fwd.Alias, errMsg)
+				b.WriteString(errorLineStyle.Render(line))
+				b.WriteString("\n")
+			}
+		}
+	}
+
+	return b.String()
+}
+
+// moveSelection moves the selection up or down
+func (ui *BubbleTeaUI) moveSelection(delta int) {
+	ui.mu.Lock()
+	defer ui.mu.Unlock()
+
+	if len(ui.forwardOrder) == 0 {
+		return
+	}
+
+	ui.selectedIndex += delta
+	if ui.selectedIndex < 0 {
+		ui.selectedIndex = 0
+	}
+	if ui.selectedIndex >= len(ui.forwardOrder) {
+		ui.selectedIndex = len(ui.forwardOrder) - 1
+	}
+}
+
+// toggleSelected toggles the selected forward on/off
+func (ui *BubbleTeaUI) toggleSelected() {
+	ui.mu.Lock()
+
+	if ui.selectedIndex < 0 || ui.selectedIndex >= len(ui.forwardOrder) {
+		ui.mu.Unlock()
+		return
+	}
+
+	selectedID := ui.forwardOrder[ui.selectedIndex]
+	currentlyDisabled := ui.disabledMap[selectedID]
+	newState := !currentlyDisabled
+	ui.disabledMap[selectedID] = newState
+
+	ui.mu.Unlock()
+
+	// Call the toggle callback in a goroutine to avoid blocking the UI
+	if ui.toggleCallback != nil {
+		go ui.toggleCallback(selectedID, !newState) // enable is inverse of disabled
+	}
+}

internal/ui/interactive.go

@@ -0,0 +1,181 @@
+package ui
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"golang.org/x/term"
+)
+
+// InteractiveController handles keyboard input and selection state
+type InteractiveController struct {
+	mu             sync.RWMutex
+	selectedIndex  int
+	forwardIDs     []string        // Ordered list of forward IDs
+	disabledMap    map[string]bool // Tracks which forwards are disabled
+	toggleCallback func(id string, enable bool)
+	enabled        bool
+	oldTermState   *term.State
+}
+
+// NewInteractiveController creates a new interactive controller
+func NewInteractiveController(toggleCallback func(id string, enable bool)) *InteractiveController {
+	return &InteractiveController{
+		selectedIndex:  0,
+		forwardIDs:     make([]string, 0),
+		disabledMap:    make(map[string]bool),
+		toggleCallback: toggleCallback,
+		enabled:        false,
+	}
+}
+
+// Enable puts the terminal in raw mode for keyboard input
+func (ic *InteractiveController) Enable() error {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+
+	if ic.enabled {
+		return nil
+	}
+
+	// Save current terminal state
+	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
+	if err != nil {
+		return fmt.Errorf("failed to enable raw mode: %w", err)
+	}
+
+	ic.oldTermState = oldState
+	ic.enabled = true
+	return nil
+}
+
+// Disable restores the terminal to normal mode
+func (ic *InteractiveController) Disable() error {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+
+	if !ic.enabled {
+		return nil
+	}
+
+	if ic.oldTermState != nil {
+		if err := term.Restore(int(os.Stdin.Fd()), ic.oldTermState); err != nil {
+			return fmt.Errorf("failed to restore terminal: %w", err)
+		}
+	}
+
+	ic.enabled = false
+	return nil
+}
+
+// UpdateForwardsList updates the list of forwards for navigation
+func (ic *InteractiveController) UpdateForwardsList(ids []string) {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+
+	ic.forwardIDs = ids
+
+	// Ensure selected index is valid
+	if ic.selectedIndex >= len(ic.forwardIDs) {
+		ic.selectedIndex = len(ic.forwardIDs) - 1
+	}
+	if ic.selectedIndex < 0 && len(ic.forwardIDs) > 0 {
+		ic.selectedIndex = 0
+	}
+}
+
+// MoveUp moves selection up
+func (ic *InteractiveController) MoveUp() {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+
+	if ic.selectedIndex > 0 {
+		ic.selectedIndex--
+	}
+}
+
+// MoveDown moves selection down
+func (ic *InteractiveController) MoveDown() {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+
+	if ic.selectedIndex < len(ic.forwardIDs)-1 {
+		ic.selectedIndex++
+	}
+}
+
+// ToggleSelected toggles the enable/disable state of the selected forward
+func (ic *InteractiveController) ToggleSelected() {
+	ic.mu.Lock()
+	if ic.selectedIndex < 0 || ic.selectedIndex >= len(ic.forwardIDs) {
+		ic.mu.Unlock()
+		return
+	}
+
+	selectedID := ic.forwardIDs[ic.selectedIndex]
+	currentlyDisabled := ic.disabledMap[selectedID]
+	newState := !currentlyDisabled
+	ic.disabledMap[selectedID] = newState
+	ic.mu.Unlock()
+
+	// Call the toggle callback
+	if ic.toggleCallback != nil {
+		ic.toggleCallback(selectedID, !newState) // enable is inverse of disabled
+	}
+}
+
+// GetSelectedIndex returns the current selection index
+func (ic *InteractiveController) GetSelectedIndex() int {
+	ic.mu.RLock()
+	defer ic.mu.RUnlock()
+	return ic.selectedIndex
+}
+
+// IsDisabled returns whether a forward is disabled
+func (ic *InteractiveController) IsDisabled(id string) bool {
+	ic.mu.RLock()
+	defer ic.mu.RUnlock()
+	return ic.disabledMap[id]
+}
+
+// GetSelectedID returns the ID of the currently selected forward
+func (ic *InteractiveController) GetSelectedID() string {
+	ic.mu.RLock()
+	defer ic.mu.RUnlock()
+
+	if ic.selectedIndex < 0 || ic.selectedIndex >= len(ic.forwardIDs) {
+		return ""
+	}
+	return ic.forwardIDs[ic.selectedIndex]
+}
+
+// HandleKey processes keyboard input and returns true if should continue
+func (ic *InteractiveController) HandleKey(b []byte) bool {
+	if len(b) == 0 {
+		return true
+	}
+
+	// Handle single byte keys
+	if len(b) == 1 {
+		switch b[0] {
+		case 'q', 'Q', 3: // q, Q, or Ctrl+C
+			return false
+		case ' ', '\r': // Space or Enter to toggle
+			ic.ToggleSelected()
+			return true
+		}
+	}
+
+	// Handle escape sequences (arrow keys)
+	if len(b) == 3 && b[0] == 27 && b[1] == 91 {
+		switch b[2] {
+		case 65: // Up arrow
+			ic.MoveUp()
+		case 66: // Down arrow
+			ic.MoveDown()
+		}
+	}
+
+	return true
+}

internal/ui/table.go

@@ -23,9 +23,10 @@ type ForwardStatus struct {
 
 // TableUI manages the terminal table display
 type TableUI struct {
-	mu       sync.RWMutex
-	forwards map[string]*ForwardStatus // key is forward ID
-	verbose  bool
+	mu          sync.RWMutex
+	forwards    map[string]*ForwardStatus // key is forward ID
+	verbose     bool
+	interactive *InteractiveController
 }
 
 // NewTableUI creates a new table UI manager
@@ -36,6 +37,13 @@ func NewTableUI(verbose bool) *TableUI {
 	}
 }
 
+// SetInteractiveController sets the interactive controller
+func (t *TableUI) SetInteractiveController(ic *InteractiveController) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.interactive = ic
+}
+
 // AddForward registers a new forward for display
 func (t *TableUI) AddForward(id string, fwd *config.Forward) {
 	t.mu.Lock()
@@ -118,10 +126,27 @@ func (t *TableUI) Render() {
 		}
 	}
 
+	// Update interactive controller with current forward IDs (in display order)
+	if t.interactive != nil {
+		ids := make([]string, len(entries))
+		for i, entry := range entries {
+			ids[i] = entry.id
+		}
+		t.interactive.UpdateForwardsList(ids)
+	}
+
 	// Print each forward
-	for _, entry := range entries {
+	for i, entry := range entries {
 		fwd := entry.fwd
 
+		// Check if this row is selected
+		isSelected := false
+		isDisabled := false
+		if t.interactive != nil {
+			isSelected = (i == t.interactive.GetSelectedIndex())
+			isDisabled = t.interactive.IsDisabled(entry.id)
+		}
+
 		// Truncate long names
 		alias := truncate(fwd.Alias, 25)
 		resource := truncate(fwd.Resource, 25)
@@ -129,7 +154,8 @@ func (t *TableUI) Render() {
 		// Color code status with indicator
 		statusStr := formatStatusWithIndicator(fwd.Status)
 
-		fmt.Printf("%-15s %-18s %-25s %-10s %-25s %-12d %-12d %s\n",
+		// Build the row content
+		rowContent := fmt.Sprintf("  %-15s %-18s %-25s %-10s %-25s %-12d %-12d %s",
 			fwd.Context,
 			fwd.Namespace,
 			alias,
@@ -138,10 +164,26 @@ func (t *TableUI) Render() {
 			fwd.RemotePort,
 			fwd.LocalPort,
 			statusStr)
+
+		// Apply selection highlighting or disabled styling
+		if isSelected {
+			// Replace leading spaces with arrow, then apply reverse video to entire line
+			rowContent = "\033[7m> " + rowContent[2:] + "\033[0m"
+		} else if isDisabled {
+			// Apply dimmed styling to entire line
+			rowContent = "\033[2m" + rowContent + "\033[0m"
+		}
+
+		fmt.Println(rowContent)
 	}
 
 	fmt.Println(strings.Repeat("=", 130))
-	fmt.Printf("Total forwards: %d | Press Ctrl+C to stop\n", len(t.forwards))
+	helpText := "Total forwards: %d | ↑↓: Navigate | Space: Toggle | q: Quit"
+	if !t.verbose {
+		fmt.Printf(helpText+"\n", len(t.forwards))
+	} else {
+		fmt.Printf("Total forwards: %d | Press Ctrl+C to stop\n", len(t.forwards))
+	}
 
 	// In verbose mode, add a newline to separate from logs
 	if t.verbose {