feat: implement Ping All feature with right-aligned status indicators

Add comprehensive ping functionality:
- Add 'G' shortcut to ping all servers simultaneously
- Add right-aligned status indicators on server list
- Show ping latency with adaptive formatting (<100ms as "##ms", >=100ms as "#.#s")
- Responsive design adapts to window width changes
- Color-coded status: green (up), red (down), orange (checking)
- Update single server ping (g) to also show status

Author: tan9

README.md

@@ -153,6 +153,7 @@ make run
 | Enter | SSH into selected server      |
 | c     | Copy SSH command to clipboard |
 | g     | Ping selected server          |
+| G     | Ping all servers              |
 | r     | Refresh background data       |
 | a     | Add server                    |
 | e     | Edit server                   |

internal/adapters/ui/handlers.go

@@ -66,6 +66,9 @@ func (t *tui) handleGlobalKeys(event *tcell.EventKey) *tcell.EventKey {
 	case 'g':
 		t.handlePingSelected()
 		return nil
+	case 'G':
+		t.handlePingAll()
+		return nil
 	case 'r':
 		t.handleRefreshBackground()
 		return nil
@@ -230,22 +233,38 @@ func (t *tui) handleFormCancel() {
 	t.returnToMain()
 }
 
+const (
+	statusUp       = "up"
+	statusDown     = "down"
+	statusChecking = "checking"
+)
+
 func (t *tui) handlePingSelected() {
 	if server, ok := t.serverList.GetSelectedServer(); ok {
 		alias := server.Alias
 
+		// Set checking status
+		server.PingStatus = statusChecking
+		t.pingStatuses[alias] = server
+		t.updateServerListWithPingStatus()
+
 		t.showStatusTemp(fmt.Sprintf("Pinging %s…", alias))
 		go func() {
 			up, dur, err := t.serverService.Ping(server)
 			t.app.QueueUpdateDraw(func() {
-				if err != nil {
-					t.showStatusTempColor(fmt.Sprintf("Ping %s: DOWN (%v)", alias, err), "#FF6B6B")
-					return
-				}
-				if up {
-					t.showStatusTempColor(fmt.Sprintf("Ping %s: UP (%s)", alias, dur), "#A0FFA0")
-				} else {
-					t.showStatusTempColor(fmt.Sprintf("Ping %s: DOWN", alias), "#FF6B6B")
+				// Update ping status
+				if ps, ok := t.pingStatuses[alias]; ok {
+					if err != nil || !up {
+						ps.PingStatus = statusDown
+						ps.PingLatency = 0
+						t.showStatusTempColor(fmt.Sprintf("Ping %s: DOWN", alias), "#FF6B6B")
+					} else {
+						ps.PingStatus = statusUp
+						ps.PingLatency = dur
+						t.showStatusTempColor(fmt.Sprintf("Ping %s: UP (%s)", alias, dur), "#A0FFA0")
+					}
+					t.pingStatuses[alias] = ps
+					t.updateServerListWithPingStatus()
 				}
 			})
 		}()
@@ -384,6 +403,93 @@ func (t *tui) returnToMain() {
 	t.app.SetRoot(t.root, true)
 }
 
+func (t *tui) updateServerListWithPingStatus() {
+	// Get current server list
+	query := ""
+	if t.searchVisible {
+		query = t.searchBar.InputField.GetText()
+	}
+	servers, _ := t.serverService.ListServers(query)
+	sortServersForUI(servers, t.sortMode)
+
+	// Update ping status for each server
+	for i := range servers {
+		if ps, ok := t.pingStatuses[servers[i].Alias]; ok {
+			servers[i].PingStatus = ps.PingStatus
+			servers[i].PingLatency = ps.PingLatency
+		}
+	}
+
+	t.serverList.UpdateServers(servers)
+}
+
+func (t *tui) handlePingAll() {
+	query := ""
+	if t.searchVisible {
+		query = t.searchBar.InputField.GetText()
+	}
+	servers, err := t.serverService.ListServers(query)
+	if err != nil {
+		t.showStatusTempColor(fmt.Sprintf("Failed to get servers: %v", err), "#FF6B6B")
+		return
+	}
+
+	if len(servers) == 0 {
+		t.showStatusTemp("No servers to ping")
+		return
+	}
+
+	t.showStatusTemp(fmt.Sprintf("Pinging all %d servers…", len(servers)))
+
+	// Clear existing statuses
+	t.pingStatuses = make(map[string]domain.Server)
+
+	// Set all servers to checking status
+	for _, server := range servers {
+		s := server
+		s.PingStatus = statusChecking
+		t.pingStatuses[s.Alias] = s
+	}
+	t.updateServerListWithPingStatus()
+
+	// Ping all servers concurrently
+	for _, server := range servers {
+		go func(srv domain.Server) {
+			up, dur, err := t.serverService.Ping(srv)
+			t.app.QueueUpdateDraw(func() {
+				if ps, ok := t.pingStatuses[srv.Alias]; ok {
+					if err != nil || !up {
+						ps.PingStatus = statusDown
+						ps.PingLatency = 0
+					} else {
+						ps.PingStatus = statusUp
+						ps.PingLatency = dur
+					}
+					t.pingStatuses[srv.Alias] = ps
+					t.updateServerListWithPingStatus()
+				}
+			})
+		}(server)
+	}
+
+	// Show completion status after 3 seconds
+	go func() {
+		time.Sleep(3 * time.Second)
+		t.app.QueueUpdateDraw(func() {
+			upCount := 0
+			downCount := 0
+			for _, ps := range t.pingStatuses {
+				if ps.PingStatus == statusUp {
+					upCount++
+				} else if ps.PingStatus == statusDown {
+					downCount++
+				}
+			}
+			t.showStatusTempColor(fmt.Sprintf("Ping completed: %d UP, %d DOWN", upCount, downCount), "#A0FFA0")
+		})
+	}()
+}
+
 // showStatusTemp displays a temporary message in the status bar (default green) and then restores the default text.
 func (t *tui) showStatusTemp(msg string) {
 	if t.statusBar == nil {

internal/adapters/ui/hint_bar.go

@@ -22,6 +22,6 @@ import (
 func NewHintBar() *tview.TextView {
 	hint := tview.NewTextView().SetDynamicColors(true)
 	hint.SetBackgroundColor(tcell.Color233)
-	hint.SetText("[#BBBBBB]Press [::b]/[-:-:b] to search…  •  ↑↓ Navigate  •  Enter SSH  •  c Copy SSH  •  g Ping  •  r Refresh  •  a Add  •  e Edit  •  t Tags  •  d Delete  •  p Pin/Unpin  •  s Sort[-]")
+	hint.SetText("[#BBBBBB]Press [::b]/[-:-:b] to search…  •  ↑↓ Navigate  •  Enter SSH  •  c Copy SSH  •  g/G Ping (All)  •  r Refresh  •  a Add  •  e Edit  •  t Tags  •  d Delete  •  p Pin/Unpin  •  s Sort[-]")
 	return hint
 }

internal/adapters/ui/server_list.go

@@ -25,6 +25,7 @@ type ServerList struct {
 	servers           []domain.Server
 	onSelection       func(domain.Server)
 	onSelectionChange func(domain.Server)
+	currentWidth      int
 }
 
 func NewServerList() *ServerList {
@@ -57,8 +58,12 @@ func (sl *ServerList) UpdateServers(servers []domain.Server) {
 	sl.servers = servers
 	sl.List.Clear()
 
+	// Get current width
+	_, _, width, _ := sl.List.GetInnerRect() //nolint:dogsled
+	sl.currentWidth = width
+
 	for i := range servers {
-		primary, secondary := formatServerLine(servers[i])
+		primary, secondary := formatServerLine(servers[i], width)
 		idx := i
 		sl.List.AddItem(primary, secondary, 0, func() {
 			if sl.onSelection != nil {
@@ -75,6 +80,22 @@ func (sl *ServerList) UpdateServers(servers []domain.Server) {
 	}
 }
 
+// RefreshDisplay re-renders the list with current width
+func (sl *ServerList) RefreshDisplay() {
+	_, _, width, _ := sl.List.GetInnerRect() //nolint:dogsled
+	if width != sl.currentWidth {
+		sl.currentWidth = width
+		// Save current selection
+		currentIdx := sl.List.GetCurrentItem()
+		// Re-render
+		sl.UpdateServers(sl.servers)
+		// Restore selection
+		if currentIdx >= 0 && currentIdx < sl.List.GetItemCount() {
+			sl.List.SetCurrentItem(currentIdx)
+		}
+	}
+}
+
 func (sl *ServerList) GetSelectedServer() (domain.Server, bool) {
 	idx := sl.List.GetCurrentItem()
 	if idx >= 0 && idx < len(sl.servers) {

internal/adapters/ui/status_bar.go

@@ -20,7 +20,7 @@ import (
 )
 
 func DefaultStatusText() string {
-	return "[white]↑↓[-] Navigate  • [white]Enter[-] SSH  • [white]c[-] Copy SSH  • [white]a[-] Add  • [white]e[-] Edit  • [white]g[-] Ping  • [white]d[-] Delete  • [white]p[-] Pin/Unpin  • [white]/[-] Search  • [white]q[-] Quit"
+	return "[white]↑↓[-] Navigate  • [white]Enter[-] SSH  • [white]c[-] Copy SSH  • [white]a[-] Add  • [white]e[-] Edit  • [white]g/G[-] Ping (All)  • [white]d[-] Delete  • [white]p[-] Pin/Unpin  • [white]/[-] Search  • [white]q[-] Quit"
 }
 
 func NewStatusBar() *tview.TextView {

internal/adapters/ui/tui.go

@@ -18,6 +18,7 @@ import (
 	"github.com/gdamore/tcell/v2"
 	"go.uber.org/zap"
 
+	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/Adembc/lazyssh/internal/core/ports"
 	"github.com/rivo/tview"
 )
@@ -48,6 +49,8 @@ type tui struct {
 
 	sortMode      SortMode
 	searchVisible bool
+
+	pingStatuses map[string]domain.Server // stores ping status for each server
 }
 
 func NewTUI(logger *zap.SugaredLogger, ss ports.ServerService, version, commit string) App {
@@ -57,6 +60,7 @@ func NewTUI(logger *zap.SugaredLogger, ss ports.ServerService, version, commit s
 		serverService: ss,
 		version:       version,
 		commit:        commit,
+		pingStatuses:  make(map[string]domain.Server),
 	}
 }
 
@@ -127,6 +131,14 @@ func (t *tui) buildLayout() *tui {
 
 func (t *tui) bindEvents() *tui {
 	t.root.SetInputCapture(t.handleGlobalKeys)
+
+	// Handle window resize
+	t.app.SetBeforeDrawFunc(func(screen tcell.Screen) bool {
+		// Refresh server list display on resize
+		t.serverList.RefreshDisplay()
+		return false
+	})
+
 	return t
 }
 

internal/adapters/ui/utils.go

@@ -64,12 +64,102 @@ func pinnedIcon(pinnedAt time.Time) string {
 	return "📌" // pinned
 }
 
-func formatServerLine(s domain.Server) (primary, secondary string) {
+func formatServerLine(s domain.Server, width int) (primary, secondary string) {
 	icon := cellPad(pinnedIcon(s.PinnedAt), 2)
-	// Use a consistent color for alias; the icon reflects pinning
-	primary = fmt.Sprintf("%s [white::b]%-12s[-] [#AAAAAA]%-18s[-] [#888888]Last SSH: %s[-]  %s", icon, s.Alias, s.Host, humanizeDuration(s.LastSeen), renderTagBadgesForList(s.Tags))
+
+	// Build main content
+	mainText := fmt.Sprintf("%s [white::b]%-12s[-] [#AAAAAA]%-18s[-] [#888888]Last SSH: %s[-]  %s",
+		icon, s.Alias, s.Host, humanizeDuration(s.LastSeen), renderTagBadgesForList(s.Tags))
+
+	// Format ping status (4 chars max for value)
+	pingIndicator := ""
+	if s.PingStatus != "" {
+		switch s.PingStatus {
+		case "up":
+			if s.PingLatency > 0 {
+				ms := s.PingLatency.Milliseconds()
+				var statusText string
+				if ms < 100 {
+					statusText = fmt.Sprintf("%dms", ms) // e.g., "57ms"
+				} else {
+					// Format as #.#s for >= 100ms
+					seconds := float64(ms) / 1000.0
+					statusText = fmt.Sprintf("%.1fs", seconds) // e.g., "0.3s", "1.5s"
+				}
+				// Ensure exactly 4 chars
+				statusText = fmt.Sprintf("%-4s", statusText)
+				pingIndicator = fmt.Sprintf("[#4AF626]● %s[-]", statusText)
+			} else {
+				pingIndicator = "[#4AF626]● UP  [-]"
+			}
+		case "down":
+			pingIndicator = "[#FF6B6B]● DOWN[-]"
+		case "checking":
+			pingIndicator = "[#FFB86C]● ... [-]"
+		}
+	}
+
+	// Calculate padding for right alignment
+	if pingIndicator != "" && width > 0 {
+		// Strip color codes to calculate real length
+		mainTextLen := len(stripSimpleColors(mainText))
+		indicatorLen := 6 // "● XXXX" is always 6 display chars
+
+		// Calculate padding needed
+		switch {
+		case width > 80:
+			// Wide screen: show full indicator
+			paddingLen := width - mainTextLen - indicatorLen // No margin, stick to right edge
+			if paddingLen < 1 {
+				paddingLen = 1
+			}
+			padding := strings.Repeat(" ", paddingLen)
+			primary = fmt.Sprintf("%s%s%s", mainText, padding, pingIndicator)
+		case width > 60:
+			// Medium screen: show only dot
+			simplePingIndicator := ""
+			switch s.PingStatus {
+			case "up":
+				simplePingIndicator = "[#4AF626]●[-]"
+			case "down":
+				simplePingIndicator = "[#FF6B6B]●[-]"
+			case "checking":
+				simplePingIndicator = "[#FFB86C]●[-]"
+			}
+			paddingLen := width - mainTextLen - 1 // 1 for dot, no margin
+			if paddingLen < 1 {
+				paddingLen = 1
+			}
+			padding := strings.Repeat(" ", paddingLen)
+			primary = fmt.Sprintf("%s%s%s", mainText, padding, simplePingIndicator)
+		default:
+			// Narrow screen: no ping indicator
+			primary = mainText
+		}
+	} else {
+		primary = mainText
+	}
+
 	secondary = ""
-	return
+	return primary, secondary
+}
+
+// stripSimpleColors removes basic tview color codes for length calculation
+func stripSimpleColors(s string) string {
+	result := s
+	// Remove color tags like [#FFFFFF] or [-]
+	for {
+		start := strings.Index(result, "[")
+		if start == -1 {
+			break
+		}
+		end := strings.Index(result[start:], "]")
+		if end == -1 {
+			break
+		}
+		result = result[:start] + result[start+end+1:]
+	}
+	return result
 }
 
 func humanizeDuration(t time.Time) string {

internal/core/domain/server.go

@@ -27,4 +27,6 @@ type Server struct {
 	LastSeen      time.Time
 	PinnedAt      time.Time
 	SSHCount      int
+	PingStatus    string        // "up", "down", "checking", or ""
+	PingLatency   time.Duration // ping latency
 }