route health on dashboard, detail panel on domains (#7)

Updated dashboard view
Updated domains tab with details
Fixed tab cycle issue
Added route health on dashboard

Author: venkatkrishna07

internal/proxy/prober/prober.go

@@ -0,0 +1,214 @@
+// Package prober TCP-probes route upstreams on a fixed interval and exposes
+// per-host health snapshots for the dashboard and runtime status reporting.
+package prober
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/venkatkrishna07/mkdev/internal/store"
+)
+
+// Status is the health verdict for a single route's upstream.
+type Status int
+
+// Status values reported by Health / Snapshot.
+const (
+	// StatusOff is the zero value and the recorded status for disabled routes.
+	StatusOff Status = iota
+	// StatusUp means the most recent dial succeeded.
+	StatusUp
+	// StatusDown means the most recent dial failed; LastErr carries the reason.
+	StatusDown
+)
+
+func (s Status) String() string {
+	switch s {
+	case StatusUp:
+		return "up"
+	case StatusDown:
+		return "down"
+	default:
+		return "off"
+	}
+}
+
+// HealthState is the most recent probe outcome for one host.
+type HealthState struct {
+	Status    Status
+	LastErr   string
+	LastProbe time.Time
+}
+
+const (
+	probePoolSize = 8
+	errMaxLen     = 80
+)
+
+// dialer is overridable so future code can swap the network call without
+// changing the Prober's structure. Default does a bounded TCP DialContext.
+var dialer = func(ctx context.Context, target string, timeout time.Duration) error {
+	d := net.Dialer{Timeout: timeout}
+	conn, err := d.DialContext(ctx, "tcp", target)
+	if err != nil {
+		return err
+	}
+	_ = conn.Close()
+	return nil
+}
+
+// Prober periodically TCP-dials every enabled route's upstream.
+type Prober struct {
+	interval time.Duration
+	timeout  time.Duration
+	routes   func() ([]store.Route, error)
+	states   sync.Map // host (lowercased) -> HealthState
+}
+
+// New returns a Prober that pulls routes from the given function and probes
+// each enabled upstream every interval with per-dial timeout.
+func New(routes func() ([]store.Route, error), interval, timeout time.Duration) *Prober {
+	return &Prober{
+		interval: interval,
+		timeout:  timeout,
+		routes:   routes,
+	}
+}
+
+// Health returns the last known state for host, or the zero value (StatusOff)
+// if the host has never been probed.
+func (p *Prober) Health(host string) HealthState {
+	v, ok := p.states.Load(strings.ToLower(host))
+	if !ok {
+		return HealthState{}
+	}
+	return v.(HealthState)
+}
+
+// Snapshot returns a copy of every host's current health state.
+func (p *Prober) Snapshot() map[string]HealthState {
+	out := map[string]HealthState{}
+	p.states.Range(func(k, v any) bool {
+		out[k.(string)] = v.(HealthState)
+		return true
+	})
+	return out
+}
+
+// Run probes immediately, then on every interval tick, until ctx is cancelled.
+func (p *Prober) Run(ctx context.Context) {
+	p.tick(ctx)
+	t := time.NewTicker(p.interval)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+			p.tick(ctx)
+		}
+	}
+}
+
+func (p *Prober) tick(ctx context.Context) {
+	routes, err := p.routes()
+	if err != nil {
+		return
+	}
+
+	live := make(map[string]struct{}, len(routes))
+	jobs := make(chan store.Route)
+	var wg sync.WaitGroup
+
+	for range probePoolSize {
+		wg.Go(func() {
+			for r := range jobs {
+				p.probe(ctx, r)
+			}
+		})
+	}
+
+	for _, r := range routes {
+		host := strings.ToLower(r.Domain)
+		live[host] = struct{}{}
+		if !r.Enabled {
+			p.states.Store(host, HealthState{Status: StatusOff, LastProbe: time.Now()})
+			continue
+		}
+		select {
+		case jobs <- r:
+		case <-ctx.Done():
+			close(jobs)
+			wg.Wait()
+			return
+		}
+	}
+	close(jobs)
+	wg.Wait()
+
+	p.states.Range(func(k, _ any) bool {
+		if _, ok := live[k.(string)]; !ok {
+			p.states.Delete(k)
+		}
+		return true
+	})
+}
+
+func (p *Prober) probe(ctx context.Context, r store.Route) {
+	host := strings.ToLower(r.Domain)
+	st := HealthState{Status: StatusUp, LastProbe: time.Now()}
+	target := strings.TrimSpace(r.Target)
+	switch target {
+	case "":
+		st.Status, st.LastErr = StatusDown, "bad upstream"
+	default:
+		addr, err := dialAddress(target)
+		if err == nil {
+			dctx, cancel := context.WithTimeout(ctx, p.timeout)
+			err = dialer(dctx, addr, p.timeout)
+			cancel()
+		}
+		if err != nil {
+			st.Status, st.LastErr = StatusDown, truncErr(err.Error())
+		}
+	}
+	p.states.Store(host, st)
+}
+
+// dialAddress normalises a route Target (bare host[:port] or full URL) into a
+// host:port string suitable for net.Dialer.
+func dialAddress(target string) (string, error) {
+	s := target
+	if !strings.HasPrefix(s, "http://") && !strings.HasPrefix(s, "https://") {
+		s = "http://" + s
+	}
+	u, err := url.Parse(s)
+	if err != nil {
+		return "", err
+	}
+	host := u.Hostname()
+	if host == "" {
+		return "", errors.New("no host in target")
+	}
+	port := u.Port()
+	if port == "" {
+		if u.Scheme == "https" {
+			port = "443"
+		} else {
+			port = "80"
+		}
+	}
+	return net.JoinHostPort(host, port), nil
+}
+
+func truncErr(s string) string {
+	if len(s) <= errMaxLen {
+		return s
+	}
+	return s[:errMaxLen-3] + "..."
+}

internal/proxy/stats.go

@@ -22,6 +22,8 @@ type Stats struct {
 	rpsMu  sync.Mutex
 	rpsBuf [rpsWindowSec]uint32
 	rpsTs  int64 // last bucket epoch second written
+
+	lastReq map[string]time.Time
 }
 
 type ring struct {
@@ -33,7 +35,10 @@ type ring struct {
 
 // NewStats returns an empty Stats collector.
 func NewStats() *Stats {
-	return &Stats{buf: make(map[string]*ring)}
+	return &Stats{
+		buf:     make(map[string]*ring),
+		lastReq: make(map[string]time.Time),
+	}
 }
 
 // Record adds one RTT sample for domain and bumps the rolling RPS window.
@@ -56,6 +61,10 @@ func (s *Stats) Record(domain string, d time.Duration) {
 	s.mu.Unlock()
 
 	s.bumpRPS()
+
+	s.rpsMu.Lock()
+	s.lastReq[domain] = time.Now()
+	s.rpsMu.Unlock()
 }
 
 func (s *Stats) bumpRPS() {
@@ -140,6 +149,15 @@ func (s *Stats) RPS() []float64 {
 	return out
 }
 
+// LastSeen returns the time the most recent request for host was recorded.
+// Returns a zero-value time.Time when host has never received a request.
+func (s *Stats) LastSeen(host string) time.Time {
+	host = strings.ToLower(host)
+	s.rpsMu.Lock()
+	defer s.rpsMu.Unlock()
+	return s.lastReq[host]
+}
+
 // Domains returns the set of domains that have recorded at least one request.
 func (s *Stats) Domains() []string {
 	s.mu.RLock()

internal/tui/components/sharebadge.go

@@ -0,0 +1,15 @@
+package components
+
+import (
+	"github.com/charmbracelet/lipgloss"
+	"github.com/venkatkrishna07/mkdev/internal/tui/styles"
+)
+
+// ShareBadge renders a compact indicator of a route's share scope:
+// "LAN" in the accent colour when shared, "local" dimmed otherwise.
+func ShareBadge(th styles.Theme, shared bool) string {
+	if shared {
+		return lipgloss.NewStyle().Bold(true).Foreground(th.Accent).Render("LAN")
+	}
+	return th.Dim.Render("local")
+}

internal/tui/program.go

@@ -14,6 +14,7 @@ import (
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/venkatkrishna07/mkdev/internal/browser"
+	"github.com/venkatkrishna07/mkdev/internal/store"
 	"github.com/venkatkrishna07/mkdev/internal/tui/components"
 	"github.com/venkatkrishna07/mkdev/internal/tui/modals"
 	"github.com/venkatkrishna07/mkdev/internal/tui/styles"
@@ -111,20 +112,33 @@ func newRootModel(rt *Runtime) rootModel {
 		RPS:   rt.Stats.RPS,
 		CA:    rt.Issuer.CACert(),
 		Start: time.Now(),
+		Routes: func() []store.Route {
+			rs, _ := rt.Store.ListRoutes()
+			return rs
+		},
+		Health:   rt.Prober.Health,
+		LastSeen: rt.Stats.LastSeen,
+		LAN: func() tabs.LANState {
+			s := rt.LANState()
+			return tabs.LANState{IP: s.IP, Advertising: s.Advertising, SharedCount: s.SharedCount}
+		},
 	}
 	return rootModel{
 		rt:        rt,
 		th:        th,
 		dashboard: tabs.NewDashboard(th, dashSrc),
-		domains:   tabs.NewDomainsWithRTT(th, 100, 24, rt.Stats.Snapshot),
-		logs:      tabs.NewLogs(th, logPath),
-		doctor:    tabs.NewDoctor(th, rt.Home, rt.Store),
-		settings:  tabs.NewSettings(th, rt.Home),
-		binPath:   bp,
-		keys:      DefaultKeyMap,
-		help:      h,
-		spinner:   sp,
-		splash:    true,
+		domains: tabs.NewDomainsWithSources(th, 100, 24, rt.Stats.Snapshot, rt.Prober.Health, func() tabs.LANState {
+			s := rt.LANState()
+			return tabs.LANState{IP: s.IP, Advertising: s.Advertising, SharedCount: s.SharedCount}
+		}),
+		logs:     tabs.NewLogs(th, logPath),
+		doctor:   tabs.NewDoctor(th, rt.Home, rt.Store),
+		settings: tabs.NewSettings(th, rt.Home),
+		binPath:  bp,
+		keys:     DefaultKeyMap,
+		help:     h,
+		spinner:  sp,
+		splash:   true,
 	}
 }
 
@@ -267,11 +281,6 @@ func (m rootModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (m rootModel) handleGlobalKey(k tea.KeyMsg) (tea.Model, tea.Cmd) {
-	// Settings owns Tab/Shift+Tab for field navigation; tab-bar uses 1-5
-	// (or ctrl+]/ctrl+[) to switch tabs while inside Settings.
-	if m.active == tabSettings && (key.Matches(k, m.keys.NextTab) || key.Matches(k, m.keys.PrevTab)) {
-		return m.forwardToActiveTab(k)
-	}
 	switch {
 	case key.Matches(k, m.keys.Quit):
 		m.modals = append(m.modals, modals.NewConfirm(m.th, "Quit mkdev?", "stops the proxy and closes the TUI"))