refactor: extract isHealthy helper pattern for consistent health checks

Add centralized helper functions for checking server health status:

Go:
- Add IsHealthy() to internal/health/constants.go for core server use
- Add isServerHealthy() to tray adapter for local HealthStatus type
- Update tray adapter to use helper instead of duplicated inline logic

TypeScript:
- Create frontend/src/utils/health.ts with isServerConnected() helper
- Add HealthLevel, AdminState, HealthAction constants matching backend
- Update stores/servers.ts to import from centralized utility

Benefits:
- Single source of truth for health check logic per language
- Consistent fallback behavior when health is nil/undefined
- Easier maintenance when updating health check algorithm
- Better testability with isolated helper functions

Implements suggestion smart-mcp-proxy#1 from PR smart-mcp-proxy#205 review.

Author: technicalpickles

cmd/mcpproxy-tray/internal/api/adapter.go

@@ -10,6 +10,17 @@ import (
 	internalRuntime "mcpproxy-go/internal/runtime"
 )
 
+// isServerHealthy returns true if the server is considered healthy.
+// It uses health.level as the source of truth, with a fallback to the legacy
+// connected field for backward compatibility when health is nil.
+func isServerHealthy(health *HealthStatus, legacyConnected bool) bool {
+	if health != nil {
+		return health.Level == "healthy"
+	}
+	// Fallback to legacy connected field if health is not available
+	return legacyConnected
+}
+
 // ServerAdapter adapts the API client to the ServerInterface expected by the tray
 type ServerAdapter struct {
 	client *Client
@@ -61,11 +72,7 @@ func (a *ServerAdapter) GetUpstreamStats() map[string]interface{} {
 	connectedCount := 0
 	totalTools := 0
 	for _, server := range servers {
-		// Spec 013: Use health.level as source of truth
-		if server.Health != nil && server.Health.Level == "healthy" {
-			connectedCount++
-		} else if server.Health == nil && server.Connected {
-			// Fallback to legacy connected field if health not available
+		if isServerHealthy(server.Health, server.Connected) {
 			connectedCount++
 		}
 		totalTools += server.ToolCount
@@ -118,11 +125,7 @@ func (a *ServerAdapter) GetStatus() interface{} {
 
 	connectedCount := 0
 	for _, server := range servers {
-		// Spec 013: Use health.level as source of truth
-		if server.Health != nil && server.Health.Level == "healthy" {
-			connectedCount++
-		} else if server.Health == nil && server.Connected {
-			// Fallback to legacy connected field if health not available
+		if isServerHealthy(server.Health, server.Connected) {
 			connectedCount++
 		}
 	}

frontend/src/stores/servers.ts

@@ -2,26 +2,13 @@ import { defineStore } from 'pinia'
 import { ref, computed } from 'vue'
 import type { Server, LoadingState } from '@/types'
 import api from '@/services/api'
+import { isServerConnected } from '@/utils/health'
 
 export const useServersStore = defineStore('servers', () => {
   // State
   const servers = ref<Server[]>([])
   const loading = ref<LoadingState>({ loading: false, error: null })
 
-  // Helper: Check if a server is considered "connected" using health.level as source of truth
-  // Falls back to legacy connected field for backward compatibility
-  function isServerConnected(server: Server): boolean {
-    // Spec 013: health.level is the single source of truth
-    if (server.health?.level === 'healthy') {
-      return true
-    }
-    // Fallback to legacy connected field if health is not present
-    if (!server.health) {
-      return server.connected
-    }
-    return false
-  }
-
   // Computed
   const serverCount = computed(() => ({
     total: servers.value.length,

frontend/src/utils/health.ts

@@ -0,0 +1,105 @@
+/**
+ * Health status utility functions
+ * Extracted for consistent health checks across the application
+ */
+
+import type { HealthStatus, Server } from '@/types'
+
+/**
+ * Health level constants matching Go backend (internal/health/constants.go)
+ */
+export const HealthLevel = {
+  Healthy: 'healthy',
+  Degraded: 'degraded',
+  Unhealthy: 'unhealthy',
+} as const
+
+/**
+ * Admin state constants matching Go backend (internal/health/constants.go)
+ */
+export const AdminState = {
+  Enabled: 'enabled',
+  Disabled: 'disabled',
+  Quarantined: 'quarantined',
+} as const
+
+/**
+ * Action constants matching Go backend (internal/health/constants.go)
+ */
+export const HealthAction = {
+  None: '',
+  Login: 'login',
+  Restart: 'restart',
+  Enable: 'enable',
+  Approve: 'approve',
+  ViewLogs: 'view_logs',
+  SetSecret: 'set_secret',
+  Configure: 'configure',
+} as const
+
+/**
+ * Check if a health status indicates a healthy server.
+ * Uses health.level as the source of truth.
+ *
+ * @param health - The health status object (may be undefined)
+ * @param legacyConnected - Fallback value when health is not available
+ * @returns true if the server is considered healthy
+ */
+export function isHealthy(health: HealthStatus | undefined, legacyConnected: boolean): boolean {
+  if (health) {
+    return health.level === HealthLevel.Healthy
+  }
+  // Fallback to legacy connected field if health is not available
+  return legacyConnected
+}
+
+/**
+ * Check if a server is considered "connected" using health.level as source of truth.
+ * Falls back to legacy connected field for backward compatibility.
+ *
+ * This is the canonical function to use when determining if a server is operational.
+ *
+ * @param server - The server object
+ * @returns true if the server is connected/healthy
+ */
+export function isServerConnected(server: Server): boolean {
+  return isHealthy(server.health, server.connected)
+}
+
+/**
+ * Get the appropriate badge class for a health level
+ *
+ * @param level - The health level
+ * @returns DaisyUI badge class
+ */
+export function getHealthBadgeClass(level: string): string {
+  switch (level) {
+    case HealthLevel.Healthy:
+      return 'badge-success'
+    case HealthLevel.Degraded:
+      return 'badge-warning'
+    case HealthLevel.Unhealthy:
+      return 'badge-error'
+    default:
+      return 'badge-ghost'
+  }
+}
+
+/**
+ * Get the appropriate badge class for an admin state
+ *
+ * @param state - The admin state
+ * @returns DaisyUI badge class
+ */
+export function getAdminStateBadgeClass(state: string): string {
+  switch (state) {
+    case AdminState.Enabled:
+      return 'badge-success'
+    case AdminState.Disabled:
+      return 'badge-ghost'
+    case AdminState.Quarantined:
+      return 'badge-warning'
+    default:
+      return 'badge-ghost'
+  }
+}

internal/health/constants.go

@@ -1,6 +1,8 @@
 // Package health provides unified health status calculation for upstream MCP servers.
 package health
 
+import "mcpproxy-go/internal/contracts"
+
 // Health levels
 const (
 	LevelHealthy   = "healthy"
@@ -26,3 +28,14 @@ const (
 	ActionSetSecret = "set_secret"
 	ActionConfigure = "configure"
 )
+
+// IsHealthy returns true if the server is considered healthy.
+// It uses health.level as the source of truth, with a fallback to the legacy
+// connected field for backward compatibility when health is nil.
+func IsHealthy(health *contracts.HealthStatus, legacyConnected bool) bool {
+	if health != nil {
+		return health.Level == LevelHealthy
+	}
+	// Fallback to legacy connected field if health is not available
+	return legacyConnected
+}

internal/health/helpers_test.go

@@ -0,0 +1,72 @@
+package health
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"mcpproxy-go/internal/contracts"
+)
+
+func TestIsHealthy_WithHealthyLevel(t *testing.T) {
+	health := &contracts.HealthStatus{
+		Level:      LevelHealthy,
+		AdminState: StateEnabled,
+		Summary:    "Connected (5 tools)",
+	}
+
+	assert.True(t, IsHealthy(health, false), "should return true when health.level is healthy")
+	assert.True(t, IsHealthy(health, true), "should return true when health.level is healthy, ignoring legacy")
+}
+
+func TestIsHealthy_WithDegradedLevel(t *testing.T) {
+	health := &contracts.HealthStatus{
+		Level:      LevelDegraded,
+		AdminState: StateEnabled,
+		Summary:    "Token expiring soon",
+	}
+
+	assert.False(t, IsHealthy(health, false), "should return false when health.level is degraded")
+	assert.False(t, IsHealthy(health, true), "should return false when health.level is degraded, ignoring legacy")
+}
+
+func TestIsHealthy_WithUnhealthyLevel(t *testing.T) {
+	health := &contracts.HealthStatus{
+		Level:      LevelUnhealthy,
+		AdminState: StateEnabled,
+		Summary:    "Connection error",
+	}
+
+	assert.False(t, IsHealthy(health, false), "should return false when health.level is unhealthy")
+	assert.False(t, IsHealthy(health, true), "should return false when health.level is unhealthy, ignoring legacy")
+}
+
+func TestIsHealthy_NilHealthFallsBackToLegacy(t *testing.T) {
+	// When health is nil, should fall back to legacy connected field
+	assert.True(t, IsHealthy(nil, true), "should return legacy connected value when health is nil")
+	assert.False(t, IsHealthy(nil, false), "should return legacy connected value when health is nil")
+}
+
+func TestIsHealthy_DisabledServerIsHealthy(t *testing.T) {
+	// Disabled servers are intentionally not running, so they're considered "healthy"
+	// (admin made a deliberate choice)
+	health := &contracts.HealthStatus{
+		Level:      LevelHealthy,
+		AdminState: StateDisabled,
+		Summary:    "Disabled",
+	}
+
+	assert.True(t, IsHealthy(health, false), "disabled servers should be considered healthy")
+}
+
+func TestIsHealthy_QuarantinedServerIsHealthy(t *testing.T) {
+	// Quarantined servers are intentionally blocked, so they're considered "healthy"
+	// (admin made a deliberate choice)
+	health := &contracts.HealthStatus{
+		Level:      LevelHealthy,
+		AdminState: StateQuarantined,
+		Summary:    "Quarantined for review",
+	}
+
+	assert.True(t, IsHealthy(health, false), "quarantined servers should be considered healthy")
+}