working intel gpu stats for one gpu

.github/workflows/docker-images.yml

@@ -12,137 +12,49 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # henrygd/beszel
           - image: henrygd/beszel
+            context: ./
             dockerfile: ./internal/dockerfile_hub
             registry: docker.io
             username_secret: DOCKERHUB_USERNAME
             password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
-          # henrygd/beszel-agent
           - image: henrygd/beszel-agent
+            context: ./
             dockerfile: ./internal/dockerfile_agent
             registry: docker.io
             username_secret: DOCKERHUB_USERNAME
             password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
-          # henrygd/beszel-agent-nvidia
           - image: henrygd/beszel-agent-nvidia
+            context: ./
             dockerfile: ./internal/dockerfile_agent_nvidia
             platforms: linux/amd64
             registry: docker.io
             username_secret: DOCKERHUB_USERNAME
             password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
-          # henrygd/beszel-agent-intel
-          - image: henrygd/beszel-agent-intel
-            dockerfile: ./internal/dockerfile_agent_intel
-            platforms: linux/amd64
-            registry: docker.io
-            username_secret: DOCKERHUB_USERNAME
-            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
-
-          # henrygd/beszel-agent:alpine
-          - image: henrygd/beszel-agent
-            dockerfile: ./internal/dockerfile_agent_alpine
-            registry: docker.io
-            username_secret: DOCKERHUB_USERNAME
-            password_secret: DOCKERHUB_TOKEN
-            tags: |
-              type=raw,value=alpine
-              type=semver,pattern={{version}}-alpine
-              type=semver,pattern={{major}}.{{minor}}-alpine
-              type=semver,pattern={{major}}-alpine
-
-          # ghcr.io/henrygd/beszel
           - image: ghcr.io/${{ github.repository }}/beszel
+            context: ./
             dockerfile: ./internal/dockerfile_hub
             registry: ghcr.io
             username: ${{ github.actor }}
             password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
-          # ghcr.io/henrygd/beszel-agent
           - image: ghcr.io/${{ github.repository }}/beszel-agent
+            context: ./
             dockerfile: ./internal/dockerfile_agent
             registry: ghcr.io
             username: ${{ github.actor }}
             password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
-          # ghcr.io/henrygd/beszel-agent-nvidia
           - image: ghcr.io/${{ github.repository }}/beszel-agent-nvidia
+            context: ./
             dockerfile: ./internal/dockerfile_agent_nvidia
             platforms: linux/amd64
             registry: ghcr.io
             username: ${{ github.actor }}
             password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
-
-          # ghcr.io/henrygd/beszel-agent-intel
-          - image: ghcr.io/${{ github.repository }}/beszel-agent-intel
-            dockerfile: ./internal/dockerfile_agent_intel
-            platforms: linux/amd64
-            registry: ghcr.io
-            username: ${{ github.actor }}
-            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=edge
-              type=semver,pattern={{version}}
-              type=semver,pattern={{major}}.{{minor}}
-              type=semver,pattern={{major}}
-              type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
-
-          # ghcr.io/henrygd/beszel-agent:alpine
-          - image: ghcr.io/${{ github.repository }}/beszel-agent
-            dockerfile: ./internal/dockerfile_agent_alpine
-            registry: ghcr.io
-            username: ${{ github.actor }}
-            password_secret: GITHUB_TOKEN
-            tags: |
-              type=raw,value=alpine
-              type=semver,pattern={{version}}-alpine
-              type=semver,pattern={{major}}.{{minor}}-alpine
-              type=semver,pattern={{major}}-alpine
 
     permissions:
       contents: read
@@ -172,7 +84,12 @@ jobs:
         uses: docker/metadata-action@v5
         with:
           images: ${{ matrix.image }}
-          tags: ${{ matrix.tags }}
+          tags: |
+            type=raw,value=edge
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
       # https://github.com/docker/login-action
       - name: Login to Docker Hub
@@ -190,7 +107,7 @@ jobs:
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
-          context: ./
+          context: "${{ matrix.context }}"
           file: ${{ matrix.dockerfile }}
           platforms: ${{ matrix.platforms || 'linux/amd64,linux/arm64,linux/arm/v7' }}
           push: ${{ github.ref_type == 'tag' && secrets[matrix.password_secret] != '' }}

agent/agent.go

@@ -12,37 +12,33 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/gliderlabs/ssh"
 	"github.com/henrygd/beszel"
-	"github.com/henrygd/beszel/agent/deltatracker"
 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/shirou/gopsutil/v4/host"
 	gossh "golang.org/x/crypto/ssh"
 )
 
 type Agent struct {
-	sync.Mutex                                                                      // Used to lock agent while collecting data
-	debug                     bool                                                  // true if LOG_LEVEL is set to debug
-	zfs                       bool                                                  // true if system has arcstats
-	memCalc                   string                                                // Memory calculation formula
-	fsNames                   []string                                              // List of filesystem device names being monitored
-	fsStats                   map[string]*system.FsStats                            // Keeps track of disk stats for each filesystem
-	diskPrev                  map[uint16]map[string]prevDisk                        // Previous disk I/O counters per cache interval
-	netInterfaces             map[string]struct{}                                   // Stores all valid network interfaces
-	netIoStats                map[uint16]system.NetIoStats                          // Keeps track of bandwidth usage per cache interval
-	netInterfaceDeltaTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64] // Per-cache-time NIC delta trackers
-	dockerManager             *dockerManager                                        // Manages Docker API requests
-	sensorConfig              *SensorConfig                                         // Sensors config
-	systemInfo                system.Info                                           // Host system info
-	gpuManager                *GPUManager                                           // Manages GPU data
-	cache                     *systemDataCache                                      // Cache for system stats based on cache time
-	connectionManager         *ConnectionManager                                    // Channel to signal connection events
-	handlerRegistry           *HandlerRegistry                                      // Registry for routing incoming messages
-	server                    *ssh.Server                                           // SSH server
-	dataDir                   string                                                // Directory for persisting data
-	keys                      []gossh.PublicKey                                     // SSH public keys
-	smartManager              *SmartManager                                         // Manages SMART data
+	sync.Mutex                                   // Used to lock agent while collecting data
+	debug             bool                       // true if LOG_LEVEL is set to debug
+	zfs               bool                       // true if system has arcstats
+	memCalc           string                     // Memory calculation formula
+	fsNames           []string                   // List of filesystem device names being monitored
+	fsStats           map[string]*system.FsStats // Keeps track of disk stats for each filesystem
+	netInterfaces     map[string]struct{}        // Stores all valid network interfaces
+	netIoStats        system.NetIoStats          // Keeps track of bandwidth usage
+	dockerManager     *dockerManager             // Manages Docker API requests
+	sensorConfig      *SensorConfig              // Sensors config
+	systemInfo        system.Info                // Host system info
+	gpuManager        *GPUManager                // Manages GPU data
+	cache             *SessionCache              // Cache for system stats based on primary session ID
+	connectionManager *ConnectionManager         // Channel to signal connection events
+	server            *ssh.Server                // SSH server
+	dataDir           string                     // Directory for persisting data
+	keys              []gossh.PublicKey          // SSH public keys
 }
 
 // NewAgent creates a new agent with the given data directory for persisting data.
@@ -50,15 +46,9 @@ type Agent struct {
 func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	agent = &Agent{
 		fsStats: make(map[string]*system.FsStats),
-		cache:   NewSystemDataCache(),
+		cache:   NewSessionCache(69 * time.Second),
 	}
 
-	// Initialize disk I/O previous counters storage
-	agent.diskPrev = make(map[uint16]map[string]prevDisk)
-	// Initialize per-cache-time network tracking structures
-	agent.netIoStats = make(map[uint16]system.NetIoStats)
-	agent.netInterfaceDeltaTrackers = make(map[uint16]*deltatracker.DeltaTracker[string, uint64])
-
 	agent.dataDir, err = getDataDir(dataDir...)
 	if err != nil {
 		slog.Warn("Data directory not found")
@@ -89,9 +79,6 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	// initialize connection manager
 	agent.connectionManager = newConnectionManager(agent)
 
-	// initialize handler registry
-	agent.handlerRegistry = NewHandlerRegistry()
-
 	// initialize disk info
 	agent.initializeDiskInfo()
 
@@ -101,20 +88,16 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	// initialize docker manager
 	agent.dockerManager = newDockerManager(agent)
 
-	agent.smartManager, err = NewSmartManager()
-	if err != nil {
-		slog.Debug("SMART", "err", err)
-	}
-
 	// initialize GPU manager
-	agent.gpuManager, err = NewGPUManager()
-	if err != nil {
+	if gm, err := NewGPUManager(); err != nil {
 		slog.Debug("GPU", "err", err)
+	} else {
+		agent.gpuManager = gm
 	}
 
 	// if debugging, print stats
 	if agent.debug {
-		slog.Debug("Stats", "data", agent.gatherStats(0))
+		slog.Debug("Stats", "data", agent.gatherStats(""))
 	}
 
 	return agent, nil
@@ -129,24 +112,24 @@ func GetEnv(key string) (value string, exists bool) {
 	return os.LookupEnv(key)
 }
 
-func (a *Agent) gatherStats(cacheTimeMs uint16) *system.CombinedData {
+func (a *Agent) gatherStats(sessionID string) *system.CombinedData {
 	a.Lock()
 	defer a.Unlock()
 
-	data, isCached := a.cache.Get(cacheTimeMs)
+	data, isCached := a.cache.Get(sessionID)
 	if isCached {
-		slog.Debug("Cached data", "cacheTimeMs", cacheTimeMs)
+		slog.Debug("Cached data", "session", sessionID)
 		return data
 	}
 
 	*data = system.CombinedData{
-		Stats: a.getSystemStats(cacheTimeMs),
+		Stats: a.getSystemStats(),
 		Info:  a.systemInfo,
 	}
-	// slog.Info("System data", "data", data, "cacheTimeMs", cacheTimeMs)
+	slog.Debug("System data", "data", data)
 
 	if a.dockerManager != nil {
-		if containerStats, err := a.dockerManager.getDockerStats(cacheTimeMs); err == nil {
+		if containerStats, err := a.dockerManager.getDockerStats(); err == nil {
 			data.Containers = containerStats
 			slog.Debug("Containers", "data", data.Containers)
 		} else {
@@ -157,17 +140,12 @@ func (a *Agent) gatherStats(cacheTimeMs uint16) *system.CombinedData {
 	data.Stats.ExtraFs = make(map[string]*system.FsStats)
 	for name, stats := range a.fsStats {
 		if !stats.Root && stats.DiskTotal > 0 {
-			// Use custom name if available, otherwise use device name
-			key := name
-			if stats.Name != "" {
-				key = stats.Name
-			}
-			data.Stats.ExtraFs[key] = stats
+			data.Stats.ExtraFs[name] = stats
 		}
 	}
 	slog.Debug("Extra FS", "data", data.Stats.ExtraFs)
 
-	a.cache.Set(data, cacheTimeMs)
+	a.cache.Set(sessionID, data)
 	return data
 }
 

agent/agent_cache.go

@@ -1,55 +1,37 @@
 package agent
 
 import (
-	"sync"
 	"time"
 
 	"github.com/henrygd/beszel/internal/entities/system"
 )
 
-type systemDataCache struct {
-	sync.RWMutex
-	cache map[uint16]*cacheNode
+// Not thread safe since we only access from gatherStats which is already locked
+type SessionCache struct {
+	data           *system.CombinedData
+	lastUpdate     time.Time
+	primarySession string
+	leaseTime      time.Duration
 }
 
-type cacheNode struct {
-	data       *system.CombinedData
-	lastUpdate time.Time
-}
-
-// NewSystemDataCache creates a cache keyed by the polling interval in milliseconds.
-func NewSystemDataCache() *systemDataCache {
-	return &systemDataCache{
-		cache: make(map[uint16]*cacheNode),
+func NewSessionCache(leaseTime time.Duration) *SessionCache {
+	return &SessionCache{
+		leaseTime: leaseTime,
+		data:      &system.CombinedData{},
 	}
 }
 
-// Get returns cached combined data when the entry is still considered fresh.
-func (c *systemDataCache) Get(cacheTimeMs uint16) (stats *system.CombinedData, isCached bool) {
-	c.RLock()
-	defer c.RUnlock()
-
-	node, ok := c.cache[cacheTimeMs]
-	if !ok {
-		return &system.CombinedData{}, false
+func (c *SessionCache) Get(sessionID string) (stats *system.CombinedData, isCached bool) {
+	if sessionID != c.primarySession && time.Since(c.lastUpdate) < c.leaseTime {
+		return c.data, true
 	}
-	// allowedSkew := time.Second
-	// isFresh := time.Since(node.lastUpdate) < time.Duration(cacheTimeMs)*time.Millisecond-allowedSkew
-	// allow a 50% skew of the cache time
-	isFresh := time.Since(node.lastUpdate) < time.Duration(cacheTimeMs/2)*time.Millisecond
-	return node.data, isFresh
+	return c.data, false
 }
 
-// Set stores the latest combined data snapshot for the given interval.
-func (c *systemDataCache) Set(data *system.CombinedData, cacheTimeMs uint16) {
-	c.Lock()
-	defer c.Unlock()
-
-	node, ok := c.cache[cacheTimeMs]
-	if !ok {
-		node = &cacheNode{}
-		c.cache[cacheTimeMs] = node
+func (c *SessionCache) Set(sessionID string, data *system.CombinedData) {
+	if data != nil {
+		*c.data = *data
 	}
-	node.data = data
-	node.lastUpdate = time.Now()
+	c.primarySession = sessionID
+	c.lastUpdate = time.Now()
 }

agent/agent_cache_test.go

@@ -8,239 +8,82 @@ import (
 	"testing/synctest"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/container"
 	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func createTestCacheData() *system.CombinedData {
-	return &system.CombinedData{
-		Stats: system.Stats{
-			Cpu:       50.5,
-			Mem:       8192,
-			DiskTotal: 100000,
-		},
-		Info: system.Info{
-			Hostname: "test-host",
-		},
-		Containers: []*container.Stats{
-			{
-				Name: "test-container",
-				Cpu:  25.0,
-			},
-		},
-	}
-}
-
-func TestNewSystemDataCache(t *testing.T) {
-	cache := NewSystemDataCache()
-	require.NotNil(t, cache)
-	assert.NotNil(t, cache.cache)
-	assert.Empty(t, cache.cache)
-}
-
-func TestCacheGetSet(t *testing.T) {
-	cache := NewSystemDataCache()
-	data := createTestCacheData()
-
-	// Test setting data
-	cache.Set(data, 1000) // 1 second cache
-
-	// Test getting fresh data
-	retrieved, isCached := cache.Get(1000)
-	assert.True(t, isCached)
-	assert.Equal(t, data, retrieved)
-
-	// Test getting non-existent cache key
-	_, isCached = cache.Get(2000)
-	assert.False(t, isCached)
-}
-
-func TestCacheFreshness(t *testing.T) {
-	cache := NewSystemDataCache()
-	data := createTestCacheData()
-
-	testCases := []struct {
-		name        string
-		cacheTimeMs uint16
-		sleepMs     time.Duration
-		expectFresh bool
-	}{
-		{
-			name:        "fresh data - well within cache time",
-			cacheTimeMs: 1000, // 1 second
-			sleepMs:     100,  // 100ms
-			expectFresh: true,
-		},
-		{
-			name:        "fresh data - at 50% of cache time boundary",
-			cacheTimeMs: 1000, // 1 second, 50% = 500ms
-			sleepMs:     499,  // just under 500ms
-			expectFresh: true,
-		},
-		{
-			name:        "stale data - exactly at 50% cache time",
-			cacheTimeMs: 1000, // 1 second, 50% = 500ms
-			sleepMs:     500,  // exactly 500ms
-			expectFresh: false,
-		},
-		{
-			name:        "stale data - well beyond cache time",
-			cacheTimeMs: 1000, // 1 second
-			sleepMs:     800,  // 800ms
-			expectFresh: false,
-		},
-		{
-			name:        "short cache time",
-			cacheTimeMs: 200, // 200ms, 50% = 100ms
-			sleepMs:     150, // 150ms > 100ms
-			expectFresh: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			synctest.Test(t, func(t *testing.T) {
-				// Set data
-				cache.Set(data, tc.cacheTimeMs)
-
-				// Wait for the specified duration
-				if tc.sleepMs > 0 {
-					time.Sleep(tc.sleepMs * time.Millisecond)
-				}
-
-				// Check freshness
-				_, isCached := cache.Get(tc.cacheTimeMs)
-				assert.Equal(t, tc.expectFresh, isCached)
-			})
-		})
-	}
-}
-
-func TestCacheMultipleIntervals(t *testing.T) {
+func TestSessionCache_GetSet(t *testing.T) {
 	synctest.Test(t, func(t *testing.T) {
-		cache := NewSystemDataCache()
-		data1 := createTestCacheData()
-		data2 := &system.CombinedData{
-			Stats: system.Stats{
-				Cpu: 75.0,
-				Mem: 16384,
-			},
+		cache := NewSessionCache(69 * time.Second)
+
+		testData := &system.CombinedData{
 			Info: system.Info{
-				Hostname: "test-host-2",
+				Hostname: "test-host",
+				Cores:    4,
+			},
+			Stats: system.Stats{
+				Cpu:     50.0,
+				MemPct:  30.0,
+				DiskPct: 40.0,
 			},
-			Containers: []*container.Stats{},
 		}
 
-		// Set data for different intervals
-		cache.Set(data1, 500)  // 500ms cache
-		cache.Set(data2, 1000) // 1000ms cache
+		// Test initial state - should not be cached
+		data, isCached := cache.Get("session1")
+		assert.False(t, isCached, "Expected no cached data initially")
+		assert.NotNil(t, data, "Expected data to be initialized")
+		// Set data for session1
+		cache.Set("session1", testData)
 
-		// Both should be fresh immediately
-		retrieved1, isCached1 := cache.Get(500)
-		assert.True(t, isCached1)
-		assert.Equal(t, data1, retrieved1)
+		time.Sleep(15 * time.Second)
 
-		retrieved2, isCached2 := cache.Get(1000)
-		assert.True(t, isCached2)
-		assert.Equal(t, data2, retrieved2)
+		// Get data for a different session - should be cached
+		data, isCached = cache.Get("session2")
+		assert.True(t, isCached, "Expected data to be cached for non-primary session")
+		require.NotNil(t, data, "Expected cached data to be returned")
+		assert.Equal(t, "test-host", data.Info.Hostname, "Hostname should match test data")
+		assert.Equal(t, 4, data.Info.Cores, "Cores should match test data")
+		assert.Equal(t, 50.0, data.Stats.Cpu, "CPU should match test data")
+		assert.Equal(t, 30.0, data.Stats.MemPct, "Memory percentage should match test data")
+		assert.Equal(t, 40.0, data.Stats.DiskPct, "Disk percentage should match test data")
 
-		// Wait 300ms - 500ms cache should be stale (250ms threshold), 1000ms should still be fresh (500ms threshold)
-		time.Sleep(300 * time.Millisecond)
+		time.Sleep(10 * time.Second)
 
-		_, isCached1 = cache.Get(500)
-		assert.False(t, isCached1)
+		// Get data for the primary session - should not be cached
+		data, isCached = cache.Get("session1")
+		assert.False(t, isCached, "Expected data not to be cached for primary session")
+		require.NotNil(t, data, "Expected data to be returned even if not cached")
+		assert.Equal(t, "test-host", data.Info.Hostname, "Hostname should match test data")
+		// if not cached, agent will update the data
+		cache.Set("session1", testData)
 
-		_, isCached2 = cache.Get(1000)
-		assert.True(t, isCached2)
+		time.Sleep(45 * time.Second)
 
-		// Wait another 300ms (total 600ms) - now 1000ms cache should also be stale
-		time.Sleep(300 * time.Millisecond)
-		_, isCached2 = cache.Get(1000)
-		assert.False(t, isCached2)
+		// Get data for a different session - should still be cached
+		_, isCached = cache.Get("session2")
+		assert.True(t, isCached, "Expected data to be cached for non-primary session")
+
+		// Wait for the lease to expire
+		time.Sleep(30 * time.Second)
+
+		// Get data for session2 - should not be cached
+		_, isCached = cache.Get("session2")
+		assert.False(t, isCached, "Expected data not to be cached after lease expiration")
 	})
 }
 
-func TestCacheOverwrite(t *testing.T) {
-	cache := NewSystemDataCache()
-	data1 := createTestCacheData()
-	data2 := &system.CombinedData{
-		Stats: system.Stats{
-			Cpu: 90.0,
-			Mem: 32768,
-		},
-		Info: system.Info{
-			Hostname: "updated-host",
-		},
-		Containers: []*container.Stats{},
-	}
+func TestSessionCache_NilData(t *testing.T) {
+	// Create a new SessionCache
+	cache := NewSessionCache(30 * time.Second)
 
-	// Set initial data
-	cache.Set(data1, 1000)
-	retrieved, isCached := cache.Get(1000)
-	assert.True(t, isCached)
-	assert.Equal(t, data1, retrieved)
+	// Test setting nil data (should not panic)
+	assert.NotPanics(t, func() {
+		cache.Set("session1", nil)
+	}, "Setting nil data should not panic")
 
-	// Overwrite with new data
-	cache.Set(data2, 1000)
-	retrieved, isCached = cache.Get(1000)
-	assert.True(t, isCached)
-	assert.Equal(t, data2, retrieved)
-	assert.NotEqual(t, data1, retrieved)
-}
-
-func TestCacheMiss(t *testing.T) {
-	synctest.Test(t, func(t *testing.T) {
-		cache := NewSystemDataCache()
-
-		// Test getting from empty cache
-		_, isCached := cache.Get(1000)
-		assert.False(t, isCached)
-
-		// Set data for one interval
-		data := createTestCacheData()
-		cache.Set(data, 1000)
-
-		// Test getting different interval
-		_, isCached = cache.Get(2000)
-		assert.False(t, isCached)
-
-		// Test getting after data has expired
-		time.Sleep(600 * time.Millisecond) // 600ms > 500ms (50% of 1000ms)
-		_, isCached = cache.Get(1000)
-		assert.False(t, isCached)
-	})
-}
-
-func TestCacheZeroInterval(t *testing.T) {
-	cache := NewSystemDataCache()
-	data := createTestCacheData()
-
-	// Set with zero interval - should allow immediate cache
-	cache.Set(data, 0)
-
-	// With 0 interval, 50% is 0, so it should never be considered fresh
-	// (time.Since(lastUpdate) >= 0, which is not < 0)
-	_, isCached := cache.Get(0)
-	assert.False(t, isCached)
-}
-
-func TestCacheLargeInterval(t *testing.T) {
-	synctest.Test(t, func(t *testing.T) {
-		cache := NewSystemDataCache()
-		data := createTestCacheData()
-
-		// Test with maximum uint16 value
-		cache.Set(data, 65535) // ~65 seconds
-
-		// Should be fresh immediately
-		_, isCached := cache.Get(65535)
-		assert.True(t, isCached)
-
-		// Should still be fresh after a short time
-		time.Sleep(100 * time.Millisecond)
-		_, isCached = cache.Get(65535)
-		assert.True(t, isCached)
-	})
+	// Get data - should not be nil even though we set nil
+	data, _ := cache.Get("session2")
+	assert.NotNil(t, data, "Expected data to not be nil after setting nil data")
 }

agent/battery/battery.go

@@ -5,8 +5,6 @@ package battery
 
 import (
 	"errors"
-	"fmt"
-	"os"
 	"log/slog"
 
 	"github.com/distatus/battery"
@@ -21,60 +19,33 @@ func HasReadableBattery() bool {
 		return systemHasBattery
 	}
 	haveCheckedBattery = true
-	batteries,err := battery.GetAll()
-	if err != nil {
-		// even if there's errors getting some batteries, the system
-		// definitely has a battery if the list is not empty.
-		// This list will include everything `battery` can find,
-		// including things like bluetooth devices.
-		fmt.Fprintln(os.Stderr, err)
-	}
-	systemHasBattery = len(batteries) > 0
+	bat, err := battery.Get(0)
+	systemHasBattery = err == nil && bat != nil && bat.Design != 0 && bat.Full != 0
 	if !systemHasBattery {
 		slog.Debug("No battery found", "err", err)
 	}
 	return systemHasBattery
 }
 
-// GetBatteryStats returns the current battery percent and charge state 
-// percent = (current charge of all batteries) / (sum of designed/full capacity of all batteries)
+// GetBatteryStats returns the current battery percent and charge state
 func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
-	if !HasReadableBattery() {
+	if !systemHasBattery {
 		return batteryPercent, batteryState, errors.ErrUnsupported
 	}
 	batteries, err := battery.GetAll()
-	// we'll handle errors later by skipping batteries with errors, rather
-	// than skipping everything because of the presence of some errors.
-	if len(batteries) == 0 {
-		return batteryPercent, batteryState, errors.New("no batteries")
+	if err != nil || len(batteries) == 0 {
+		return batteryPercent, batteryState, err
 	}
-
 	totalCapacity := float64(0)
 	totalCharge := float64(0)
-	errs, partialErrs := err.(battery.Errors)
-
-	for i, bat := range batteries {
-		if partialErrs && errs[i] != nil {
-			// if there were some errors, like missing data, skip it
-			continue
+	for _, bat := range batteries {
+		if bat.Design != 0 {
+			totalCapacity += bat.Design
+		} else {
+			totalCapacity += bat.Full
 		}
-		if bat.Full == 0  {
-			// skip batteries with no capacity. Charge is unlikely to ever be zero, but
-			// we can't guarantee that, so don't skip based on charge.
-			continue
-		}
-		totalCapacity += bat.Full
 		totalCharge += bat.Current
 	}
-
-	if totalCapacity == 0 {
-		// for macs there's sometimes a ghost battery with 0 capacity
-		// https://github.com/distatus/battery/issues/34
-		// Instead of skipping over those batteries, we'll check for total 0 capacity
-		// and return an error. This also prevents a divide by zero.
-		return batteryPercent, batteryState, errors.New("no battery capacity")
-	}
-
 	batteryPercent = uint8(totalCharge / totalCapacity * 100)
 	batteryState = uint8(batteries[0].State.Raw)
 	return batteryPercent, batteryState, nil

agent/client.go

@@ -15,8 +15,6 @@ import (
 
 	"github.com/henrygd/beszel"
 	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/smart"
-	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/fxamacker/cbor/v2"
 	"github.com/lxzan/gws"
@@ -144,9 +142,7 @@ func (client *WebSocketClient) OnOpen(conn *gws.Conn) {
 // OnClose handles WebSocket connection closure.
 // It logs the closure reason and notifies the connection manager.
 func (client *WebSocketClient) OnClose(conn *gws.Conn, err error) {
-	if err != nil {
-		slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
-	}
+	slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
 	client.agent.connectionManager.eventChan <- WebSocketDisconnect
 }
 
@@ -160,15 +156,11 @@ func (client *WebSocketClient) OnMessage(conn *gws.Conn, message *gws.Message) {
 		return
 	}
 
-	var HubRequest common.HubRequest[cbor.RawMessage]
-
-	err := cbor.Unmarshal(message.Data.Bytes(), &HubRequest)
-	if err != nil {
+	if err := cbor.NewDecoder(message.Data).Decode(client.hubRequest); err != nil {
 		slog.Error("Error parsing message", "err", err)
 		return
 	}
-
-	if err := client.handleHubRequest(&HubRequest, HubRequest.Id); err != nil {
+	if err := client.handleHubRequest(client.hubRequest); err != nil {
 		slog.Error("Error handling message", "err", err)
 	}
 }
@@ -181,7 +173,7 @@ func (client *WebSocketClient) OnPing(conn *gws.Conn, message []byte) {
 }
 
 // handleAuthChallenge verifies the authenticity of the hub and returns the system's fingerprint.
-func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) (err error) {
+func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.RawMessage]) (err error) {
 	var authRequest common.FingerprintRequest
 	if err := cbor.Unmarshal(msg.Data, &authRequest); err != nil {
 		return err
@@ -199,13 +191,12 @@ func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.R
 	}
 
 	if authRequest.NeedSysInfo {
-		response.Name, _ = GetEnv("SYSTEM_NAME")
 		response.Hostname = client.agent.systemInfo.Hostname
 		serverAddr := client.agent.connectionManager.serverOptions.Addr
 		_, response.Port, _ = net.SplitHostPort(serverAddr)
 	}
 
-	return client.sendResponse(response, requestID)
+	return client.sendMessage(response)
 }
 
 // verifySignature verifies the signature of the token using the public keys.
@@ -230,17 +221,25 @@ func (client *WebSocketClient) Close() {
 	}
 }
 
-// handleHubRequest routes the request to the appropriate handler using the handler registry.
-func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) error {
-	ctx := &HandlerContext{
-		Client:       client,
-		Agent:        client.agent,
-		Request:      msg,
-		RequestID:    requestID,
-		HubVerified:  client.hubVerified,
-		SendResponse: client.sendResponse,
+// handleHubRequest routes the request to the appropriate handler.
+// It ensures the hub is verified before processing most requests.
+func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage]) error {
+	if !client.hubVerified && msg.Action != common.CheckFingerprint {
+		return errors.New("hub not verified")
 	}
-	return client.agent.handlerRegistry.Handle(ctx)
+	switch msg.Action {
+	case common.GetData:
+		return client.sendSystemData()
+	case common.CheckFingerprint:
+		return client.handleAuthChallenge(msg)
+	}
+	return nil
+}
+
+// sendSystemData gathers and sends current system statistics to the hub.
+func (client *WebSocketClient) sendSystemData() error {
+	sysStats := client.agent.gatherStats(client.token)
+	return client.sendMessage(sysStats)
 }
 
 // sendMessage encodes the given data to CBOR and sends it as a binary message over the WebSocket connection to the hub.
@@ -249,47 +248,7 @@ func (client *WebSocketClient) sendMessage(data any) error {
 	if err != nil {
 		return err
 	}
-	err = client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
-	if err != nil {
-		// If writing fails (e.g., broken pipe due to network issues),
-		// close the connection to trigger reconnection logic (#1263)
-		client.Close()
-	}
-	return err
-}
-
-// sendResponse sends a response with optional request ID for the new protocol
-func (client *WebSocketClient) sendResponse(data any, requestID *uint32) error {
-	if requestID != nil {
-		// New format with ID - use typed fields
-		response := common.AgentResponse{
-			Id: requestID,
-		}
-
-		// Set the appropriate typed field based on data type
-		switch v := data.(type) {
-		case *system.CombinedData:
-			response.SystemData = v
-		case *common.FingerprintResponse:
-			response.Fingerprint = v
-		case string:
-			response.String = &v
-		case map[string]smart.SmartData:
-			response.SmartData = v
-		// case []byte:
-		// 	response.RawBytes = v
-		// case string:
-		// 	response.RawBytes = []byte(v)
-		default:
-			// For any other type, convert to error
-			response.Error = fmt.Sprintf("unsupported response type: %T", data)
-		}
-
-		return client.sendMessage(response)
-	} else {
-		// Legacy format - send data directly
-		return client.sendMessage(data)
-	}
+	return client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
 }
 
 // getUserAgent returns one of two User-Agent strings based on current time.

agent/client_test.go

@@ -301,7 +301,7 @@ func TestWebSocketClient_HandleHubRequest(t *testing.T) {
 				Data:   cbor.RawMessage{},
 			}
 
-			err := client.handleHubRequest(hubRequest, nil)
+			err := client.handleHubRequest(hubRequest)
 
 			if tc.expectError {
 				assert.Error(t, err)

agent/cpu.go

@@ -1,66 +0,0 @@
-package agent
-
-import (
-	"math"
-	"runtime"
-
-	"github.com/shirou/gopsutil/v4/cpu"
-)
-
-var lastCpuTimes = make(map[uint16]cpu.TimesStat)
-
-// init initializes the CPU monitoring by storing the initial CPU times
-// for the default 60-second cache interval.
-func init() {
-	if times, err := cpu.Times(false); err == nil {
-		lastCpuTimes[60000] = times[0]
-	}
-}
-
-// getCpuPercent calculates the CPU usage percentage using cached previous measurements.
-// It uses the specified cache time interval to determine the time window for calculation.
-// Returns the CPU usage percentage (0-100) and any error encountered.
-func getCpuPercent(cacheTimeMs uint16) (float64, error) {
-	times, err := cpu.Times(false)
-	if err != nil || len(times) == 0 {
-		return 0, err
-	}
-	// if cacheTimeMs is not in lastCpuTimes, use 60000 as fallback lastCpuTime
-	if _, ok := lastCpuTimes[cacheTimeMs]; !ok {
-		lastCpuTimes[cacheTimeMs] = lastCpuTimes[60000]
-	}
-	delta := calculateBusy(lastCpuTimes[cacheTimeMs], times[0])
-	lastCpuTimes[cacheTimeMs] = times[0]
-	return delta, nil
-}
-
-// calculateBusy calculates the CPU busy percentage between two time points.
-// It computes the ratio of busy time to total time elapsed between t1 and t2,
-// returning a percentage clamped between 0 and 100.
-func calculateBusy(t1, t2 cpu.TimesStat) float64 {
-	t1All, t1Busy := getAllBusy(t1)
-	t2All, t2Busy := getAllBusy(t2)
-
-	if t2Busy <= t1Busy {
-		return 0
-	}
-	if t2All <= t1All {
-		return 100
-	}
-	return math.Min(100, math.Max(0, (t2Busy-t1Busy)/(t2All-t1All)*100))
-}
-
-// getAllBusy calculates the total CPU time and busy CPU time from CPU times statistics.
-// On Linux, it excludes guest and guest_nice time from the total to match kernel behavior.
-// Returns total CPU time and busy CPU time (total minus idle and I/O wait time).
-func getAllBusy(t cpu.TimesStat) (float64, float64) {
-	tot := t.Total()
-	if runtime.GOOS == "linux" {
-		tot -= t.Guest     // Linux 2.6.24+
-		tot -= t.GuestNice // Linux 3.2.0+
-	}
-
-	busy := tot - t.Idle - t.Iowait
-
-	return tot, busy
-}

agent/deltatracker/deltatracker.go

@@ -37,16 +37,6 @@ func (t *DeltaTracker[K, V]) Set(id K, value V) {
 	t.current[id] = value
 }
 
-// Snapshot returns a copy of the current map.
-// func (t *DeltaTracker[K, V]) Snapshot() map[K]V {
-// 	t.RLock()
-// 	defer t.RUnlock()
-
-// 	copyMap := make(map[K]V, len(t.current))
-// 	maps.Copy(copyMap, t.current)
-// 	return copyMap
-// }
-
 // Deltas returns a map of all calculated deltas for the current interval.
 func (t *DeltaTracker[K, V]) Deltas() map[K]V {
 	t.RLock()
@@ -63,15 +53,6 @@ func (t *DeltaTracker[K, V]) Deltas() map[K]V {
 	return deltas
 }
 
-// Previous returns the previously recorded value for the given key, if it exists.
-func (t *DeltaTracker[K, V]) Previous(id K) (V, bool) {
-	t.RLock()
-	defer t.RUnlock()
-
-	value, ok := t.previous[id]
-	return value, ok
-}
-
 // Delta returns the delta for a single key.
 // Returns 0 if the key doesn't exist or has no previous value.
 func (t *DeltaTracker[K, V]) Delta(id K) V {

agent/disk.go

@@ -13,19 +13,6 @@ import (
 	"github.com/shirou/gopsutil/v4/disk"
 )
 
-// parseFilesystemEntry parses a filesystem entry in the format "device__customname"
-// Returns the device/filesystem part and the custom name part
-func parseFilesystemEntry(entry string) (device, customName string) {
-	entry = strings.TrimSpace(entry)
-	if parts := strings.SplitN(entry, "__", 2); len(parts) == 2 {
-		device = strings.TrimSpace(parts[0])
-		customName = strings.TrimSpace(parts[1])
-	} else {
-		device = entry
-	}
-	return device, customName
-}
-
 // Sets up the filesystems to monitor for disk usage and I/O.
 func (a *Agent) initializeDiskInfo() {
 	filesystem, _ := GetEnv("FILESYSTEM")
@@ -50,7 +37,7 @@ func (a *Agent) initializeDiskInfo() {
 	slog.Debug("Disk I/O", "diskstats", diskIoCounters)
 
 	// Helper function to add a filesystem to fsStats if it doesn't exist
-	addFsStat := func(device, mountpoint string, root bool, customName ...string) {
+	addFsStat := func(device, mountpoint string, root bool) {
 		var key string
 		if runtime.GOOS == "windows" {
 			key = device
@@ -79,11 +66,7 @@ func (a *Agent) initializeDiskInfo() {
 					}
 				}
 			}
-			fsStats := &system.FsStats{Root: root, Mountpoint: mountpoint}
-			if len(customName) > 0 && customName[0] != "" {
-				fsStats.Name = customName[0]
-			}
-			a.fsStats[key] = fsStats
+			a.fsStats[key] = &system.FsStats{Root: root, Mountpoint: mountpoint}
 		}
 	}
 
@@ -103,14 +86,11 @@ func (a *Agent) initializeDiskInfo() {
 
 	// Add EXTRA_FILESYSTEMS env var values to fsStats
 	if extraFilesystems, exists := GetEnv("EXTRA_FILESYSTEMS"); exists {
-		for _, fsEntry := range strings.Split(extraFilesystems, ",") {
-			// Parse custom name from format: device__customname
-			fs, customName := parseFilesystemEntry(fsEntry)
-
+		for _, fs := range strings.Split(extraFilesystems, ",") {
 			found := false
 			for _, p := range partitions {
 				if strings.HasSuffix(p.Device, fs) || p.Mountpoint == fs {
-					addFsStat(p.Device, p.Mountpoint, false, customName)
+					addFsStat(p.Device, p.Mountpoint, false)
 					found = true
 					break
 				}
@@ -118,7 +98,7 @@ func (a *Agent) initializeDiskInfo() {
 			// if not in partitions, test if we can get disk usage
 			if !found {
 				if _, err := disk.Usage(fs); err == nil {
-					addFsStat(filepath.Base(fs), fs, false, customName)
+					addFsStat(filepath.Base(fs), fs, false)
 				} else {
 					slog.Error("Invalid filesystem", "name", fs, "err", err)
 				}
@@ -140,8 +120,7 @@ func (a *Agent) initializeDiskInfo() {
 
 		// Check if device is in /extra-filesystems
 		if strings.HasPrefix(p.Mountpoint, efPath) {
-			device, customName := parseFilesystemEntry(p.Mountpoint)
-			addFsStat(device, p.Mountpoint, false, customName)
+			addFsStat(p.Device, p.Mountpoint, false)
 		}
 	}
 
@@ -156,8 +135,7 @@ func (a *Agent) initializeDiskInfo() {
 				mountpoint := filepath.Join(efPath, folder.Name())
 				slog.Debug("/extra-filesystems", "mountpoint", mountpoint)
 				if !existingMountpoints[mountpoint] {
-					device, customName := parseFilesystemEntry(folder.Name())
-					addFsStat(device, mountpoint, false, customName)
+					addFsStat(folder.Name(), mountpoint, false)
 				}
 			}
 		}
@@ -211,96 +189,3 @@ func (a *Agent) initializeDiskIoStats(diskIoCounters map[string]disk.IOCountersS
 		a.fsNames = append(a.fsNames, device)
 	}
 }
-
-// Updates disk usage statistics for all monitored filesystems
-func (a *Agent) updateDiskUsage(systemStats *system.Stats) {
-	// disk usage
-	for _, stats := range a.fsStats {
-		if d, err := disk.Usage(stats.Mountpoint); err == nil {
-			stats.DiskTotal = bytesToGigabytes(d.Total)
-			stats.DiskUsed = bytesToGigabytes(d.Used)
-			if stats.Root {
-				systemStats.DiskTotal = bytesToGigabytes(d.Total)
-				systemStats.DiskUsed = bytesToGigabytes(d.Used)
-				systemStats.DiskPct = twoDecimals(d.UsedPercent)
-			}
-		} else {
-			// reset stats if error (likely unmounted)
-			slog.Error("Error getting disk stats", "name", stats.Mountpoint, "err", err)
-			stats.DiskTotal = 0
-			stats.DiskUsed = 0
-			stats.TotalRead = 0
-			stats.TotalWrite = 0
-		}
-	}
-}
-
-// Updates disk I/O statistics for all monitored filesystems
-func (a *Agent) updateDiskIo(cacheTimeMs uint16, systemStats *system.Stats) {
-	// disk i/o (cache-aware per interval)
-	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
-		// Ensure map for this interval exists
-		if _, ok := a.diskPrev[cacheTimeMs]; !ok {
-			a.diskPrev[cacheTimeMs] = make(map[string]prevDisk)
-		}
-		now := time.Now()
-		for name, d := range ioCounters {
-			stats := a.fsStats[d.Name]
-			if stats == nil {
-				// skip devices not tracked
-				continue
-			}
-
-			// Previous snapshot for this interval and device
-			prev, hasPrev := a.diskPrev[cacheTimeMs][name]
-			if !hasPrev {
-				// Seed from agent-level fsStats if present, else seed from current
-				prev = prevDisk{readBytes: stats.TotalRead, writeBytes: stats.TotalWrite, at: stats.Time}
-				if prev.at.IsZero() {
-					prev = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
-				}
-			}
-
-			msElapsed := uint64(now.Sub(prev.at).Milliseconds())
-			if msElapsed < 100 {
-				// Avoid division by zero or clock issues; update snapshot and continue
-				a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
-				continue
-			}
-
-			diskIORead := (d.ReadBytes - prev.readBytes) * 1000 / msElapsed
-			diskIOWrite := (d.WriteBytes - prev.writeBytes) * 1000 / msElapsed
-			readMbPerSecond := bytesToMegabytes(float64(diskIORead))
-			writeMbPerSecond := bytesToMegabytes(float64(diskIOWrite))
-
-			// validate values
-			if readMbPerSecond > 50_000 || writeMbPerSecond > 50_000 {
-				slog.Warn("Invalid disk I/O. Resetting.", "name", d.Name, "read", readMbPerSecond, "write", writeMbPerSecond)
-				// Reset interval snapshot and seed from current
-				a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
-				// also refresh agent baseline to avoid future negatives
-				a.initializeDiskIoStats(ioCounters)
-				continue
-			}
-
-			// Update per-interval snapshot
-			a.diskPrev[cacheTimeMs][name] = prevDisk{readBytes: d.ReadBytes, writeBytes: d.WriteBytes, at: now}
-
-			// Update global fsStats baseline for cross-interval correctness
-			stats.Time = now
-			stats.TotalRead = d.ReadBytes
-			stats.TotalWrite = d.WriteBytes
-			stats.DiskReadPs = readMbPerSecond
-			stats.DiskWritePs = writeMbPerSecond
-			stats.DiskReadBytes = diskIORead
-			stats.DiskWriteBytes = diskIOWrite
-
-			if stats.Root {
-				systemStats.DiskReadPs = stats.DiskReadPs
-				systemStats.DiskWritePs = stats.DiskWritePs
-				systemStats.DiskIO[0] = diskIORead
-				systemStats.DiskIO[1] = diskIOWrite
-			}
-		}
-	}
-}

agent/disk_test.go

@@ -1,235 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/shirou/gopsutil/v4/disk"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestParseFilesystemEntry(t *testing.T) {
-	tests := []struct {
-		name         string
-		input        string
-		expectedFs   string
-		expectedName string
-	}{
-		{
-			name:         "simple device name",
-			input:        "sda1",
-			expectedFs:   "sda1",
-			expectedName: "",
-		},
-		{
-			name:         "device with custom name",
-			input:        "sda1__my-storage",
-			expectedFs:   "sda1",
-			expectedName: "my-storage",
-		},
-		{
-			name:         "full device path with custom name",
-			input:        "/dev/sdb1__backup-drive",
-			expectedFs:   "/dev/sdb1",
-			expectedName: "backup-drive",
-		},
-		{
-			name:         "NVMe device with custom name",
-			input:        "nvme0n1p2__fast-ssd",
-			expectedFs:   "nvme0n1p2",
-			expectedName: "fast-ssd",
-		},
-		{
-			name:         "whitespace trimmed",
-			input:        "  sda2__trimmed-name  ",
-			expectedFs:   "sda2",
-			expectedName: "trimmed-name",
-		},
-		{
-			name:         "empty custom name",
-			input:        "sda3__",
-			expectedFs:   "sda3",
-			expectedName: "",
-		},
-		{
-			name:         "empty device name",
-			input:        "__just-custom",
-			expectedFs:   "",
-			expectedName: "just-custom",
-		},
-		{
-			name:         "multiple underscores in custom name",
-			input:        "sda1__my_custom_drive",
-			expectedFs:   "sda1",
-			expectedName: "my_custom_drive",
-		},
-		{
-			name:         "custom name with spaces",
-			input:        "sda1__My Storage Drive",
-			expectedFs:   "sda1",
-			expectedName: "My Storage Drive",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			fsEntry := strings.TrimSpace(tt.input)
-			var fs, customName string
-			if parts := strings.SplitN(fsEntry, "__", 2); len(parts) == 2 {
-				fs = strings.TrimSpace(parts[0])
-				customName = strings.TrimSpace(parts[1])
-			} else {
-				fs = fsEntry
-			}
-
-			assert.Equal(t, tt.expectedFs, fs)
-			assert.Equal(t, tt.expectedName, customName)
-		})
-	}
-}
-
-func TestInitializeDiskInfoWithCustomNames(t *testing.T) {
-	// Set up environment variables
-	oldEnv := os.Getenv("EXTRA_FILESYSTEMS")
-	defer func() {
-		if oldEnv != "" {
-			os.Setenv("EXTRA_FILESYSTEMS", oldEnv)
-		} else {
-			os.Unsetenv("EXTRA_FILESYSTEMS")
-		}
-	}()
-
-	// Test with custom names
-	os.Setenv("EXTRA_FILESYSTEMS", "sda1__my-storage,/dev/sdb1__backup-drive,nvme0n1p2")
-
-	// Mock disk partitions (we'll just test the parsing logic)
-	// Since the actual disk operations are system-dependent, we'll focus on the parsing
-	testCases := []struct {
-		envValue      string
-		expectedFs    []string
-		expectedNames map[string]string
-	}{
-		{
-			envValue:   "sda1__my-storage,sdb1__backup-drive",
-			expectedFs: []string{"sda1", "sdb1"},
-			expectedNames: map[string]string{
-				"sda1": "my-storage",
-				"sdb1": "backup-drive",
-			},
-		},
-		{
-			envValue:   "sda1,nvme0n1p2__fast-ssd",
-			expectedFs: []string{"sda1", "nvme0n1p2"},
-			expectedNames: map[string]string{
-				"nvme0n1p2": "fast-ssd",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run("env_"+tc.envValue, func(t *testing.T) {
-			os.Setenv("EXTRA_FILESYSTEMS", tc.envValue)
-
-			// Create mock partitions that would match our test cases
-			partitions := []disk.PartitionStat{}
-			for _, fs := range tc.expectedFs {
-				if strings.HasPrefix(fs, "/dev/") {
-					partitions = append(partitions, disk.PartitionStat{
-						Device:     fs,
-						Mountpoint: fs,
-					})
-				} else {
-					partitions = append(partitions, disk.PartitionStat{
-						Device:     "/dev/" + fs,
-						Mountpoint: "/" + fs,
-					})
-				}
-			}
-
-			// Test the parsing logic by calling the relevant part
-			// We'll create a simplified version to test just the parsing
-			extraFilesystems := tc.envValue
-			for _, fsEntry := range strings.Split(extraFilesystems, ",") {
-				// Parse the entry
-				fsEntry = strings.TrimSpace(fsEntry)
-				var fs, customName string
-				if parts := strings.SplitN(fsEntry, "__", 2); len(parts) == 2 {
-					fs = strings.TrimSpace(parts[0])
-					customName = strings.TrimSpace(parts[1])
-				} else {
-					fs = fsEntry
-				}
-
-				// Verify the device is in our expected list
-				assert.Contains(t, tc.expectedFs, fs, "parsed device should be in expected list")
-
-				// Check if custom name should exist
-				if expectedName, exists := tc.expectedNames[fs]; exists {
-					assert.Equal(t, expectedName, customName, "custom name should match expected")
-				} else {
-					assert.Empty(t, customName, "custom name should be empty when not expected")
-				}
-			}
-		})
-	}
-}
-
-func TestFsStatsWithCustomNames(t *testing.T) {
-	// Test that FsStats properly stores custom names
-	fsStats := &system.FsStats{
-		Mountpoint: "/mnt/storage",
-		Name:       "my-custom-storage",
-		DiskTotal:  100.0,
-		DiskUsed:   50.0,
-	}
-
-	assert.Equal(t, "my-custom-storage", fsStats.Name)
-	assert.Equal(t, "/mnt/storage", fsStats.Mountpoint)
-	assert.Equal(t, 100.0, fsStats.DiskTotal)
-	assert.Equal(t, 50.0, fsStats.DiskUsed)
-}
-
-func TestExtraFsKeyGeneration(t *testing.T) {
-	// Test the logic for generating ExtraFs keys with custom names
-	testCases := []struct {
-		name        string
-		deviceName  string
-		customName  string
-		expectedKey string
-	}{
-		{
-			name:        "with custom name",
-			deviceName:  "sda1",
-			customName:  "my-storage",
-			expectedKey: "my-storage",
-		},
-		{
-			name:        "without custom name",
-			deviceName:  "sda1",
-			customName:  "",
-			expectedKey: "sda1",
-		},
-		{
-			name:        "empty custom name falls back to device",
-			deviceName:  "nvme0n1p2",
-			customName:  "",
-			expectedKey: "nvme0n1p2",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Simulate the key generation logic from agent.go
-			key := tc.deviceName
-			if tc.customName != "" {
-				key = tc.customName
-			}
-			assert.Equal(t, tc.expectedKey, key)
-		})
-	}
-}

agent/docker.go

@@ -3,11 +3,8 @@ package agent
 import (
 	"bytes"
 	"context"
-	"encoding/binary"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net"
 	"net/http"
@@ -17,29 +14,17 @@ import (
 	"sync"
 	"time"
 
-	"github.com/henrygd/beszel/agent/deltatracker"
 	"github.com/henrygd/beszel/internal/entities/container"
 
 	"github.com/blang/semver"
 )
 
-const (
-	// Docker API timeout in milliseconds
-	dockerTimeoutMs = 2100
-	// Maximum realistic network speed (5 GB/s) to detect bad deltas
-	maxNetworkSpeedBps uint64 = 5e9
-	// Maximum conceivable memory usage of a container (100TB) to detect bad memory stats
-	maxMemoryUsage uint64 = 100 * 1024 * 1024 * 1024 * 1024
-	// Number of log lines to request when fetching container logs
-	dockerLogsTail = 200
-)
-
 type dockerManager struct {
 	client              *http.Client                // Client to query Docker API
 	wg                  sync.WaitGroup              // WaitGroup to wait for all goroutines to finish
 	sem                 chan struct{}               // Semaphore to limit concurrent container requests
 	containerStatsMutex sync.RWMutex                // Mutex to prevent concurrent access to containerStatsMap
-	apiContainerList    []*container.ApiInfo        // List of containers from Docker API
+	apiContainerList    []*container.ApiInfo        // List of containers from Docker API (no pointer)
 	containerStatsMap   map[string]*container.Stats // Keeps track of container stats
 	validIds            map[string]struct{}         // Map of valid container ids, used to prune invalid containers from containerStatsMap
 	goodDockerVersion   bool                        // Whether docker version is at least 25.0.0 (one-shot works correctly)
@@ -47,17 +32,6 @@ type dockerManager struct {
 	buf                 *bytes.Buffer               // Buffer to store and read response bodies
 	decoder             *json.Decoder               // Reusable JSON decoder that reads from buf
 	apiStats            *container.ApiStats         // Reusable API stats object
-
-	// Cache-time-aware tracking for CPU stats (similar to cpu.go)
-	// Maps cache time intervals to container-specific CPU usage tracking
-	lastCpuContainer map[uint16]map[string]uint64    // cacheTimeMs -> containerId -> last cpu container usage
-	lastCpuSystem    map[uint16]map[string]uint64    // cacheTimeMs -> containerId -> last cpu system usage
-	lastCpuReadTime  map[uint16]map[string]time.Time // cacheTimeMs -> containerId -> last read time (Windows)
-
-	// Network delta trackers - one per cache time to avoid interference
-	// cacheTimeMs -> DeltaTracker for network bytes sent/received
-	networkSentTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
-	networkRecvTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
 }
 
 // userAgentRoundTripper is a custom http.RoundTripper that adds a User-Agent header to all requests
@@ -88,8 +62,8 @@ func (d *dockerManager) dequeue() {
 	}
 }
 
-// Returns stats for all running containers with cache-time-aware delta tracking
-func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats, error) {
+// Returns stats for all running containers
+func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 	resp, err := dm.client.Get("http://localhost/containers/json")
 	if err != nil {
 		return nil, err
@@ -113,7 +87,8 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 
 	var failedContainers []*container.ApiInfo
 
-	for _, ctr := range dm.apiContainerList {
+	for i := range dm.apiContainerList {
+		ctr := dm.apiContainerList[i]
 		ctr.IdShort = ctr.Id[:12]
 		dm.validIds[ctr.IdShort] = struct{}{}
 		// check if container is less than 1 minute old (possible restart)
@@ -123,9 +98,9 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 			dm.deleteContainerStatsSync(ctr.IdShort)
 		}
 		dm.queue()
-		go func(ctr *container.ApiInfo) {
+		go func() {
 			defer dm.dequeue()
-			err := dm.updateContainerStats(ctr, cacheTimeMs)
+			err := dm.updateContainerStats(ctr)
 			// if error, delete from map and add to failed list to retry
 			if err != nil {
 				dm.containerStatsMutex.Lock()
@@ -133,7 +108,7 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 				failedContainers = append(failedContainers, ctr)
 				dm.containerStatsMutex.Unlock()
 			}
-		}(ctr)
+		}()
 	}
 
 	dm.wg.Wait()
@@ -144,12 +119,13 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 		for i := range failedContainers {
 			ctr := failedContainers[i]
 			dm.queue()
-			go func(ctr *container.ApiInfo) {
+			go func() {
 				defer dm.dequeue()
-				if err2 := dm.updateContainerStats(ctr, cacheTimeMs); err2 != nil {
-					slog.Error("Error getting container stats", "err", err2)
+				err = dm.updateContainerStats(ctr)
+				if err != nil {
+					slog.Error("Error getting container stats", "err", err)
 				}
-			}(ctr)
+			}()
 		}
 		dm.wg.Wait()
 	}
@@ -164,191 +140,18 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 		}
 	}
 
-	// prepare network trackers for next interval for this cache time
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-
 	return stats, nil
 }
 
-// initializeCpuTracking initializes CPU tracking maps for a specific cache time interval
-func (dm *dockerManager) initializeCpuTracking(cacheTimeMs uint16) {
-	// Initialize cache time maps if they don't exist
-	if dm.lastCpuContainer[cacheTimeMs] == nil {
-		dm.lastCpuContainer[cacheTimeMs] = make(map[string]uint64)
-	}
-	if dm.lastCpuSystem[cacheTimeMs] == nil {
-		dm.lastCpuSystem[cacheTimeMs] = make(map[string]uint64)
-	}
-	// Ensure the outer map exists before indexing
-	if dm.lastCpuReadTime == nil {
-		dm.lastCpuReadTime = make(map[uint16]map[string]time.Time)
-	}
-	if dm.lastCpuReadTime[cacheTimeMs] == nil {
-		dm.lastCpuReadTime[cacheTimeMs] = make(map[string]time.Time)
-	}
-}
-
-// getCpuPreviousValues returns previous CPU values for a container and cache time interval
-func (dm *dockerManager) getCpuPreviousValues(cacheTimeMs uint16, containerId string) (uint64, uint64) {
-	return dm.lastCpuContainer[cacheTimeMs][containerId], dm.lastCpuSystem[cacheTimeMs][containerId]
-}
-
-// setCpuCurrentValues stores current CPU values for a container and cache time interval
-func (dm *dockerManager) setCpuCurrentValues(cacheTimeMs uint16, containerId string, cpuContainer, cpuSystem uint64) {
-	dm.lastCpuContainer[cacheTimeMs][containerId] = cpuContainer
-	dm.lastCpuSystem[cacheTimeMs][containerId] = cpuSystem
-}
-
-// calculateMemoryUsage calculates memory usage from Docker API stats
-func calculateMemoryUsage(apiStats *container.ApiStats, isWindows bool) (uint64, error) {
-	if isWindows {
-		return apiStats.MemoryStats.PrivateWorkingSet, nil
-	}
-
-	memCache := apiStats.MemoryStats.Stats.InactiveFile
-	if memCache == 0 {
-		memCache = apiStats.MemoryStats.Stats.Cache
-	}
-
-	usedDelta := apiStats.MemoryStats.Usage - memCache
-	if usedDelta <= 0 || usedDelta > maxMemoryUsage {
-		return 0, fmt.Errorf("bad memory stats")
-	}
-
-	return usedDelta, nil
-}
-
-// getNetworkTracker returns the DeltaTracker for a specific cache time, creating it if needed
-func (dm *dockerManager) getNetworkTracker(cacheTimeMs uint16, isSent bool) *deltatracker.DeltaTracker[string, uint64] {
-	var trackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
-	if isSent {
-		trackers = dm.networkSentTrackers
-	} else {
-		trackers = dm.networkRecvTrackers
-	}
-
-	if trackers[cacheTimeMs] == nil {
-		trackers[cacheTimeMs] = deltatracker.NewDeltaTracker[string, uint64]()
-	}
-
-	return trackers[cacheTimeMs]
-}
-
-// cycleNetworkDeltasForCacheTime cycles the network delta trackers for a specific cache time
-func (dm *dockerManager) cycleNetworkDeltasForCacheTime(cacheTimeMs uint16) {
-	if dm.networkSentTrackers[cacheTimeMs] != nil {
-		dm.networkSentTrackers[cacheTimeMs].Cycle()
-	}
-	if dm.networkRecvTrackers[cacheTimeMs] != nil {
-		dm.networkRecvTrackers[cacheTimeMs].Cycle()
-	}
-}
-
-// calculateNetworkStats calculates network sent/receive deltas using DeltaTracker
-func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats *container.ApiStats, stats *container.Stats, initialized bool, name string, cacheTimeMs uint16) (uint64, uint64) {
-	var total_sent, total_recv uint64
-	for _, v := range apiStats.Networks {
-		total_sent += v.TxBytes
-		total_recv += v.RxBytes
-	}
-
-	// Get the DeltaTracker for this specific cache time
-	sentTracker := dm.getNetworkTracker(cacheTimeMs, true)
-	recvTracker := dm.getNetworkTracker(cacheTimeMs, false)
-
-	// Set current values in the cache-time-specific DeltaTracker
-	sentTracker.Set(ctr.IdShort, total_sent)
-	recvTracker.Set(ctr.IdShort, total_recv)
-
-	// Get deltas (bytes since last measurement)
-	sent_delta_raw := sentTracker.Delta(ctr.IdShort)
-	recv_delta_raw := recvTracker.Delta(ctr.IdShort)
-
-	// Calculate bytes per second independently for Tx and Rx if we have previous data
-	var sent_delta, recv_delta uint64
-	if initialized {
-		millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
-		if millisecondsElapsed > 0 {
-			if sent_delta_raw > 0 {
-				sent_delta = sent_delta_raw * 1000 / millisecondsElapsed
-				if sent_delta > maxNetworkSpeedBps {
-					slog.Warn("Bad network delta", "container", name)
-					sent_delta = 0
-				}
-			}
-			if recv_delta_raw > 0 {
-				recv_delta = recv_delta_raw * 1000 / millisecondsElapsed
-				if recv_delta > maxNetworkSpeedBps {
-					slog.Warn("Bad network delta", "container", name)
-					recv_delta = 0
-				}
-			}
-		}
-	}
-
-	return sent_delta, recv_delta
-}
-
-// validateCpuPercentage checks if CPU percentage is within valid range
-func validateCpuPercentage(cpuPct float64, containerName string) error {
-	if cpuPct > 100 {
-		return fmt.Errorf("%s cpu pct greater than 100: %+v", containerName, cpuPct)
-	}
-	return nil
-}
-
-// updateContainerStatsValues updates the final stats values
-func updateContainerStatsValues(stats *container.Stats, cpuPct float64, usedMemory uint64, sent_delta, recv_delta uint64, readTime time.Time) {
-	stats.Cpu = twoDecimals(cpuPct)
-	stats.Mem = bytesToMegabytes(float64(usedMemory))
-	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
-	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
-	stats.PrevReadTime = readTime
-}
-
-func parseDockerStatus(status string) (string, container.DockerHealth) {
-	trimmed := strings.TrimSpace(status)
-	if trimmed == "" {
-		return "", container.DockerHealthNone
-	}
-
-	// Remove "About " from status
-	trimmed = strings.Replace(trimmed, "About ", "", 1)
-
-	openIdx := strings.LastIndex(trimmed, "(")
-	if openIdx == -1 || !strings.HasSuffix(trimmed, ")") {
-		return trimmed, container.DockerHealthNone
-	}
-
-	statusText := strings.TrimSpace(trimmed[:openIdx])
-	if statusText == "" {
-		statusText = trimmed
-	}
-
-	healthText := strings.ToLower(strings.TrimSpace(strings.TrimSuffix(trimmed[openIdx+1:], ")")))
-	// Some Docker statuses include a "health:" prefix inside the parentheses.
-	// Strip it so it maps correctly to the known health states.
-	if colonIdx := strings.IndexRune(healthText, ':'); colonIdx != -1 {
-		prefix := strings.TrimSpace(healthText[:colonIdx])
-		if prefix == "health" || prefix == "health status" {
-			healthText = strings.TrimSpace(healthText[colonIdx+1:])
-		}
-	}
-	if health, ok := container.DockerHealthStrings[healthText]; ok {
-		return statusText, health
-	}
-
-	return trimmed, container.DockerHealthNone
-}
-
-// Updates stats for individual container with cache-time-aware delta tracking
-func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeMs uint16) error {
+// Updates stats for individual container
+func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
 	name := ctr.Names[0][1:]
 
-	resp, err := dm.client.Get(fmt.Sprintf("http://localhost/containers/%s/stats?stream=0&one-shot=1", ctr.IdShort))
+	resp, err := dm.client.Get("http://localhost/containers/" + ctr.IdShort + "/stats?stream=0&one-shot=1")
 	if err != nil {
 		return err
 	}
+	defer resp.Body.Close()
 
 	dm.containerStatsMutex.Lock()
 	defer dm.containerStatsMutex.Unlock()
@@ -356,74 +159,82 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeM
 	// add empty values if they doesn't exist in map
 	stats, initialized := dm.containerStatsMap[ctr.IdShort]
 	if !initialized {
-		stats = &container.Stats{Name: name, Id: ctr.IdShort, Image: ctr.Image}
+		stats = &container.Stats{Name: name}
 		dm.containerStatsMap[ctr.IdShort] = stats
 	}
 
-	stats.Id = ctr.IdShort
-
-	statusText, health := parseDockerStatus(ctr.Status)
-	stats.Status = statusText
-	stats.Health = health
-
 	// reset current stats
 	stats.Cpu = 0
 	stats.Mem = 0
 	stats.NetworkSent = 0
 	stats.NetworkRecv = 0
 
+	// docker host container stats response
+	// res := dm.getApiStats()
+	// defer dm.putApiStats(res)
+	//
+
 	res := dm.apiStats
 	res.Networks = nil
 	if err := dm.decode(resp, res); err != nil {
 		return err
 	}
 
-	// Initialize CPU tracking for this cache time interval
-	dm.initializeCpuTracking(cacheTimeMs)
-
-	// Get previous CPU values
-	prevCpuContainer, prevCpuSystem := dm.getCpuPreviousValues(cacheTimeMs, ctr.IdShort)
-
-	// Calculate CPU percentage based on platform
+	// calculate cpu and memory stats
+	var usedMemory uint64
 	var cpuPct float64
+
+	// store current cpu stats
+	prevCpuContainer, prevCpuSystem := stats.CpuContainer, stats.CpuSystem
+	stats.CpuContainer = res.CPUStats.CPUUsage.TotalUsage
+	stats.CpuSystem = res.CPUStats.SystemUsage
+
 	if dm.isWindows {
-		prevRead := dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort]
-		cpuPct = res.CalculateCpuPercentWindows(prevCpuContainer, prevRead)
+		usedMemory = res.MemoryStats.PrivateWorkingSet
+		cpuPct = res.CalculateCpuPercentWindows(prevCpuContainer, stats.PrevReadTime)
 	} else {
+		// check if container has valid data, otherwise may be in restart loop (#103)
+		if res.MemoryStats.Usage == 0 {
+			return fmt.Errorf("%s - no memory stats - see https://github.com/henrygd/beszel/issues/144", name)
+		}
+		memCache := res.MemoryStats.Stats.InactiveFile
+		if memCache == 0 {
+			memCache = res.MemoryStats.Stats.Cache
+		}
+		usedMemory = res.MemoryStats.Usage - memCache
+
 		cpuPct = res.CalculateCpuPercentLinux(prevCpuContainer, prevCpuSystem)
 	}
 
-	// Calculate memory usage
-	usedMemory, err := calculateMemoryUsage(res, dm.isWindows)
-	if err != nil {
-		return fmt.Errorf("%s - %w - see https://github.com/henrygd/beszel/issues/144", name, err)
+	if cpuPct > 100 {
+		return fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
 	}
 
-	// Store current CPU stats for next calculation
-	currentCpuContainer := res.CPUStats.CPUUsage.TotalUsage
-	currentCpuSystem := res.CPUStats.SystemUsage
-	dm.setCpuCurrentValues(cacheTimeMs, ctr.IdShort, currentCpuContainer, currentCpuSystem)
-
-	// Validate CPU percentage
-	if err := validateCpuPercentage(cpuPct, name); err != nil {
-		return err
-	}
-
-	// Calculate network stats using DeltaTracker
-	sent_delta, recv_delta := dm.calculateNetworkStats(ctr, res, stats, initialized, name, cacheTimeMs)
-
-	// Store current network values for legacy compatibility
+	// network
 	var total_sent, total_recv uint64
 	for _, v := range res.Networks {
 		total_sent += v.TxBytes
 		total_recv += v.RxBytes
 	}
+	var sent_delta, recv_delta uint64
+	millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
+	if initialized && millisecondsElapsed > 0 {
+		// get bytes per second
+		sent_delta = (total_sent - stats.PrevNet.Sent) * 1000 / millisecondsElapsed
+		recv_delta = (total_recv - stats.PrevNet.Recv) * 1000 / millisecondsElapsed
+		// check for unrealistic network values (> 5GB/s)
+		if sent_delta > 5e9 || recv_delta > 5e9 {
+			slog.Warn("Bad network delta", "container", name)
+			sent_delta, recv_delta = 0, 0
+		}
+	}
 	stats.PrevNet.Sent, stats.PrevNet.Recv = total_sent, total_recv
 
-	// Update final stats values
-	updateContainerStatsValues(stats, cpuPct, usedMemory, sent_delta, recv_delta, res.Read)
-	// store per-cache-time read time for Windows CPU percent calc
-	dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort] = res.Read
+	stats.Cpu = twoDecimals(cpuPct)
+	stats.Mem = bytesToMegabytes(float64(usedMemory))
+	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
+	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
+	stats.PrevReadTime = res.Read
 
 	return nil
 }
@@ -433,15 +244,6 @@ func (dm *dockerManager) deleteContainerStatsSync(id string) {
 	dm.containerStatsMutex.Lock()
 	defer dm.containerStatsMutex.Unlock()
 	delete(dm.containerStatsMap, id)
-	for ct := range dm.lastCpuContainer {
-		delete(dm.lastCpuContainer[ct], id)
-	}
-	for ct := range dm.lastCpuSystem {
-		delete(dm.lastCpuSystem[ct], id)
-	}
-	for ct := range dm.lastCpuReadTime {
-		delete(dm.lastCpuReadTime[ct], id)
-	}
 }
 
 // Creates a new http client for Docker or Podman API
@@ -481,7 +283,7 @@ func newDockerManager(a *Agent) *dockerManager {
 	}
 
 	// configurable timeout
-	timeout := time.Millisecond * time.Duration(dockerTimeoutMs)
+	timeout := time.Millisecond * 2100
 	if t, set := GetEnv("DOCKER_TIMEOUT"); set {
 		timeout, err = time.ParseDuration(t)
 		if err != nil {
@@ -506,13 +308,6 @@ func newDockerManager(a *Agent) *dockerManager {
 		sem:               make(chan struct{}, 5),
 		apiContainerList:  []*container.ApiInfo{},
 		apiStats:          &container.ApiStats{},
-
-		// Initialize cache-time-aware tracking structures
-		lastCpuContainer:    make(map[uint16]map[string]uint64),
-		lastCpuSystem:       make(map[uint16]map[string]uint64),
-		lastCpuReadTime:     make(map[uint16]map[string]time.Time),
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
 	}
 
 	// If using podman, return client
@@ -522,49 +317,28 @@ func newDockerManager(a *Agent) *dockerManager {
 		return manager
 	}
 
-	// this can take up to 5 seconds with retry, so run in goroutine
-	go manager.checkDockerVersion()
-
-	// give version check a chance to complete before returning
-	time.Sleep(50 * time.Millisecond)
-
-	return manager
-}
-
-// checkDockerVersion checks Docker version and sets goodDockerVersion if at least 25.0.0.
-// Versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch.
-func (dm *dockerManager) checkDockerVersion() {
-	var err error
-	var resp *http.Response
+	// Check docker version
+	// (versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch)
 	var versionInfo struct {
 		Version string `json:"Version"`
 	}
-	const versionMaxTries = 2
-	for i := 1; i <= versionMaxTries; i++ {
-		resp, err = dm.client.Get("http://localhost/version")
-		if err == nil {
-			break
-		}
-		if resp != nil {
-			resp.Body.Close()
-		}
-		if i < versionMaxTries {
-			slog.Debug("Failed to get Docker version; retrying", "attempt", i, "error", err)
-			time.Sleep(5 * time.Second)
-		}
-	}
+	resp, err := manager.client.Get("http://localhost/version")
 	if err != nil {
-		return
+		return manager
 	}
-	if err := dm.decode(resp, &versionInfo); err != nil {
-		return
+
+	if err := manager.decode(resp, &versionInfo); err != nil {
+		return manager
 	}
+
 	// if version > 24, one-shot works correctly and we can limit concurrent operations
 	if dockerVersion, err := semver.Parse(versionInfo.Version); err == nil && dockerVersion.Major > 24 {
-		dm.goodDockerVersion = true
+		manager.goodDockerVersion = true
 	} else {
 		slog.Info(fmt.Sprintf("Docker %s is outdated. Upgrade if possible. See https://github.com/henrygd/beszel/issues/58", versionInfo.Version))
 	}
+
+	return manager
 }
 
 // Decodes Docker API JSON response using a reusable buffer and decoder. Not thread safe.
@@ -594,107 +368,3 @@ func getDockerHost() string {
 	}
 	return scheme + socks[0]
 }
-
-// getContainerInfo fetches the inspection data for a container
-func (dm *dockerManager) getContainerInfo(ctx context.Context, containerID string) ([]byte, error) {
-	endpoint := fmt.Sprintf("http://localhost/containers/%s/json", containerID)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := dm.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return nil, fmt.Errorf("container info request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
-	}
-
-	// Remove sensitive environment variables from Config.Env
-	var containerInfo map[string]any
-	if err := json.NewDecoder(resp.Body).Decode(&containerInfo); err != nil {
-		return nil, err
-	}
-	if config, ok := containerInfo["Config"].(map[string]any); ok {
-		delete(config, "Env")
-	}
-
-	return json.Marshal(containerInfo)
-}
-
-// getLogs fetches the logs for a container
-func (dm *dockerManager) getLogs(ctx context.Context, containerID string) (string, error) {
-	endpoint := fmt.Sprintf("http://localhost/containers/%s/logs?stdout=1&stderr=1&tail=%d", containerID, dockerLogsTail)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return "", err
-	}
-
-	resp, err := dm.client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		return "", fmt.Errorf("logs request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
-	}
-
-	var builder strings.Builder
-	if err := decodeDockerLogStream(resp.Body, &builder); err != nil {
-		return "", err
-	}
-
-	return builder.String(), nil
-}
-
-func decodeDockerLogStream(reader io.Reader, builder *strings.Builder) error {
-	const headerSize = 8
-	var header [headerSize]byte
-	buf := make([]byte, 0, dockerLogsTail*200)
-
-	for {
-		if _, err := io.ReadFull(reader, header[:]); err != nil {
-			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
-				return nil
-			}
-			return err
-		}
-
-		frameLen := binary.BigEndian.Uint32(header[4:])
-		if frameLen == 0 {
-			continue
-		}
-
-		buf = allocateBuffer(buf, int(frameLen))
-		if _, err := io.ReadFull(reader, buf[:frameLen]); err != nil {
-			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
-				if len(buf) > 0 {
-					builder.Write(buf[:min(int(frameLen), len(buf))])
-				}
-				return nil
-			}
-			return err
-		}
-		builder.Write(buf[:frameLen])
-	}
-}
-
-func allocateBuffer(current []byte, needed int) []byte {
-	if cap(current) >= needed {
-		return current[:needed]
-	}
-	return make([]byte, needed)
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

agent/docker_test.go

@@ -1,923 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"encoding/json"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/henrygd/beszel/agent/deltatracker"
-	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var defaultCacheTimeMs = uint16(60_000)
-
-// cycleCpuDeltas cycles the CPU tracking data for a specific cache time interval
-func (dm *dockerManager) cycleCpuDeltas(cacheTimeMs uint16) {
-	// Clear the CPU tracking maps for this cache time interval
-	if dm.lastCpuContainer[cacheTimeMs] != nil {
-		clear(dm.lastCpuContainer[cacheTimeMs])
-	}
-	if dm.lastCpuSystem[cacheTimeMs] != nil {
-		clear(dm.lastCpuSystem[cacheTimeMs])
-	}
-}
-
-func TestCalculateMemoryUsage(t *testing.T) {
-	tests := []struct {
-		name        string
-		apiStats    *container.ApiStats
-		isWindows   bool
-		expected    uint64
-		expectError bool
-	}{
-		{
-			name: "Linux with valid memory stats",
-			apiStats: &container.ApiStats{
-				MemoryStats: container.MemoryStats{
-					Usage: 1048576, // 1MB
-					Stats: container.MemoryStatsStats{
-						Cache:        524288, // 512KB
-						InactiveFile: 262144, // 256KB
-					},
-				},
-			},
-			isWindows:   false,
-			expected:    786432, // 1MB - 256KB (inactive_file takes precedence) = 768KB
-			expectError: false,
-		},
-		{
-			name: "Linux with zero cache uses inactive_file",
-			apiStats: &container.ApiStats{
-				MemoryStats: container.MemoryStats{
-					Usage: 1048576, // 1MB
-					Stats: container.MemoryStatsStats{
-						Cache:        0,
-						InactiveFile: 262144, // 256KB
-					},
-				},
-			},
-			isWindows:   false,
-			expected:    786432, // 1MB - 256KB = 768KB
-			expectError: false,
-		},
-		{
-			name: "Windows with valid memory stats",
-			apiStats: &container.ApiStats{
-				MemoryStats: container.MemoryStats{
-					PrivateWorkingSet: 524288, // 512KB
-				},
-			},
-			isWindows:   true,
-			expected:    524288,
-			expectError: false,
-		},
-		{
-			name: "Linux with zero usage returns error",
-			apiStats: &container.ApiStats{
-				MemoryStats: container.MemoryStats{
-					Usage: 0,
-					Stats: container.MemoryStatsStats{
-						Cache:        0,
-						InactiveFile: 0,
-					},
-				},
-			},
-			isWindows:   false,
-			expected:    0,
-			expectError: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := calculateMemoryUsage(tt.apiStats, tt.isWindows)
-
-			if tt.expectError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expected, result)
-			}
-		})
-	}
-}
-
-func TestValidateCpuPercentage(t *testing.T) {
-	tests := []struct {
-		name          string
-		cpuPct        float64
-		containerName string
-		expectError   bool
-		expectedError string
-	}{
-		{
-			name:          "valid CPU percentage",
-			cpuPct:        50.5,
-			containerName: "test-container",
-			expectError:   false,
-		},
-		{
-			name:          "zero CPU percentage",
-			cpuPct:        0.0,
-			containerName: "test-container",
-			expectError:   false,
-		},
-		{
-			name:          "CPU percentage over 100",
-			cpuPct:        150.5,
-			containerName: "test-container",
-			expectError:   true,
-			expectedError: "test-container cpu pct greater than 100: 150.5",
-		},
-		{
-			name:          "CPU percentage exactly 100",
-			cpuPct:        100.0,
-			containerName: "test-container",
-			expectError:   false,
-		},
-		{
-			name:          "negative CPU percentage",
-			cpuPct:        -10.0,
-			containerName: "test-container",
-			expectError:   false, // Function only checks for > 100, not negative
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateCpuPercentage(tt.cpuPct, tt.containerName)
-
-			if tt.expectError {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.expectedError)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestUpdateContainerStatsValues(t *testing.T) {
-	stats := &container.Stats{
-		Name:         "test-container",
-		Cpu:          0.0,
-		Mem:          0.0,
-		NetworkSent:  0.0,
-		NetworkRecv:  0.0,
-		PrevReadTime: time.Time{},
-	}
-
-	testTime := time.Now()
-	updateContainerStatsValues(stats, 75.5, 1048576, 524288, 262144, testTime)
-
-	// Check CPU percentage (should be rounded to 2 decimals)
-	assert.Equal(t, 75.5, stats.Cpu)
-
-	// Check memory (should be converted to MB: 1048576 bytes = 1 MB)
-	assert.Equal(t, 1.0, stats.Mem)
-
-	// Check network sent (should be converted to MB: 524288 bytes = 0.5 MB)
-	assert.Equal(t, 0.5, stats.NetworkSent)
-
-	// Check network recv (should be converted to MB: 262144 bytes = 0.25 MB)
-	assert.Equal(t, 0.25, stats.NetworkRecv)
-
-	// Check read time
-	assert.Equal(t, testTime, stats.PrevReadTime)
-}
-
-func TestTwoDecimals(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    float64
-		expected float64
-	}{
-		{"round down", 1.234, 1.23},
-		{"round half up", 1.235, 1.24}, // math.Round rounds half up
-		{"no rounding needed", 1.23, 1.23},
-		{"negative number", -1.235, -1.24}, // math.Round rounds half up (more negative)
-		{"zero", 0.0, 0.0},
-		{"large number", 123.456, 123.46}, // rounds 5 up
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := twoDecimals(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestBytesToMegabytes(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    float64
-		expected float64
-	}{
-		{"1 MB", 1048576, 1.0},
-		{"512 KB", 524288, 0.5},
-		{"zero", 0, 0},
-		{"large value", 1073741824, 1024}, // 1 GB = 1024 MB
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := bytesToMegabytes(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestInitializeCpuTracking(t *testing.T) {
-	dm := &dockerManager{
-		lastCpuContainer: make(map[uint16]map[string]uint64),
-		lastCpuSystem:    make(map[uint16]map[string]uint64),
-		lastCpuReadTime:  make(map[uint16]map[string]time.Time),
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Test initializing a new cache time
-	dm.initializeCpuTracking(cacheTimeMs)
-
-	// Check that maps were created
-	assert.NotNil(t, dm.lastCpuContainer[cacheTimeMs])
-	assert.NotNil(t, dm.lastCpuSystem[cacheTimeMs])
-	assert.NotNil(t, dm.lastCpuReadTime[cacheTimeMs])
-	assert.Empty(t, dm.lastCpuContainer[cacheTimeMs])
-	assert.Empty(t, dm.lastCpuSystem[cacheTimeMs])
-
-	// Test initializing existing cache time (should not overwrite)
-	dm.lastCpuContainer[cacheTimeMs]["test"] = 100
-	dm.lastCpuSystem[cacheTimeMs]["test"] = 200
-
-	dm.initializeCpuTracking(cacheTimeMs)
-
-	// Should still have the existing values
-	assert.Equal(t, uint64(100), dm.lastCpuContainer[cacheTimeMs]["test"])
-	assert.Equal(t, uint64(200), dm.lastCpuSystem[cacheTimeMs]["test"])
-}
-
-func TestGetCpuPreviousValues(t *testing.T) {
-	dm := &dockerManager{
-		lastCpuContainer: map[uint16]map[string]uint64{
-			30000: {"container1": 100, "container2": 200},
-		},
-		lastCpuSystem: map[uint16]map[string]uint64{
-			30000: {"container1": 150, "container2": 250},
-		},
-	}
-
-	// Test getting existing values
-	container, system := dm.getCpuPreviousValues(30000, "container1")
-	assert.Equal(t, uint64(100), container)
-	assert.Equal(t, uint64(150), system)
-
-	// Test getting non-existing container
-	container, system = dm.getCpuPreviousValues(30000, "nonexistent")
-	assert.Equal(t, uint64(0), container)
-	assert.Equal(t, uint64(0), system)
-
-	// Test getting non-existing cache time
-	container, system = dm.getCpuPreviousValues(60000, "container1")
-	assert.Equal(t, uint64(0), container)
-	assert.Equal(t, uint64(0), system)
-}
-
-func TestSetCpuCurrentValues(t *testing.T) {
-	dm := &dockerManager{
-		lastCpuContainer: make(map[uint16]map[string]uint64),
-		lastCpuSystem:    make(map[uint16]map[string]uint64),
-	}
-
-	cacheTimeMs := uint16(30000)
-	containerId := "test-container"
-
-	// Initialize the cache time maps first
-	dm.initializeCpuTracking(cacheTimeMs)
-
-	// Set values
-	dm.setCpuCurrentValues(cacheTimeMs, containerId, 500, 750)
-
-	// Check that values were set
-	assert.Equal(t, uint64(500), dm.lastCpuContainer[cacheTimeMs][containerId])
-	assert.Equal(t, uint64(750), dm.lastCpuSystem[cacheTimeMs][containerId])
-}
-
-func TestCalculateNetworkStats(t *testing.T) {
-	// Create docker manager with tracker maps
-	dm := &dockerManager{
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Pre-populate tracker for this cache time with initial values
-	sentTracker := deltatracker.NewDeltaTracker[string, uint64]()
-	recvTracker := deltatracker.NewDeltaTracker[string, uint64]()
-	sentTracker.Set("container1", 1000)
-	recvTracker.Set("container1", 800)
-	sentTracker.Cycle() // Move to previous
-	recvTracker.Cycle()
-
-	dm.networkSentTrackers[cacheTimeMs] = sentTracker
-	dm.networkRecvTrackers[cacheTimeMs] = recvTracker
-
-	ctr := &container.ApiInfo{
-		IdShort: "container1",
-	}
-
-	apiStats := &container.ApiStats{
-		Networks: map[string]container.NetworkStats{
-			"eth0": {TxBytes: 2000, RxBytes: 1800}, // New values
-		},
-	}
-
-	stats := &container.Stats{
-		PrevReadTime: time.Now().Add(-time.Second), // 1 second ago
-	}
-
-	// Test with initialized container
-	sent, recv := dm.calculateNetworkStats(ctr, apiStats, stats, true, "test-container", cacheTimeMs)
-
-	// Should return calculated byte rates per second
-	assert.GreaterOrEqual(t, sent, uint64(0))
-	assert.GreaterOrEqual(t, recv, uint64(0))
-
-	// Cycle and test one-direction change (Tx only) is reflected independently
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-	apiStats.Networks["eth0"] = container.NetworkStats{TxBytes: 2500, RxBytes: 1800} // +500 Tx only
-	sent, recv = dm.calculateNetworkStats(ctr, apiStats, stats, true, "test-container", cacheTimeMs)
-	assert.Greater(t, sent, uint64(0))
-	assert.Equal(t, uint64(0), recv)
-}
-
-func TestDockerManagerCreation(t *testing.T) {
-	// Test that dockerManager can be created without panicking
-	dm := &dockerManager{
-		lastCpuContainer:    make(map[uint16]map[string]uint64),
-		lastCpuSystem:       make(map[uint16]map[string]uint64),
-		lastCpuReadTime:     make(map[uint16]map[string]time.Time),
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	assert.NotNil(t, dm)
-	assert.NotNil(t, dm.lastCpuContainer)
-	assert.NotNil(t, dm.lastCpuSystem)
-	assert.NotNil(t, dm.networkSentTrackers)
-	assert.NotNil(t, dm.networkRecvTrackers)
-}
-
-func TestCycleCpuDeltas(t *testing.T) {
-	dm := &dockerManager{
-		lastCpuContainer: map[uint16]map[string]uint64{
-			30000: {"container1": 100, "container2": 200},
-		},
-		lastCpuSystem: map[uint16]map[string]uint64{
-			30000: {"container1": 150, "container2": 250},
-		},
-		lastCpuReadTime: map[uint16]map[string]time.Time{
-			30000: {"container1": time.Now()},
-		},
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Verify values exist before cycling
-	assert.Equal(t, uint64(100), dm.lastCpuContainer[cacheTimeMs]["container1"])
-	assert.Equal(t, uint64(200), dm.lastCpuContainer[cacheTimeMs]["container2"])
-
-	// Cycle the CPU deltas
-	dm.cycleCpuDeltas(cacheTimeMs)
-
-	// Verify values are cleared
-	assert.Empty(t, dm.lastCpuContainer[cacheTimeMs])
-	assert.Empty(t, dm.lastCpuSystem[cacheTimeMs])
-	// lastCpuReadTime is not affected by cycleCpuDeltas
-	assert.NotEmpty(t, dm.lastCpuReadTime[cacheTimeMs])
-}
-
-func TestCycleNetworkDeltas(t *testing.T) {
-	// Create docker manager with tracker maps
-	dm := &dockerManager{
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Get trackers for this cache time (creates them)
-	sentTracker := dm.getNetworkTracker(cacheTimeMs, true)
-	recvTracker := dm.getNetworkTracker(cacheTimeMs, false)
-
-	// Set some test data
-	sentTracker.Set("test", 100)
-	recvTracker.Set("test", 200)
-
-	// This should not panic
-	assert.NotPanics(t, func() {
-		dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-	})
-
-	// Verify that cycle worked by checking deltas are now zero (no previous values)
-	assert.Equal(t, uint64(0), sentTracker.Delta("test"))
-	assert.Equal(t, uint64(0), recvTracker.Delta("test"))
-}
-
-func TestConstants(t *testing.T) {
-	// Test that constants are properly defined
-	assert.Equal(t, uint16(60000), defaultCacheTimeMs)
-	assert.Equal(t, uint64(5e9), maxNetworkSpeedBps)
-	assert.Equal(t, 2100, dockerTimeoutMs)
-}
-
-func TestDockerStatsWithMockData(t *testing.T) {
-	// Create a docker manager with initialized tracking
-	dm := &dockerManager{
-		lastCpuContainer:    make(map[uint16]map[string]uint64),
-		lastCpuSystem:       make(map[uint16]map[string]uint64),
-		lastCpuReadTime:     make(map[uint16]map[string]time.Time),
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		containerStatsMap:   make(map[string]*container.Stats),
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Test that initializeCpuTracking works
-	dm.initializeCpuTracking(cacheTimeMs)
-	assert.NotNil(t, dm.lastCpuContainer[cacheTimeMs])
-	assert.NotNil(t, dm.lastCpuSystem[cacheTimeMs])
-
-	// Test that we can set and get CPU values
-	dm.setCpuCurrentValues(cacheTimeMs, "test-container", 1000, 2000)
-	container, system := dm.getCpuPreviousValues(cacheTimeMs, "test-container")
-	assert.Equal(t, uint64(1000), container)
-	assert.Equal(t, uint64(2000), system)
-}
-
-func TestMemoryStatsEdgeCases(t *testing.T) {
-	tests := []struct {
-		name      string
-		usage     uint64
-		cache     uint64
-		inactive  uint64
-		isWindows bool
-		expected  uint64
-		hasError  bool
-	}{
-		{"Linux normal case", 1000, 200, 0, false, 800, false},
-		{"Linux with inactive file", 1000, 0, 300, false, 700, false},
-		{"Windows normal case", 0, 0, 0, true, 500, false},
-		{"Linux zero usage error", 0, 0, 0, false, 0, true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			apiStats := &container.ApiStats{
-				MemoryStats: container.MemoryStats{
-					Usage: tt.usage,
-					Stats: container.MemoryStatsStats{
-						Cache:        tt.cache,
-						InactiveFile: tt.inactive,
-					},
-				},
-			}
-
-			if tt.isWindows {
-				apiStats.MemoryStats.PrivateWorkingSet = tt.expected
-			}
-
-			result, err := calculateMemoryUsage(apiStats, tt.isWindows)
-
-			if tt.hasError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expected, result)
-			}
-		})
-	}
-}
-
-func TestContainerStatsInitialization(t *testing.T) {
-	stats := &container.Stats{Name: "test-container"}
-
-	// Verify initial values
-	assert.Equal(t, "test-container", stats.Name)
-	assert.Equal(t, 0.0, stats.Cpu)
-	assert.Equal(t, 0.0, stats.Mem)
-	assert.Equal(t, 0.0, stats.NetworkSent)
-	assert.Equal(t, 0.0, stats.NetworkRecv)
-	assert.Equal(t, time.Time{}, stats.PrevReadTime)
-
-	// Test updating values
-	testTime := time.Now()
-	updateContainerStatsValues(stats, 45.67, 2097152, 1048576, 524288, testTime)
-
-	assert.Equal(t, 45.67, stats.Cpu)
-	assert.Equal(t, 2.0, stats.Mem)
-	assert.Equal(t, 1.0, stats.NetworkSent)
-	assert.Equal(t, 0.5, stats.NetworkRecv)
-	assert.Equal(t, testTime, stats.PrevReadTime)
-}
-
-// Test with real Docker API test data
-func TestCalculateMemoryUsageWithRealData(t *testing.T) {
-	// Load minimal container stats from test data
-	data, err := os.ReadFile("test-data/container.json")
-	require.NoError(t, err)
-
-	var apiStats container.ApiStats
-	err = json.Unmarshal(data, &apiStats)
-	require.NoError(t, err)
-
-	// Test memory calculation with real data
-	usedMemory, err := calculateMemoryUsage(&apiStats, false)
-	require.NoError(t, err)
-
-	// From the real data: usage - inactive_file = 507400192 - 165130240 = 342269952
-	expected := uint64(507400192 - 165130240)
-	assert.Equal(t, expected, usedMemory)
-}
-
-func TestCpuPercentageCalculationWithRealData(t *testing.T) {
-	// Load minimal container stats from test data
-	data1, err := os.ReadFile("test-data/container.json")
-	require.NoError(t, err)
-
-	data2, err := os.ReadFile("test-data/container2.json")
-	require.NoError(t, err)
-
-	var apiStats1, apiStats2 container.ApiStats
-	err = json.Unmarshal(data1, &apiStats1)
-	require.NoError(t, err)
-	err = json.Unmarshal(data2, &apiStats2)
-	require.NoError(t, err)
-
-	// Calculate delta manually: 314891801000 - 312055276000 = 2836525000
-	// System delta: 1368474900000000 - 1366399830000000 = 2075070000000
-	// Expected %: (2836525000 / 2075070000000) * 100 ≈ 0.1367%
-	expectedPct := float64(2836525000) / float64(2075070000000) * 100.0
-	actualPct := apiStats2.CalculateCpuPercentLinux(apiStats1.CPUStats.CPUUsage.TotalUsage, apiStats1.CPUStats.SystemUsage)
-
-	assert.InDelta(t, expectedPct, actualPct, 0.01)
-}
-
-func TestNetworkStatsCalculationWithRealData(t *testing.T) {
-	// Create synthetic test data to avoid timing issues
-	apiStats1 := &container.ApiStats{
-		Networks: map[string]container.NetworkStats{
-			"eth0": {TxBytes: 1000000, RxBytes: 500000},
-		},
-	}
-
-	apiStats2 := &container.ApiStats{
-		Networks: map[string]container.NetworkStats{
-			"eth0": {TxBytes: 3000000, RxBytes: 1500000}, // 2MB sent, 1MB received increase
-		},
-	}
-
-	// Create docker manager with tracker maps
-	dm := &dockerManager{
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	ctr := &container.ApiInfo{IdShort: "test-container"}
-	cacheTimeMs := uint16(30000) // Test with 30 second cache
-
-	// Use exact timing for deterministic results
-	exactly1000msAgo := time.Now().Add(-1000 * time.Millisecond)
-	stats := &container.Stats{
-		PrevReadTime: exactly1000msAgo,
-	}
-
-	// First call sets baseline
-	sent1, recv1 := dm.calculateNetworkStats(ctr, apiStats1, stats, true, "test", cacheTimeMs)
-	assert.Equal(t, uint64(0), sent1)
-	assert.Equal(t, uint64(0), recv1)
-
-	// Cycle to establish baseline for this cache time
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-
-	// Calculate expected results precisely
-	deltaSent := uint64(2000000)                             // 3000000 - 1000000
-	deltaRecv := uint64(1000000)                             // 1500000 - 500000
-	expectedElapsedMs := uint64(1000)                        // Exactly 1000ms
-	expectedSentRate := deltaSent * 1000 / expectedElapsedMs // Should be exactly 2000000
-	expectedRecvRate := deltaRecv * 1000 / expectedElapsedMs // Should be exactly 1000000
-
-	// Second call with changed data
-	sent2, recv2 := dm.calculateNetworkStats(ctr, apiStats2, stats, true, "test", cacheTimeMs)
-
-	// Should be exactly the expected rates (no tolerance needed)
-	assert.Equal(t, expectedSentRate, sent2)
-	assert.Equal(t, expectedRecvRate, recv2)
-
-	// Bad speed cap: set absurd delta over 1ms and expect 0 due to cap
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-	stats.PrevReadTime = time.Now().Add(-1 * time.Millisecond)
-	apiStats1.Networks["eth0"] = container.NetworkStats{TxBytes: 0, RxBytes: 0}
-	apiStats2.Networks["eth0"] = container.NetworkStats{TxBytes: 10 * 1024 * 1024 * 1024, RxBytes: 0} // 10GB delta
-	_, _ = dm.calculateNetworkStats(ctr, apiStats1, stats, true, "test", cacheTimeMs)                 // baseline
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-	sent3, recv3 := dm.calculateNetworkStats(ctr, apiStats2, stats, true, "test", cacheTimeMs)
-	assert.Equal(t, uint64(0), sent3)
-	assert.Equal(t, uint64(0), recv3)
-}
-
-func TestContainerStatsEndToEndWithRealData(t *testing.T) {
-	// Load minimal container stats
-	data, err := os.ReadFile("test-data/container.json")
-	require.NoError(t, err)
-
-	var apiStats container.ApiStats
-	err = json.Unmarshal(data, &apiStats)
-	require.NoError(t, err)
-
-	// Create a docker manager with proper initialization
-	dm := &dockerManager{
-		lastCpuContainer:    make(map[uint16]map[string]uint64),
-		lastCpuSystem:       make(map[uint16]map[string]uint64),
-		lastCpuReadTime:     make(map[uint16]map[string]time.Time),
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		containerStatsMap:   make(map[string]*container.Stats),
-	}
-
-	// Initialize CPU tracking
-	cacheTimeMs := uint16(30000)
-	dm.initializeCpuTracking(cacheTimeMs)
-
-	// Create container info
-	ctr := &container.ApiInfo{
-		IdShort: "abc123",
-	}
-
-	// Initialize container stats
-	stats := &container.Stats{Name: "jellyfin"}
-	dm.containerStatsMap[ctr.IdShort] = stats
-
-	// Test individual components that we can verify
-	usedMemory, memErr := calculateMemoryUsage(&apiStats, false)
-	assert.NoError(t, memErr)
-	assert.Greater(t, usedMemory, uint64(0))
-
-	// Test CPU percentage validation
-	cpuPct := 85.5
-	err = validateCpuPercentage(cpuPct, "jellyfin")
-	assert.NoError(t, err)
-
-	err = validateCpuPercentage(150.0, "jellyfin")
-	assert.Error(t, err)
-
-	// Test stats value updates
-	testStats := &container.Stats{}
-	testTime := time.Now()
-	updateContainerStatsValues(testStats, cpuPct, usedMemory, 1000000, 500000, testTime)
-
-	assert.Equal(t, cpuPct, testStats.Cpu)
-	assert.Equal(t, bytesToMegabytes(float64(usedMemory)), testStats.Mem)
-	assert.Equal(t, bytesToMegabytes(1000000), testStats.NetworkSent)
-	assert.Equal(t, bytesToMegabytes(500000), testStats.NetworkRecv)
-	assert.Equal(t, testTime, testStats.PrevReadTime)
-}
-
-func TestEdgeCasesWithRealData(t *testing.T) {
-	// Test with minimal container stats
-	minimalStats := &container.ApiStats{
-		CPUStats: container.CPUStats{
-			CPUUsage:    container.CPUUsage{TotalUsage: 1000},
-			SystemUsage: 50000,
-		},
-		MemoryStats: container.MemoryStats{
-			Usage: 1000000,
-			Stats: container.MemoryStatsStats{
-				Cache:        0,
-				InactiveFile: 0,
-			},
-		},
-		Networks: map[string]container.NetworkStats{
-			"eth0": {TxBytes: 1000, RxBytes: 500},
-		},
-	}
-
-	// Test memory calculation with zero cache/inactive
-	usedMemory, err := calculateMemoryUsage(minimalStats, false)
-	assert.NoError(t, err)
-	assert.Equal(t, uint64(1000000), usedMemory) // Should equal usage when no cache
-
-	// Test CPU percentage calculation
-	cpuPct := minimalStats.CalculateCpuPercentLinux(0, 0) // First run
-	assert.Equal(t, 0.0, cpuPct)
-
-	// Test with Windows data
-	minimalStats.MemoryStats.PrivateWorkingSet = 800000
-	usedMemory, err = calculateMemoryUsage(minimalStats, true)
-	assert.NoError(t, err)
-	assert.Equal(t, uint64(800000), usedMemory)
-}
-
-func TestDockerStatsWorkflow(t *testing.T) {
-	// Test the complete workflow that can be tested without HTTP calls
-	dm := &dockerManager{
-		lastCpuContainer:    make(map[uint16]map[string]uint64),
-		lastCpuSystem:       make(map[uint16]map[string]uint64),
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		containerStatsMap:   make(map[string]*container.Stats),
-	}
-
-	cacheTimeMs := uint16(30000)
-
-	// Test CPU tracking workflow
-	dm.initializeCpuTracking(cacheTimeMs)
-	assert.NotNil(t, dm.lastCpuContainer[cacheTimeMs])
-
-	// Test setting and getting CPU values
-	dm.setCpuCurrentValues(cacheTimeMs, "test-container", 1000, 50000)
-	containerVal, systemVal := dm.getCpuPreviousValues(cacheTimeMs, "test-container")
-	assert.Equal(t, uint64(1000), containerVal)
-	assert.Equal(t, uint64(50000), systemVal)
-
-	// Test network tracking workflow (multi-interface summation)
-	sentTracker := dm.getNetworkTracker(cacheTimeMs, true)
-	recvTracker := dm.getNetworkTracker(cacheTimeMs, false)
-
-	// Simulate two interfaces summed by setting combined totals
-	sentTracker.Set("test-container", 1000+2000)
-	recvTracker.Set("test-container", 500+700)
-
-	deltaSent := sentTracker.Delta("test-container")
-	deltaRecv := recvTracker.Delta("test-container")
-	assert.Equal(t, uint64(0), deltaSent) // No previous value
-	assert.Equal(t, uint64(0), deltaRecv)
-
-	// Cycle and test again
-	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
-
-	// Increase each interface total (combined totals go up by 1500 and 800)
-	sentTracker.Set("test-container", (1000+2000)+1500)
-	recvTracker.Set("test-container", (500+700)+800)
-
-	deltaSent = sentTracker.Delta("test-container")
-	deltaRecv = recvTracker.Delta("test-container")
-	assert.Equal(t, uint64(1500), deltaSent)
-	assert.Equal(t, uint64(800), deltaRecv)
-}
-
-func TestNetworkRateCalculationFormula(t *testing.T) {
-	// Test the exact formula used in calculateNetworkStats
-	testCases := []struct {
-		name         string
-		deltaBytes   uint64
-		elapsedMs    uint64
-		expectedRate uint64
-	}{
-		{"1MB over 1 second", 1000000, 1000, 1000000},
-		{"2MB over 1 second", 2000000, 1000, 2000000},
-		{"1MB over 2 seconds", 1000000, 2000, 500000},
-		{"500KB over 500ms", 500000, 500, 1000000},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// This is the exact formula from calculateNetworkStats
-			actualRate := tc.deltaBytes * 1000 / tc.elapsedMs
-			assert.Equal(t, tc.expectedRate, actualRate,
-				"Rate calculation should be exact: %d bytes * 1000 / %d ms = %d",
-				tc.deltaBytes, tc.elapsedMs, tc.expectedRate)
-		})
-	}
-}
-
-func TestDeltaTrackerCacheTimeIsolation(t *testing.T) {
-	// Test that different cache times have separate DeltaTracker instances
-	dm := &dockerManager{
-		networkSentTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-		networkRecvTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	ctr := &container.ApiInfo{IdShort: "web-server"}
-	cacheTime1 := uint16(30000)
-	cacheTime2 := uint16(60000)
-
-	// Get trackers for different cache times (creates separate instances)
-	sentTracker1 := dm.getNetworkTracker(cacheTime1, true)
-	recvTracker1 := dm.getNetworkTracker(cacheTime1, false)
-
-	sentTracker2 := dm.getNetworkTracker(cacheTime2, true)
-	recvTracker2 := dm.getNetworkTracker(cacheTime2, false)
-
-	// Verify they are different instances
-	assert.NotSame(t, sentTracker1, sentTracker2)
-	assert.NotSame(t, recvTracker1, recvTracker2)
-
-	// Set values for cache time 1
-	sentTracker1.Set(ctr.IdShort, 1000000)
-	recvTracker1.Set(ctr.IdShort, 500000)
-
-	// Set values for cache time 2
-	sentTracker2.Set(ctr.IdShort, 2000000)
-	recvTracker2.Set(ctr.IdShort, 1000000)
-
-	// Verify they don't interfere (both should return 0 since no previous values)
-	assert.Equal(t, uint64(0), sentTracker1.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(0), recvTracker1.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(0), sentTracker2.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(0), recvTracker2.Delta(ctr.IdShort))
-
-	// Cycle cache time 1 trackers
-	dm.cycleNetworkDeltasForCacheTime(cacheTime1)
-
-	// Set new values for cache time 1
-	sentTracker1.Set(ctr.IdShort, 3000000) // 2MB increase
-	recvTracker1.Set(ctr.IdShort, 1500000) // 1MB increase
-
-	// Cache time 1 should show deltas, cache time 2 should still be 0
-	assert.Equal(t, uint64(2000000), sentTracker1.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(1000000), recvTracker1.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(0), sentTracker2.Delta(ctr.IdShort)) // Unaffected
-	assert.Equal(t, uint64(0), recvTracker2.Delta(ctr.IdShort)) // Unaffected
-
-	// Cycle cache time 2 and verify it works independently
-	dm.cycleNetworkDeltasForCacheTime(cacheTime2)
-	sentTracker2.Set(ctr.IdShort, 2500000) // 0.5MB increase
-	recvTracker2.Set(ctr.IdShort, 1200000) // 0.2MB increase
-
-	assert.Equal(t, uint64(500000), sentTracker2.Delta(ctr.IdShort))
-	assert.Equal(t, uint64(200000), recvTracker2.Delta(ctr.IdShort))
-}
-
-func TestParseDockerStatus(t *testing.T) {
-	tests := []struct {
-		name           string
-		input          string
-		expectedStatus string
-		expectedHealth container.DockerHealth
-	}{
-		{
-			name:           "status with About an removed",
-			input:          "Up About an hour (healthy)",
-			expectedStatus: "Up an hour",
-			expectedHealth: container.DockerHealthHealthy,
-		},
-		{
-			name:           "status without About an unchanged",
-			input:          "Up 2 hours (healthy)",
-			expectedStatus: "Up 2 hours",
-			expectedHealth: container.DockerHealthHealthy,
-		},
-		{
-			name:           "status with About and no parentheses",
-			input:          "Up About an hour",
-			expectedStatus: "Up an hour",
-			expectedHealth: container.DockerHealthNone,
-		},
-		{
-			name:           "status without parentheses",
-			input:          "Created",
-			expectedStatus: "Created",
-			expectedHealth: container.DockerHealthNone,
-		},
-		{
-			name:           "empty status",
-			input:          "",
-			expectedStatus: "",
-			expectedHealth: container.DockerHealthNone,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			status, health := parseDockerStatus(tt.input)
-			assert.Equal(t, tt.expectedStatus, status)
-			assert.Equal(t, tt.expectedHealth, health)
-		})
-	}
-}
-
-func TestConstantsAndUtilityFunctions(t *testing.T) {
-	// Test constants are properly defined
-	assert.Equal(t, uint16(60000), defaultCacheTimeMs)
-	assert.Equal(t, uint64(5e9), maxNetworkSpeedBps)
-	assert.Equal(t, 2100, dockerTimeoutMs)
-
-	// Test utility functions
-	assert.Equal(t, 1.5, twoDecimals(1.499))
-	assert.Equal(t, 1.5, twoDecimals(1.5))
-	assert.Equal(t, 1.5, twoDecimals(1.501))
-
-	assert.Equal(t, 1.0, bytesToMegabytes(1048576)) // 1 MB
-	assert.Equal(t, 0.5, bytesToMegabytes(524288))  // 512 KB
-	assert.Equal(t, 0.0, bytesToMegabytes(0))
-}

agent/gpu.go

@@ -5,7 +5,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"maps"
 	"os/exec"
 	"regexp"
 	"strconv"
@@ -45,21 +44,6 @@ type GPUManager struct {
 	tegrastats    bool
 	intelGpuStats bool
 	GpuDataMap    map[string]*system.GPUData
-	// lastAvgData stores the last calculated averages for each GPU
-	// Used when a collection happens before new data arrives (Count == 0)
-	lastAvgData map[string]system.GPUData
-	// Per-cache-key tracking for delta calculations
-	// cacheKey -> gpuId -> snapshot of last count/usage/power values
-	lastSnapshots map[uint16]map[string]*gpuSnapshot
-}
-
-// gpuSnapshot stores the last observed incremental values for delta tracking
-type gpuSnapshot struct {
-	count    uint32
-	usage    float64
-	power    float64
-	powerPkg float64
-	engines  map[string]float64
 }
 
 // RocmSmiJson represents the JSON structure of rocm-smi output
@@ -245,21 +229,47 @@ func (gm *GPUManager) parseAmdData(output []byte) bool {
 	return true
 }
 
-// GetCurrentData returns GPU utilization data averaged since the last call with this cacheKey
-func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData {
+// sums and resets the current GPU utilization data since the last update
+func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
 	gm.Lock()
 	defer gm.Unlock()
 
-	gm.initializeSnapshots(cacheKey)
-	nameCounts := gm.countGPUNames()
+	// check for GPUs with the same name
+	nameCounts := make(map[string]int)
+	for _, gpu := range gm.GpuDataMap {
+		nameCounts[gpu.Name]++
+	}
 
+	// copy / reset the data
 	gpuData := make(map[string]system.GPUData, len(gm.GpuDataMap))
 	for id, gpu := range gm.GpuDataMap {
-		gpuAvg := gm.calculateGPUAverage(id, gpu, cacheKey)
-		gm.updateInstantaneousValues(&gpuAvg, gpu)
-		gm.storeSnapshot(id, gpu, cacheKey)
+		// avoid division by zero
+		count := max(gpu.Count, 1)
 
-		// Append id to name if there are multiple GPUs with the same name
+		// average the data
+		gpuAvg := *gpu
+		gpuAvg.Temperature = twoDecimals(gpu.Temperature)
+		gpuAvg.Power = twoDecimals(gpu.Power / count)
+
+		// intel gpu stats doesn't provide usage, memory used, or memory total
+		if gm.intelGpuStats {
+			maxEngineUsage := 0.0
+			for name, engine := range gpu.Engines {
+				gpuAvg.Engines[name] = twoDecimals(engine / count)
+				maxEngineUsage = max(maxEngineUsage, engine/count)
+			}
+			gpuAvg.Usage = twoDecimals(maxEngineUsage)
+		} else {
+			gpuAvg.Usage = twoDecimals(gpu.Usage / count)
+			gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
+			gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
+		}
+
+		// reset accumulators in the original gpu data for next collection
+		gpu.Usage, gpu.Power, gpu.Count = gpuAvg.Usage, gpuAvg.Power, 1
+		gpu.Engines = gpuAvg.Engines
+
+		// append id to the name if there are multiple GPUs with the same name
 		if nameCounts[gpu.Name] > 1 {
 			gpuAvg.Name = fmt.Sprintf("%s %s", gpu.Name, id)
 		}
@@ -269,115 +279,6 @@ func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData
 	return gpuData
 }
 
-// initializeSnapshots ensures snapshot maps are initialized for the given cache key
-func (gm *GPUManager) initializeSnapshots(cacheKey uint16) {
-	if gm.lastAvgData == nil {
-		gm.lastAvgData = make(map[string]system.GPUData)
-	}
-	if gm.lastSnapshots == nil {
-		gm.lastSnapshots = make(map[uint16]map[string]*gpuSnapshot)
-	}
-	if gm.lastSnapshots[cacheKey] == nil {
-		gm.lastSnapshots[cacheKey] = make(map[string]*gpuSnapshot)
-	}
-}
-
-// countGPUNames returns a map of GPU names to their occurrence count
-func (gm *GPUManager) countGPUNames() map[string]int {
-	nameCounts := make(map[string]int)
-	for _, gpu := range gm.GpuDataMap {
-		nameCounts[gpu.Name]++
-	}
-	return nameCounts
-}
-
-// calculateGPUAverage computes the average GPU metrics since the last snapshot for this cache key
-func (gm *GPUManager) calculateGPUAverage(id string, gpu *system.GPUData, cacheKey uint16) system.GPUData {
-	lastSnapshot := gm.lastSnapshots[cacheKey][id]
-	currentCount := uint32(gpu.Count)
-	deltaCount := gm.calculateDeltaCount(currentCount, lastSnapshot)
-
-	// If no new data arrived, use last known average
-	if deltaCount == 0 {
-		return gm.lastAvgData[id] // zero value if not found
-	}
-
-	// Calculate new average
-	gpuAvg := *gpu
-	deltaUsage, deltaPower, deltaPowerPkg := gm.calculateDeltas(gpu, lastSnapshot)
-
-	gpuAvg.Power = twoDecimals(deltaPower / float64(deltaCount))
-
-	if gpu.Engines != nil {
-		// make fresh map for averaged engine metrics to avoid mutating
-		// the accumulator map stored in gm.GpuDataMap
-		gpuAvg.Engines = make(map[string]float64, len(gpu.Engines))
-		gpuAvg.Usage = gm.calculateIntelGPUUsage(&gpuAvg, gpu, lastSnapshot, deltaCount)
-		gpuAvg.PowerPkg = twoDecimals(deltaPowerPkg / float64(deltaCount))
-	} else {
-		gpuAvg.Usage = twoDecimals(deltaUsage / float64(deltaCount))
-	}
-
-	gm.lastAvgData[id] = gpuAvg
-	return gpuAvg
-}
-
-// calculateDeltaCount returns the change in count since the last snapshot
-func (gm *GPUManager) calculateDeltaCount(currentCount uint32, lastSnapshot *gpuSnapshot) uint32 {
-	if lastSnapshot != nil {
-		return currentCount - lastSnapshot.count
-	}
-	return currentCount
-}
-
-// calculateDeltas computes the change in usage, power, and powerPkg since the last snapshot
-func (gm *GPUManager) calculateDeltas(gpu *system.GPUData, lastSnapshot *gpuSnapshot) (deltaUsage, deltaPower, deltaPowerPkg float64) {
-	if lastSnapshot != nil {
-		return gpu.Usage - lastSnapshot.usage,
-			gpu.Power - lastSnapshot.power,
-			gpu.PowerPkg - lastSnapshot.powerPkg
-	}
-	return gpu.Usage, gpu.Power, gpu.PowerPkg
-}
-
-// calculateIntelGPUUsage computes Intel GPU usage from engine metrics and returns max engine usage
-func (gm *GPUManager) calculateIntelGPUUsage(gpuAvg, gpu *system.GPUData, lastSnapshot *gpuSnapshot, deltaCount uint32) float64 {
-	maxEngineUsage := 0.0
-	for name, engine := range gpu.Engines {
-		var deltaEngine float64
-		if lastSnapshot != nil && lastSnapshot.engines != nil {
-			deltaEngine = engine - lastSnapshot.engines[name]
-		} else {
-			deltaEngine = engine
-		}
-		gpuAvg.Engines[name] = twoDecimals(deltaEngine / float64(deltaCount))
-		maxEngineUsage = max(maxEngineUsage, deltaEngine/float64(deltaCount))
-	}
-	return twoDecimals(maxEngineUsage)
-}
-
-// updateInstantaneousValues updates values that should reflect current state, not averages
-func (gm *GPUManager) updateInstantaneousValues(gpuAvg *system.GPUData, gpu *system.GPUData) {
-	gpuAvg.Temperature = twoDecimals(gpu.Temperature)
-	gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
-	gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
-}
-
-// storeSnapshot saves the current GPU state for this cache key
-func (gm *GPUManager) storeSnapshot(id string, gpu *system.GPUData, cacheKey uint16) {
-	snapshot := &gpuSnapshot{
-		count:    uint32(gpu.Count),
-		usage:    gpu.Usage,
-		power:    gpu.Power,
-		powerPkg: gpu.PowerPkg,
-	}
-	if gpu.Engines != nil {
-		snapshot.engines = make(map[string]float64, len(gpu.Engines))
-		maps.Copy(snapshot.engines, gpu.Engines)
-	}
-	gm.lastSnapshots[cacheKey][id] = snapshot
-}
-
 // detectGPUs checks for the presence of GPU management tools (nvidia-smi, rocm-smi, tegrastats)
 // in the system path. It sets the corresponding flags in the GPUManager struct if any of these
 // tools are found. If none of the tools are found, it returns an error indicating that no GPU
@@ -457,9 +358,6 @@ func (gm *GPUManager) startCollector(command string) {
 
 // NewGPUManager creates and initializes a new GPUManager
 func NewGPUManager() (*GPUManager, error) {
-	if skipGPU, _ := GetEnv("SKIP_GPU"); skipGPU == "true" {
-		return nil, nil
-	}
 	var gm GPUManager
 	if err := gm.detectGPUs(); err != nil {
 		return nil, err

agent/gpu_intel.go

@@ -1,11 +1,9 @@
 package agent
 
 import (
-	"bufio"
-	"io"
+	"encoding/json"
+	"fmt"
 	"os/exec"
-	"strconv"
-	"strings"
 
 	"github.com/henrygd/beszel/internal/entities/system"
 )
@@ -16,9 +14,12 @@ const (
 )
 
 type intelGpuStats struct {
-	PowerGPU float64
-	PowerPkg float64
-	Engines  map[string]float64
+	Power struct {
+		GPU float64 `json:"GPU"`
+	} `json:"power"`
+	Engines map[string]struct {
+		Busy float64 `json:"busy"`
+	} `json:"engines"`
 }
 
 // updateIntelFromStats updates aggregated GPU data from a single intelGpuStats sample
@@ -33,25 +34,24 @@ func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {
 		gm.GpuDataMap["0"] = gpuData
 	}
 
-	gpuData.Power += sample.PowerGPU
-	gpuData.PowerPkg += sample.PowerPkg
+	if sample.Power.GPU > 0 {
+		gpuData.Power += sample.Power.GPU
+	}
 
 	if gpuData.Engines == nil {
 		gpuData.Engines = make(map[string]float64, len(sample.Engines))
 	}
 	for name, engine := range sample.Engines {
-		gpuData.Engines[name] += engine
+		gpuData.Engines[name] += engine.Busy
 	}
 
 	gpuData.Count++
 	return true
 }
 
-// collectIntelStats executes intel_gpu_top in text mode (-l) and parses the output
-func (gm *GPUManager) collectIntelStats() (err error) {
-	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-l")
-	// Avoid blocking if intel_gpu_top writes to stderr
-	cmd.Stderr = io.Discard
+// collectIntelStats executes intel_gpu_top in JSON mode and stream-decodes the array of samples
+func (gm *GPUManager) collectIntelStats() error {
+	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-J")
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return err
@@ -60,140 +60,43 @@ func (gm *GPUManager) collectIntelStats() (err error) {
 		return err
 	}
 
-	// Ensure we always reap the child to avoid zombies on any return path and
-	// propagate a non-zero exit code if no other error was set.
-	defer func() {
-		// Best-effort close of the pipe (unblock the child if it writes)
-		_ = stdout.Close()
-		if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
-			_ = cmd.Process.Kill()
-		}
-		if waitErr := cmd.Wait(); err == nil && waitErr != nil {
-			err = waitErr
-		}
-	}()
+	dec := json.NewDecoder(stdout)
 
-	scanner := bufio.NewScanner(stdout)
-	var header1 string
-	var engineNames []string
-	var friendlyNames []string
-	var preEngineCols int
-	var powerIndex int
-	var hadDataRow bool
-	// skip first data row because it sometimes has erroneous data
-	var skippedFirstDataRow bool
+	// Expect a JSON array stream: [ { ... }, { ... }, ... ]
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	if delim, ok := tok.(json.Delim); !ok || delim != '[' {
+		return fmt.Errorf("unexpected JSON start token: %v", tok)
+	}
 
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" {
+	var sample intelGpuStats
+	for {
+		if dec.More() {
+			// Clear the engines map before decoding
+			if sample.Engines != nil {
+				for k := range sample.Engines {
+					delete(sample.Engines, k)
+				}
+			}
+
+			if err := dec.Decode(&sample); err != nil {
+				return fmt.Errorf("decode intel gpu: %w", err)
+			}
+			gm.updateIntelFromStats(&sample)
 			continue
 		}
-
-		// first header line
-		if strings.HasPrefix(line, "Freq") {
-			header1 = line
-			continue
-		}
-
-		// second header line
-		if strings.HasPrefix(line, "req") {
-			engineNames, friendlyNames, powerIndex, preEngineCols = gm.parseIntelHeaders(header1, line)
-			continue
-		}
-
-		// Data row
-		if !skippedFirstDataRow {
-			skippedFirstDataRow = true
-			continue
-		}
-		sample, err := gm.parseIntelData(line, engineNames, friendlyNames, powerIndex, preEngineCols)
+		// Attempt to read closing bracket (will only be present when process exits)
+		tok, err = dec.Token()
 		if err != nil {
+			// When the process is still running, decoder will block in More/Decode; any error here is terminal
 			return err
 		}
-		hadDataRow = true
-		gm.updateIntelFromStats(&sample)
+		if delim, ok := tok.(json.Delim); ok && delim == ']' {
+			break
+		}
 	}
-	if scanErr := scanner.Err(); scanErr != nil {
-		return scanErr
-	}
-	if !hadDataRow {
-		return errNoValidData
-	}
-	return nil
-}
 
-func (gm *GPUManager) parseIntelHeaders(header1 string, header2 string) (engineNames []string, friendlyNames []string, powerIndex int, preEngineCols int) {
-	// Build indexes
-	h1 := strings.Fields(header1)
-	h2 := strings.Fields(header2)
-	powerIndex = -1 // Initialize to -1, will be set to actual index if found
-	// Collect engine names from header1
-	for _, col := range h1 {
-		key := strings.TrimRightFunc(col, func(r rune) bool { return r >= '0' && r <= '9' })
-		var friendly string
-		switch key {
-		case "RCS":
-			friendly = "Render/3D"
-		case "BCS":
-			friendly = "Blitter"
-		case "VCS":
-			friendly = "Video"
-		case "VECS":
-			friendly = "VideoEnhance"
-		case "CCS":
-			friendly = "Compute"
-		default:
-			continue
-		}
-		engineNames = append(engineNames, key)
-		friendlyNames = append(friendlyNames, friendly)
-	}
-	// find power gpu index among pre-engine columns
-	if n := len(engineNames); n > 0 {
-		preEngineCols = max(len(h2)-3*n, 0)
-		limit := min(len(h2), preEngineCols)
-		for i := range limit {
-			if strings.EqualFold(h2[i], "gpu") {
-				powerIndex = i
-				break
-			}
-		}
-	}
-	return engineNames, friendlyNames, powerIndex, preEngineCols
-}
-
-func (gm *GPUManager) parseIntelData(line string, engineNames []string, friendlyNames []string, powerIndex int, preEngineCols int) (sample intelGpuStats, err error) {
-	fields := strings.Fields(line)
-	if len(fields) == 0 {
-		return sample, errNoValidData
-	}
-	// Make sure row has enough columns for engines
-	if need := preEngineCols + 3*len(engineNames); len(fields) < need {
-		return sample, errNoValidData
-	}
-	if powerIndex >= 0 && powerIndex < len(fields) {
-		if v, perr := strconv.ParseFloat(fields[powerIndex], 64); perr == nil {
-			sample.PowerGPU = v
-		}
-		if v, perr := strconv.ParseFloat(fields[powerIndex+1], 64); perr == nil {
-			sample.PowerPkg = v
-		}
-	}
-	if len(engineNames) > 0 {
-		sample.Engines = make(map[string]float64, len(engineNames))
-		for k := range engineNames {
-			base := preEngineCols + 3*k
-			if base < len(fields) {
-				busy := 0.0
-				if v, e := strconv.ParseFloat(fields[base], 64); e == nil {
-					busy = v
-				}
-				cur := sample.Engines[friendlyNames[k]]
-				sample.Engines[friendlyNames[k]] = cur + busy
-			} else {
-				sample.Engines[friendlyNames[k]] = 0
-			}
-		}
-	}
-	return sample, nil
+	return cmd.Wait()
 }

agent/gpu_test.go

@@ -332,7 +332,7 @@ func TestParseJetsonData(t *testing.T) {
 }
 
 func TestGetCurrentData(t *testing.T) {
-	t.Run("calculates averages with per-cache-key delta tracking", func(t *testing.T) {
+	t.Run("calculates averages and resets accumulators", func(t *testing.T) {
 		gm := &GPUManager{
 			GpuDataMap: map[string]*system.GPUData{
 				"0": {
@@ -365,8 +365,7 @@ func TestGetCurrentData(t *testing.T) {
 			},
 		}
 
-		cacheKey := uint16(5000)
-		result := gm.GetCurrentData(cacheKey)
+		result := gm.GetCurrentData()
 
 		// Verify name disambiguation
 		assert.Equal(t, "GPU1 0", result["0"].Name)
@@ -379,19 +378,13 @@ func TestGetCurrentData(t *testing.T) {
 		assert.InDelta(t, 30.0, result["1"].Usage, 0.01)
 		assert.InDelta(t, 60.0, result["1"].Power, 0.01)
 
-		// Verify that accumulators in the original map are NOT reset (they keep growing)
-		assert.EqualValues(t, 2, gm.GpuDataMap["0"].Count, "GPU 0 Count should remain at 2")
-		assert.EqualValues(t, 100, gm.GpuDataMap["0"].Usage, "GPU 0 Usage should remain at 100")
-		assert.Equal(t, 200.0, gm.GpuDataMap["0"].Power, "GPU 0 Power should remain at 200")
-		assert.Equal(t, 1.0, gm.GpuDataMap["1"].Count, "GPU 1 Count should remain at 1")
-		assert.Equal(t, 30.0, gm.GpuDataMap["1"].Usage, "GPU 1 Usage should remain at 30")
-		assert.Equal(t, 60.0, gm.GpuDataMap["1"].Power, "GPU 1 Power should remain at 60")
-
-		// Verify snapshots were stored for this cache key
-		assert.NotNil(t, gm.lastSnapshots[cacheKey]["0"])
-		assert.Equal(t, uint32(2), gm.lastSnapshots[cacheKey]["0"].count)
-		assert.Equal(t, 100.0, gm.lastSnapshots[cacheKey]["0"].usage)
-		assert.Equal(t, 200.0, gm.lastSnapshots[cacheKey]["0"].power)
+		// Verify that accumulators in the original map are reset
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Count, "GPU 0 Count should be reset")
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Usage, "GPU 0 Usage should be reset")
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Power, "GPU 0 Power should be reset")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Count, "GPU 1 Count should be reset")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Usage, "GPU 1 Usage should be reset")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Power, "GPU 1 Power should be reset")
 	})
 
 	t.Run("handles zero count without panicking", func(t *testing.T) {
@@ -406,543 +399,17 @@ func TestGetCurrentData(t *testing.T) {
 			},
 		}
 
-		cacheKey := uint16(5000)
 		var result map[string]system.GPUData
 		assert.NotPanics(t, func() {
-			result = gm.GetCurrentData(cacheKey)
+			result = gm.GetCurrentData()
 		})
 
 		// Check that usage and power are 0
 		assert.Equal(t, 0.0, result["0"].Usage)
 		assert.Equal(t, 0.0, result["0"].Power)
 
-		// Verify count remains 0
-		assert.EqualValues(t, 0, gm.GpuDataMap["0"].Count)
-	})
-
-	t.Run("uses last average when no new data arrives", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {
-					Name:        "TestGPU",
-					Temperature: 55.0,
-					MemoryUsed:  1500,
-					MemoryTotal: 8000,
-					Usage:       100, // Will average to 50
-					Power:       200, // Will average to 100
-					Count:       2,
-				},
-			},
-		}
-
-		cacheKey := uint16(5000)
-
-		// First collection - should calculate averages and store them
-		result1 := gm.GetCurrentData(cacheKey)
-		assert.InDelta(t, 50.0, result1["0"].Usage, 0.01)
-		assert.InDelta(t, 100.0, result1["0"].Power, 0.01)
-		assert.EqualValues(t, 2, gm.GpuDataMap["0"].Count, "Count should remain at 2")
-
-		// Update temperature but no new usage/power data (count stays same)
-		gm.GpuDataMap["0"].Temperature = 60.0
-		gm.GpuDataMap["0"].MemoryUsed = 1600
-
-		// Second collection - should use last averages since count hasn't changed (delta = 0)
-		result2 := gm.GetCurrentData(cacheKey)
-		assert.InDelta(t, 50.0, result2["0"].Usage, 0.01, "Should use last average")
-		assert.InDelta(t, 100.0, result2["0"].Power, 0.01, "Should use last average")
-		assert.InDelta(t, 60.0, result2["0"].Temperature, 0.01, "Should use current temperature")
-		assert.InDelta(t, 1600.0, result2["0"].MemoryUsed, 0.01, "Should use current memory")
-		assert.EqualValues(t, 2, gm.GpuDataMap["0"].Count, "Count should still be 2")
-	})
-
-	t.Run("tracks separate averages per cache key", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {
-					Name:        "TestGPU",
-					Temperature: 55.0,
-					MemoryUsed:  1500,
-					MemoryTotal: 8000,
-					Usage:       100, // Initial: 100 over 2 counts = 50 avg
-					Power:       200, // Initial: 200 over 2 counts = 100 avg
-					Count:       2,
-				},
-			},
-		}
-
-		cacheKey1 := uint16(5000)
-		cacheKey2 := uint16(10000)
-
-		// First check with cacheKey1 - baseline
-		result1 := gm.GetCurrentData(cacheKey1)
-		assert.InDelta(t, 50.0, result1["0"].Usage, 0.01, "CacheKey1: Initial average should be 50")
-		assert.InDelta(t, 100.0, result1["0"].Power, 0.01, "CacheKey1: Initial average should be 100")
-
-		// Simulate GPU activity - accumulate more data
-		gm.GpuDataMap["0"].Usage += 60  // Now total: 160
-		gm.GpuDataMap["0"].Power += 150 // Now total: 350
-		gm.GpuDataMap["0"].Count += 3   // Now total: 5
-
-		// Check with cacheKey1 again - should get delta since last cacheKey1 check
-		result2 := gm.GetCurrentData(cacheKey1)
-		assert.InDelta(t, 20.0, result2["0"].Usage, 0.01, "CacheKey1: Delta average should be 60/3 = 20")
-		assert.InDelta(t, 50.0, result2["0"].Power, 0.01, "CacheKey1: Delta average should be 150/3 = 50")
-
-		// Check with cacheKey2 for the first time - should get average since beginning
-		result3 := gm.GetCurrentData(cacheKey2)
-		assert.InDelta(t, 32.0, result3["0"].Usage, 0.01, "CacheKey2: Total average should be 160/5 = 32")
-		assert.InDelta(t, 70.0, result3["0"].Power, 0.01, "CacheKey2: Total average should be 350/5 = 70")
-
-		// Simulate more GPU activity
-		gm.GpuDataMap["0"].Usage += 80  // Now total: 240
-		gm.GpuDataMap["0"].Power += 160 // Now total: 510
-		gm.GpuDataMap["0"].Count += 2   // Now total: 7
-
-		// Check with cacheKey1 - should get delta since last cacheKey1 check
-		result4 := gm.GetCurrentData(cacheKey1)
-		assert.InDelta(t, 40.0, result4["0"].Usage, 0.01, "CacheKey1: New delta average should be 80/2 = 40")
-		assert.InDelta(t, 80.0, result4["0"].Power, 0.01, "CacheKey1: New delta average should be 160/2 = 80")
-
-		// Check with cacheKey2 - should get delta since last cacheKey2 check
-		result5 := gm.GetCurrentData(cacheKey2)
-		assert.InDelta(t, 40.0, result5["0"].Usage, 0.01, "CacheKey2: Delta average should be 80/2 = 40")
-		assert.InDelta(t, 80.0, result5["0"].Power, 0.01, "CacheKey2: Delta average should be 160/2 = 80")
-
-		// Verify snapshots exist for both cache keys
-		assert.NotNil(t, gm.lastSnapshots[cacheKey1])
-		assert.NotNil(t, gm.lastSnapshots[cacheKey2])
-		assert.NotNil(t, gm.lastSnapshots[cacheKey1]["0"])
-		assert.NotNil(t, gm.lastSnapshots[cacheKey2]["0"])
-	})
-}
-
-func TestCalculateDeltaCount(t *testing.T) {
-	gm := &GPUManager{}
-
-	t.Run("with no previous snapshot", func(t *testing.T) {
-		delta := gm.calculateDeltaCount(10, nil)
-		assert.Equal(t, uint32(10), delta, "Should return current count when no snapshot exists")
-	})
-
-	t.Run("with previous snapshot", func(t *testing.T) {
-		snapshot := &gpuSnapshot{count: 5}
-		delta := gm.calculateDeltaCount(15, snapshot)
-		assert.Equal(t, uint32(10), delta, "Should return difference between current and snapshot")
-	})
-
-	t.Run("with same count", func(t *testing.T) {
-		snapshot := &gpuSnapshot{count: 10}
-		delta := gm.calculateDeltaCount(10, snapshot)
-		assert.Equal(t, uint32(0), delta, "Should return zero when count hasn't changed")
-	})
-}
-
-func TestCalculateDeltas(t *testing.T) {
-	gm := &GPUManager{}
-
-	t.Run("with no previous snapshot", func(t *testing.T) {
-		gpu := &system.GPUData{
-			Usage:    100.5,
-			Power:    250.75,
-			PowerPkg: 300.25,
-		}
-		deltaUsage, deltaPower, deltaPowerPkg := gm.calculateDeltas(gpu, nil)
-		assert.Equal(t, 100.5, deltaUsage)
-		assert.Equal(t, 250.75, deltaPower)
-		assert.Equal(t, 300.25, deltaPowerPkg)
-	})
-
-	t.Run("with previous snapshot", func(t *testing.T) {
-		gpu := &system.GPUData{
-			Usage:    150.5,
-			Power:    300.75,
-			PowerPkg: 400.25,
-		}
-		snapshot := &gpuSnapshot{
-			usage:    100.5,
-			power:    250.75,
-			powerPkg: 300.25,
-		}
-		deltaUsage, deltaPower, deltaPowerPkg := gm.calculateDeltas(gpu, snapshot)
-		assert.InDelta(t, 50.0, deltaUsage, 0.01)
-		assert.InDelta(t, 50.0, deltaPower, 0.01)
-		assert.InDelta(t, 100.0, deltaPowerPkg, 0.01)
-	})
-}
-
-func TestCalculateIntelGPUUsage(t *testing.T) {
-	gm := &GPUManager{}
-
-	t.Run("with no previous snapshot", func(t *testing.T) {
-		gpuAvg := &system.GPUData{
-			Engines: make(map[string]float64),
-		}
-		gpu := &system.GPUData{
-			Engines: map[string]float64{
-				"Render/3D": 80.0,
-				"Video":     40.0,
-				"Compute":   60.0,
-			},
-		}
-		maxUsage := gm.calculateIntelGPUUsage(gpuAvg, gpu, nil, 2)
-
-		assert.Equal(t, 40.0, maxUsage, "Should return max engine usage (80/2=40)")
-		assert.Equal(t, 40.0, gpuAvg.Engines["Render/3D"])
-		assert.Equal(t, 20.0, gpuAvg.Engines["Video"])
-		assert.Equal(t, 30.0, gpuAvg.Engines["Compute"])
-	})
-
-	t.Run("with previous snapshot", func(t *testing.T) {
-		gpuAvg := &system.GPUData{
-			Engines: make(map[string]float64),
-		}
-		gpu := &system.GPUData{
-			Engines: map[string]float64{
-				"Render/3D": 180.0,
-				"Video":     100.0,
-				"Compute":   140.0,
-			},
-		}
-		snapshot := &gpuSnapshot{
-			engines: map[string]float64{
-				"Render/3D": 80.0,
-				"Video":     40.0,
-				"Compute":   60.0,
-			},
-		}
-		maxUsage := gm.calculateIntelGPUUsage(gpuAvg, gpu, snapshot, 5)
-
-		// Deltas: Render/3D=100, Video=60, Compute=80 over 5 counts
-		assert.Equal(t, 20.0, maxUsage, "Should return max engine delta (100/5=20)")
-		assert.Equal(t, 20.0, gpuAvg.Engines["Render/3D"])
-		assert.Equal(t, 12.0, gpuAvg.Engines["Video"])
-		assert.Equal(t, 16.0, gpuAvg.Engines["Compute"])
-	})
-
-	t.Run("handles missing engine in snapshot", func(t *testing.T) {
-		gpuAvg := &system.GPUData{
-			Engines: make(map[string]float64),
-		}
-		gpu := &system.GPUData{
-			Engines: map[string]float64{
-				"Render/3D": 100.0,
-				"NewEngine": 50.0,
-			},
-		}
-		snapshot := &gpuSnapshot{
-			engines: map[string]float64{
-				"Render/3D": 80.0,
-				// NewEngine doesn't exist in snapshot
-			},
-		}
-		maxUsage := gm.calculateIntelGPUUsage(gpuAvg, gpu, snapshot, 2)
-
-		assert.Equal(t, 25.0, maxUsage)
-		assert.Equal(t, 10.0, gpuAvg.Engines["Render/3D"], "Should use delta for existing engine")
-		assert.Equal(t, 25.0, gpuAvg.Engines["NewEngine"], "Should use full value for new engine")
-	})
-}
-
-func TestUpdateInstantaneousValues(t *testing.T) {
-	gm := &GPUManager{}
-
-	t.Run("updates temperature, memory used and total", func(t *testing.T) {
-		gpuAvg := &system.GPUData{
-			Temperature: 50.123,
-			MemoryUsed:  1000.456,
-			MemoryTotal: 8000.789,
-		}
-		gpu := &system.GPUData{
-			Temperature: 75.567,
-			MemoryUsed:  2500.891,
-			MemoryTotal: 8192.234,
-		}
-
-		gm.updateInstantaneousValues(gpuAvg, gpu)
-
-		assert.Equal(t, 75.57, gpuAvg.Temperature, "Should update and round temperature")
-		assert.Equal(t, 2500.89, gpuAvg.MemoryUsed, "Should update and round memory used")
-		assert.Equal(t, 8192.23, gpuAvg.MemoryTotal, "Should update and round memory total")
-	})
-}
-
-func TestStoreSnapshot(t *testing.T) {
-	gm := &GPUManager{
-		lastSnapshots: make(map[uint16]map[string]*gpuSnapshot),
-	}
-
-	t.Run("stores standard GPU snapshot", func(t *testing.T) {
-		cacheKey := uint16(5000)
-		gm.lastSnapshots[cacheKey] = make(map[string]*gpuSnapshot)
-
-		gpu := &system.GPUData{
-			Count:    10.0,
-			Usage:    150.5,
-			Power:    250.75,
-			PowerPkg: 300.25,
-		}
-
-		gm.storeSnapshot("0", gpu, cacheKey)
-
-		snapshot := gm.lastSnapshots[cacheKey]["0"]
-		assert.NotNil(t, snapshot)
-		assert.Equal(t, uint32(10), snapshot.count)
-		assert.Equal(t, 150.5, snapshot.usage)
-		assert.Equal(t, 250.75, snapshot.power)
-		assert.Equal(t, 300.25, snapshot.powerPkg)
-		assert.Nil(t, snapshot.engines, "Should not have engines for standard GPU")
-	})
-
-	t.Run("stores Intel GPU snapshot with engines", func(t *testing.T) {
-		cacheKey := uint16(10000)
-		gm.lastSnapshots[cacheKey] = make(map[string]*gpuSnapshot)
-
-		gpu := &system.GPUData{
-			Count:    5.0,
-			Usage:    100.0,
-			Power:    200.0,
-			PowerPkg: 250.0,
-			Engines: map[string]float64{
-				"Render/3D": 80.0,
-				"Video":     40.0,
-			},
-		}
-
-		gm.storeSnapshot("0", gpu, cacheKey)
-
-		snapshot := gm.lastSnapshots[cacheKey]["0"]
-		assert.NotNil(t, snapshot)
-		assert.Equal(t, uint32(5), snapshot.count)
-		assert.NotNil(t, snapshot.engines, "Should have engines for Intel GPU")
-		assert.Equal(t, 80.0, snapshot.engines["Render/3D"])
-		assert.Equal(t, 40.0, snapshot.engines["Video"])
-		assert.Len(t, snapshot.engines, 2)
-	})
-
-	t.Run("overwrites existing snapshot", func(t *testing.T) {
-		cacheKey := uint16(5000)
-		gm.lastSnapshots[cacheKey] = make(map[string]*gpuSnapshot)
-
-		// Store initial snapshot
-		gpu1 := &system.GPUData{Count: 5.0, Usage: 100.0, Power: 200.0}
-		gm.storeSnapshot("0", gpu1, cacheKey)
-
-		// Store updated snapshot
-		gpu2 := &system.GPUData{Count: 10.0, Usage: 250.0, Power: 400.0}
-		gm.storeSnapshot("0", gpu2, cacheKey)
-
-		snapshot := gm.lastSnapshots[cacheKey]["0"]
-		assert.Equal(t, uint32(10), snapshot.count, "Should overwrite previous count")
-		assert.Equal(t, 250.0, snapshot.usage, "Should overwrite previous usage")
-		assert.Equal(t, 400.0, snapshot.power, "Should overwrite previous power")
-	})
-}
-
-func TestCountGPUNames(t *testing.T) {
-	t.Run("returns empty map for no GPUs", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: make(map[string]*system.GPUData),
-		}
-		counts := gm.countGPUNames()
-		assert.Empty(t, counts)
-	})
-
-	t.Run("counts unique GPU names", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {Name: "GPU A"},
-				"1": {Name: "GPU B"},
-				"2": {Name: "GPU C"},
-			},
-		}
-		counts := gm.countGPUNames()
-		assert.Equal(t, 1, counts["GPU A"])
-		assert.Equal(t, 1, counts["GPU B"])
-		assert.Equal(t, 1, counts["GPU C"])
-		assert.Len(t, counts, 3)
-	})
-
-	t.Run("counts duplicate GPU names", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {Name: "RTX 4090"},
-				"1": {Name: "RTX 4090"},
-				"2": {Name: "RTX 4090"},
-				"3": {Name: "RTX 3080"},
-			},
-		}
-		counts := gm.countGPUNames()
-		assert.Equal(t, 3, counts["RTX 4090"])
-		assert.Equal(t, 1, counts["RTX 3080"])
-		assert.Len(t, counts, 2)
-	})
-}
-
-func TestInitializeSnapshots(t *testing.T) {
-	t.Run("initializes all maps from scratch", func(t *testing.T) {
-		gm := &GPUManager{}
-		cacheKey := uint16(5000)
-
-		gm.initializeSnapshots(cacheKey)
-
-		assert.NotNil(t, gm.lastAvgData)
-		assert.NotNil(t, gm.lastSnapshots)
-		assert.NotNil(t, gm.lastSnapshots[cacheKey])
-	})
-
-	t.Run("initializes only missing maps", func(t *testing.T) {
-		gm := &GPUManager{
-			lastAvgData: make(map[string]system.GPUData),
-		}
-		cacheKey := uint16(5000)
-
-		gm.initializeSnapshots(cacheKey)
-
-		assert.NotNil(t, gm.lastAvgData, "Should preserve existing lastAvgData")
-		assert.NotNil(t, gm.lastSnapshots)
-		assert.NotNil(t, gm.lastSnapshots[cacheKey])
-	})
-
-	t.Run("adds new cache key to existing snapshots", func(t *testing.T) {
-		existingKey := uint16(5000)
-		newKey := uint16(10000)
-
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				existingKey: {"0": {count: 10}},
-			},
-		}
-
-		gm.initializeSnapshots(newKey)
-
-		assert.NotNil(t, gm.lastSnapshots[existingKey], "Should preserve existing cache key")
-		assert.NotNil(t, gm.lastSnapshots[newKey], "Should add new cache key")
-		assert.NotNil(t, gm.lastSnapshots[existingKey]["0"], "Should preserve existing snapshot data")
-	})
-}
-
-func TestCalculateGPUAverage(t *testing.T) {
-	t.Run("returns zero value when deltaCount is zero", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {
-					"0": {count: 10, usage: 100, power: 200},
-				},
-			},
-			lastAvgData: map[string]system.GPUData{
-				"0": {Usage: 50.0, Power: 100.0},
-			},
-		}
-
-		gpu := &system.GPUData{
-			Count: 10.0, // Same as snapshot, so delta = 0
-			Usage: 100.0,
-			Power: 200.0,
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, 50.0, result.Usage, "Should return cached average")
-		assert.Equal(t, 100.0, result.Power, "Should return cached average")
-	})
-
-	t.Run("calculates average for standard GPU", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {},
-			},
-			lastAvgData: make(map[string]system.GPUData),
-		}
-
-		gpu := &system.GPUData{
-			Name:  "Test GPU",
-			Count: 4.0,
-			Usage: 200.0, // 200 / 4 = 50
-			Power: 400.0, // 400 / 4 = 100
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, 50.0, result.Usage)
-		assert.Equal(t, 100.0, result.Power)
-		assert.Equal(t, "Test GPU", result.Name)
-	})
-
-	t.Run("calculates average for Intel GPU with engines", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {},
-			},
-			lastAvgData: make(map[string]system.GPUData),
-		}
-
-		gpu := &system.GPUData{
-			Name:     "Intel GPU",
-			Count:    5.0,
-			Power:    500.0,
-			PowerPkg: 600.0,
-			Engines: map[string]float64{
-				"Render/3D": 100.0, // 100 / 5 = 20
-				"Video":     50.0,  // 50 / 5 = 10
-			},
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, 100.0, result.Power)
-		assert.Equal(t, 120.0, result.PowerPkg)
-		assert.Equal(t, 20.0, result.Usage, "Should use max engine usage")
-		assert.Equal(t, 20.0, result.Engines["Render/3D"])
-		assert.Equal(t, 10.0, result.Engines["Video"])
-	})
-
-	t.Run("calculates delta from previous snapshot", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {
-					"0": {
-						count:    2,
-						usage:    50.0,
-						power:    100.0,
-						powerPkg: 120.0,
-					},
-				},
-			},
-			lastAvgData: make(map[string]system.GPUData),
-		}
-
-		gpu := &system.GPUData{
-			Name:     "Test GPU",
-			Count:    7.0,   // Delta = 7 - 2 = 5
-			Usage:    200.0, // Delta = 200 - 50 = 150, avg = 150/5 = 30
-			Power:    350.0, // Delta = 350 - 100 = 250, avg = 250/5 = 50
-			PowerPkg: 420.0, // Delta = 420 - 120 = 300, avg = 300/5 = 60
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, 30.0, result.Usage)
-		assert.Equal(t, 50.0, result.Power)
-	})
-
-	t.Run("stores result in lastAvgData", func(t *testing.T) {
-		gm := &GPUManager{
-			lastSnapshots: map[uint16]map[string]*gpuSnapshot{
-				5000: {},
-			},
-			lastAvgData: make(map[string]system.GPUData),
-		}
-
-		gpu := &system.GPUData{
-			Count: 2.0,
-			Usage: 100.0,
-			Power: 200.0,
-		}
-
-		result := gm.calculateGPUAverage("0", gpu, 5000)
-
-		assert.Equal(t, result, gm.lastAvgData["0"], "Should store calculated average")
+		// Verify reset count
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Count)
 	})
 }
 
@@ -1289,17 +756,16 @@ func TestAccumulation(t *testing.T) {
 					continue
 				}
 
-				assert.EqualValues(t, expected.temperature, gpu.Temperature, "Temperature should match")
-				assert.EqualValues(t, expected.memoryUsed, gpu.MemoryUsed, "Memory used should match")
-				assert.EqualValues(t, expected.memoryTotal, gpu.MemoryTotal, "Memory total should match")
-				assert.EqualValues(t, expected.usage, gpu.Usage, "Usage should match")
-				assert.EqualValues(t, expected.power, gpu.Power, "Power should match")
+				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature should match")
+				assert.InDelta(t, expected.memoryUsed, gpu.MemoryUsed, 0.01, "Memory used should match")
+				assert.InDelta(t, expected.memoryTotal, gpu.MemoryTotal, 0.01, "Memory total should match")
+				assert.InDelta(t, expected.usage, gpu.Usage, 0.01, "Usage should match")
+				assert.InDelta(t, expected.power, gpu.Power, 0.01, "Power should match")
 				assert.Equal(t, expected.count, gpu.Count, "Count should match")
 			}
 
 			// Verify average calculation in GetCurrentData
-			cacheKey := uint16(5000)
-			result := gm.GetCurrentData(cacheKey)
+			result := gm.GetCurrentData()
 			for id, expected := range tt.expectedValues {
 				gpu, exists := result[id]
 				assert.True(t, exists, "GPU with ID %s should exist in GetCurrentData result", id)
@@ -1307,21 +773,21 @@ func TestAccumulation(t *testing.T) {
 					continue
 				}
 
-				assert.EqualValues(t, expected.temperature, gpu.Temperature, "Temperature in GetCurrentData should match")
-				assert.EqualValues(t, expected.avgUsage, gpu.Usage, "Average usage in GetCurrentData should match")
-				assert.EqualValues(t, expected.avgPower, gpu.Power, "Average power in GetCurrentData should match")
+				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature in GetCurrentData should match")
+				assert.InDelta(t, expected.avgUsage, gpu.Usage, 0.01, "Average usage in GetCurrentData should match")
+				assert.InDelta(t, expected.avgPower, gpu.Power, 0.01, "Average power in GetCurrentData should match")
 			}
 
-			// Verify that accumulators in the original map are NOT reset (they keep growing)
-			for id, expected := range tt.expectedValues {
+			// Verify that accumulators in the original map are reset
+			for id := range tt.expectedValues {
 				gpu, exists := gm.GpuDataMap[id]
 				assert.True(t, exists, "GPU with ID %s should still exist after GetCurrentData", id)
 				if !exists {
 					continue
 				}
-				assert.EqualValues(t, expected.count, gpu.Count, "Count should remain at accumulated value for GPU ID %s", id)
-				assert.EqualValues(t, expected.usage, gpu.Usage, "Usage should remain at accumulated value for GPU ID %s", id)
-				assert.EqualValues(t, expected.power, gpu.Power, "Power should remain at accumulated value for GPU ID %s", id)
+				assert.Equal(t, float64(0), gpu.Count, "Count should be reset for GPU ID %s", id)
+				assert.Equal(t, float64(0), gpu.Usage, "Usage should be reset for GPU ID %s", id)
+				assert.Equal(t, float64(0), gpu.Power, "Power should be reset for GPU ID %s", id)
 			}
 		})
 	}
@@ -1334,12 +800,14 @@ func TestIntelUpdateFromStats(t *testing.T) {
 
 	// First sample with power and two engines
 	sample1 := intelGpuStats{
-		PowerGPU: 10.5,
-		Engines: map[string]float64{
-			"Render/3D": 20.0,
-			"Video":     5.0,
+		Engines: map[string]struct {
+			Busy float64 `json:"busy"`
+		}{
+			"Render/3D": {Busy: 20.0},
+			"Video":     {Busy: 5.0},
 		},
 	}
+	sample1.Power.GPU = 10.5
 
 	ok := gm.updateIntelFromStats(&sample1)
 	assert.True(t, ok)
@@ -1347,31 +815,33 @@ func TestIntelUpdateFromStats(t *testing.T) {
 	gpu := gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
 	assert.Equal(t, "GPU", gpu.Name)
-	assert.EqualValues(t, 10.5, gpu.Power)
-	assert.EqualValues(t, 20.0, gpu.Engines["Render/3D"])
-	assert.EqualValues(t, 5.0, gpu.Engines["Video"])
+	assert.InDelta(t, 10.5, gpu.Power, 0.001)
+	assert.InDelta(t, 20.0, gpu.Engines["Render/3D"], 0.001)
+	assert.InDelta(t, 5.0, gpu.Engines["Video"], 0.001)
 	assert.Equal(t, float64(1), gpu.Count)
 
 	// Second sample with zero power (should not add) and additional engine busy
 	sample2 := intelGpuStats{
-		PowerGPU: 0.0,
-		Engines: map[string]float64{
-			"Render/3D": 10.0,
-			"Video":     2.5,
-			"Blitter":   1.0,
+		Engines: map[string]struct {
+			Busy float64 `json:"busy"`
+		}{
+			"Render/3D": {Busy: 10.0},
+			"Video":     {Busy: 2.5},
+			"Blitter":   {Busy: 1.0},
 		},
 	}
 	// zero power should not increment power accumulator
+	sample2.Power.GPU = 0.0
 
 	ok = gm.updateIntelFromStats(&sample2)
 	assert.True(t, ok)
 
 	gpu = gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
-	assert.EqualValues(t, 10.5, gpu.Power)
-	assert.EqualValues(t, 30.0, gpu.Engines["Render/3D"]) // 20 + 10
-	assert.EqualValues(t, 7.5, gpu.Engines["Video"])      // 5 + 2.5
-	assert.EqualValues(t, 1.0, gpu.Engines["Blitter"])
+	assert.InDelta(t, 10.5, gpu.Power, 0.001)
+	assert.InDelta(t, 30.0, gpu.Engines["Render/3D"], 0.001) // 20 + 10
+	assert.InDelta(t, 7.5, gpu.Engines["Video"], 0.001)      // 5 + 2.5
+	assert.InDelta(t, 1.0, gpu.Engines["Blitter"], 0.001)
 	assert.Equal(t, float64(2), gpu.Count)
 }
 
@@ -1383,15 +853,15 @@ func TestIntelCollectorStreaming(t *testing.T) {
 	dir := t.TempDir()
 	os.Setenv("PATH", dir)
 
-	// Create a fake intel_gpu_top that prints -l format with four samples (first will be skipped) and exits
+	// Create a fake intel_gpu_top that prints a JSON array with two samples and exits
 	scriptPath := filepath.Join(dir, "intel_gpu_top")
 	script := `#!/bin/sh
-echo "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS             BCS             VCS"
-echo " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa       %  se  wa       %  se  wa"
-echo "373  373      224  45  1.50  4.13   2554    714   12.34   0   0    0.00   0   0    5.00   0   0"
-echo "226  223      338  58  2.00  2.69   1820    965   0.00    0   0    0.00   0   0    0.00   0   0"
-echo "189  187      412  67  1.80  2.45   1950    823   8.50    2   1    15.00   1   0    22.00  0   1"
-echo "298  295      278  51  2.20  3.12   1675    942   5.75    1   2    9.50    3   1    12.00  1   0"`
+# Ignore args -s and -J
+# Emit a JSON array with two objects, separated by a comma, then exit
+(echo '['; \
+ echo '{"power":{"GPU":1.5},"engines":{"Render/3D":{"busy":12.34}}},'; \
+ echo '{"power":{"GPU":2.0},"engines":{"Video":{"busy":5}}}'; \
+ echo ']')`
 	if err := os.WriteFile(scriptPath, []byte(script), 0755); err != nil {
 		t.Fatal(err)
 	}
@@ -1400,227 +870,18 @@ echo "298  295      278  51  2.20  3.12   1675    942   5.75    1   2    9.50
 		GpuDataMap: make(map[string]*system.GPUData),
 	}
 
-	// Run the collector once; it should read four samples but skip the first and return
+	// Run the collector once; it should read two samples and return
 	if err := gm.collectIntelStats(); err != nil {
 		t.Fatalf("collectIntelStats error: %v", err)
 	}
 
 	gpu := gm.GpuDataMap["0"]
 	require.NotNil(t, gpu)
-	// Power should be sum of samples 2-4 (first is skipped): 2.0 + 1.8 + 2.2 = 6.0
-	assert.EqualValues(t, 6.0, gpu.Power)
-	assert.InDelta(t, 8.26, gpu.PowerPkg, 0.01) // Allow small floating point differences
-	// Engines aggregated from samples 2-4
-	assert.EqualValues(t, 14.25, gpu.Engines["Render/3D"]) // 0.00 + 8.50 + 5.75
-	assert.EqualValues(t, 34.0, gpu.Engines["Video"])      // 0.00 + 22.00 + 12.00
-	assert.EqualValues(t, 24.5, gpu.Engines["Blitter"])    // 0.00 + 15.00 + 9.50
-	// Count should be 3 samples (first is skipped)
-	assert.Equal(t, float64(3), gpu.Count)
-}
-
-func TestParseIntelHeaders(t *testing.T) {
-	tests := []struct {
-		name              string
-		header1           string
-		header2           string
-		wantEngineNames   []string
-		wantFriendlyNames []string
-		wantPowerIndex    int
-		wantPreEngineCols int
-	}{
-		{
-			name:              "basic headers with RCS BCS VCS",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS             BCS             VCS",
-			header2:           " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa       %  se  wa       %  se  wa",
-			wantEngineNames:   []string{"RCS", "BCS", "VCS"},
-			wantFriendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			wantPowerIndex:    4, // "gpu" is at index 4
-			wantPreEngineCols: 8, // 17 total cols - 3*3 = 8
-		},
-		{
-			name:              "headers with only RCS",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS",
-			header2:           " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa",
-			wantEngineNames:   []string{"RCS"},
-			wantFriendlyNames: []string{"Render/3D"},
-			wantPowerIndex:    4,
-			wantPreEngineCols: 8, // 11 total - 3*1 = 8
-		},
-		{
-			name:              "headers with VECS and CCS",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s             VECS            CCS",
-			header2:           " req  act       /s   %   gpu   pkg     rd     wr       %  se  wa     %  se  wa",
-			wantEngineNames:   []string{"VECS", "CCS"},
-			wantFriendlyNames: []string{"VideoEnhance", "Compute"},
-			wantPowerIndex:    4,
-			wantPreEngineCols: 8, // 14 total - 3*2 = 8
-		},
-		{
-			name:              "no engines",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s",
-			header2:           " req  act       /s   %   gpu   pkg     rd     wr",
-			wantEngineNames:   nil, // no engines found, slices remain nil
-			wantFriendlyNames: nil,
-			wantPowerIndex:    -1, // no engines, so no search
-			wantPreEngineCols: 0,
-		},
-		{
-			name:              "power index not found",
-			header1:           "Freq MHz      IRQ RC6     Power W     IMC MiB/s             RCS",
-			header2:           " req  act       /s   %   pkg   cpu     rd     wr       %  se  wa", // no "gpu"
-			wantEngineNames:   []string{"RCS"},
-			wantFriendlyNames: []string{"Render/3D"},
-			wantPowerIndex:    -1, // "gpu" not found
-			wantPreEngineCols: 8,  // 11 total - 3*1 = 8
-		},
-		{
-			name:              "empty headers",
-			header1:           "",
-			header2:           "",
-			wantEngineNames:   nil, // empty input, slices remain nil
-			wantFriendlyNames: nil,
-			wantPowerIndex:    -1,
-			wantPreEngineCols: 0,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := &GPUManager{}
-			engineNames, friendlyNames, powerIndex, preEngineCols := gm.parseIntelHeaders(tt.header1, tt.header2)
-
-			assert.Equal(t, tt.wantEngineNames, engineNames)
-			assert.Equal(t, tt.wantFriendlyNames, friendlyNames)
-			assert.Equal(t, tt.wantPowerIndex, powerIndex)
-			assert.Equal(t, tt.wantPreEngineCols, preEngineCols)
-		})
-	}
-}
-
-func TestParseIntelData(t *testing.T) {
-	tests := []struct {
-		name          string
-		line          string
-		engineNames   []string
-		friendlyNames []string
-		powerIndex    int
-		preEngineCols int
-		wantPowerGPU  float64
-		wantEngines   map[string]float64
-		wantErr       error
-	}{
-		{
-			name:          "basic data with power and engines",
-			line:          "373  373      224  45  1.50  4.13   2554    714   12.34   0   0    0.00   0   0    5.00   0   0",
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  1.50,
-			wantEngines: map[string]float64{
-				"Render/3D": 12.34,
-				"Blitter":   0.00,
-				"Video":     5.00,
-			},
-		},
-		{
-			name:          "data with zero power",
-			line:          "226  223      338  58  0.00  2.69   1820    965   0.00    0   0    0.00   0   0    0.00   0   0",
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  0.00,
-			wantEngines: map[string]float64{
-				"Render/3D": 0.00,
-				"Blitter":   0.00,
-				"Video":     0.00,
-			},
-		},
-		{
-			name:          "data with no power index",
-			line:          "373  373      224  45  1.50  4.13   2554    714   12.34   0   0    0.00   0   0    5.00   0   0",
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    -1,
-			preEngineCols: 8,
-			wantPowerGPU:  0.0, // no power parsed
-			wantEngines: map[string]float64{
-				"Render/3D": 12.34,
-				"Blitter":   0.00,
-				"Video":     5.00,
-			},
-		},
-		{
-			name:          "data with insufficient columns",
-			line:          "373  373      224  45  1.50", // too few columns
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  0.0,
-			wantEngines:   nil, // empty sample returned
-			wantErr:       errNoValidData,
-		},
-		{
-			name:          "empty line",
-			line:          "",
-			engineNames:   []string{"RCS"},
-			friendlyNames: []string{"Render/3D"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  0.0,
-			wantEngines:   nil,
-			wantErr:       errNoValidData,
-		},
-		{
-			name:          "data with invalid power value",
-			line:          "373  373      224  45  N/A  4.13   2554    714   12.34   0   0    0.00   0   0    5.00   0   0",
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  0.0, // N/A can't be parsed
-			wantEngines: map[string]float64{
-				"Render/3D": 12.34,
-				"Blitter":   0.00,
-				"Video":     5.00,
-			},
-		},
-		{
-			name:          "data with invalid engine value",
-			line:          "373  373      224  45  1.50  4.13   2554    714   N/A     0   0    0.00   0   0    5.00   0   0",
-			engineNames:   []string{"RCS", "BCS", "VCS"},
-			friendlyNames: []string{"Render/3D", "Blitter", "Video"},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  1.50,
-			wantEngines: map[string]float64{
-				"Render/3D": 0.0, // N/A becomes 0
-				"Blitter":   0.00,
-				"Video":     5.00,
-			},
-		},
-		{
-			name:          "data with no engines",
-			line:          "373  373      224  45  1.50  4.13   2554    714",
-			engineNames:   []string{},
-			friendlyNames: []string{},
-			powerIndex:    4,
-			preEngineCols: 8,
-			wantPowerGPU:  1.50,
-			wantEngines:   nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := &GPUManager{}
-			sample, err := gm.parseIntelData(tt.line, tt.engineNames, tt.friendlyNames, tt.powerIndex, tt.preEngineCols)
-			assert.Equal(t, tt.wantErr, err)
-
-			assert.Equal(t, tt.wantPowerGPU, sample.PowerGPU)
-			assert.Equal(t, tt.wantEngines, sample.Engines)
-		})
-	}
+	// Power should be sum of non-zero samples: 1.5 + 2.0 = 3.5
+	assert.InDelta(t, 3.5, gpu.Power, 0.001)
+	// Engines aggregated
+	assert.InDelta(t, 12.34, gpu.Engines["Render/3D"], 0.001)
+	assert.InDelta(t, 5.0, gpu.Engines["Video"], 0.001)
+	// Count should be 2 samples
+	assert.Equal(t, float64(2), gpu.Count)
 }

agent/handlers.go

@@ -1,176 +0,0 @@
-package agent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/fxamacker/cbor/v2"
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/smart"
-
-	"golang.org/x/exp/slog"
-)
-
-// HandlerContext provides context for request handlers
-type HandlerContext struct {
-	Client      *WebSocketClient
-	Agent       *Agent
-	Request     *common.HubRequest[cbor.RawMessage]
-	RequestID   *uint32
-	HubVerified bool
-	// SendResponse abstracts how a handler sends responses (WS or SSH)
-	SendResponse func(data any, requestID *uint32) error
-}
-
-// RequestHandler defines the interface for handling specific websocket request types
-type RequestHandler interface {
-	// Handle processes the request and returns an error if unsuccessful
-	Handle(hctx *HandlerContext) error
-}
-
-// Responder sends handler responses back to the hub (over WS or SSH)
-type Responder interface {
-	SendResponse(data any, requestID *uint32) error
-}
-
-// HandlerRegistry manages the mapping between actions and their handlers
-type HandlerRegistry struct {
-	handlers map[common.WebSocketAction]RequestHandler
-}
-
-// NewHandlerRegistry creates a new handler registry with default handlers
-func NewHandlerRegistry() *HandlerRegistry {
-	registry := &HandlerRegistry{
-		handlers: make(map[common.WebSocketAction]RequestHandler),
-	}
-
-	registry.Register(common.GetData, &GetDataHandler{})
-	registry.Register(common.CheckFingerprint, &CheckFingerprintHandler{})
-	registry.Register(common.GetContainerLogs, &GetContainerLogsHandler{})
-	registry.Register(common.GetContainerInfo, &GetContainerInfoHandler{})
-	registry.Register(common.GetSmartData, &GetSmartDataHandler{})
-
-	return registry
-}
-
-// Register registers a handler for a specific action type
-func (hr *HandlerRegistry) Register(action common.WebSocketAction, handler RequestHandler) {
-	hr.handlers[action] = handler
-}
-
-// Handle routes the request to the appropriate handler
-func (hr *HandlerRegistry) Handle(hctx *HandlerContext) error {
-	handler, exists := hr.handlers[hctx.Request.Action]
-	if !exists {
-		return fmt.Errorf("unknown action: %d", hctx.Request.Action)
-	}
-
-	// Check verification requirement - default to requiring verification
-	if hctx.Request.Action != common.CheckFingerprint && !hctx.HubVerified {
-		return errors.New("hub not verified")
-	}
-
-	// Log handler execution for debugging
-	// slog.Debug("Executing handler", "action", hctx.Request.Action)
-
-	return handler.Handle(hctx)
-}
-
-// GetHandler returns the handler for a specific action
-func (hr *HandlerRegistry) GetHandler(action common.WebSocketAction) (RequestHandler, bool) {
-	handler, exists := hr.handlers[action]
-	return handler, exists
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetDataHandler handles system data requests
-type GetDataHandler struct{}
-
-func (h *GetDataHandler) Handle(hctx *HandlerContext) error {
-	var options common.DataRequestOptions
-	_ = cbor.Unmarshal(hctx.Request.Data, &options)
-
-	sysStats := hctx.Agent.gatherStats(options.CacheTimeMs)
-	return hctx.SendResponse(sysStats, hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// CheckFingerprintHandler handles authentication challenges
-type CheckFingerprintHandler struct{}
-
-func (h *CheckFingerprintHandler) Handle(hctx *HandlerContext) error {
-	return hctx.Client.handleAuthChallenge(hctx.Request, hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetContainerLogsHandler handles container log requests
-type GetContainerLogsHandler struct{}
-
-func (h *GetContainerLogsHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.dockerManager == nil {
-		return hctx.SendResponse("", hctx.RequestID)
-	}
-
-	var req common.ContainerLogsRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-	logContent, err := hctx.Agent.dockerManager.getLogs(ctx, req.ContainerID)
-	if err != nil {
-		return err
-	}
-
-	return hctx.SendResponse(logContent, hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetContainerInfoHandler handles container info requests
-type GetContainerInfoHandler struct{}
-
-func (h *GetContainerInfoHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.dockerManager == nil {
-		return hctx.SendResponse("", hctx.RequestID)
-	}
-
-	var req common.ContainerInfoRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-	info, err := hctx.Agent.dockerManager.getContainerInfo(ctx, req.ContainerID)
-	if err != nil {
-		return err
-	}
-
-	return hctx.SendResponse(string(info), hctx.RequestID)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// GetSmartDataHandler handles SMART data requests
-type GetSmartDataHandler struct{}
-
-func (h *GetSmartDataHandler) Handle(hctx *HandlerContext) error {
-	if hctx.Agent.smartManager == nil {
-		// return empty map to indicate no data
-		return hctx.SendResponse(map[string]smart.SmartData{}, hctx.RequestID)
-	}
-	if err := hctx.Agent.smartManager.Refresh(); err != nil {
-		slog.Debug("smart refresh failed", "err", err)
-	}
-	data := hctx.Agent.smartManager.GetCurrentData()
-	return hctx.SendResponse(data, hctx.RequestID)
-}

agent/handlers_test.go

@@ -1,112 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"testing"
-
-	"github.com/fxamacker/cbor/v2"
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/stretchr/testify/assert"
-)
-
-// MockHandler for testing
-type MockHandler struct {
-	requiresVerification bool
-	description          string
-	handleFunc           func(ctx *HandlerContext) error
-}
-
-func (m *MockHandler) Handle(ctx *HandlerContext) error {
-	if m.handleFunc != nil {
-		return m.handleFunc(ctx)
-	}
-	return nil
-}
-
-func (m *MockHandler) RequiresVerification() bool {
-	return m.requiresVerification
-}
-
-// TestHandlerRegistry tests the handler registry functionality
-func TestHandlerRegistry(t *testing.T) {
-	t.Run("default registration", func(t *testing.T) {
-		registry := NewHandlerRegistry()
-
-		// Check default handlers are registered
-		getDataHandler, exists := registry.GetHandler(common.GetData)
-		assert.True(t, exists)
-		assert.IsType(t, &GetDataHandler{}, getDataHandler)
-
-		fingerprintHandler, exists := registry.GetHandler(common.CheckFingerprint)
-		assert.True(t, exists)
-		assert.IsType(t, &CheckFingerprintHandler{}, fingerprintHandler)
-	})
-
-	t.Run("custom handler registration", func(t *testing.T) {
-		registry := NewHandlerRegistry()
-		mockHandler := &MockHandler{
-			requiresVerification: true,
-			description:          "Test handler",
-		}
-
-		// Register a custom handler for a mock action
-		const mockAction common.WebSocketAction = 99
-		registry.Register(mockAction, mockHandler)
-
-		// Verify registration
-		handler, exists := registry.GetHandler(mockAction)
-		assert.True(t, exists)
-		assert.Equal(t, mockHandler, handler)
-	})
-
-	t.Run("unknown action", func(t *testing.T) {
-		registry := NewHandlerRegistry()
-		ctx := &HandlerContext{
-			Request: &common.HubRequest[cbor.RawMessage]{
-				Action: common.WebSocketAction(255), // Unknown action
-			},
-			HubVerified: true,
-		}
-
-		err := registry.Handle(ctx)
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "unknown action: 255")
-	})
-
-	t.Run("verification required", func(t *testing.T) {
-		registry := NewHandlerRegistry()
-		ctx := &HandlerContext{
-			Request: &common.HubRequest[cbor.RawMessage]{
-				Action: common.GetData, // Requires verification
-			},
-			HubVerified: false, // Not verified
-		}
-
-		err := registry.Handle(ctx)
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "hub not verified")
-	})
-}
-
-// TestCheckFingerprintHandler tests the CheckFingerprint handler
-func TestCheckFingerprintHandler(t *testing.T) {
-	handler := &CheckFingerprintHandler{}
-
-	t.Run("handle with invalid data", func(t *testing.T) {
-		client := &WebSocketClient{}
-		ctx := &HandlerContext{
-			Client:      client,
-			HubVerified: false,
-			Request: &common.HubRequest[cbor.RawMessage]{
-				Action: common.CheckFingerprint,
-				Data:   cbor.RawMessage{}, // Empty/invalid data
-			},
-		}
-
-		// Should fail to decode the fingerprint request
-		err := handler.Handle(ctx)
-		assert.Error(t, err)
-	})
-}

agent/network.go

@@ -3,7 +3,6 @@ package agent
 import (
 	"fmt"
 	"log/slog"
-	"path"
 	"strings"
 	"time"
 
@@ -12,116 +11,10 @@ import (
 	psutilNet "github.com/shirou/gopsutil/v4/net"
 )
 
-// NicConfig controls inclusion/exclusion of network interfaces via the NICS env var
-//
-// Behavior mirrors SensorConfig's matching logic:
-// - Leading '-' means blacklist mode; otherwise whitelist mode
-// - Supports '*' wildcards using path.Match
-// - In whitelist mode with an empty list, no NICs are selected
-// - In blacklist mode with an empty list, all NICs are selected
-type NicConfig struct {
-	nics         map[string]struct{}
-	isBlacklist  bool
-	hasWildcards bool
-}
+var netInterfaceDeltaTracker = deltatracker.NewDeltaTracker[string, uint64]()
 
-func newNicConfig(nicsEnvVal string) *NicConfig {
-	cfg := &NicConfig{
-		nics: make(map[string]struct{}),
-	}
-	if strings.HasPrefix(nicsEnvVal, "-") {
-		cfg.isBlacklist = true
-		nicsEnvVal = nicsEnvVal[1:]
-	}
-	for nic := range strings.SplitSeq(nicsEnvVal, ",") {
-		nic = strings.TrimSpace(nic)
-		if nic != "" {
-			cfg.nics[nic] = struct{}{}
-			if strings.Contains(nic, "*") {
-				cfg.hasWildcards = true
-			}
-		}
-	}
-	return cfg
-}
-
-// isValidNic determines if a NIC should be included based on NicConfig rules
-func isValidNic(nicName string, cfg *NicConfig) bool {
-	// Empty list behavior differs by mode: blacklist: allow all; whitelist: allow none
-	if len(cfg.nics) == 0 {
-		return cfg.isBlacklist
-	}
-
-	// Exact match: return true if whitelist, false if blacklist
-	if _, exactMatch := cfg.nics[nicName]; exactMatch {
-		return !cfg.isBlacklist
-	}
-
-	// If no wildcards, return true if blacklist, false if whitelist
-	if !cfg.hasWildcards {
-		return cfg.isBlacklist
-	}
-
-	// Check for wildcard patterns
-	for pattern := range cfg.nics {
-		if !strings.Contains(pattern, "*") {
-			continue
-		}
-		if match, _ := path.Match(pattern, nicName); match {
-			return !cfg.isBlacklist
-		}
-	}
-
-	return cfg.isBlacklist
-}
-
-func (a *Agent) updateNetworkStats(cacheTimeMs uint16, systemStats *system.Stats) {
+func (a *Agent) updateNetworkStats(systemStats *system.Stats) {
 	// network stats
-	a.ensureNetInterfacesInitialized()
-
-	a.ensureNetworkInterfacesMap(systemStats)
-
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		nis, msElapsed := a.loadAndTickNetBaseline(cacheTimeMs)
-		totalBytesSent, totalBytesRecv := a.sumAndTrackPerNicDeltas(cacheTimeMs, msElapsed, netIO, systemStats)
-		bytesSentPerSecond, bytesRecvPerSecond := a.computeBytesPerSecond(msElapsed, totalBytesSent, totalBytesRecv, nis)
-		a.applyNetworkTotals(cacheTimeMs, netIO, systemStats, nis, totalBytesSent, totalBytesRecv, bytesSentPerSecond, bytesRecvPerSecond)
-	}
-}
-
-func (a *Agent) initializeNetIoStats() {
-	// reset valid network interfaces
-	a.netInterfaces = make(map[string]struct{}, 0)
-
-	// parse NICS env var for whitelist / blacklist
-	nicsEnvVal, nicsEnvExists := GetEnv("NICS")
-	var nicCfg *NicConfig
-	if nicsEnvExists {
-		nicCfg = newNicConfig(nicsEnvVal)
-	}
-
-	// get current network I/O stats and record valid interfaces
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		for _, v := range netIO {
-			if nicsEnvExists && !isValidNic(v.Name, nicCfg) {
-				continue
-			}
-			if a.skipNetworkInterface(v) {
-				continue
-			}
-			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
-			// store as a valid network interface
-			a.netInterfaces[v.Name] = struct{}{}
-		}
-	}
-
-	// Reset per-cache-time trackers and baselines so they will reinitialize on next use
-	a.netInterfaceDeltaTrackers = make(map[uint16]*deltatracker.DeltaTracker[string, uint64])
-	a.netIoStats = make(map[uint16]system.NetIoStats)
-}
-
-// ensureNetInterfacesInitialized re-initializes NICs if none are currently tracked
-func (a *Agent) ensureNetInterfacesInitialized() {
 	if len(a.netInterfaces) == 0 {
 		// if no network interfaces, initialize again
 		// this is a fix if agent started before network is online (#466)
@@ -129,117 +22,110 @@ func (a *Agent) ensureNetInterfacesInitialized() {
 		// don't miss an interface that's been added after agent started in any circumstance
 		a.initializeNetIoStats()
 	}
-}
 
-// ensureNetworkInterfacesMap ensures systemStats.NetworkInterfaces map exists
-func (a *Agent) ensureNetworkInterfacesMap(systemStats *system.Stats) {
 	if systemStats.NetworkInterfaces == nil {
 		systemStats.NetworkInterfaces = make(map[string][4]uint64, 0)
 	}
-}
 
-// loadAndTickNetBaseline returns the NetIoStats baseline and milliseconds elapsed, updating time
-func (a *Agent) loadAndTickNetBaseline(cacheTimeMs uint16) (netIoStat system.NetIoStats, msElapsed uint64) {
-	netIoStat = a.netIoStats[cacheTimeMs]
-	if netIoStat.Time.IsZero() {
-		netIoStat.Time = time.Now()
-		msElapsed = 0
-	} else {
-		msElapsed = uint64(time.Since(netIoStat.Time).Milliseconds())
-		netIoStat.Time = time.Now()
-	}
-	return netIoStat, msElapsed
-}
-
-// sumAndTrackPerNicDeltas accumulates totals and records per-NIC up/down deltas into systemStats
-func (a *Agent) sumAndTrackPerNicDeltas(cacheTimeMs uint16, msElapsed uint64, netIO []psutilNet.IOCountersStat, systemStats *system.Stats) (totalBytesSent, totalBytesRecv uint64) {
-	tracker := a.netInterfaceDeltaTrackers[cacheTimeMs]
-	if tracker == nil {
-		tracker = deltatracker.NewDeltaTracker[string, uint64]()
-		a.netInterfaceDeltaTrackers[cacheTimeMs] = tracker
-	}
-	tracker.Cycle()
-
-	for _, v := range netIO {
-		if _, exists := a.netInterfaces[v.Name]; !exists {
-			continue
-		}
-		totalBytesSent += v.BytesSent
-		totalBytesRecv += v.BytesRecv
-
-		var upDelta, downDelta uint64
-		upKey, downKey := fmt.Sprintf("%sup", v.Name), fmt.Sprintf("%sdown", v.Name)
-		tracker.Set(upKey, v.BytesSent)
-		tracker.Set(downKey, v.BytesRecv)
-		if msElapsed > 0 {
-			if prevVal, ok := tracker.Previous(upKey); ok {
-				var deltaBytes uint64
-				if v.BytesSent >= prevVal {
-					deltaBytes = v.BytesSent - prevVal
-				} else {
-					deltaBytes = v.BytesSent
-				}
-				upDelta = deltaBytes * 1000 / msElapsed
-			}
-			if prevVal, ok := tracker.Previous(downKey); ok {
-				var deltaBytes uint64
-				if v.BytesRecv >= prevVal {
-					deltaBytes = v.BytesRecv - prevVal
-				} else {
-					deltaBytes = v.BytesRecv
-				}
-				downDelta = deltaBytes * 1000 / msElapsed
-			}
-		}
-		systemStats.NetworkInterfaces[v.Name] = [4]uint64{upDelta, downDelta, v.BytesSent, v.BytesRecv}
-	}
-
-	return totalBytesSent, totalBytesRecv
-}
-
-// computeBytesPerSecond calculates per-second totals from elapsed time and totals
-func (a *Agent) computeBytesPerSecond(msElapsed, totalBytesSent, totalBytesRecv uint64, nis system.NetIoStats) (bytesSentPerSecond, bytesRecvPerSecond uint64) {
-	if msElapsed > 0 {
-		bytesSentPerSecond = (totalBytesSent - nis.BytesSent) * 1000 / msElapsed
-		bytesRecvPerSecond = (totalBytesRecv - nis.BytesRecv) * 1000 / msElapsed
-	}
-	return bytesSentPerSecond, bytesRecvPerSecond
-}
-
-// applyNetworkTotals validates and writes computed network stats, or resets on anomaly
-func (a *Agent) applyNetworkTotals(
-	cacheTimeMs uint16,
-	netIO []psutilNet.IOCountersStat,
-	systemStats *system.Stats,
-	nis system.NetIoStats,
-	totalBytesSent, totalBytesRecv uint64,
-	bytesSentPerSecond, bytesRecvPerSecond uint64,
-) {
-	networkSentPs := bytesToMegabytes(float64(bytesSentPerSecond))
-	networkRecvPs := bytesToMegabytes(float64(bytesRecvPerSecond))
-	if networkSentPs > 10_000 || networkRecvPs > 10_000 {
-		slog.Warn("Invalid net stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		msElapsed := uint64(time.Since(a.netIoStats.Time).Milliseconds())
+		a.netIoStats.Time = time.Now()
+		totalBytesSent := uint64(0)
+		totalBytesRecv := uint64(0)
+		netInterfaceDeltaTracker.Cycle()
+		// sum all bytes sent and received
 		for _, v := range netIO {
+			// skip if not in valid network interfaces list
 			if _, exists := a.netInterfaces[v.Name]; !exists {
 				continue
 			}
-			slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
+			totalBytesSent += v.BytesSent
+			totalBytesRecv += v.BytesRecv
+
+			// track deltas for each network interface
+			var upDelta, downDelta uint64
+			upKey, downKey := fmt.Sprintf("%sup", v.Name), fmt.Sprintf("%sdown", v.Name)
+			netInterfaceDeltaTracker.Set(upKey, v.BytesSent)
+			netInterfaceDeltaTracker.Set(downKey, v.BytesRecv)
+			if msElapsed > 0 {
+				upDelta = netInterfaceDeltaTracker.Delta(upKey) * 1000 / msElapsed
+				downDelta = netInterfaceDeltaTracker.Delta(downKey) * 1000 / msElapsed
+			}
+			// add interface to systemStats
+			systemStats.NetworkInterfaces[v.Name] = [4]uint64{upDelta, downDelta, v.BytesSent, v.BytesRecv}
+		}
+
+		// add to systemStats
+		var bytesSentPerSecond, bytesRecvPerSecond uint64
+		if msElapsed > 0 {
+			bytesSentPerSecond = (totalBytesSent - a.netIoStats.BytesSent) * 1000 / msElapsed
+			bytesRecvPerSecond = (totalBytesRecv - a.netIoStats.BytesRecv) * 1000 / msElapsed
+		}
+		networkSentPs := bytesToMegabytes(float64(bytesSentPerSecond))
+		networkRecvPs := bytesToMegabytes(float64(bytesRecvPerSecond))
+		// add check for issue (#150) where sent is a massive number
+		if networkSentPs > 10_000 || networkRecvPs > 10_000 {
+			slog.Warn("Invalid net stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
+			for _, v := range netIO {
+				if _, exists := a.netInterfaces[v.Name]; !exists {
+					continue
+				}
+				slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
+			}
+			// reset network I/O stats
+			a.initializeNetIoStats()
+		} else {
+			systemStats.NetworkSent = networkSentPs
+			systemStats.NetworkRecv = networkRecvPs
+			systemStats.Bandwidth[0], systemStats.Bandwidth[1] = bytesSentPerSecond, bytesRecvPerSecond
+			// update netIoStats
+			a.netIoStats.BytesSent = totalBytesSent
+			a.netIoStats.BytesRecv = totalBytesRecv
+		}
+	}
+}
+
+func (a *Agent) initializeNetIoStats() {
+	// reset valid network interfaces
+	a.netInterfaces = make(map[string]struct{}, 0)
+
+	// map of network interface names passed in via NICS env var
+	var nicsMap map[string]struct{}
+	nics, nicsEnvExists := GetEnv("NICS")
+	if nicsEnvExists {
+		nicsMap = make(map[string]struct{}, 0)
+		for nic := range strings.SplitSeq(nics, ",") {
+			nicsMap[nic] = struct{}{}
 		}
-		a.initializeNetIoStats()
-		delete(a.netIoStats, cacheTimeMs)
-		delete(a.netInterfaceDeltaTrackers, cacheTimeMs)
-		systemStats.NetworkSent = 0
-		systemStats.NetworkRecv = 0
-		systemStats.Bandwidth[0], systemStats.Bandwidth[1] = 0, 0
-		return
 	}
 
-	systemStats.NetworkSent = networkSentPs
-	systemStats.NetworkRecv = networkRecvPs
-	systemStats.Bandwidth[0], systemStats.Bandwidth[1] = bytesSentPerSecond, bytesRecvPerSecond
-	nis.BytesSent = totalBytesSent
-	nis.BytesRecv = totalBytesRecv
-	a.netIoStats[cacheTimeMs] = nis
+	// reset network I/O stats
+	a.netIoStats.BytesSent = 0
+	a.netIoStats.BytesRecv = 0
+
+	// get intial network I/O stats
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		a.netIoStats.Time = time.Now()
+		for _, v := range netIO {
+			switch {
+			// skip if nics exists and the interface is not in the list
+			case nicsEnvExists:
+				if _, nameInNics := nicsMap[v.Name]; !nameInNics {
+					continue
+				}
+			// otherwise run the interface name through the skipNetworkInterface function
+			default:
+				if a.skipNetworkInterface(v) {
+					continue
+				}
+			}
+			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
+			a.netIoStats.BytesSent += v.BytesSent
+			a.netIoStats.BytesRecv += v.BytesRecv
+			// store as a valid network interface
+			a.netInterfaces[v.Name] = struct{}{}
+		}
+	}
 }
 
 func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
@@ -249,7 +135,6 @@ func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
 		strings.HasPrefix(v.Name, "br-"),
 		strings.HasPrefix(v.Name, "veth"),
 		strings.HasPrefix(v.Name, "bond"),
-		strings.HasPrefix(v.Name, "cali"),
 		v.BytesRecv == 0,
 		v.BytesSent == 0:
 		return true

agent/network_test.go

@@ -1,502 +0,0 @@
-//go:build testing
-
-package agent
-
-import (
-	"testing"
-	"time"
-
-	"github.com/henrygd/beszel/agent/deltatracker"
-	"github.com/henrygd/beszel/internal/entities/system"
-	psutilNet "github.com/shirou/gopsutil/v4/net"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestIsValidNic(t *testing.T) {
-	tests := []struct {
-		name          string
-		nicName       string
-		config        *NicConfig
-		expectedValid bool
-	}{
-		{
-			name:    "Whitelist - NIC in list",
-			nicName: "eth0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{"eth0": {}},
-				isBlacklist: false,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Whitelist - NIC not in list",
-			nicName: "wlan0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{"eth0": {}},
-				isBlacklist: false,
-			},
-			expectedValid: false,
-		},
-		{
-			name:    "Blacklist - NIC in list",
-			nicName: "eth0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{"eth0": {}},
-				isBlacklist: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:    "Blacklist - NIC not in list",
-			nicName: "wlan0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{"eth0": {}},
-				isBlacklist: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Whitelist with wildcard - matching pattern",
-			nicName: "eth1",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Whitelist with wildcard - non-matching pattern",
-			nicName: "wlan0",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:    "Blacklist with wildcard - matching pattern",
-			nicName: "eth1",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:    "Blacklist with wildcard - non-matching pattern",
-			nicName: "wlan0",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Empty whitelist config - no NICs allowed",
-			nicName: "eth0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{},
-				isBlacklist: false,
-			},
-			expectedValid: false,
-		},
-		{
-			name:    "Empty blacklist config - all NICs allowed",
-			nicName: "eth0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{},
-				isBlacklist: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Multiple patterns - exact match",
-			nicName: "eth0",
-			config: &NicConfig{
-				nics:        map[string]struct{}{"eth0": {}, "wlan*": {}},
-				isBlacklist: false,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Multiple patterns - wildcard match",
-			nicName: "wlan1",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "wlan*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:    "Multiple patterns - no match",
-			nicName: "bond0",
-			config: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "wlan*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isValidNic(tt.nicName, tt.config)
-			assert.Equal(t, tt.expectedValid, result)
-		})
-	}
-}
-
-func TestNewNicConfig(t *testing.T) {
-	tests := []struct {
-		name        string
-		nicsEnvVal  string
-		expectedCfg *NicConfig
-	}{
-		{
-			name:       "Empty string",
-			nicsEnvVal: "",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "Single NIC whitelist",
-			nicsEnvVal: "eth0",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "Multiple NICs whitelist",
-			nicsEnvVal: "eth0,wlan0",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "wlan0": {}},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "Blacklist mode",
-			nicsEnvVal: "-eth0,wlan0",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "wlan0": {}},
-				isBlacklist:  true,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "With wildcards",
-			nicsEnvVal: "eth*,wlan0",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}, "wlan0": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-		},
-		{
-			name:       "Blacklist with wildcards",
-			nicsEnvVal: "-eth*,wlan0",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}, "wlan0": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-		},
-		{
-			name:       "With whitespace",
-			nicsEnvVal: "eth0, wlan0 , eth1",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "wlan0": {}, "eth1": {}},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "Only wildcards",
-			nicsEnvVal: "eth*,wlan*",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth*": {}, "wlan*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-		},
-		{
-			name:       "Leading dash only",
-			nicsEnvVal: "-",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{},
-				isBlacklist:  true,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:       "Mixed exact and wildcard",
-			nicsEnvVal: "eth0,br-*",
-			expectedCfg: &NicConfig{
-				nics:         map[string]struct{}{"eth0": {}, "br-*": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cfg := newNicConfig(tt.nicsEnvVal)
-			require.NotNil(t, cfg)
-			assert.Equal(t, tt.expectedCfg.isBlacklist, cfg.isBlacklist)
-			assert.Equal(t, tt.expectedCfg.hasWildcards, cfg.hasWildcards)
-			assert.Equal(t, tt.expectedCfg.nics, cfg.nics)
-		})
-	}
-}
-func TestEnsureNetworkInterfacesMap(t *testing.T) {
-	var a Agent
-	var stats system.Stats
-
-	// Initially nil
-	assert.Nil(t, stats.NetworkInterfaces)
-	// Ensure map is created
-	a.ensureNetworkInterfacesMap(&stats)
-	assert.NotNil(t, stats.NetworkInterfaces)
-	// Idempotent
-	a.ensureNetworkInterfacesMap(&stats)
-	assert.NotNil(t, stats.NetworkInterfaces)
-}
-
-func TestLoadAndTickNetBaseline(t *testing.T) {
-	a := &Agent{netIoStats: make(map[uint16]system.NetIoStats)}
-
-	// First call initializes time and returns 0 elapsed
-	ni, elapsed := a.loadAndTickNetBaseline(100)
-	assert.Equal(t, uint64(0), elapsed)
-	assert.False(t, ni.Time.IsZero())
-
-	// Store back what loadAndTick returns to mimic updateNetworkStats behavior
-	a.netIoStats[100] = ni
-
-	time.Sleep(2 * time.Millisecond)
-
-	// Next call should produce >= 0 elapsed and update time
-	ni2, elapsed2 := a.loadAndTickNetBaseline(100)
-	assert.True(t, elapsed2 > 0)
-	assert.False(t, ni2.Time.IsZero())
-}
-
-func TestComputeBytesPerSecond(t *testing.T) {
-	a := &Agent{}
-
-	// No elapsed -> zero rate
-	bytesUp, bytesDown := a.computeBytesPerSecond(0, 2000, 3000, system.NetIoStats{BytesSent: 1000, BytesRecv: 1000})
-	assert.Equal(t, uint64(0), bytesUp)
-	assert.Equal(t, uint64(0), bytesDown)
-
-	// With elapsed -> per-second calculation
-	bytesUp, bytesDown = a.computeBytesPerSecond(500, 6000, 11000, system.NetIoStats{BytesSent: 1000, BytesRecv: 1000})
-	// (6000-1000)*1000/500 = 10000; (11000-1000)*1000/500 = 20000
-	assert.Equal(t, uint64(10000), bytesUp)
-	assert.Equal(t, uint64(20000), bytesDown)
-}
-
-func TestSumAndTrackPerNicDeltas(t *testing.T) {
-	a := &Agent{
-		netInterfaces:             map[string]struct{}{"eth0": {}, "wlan0": {}},
-		netInterfaceDeltaTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	// Two samples for same cache interval to verify delta behavior
-	cache := uint16(42)
-	net1 := []psutilNet.IOCountersStat{{Name: "eth0", BytesSent: 1000, BytesRecv: 2000}}
-	stats1 := &system.Stats{}
-	a.ensureNetworkInterfacesMap(stats1)
-	tx1, rx1 := a.sumAndTrackPerNicDeltas(cache, 0, net1, stats1)
-	assert.Equal(t, uint64(1000), tx1)
-	assert.Equal(t, uint64(2000), rx1)
-
-	// Second cycle with elapsed, larger counters -> deltas computed inside
-	net2 := []psutilNet.IOCountersStat{{Name: "eth0", BytesSent: 4000, BytesRecv: 9000}}
-	stats := &system.Stats{}
-	a.ensureNetworkInterfacesMap(stats)
-	tx2, rx2 := a.sumAndTrackPerNicDeltas(cache, 1000, net2, stats)
-	assert.Equal(t, uint64(4000), tx2)
-	assert.Equal(t, uint64(9000), rx2)
-	// Up/Down deltas per second should be (4000-1000)/1s = 3000 and (9000-2000)/1s = 7000
-	ni, ok := stats.NetworkInterfaces["eth0"]
-	assert.True(t, ok)
-	assert.Equal(t, uint64(3000), ni[0])
-	assert.Equal(t, uint64(7000), ni[1])
-}
-
-func TestSumAndTrackPerNicDeltasHandlesCounterReset(t *testing.T) {
-	a := &Agent{
-		netInterfaces:             map[string]struct{}{"eth0": {}},
-		netInterfaceDeltaTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-	}
-
-	cache := uint16(77)
-
-	// First interval establishes baseline values
-	initial := []psutilNet.IOCountersStat{{Name: "eth0", BytesSent: 4_000, BytesRecv: 6_000}}
-	statsInitial := &system.Stats{}
-	a.ensureNetworkInterfacesMap(statsInitial)
-	_, _ = a.sumAndTrackPerNicDeltas(cache, 0, initial, statsInitial)
-
-	// Second interval increments counters normally so previous snapshot gets populated
-	increment := []psutilNet.IOCountersStat{{Name: "eth0", BytesSent: 9_000, BytesRecv: 11_000}}
-	statsIncrement := &system.Stats{}
-	a.ensureNetworkInterfacesMap(statsIncrement)
-	_, _ = a.sumAndTrackPerNicDeltas(cache, 1_000, increment, statsIncrement)
-
-	niIncrement, ok := statsIncrement.NetworkInterfaces["eth0"]
-	require.True(t, ok)
-	assert.Equal(t, uint64(5_000), niIncrement[0])
-	assert.Equal(t, uint64(5_000), niIncrement[1])
-
-	// Third interval simulates counter reset (values drop below previous totals)
-	reset := []psutilNet.IOCountersStat{{Name: "eth0", BytesSent: 1_200, BytesRecv: 1_500}}
-	statsReset := &system.Stats{}
-	a.ensureNetworkInterfacesMap(statsReset)
-	_, _ = a.sumAndTrackPerNicDeltas(cache, 1_000, reset, statsReset)
-
-	niReset, ok := statsReset.NetworkInterfaces["eth0"]
-	require.True(t, ok)
-	assert.Equal(t, uint64(1_200), niReset[0], "upload delta should match new counter value after reset")
-	assert.Equal(t, uint64(1_500), niReset[1], "download delta should match new counter value after reset")
-}
-
-func TestApplyNetworkTotals(t *testing.T) {
-	tests := []struct {
-		name                  string
-		bytesSentPerSecond    uint64
-		bytesRecvPerSecond    uint64
-		totalBytesSent        uint64
-		totalBytesRecv        uint64
-		expectReset           bool
-		expectedNetworkSent   float64
-		expectedNetworkRecv   float64
-		expectedBandwidthSent uint64
-		expectedBandwidthRecv uint64
-	}{
-		{
-			name:                  "Valid network stats - normal values",
-			bytesSentPerSecond:    1000000, // 1 MB/s
-			bytesRecvPerSecond:    2000000, // 2 MB/s
-			totalBytesSent:        10000000,
-			totalBytesRecv:        20000000,
-			expectReset:           false,
-			expectedNetworkSent:   0.95, // ~1 MB/s rounded to 2 decimals
-			expectedNetworkRecv:   1.91, // ~2 MB/s rounded to 2 decimals
-			expectedBandwidthSent: 1000000,
-			expectedBandwidthRecv: 2000000,
-		},
-		{
-			name:               "Invalid network stats - sent exceeds threshold",
-			bytesSentPerSecond: 11000000000, // ~10.5 GB/s > 10 GB/s threshold
-			bytesRecvPerSecond: 1000000,     // 1 MB/s
-			totalBytesSent:     10000000,
-			totalBytesRecv:     20000000,
-			expectReset:        true,
-		},
-		{
-			name:               "Invalid network stats - recv exceeds threshold",
-			bytesSentPerSecond: 1000000,     // 1 MB/s
-			bytesRecvPerSecond: 11000000000, // ~10.5 GB/s > 10 GB/s threshold
-			totalBytesSent:     10000000,
-			totalBytesRecv:     20000000,
-			expectReset:        true,
-		},
-		{
-			name:               "Invalid network stats - both exceed threshold",
-			bytesSentPerSecond: 12000000000, // ~11.4 GB/s
-			bytesRecvPerSecond: 13000000000, // ~12.4 GB/s
-			totalBytesSent:     10000000,
-			totalBytesRecv:     20000000,
-			expectReset:        true,
-		},
-		{
-			name:                  "Valid network stats - at threshold boundary",
-			bytesSentPerSecond:    10485750000, // ~9999.99 MB/s (rounds to 9999.99)
-			bytesRecvPerSecond:    10485750000, // ~9999.99 MB/s (rounds to 9999.99)
-			totalBytesSent:        10000000,
-			totalBytesRecv:        20000000,
-			expectReset:           false,
-			expectedNetworkSent:   9999.99,
-			expectedNetworkRecv:   9999.99,
-			expectedBandwidthSent: 10485750000,
-			expectedBandwidthRecv: 10485750000,
-		},
-		{
-			name:                  "Zero values",
-			bytesSentPerSecond:    0,
-			bytesRecvPerSecond:    0,
-			totalBytesSent:        0,
-			totalBytesRecv:        0,
-			expectReset:           false,
-			expectedNetworkSent:   0.0,
-			expectedNetworkRecv:   0.0,
-			expectedBandwidthSent: 0,
-			expectedBandwidthRecv: 0,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Setup agent with initialized maps
-			a := &Agent{
-				netInterfaces:             make(map[string]struct{}),
-				netIoStats:                make(map[uint16]system.NetIoStats),
-				netInterfaceDeltaTrackers: make(map[uint16]*deltatracker.DeltaTracker[string, uint64]),
-			}
-
-			cacheTimeMs := uint16(100)
-			netIO := []psutilNet.IOCountersStat{
-				{Name: "eth0", BytesSent: 1000, BytesRecv: 2000},
-			}
-			systemStats := &system.Stats{}
-			nis := system.NetIoStats{}
-
-			a.applyNetworkTotals(
-				cacheTimeMs,
-				netIO,
-				systemStats,
-				nis,
-				tt.totalBytesSent,
-				tt.totalBytesRecv,
-				tt.bytesSentPerSecond,
-				tt.bytesRecvPerSecond,
-			)
-
-			if tt.expectReset {
-				// Should have reset network tracking state - maps cleared and stats zeroed
-				assert.NotContains(t, a.netIoStats, cacheTimeMs, "cache entry should be cleared after reset")
-				assert.NotContains(t, a.netInterfaceDeltaTrackers, cacheTimeMs, "tracker should be cleared on reset")
-				assert.Zero(t, systemStats.NetworkSent)
-				assert.Zero(t, systemStats.NetworkRecv)
-				assert.Zero(t, systemStats.Bandwidth[0])
-				assert.Zero(t, systemStats.Bandwidth[1])
-			} else {
-				// Should have applied stats
-				assert.Equal(t, tt.expectedNetworkSent, systemStats.NetworkSent)
-				assert.Equal(t, tt.expectedNetworkRecv, systemStats.NetworkRecv)
-				assert.Equal(t, tt.expectedBandwidthSent, systemStats.Bandwidth[0])
-				assert.Equal(t, tt.expectedBandwidthRecv, systemStats.Bandwidth[1])
-
-				// Should have updated NetIoStats
-				updatedNis := a.netIoStats[cacheTimeMs]
-				assert.Equal(t, tt.totalBytesSent, updatedNis.BytesSent)
-				assert.Equal(t, tt.totalBytesRecv, updatedNis.BytesRecv)
-			}
-		})
-	}
-}

agent/server.go

@@ -127,77 +127,15 @@ func (a *Agent) handleSession(s ssh.Session) {
 
 	hubVersion := a.getHubVersion(sessionID, sessionCtx)
 
-	// Legacy one-shot behavior for older hubs
-	if hubVersion.LT(beszel.MinVersionAgentResponse) {
-		if err := a.handleLegacyStats(s, hubVersion); err != nil {
-			slog.Error("Error encoding stats", "err", err)
-			s.Exit(1)
-			return
-		}
-	}
+	stats := a.gatherStats(sessionID)
 
-	var req common.HubRequest[cbor.RawMessage]
-	if err := cbor.NewDecoder(s).Decode(&req); err != nil {
-		// Fallback to legacy one-shot if the first decode fails
-		if err2 := a.handleLegacyStats(s, hubVersion); err2 != nil {
-			slog.Error("Error encoding stats (fallback)", "err", err2)
-			s.Exit(1)
-			return
-		}
-		s.Exit(0)
-		return
-	}
-	if err := a.handleSSHRequest(s, &req); err != nil {
-		slog.Error("SSH request handling failed", "err", err)
+	err := a.writeToSession(s, stats, hubVersion)
+	if err != nil {
+		slog.Error("Error encoding stats", "err", err, "stats", stats)
 		s.Exit(1)
-		return
+	} else {
+		s.Exit(0)
 	}
-	s.Exit(0)
-}
-
-// handleSSHRequest builds a handler context and dispatches to the shared registry
-func (a *Agent) handleSSHRequest(w io.Writer, req *common.HubRequest[cbor.RawMessage]) error {
-	// SSH does not support fingerprint auth action
-	if req.Action == common.CheckFingerprint {
-		return cbor.NewEncoder(w).Encode(common.AgentResponse{Error: "unsupported action"})
-	}
-
-	// responder that writes AgentResponse to stdout
-	sshResponder := func(data any, requestID *uint32) error {
-		response := common.AgentResponse{Id: requestID}
-		switch v := data.(type) {
-		case *system.CombinedData:
-			response.SystemData = v
-		case string:
-			response.String = &v
-		default:
-			response.Error = fmt.Sprintf("unsupported response type: %T", data)
-		}
-		return cbor.NewEncoder(w).Encode(response)
-	}
-
-	ctx := &HandlerContext{
-		Client:       nil,
-		Agent:        a,
-		Request:      req,
-		RequestID:    nil,
-		HubVerified:  true,
-		SendResponse: sshResponder,
-	}
-
-	if handler, ok := a.handlerRegistry.GetHandler(req.Action); ok {
-		if err := handler.Handle(ctx); err != nil {
-			return cbor.NewEncoder(w).Encode(common.AgentResponse{Error: err.Error()})
-		}
-		return nil
-	}
-	return cbor.NewEncoder(w).Encode(common.AgentResponse{Error: fmt.Sprintf("unknown action: %d", req.Action)})
-}
-
-// handleLegacyStats serves the legacy one-shot stats payload for older hubs
-func (a *Agent) handleLegacyStats(w io.Writer, hubVersion semver.Version) error {
-	stats := a.gatherStats(60_000)
-	return a.writeToSession(w, stats, hubVersion)
 }
 
 // writeToSession encodes and writes system statistics to the session.

agent/smart.go

@@ -1,402 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os/exec"
-	"sync"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/smart"
-
-	"golang.org/x/exp/slog"
-)
-
-// SmartManager manages data collection for SMART devices
-type SmartManager struct {
-	sync.Mutex
-	SmartDataMap map[string]*smart.SmartData
-	SmartDevices []*DeviceInfo
-	refreshMutex sync.Mutex
-}
-
-type scanOutput struct {
-	Devices []struct {
-		Name     string `json:"name"`
-		Type     string `json:"type"`
-		InfoName string `json:"info_name"`
-		Protocol string `json:"protocol"`
-	} `json:"devices"`
-}
-
-type DeviceInfo struct {
-	Name     string `json:"name"`
-	Type     string `json:"type"`
-	InfoName string `json:"info_name"`
-	Protocol string `json:"protocol"`
-}
-
-var errNoValidSmartData = fmt.Errorf("no valid SMART data found") // Error for missing data
-
-// Refresh updates SMART data for all known devices on demand.
-func (sm *SmartManager) Refresh() error {
-	sm.refreshMutex.Lock()
-	defer sm.refreshMutex.Unlock()
-
-	scanErr := sm.ScanDevices()
-	if scanErr != nil {
-		slog.Warn("smartctl scan failed", "err", scanErr)
-	}
-
-	devices := sm.devicesSnapshot()
-	var collectErr error
-	for _, deviceInfo := range devices {
-		if deviceInfo == nil {
-			continue
-		}
-		if err := sm.CollectSmart(deviceInfo); err != nil {
-			slog.Info("smartctl collect failed for device, skipping", "device", deviceInfo.Name, "err", err)
-			collectErr = err
-		}
-	}
-
-	return sm.resolveRefreshError(scanErr, collectErr)
-}
-
-// devicesSnapshot returns a copy of the current device slice to avoid iterating
-// while holding the primary mutex for longer than necessary.
-func (sm *SmartManager) devicesSnapshot() []*DeviceInfo {
-	sm.Lock()
-	defer sm.Unlock()
-
-	devices := make([]*DeviceInfo, len(sm.SmartDevices))
-	copy(devices, sm.SmartDevices)
-	return devices
-}
-
-// hasSmartData reports whether any SMART data has been collected.
-// func (sm *SmartManager) hasSmartData() bool {
-// 	sm.Lock()
-// 	defer sm.Unlock()
-
-// 	return len(sm.SmartDataMap) > 0
-// }
-
-// resolveRefreshError determines the proper error to return after a refresh.
-func (sm *SmartManager) resolveRefreshError(scanErr, collectErr error) error {
-	sm.Lock()
-	noDevices := len(sm.SmartDevices) == 0
-	noData := len(sm.SmartDataMap) == 0
-	sm.Unlock()
-
-	if noDevices {
-		if scanErr != nil {
-			return scanErr
-		}
-	}
-
-	if !noData {
-		return nil
-	}
-
-	if collectErr != nil {
-		return collectErr
-	}
-	if scanErr != nil {
-		return scanErr
-	}
-	return errNoValidSmartData
-}
-
-// GetCurrentData returns the current SMART data
-func (sm *SmartManager) GetCurrentData() map[string]smart.SmartData {
-	sm.Lock()
-	defer sm.Unlock()
-	result := make(map[string]smart.SmartData, len(sm.SmartDataMap))
-	for key, value := range sm.SmartDataMap {
-		if value != nil {
-			result[key] = *value
-		}
-	}
-	return result
-}
-
-// ScanDevices scans for SMART devices
-// Scan devices using `smartctl --scan -j`
-// If scan fails, return error
-// If scan succeeds, parse the output and update the SmartDevices slice
-func (sm *SmartManager) ScanDevices() error {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, "smartctl", "--scan", "-j")
-	output, err := cmd.Output()
-
-	if err != nil {
-		return err
-	}
-
-	hasValidData := sm.parseScan(output)
-	if !hasValidData {
-		return errNoValidSmartData
-	}
-	return nil
-}
-
-// CollectSmart collects SMART data for a device
-// Collect data using `smartctl --all -j /dev/sdX` or `smartctl --all -j /dev/nvmeX`
-// Always attempts to parse output even if command fails, as some data may still be available
-// If collect fails, return error
-// If collect succeeds, parse the output and update the SmartDataMap
-// Uses -n standby to avoid waking up sleeping disks, but bypasses standby mode
-// for initial data collection when no cached data exists
-func (sm *SmartManager) CollectSmart(deviceInfo *DeviceInfo) error {
-	// Check if we have any existing data for this device
-	hasExistingData := sm.hasDataForDevice(deviceInfo.Name)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	// Try with -n standby first if we have existing data
-	cmd := exec.CommandContext(ctx, "smartctl", "-aj", "-n", "standby", deviceInfo.Name)
-	output, err := cmd.CombinedOutput()
-
-	// Check if device is in standby (exit status 2)
-	if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 2 {
-		if hasExistingData {
-			// Device is in standby and we have cached data, keep using cache
-			slog.Debug("device in standby mode, using cached data", "device", deviceInfo.Name)
-			return nil
-		}
-		// No cached data, need to collect initial data by bypassing standby
-		slog.Debug("device in standby but no cached data, collecting initial data", "device", deviceInfo.Name)
-		ctx2, cancel2 := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel2()
-		cmd = exec.CommandContext(ctx2, "smartctl", "-aj", deviceInfo.Name)
-		output, err = cmd.CombinedOutput()
-	}
-
-	hasValidData := false
-
-	switch deviceInfo.Type {
-	case "scsi", "sat", "ata":
-		// parse SATA/SCSI/ATA devices
-		hasValidData, _ = sm.parseSmartForSata(output)
-	case "nvme":
-		// parse nvme devices
-		hasValidData, _ = sm.parseSmartForNvme(output)
-	}
-
-	if !hasValidData {
-		if err != nil {
-			return err
-		}
-		return errNoValidSmartData
-	}
-	return nil
-}
-
-// hasDataForDevice checks if we have cached SMART data for a specific device
-func (sm *SmartManager) hasDataForDevice(deviceName string) bool {
-	sm.Lock()
-	defer sm.Unlock()
-
-	// Check if any cached data has this device name
-	for _, data := range sm.SmartDataMap {
-		if data != nil && data.DiskName == deviceName {
-			return true
-		}
-	}
-	return false
-}
-
-// parseScan parses the output of smartctl --scan -j and updates the SmartDevices slice
-func (sm *SmartManager) parseScan(output []byte) bool {
-	sm.Lock()
-	defer sm.Unlock()
-
-	sm.SmartDevices = make([]*DeviceInfo, 0)
-	scan := &scanOutput{}
-
-	if err := json.Unmarshal(output, scan); err != nil {
-		slog.Warn("Failed to parse smartctl scan JSON", "err", err)
-		return false
-	}
-
-	if len(scan.Devices) == 0 {
-		return false
-	}
-
-	scannedDeviceNameMap := make(map[string]bool, len(scan.Devices))
-
-	for _, device := range scan.Devices {
-		deviceInfo := &DeviceInfo{
-			Name:     device.Name,
-			Type:     device.Type,
-			InfoName: device.InfoName,
-			Protocol: device.Protocol,
-		}
-		sm.SmartDevices = append(sm.SmartDevices, deviceInfo)
-		scannedDeviceNameMap[device.Name] = true
-	}
-	// remove devices that are not in the scan
-	for key := range sm.SmartDataMap {
-		if _, ok := scannedDeviceNameMap[key]; !ok {
-			delete(sm.SmartDataMap, key)
-		}
-	}
-
-	return true
-}
-
-// parseSmartForSata parses the output of smartctl --all -j for SATA/ATA devices and updates the SmartDataMap
-// Returns hasValidData and exitStatus
-func (sm *SmartManager) parseSmartForSata(output []byte) (bool, int) {
-	var data smart.SmartInfoForSata
-
-	if err := json.Unmarshal(output, &data); err != nil {
-		return false, 0
-	}
-
-	if data.SerialNumber == "" {
-		slog.Warn("device has no serial number, skipping", "device", data.Device.Name)
-		return false, data.Smartctl.ExitStatus
-	}
-
-	sm.Lock()
-	defer sm.Unlock()
-
-	// get device name (e.g. /dev/sda)
-	keyName := data.SerialNumber
-
-	// if device does not exist in SmartDataMap, initialize it
-	if _, ok := sm.SmartDataMap[keyName]; !ok {
-		sm.SmartDataMap[keyName] = &smart.SmartData{}
-	}
-
-	// update SmartData
-	smartData := sm.SmartDataMap[keyName]
-	// smartData.ModelFamily = data.ModelFamily
-	smartData.ModelName = data.ModelName
-	smartData.SerialNumber = data.SerialNumber
-	smartData.FirmwareVersion = data.FirmwareVersion
-	smartData.Capacity = data.UserCapacity.Bytes
-	smartData.Temperature = data.Temperature.Current
-	smartData.SmartStatus = getSmartStatus(smartData.Temperature, data.SmartStatus.Passed)
-	smartData.DiskName = data.Device.Name
-	smartData.DiskType = data.Device.Type
-
-	// update SmartAttributes
-	smartData.Attributes = make([]*smart.SmartAttribute, 0, len(data.AtaSmartAttributes.Table))
-	for _, attr := range data.AtaSmartAttributes.Table {
-		smartAttr := &smart.SmartAttribute{
-			ID:         attr.ID,
-			Name:       attr.Name,
-			Value:      attr.Value,
-			Worst:      attr.Worst,
-			Threshold:  attr.Thresh,
-			RawValue:   attr.Raw.Value,
-			RawString:  attr.Raw.String,
-			WhenFailed: attr.WhenFailed,
-		}
-		smartData.Attributes = append(smartData.Attributes, smartAttr)
-	}
-	sm.SmartDataMap[keyName] = smartData
-
-	return true, data.Smartctl.ExitStatus
-}
-
-func getSmartStatus(temperature uint8, passed bool) string {
-	if passed {
-		return "PASSED"
-	} else if temperature > 0 {
-		return "FAILED"
-	} else {
-		return "UNKNOWN"
-	}
-}
-
-// parseSmartForNvme parses the output of smartctl --all -j /dev/nvmeX and updates the SmartDataMap
-// Returns hasValidData and exitStatus
-func (sm *SmartManager) parseSmartForNvme(output []byte) (bool, int) {
-	data := &smart.SmartInfoForNvme{}
-
-	if err := json.Unmarshal(output, &data); err != nil {
-		return false, 0
-	}
-
-	if data.SerialNumber == "" {
-		slog.Warn("device has no serial number, skipping", "device", data.Device.Name)
-		return false, data.Smartctl.ExitStatus
-	}
-
-	sm.Lock()
-	defer sm.Unlock()
-
-	// get device name (e.g. /dev/nvme0)
-	keyName := data.SerialNumber
-
-	// if device does not exist in SmartDataMap, initialize it
-	if _, ok := sm.SmartDataMap[keyName]; !ok {
-		sm.SmartDataMap[keyName] = &smart.SmartData{}
-	}
-
-	// update SmartData
-	smartData := sm.SmartDataMap[keyName]
-	smartData.ModelName = data.ModelName
-	smartData.SerialNumber = data.SerialNumber
-	smartData.FirmwareVersion = data.FirmwareVersion
-	smartData.Capacity = data.UserCapacity.Bytes
-	smartData.Temperature = data.NVMeSmartHealthInformationLog.Temperature
-	smartData.SmartStatus = getSmartStatus(smartData.Temperature, data.SmartStatus.Passed)
-	smartData.DiskName = data.Device.Name
-	smartData.DiskType = data.Device.Type
-
-	// nvme attributes does not follow the same format as ata attributes,
-	// so we manually map each field to SmartAttributes
-	log := data.NVMeSmartHealthInformationLog
-	smartData.Attributes = []*smart.SmartAttribute{
-		{Name: "CriticalWarning", RawValue: uint64(log.CriticalWarning)},
-		{Name: "Temperature", RawValue: uint64(log.Temperature)},
-		{Name: "AvailableSpare", RawValue: uint64(log.AvailableSpare)},
-		{Name: "AvailableSpareThreshold", RawValue: uint64(log.AvailableSpareThreshold)},
-		{Name: "PercentageUsed", RawValue: uint64(log.PercentageUsed)},
-		{Name: "DataUnitsRead", RawValue: log.DataUnitsRead},
-		{Name: "DataUnitsWritten", RawValue: log.DataUnitsWritten},
-		{Name: "HostReads", RawValue: uint64(log.HostReads)},
-		{Name: "HostWrites", RawValue: uint64(log.HostWrites)},
-		{Name: "ControllerBusyTime", RawValue: uint64(log.ControllerBusyTime)},
-		{Name: "PowerCycles", RawValue: uint64(log.PowerCycles)},
-		{Name: "PowerOnHours", RawValue: uint64(log.PowerOnHours)},
-		{Name: "UnsafeShutdowns", RawValue: uint64(log.UnsafeShutdowns)},
-		{Name: "MediaErrors", RawValue: uint64(log.MediaErrors)},
-		{Name: "NumErrLogEntries", RawValue: uint64(log.NumErrLogEntries)},
-		{Name: "WarningTempTime", RawValue: uint64(log.WarningTempTime)},
-		{Name: "CriticalCompTime", RawValue: uint64(log.CriticalCompTime)},
-	}
-
-	sm.SmartDataMap[keyName] = smartData
-
-	return true, data.Smartctl.ExitStatus
-}
-
-// detectSmartctl checks if smartctl is installed, returns an error if not
-func (sm *SmartManager) detectSmartctl() error {
-	if _, err := exec.LookPath("smartctl"); err == nil {
-		return nil
-	}
-	return fmt.Errorf("no smartctl found - install smartctl")
-}
-
-// NewSmartManager creates and initializes a new SmartManager
-func NewSmartManager() (*SmartManager, error) {
-	sm := &SmartManager{
-		SmartDataMap: make(map[string]*smart.SmartData),
-	}
-	if err := sm.detectSmartctl(); err != nil {
-		return nil, err
-	}
-
-	return sm, nil
-}

agent/system.go

@@ -14,18 +14,12 @@ import (
 	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/disk"
 	"github.com/shirou/gopsutil/v4/host"
 	"github.com/shirou/gopsutil/v4/load"
 	"github.com/shirou/gopsutil/v4/mem"
 )
 
-// prevDisk stores previous per-device disk counters for a given cache interval
-type prevDisk struct {
-	readBytes  uint64
-	writeBytes uint64
-	at         time.Time
-}
-
 // Sets initial / non-changing values about the host system
 func (a *Agent) initializeSystemInfo() {
 	a.systemInfo.AgentVersion = beszel.Version
@@ -74,21 +68,20 @@ func (a *Agent) initializeSystemInfo() {
 }
 
 // Returns current info, stats about the host system
-func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
+func (a *Agent) getSystemStats() system.Stats {
 	var systemStats system.Stats
 
 	// battery
-	if batteryPercent, batteryState, err := battery.GetBatteryStats(); err == nil {
-		systemStats.Battery[0] = batteryPercent
-		systemStats.Battery[1] = batteryState
+	if battery.HasReadableBattery() {
+		systemStats.Battery[0], systemStats.Battery[1], _ = battery.GetBatteryStats()
 	}
 
 	// cpu percent
-	cpuPercent, err := getCpuPercent(cacheTimeMs)
-	if err == nil {
-		systemStats.Cpu = twoDecimals(cpuPercent)
-	} else {
+	cpuPct, err := cpu.Percent(0, false)
+	if err != nil {
 		slog.Error("Error getting cpu percent", "err", err)
+	} else if len(cpuPct) > 0 {
+		systemStats.Cpu = twoDecimals(cpuPct[0])
 	}
 
 	// load average
@@ -107,22 +100,14 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
 		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
 		// cache + buffers value for default mem calculation
-		// note: gopsutil automatically adds SReclaimable to v.Cached
-		cacheBuff := v.Cached + v.Buffers - v.Shared
-		if cacheBuff <= 0 {
-			cacheBuff = max(v.Total-v.Free-v.Used, 0)
-		}
-		// htop memory calculation overrides (likely outdated as of mid 2025)
+		cacheBuff := v.Total - v.Free - v.Used
+		// htop memory calculation overrides
 		if a.memCalc == "htop" {
-			// cacheBuff = v.Cached + v.Buffers - v.Shared
+			// note: gopsutil automatically adds SReclaimable to v.Cached
+			cacheBuff = v.Cached + v.Buffers - v.Shared
 			v.Used = v.Total - (v.Free + cacheBuff)
 			v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
 		}
-		// if a.memCalc == "legacy" {
-		// 	v.Used = v.Total - v.Free - v.Buffers - v.Cached
-		// 	cacheBuff = v.Total - v.Free - v.Used
-		// 	v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
-		// }
 		// subtract ZFS ARC size from used memory and add as its own category
 		if a.zfs {
 			if arcSize, _ := getARCSize(); arcSize > 0 && arcSize < v.Used {
@@ -138,13 +123,56 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	}
 
 	// disk usage
-	a.updateDiskUsage(&systemStats)
+	for _, stats := range a.fsStats {
+		if d, err := disk.Usage(stats.Mountpoint); err == nil {
+			stats.DiskTotal = bytesToGigabytes(d.Total)
+			stats.DiskUsed = bytesToGigabytes(d.Used)
+			if stats.Root {
+				systemStats.DiskTotal = bytesToGigabytes(d.Total)
+				systemStats.DiskUsed = bytesToGigabytes(d.Used)
+				systemStats.DiskPct = twoDecimals(d.UsedPercent)
+			}
+		} else {
+			// reset stats if error (likely unmounted)
+			slog.Error("Error getting disk stats", "name", stats.Mountpoint, "err", err)
+			stats.DiskTotal = 0
+			stats.DiskUsed = 0
+			stats.TotalRead = 0
+			stats.TotalWrite = 0
+		}
+	}
 
-	// disk i/o (cache-aware per interval)
-	a.updateDiskIo(cacheTimeMs, &systemStats)
+	// disk i/o
+	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
+		for _, d := range ioCounters {
+			stats := a.fsStats[d.Name]
+			if stats == nil {
+				continue
+			}
+			secondsElapsed := time.Since(stats.Time).Seconds()
+			readPerSecond := bytesToMegabytes(float64(d.ReadBytes-stats.TotalRead) / secondsElapsed)
+			writePerSecond := bytesToMegabytes(float64(d.WriteBytes-stats.TotalWrite) / secondsElapsed)
+			// check for invalid values and reset stats if so
+			if readPerSecond < 0 || writePerSecond < 0 || readPerSecond > 50_000 || writePerSecond > 50_000 {
+				slog.Warn("Invalid disk I/O. Resetting.", "name", d.Name, "read", readPerSecond, "write", writePerSecond)
+				a.initializeDiskIoStats(ioCounters)
+				break
+			}
+			stats.Time = time.Now()
+			stats.DiskReadPs = readPerSecond
+			stats.DiskWritePs = writePerSecond
+			stats.TotalRead = d.ReadBytes
+			stats.TotalWrite = d.WriteBytes
+			// if root filesystem, update system stats
+			if stats.Root {
+				systemStats.DiskReadPs = stats.DiskReadPs
+				systemStats.DiskWritePs = stats.DiskWritePs
+			}
+		}
+	}
 
-	// network stats (per cache interval)
-	a.updateNetworkStats(cacheTimeMs, &systemStats)
+	// network stats
+	a.updateNetworkStats(&systemStats)
 
 	// temperatures
 	// TODO: maybe refactor to methods on systemStats
@@ -155,7 +183,7 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		// reset high gpu percent
 		a.systemInfo.GpuPct = 0
 		// get current GPU data
-		if gpuData := a.gpuManager.GetCurrentData(cacheTimeMs); len(gpuData) > 0 {
+		if gpuData := a.gpuManager.GetCurrentData(); len(gpuData) > 0 {
 			systemStats.GPUData = gpuData
 
 			// add temperatures

agent/test-data/container.json

@@ -1,24 +0,0 @@
-{
-	"cpu_stats": {
-		"cpu_usage": {
-			"total_usage": 312055276000
-		},
-		"system_cpu_usage": 1366399830000000
-	},
-	"memory_stats": {
-		"usage": 507400192,
-		"stats": {
-			"inactive_file": 165130240
-		}
-	},
-	"networks": {
-		"eth0": {
-			"tx_bytes": 20376558,
-			"rx_bytes": 537029455
-		},
-		"eth1": {
-			"tx_bytes": 2003766,
-			"rx_bytes": 6241
-		}
-	}
-}

agent/test-data/container2.json

@@ -1,24 +0,0 @@
-{
-	"cpu_stats": {
-		"cpu_usage": {
-			"total_usage": 314891801000
-		},
-		"system_cpu_usage": 1368474900000000
-	},
-	"memory_stats": {
-		"usage": 507400192,
-		"stats": {
-			"inactive_file": 165130240
-		}
-	},
-	"networks": {
-		"eth0": {
-			"tx_bytes": 20376558,
-			"rx_bytes": 537029455
-		},
-		"eth1": {
-			"tx_bytes": 2003766,
-			"rx_bytes": 6241
-		}
-	}
-}

agent/update.go

@@ -30,22 +30,21 @@ func (s *systemdRestarter) Restart() error {
 type openRCRestarter struct{ cmd string }
 
 func (o *openRCRestarter) Restart() error {
-	if err := exec.Command(o.cmd, "beszel-agent", "status").Run(); err != nil {
+	if err := exec.Command(o.cmd, "status", "beszel-agent").Run(); err != nil {
 		return nil
 	}
 	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via OpenRC…")
-	return exec.Command(o.cmd, "beszel-agent", "restart").Run()
+	return exec.Command(o.cmd, "restart", "beszel-agent").Run()
 }
 
 type openWRTRestarter struct{ cmd string }
 
 func (w *openWRTRestarter) Restart() error {
-	// https://openwrt.org/docs/guide-user/base-system/managing_services?s[]=service
-	if err := exec.Command("/etc/init.d/beszel-agent", "running").Run(); err != nil {
+	if err := exec.Command(w.cmd, "running", "beszel-agent").Run(); err != nil {
 		return nil
 	}
 	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via procd…")
-	return exec.Command("/etc/init.d/beszel-agent", "restart").Run()
+	return exec.Command(w.cmd, "restart", "beszel-agent").Run()
 }
 
 type freeBSDRestarter struct{ cmd string }
@@ -65,13 +64,11 @@ func detectRestarter() restarter {
 	if path, err := exec.LookPath("rc-service"); err == nil {
 		return &openRCRestarter{cmd: path}
 	}
-    if path, err := exec.LookPath("procd"); err == nil {
-        return &openWRTRestarter{cmd: path}
-    }
 	if path, err := exec.LookPath("service"); err == nil {
 		if runtime.GOOS == "freebsd" {
 			return &freeBSDRestarter{cmd: path}
 		}
+		return &openWRTRestarter{cmd: path}
 	}
 	return nil
 }

beszel.go

@@ -6,13 +6,10 @@ import "github.com/blang/semver"
 
 const (
 	// Version is the current version of the application.
-	Version = "0.14.1"
+	Version = "0.12.9"
 	// AppName is the name of the application.
 	AppName = "beszel"
 )
 
 // MinVersionCbor is the minimum supported version for CBOR compatibility.
 var MinVersionCbor = semver.MustParse("0.12.0")
-
-// MinVersionAgentResponse is the minimum supported version for AgentResponse compatibility.
-var MinVersionAgentResponse = semver.MustParse("0.13.0")

go.mod

@@ -3,7 +3,7 @@ module github.com/henrygd/beszel
 go 1.25.1
 
 // lock shoutrrr to specific version to allow review before updating
-replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.9.1
+replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.8.8
 
 require (
 	github.com/blang/semver v3.5.1+incompatible
@@ -12,16 +12,16 @@ require (
 	github.com/gliderlabs/ssh v0.3.8
 	github.com/google/uuid v1.6.0
 	github.com/lxzan/gws v1.8.9
-	github.com/nicholas-fedor/shoutrrr v0.10.0
+	github.com/nicholas-fedor/shoutrrr v0.8.17
 	github.com/pocketbase/dbx v1.11.0
-	github.com/pocketbase/pocketbase v0.30.1
-	github.com/shirou/gopsutil/v4 v4.25.9
-	github.com/spf13/cast v1.10.0
-	github.com/spf13/cobra v1.10.1
-	github.com/spf13/pflag v1.0.10
-	github.com/stretchr/testify v1.11.1
-	golang.org/x/crypto v0.42.0
-	golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9
+	github.com/pocketbase/pocketbase v0.29.3
+	github.com/shirou/gopsutil/v4 v4.25.6
+	github.com/spf13/cast v1.9.2
+	github.com/spf13/cobra v1.9.1
+	github.com/spf13/pflag v1.0.7
+	github.com/stretchr/testify v1.11.0
+	golang.org/x/crypto v0.41.0
+	golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -33,9 +33,9 @@ require (
 	github.com/dolthub/maphash v0.1.0 // indirect
 	github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/ebitengine/purego v0.9.0 // indirect
+	github.com/ebitengine/purego v0.8.4 // indirect
 	github.com/fatih/color v1.18.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.10 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
 	github.com/ganigeorgiev/fexpr v0.5.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
@@ -43,7 +43,7 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 // indirect
+	github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
@@ -54,16 +54,16 @@ require (
 	github.com/tklauser/numcpus v0.10.0 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/image v0.31.0 // indirect
-	golang.org/x/net v0.44.0 // indirect
-	golang.org/x/oauth2 v0.31.0 // indirect
-	golang.org/x/sync v0.17.0 // indirect
-	golang.org/x/sys v0.36.0 // indirect
-	golang.org/x/text v0.29.0 // indirect
+	golang.org/x/image v0.30.0 // indirect
+	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/oauth2 v0.30.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	howett.net/plist v1.0.1 // indirect
 	modernc.org/libc v1.66.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.39.0 // indirect
+	modernc.org/sqlite v1.38.2 // indirect
 )

go.sum

@@ -1,7 +1,5 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
-github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg=
@@ -23,22 +21,22 @@ github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCO
 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/ebitengine/purego v0.9.0 h1:mh0zpKBIXDceC63hpvPuGLiJ8ZAa3DfrFTudmfi8A4k=
-github.com/ebitengine/purego v0.9.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
+github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
 github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
-github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
-github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
+github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
 github.com/ganigeorgiev/fexpr v0.5.0 h1:XA9JxtTE/Xm+g/JFI6RfZEHSiQlk+1glLvRK1Lpv/Tk=
 github.com/ganigeorgiev/fexpr v0.5.0/go.mod h1:RyGiGqmeXhEQ6+mlGdnUleLHgtzzu/VGO2WtJkF5drE=
 github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -54,14 +52,14 @@ github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArs
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 h1:EEHtgt9IwisQ2AZ4pIsMjahcegHh6rmhqxzIRQIyepY=
-github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/jarcoal/httpmock v1.4.1 h1:0Ju+VCFuARfFlhVXFc2HxlcQkfB+Xq12/EotHko+x2A=
-github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
+github.com/jarcoal/httpmock v1.4.0 h1:BvhqnH0JAYbNudL2GMJKgOHe2CtKlzJ/5rWKyp+hc2k=
+github.com/jarcoal/httpmock v1.4.0/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
@@ -69,8 +67,8 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 h1:mFWunSatvkQQDhpdyuFAYwyAan3hzCuma+Pz8sqvOfg=
-github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
+github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d h1:vFzYZc8yji+9DmNRhpEbs8VBK4CgV/DPfGzeVJSSp/8=
+github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/lxzan/gws v1.8.9 h1:VU3SGUeWlQrEwfUSfokcZep8mdg/BrUF+y73YYshdBM=
 github.com/lxzan/gws v1.8.9/go.mod h1:d9yHaR1eDTBHagQC6KY7ycUOaz5KWeqQtP3xu7aMK8Y=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
@@ -79,19 +77,19 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.9.1 h1:SEBhM6P1favzILO0f55CY3P9JwvM9RZ7B1ZMCl+Injs=
-github.com/nicholas-fedor/shoutrrr v0.9.1/go.mod h1:khue5m8LYyMzdPWuJxDTJeT89l9gjwjA+a+r0e8qxxk=
-github.com/onsi/ginkgo/v2 v2.25.3 h1:Ty8+Yi/ayDAGtk4XxmmfUy4GabvM+MegeB4cDLRi6nw=
-github.com/onsi/ginkgo/v2 v2.25.3/go.mod h1:43uiyQC4Ed2tkOzLsEYm7hnrb7UJTWHYNsuy3bG/snE=
-github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
-github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
+github.com/nicholas-fedor/shoutrrr v0.8.8 h1:F/oyoatWK5cbHPPgkjRZrA0262TP7KWuUQz9KskRtR8=
+github.com/nicholas-fedor/shoutrrr v0.8.8/go.mod h1:T30Y+eoZFEjDk4HtOItcHQioZSOe3Z6a6aNfSz6jc5c=
+github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus=
+github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8=
+github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
+github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pocketbase/dbx v1.11.0 h1:LpZezioMfT3K4tLrqA55wWFw1EtH1pM4tzSVa7kgszU=
 github.com/pocketbase/dbx v1.11.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
-github.com/pocketbase/pocketbase v0.30.1 h1:8lgfhH+HiSw1PyKVMq2sjtC4ZNvda2f/envTAzWMLOA=
-github.com/pocketbase/pocketbase v0.30.1/go.mod h1:sUI+uekXZam5Wa0eh+DClc+HieKMCeqsHA7Ydd9vwyE=
+github.com/pocketbase/pocketbase v0.29.3 h1:Mj8o5awsbVJIdIoTuQNhfC2oL/c4aImQ3RyfFZlzFVg=
+github.com/pocketbase/pocketbase v0.29.3/go.mod h1:oGpT67LObxCFK4V2fSL7J9YnPbBnnshOpJ5v3zcneww=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
@@ -99,19 +97,19 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v4 v4.25.9 h1:JImNpf6gCVhKgZhtaAHJ0serfFGtlfIlSC08eaKdTrU=
-github.com/shirou/gopsutil/v4 v4.25.9/go.mod h1:gxIxoC+7nQRwUl/xNhutXlD8lq+jxTgpIkEf3rADHL8=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
-github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
-github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
+github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
+github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
+github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
+github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.11.0 h1:ib4sjIrwZKxE5u/Japgo/7SJV3PvgjGiRNAvTVGqQl8=
+github.com/stretchr/testify v1.11.0/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
 github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
 github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
@@ -122,44 +120,42 @@ github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
 go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
-golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
-golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9 h1:TQwNpfvNkxAVlItJf6Cr5JTsVZoC/Sj7K3OZv2Pc14A=
-golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b h1:DXr+pvt3nC887026GRP39Ej11UATqWDmWuS99x26cD0=
+golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.31.0 h1:mLChjE2MV6g1S7oqbXC0/UcKijjm5fnJLUYKIYrLESA=
-golang.org/x/image v0.31.0/go.mod h1:R9ec5Lcp96v9FTF+ajwaH3uGxPH4fKfHHAVbUILxghA=
-golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
-golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
+golang.org/x/image v0.30.0 h1:jD5RhkmVAnjqaCUXfbGBrn3lpxbknfN9w2UhHHU+5B4=
+golang.org/x/image v0.30.0/go.mod h1:SAEUTxCCMWSrJcCy/4HwavEsfZZJlYxeHLc6tTiAe/c=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
-golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo=
-golang.org/x/oauth2 v0.31.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
+golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
-golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
+golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
-golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
-golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
-google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -189,8 +185,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
 modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.39.0 h1:6bwu9Ooim0yVYA7IZn9demiQk/Ejp0BtTjBWFLymSeY=
-modernc.org/sqlite v1.39.0/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
+modernc.org/sqlite v1.38.2 h1:Aclu7+tgjgcQVShZqim41Bbw9Cho0y/7WzYptXqkEek=
+modernc.org/sqlite v1.38.2/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=

internal/common/common-ws.go

@@ -1,43 +1,22 @@
 package common
 
-import (
-	"github.com/henrygd/beszel/internal/entities/smart"
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
 type WebSocketAction = uint8
 
+// Not implemented yet
+// type AgentError = uint8
+
 const (
 	// Request system data from agent
 	GetData WebSocketAction = iota
 	// Check the fingerprint of the agent
 	CheckFingerprint
-	// Request container logs from agent
-	GetContainerLogs
-	// Request container info from agent
-	GetContainerInfo
-	// Request SMART data from agent
-	GetSmartData
-	// Add new actions here...
 )
 
 // HubRequest defines the structure for requests sent from hub to agent.
 type HubRequest[T any] struct {
 	Action WebSocketAction `cbor:"0,keyasint"`
 	Data   T               `cbor:"1,keyasint,omitempty,omitzero"`
-	Id     *uint32         `cbor:"2,keyasint,omitempty"`
-}
-
-// AgentResponse defines the structure for responses sent from agent to hub.
-type AgentResponse struct {
-	Id          *uint32                    `cbor:"0,keyasint,omitempty"`
-	SystemData  *system.CombinedData       `cbor:"1,keyasint,omitempty,omitzero"`
-	Fingerprint *FingerprintResponse       `cbor:"2,keyasint,omitempty,omitzero"`
-	Error       string                     `cbor:"3,keyasint,omitempty,omitzero"`
-	String      *string                    `cbor:"4,keyasint,omitempty,omitzero"`
-	SmartData   map[string]smart.SmartData `cbor:"5,keyasint,omitempty,omitzero"`
-	// Logs        *LogsPayload         `cbor:"4,keyasint,omitempty,omitzero"`
-	// RawBytes    []byte               `cbor:"4,keyasint,omitempty,omitzero"`
+	// Error  AgentError      `cbor:"error,omitempty,omitzero"`
 }
 
 type FingerprintRequest struct {
@@ -48,20 +27,6 @@ type FingerprintRequest struct {
 type FingerprintResponse struct {
 	Fingerprint string `cbor:"0,keyasint"`
 	// Optional system info for universal token system creation
-	Hostname string `cbor:"1,keyasint,omitzero"`
-	Port     string `cbor:"2,keyasint,omitzero"`
-	Name     string `cbor:"3,keyasint,omitzero"`
-}
-
-type DataRequestOptions struct {
-	CacheTimeMs uint16 `cbor:"0,keyasint"`
-	// ResourceType uint8  `cbor:"1,keyasint,omitempty,omitzero"`
-}
-
-type ContainerLogsRequest struct {
-	ContainerID string `cbor:"0,keyasint"`
-}
-
-type ContainerInfoRequest struct {
-	ContainerID string `cbor:"0,keyasint"`
+	Hostname string `cbor:"1,keyasint,omitempty,omitzero"`
+	Port     string `cbor:"2,keyasint,omitempty,omitzero"`
 }

internal/dockerfile_agent

@@ -23,7 +23,4 @@ COPY --from=builder /agent /agent
 # this is so we don't need to create the /tmp directory in the scratch container
 COPY --from=builder /tmp /tmp
 
-# Ensure data persistence across container recreations
-VOLUME ["/var/lib/beszel-agent"]
-
 ENTRYPOINT ["/agent"]

internal/dockerfile_agent_alpine

@@ -1,28 +0,0 @@
-FROM --platform=$BUILDPLATFORM golang:alpine AS builder
-
-WORKDIR /app
-
-COPY ../go.mod ../go.sum ./
-RUN go mod download
-
-# Copy source files
-COPY . ./
-
-# Build
-ARG TARGETOS TARGETARCH
-RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./internal/cmd/agent
-
-RUN rm -rf /tmp/*
-
-# --------------------------
-# Final image: default scratch-based agent
-# --------------------------
-FROM alpine:latest
-COPY --from=builder /agent /agent
-
-RUN apk add --no-cache smartmontools
-
-# Ensure data persistence across container recreations
-VOLUME ["/var/lib/beszel-agent"]
-
-ENTRYPOINT ["/agent"]

internal/dockerfile_agent_intel

@@ -1,28 +0,0 @@
-FROM --platform=$BUILDPLATFORM golang:alpine AS builder
-
-WORKDIR /app
-
-COPY ../go.mod ../go.sum ./
-RUN go mod download
-
-# Copy source files
-COPY . ./
-
-# Build
-ARG TARGETOS TARGETARCH
-RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./internal/cmd/agent
-
-# --------------------------
-# Final image
-# Note: must cap_add: [CAP_PERFMON] and mount /dev/dri/ as volume
-# --------------------------
-FROM alpine:edge
-
-COPY --from=builder /agent /agent
-
-RUN apk add --no-cache -X https://dl-cdn.alpinelinux.org/alpine/edge/testing igt-gpu-tools smartmontools
-
-# Ensure data persistence across container recreations
-VOLUME ["/var/lib/beszel-agent"]
-
-ENTRYPOINT ["/agent"]

internal/dockerfile_agent_nvidia

@@ -24,9 +24,4 @@ COPY --from=builder /agent /agent
 # this is so we don't need to create the /tmp directory in the scratch container
 COPY --from=builder /tmp /tmp
 
-RUN apt-get update && apt-get install -y smartmontools && rm -rf /var/lib/apt/lists/*
-
-# Ensure data persistence across container recreations
-VOLUME ["/var/lib/beszel-agent"]
-
 ENTRYPOINT ["/agent"]

internal/dockerfile_hub

@@ -25,9 +25,6 @@ FROM scratch
 COPY --from=builder /beszel /
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-# Ensure data persistence across container recreations
-VOLUME ["/beszel_data"]
-
 EXPOSE 8090
 
 ENTRYPOINT [ "/beszel" ]

internal/entities/container/container.go

@@ -8,8 +8,7 @@ type ApiInfo struct {
 	IdShort string
 	Names   []string
 	Status  string
-	State   string
-	Image   string
+	// Image   string
 	// ImageID string
 	// Command string
 	// Created int64
@@ -17,6 +16,7 @@ type ApiInfo struct {
 	// SizeRw     int64 `json:",omitempty"`
 	// SizeRootFs int64 `json:",omitempty"`
 	// Labels     map[string]string
+	// State      string
 	// HostConfig struct {
 	// 	NetworkMode string            `json:",omitempty"`
 	// 	Annotations map[string]string `json:",omitempty"`
@@ -103,22 +103,6 @@ type prevNetStats struct {
 	Recv uint64
 }
 
-type DockerHealth = uint8
-
-const (
-	DockerHealthNone DockerHealth = iota
-	DockerHealthStarting
-	DockerHealthHealthy
-	DockerHealthUnhealthy
-)
-
-var DockerHealthStrings = map[string]DockerHealth{
-	"none":      DockerHealthNone,
-	"starting":  DockerHealthStarting,
-	"healthy":   DockerHealthHealthy,
-	"unhealthy": DockerHealthUnhealthy,
-}
-
 // Docker container stats
 type Stats struct {
 	Name        string  `json:"n" cbor:"0,keyasint"`
@@ -126,11 +110,6 @@ type Stats struct {
 	Mem         float64 `json:"m" cbor:"2,keyasint"`
 	NetworkSent float64 `json:"ns" cbor:"3,keyasint"`
 	NetworkRecv float64 `json:"nr" cbor:"4,keyasint"`
-
-	Health DockerHealth `json:"-" cbor:"5,keyasint"`
-	Status string       `json:"-" cbor:"6,keyasint"`
-	Id     string       `json:"-" cbor:"7,keyasint"`
-	Image  string       `json:"-" cbor:"8,keyasint"`
 	// PrevCpu     [2]uint64    `json:"-"`
 	CpuSystem    uint64       `json:"-"`
 	CpuContainer uint64       `json:"-"`

internal/entities/smart/smart.go

@@ -1,362 +0,0 @@
-package smart
-
-// Common types
-type VersionInfo [2]int
-
-type SmartctlInfo struct {
-	Version      VersionInfo `json:"version"`
-	SvnRevision  string      `json:"svn_revision"`
-	PlatformInfo string      `json:"platform_info"`
-	BuildInfo    string      `json:"build_info"`
-	Argv         []string    `json:"argv"`
-	ExitStatus   int         `json:"exit_status"`
-}
-
-type DeviceInfo struct {
-	Name     string `json:"name"`
-	InfoName string `json:"info_name"`
-	Type     string `json:"type"`
-	Protocol string `json:"protocol"`
-}
-
-type UserCapacity struct {
-	Blocks uint64 `json:"blocks"`
-	Bytes  uint64 `json:"bytes"`
-}
-
-// type LocalTime struct {
-// 	TimeT   int64  `json:"time_t"`
-// 	Asctime string `json:"asctime"`
-// }
-
-// type WwnInfo struct {
-// 	Naa int `json:"naa"`
-// 	Oui int `json:"oui"`
-// 	ID  int `json:"id"`
-// }
-
-// type FormFactorInfo struct {
-// 	AtaValue int    `json:"ata_value"`
-// 	Name     string `json:"name"`
-// }
-
-// type TrimInfo struct {
-// 	Supported bool `json:"supported"`
-// }
-
-// type AtaVersionInfo struct {
-// 	String     string `json:"string"`
-// 	MajorValue int    `json:"major_value"`
-// 	MinorValue int    `json:"minor_value"`
-// }
-
-// type VersionStringInfo struct {
-// 	String string `json:"string"`
-// 	Value  int    `json:"value"`
-// }
-
-// type SpeedInfo struct {
-// 	SataValue      int    `json:"sata_value"`
-// 	String         string `json:"string"`
-// 	UnitsPerSecond int    `json:"units_per_second"`
-// 	BitsPerUnit    int    `json:"bits_per_unit"`
-// }
-
-// type InterfaceSpeedInfo struct {
-// 	Max     SpeedInfo `json:"max"`
-// 	Current SpeedInfo `json:"current"`
-// }
-
-type SmartStatusInfo struct {
-	Passed bool `json:"passed"`
-}
-
-type StatusInfo struct {
-	Value  int    `json:"value"`
-	String string `json:"string"`
-	Passed bool   `json:"passed"`
-}
-
-type PollingMinutes struct {
-	Short    int `json:"short"`
-	Extended int `json:"extended"`
-}
-
-type CapabilitiesInfo struct {
-	Values                        []int `json:"values"`
-	ExecOfflineImmediateSupported bool  `json:"exec_offline_immediate_supported"`
-	OfflineIsAbortedUponNewCmd    bool  `json:"offline_is_aborted_upon_new_cmd"`
-	OfflineSurfaceScanSupported   bool  `json:"offline_surface_scan_supported"`
-	SelfTestsSupported            bool  `json:"self_tests_supported"`
-	ConveyanceSelfTestSupported   bool  `json:"conveyance_self_test_supported"`
-	SelectiveSelfTestSupported    bool  `json:"selective_self_test_supported"`
-	AttributeAutosaveEnabled      bool  `json:"attribute_autosave_enabled"`
-	ErrorLoggingSupported         bool  `json:"error_logging_supported"`
-	GpLoggingSupported            bool  `json:"gp_logging_supported"`
-}
-
-// type AtaSmartData struct {
-// 	OfflineDataCollection OfflineDataCollectionInfo `json:"offline_data_collection"`
-// 	SelfTest              SelfTestInfo              `json:"self_test"`
-// 	Capabilities          CapabilitiesInfo          `json:"capabilities"`
-// }
-
-// type OfflineDataCollectionInfo struct {
-// 	Status            StatusInfo `json:"status"`
-// 	CompletionSeconds int        `json:"completion_seconds"`
-// }
-
-// type SelfTestInfo struct {
-// 	Status         StatusInfo     `json:"status"`
-// 	PollingMinutes PollingMinutes `json:"polling_minutes"`
-// }
-
-// type AtaSctCapabilities struct {
-// 	Value                         int  `json:"value"`
-// 	ErrorRecoveryControlSupported bool `json:"error_recovery_control_supported"`
-// 	FeatureControlSupported       bool `json:"feature_control_supported"`
-// 	DataTableSupported            bool `json:"data_table_supported"`
-// }
-
-type SummaryInfo struct {
-	Revision int `json:"revision"`
-	Count    int `json:"count"`
-}
-
-type AtaSmartAttributes struct {
-	// Revision int                 `json:"revision"`
-	Table []AtaSmartAttribute `json:"table"`
-}
-
-type AtaSmartAttribute struct {
-	ID         uint16         `json:"id"`
-	Name       string         `json:"name"`
-	Value      uint16         `json:"value"`
-	Worst      uint16         `json:"worst"`
-	Thresh     uint16         `json:"thresh"`
-	WhenFailed string         `json:"when_failed"`
-	Flags      AttributeFlags `json:"flags"`
-	Raw        RawValue       `json:"raw"`
-}
-
-type AttributeFlags struct {
-	Value         int    `json:"value"`
-	String        string `json:"string"`
-	Prefailure    bool   `json:"prefailure"`
-	UpdatedOnline bool   `json:"updated_online"`
-	Performance   bool   `json:"performance"`
-	ErrorRate     bool   `json:"error_rate"`
-	EventCount    bool   `json:"event_count"`
-	AutoKeep      bool   `json:"auto_keep"`
-}
-
-type RawValue struct {
-	Value  uint64 `json:"value"`
-	String string `json:"string"`
-}
-
-// type PowerOnTimeInfo struct {
-// 	Hours uint32 `json:"hours"`
-// }
-
-type TemperatureInfo struct {
-	Current uint8 `json:"current"`
-}
-
-// type SelectiveSelfTestTable struct {
-// 	LbaMin int        `json:"lba_min"`
-// 	LbaMax int        `json:"lba_max"`
-// 	Status StatusInfo `json:"status"`
-// }
-
-// type SelectiveSelfTestFlags struct {
-// 	Value                int  `json:"value"`
-// 	RemainderScanEnabled bool `json:"remainder_scan_enabled"`
-// }
-
-// type AtaSmartSelectiveSelfTestLog struct {
-// 	Revision                 int                      `json:"revision"`
-// 	Table                    []SelectiveSelfTestTable `json:"table"`
-// 	Flags                    SelectiveSelfTestFlags   `json:"flags"`
-// 	PowerUpScanResumeMinutes int                      `json:"power_up_scan_resume_minutes"`
-// }
-
-// BaseSmartInfo contains common fields shared between SATA and NVMe drives
-// type BaseSmartInfo struct {
-// 	Device           DeviceInfo   `json:"device"`
-// 	ModelName        string       `json:"model_name"`
-// 	SerialNumber     string       `json:"serial_number"`
-// 	FirmwareVersion  string       `json:"firmware_version"`
-// 	UserCapacity     UserCapacity `json:"user_capacity"`
-// 	LogicalBlockSize int          `json:"logical_block_size"`
-// 	LocalTime        LocalTime    `json:"local_time"`
-// }
-
-type SmartctlInfoLegacy struct {
-	Version      VersionInfo `json:"version"`
-	SvnRevision  string      `json:"svn_revision"`
-	PlatformInfo string      `json:"platform_info"`
-	BuildInfo    string      `json:"build_info"`
-	Argv         []string    `json:"argv"`
-	ExitStatus   int         `json:"exit_status"`
-}
-
-type SmartInfoForSata struct {
-	// JSONFormatVersion VersionInfo        `json:"json_format_version"`
-	Smartctl SmartctlInfoLegacy `json:"smartctl"`
-	Device   DeviceInfo         `json:"device"`
-	// ModelFamily  string             `json:"model_family"`
-	ModelName    string `json:"model_name"`
-	SerialNumber string `json:"serial_number"`
-	// Wwn               WwnInfo            `json:"wwn"`
-	FirmwareVersion string       `json:"firmware_version"`
-	UserCapacity    UserCapacity `json:"user_capacity"`
-	// LogicalBlockSize  int                `json:"logical_block_size"`
-	// PhysicalBlockSize int                `json:"physical_block_size"`
-	// RotationRate      int                `json:"rotation_rate"`
-	// FormFactor        FormFactorInfo     `json:"form_factor"`
-	// Trim                         TrimInfo                     `json:"trim"`
-	// InSmartctlDatabase           bool                         `json:"in_smartctl_database"`
-	// AtaVersion                   AtaVersionInfo               `json:"ata_version"`
-	// SataVersion                  VersionStringInfo            `json:"sata_version"`
-	// InterfaceSpeed               InterfaceSpeedInfo           `json:"interface_speed"`
-	// LocalTime                    LocalTime                    `json:"local_time"`
-	SmartStatus SmartStatusInfo `json:"smart_status"`
-	// AtaSmartData                 AtaSmartData                 `json:"ata_smart_data"`
-	// AtaSctCapabilities           AtaSctCapabilities           `json:"ata_sct_capabilities"`
-	AtaSmartAttributes AtaSmartAttributes `json:"ata_smart_attributes"`
-	// PowerOnTime                  PowerOnTimeInfo              `json:"power_on_time"`
-	// PowerCycleCount              uint16                       `json:"power_cycle_count"`
-	Temperature TemperatureInfo `json:"temperature"`
-	// AtaSmartErrorLog             AtaSmartErrorLog             `json:"ata_smart_error_log"`
-	// AtaSmartSelfTestLog          AtaSmartSelfTestLog          `json:"ata_smart_self_test_log"`
-	// AtaSmartSelectiveSelfTestLog AtaSmartSelectiveSelfTestLog `json:"ata_smart_selective_self_test_log"`
-}
-
-// type AtaSmartErrorLog struct {
-// 	Summary SummaryInfo `json:"summary"`
-// }
-
-// type AtaSmartSelfTestLog struct {
-// 	Standard SummaryInfo `json:"standard"`
-// }
-
-type SmartctlInfoNvme struct {
-	Version      VersionInfo `json:"version"`
-	SVNRevision  string      `json:"svn_revision"`
-	PlatformInfo string      `json:"platform_info"`
-	BuildInfo    string      `json:"build_info"`
-	Argv         []string    `json:"argv"`
-	ExitStatus   int         `json:"exit_status"`
-}
-
-// type NVMePCIVendor struct {
-// 	ID          int `json:"id"`
-// 	SubsystemID int `json:"subsystem_id"`
-// }
-
-// type SizeCapacityInfo struct {
-// 	Blocks uint64 `json:"blocks"`
-// 	Bytes  uint64 `json:"bytes"`
-// }
-
-// type EUI64Info struct {
-// 	OUI   int `json:"oui"`
-// 	ExtID int `json:"ext_id"`
-// }
-
-// type NVMeNamespace struct {
-// 	ID               uint32           `json:"id"`
-// 	Size             SizeCapacityInfo `json:"size"`
-// 	Capacity         SizeCapacityInfo `json:"capacity"`
-// 	Utilization      SizeCapacityInfo `json:"utilization"`
-// 	FormattedLBASize uint32           `json:"formatted_lba_size"`
-// 	EUI64            EUI64Info        `json:"eui64"`
-// }
-
-type SmartStatusInfoNvme struct {
-	Passed bool            `json:"passed"`
-	NVMe   SmartStatusNVMe `json:"nvme"`
-}
-
-type SmartStatusNVMe struct {
-	Value int `json:"value"`
-}
-
-type NVMeSmartHealthInformationLog struct {
-	CriticalWarning         uint    `json:"critical_warning"`
-	Temperature             uint8   `json:"temperature"`
-	AvailableSpare          uint    `json:"available_spare"`
-	AvailableSpareThreshold uint    `json:"available_spare_threshold"`
-	PercentageUsed          uint8   `json:"percentage_used"`
-	DataUnitsRead           uint64  `json:"data_units_read"`
-	DataUnitsWritten        uint64  `json:"data_units_written"`
-	HostReads               uint    `json:"host_reads"`
-	HostWrites              uint    `json:"host_writes"`
-	ControllerBusyTime      uint    `json:"controller_busy_time"`
-	PowerCycles             uint16  `json:"power_cycles"`
-	PowerOnHours            uint32  `json:"power_on_hours"`
-	UnsafeShutdowns         uint16  `json:"unsafe_shutdowns"`
-	MediaErrors             uint    `json:"media_errors"`
-	NumErrLogEntries        uint    `json:"num_err_log_entries"`
-	WarningTempTime         uint    `json:"warning_temp_time"`
-	CriticalCompTime        uint    `json:"critical_comp_time"`
-	TemperatureSensors      []uint8 `json:"temperature_sensors"`
-}
-
-type SmartInfoForNvme struct {
-	// JSONFormatVersion             VersionInfo                   `json:"json_format_version"`
-	Smartctl        SmartctlInfoNvme `json:"smartctl"`
-	Device          DeviceInfo       `json:"device"`
-	ModelName       string           `json:"model_name"`
-	SerialNumber    string           `json:"serial_number"`
-	FirmwareVersion string           `json:"firmware_version"`
-	// NVMePCIVendor                 NVMePCIVendor                 `json:"nvme_pci_vendor"`
-	// NVMeIEEEOUIIdentifier         uint32                        `json:"nvme_ieee_oui_identifier"`
-	// NVMeTotalCapacity             uint64                        `json:"nvme_total_capacity"`
-	// NVMeUnallocatedCapacity       uint64                        `json:"nvme_unallocated_capacity"`
-	// NVMeControllerID              uint16                        `json:"nvme_controller_id"`
-	// NVMeVersion                   VersionStringInfo             `json:"nvme_version"`
-	// NVMeNumberOfNamespaces        uint8                         `json:"nvme_number_of_namespaces"`
-	// NVMeNamespaces                []NVMeNamespace               `json:"nvme_namespaces"`
-	UserCapacity UserCapacity `json:"user_capacity"`
-	// LogicalBlockSize              int                           `json:"logical_block_size"`
-	// LocalTime                     LocalTime                     `json:"local_time"`
-	SmartStatus                   SmartStatusInfoNvme           `json:"smart_status"`
-	NVMeSmartHealthInformationLog NVMeSmartHealthInformationLog `json:"nvme_smart_health_information_log"`
-	Temperature                   TemperatureInfoNvme           `json:"temperature"`
-	PowerCycleCount               uint16                        `json:"power_cycle_count"`
-	PowerOnTime                   PowerOnTimeInfoNvme           `json:"power_on_time"`
-}
-
-type TemperatureInfoNvme struct {
-	Current int `json:"current"`
-}
-
-type PowerOnTimeInfoNvme struct {
-	Hours int `json:"hours"`
-}
-
-type SmartData struct {
-	// ModelFamily     string            `json:"mf,omitempty" cbor:"0,keyasint,omitempty"`
-	ModelName       string            `json:"mn,omitempty" cbor:"1,keyasint,omitempty"`
-	SerialNumber    string            `json:"sn,omitempty" cbor:"2,keyasint,omitempty"`
-	FirmwareVersion string            `json:"fv,omitempty" cbor:"3,keyasint,omitempty"`
-	Capacity        uint64            `json:"c,omitempty" cbor:"4,keyasint,omitempty"`
-	SmartStatus     string            `json:"s,omitempty" cbor:"5,keyasint,omitempty"`
-	DiskName        string            `json:"dn,omitempty" cbor:"6,keyasint,omitempty"`
-	DiskType        string            `json:"dt,omitempty" cbor:"7,keyasint,omitempty"`
-	Temperature     uint8             `json:"t,omitempty" cbor:"8,keyasint,omitempty"`
-	Attributes      []*SmartAttribute `json:"a,omitempty" cbor:"9,keyasint,omitempty"`
-}
-
-type SmartAttribute struct {
-	ID         uint16 `json:"id,omitempty" cbor:"0,keyasint,omitempty"`
-	Name       string `json:"n" cbor:"1,keyasint"`
-	Value      uint16 `json:"v,omitempty" cbor:"2,keyasint,omitempty"`
-	Worst      uint16 `json:"w,omitempty" cbor:"3,keyasint,omitempty"`
-	Threshold  uint16 `json:"t,omitempty" cbor:"4,keyasint,omitempty"`
-	RawValue   uint64 `json:"rv" cbor:"5,keyasint"`
-	RawString  string `json:"rs,omitempty" cbor:"6,keyasint,omitempty"`
-	WhenFailed string `json:"wf,omitempty" cbor:"7,keyasint,omitempty"`
-}

internal/entities/system/system.go

@@ -42,8 +42,6 @@ type Stats struct {
 	Battery           [2]uint8             `json:"bat,omitzero" cbor:"29,keyasint,omitzero"` // [percent, charge state, current]
 	MaxMem            float64              `json:"mm,omitempty" cbor:"30,keyasint,omitempty"`
 	NetworkInterfaces map[string][4]uint64 `json:"ni,omitempty" cbor:"31,keyasint,omitempty"` // [upload bytes, download bytes, total upload, total download]
-	DiskIO            [2]uint64            `json:"dio,omitzero" cbor:"32,keyasint,omitzero"`  // [read bytes, write bytes]
-	MaxDiskIO         [2]uint64            `json:"diom,omitzero" cbor:"-"`                    // [max read bytes, max write bytes]
 }
 
 type GPUData struct {
@@ -55,14 +53,12 @@ type GPUData struct {
 	Power       float64            `json:"p,omitempty" cbor:"4,keyasint,omitempty"`
 	Count       float64            `json:"-"`
 	Engines     map[string]float64 `json:"e,omitempty" cbor:"5,keyasint,omitempty"`
-	PowerPkg    float64            `json:"pp,omitempty" cbor:"6,keyasint,omitempty"`
 }
 
 type FsStats struct {
 	Time           time.Time `json:"-"`
 	Root           bool      `json:"-"`
 	Mountpoint     string    `json:"-"`
-	Name           string    `json:"-"`
 	DiskTotal      float64   `json:"d" cbor:"0,keyasint"`
 	DiskUsed       float64   `json:"du" cbor:"1,keyasint"`
 	TotalRead      uint64    `json:"-"`
@@ -71,11 +67,6 @@ type FsStats struct {
 	DiskWritePs    float64   `json:"w" cbor:"3,keyasint"`
 	MaxDiskReadPS  float64   `json:"rm,omitempty" cbor:"4,keyasint,omitempty"`
 	MaxDiskWritePS float64   `json:"wm,omitempty" cbor:"5,keyasint,omitempty"`
-	// TODO: remove DiskReadPs and DiskWritePs in future release in favor of DiskReadBytes and DiskWriteBytes
-	DiskReadBytes     uint64 `json:"rb" cbor:"6,keyasint,omitempty"`
-	DiskWriteBytes    uint64 `json:"wb" cbor:"7,keyasint,omitempty"`
-	MaxDiskReadBytes  uint64 `json:"rbm,omitempty" cbor:"-"`
-	MaxDiskWriteBytes uint64 `json:"wbm,omitempty" cbor:"-"`
 }
 
 type NetIoStats struct {

internal/hub/agent_connect.go

@@ -1,7 +1,6 @@
 package hub
 
 import (
-	"context"
 	"errors"
 	"net"
 	"net/http"
@@ -94,7 +93,7 @@ func (acr *agentConnectRequest) agentConnect() (err error) {
 // verifyWsConn verifies the WebSocket connection using the agent's fingerprint and
 // SSH key signature, then adds the system to the system manager.
 func (acr *agentConnectRequest) verifyWsConn(conn *gws.Conn, fpRecords []ws.FingerprintRecord) (err error) {
-	wsConn := ws.NewWsConnection(conn, acr.agentSemVer)
+	wsConn := ws.NewWsConnection(conn)
 
 	// must set wsConn in connection store before the read loop
 	conn.Session().Store("wsConn", wsConn)
@@ -113,7 +112,7 @@ func (acr *agentConnectRequest) verifyWsConn(conn *gws.Conn, fpRecords []ws.Fing
 		return err
 	}
 
-	agentFingerprint, err := wsConn.GetFingerprint(context.Background(), acr.token, signer, acr.isUniversalToken)
+	agentFingerprint, err := wsConn.GetFingerprint(acr.token, signer, acr.isUniversalToken)
 	if err != nil {
 		return err
 	}
@@ -268,12 +267,9 @@ func (acr *agentConnectRequest) createSystem(agentFingerprint common.Fingerprint
 	if agentFingerprint.Port == "" {
 		agentFingerprint.Port = "45876"
 	}
-	if agentFingerprint.Name == "" {
-		agentFingerprint.Name = agentFingerprint.Hostname
-	}
 	// create new record
 	systemRecord := core.NewRecord(systemsCollection)
-	systemRecord.Set("name", agentFingerprint.Name)
+	systemRecord.Set("name", agentFingerprint.Hostname)
 	systemRecord.Set("host", remoteAddr)
 	systemRecord.Set("port", agentFingerprint.Port)
 	systemRecord.Set("users", []string{acr.userId})

internal/hub/hub.go

@@ -120,19 +120,7 @@ func (h *Hub) initialize(e *core.ServeEvent) error {
 		return err
 	}
 	// set auth settings
-	if err := setCollectionAuthSettings(e.App); err != nil {
-		return err
-	}
-	return nil
-}
-
-// setCollectionAuthSettings sets up default authentication settings for the app
-func setCollectionAuthSettings(app core.App) error {
-	usersCollection, err := app.FindCollectionByNameOrId("users")
-	if err != nil {
-		return err
-	}
-	superusersCollection, err := app.FindCollectionByNameOrId(core.CollectionNameSuperusers)
+	usersCollection, err := e.App.FindCollectionByNameOrId("users")
 	if err != nil {
 		return err
 	}
@@ -140,6 +128,10 @@ func setCollectionAuthSettings(app core.App) error {
 	disablePasswordAuth, _ := GetEnv("DISABLE_PASSWORD_AUTH")
 	usersCollection.PasswordAuth.Enabled = disablePasswordAuth != "true"
 	usersCollection.PasswordAuth.IdentityFields = []string{"email"}
+	// disable oauth if no providers are configured (todo: remove this in post 0.9.0 release)
+	if usersCollection.OAuth2.Enabled {
+		usersCollection.OAuth2.Enabled = len(usersCollection.OAuth2.Providers) > 0
+	}
 	// allow oauth user creation if USER_CREATION is set
 	if userCreation, _ := GetEnv("USER_CREATION"); userCreation == "true" {
 		cr := "@request.context = 'oauth2'"
@@ -147,22 +139,11 @@ func setCollectionAuthSettings(app core.App) error {
 	} else {
 		usersCollection.CreateRule = nil
 	}
-	// enable mfaOtp mfa if MFA_OTP env var is set
-	mfaOtp, _ := GetEnv("MFA_OTP")
-	usersCollection.OTP.Length = 6
-	superusersCollection.OTP.Length = 6
-	usersCollection.OTP.Enabled = mfaOtp == "true"
-	usersCollection.MFA.Enabled = mfaOtp == "true"
-	superusersCollection.OTP.Enabled = mfaOtp == "true" || mfaOtp == "superusers"
-	superusersCollection.MFA.Enabled = mfaOtp == "true" || mfaOtp == "superusers"
-	if err := app.Save(superusersCollection); err != nil {
-		return err
-	}
-	if err := app.Save(usersCollection); err != nil {
+	if err := e.App.Save(usersCollection); err != nil {
 		return err
 	}
 	// allow all users to access systems if SHARE_ALL_SYSTEMS is set
-	systemsCollection, err := app.FindCollectionByNameOrId("systems")
+	systemsCollection, err := e.App.FindCachedCollectionByNameOrId("systems")
 	if err != nil {
 		return err
 	}
@@ -177,7 +158,10 @@ func setCollectionAuthSettings(app core.App) error {
 	systemsCollection.ViewRule = &systemsReadRule
 	systemsCollection.UpdateRule = &updateDeleteRule
 	systemsCollection.DeleteRule = &updateDeleteRule
-	return app.Save(systemsCollection)
+	if err := e.App.Save(systemsCollection); err != nil {
+		return err
+	}
+	return nil
 }
 
 // registerCronJobs sets up scheduled tasks
@@ -252,12 +236,7 @@ func (h *Hub) registerApiRoutes(se *core.ServeEvent) error {
 	// update / delete user alerts
 	apiAuth.POST("/user-alerts", alerts.UpsertUserAlerts)
 	apiAuth.DELETE("/user-alerts", alerts.DeleteUserAlerts)
-	// get container logs
-	apiAuth.GET("/containers/logs", h.getContainerLogs)
-	// get container info
-	apiAuth.GET("/containers/info", h.getContainerInfo)
-	// get SMART data
-	apiAuth.GET("/smart", h.getSmartData)
+
 	return nil
 }
 
@@ -288,59 +267,6 @@ func (h *Hub) getUniversalToken(e *core.RequestEvent) error {
 	return e.JSON(http.StatusOK, response)
 }
 
-// containerRequestHandler handles both container logs and info requests
-func (h *Hub) containerRequestHandler(e *core.RequestEvent, fetchFunc func(*systems.System, string) (string, error), responseKey string) error {
-	systemID := e.Request.URL.Query().Get("system")
-	containerID := e.Request.URL.Query().Get("container")
-
-	if systemID == "" || containerID == "" {
-		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system and container parameters are required"})
-	}
-
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return e.JSON(http.StatusNotFound, map[string]string{"error": "system not found"})
-	}
-
-	data, err := fetchFunc(system, containerID)
-	if err != nil {
-		return e.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
-	}
-
-	return e.JSON(http.StatusOK, map[string]string{responseKey: data})
-}
-
-// getContainerLogs handles GET /api/beszel/containers/logs requests
-func (h *Hub) getContainerLogs(e *core.RequestEvent) error {
-	return h.containerRequestHandler(e, func(system *systems.System, containerID string) (string, error) {
-		return system.FetchContainerLogsFromAgent(containerID)
-	}, "logs")
-}
-
-func (h *Hub) getContainerInfo(e *core.RequestEvent) error {
-	return h.containerRequestHandler(e, func(system *systems.System, containerID string) (string, error) {
-		return system.FetchContainerInfoFromAgent(containerID)
-	}, "info")
-}
-
-// getSmartData handles GET /api/beszel/smart requests
-func (h *Hub) getSmartData(e *core.RequestEvent) error {
-	systemID := e.Request.URL.Query().Get("system")
-	if systemID == "" {
-		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system parameter is required"})
-	}
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return e.JSON(http.StatusNotFound, map[string]string{"error": "system not found"})
-	}
-	data, err := system.FetchSmartDataFromAgent()
-	if err != nil {
-		return e.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
-	}
-	e.Response.Header().Set("Cache-Control", "public, max-age=60")
-	return e.JSON(http.StatusOK, data)
-}
-
 // generates key pair if it doesn't exist and returns signer
 func (h *Hub) GetSSHKey(dataDir string) (ssh.Signer, error) {
 	if h.signer != nil {

internal/hub/hub_test.go

@@ -449,47 +449,6 @@ func TestApiRoutesAuthentication(t *testing.T) {
 				})
 			},
 		},
-		{
-			Name:            "GET /containers/logs - no auth should fail",
-			Method:          http.MethodGet,
-			URL:             "/api/beszel/containers/logs?system=test-system&container=test-container",
-			ExpectedStatus:  401,
-			ExpectedContent: []string{"requires valid"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /containers/logs - with auth but missing system param should fail",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/logs?container=test-container",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"system and container parameters are required"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /containers/logs - with auth but missing container param should fail",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/logs?system=test-system",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"system and container parameters are required"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "GET /containers/logs - with auth but invalid system should fail",
-			Method: http.MethodGet,
-			URL:    "/api/beszel/containers/logs?system=invalid-system&container=test-container",
-			Headers: map[string]string{
-				"Authorization": userToken,
-			},
-			ExpectedStatus:  404,
-			ExpectedContent: []string{"system not found"},
-			TestAppFactory:  testAppFactory,
-		},
 
 		// Auth Optional Routes - Should work without authentication
 		{

internal/hub/systems/system.go

@@ -10,17 +10,14 @@ import (
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel/internal/common"
 	"github.com/henrygd/beszel/internal/hub/ws"
 
-	"github.com/henrygd/beszel/internal/entities/container"
 	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/henrygd/beszel"
 
 	"github.com/blang/semver"
 	"github.com/fxamacker/cbor/v2"
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"golang.org/x/crypto/ssh"
 )
@@ -110,7 +107,7 @@ func (sys *System) update() error {
 		sys.handlePaused()
 		return nil
 	}
-	data, err := sys.fetchDataFromAgent(common.DataRequestOptions{CacheTimeMs: uint16(interval)})
+	data, err := sys.fetchDataFromAgent()
 	if err == nil {
 		_, err = sys.createRecords(data)
 	}
@@ -137,81 +134,41 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 		return nil, err
 	}
 	hub := sys.manager.hub
-	err = hub.RunInTransaction(func(txApp core.App) error {
-		// add system_stats and container_stats records
-		systemStatsCollection, err := txApp.FindCachedCollectionByNameOrId("system_stats")
+	// add system_stats and container_stats records
+	systemStatsCollection, err := hub.FindCachedCollectionByNameOrId("system_stats")
+	if err != nil {
+		return nil, err
+	}
+
+	systemStatsRecord := core.NewRecord(systemStatsCollection)
+	systemStatsRecord.Set("system", systemRecord.Id)
+	systemStatsRecord.Set("stats", data.Stats)
+	systemStatsRecord.Set("type", "1m")
+	if err := hub.SaveNoValidate(systemStatsRecord); err != nil {
+		return nil, err
+	}
+	// add new container_stats record
+	if len(data.Containers) > 0 {
+		containerStatsCollection, err := hub.FindCachedCollectionByNameOrId("container_stats")
 		if err != nil {
-			return err
+			return nil, err
 		}
-
-		systemStatsRecord := core.NewRecord(systemStatsCollection)
-		systemStatsRecord.Set("system", systemRecord.Id)
-		systemStatsRecord.Set("stats", data.Stats)
-		systemStatsRecord.Set("type", "1m")
-		if err := txApp.SaveNoValidate(systemStatsRecord); err != nil {
-			return err
+		containerStatsRecord := core.NewRecord(containerStatsCollection)
+		containerStatsRecord.Set("system", systemRecord.Id)
+		containerStatsRecord.Set("stats", data.Containers)
+		containerStatsRecord.Set("type", "1m")
+		if err := hub.SaveNoValidate(containerStatsRecord); err != nil {
+			return nil, err
 		}
-		if len(data.Containers) > 0 {
-			// add / update containers records
-			if data.Containers[0].Id != "" {
-				if err := createContainerRecords(txApp, data.Containers, sys.Id); err != nil {
-					return err
-				}
-			}
-			// add new container_stats record
-			containerStatsCollection, err := txApp.FindCachedCollectionByNameOrId("container_stats")
-			if err != nil {
-				return err
-			}
-			containerStatsRecord := core.NewRecord(containerStatsCollection)
-			containerStatsRecord.Set("system", systemRecord.Id)
-			containerStatsRecord.Set("stats", data.Containers)
-			containerStatsRecord.Set("type", "1m")
-			if err := txApp.SaveNoValidate(containerStatsRecord); err != nil {
-				return err
-			}
-		}
-		// update system record (do this last because it triggers alerts and we need above records to be inserted first)
-		systemRecord.Set("status", up)
-
-		systemRecord.Set("info", data.Info)
-		if err := txApp.SaveNoValidate(systemRecord); err != nil {
-			return err
-		}
-		return nil
-	})
-
-	return systemRecord, err
-}
-
-// createContainerRecords creates container records
-func createContainerRecords(app core.App, data []*container.Stats, systemId string) error {
-	if len(data) == 0 {
-		return nil
 	}
-	params := dbx.Params{
-		"system":  systemId,
-		"updated": time.Now().UTC().UnixMilli(),
+	// update system record (do this last because it triggers alerts and we need above records to be inserted first)
+	systemRecord.Set("status", up)
+
+	systemRecord.Set("info", data.Info)
+	if err := hub.SaveNoValidate(systemRecord); err != nil {
+		return nil, err
 	}
-	valueStrings := make([]string, 0, len(data))
-	for i, container := range data {
-		suffix := fmt.Sprintf("%d", i)
-		valueStrings = append(valueStrings, fmt.Sprintf("({:id%[1]s}, {:system}, {:name%[1]s}, {:image%[1]s}, {:status%[1]s}, {:health%[1]s}, {:cpu%[1]s}, {:memory%[1]s}, {:net%[1]s}, {:updated})", suffix))
-		params["id"+suffix] = container.Id
-		params["name"+suffix] = container.Name
-		params["image"+suffix] = container.Image
-		params["status"+suffix] = container.Status
-		params["health"+suffix] = container.Health
-		params["cpu"+suffix] = container.Cpu
-		params["memory"+suffix] = container.Mem
-		params["net"+suffix] = container.NetworkSent + container.NetworkRecv
-	}
-	queryString := fmt.Sprintf(
-		"INSERT INTO containers (id, system, name, image, status, health, cpu, memory, net, updated) VALUES %s ON CONFLICT(id) DO UPDATE SET system = excluded.system, name = excluded.name, image = excluded.image, status = excluded.status, health = excluded.health, cpu = excluded.cpu, memory = excluded.memory, net = excluded.net, updated = excluded.updated",
-		strings.Join(valueStrings, ","),
-	)
-	_, err := app.DB().NewQuery(queryString).Bind(params).Execute()
-	return err
+	return systemRecord, nil
 }
 
 // getRecord retrieves the system record from the database.
@@ -252,13 +209,13 @@ func (sys *System) getContext() (context.Context, context.CancelFunc) {
 
 // fetchDataFromAgent attempts to fetch data from the agent,
 // prioritizing WebSocket if available.
-func (sys *System) fetchDataFromAgent(options common.DataRequestOptions) (*system.CombinedData, error) {
+func (sys *System) fetchDataFromAgent() (*system.CombinedData, error) {
 	if sys.data == nil {
 		sys.data = &system.CombinedData{}
 	}
 
 	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		wsData, err := sys.fetchDataViaWebSocket(options)
+		wsData, err := sys.fetchDataViaWebSocket()
 		if err == nil {
 			return wsData, nil
 		}
@@ -266,214 +223,82 @@ func (sys *System) fetchDataFromAgent(options common.DataRequestOptions) (*syste
 		sys.closeWebSocketConnection()
 	}
 
-	sshData, err := sys.fetchDataViaSSH(options)
+	sshData, err := sys.fetchDataViaSSH()
 	if err != nil {
 		return nil, err
 	}
 	return sshData, nil
 }
 
-func (sys *System) fetchDataViaWebSocket(options common.DataRequestOptions) (*system.CombinedData, error) {
+func (sys *System) fetchDataViaWebSocket() (*system.CombinedData, error) {
 	if sys.WsConn == nil || !sys.WsConn.IsConnected() {
 		return nil, errors.New("no websocket connection")
 	}
-	err := sys.WsConn.RequestSystemData(context.Background(), sys.data, options)
+	err := sys.WsConn.RequestSystemData(sys.data)
 	if err != nil {
 		return nil, err
 	}
 	return sys.data, nil
 }
 
-// fetchStringFromAgentViaSSH is a generic function to fetch strings via SSH
-func (sys *System) fetchStringFromAgentViaSSH(action common.WebSocketAction, requestData any, errorMsg string) (string, error) {
-	var result string
-	err := sys.runSSHOperation(4*time.Second, 1, func(session *ssh.Session) (bool, error) {
-		stdout, err := session.StdoutPipe()
-		if err != nil {
-			return false, err
-		}
-		stdin, stdinErr := session.StdinPipe()
-		if stdinErr != nil {
-			return false, stdinErr
-		}
-		if err := session.Shell(); err != nil {
-			return false, err
-		}
-		req := common.HubRequest[any]{Action: action, Data: requestData}
-		_ = cbor.NewEncoder(stdin).Encode(req)
-		_ = stdin.Close()
-		var resp common.AgentResponse
-		err = cbor.NewDecoder(stdout).Decode(&resp)
-		if err != nil {
-			return false, err
-		}
-		if resp.String == nil {
-			return false, errors.New(errorMsg)
-		}
-		result = *resp.String
-		return false, nil
-	})
-	return result, err
-}
-
-// FetchContainerInfoFromAgent fetches container info from the agent
-func (sys *System) FetchContainerInfoFromAgent(containerID string) (string, error) {
-	// fetch via websocket
-	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		return sys.WsConn.RequestContainerInfo(ctx, containerID)
-	}
-	// fetch via SSH
-	return sys.fetchStringFromAgentViaSSH(common.GetContainerInfo, common.ContainerInfoRequest{ContainerID: containerID}, "no info in response")
-}
-
-// FetchContainerLogsFromAgent fetches container logs from the agent
-func (sys *System) FetchContainerLogsFromAgent(containerID string) (string, error) {
-	// fetch via websocket
-	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		return sys.WsConn.RequestContainerLogs(ctx, containerID)
-	}
-	// fetch via SSH
-	return sys.fetchStringFromAgentViaSSH(common.GetContainerLogs, common.ContainerLogsRequest{ContainerID: containerID}, "no logs in response")
-}
-
-// FetchSmartDataFromAgent fetches SMART data from the agent
-func (sys *System) FetchSmartDataFromAgent() (map[string]any, error) {
-	// fetch via websocket
-	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		return sys.WsConn.RequestSmartData(ctx)
-	}
-	// fetch via SSH
-	var result map[string]any
-	err := sys.runSSHOperation(5*time.Second, 1, func(session *ssh.Session) (bool, error) {
-		stdout, err := session.StdoutPipe()
-		if err != nil {
-			return false, err
-		}
-		stdin, stdinErr := session.StdinPipe()
-		if stdinErr != nil {
-			return false, stdinErr
-		}
-		if err := session.Shell(); err != nil {
-			return false, err
-		}
-		req := common.HubRequest[any]{Action: common.GetSmartData}
-		_ = cbor.NewEncoder(stdin).Encode(req)
-		_ = stdin.Close()
-		var resp common.AgentResponse
-		if err := cbor.NewDecoder(stdout).Decode(&resp); err != nil {
-			return false, err
-		}
-		// Convert to generic map for JSON response
-		result = make(map[string]any, len(resp.SmartData))
-		for k, v := range resp.SmartData {
-			result[k] = v
-		}
-		return false, nil
-	})
-	return result, err
-}
-
 // fetchDataViaSSH handles fetching data using SSH.
 // This function encapsulates the original SSH logic.
 // It updates sys.data directly upon successful fetch.
-func (sys *System) fetchDataViaSSH(options common.DataRequestOptions) (*system.CombinedData, error) {
-	err := sys.runSSHOperation(4*time.Second, 1, func(session *ssh.Session) (bool, error) {
+func (sys *System) fetchDataViaSSH() (*system.CombinedData, error) {
+	maxRetries := 1
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		if sys.client == nil || sys.Status == down {
+			if err := sys.createSSHClient(); err != nil {
+				return nil, err
+			}
+		}
+
+		session, err := sys.createSessionWithTimeout(4 * time.Second)
+		if err != nil {
+			if attempt >= maxRetries {
+				return nil, err
+			}
+			sys.manager.hub.Logger().Warn("Session closed. Retrying...", "host", sys.Host, "port", sys.Port, "err", err)
+			sys.closeSSHConnection()
+			// Reset format detection on connection failure - agent might have been upgraded
+			continue
+		}
+		defer session.Close()
+
 		stdout, err := session.StdoutPipe()
 		if err != nil {
-			return false, err
+			return nil, err
 		}
-		stdin, stdinErr := session.StdinPipe()
 		if err := session.Shell(); err != nil {
-			return false, err
+			return nil, err
 		}
 
 		*sys.data = system.CombinedData{}
 
-		if sys.agentVersion.GTE(beszel.MinVersionAgentResponse) && stdinErr == nil {
-			req := common.HubRequest[any]{Action: common.GetData, Data: options}
-			_ = cbor.NewEncoder(stdin).Encode(req)
-			_ = stdin.Close()
-
-			var resp common.AgentResponse
-			if decErr := cbor.NewDecoder(stdout).Decode(&resp); decErr == nil && resp.SystemData != nil {
-				*sys.data = *resp.SystemData
-				if err := session.Wait(); err != nil {
-					return false, err
-				}
-				return false, nil
-			}
-		}
-
-		var decodeErr error
 		if sys.agentVersion.GTE(beszel.MinVersionCbor) {
-			decodeErr = cbor.NewDecoder(stdout).Decode(sys.data)
+			err = cbor.NewDecoder(stdout).Decode(sys.data)
 		} else {
-			decodeErr = json.NewDecoder(stdout).Decode(sys.data)
+			err = json.NewDecoder(stdout).Decode(sys.data)
 		}
 
-		if decodeErr != nil {
-			return true, decodeErr
-		}
-
-		if err := session.Wait(); err != nil {
-			return false, err
-		}
-
-		return false, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return sys.data, nil
-}
-
-// runSSHOperation establishes an SSH session and executes the provided operation.
-// The operation can request a retry by returning true as the first return value.
-func (sys *System) runSSHOperation(timeout time.Duration, retries int, operation func(*ssh.Session) (bool, error)) error {
-	for attempt := 0; attempt <= retries; attempt++ {
-		if sys.client == nil || sys.Status == down {
-			if err := sys.createSSHClient(); err != nil {
-				return err
-			}
-		}
-
-		session, err := sys.createSessionWithTimeout(timeout)
 		if err != nil {
-			if attempt >= retries {
-				return err
-			}
-			sys.manager.hub.Logger().Warn("Session closed. Retrying...", "host", sys.Host, "port", sys.Port, "err", err)
 			sys.closeSSHConnection()
-			continue
-		}
-
-		retry, opErr := func() (bool, error) {
-			defer session.Close()
-			return operation(session)
-		}()
-
-		if opErr == nil {
-			return nil
-		}
-
-		if retry {
-			sys.closeSSHConnection()
-			if attempt < retries {
+			if attempt < maxRetries {
 				continue
 			}
+			return nil, err
 		}
 
-		return opErr
+		// wait for the session to complete
+		if err := session.Wait(); err != nil {
+			return nil, err
+		}
+
+		return sys.data, nil
 	}
 
-	return fmt.Errorf("ssh operation failed")
+	// this should never be reached due to the return in the loop
+	return nil, fmt.Errorf("failed to fetch data")
 }
 
 // createSSHClient creates a new SSH client for the system
@@ -554,11 +379,11 @@ func extractAgentVersion(versionString string) (semver.Version, error) {
 }
 
 // getJitter returns a channel that will be triggered after a random delay
-// between 51% and 95% of the interval.
+// between 40% and 90% of the interval.
 // This is used to stagger the initial WebSocket connections to prevent clustering.
 func getJitter() <-chan time.Time {
-	minPercent := 51
-	maxPercent := 95
+	minPercent := 40
+	maxPercent := 90
 	jitterRange := maxPercent - minPercent
 	msDelay := (interval * minPercent / 100) + rand.Intn(interval*jitterRange/100)
 	return time.After(time.Duration(msDelay) * time.Millisecond)

internal/hub/systems/system_manager.go

@@ -63,15 +63,6 @@ func NewSystemManager(hub hubLike) *SystemManager {
 	}
 }
 
-// GetSystem returns a system by ID from the store
-func (sm *SystemManager) GetSystem(systemID string) (*System, error) {
-	sys, ok := sm.systems.GetOk(systemID)
-	if !ok {
-		return nil, fmt.Errorf("system not found")
-	}
-	return sys, nil
-}
-
 // Initialize sets up the system manager by binding event hooks and starting existing systems.
 // It configures SSH client settings and begins monitoring all non-paused systems from the database.
 // Systems are started with staggered delays to prevent overwhelming the hub during startup.
@@ -115,8 +106,6 @@ func (sm *SystemManager) bindEventHooks() {
 	sm.hub.OnRecordAfterUpdateSuccess("systems").BindFunc(sm.onRecordAfterUpdateSuccess)
 	sm.hub.OnRecordAfterDeleteSuccess("systems").BindFunc(sm.onRecordAfterDeleteSuccess)
 	sm.hub.OnRecordAfterUpdateSuccess("fingerprints").BindFunc(sm.onTokenRotated)
-	sm.hub.OnRealtimeSubscribeRequest().BindFunc(sm.onRealtimeSubscribeRequest)
-	sm.hub.OnRealtimeConnectRequest().BindFunc(sm.onRealtimeConnectRequest)
 }
 
 // onTokenRotated handles fingerprint token rotation events.

internal/hub/systems/system_realtime.go

@@ -1,188 +0,0 @@
-package systems
-
-import (
-	"encoding/json"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/subscriptions"
-)
-
-type subscriptionInfo struct {
-	subscription     string
-	connectedClients uint8
-}
-
-var (
-	activeSubscriptions = make(map[string]*subscriptionInfo)
-	workerRunning       bool
-	realtimeTicker      *time.Ticker
-	tickerStopChan      chan struct{}
-	realtimeMutex       sync.Mutex
-)
-
-// onRealtimeConnectRequest handles client connection events for realtime subscriptions.
-// It cleans up existing subscriptions when a client connects.
-func (sm *SystemManager) onRealtimeConnectRequest(e *core.RealtimeConnectRequestEvent) error {
-	// after e.Next() is the client disconnection
-	e.Next()
-	subscriptions := e.Client.Subscriptions()
-	for k := range subscriptions {
-		sm.removeRealtimeSubscription(k, subscriptions[k])
-	}
-	return nil
-}
-
-// onRealtimeSubscribeRequest handles client subscription events for realtime metrics.
-// It tracks new subscriptions and unsubscriptions to manage the realtime worker lifecycle.
-func (sm *SystemManager) onRealtimeSubscribeRequest(e *core.RealtimeSubscribeRequestEvent) error {
-	oldSubs := e.Client.Subscriptions()
-	// after e.Next() is the result of the subscribe request
-	err := e.Next()
-	newSubs := e.Client.Subscriptions()
-
-	// handle new subscriptions
-	for k, options := range newSubs {
-		if _, ok := oldSubs[k]; !ok {
-			if strings.HasPrefix(k, "rt_metrics") {
-				systemId := options.Query["system"]
-				if _, ok := activeSubscriptions[systemId]; !ok {
-					activeSubscriptions[systemId] = &subscriptionInfo{
-						subscription: k,
-					}
-				}
-				activeSubscriptions[systemId].connectedClients += 1
-				sm.onRealtimeSubscriptionAdded()
-			}
-		}
-	}
-	// handle unsubscriptions
-	for k := range oldSubs {
-		if _, ok := newSubs[k]; !ok {
-			sm.removeRealtimeSubscription(k, oldSubs[k])
-		}
-	}
-
-	return err
-}
-
-// onRealtimeSubscriptionAdded initializes or starts the realtime worker when the first subscription is added.
-// It ensures only one worker runs at a time and creates the ticker for periodic data fetching.
-func (sm *SystemManager) onRealtimeSubscriptionAdded() {
-	realtimeMutex.Lock()
-	defer realtimeMutex.Unlock()
-
-	// Start the worker if it's not already running
-	if !workerRunning {
-		workerRunning = true
-		// Create a new stop channel for this worker instance
-		tickerStopChan = make(chan struct{})
-		go sm.startRealtimeWorker()
-	}
-
-	// If no ticker exists, create one
-	if realtimeTicker == nil {
-		realtimeTicker = time.NewTicker(1 * time.Second)
-	}
-}
-
-// checkSubscriptions stops the realtime worker when there are no active subscriptions.
-// This prevents unnecessary resource usage when no clients are listening for realtime data.
-func (sm *SystemManager) checkSubscriptions() {
-	if !workerRunning || len(activeSubscriptions) > 0 {
-		return
-	}
-
-	realtimeMutex.Lock()
-	defer realtimeMutex.Unlock()
-
-	// Signal the worker to stop
-	if tickerStopChan != nil {
-		select {
-		case tickerStopChan <- struct{}{}:
-		default:
-		}
-	}
-
-	if realtimeTicker != nil {
-		realtimeTicker.Stop()
-		realtimeTicker = nil
-	}
-
-	// Mark worker as stopped (will be reset when next subscription comes in)
-	workerRunning = false
-}
-
-// removeRealtimeSubscription removes a realtime subscription and checks if the worker should be stopped.
-// It only processes subscriptions with the "rt_metrics" prefix and triggers cleanup when subscriptions are removed.
-func (sm *SystemManager) removeRealtimeSubscription(subscription string, options subscriptions.SubscriptionOptions) {
-	if strings.HasPrefix(subscription, "rt_metrics") {
-		systemId := options.Query["system"]
-		if info, ok := activeSubscriptions[systemId]; ok {
-			info.connectedClients -= 1
-			if info.connectedClients <= 0 {
-				delete(activeSubscriptions, systemId)
-			}
-		}
-		sm.checkSubscriptions()
-	}
-}
-
-// startRealtimeWorker runs the main loop for fetching realtime data from agents.
-// It continuously fetches system data and broadcasts it to subscribed clients via WebSocket.
-func (sm *SystemManager) startRealtimeWorker() {
-	sm.fetchRealtimeDataAndNotify()
-
-	for {
-		select {
-		case <-tickerStopChan:
-			return
-		case <-realtimeTicker.C:
-			// Check if ticker is still valid (might have been stopped)
-			if realtimeTicker == nil || len(activeSubscriptions) == 0 {
-				return
-			}
-			// slog.Debug("activeSubscriptions", "count", len(activeSubscriptions))
-			sm.fetchRealtimeDataAndNotify()
-		}
-	}
-}
-
-// fetchRealtimeDataAndNotify fetches realtime data for all active subscriptions and notifies the clients.
-func (sm *SystemManager) fetchRealtimeDataAndNotify() {
-	for systemId, info := range activeSubscriptions {
-		system, err := sm.GetSystem(systemId)
-		if err != nil {
-			continue
-		}
-		go func() {
-			data, err := system.fetchDataFromAgent(common.DataRequestOptions{CacheTimeMs: 1000})
-			if err != nil {
-				return
-			}
-			bytes, err := json.Marshal(data)
-			if err == nil {
-				notify(sm.hub, info.subscription, bytes)
-			}
-		}()
-	}
-}
-
-// notify broadcasts realtime data to all clients subscribed to a specific subscription.
-// It iterates through all connected clients and sends the data only to those with matching subscriptions.
-func notify(app core.App, subscription string, data []byte) error {
-	message := subscriptions.Message{
-		Name: subscription,
-		Data: data,
-	}
-	for _, client := range app.SubscriptionsBroker().Clients() {
-		if !client.HasSubscription(subscription) {
-			continue
-		}
-		client.Send(message)
-	}
-	return nil
-}

internal/hub/update.go

@@ -22,12 +22,6 @@ func Update(cmd *cobra.Command, _ []string) {
 	// Check if china-mirrors flag is set
 	useMirror, _ := cmd.Flags().GetBool("china-mirrors")
 
-	// Get the executable path before update
-	exePath, err := os.Executable()
-	if err != nil {
-		log.Fatal(err)
-	}
-
 	updated, err := ghupdate.Update(ghupdate.Config{
 		ArchiveExecutable: "beszel",
 		DataDir:           dataDir,
@@ -41,8 +35,11 @@ func Update(cmd *cobra.Command, _ []string) {
 	}
 
 	// make sure the file is executable
-	if err := os.Chmod(exePath, 0755); err != nil {
-		fmt.Printf("Warning: failed to set executable permissions: %v\n", err)
+	exePath, err := os.Executable()
+	if err == nil {
+		if err := os.Chmod(exePath, 0755); err != nil {
+			fmt.Printf("Warning: failed to set executable permissions: %v\n", err)
+		}
 	}
 
 	// Try to restart the service if it's running

internal/hub/ws/handlers.go

@@ -1,199 +0,0 @@
-package ws
-
-import (
-	"context"
-	"errors"
-
-	"github.com/fxamacker/cbor/v2"
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/lxzan/gws"
-	"golang.org/x/crypto/ssh"
-)
-
-// ResponseHandler defines interface for handling agent responses
-type ResponseHandler interface {
-	Handle(agentResponse common.AgentResponse) error
-	HandleLegacy(rawData []byte) error
-}
-
-// BaseHandler provides a default implementation that can be embedded to make HandleLegacy optional
-type BaseHandler struct{}
-
-func (h *BaseHandler) HandleLegacy(rawData []byte) error {
-	return errors.New("legacy format not supported")
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// systemDataHandler implements ResponseHandler for system data requests
-type systemDataHandler struct {
-	data *system.CombinedData
-}
-
-func (h *systemDataHandler) HandleLegacy(rawData []byte) error {
-	return cbor.Unmarshal(rawData, h.data)
-}
-
-func (h *systemDataHandler) Handle(agentResponse common.AgentResponse) error {
-	if agentResponse.SystemData != nil {
-		*h.data = *agentResponse.SystemData
-	}
-	return nil
-}
-
-// RequestSystemData requests system metrics from the agent and unmarshals the response.
-func (ws *WsConn) RequestSystemData(ctx context.Context, data *system.CombinedData, options common.DataRequestOptions) error {
-	if !ws.IsConnected() {
-		return gws.ErrConnClosed
-	}
-
-	req, err := ws.requestManager.SendRequest(ctx, common.GetData, options)
-	if err != nil {
-		return err
-	}
-
-	handler := &systemDataHandler{data: data}
-	return ws.handleAgentRequest(req, handler)
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// stringResponseHandler is a generic handler for string responses from agents
-type stringResponseHandler struct {
-	BaseHandler
-	value    string
-	errorMsg string
-}
-
-func (h *stringResponseHandler) Handle(agentResponse common.AgentResponse) error {
-	if agentResponse.String == nil {
-		return errors.New(h.errorMsg)
-	}
-	h.value = *agentResponse.String
-	return nil
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// requestContainerStringViaWS is a generic function to request container-related strings via WebSocket
-func (ws *WsConn) requestContainerStringViaWS(ctx context.Context, action common.WebSocketAction, requestData any, errorMsg string) (string, error) {
-	if !ws.IsConnected() {
-		return "", gws.ErrConnClosed
-	}
-
-	req, err := ws.requestManager.SendRequest(ctx, action, requestData)
-	if err != nil {
-		return "", err
-	}
-
-	handler := &stringResponseHandler{errorMsg: errorMsg}
-	if err := ws.handleAgentRequest(req, handler); err != nil {
-		return "", err
-	}
-
-	return handler.value, nil
-}
-
-// RequestContainerLogs requests logs for a specific container via WebSocket.
-func (ws *WsConn) RequestContainerLogs(ctx context.Context, containerID string) (string, error) {
-	return ws.requestContainerStringViaWS(ctx, common.GetContainerLogs, common.ContainerLogsRequest{ContainerID: containerID}, "no logs in response")
-}
-
-// RequestContainerInfo requests information about a specific container via WebSocket.
-func (ws *WsConn) RequestContainerInfo(ctx context.Context, containerID string) (string, error) {
-	return ws.requestContainerStringViaWS(ctx, common.GetContainerInfo, common.ContainerInfoRequest{ContainerID: containerID}, "no info in response")
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// RequestSmartData requests SMART data via WebSocket.
-func (ws *WsConn) RequestSmartData(ctx context.Context) (map[string]any, error) {
-	if !ws.IsConnected() {
-		return nil, gws.ErrConnClosed
-	}
-	req, err := ws.requestManager.SendRequest(ctx, common.GetSmartData, nil)
-	if err != nil {
-		return nil, err
-	}
-	var result map[string]any
-	handler := ResponseHandler(&smartDataHandler{result: &result})
-	if err := ws.handleAgentRequest(req, handler); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-// smartDataHandler parses SMART data map from AgentResponse
-type smartDataHandler struct {
-	BaseHandler
-	result *map[string]any
-}
-
-func (h *smartDataHandler) Handle(agentResponse common.AgentResponse) error {
-	if agentResponse.SmartData == nil {
-		return errors.New("no SMART data in response")
-	}
-	// convert to map[string]any for transport convenience in hub layer
-	out := make(map[string]any, len(agentResponse.SmartData))
-	for k, v := range agentResponse.SmartData {
-		out[k] = v
-	}
-	*h.result = out
-	return nil
-}
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// fingerprintHandler implements ResponseHandler for fingerprint requests
-type fingerprintHandler struct {
-	result *common.FingerprintResponse
-}
-
-func (h *fingerprintHandler) HandleLegacy(rawData []byte) error {
-	return cbor.Unmarshal(rawData, h.result)
-}
-
-func (h *fingerprintHandler) Handle(agentResponse common.AgentResponse) error {
-	if agentResponse.Fingerprint != nil {
-		*h.result = *agentResponse.Fingerprint
-		return nil
-	}
-	return errors.New("no fingerprint data in response")
-}
-
-// GetFingerprint authenticates with the agent using SSH signature and returns the agent's fingerprint.
-func (ws *WsConn) GetFingerprint(ctx context.Context, token string, signer ssh.Signer, needSysInfo bool) (common.FingerprintResponse, error) {
-	if !ws.IsConnected() {
-		return common.FingerprintResponse{}, gws.ErrConnClosed
-	}
-
-	challenge := []byte(token)
-	signature, err := signer.Sign(nil, challenge)
-	if err != nil {
-		return common.FingerprintResponse{}, err
-	}
-
-	req, err := ws.requestManager.SendRequest(ctx, common.CheckFingerprint, common.FingerprintRequest{
-		Signature:   signature.Blob,
-		NeedSysInfo: needSysInfo,
-	})
-	if err != nil {
-		return common.FingerprintResponse{}, err
-	}
-
-	var result common.FingerprintResponse
-	handler := &fingerprintHandler{result: &result}
-	err = ws.handleAgentRequest(req, handler)
-	return result, err
-}

internal/hub/ws/request_manager.go

@@ -1,186 +0,0 @@
-package ws
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/fxamacker/cbor/v2"
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/lxzan/gws"
-)
-
-// RequestID uniquely identifies a request
-type RequestID uint32
-
-// PendingRequest tracks an in-flight request
-type PendingRequest struct {
-	ID         RequestID
-	ResponseCh chan *gws.Message
-	Context    context.Context
-	Cancel     context.CancelFunc
-	CreatedAt  time.Time
-}
-
-// RequestManager handles concurrent requests to an agent
-type RequestManager struct {
-	sync.RWMutex
-	conn        *gws.Conn
-	pendingReqs map[RequestID]*PendingRequest
-	nextID      atomic.Uint32
-}
-
-// NewRequestManager creates a new request manager for a WebSocket connection
-func NewRequestManager(conn *gws.Conn) *RequestManager {
-	rm := &RequestManager{
-		conn:        conn,
-		pendingReqs: make(map[RequestID]*PendingRequest),
-	}
-	return rm
-}
-
-// SendRequest sends a request and returns a channel for the response
-func (rm *RequestManager) SendRequest(ctx context.Context, action common.WebSocketAction, data any) (*PendingRequest, error) {
-	reqID := RequestID(rm.nextID.Add(1))
-
-	reqCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
-
-	req := &PendingRequest{
-		ID:         reqID,
-		ResponseCh: make(chan *gws.Message, 1),
-		Context:    reqCtx,
-		Cancel:     cancel,
-		CreatedAt:  time.Now(),
-	}
-
-	rm.Lock()
-	rm.pendingReqs[reqID] = req
-	rm.Unlock()
-
-	hubReq := common.HubRequest[any]{
-		Id:     (*uint32)(&reqID),
-		Action: action,
-		Data:   data,
-	}
-
-	// Send the request
-	if err := rm.sendMessage(hubReq); err != nil {
-		rm.cancelRequest(reqID)
-		return nil, fmt.Errorf("failed to send request: %w", err)
-	}
-
-	// Start cleanup watcher for timeout/cancellation
-	go rm.cleanupRequest(req)
-
-	return req, nil
-}
-
-// sendMessage encodes and sends a message over WebSocket
-func (rm *RequestManager) sendMessage(data any) error {
-	if rm.conn == nil {
-		return gws.ErrConnClosed
-	}
-
-	bytes, err := cbor.Marshal(data)
-	if err != nil {
-		return fmt.Errorf("failed to marshal request: %w", err)
-	}
-
-	return rm.conn.WriteMessage(gws.OpcodeBinary, bytes)
-}
-
-// handleResponse processes a single response message
-func (rm *RequestManager) handleResponse(message *gws.Message) {
-	var response common.AgentResponse
-	if err := cbor.Unmarshal(message.Data.Bytes(), &response); err != nil {
-		// Legacy response without ID - route to first pending request of any type
-		rm.routeLegacyResponse(message)
-		return
-	}
-
-	reqID := RequestID(*response.Id)
-
-	rm.RLock()
-	req, exists := rm.pendingReqs[reqID]
-	rm.RUnlock()
-
-	if !exists {
-		// Request not found (might have timed out) - close the message
-		message.Close()
-		return
-	}
-
-	select {
-	case req.ResponseCh <- message:
-		// Message successfully delivered - the receiver will close it
-		rm.deleteRequest(reqID)
-	case <-req.Context.Done():
-		// Request was cancelled/timed out - close the message
-		message.Close()
-	}
-}
-
-// routeLegacyResponse handles responses that don't have request IDs (backwards compatibility)
-func (rm *RequestManager) routeLegacyResponse(message *gws.Message) {
-	// Snapshot the oldest pending request without holding the lock during send
-	rm.RLock()
-	var oldestReq *PendingRequest
-	for _, req := range rm.pendingReqs {
-		if oldestReq == nil || req.CreatedAt.Before(oldestReq.CreatedAt) {
-			oldestReq = req
-		}
-	}
-	rm.RUnlock()
-
-	if oldestReq != nil {
-		select {
-		case oldestReq.ResponseCh <- message:
-			// Message successfully delivered - the receiver will close it
-			rm.deleteRequest(oldestReq.ID)
-		case <-oldestReq.Context.Done():
-			// Request was cancelled - close the message
-			message.Close()
-		}
-	} else {
-		// No pending requests - close the message
-		message.Close()
-	}
-}
-
-// cleanupRequest handles request timeout and cleanup
-func (rm *RequestManager) cleanupRequest(req *PendingRequest) {
-	<-req.Context.Done()
-	rm.cancelRequest(req.ID)
-}
-
-// cancelRequest removes a request and cancels its context
-func (rm *RequestManager) cancelRequest(reqID RequestID) {
-	rm.Lock()
-	defer rm.Unlock()
-
-	if req, exists := rm.pendingReqs[reqID]; exists {
-		req.Cancel()
-		delete(rm.pendingReqs, reqID)
-	}
-}
-
-// deleteRequest removes a request from the pending map without cancelling its context.
-func (rm *RequestManager) deleteRequest(reqID RequestID) {
-	rm.Lock()
-	defer rm.Unlock()
-	delete(rm.pendingReqs, reqID)
-}
-
-// Close shuts down the request manager
-func (rm *RequestManager) Close() {
-	rm.Lock()
-	defer rm.Unlock()
-
-	// Cancel all pending requests
-	for _, req := range rm.pendingReqs {
-		req.Cancel()
-	}
-	rm.pendingReqs = make(map[RequestID]*PendingRequest)
-}

internal/hub/ws/request_manager_test.go

@@ -1,81 +0,0 @@
-//go:build testing
-// +build testing
-
-package ws
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestRequestManager_BasicFunctionality tests the request manager without mocking gws.Conn
-func TestRequestManager_BasicFunctionality(t *testing.T) {
-	// We'll test the core logic without mocking the connection
-	// since the gws.Conn interface is complex to mock properly
-
-	t.Run("request ID generation", func(t *testing.T) {
-		// Test that request IDs are generated sequentially and uniquely
-		rm := &RequestManager{}
-
-		// Simulate multiple ID generations
-		id1 := rm.nextID.Add(1)
-		id2 := rm.nextID.Add(1)
-		id3 := rm.nextID.Add(1)
-
-		assert.NotEqual(t, id1, id2)
-		assert.NotEqual(t, id2, id3)
-		assert.Greater(t, id2, id1)
-		assert.Greater(t, id3, id2)
-	})
-
-	t.Run("pending request tracking", func(t *testing.T) {
-		rm := &RequestManager{
-			pendingReqs: make(map[RequestID]*PendingRequest),
-		}
-
-		// Initially no pending requests
-		assert.Equal(t, 0, rm.GetPendingCount())
-
-		// Add some fake pending requests
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		req1 := &PendingRequest{
-			ID:      RequestID(1),
-			Context: ctx,
-			Cancel:  cancel,
-		}
-		req2 := &PendingRequest{
-			ID:      RequestID(2),
-			Context: ctx,
-			Cancel:  cancel,
-		}
-
-		rm.pendingReqs[req1.ID] = req1
-		rm.pendingReqs[req2.ID] = req2
-
-		assert.Equal(t, 2, rm.GetPendingCount())
-
-		// Remove one
-		delete(rm.pendingReqs, req1.ID)
-		assert.Equal(t, 1, rm.GetPendingCount())
-
-		// Remove all
-		delete(rm.pendingReqs, req2.ID)
-		assert.Equal(t, 0, rm.GetPendingCount())
-	})
-
-	t.Run("context cancellation", func(t *testing.T) {
-		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
-		defer cancel()
-
-		// Wait for context to timeout
-		<-ctx.Done()
-
-		// Verify context was cancelled
-		assert.Equal(t, context.DeadlineExceeded, ctx.Err())
-	})
-}

internal/hub/ws/ws.go

@@ -5,13 +5,13 @@ import (
 	"time"
 	"weak"
 
-	"github.com/blang/semver"
-	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/henrygd/beszel/internal/common"
 
 	"github.com/fxamacker/cbor/v2"
 	"github.com/lxzan/gws"
+	"golang.org/x/crypto/ssh"
 )
 
 const (
@@ -25,10 +25,9 @@ type Handler struct {
 
 // WsConn represents a WebSocket connection to an agent.
 type WsConn struct {
-	conn           *gws.Conn
-	requestManager *RequestManager
-	DownChan       chan struct{}
-	agentVersion   semver.Version
+	conn         *gws.Conn
+	responseChan chan *gws.Message
+	DownChan     chan struct{}
 }
 
 // FingerprintRecord is fingerprints collection record data in the hub
@@ -51,22 +50,21 @@ func GetUpgrader() *gws.Upgrader {
 	return upgrader
 }
 
-// NewWsConnection creates a new WebSocket connection wrapper with agent version.
-func NewWsConnection(conn *gws.Conn, agentVersion semver.Version) *WsConn {
+// NewWsConnection creates a new WebSocket connection wrapper.
+func NewWsConnection(conn *gws.Conn) *WsConn {
 	return &WsConn{
-		conn:           conn,
-		requestManager: NewRequestManager(conn),
-		DownChan:       make(chan struct{}, 1),
-		agentVersion:   agentVersion,
+		conn:         conn,
+		responseChan: make(chan *gws.Message, 1),
+		DownChan:     make(chan struct{}, 1),
 	}
 }
 
-// OnOpen sets a deadline for the WebSocket connection and extracts agent version.
+// OnOpen sets a deadline for the WebSocket connection.
 func (h *Handler) OnOpen(conn *gws.Conn) {
 	conn.SetDeadline(time.Now().Add(deadline))
 }
 
-// OnMessage routes incoming WebSocket messages to the request manager.
+// OnMessage routes incoming WebSocket messages to the response channel.
 func (h *Handler) OnMessage(conn *gws.Conn, message *gws.Message) {
 	conn.SetDeadline(time.Now().Add(deadline))
 	if message.Opcode != gws.OpcodeBinary || message.Data.Len() == 0 {
@@ -77,7 +75,12 @@ func (h *Handler) OnMessage(conn *gws.Conn, message *gws.Message) {
 		_ = conn.WriteClose(1000, nil)
 		return
 	}
-	wsConn.(*WsConn).requestManager.handleResponse(message)
+	select {
+	case wsConn.(*WsConn).responseChan <- message:
+	default:
+		// close if the connection is not expecting a response
+		wsConn.(*WsConn).Close(nil)
+	}
 }
 
 // OnClose handles WebSocket connection closures and triggers system down status after delay.
@@ -103,9 +106,6 @@ func (ws *WsConn) Close(msg []byte) {
 	if ws.IsConnected() {
 		ws.conn.WriteClose(1000, msg)
 	}
-	if ws.requestManager != nil {
-		ws.requestManager.Close()
-	}
 }
 
 // Ping sends a ping frame to keep the connection alive.
@@ -115,7 +115,6 @@ func (ws *WsConn) Ping() error {
 }
 
 // sendMessage encodes data to CBOR and sends it as a binary message to the agent.
-// This is kept for backwards compatibility but new actions should use RequestManager.
 func (ws *WsConn) sendMessage(data common.HubRequest[any]) error {
 	if ws.conn == nil {
 		return gws.ErrConnClosed
@@ -127,34 +126,54 @@ func (ws *WsConn) sendMessage(data common.HubRequest[any]) error {
 	return ws.conn.WriteMessage(gws.OpcodeBinary, bytes)
 }
 
-// handleAgentRequest processes a request to the agent, handling both legacy and new formats.
-func (ws *WsConn) handleAgentRequest(req *PendingRequest, handler ResponseHandler) error {
-	// Wait for response
+// RequestSystemData requests system metrics from the agent and unmarshals the response.
+func (ws *WsConn) RequestSystemData(data *system.CombinedData) error {
+	var message *gws.Message
+
+	ws.sendMessage(common.HubRequest[any]{
+		Action: common.GetData,
+	})
 	select {
-	case message := <-req.ResponseCh:
-		defer message.Close()
-		// Cancel request context to stop timeout watcher promptly
-		defer req.Cancel()
-		data := message.Data.Bytes()
-
-		// Legacy format - unmarshal directly
-		if ws.agentVersion.LT(beszel.MinVersionAgentResponse) {
-			return handler.HandleLegacy(data)
-		}
-
-		// New format with AgentResponse wrapper
-		var agentResponse common.AgentResponse
-		if err := cbor.Unmarshal(data, &agentResponse); err != nil {
-			return err
-		}
-		if agentResponse.Error != "" {
-			return errors.New(agentResponse.Error)
-		}
-		return handler.Handle(agentResponse)
-
-	case <-req.Context.Done():
-		return req.Context.Err()
+	case <-time.After(10 * time.Second):
+		ws.Close(nil)
+		return gws.ErrConnClosed
+	case message = <-ws.responseChan:
 	}
+	defer message.Close()
+	return cbor.Unmarshal(message.Data.Bytes(), data)
+}
+
+// GetFingerprint authenticates with the agent using SSH signature and returns the agent's fingerprint.
+func (ws *WsConn) GetFingerprint(token string, signer ssh.Signer, needSysInfo bool) (common.FingerprintResponse, error) {
+	var clientFingerprint common.FingerprintResponse
+	challenge := []byte(token)
+
+	signature, err := signer.Sign(nil, challenge)
+	if err != nil {
+		return clientFingerprint, err
+	}
+
+	err = ws.sendMessage(common.HubRequest[any]{
+		Action: common.CheckFingerprint,
+		Data: common.FingerprintRequest{
+			Signature:   signature.Blob,
+			NeedSysInfo: needSysInfo,
+		},
+	})
+	if err != nil {
+		return clientFingerprint, err
+	}
+
+	var message *gws.Message
+	select {
+	case message = <-ws.responseChan:
+	case <-time.After(10 * time.Second):
+		return clientFingerprint, errors.New("request expired")
+	}
+	defer message.Close()
+
+	err = cbor.Unmarshal(message.Data.Bytes(), &clientFingerprint)
+	return clientFingerprint, err
 }
 
 // IsConnected returns true if the WebSocket connection is active.

internal/hub/ws/ws_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/blang/semver"
 	"github.com/henrygd/beszel/internal/common"
 
 	"github.com/fxamacker/cbor/v2"
@@ -37,25 +36,26 @@ func TestGetUpgrader(t *testing.T) {
 // TestNewWsConnection tests WebSocket connection creation
 func TestNewWsConnection(t *testing.T) {
 	// We can't easily mock gws.Conn, so we'll pass nil and test the structure
-	wsConn := NewWsConnection(nil, semver.MustParse("0.12.10"))
+	wsConn := NewWsConnection(nil)
 
 	assert.NotNil(t, wsConn, "WebSocket connection should not be nil")
 	assert.Nil(t, wsConn.conn, "Connection should be nil as passed")
-	assert.NotNil(t, wsConn.requestManager, "Request manager should be initialized")
+	assert.NotNil(t, wsConn.responseChan, "Response channel should be initialized")
 	assert.NotNil(t, wsConn.DownChan, "Down channel should be initialized")
+	assert.Equal(t, 1, cap(wsConn.responseChan), "Response channel should have capacity of 1")
 	assert.Equal(t, 1, cap(wsConn.DownChan), "Down channel should have capacity of 1")
 }
 
 // TestWsConn_IsConnected tests the connection status check
 func TestWsConn_IsConnected(t *testing.T) {
 	// Test with nil connection
-	wsConn := NewWsConnection(nil, semver.MustParse("0.12.10"))
+	wsConn := NewWsConnection(nil)
 	assert.False(t, wsConn.IsConnected(), "Should not be connected when conn is nil")
 }
 
 // TestWsConn_Close tests the connection closing with nil connection
 func TestWsConn_Close(t *testing.T) {
-	wsConn := NewWsConnection(nil, semver.MustParse("0.12.10"))
+	wsConn := NewWsConnection(nil)
 
 	// Should handle nil connection gracefully
 	assert.NotPanics(t, func() {
@@ -65,7 +65,7 @@ func TestWsConn_Close(t *testing.T) {
 
 // TestWsConn_SendMessage_CBOR tests CBOR encoding in sendMessage
 func TestWsConn_SendMessage_CBOR(t *testing.T) {
-	wsConn := NewWsConnection(nil, semver.MustParse("0.12.10"))
+	wsConn := NewWsConnection(nil)
 
 	testData := common.HubRequest[any]{
 		Action: common.GetData,
@@ -181,17 +181,6 @@ func TestCommonActions(t *testing.T) {
 	// Test that the actions we use exist and have expected values
 	assert.Equal(t, common.WebSocketAction(0), common.GetData, "GetData should be action 0")
 	assert.Equal(t, common.WebSocketAction(1), common.CheckFingerprint, "CheckFingerprint should be action 1")
-	assert.Equal(t, common.WebSocketAction(2), common.GetContainerLogs, "GetLogs should be action 2")
-}
-
-func TestLogsHandler(t *testing.T) {
-	h := &stringResponseHandler{errorMsg: "no logs in response"}
-
-	logValue := "test logs"
-	resp := common.AgentResponse{String: &logValue}
-	err := h.Handle(resp)
-	assert.NoError(t, err)
-	assert.Equal(t, logValue, h.value)
 }
 
 // TestHandler tests that we can create a Handler
@@ -205,7 +194,7 @@ func TestHandler(t *testing.T) {
 
 // TestWsConnChannelBehavior tests channel behavior without WebSocket connections
 func TestWsConnChannelBehavior(t *testing.T) {
-	wsConn := NewWsConnection(nil, semver.MustParse("0.12.10"))
+	wsConn := NewWsConnection(nil)
 
 	// Test that channels are properly initialized and can be used
 	select {
@@ -223,6 +212,11 @@ func TestWsConnChannelBehavior(t *testing.T) {
 		t.Error("Should be able to read from DownChan")
 	}
 
-	// Request manager should have no pending requests initially
-	assert.Equal(t, 0, wsConn.requestManager.GetPendingCount(), "Should have no pending requests initially")
+	// Response channel should be empty initially
+	select {
+	case <-wsConn.responseChan:
+		t.Error("Response channel should be empty initially")
+	default:
+		// Expected - channel should be empty
+	}
 }

internal/hub/ws/ws_test_helpers.go

@@ -1,11 +0,0 @@
-//go:build testing
-// +build testing
-
-package ws
-
-// GetPendingCount returns the number of pending requests (for monitoring)
-func (rm *RequestManager) GetPendingCount() int {
-	rm.RLock()
-	defer rm.RUnlock()
-	return len(rm.pendingReqs)
-}

internal/migrations/0_collections_snapshot_0_12_0_7.go

@@ -1,6 +1,7 @@
 package migrations
 
 import (
+	"github.com/google/uuid"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -859,152 +860,6 @@ func init() {
 		"system": false,
 		"authRule": "verified=true",
 		"manageRule": null
-	},
-	{
-		"id": "pbc_1864144027",
-		"listRule": "@request.auth.id != \"\" && system.users.id ?= @request.auth.id",
-		"viewRule": null,
-		"createRule": null,
-		"updateRule": null,
-		"deleteRule": null,
-		"name": "containers",
-		"type": "base",
-		"fields": [
-				{
-						"autogeneratePattern": "[a-f0-9]{6}",
-						"hidden": false,
-						"id": "text3208210256",
-						"max": 12,
-						"min": 6,
-						"name": "id",
-						"pattern": "^[a-f0-9]+$",
-						"presentable": false,
-						"primaryKey": true,
-						"required": true,
-						"system": true,
-						"type": "text"
-				},
-				{
-						"cascadeDelete": false,
-						"collectionId": "2hz5ncl8tizk5nx",
-						"hidden": false,
-						"id": "relation3377271179",
-						"maxSelect": 1,
-						"minSelect": 0,
-						"name": "system",
-						"presentable": false,
-						"required": false,
-						"system": false,
-						"type": "relation"
-				},
-				{
-						"autogeneratePattern": "",
-						"hidden": false,
-						"id": "text1579384326",
-						"max": 0,
-						"min": 0,
-						"name": "name",
-						"pattern": "",
-						"presentable": false,
-						"primaryKey": false,
-						"required": false,
-						"system": false,
-						"type": "text"
-				},
-				{
-						"autogeneratePattern": "",
-						"hidden": false,
-						"id": "text2063623452",
-						"max": 0,
-						"min": 0,
-						"name": "status",
-						"pattern": "",
-						"presentable": false,
-						"primaryKey": false,
-						"required": false,
-						"system": false,
-						"type": "text"
-				},
-				{
-						"hidden": false,
-						"id": "number3470402323",
-						"max": null,
-						"min": null,
-						"name": "health",
-						"onlyInt": false,
-						"presentable": false,
-						"required": false,
-						"system": false,
-						"type": "number"
-				},
-				{
-						"hidden": false,
-						"id": "number3128971310",
-						"max": 100,
-						"min": 0,
-						"name": "cpu",
-						"onlyInt": false,
-						"presentable": false,
-						"required": false,
-						"system": false,
-						"type": "number"
-				},
-				{
-						"hidden": false,
-						"id": "number3933025333",
-						"max": null,
-						"min": 0,
-						"name": "memory",
-						"onlyInt": false,
-						"presentable": false,
-						"required": false,
-						"system": false,
-						"type": "number"
-				},
-				{
-					"hidden": false,
-					"id": "number4075427327",
-					"max": null,
-					"min": null,
-					"name": "net",
-					"onlyInt": false,
-					"presentable": false,
-					"required": false,
-					"system": false,
-					"type": "number"
-				},
-				{
-					"hidden": false,
-					"id": "number3332085495",
-					"max": null,
-					"min": null,
-					"name": "updated",
-					"onlyInt": true,
-					"presentable": false,
-					"required": true,
-					"system": false,
-					"type": "number"
-				},
-				{
-					"autogeneratePattern": "",
-					"hidden": false,
-					"id": "text3309110367",
-					"max": 0,
-					"min": 0,
-					"name": "image",
-					"pattern": "",
-					"presentable": false,
-					"primaryKey": false,
-					"required": false,
-					"system": false,
-					"type": "text"
-				}
-		],
-		"indexes": [
-			"CREATE INDEX ` + "`" + `idx_JxWirjdhyO` + "`" + ` ON ` + "`" + `containers` + "`" + ` (` + "`" + `updated` + "`" + `)",
-			"CREATE INDEX ` + "`" + `idx_r3Ja0rs102` + "`" + ` ON ` + "`" + `containers` + "`" + ` (` + "`" + `system` + "`" + `)"
-		],
-		"system": false
 	}
 ]`
 
@@ -1013,6 +868,31 @@ func init() {
 			return err
 		}
 
+		// Get all systems that don't have fingerprint records
+		var systemIds []string
+		err = app.DB().NewQuery(`
+			SELECT s.id FROM systems s
+			LEFT JOIN fingerprints f ON s.id = f.system
+			WHERE f.system IS NULL
+		`).Column(&systemIds)
+		if err != nil {
+			return err
+		}
+		// Create fingerprint records with unique UUID tokens for each system
+		for _, systemId := range systemIds {
+			token := uuid.New().String()
+			_, err = app.DB().NewQuery(`
+				INSERT INTO fingerprints (system, token)
+				VALUES ({:system}, {:token})
+			`).Bind(map[string]any{
+				"system": systemId,
+				"token":  token,
+			}).Execute()
+			if err != nil {
+				return err
+			}
+		}
+
 		return nil
 	}, func(app core.App) error {
 		return nil

internal/migrations/1758738789_fix_cached_mem.go

@@ -1,50 +0,0 @@
-package migrations
-
-import (
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/pocketbase/pocketbase/core"
-	m "github.com/pocketbase/pocketbase/migrations"
-)
-
-// This can be deleted after Nov 2025 or so
-
-func init() {
-	m.Register(func(app core.App) error {
-		app.RunInTransaction(func(txApp core.App) error {
-			var systemIds []string
-			txApp.DB().NewQuery("SELECT id FROM systems").Column(&systemIds)
-
-			for _, systemId := range systemIds {
-				var statRecordIds []string
-				txApp.DB().NewQuery("SELECT id FROM system_stats WHERE system = {:system} AND created > {:created}").Bind(map[string]any{"system": systemId, "created": "2025-09-21"}).Column(&statRecordIds)
-
-				for _, statRecordId := range statRecordIds {
-					statRecord, err := txApp.FindRecordById("system_stats", statRecordId)
-					if err != nil {
-						return err
-					}
-					var systemStats system.Stats
-					err = statRecord.UnmarshalJSONField("stats", &systemStats)
-					if err != nil {
-						return err
-					}
-					// if mem buff cache is less than total mem, we don't need to fix it
-					if systemStats.MemBuffCache < systemStats.Mem {
-						continue
-					}
-					systemStats.MemBuffCache = 0
-					statRecord.Set("stats", systemStats)
-					err = txApp.SaveNoValidate(statRecord)
-					if err != nil {
-						return err
-					}
-				}
-			}
-
-			return nil
-		})
-		return nil
-	}, func(app core.App) error {
-		return nil
-	})
-}

internal/records/records.go

@@ -213,8 +213,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.LoadAvg[2] += stats.LoadAvg[2]
 		sum.Bandwidth[0] += stats.Bandwidth[0]
 		sum.Bandwidth[1] += stats.Bandwidth[1]
-		sum.DiskIO[0] += stats.DiskIO[0]
-		sum.DiskIO[1] += stats.DiskIO[1]
 		batterySum += int(stats.Battery[0])
 		sum.Battery[1] = stats.Battery[1]
 		// Set peak values
@@ -226,8 +224,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.MaxDiskWritePs = max(sum.MaxDiskWritePs, stats.MaxDiskWritePs, stats.DiskWritePs)
 		sum.MaxBandwidth[0] = max(sum.MaxBandwidth[0], stats.MaxBandwidth[0], stats.Bandwidth[0])
 		sum.MaxBandwidth[1] = max(sum.MaxBandwidth[1], stats.MaxBandwidth[1], stats.Bandwidth[1])
-		sum.MaxDiskIO[0] = max(sum.MaxDiskIO[0], stats.MaxDiskIO[0], stats.DiskIO[0])
-		sum.MaxDiskIO[1] = max(sum.MaxDiskIO[1], stats.MaxDiskIO[1], stats.DiskIO[1])
 
 		// Accumulate network interfaces
 		if sum.NetworkInterfaces == nil {
@@ -318,8 +314,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.DiskPct = twoDecimals(sum.DiskPct / count)
 		sum.DiskReadPs = twoDecimals(sum.DiskReadPs / count)
 		sum.DiskWritePs = twoDecimals(sum.DiskWritePs / count)
-		sum.DiskIO[0] = sum.DiskIO[0] / uint64(count)
-		sum.DiskIO[1] = sum.DiskIO[1] / uint64(count)
 		sum.NetworkSent = twoDecimals(sum.NetworkSent / count)
 		sum.NetworkRecv = twoDecimals(sum.NetworkRecv / count)
 		sum.LoadAvg[0] = twoDecimals(sum.LoadAvg[0] / count)
@@ -437,10 +431,6 @@ func (rm *RecordManager) DeleteOldRecords() {
 		if err != nil {
 			return err
 		}
-		err = deleteOldContainerRecords(txApp)
-		if err != nil {
-			return err
-		}
 		err = deleteOldAlertsHistory(txApp, 200, 250)
 		if err != nil {
 			return err
@@ -510,20 +500,6 @@ func deleteOldSystemStats(app core.App) error {
 	return nil
 }
 
-// Deletes container records that haven't been updated in the last 10 minutes
-func deleteOldContainerRecords(app core.App) error {
-	now := time.Now().UTC()
-	tenMinutesAgo := now.Add(-10 * time.Minute)
-
-	// Delete container records where updated < tenMinutesAgo
-	_, err := app.DB().NewQuery("DELETE FROM containers WHERE updated < {:updated}").Bind(dbx.Params{"updated": tenMinutesAgo.UnixMilli()}).Execute()
-	if err != nil {
-		return fmt.Errorf("failed to delete old container records: %v", err)
-	}
-
-	return nil
-}
-
 /* Round float to two decimals */
 func twoDecimals(value float64) float64 {
 	return math.Round(value*100) / 100

internal/site/biome.json

@@ -1,83 +1,41 @@
 {
 	"$schema": "https://biomejs.dev/schemas/2.2.3/schema.json",
 	"vcs": {
-		"enabled": true,
+		"enabled": false,
 		"clientKind": "git",
-		"useIgnoreFile": true,
-		"defaultBranch": "main"
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false
 	},
 	"formatter": {
 		"enabled": true,
 		"indentStyle": "tab",
-		"lineWidth": 120,
-		"formatWithErrors": true
+		"indentWidth": 2,
+		"lineWidth": 120
 	},
-	"assist": { "actions": { "source": { "organizeImports": "on" } } },
 	"linter": {
 		"enabled": true,
 		"rules": {
 			"recommended": true,
-			"complexity": {
-				"noUselessStringConcat": "error",
-				"noUselessUndefinedInitialization": "error",
-				"noVoid": "error",
-				"useDateNow": "error"
-			},
 			"correctness": {
-				"noConstantMathMinMaxClamp": "error",
-				"noUndeclaredVariables": "error",
-				"noUnusedImports": "error",
-				"noUnusedFunctionParameters": "error",
-				"noUnusedPrivateClassMembers": "error",
-				"useExhaustiveDependencies": {
-					"level": "error",
-					"options": {
-						"reportUnnecessaryDependencies": false
-					}
-				},
-				"noUnusedVariables": "error"
-			},
-			"style": {
-				"noParameterProperties": "error",
-				"noYodaExpression": "error",
-				"useConsistentBuiltinInstantiation": "error",
-				"useFragmentSyntax": "error",
-				"useShorthandAssign": "error",
-				"useArrayLiterals": "error"
-			},
-			"suspicious": {
-				"useAwait": "error",
-				"noEvolvingTypes": "error"
+				"useUniqueElementIds": "off"
 			}
 		}
 	},
 	"javascript": {
 		"formatter": {
 			"quoteStyle": "double",
-			"trailingCommas": "es5",
-			"semicolons": "asNeeded"
+			"semicolons": "asNeeded",
+			"trailingCommas": "es5"
 		}
 	},
-	"overrides": [
-		{
-			"includes": ["**/*.jsx", "**/*.tsx"],
-			"linter": {
-				"rules": {
-					"style": {
-						"noParameterAssign": "error"
-					}
-				}
-			}
-		},
-		{
-			"includes": ["**/*.ts", "**/*.tsx"],
-			"linter": {
-				"rules": {
-					"correctness": {
-						"noUnusedVariables": "off"
-					}
-				}
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
 			}
 		}
-	]
+	}
 }

internal/site/index.html

@@ -3,9 +3,8 @@
 	<head>
 		<meta charset="UTF-8" />
 		<link rel="manifest" href="./static/manifest.json" />
-		<link rel="icon" type="image/svg+xml" href="./static/icon.svg" />
+		<link rel="icon" type="image/svg+xml" href="./static/favicon.svg" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0,maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
-		<meta name="robots" content="noindex, nofollow" />
 		<title>Beszel</title>
 		<script>
 			globalThis.BESZEL = {

internal/site/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "beszel",
 	"private": true,
-	"version": "0.14.1",
+	"version": "0.12.9",
 	"type": "module",
 	"scripts": {
 		"dev": "vite --host",
@@ -49,12 +49,11 @@
 		"react": "^19.1.1",
 		"react-dom": "^19.1.1",
 		"recharts": "^2.15.4",
-		"shiki": "^3.13.0",
 		"tailwind-merge": "^3.3.1",
 		"valibot": "^0.42.1"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.2.4",
+		"@biomejs/biome": "2.2.3",
 		"@lingui/cli": "^5.4.1",
 		"@lingui/swc-plugin": "^5.6.1",
 		"@lingui/vite-plugin": "^5.4.1",
@@ -77,4 +76,4 @@
 	"optionalDependencies": {
 		"@esbuild/linux-arm64": "^0.21.5"
 	}
-}
+}

internal/site/public/static/favicon-green.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 70" fill="#22c55e"><path d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/></svg>

internal/site/public/static/favicon-red.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 70" fill="#dc2626"><path d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/></svg>

internal/site/public/static/favicon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 70" fill="#888"><path d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/></svg>

internal/site/public/static/icon.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 70">
-  <defs>
-    <linearGradient id="gradient" x1="0%" y1="20%" x2="100%" y2="120%">
-      <stop offset="0%" style="stop-color:#747bff"/>
-      <stop offset="100%" style="stop-color:#24eb5c"/>
-    </linearGradient>
-  </defs>
-  <path fill="url(#gradient)" d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/>
-</svg>

internal/site/src/components/active-alerts.tsx

@@ -1,85 +0,0 @@
-import { alertInfo } from "@/lib/alerts"
-import { $alerts, $allSystemsById } from "@/lib/stores"
-import type { AlertRecord } from "@/types"
-import { Plural, Trans } from "@lingui/react/macro"
-import { useStore } from "@nanostores/react"
-import { getPagePath } from "@nanostores/router"
-import { useMemo } from "react"
-import { $router, Link } from "./router"
-import { Alert, AlertTitle, AlertDescription } from "./ui/alert"
-import { Card, CardHeader, CardTitle, CardContent } from "./ui/card"
-
-export const ActiveAlerts = () => {
-	const alerts = useStore($alerts)
-	const systems = useStore($allSystemsById)
-
-	const { activeAlerts, alertsKey } = useMemo(() => {
-		const activeAlerts: AlertRecord[] = []
-		// key to prevent re-rendering if alerts change but active alerts didn't
-		const alertsKey: string[] = []
-
-		for (const systemId of Object.keys(alerts)) {
-			for (const alert of alerts[systemId].values()) {
-				if (alert.triggered && alert.name in alertInfo) {
-					activeAlerts.push(alert)
-					alertsKey.push(`${alert.system}${alert.value}${alert.min}`)
-				}
-			}
-		}
-
-		return { activeAlerts, alertsKey }
-	}, [alerts])
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: alertsKey is inclusive
-	return useMemo(() => {
-		if (activeAlerts.length === 0) {
-			return null
-		}
-		return (
-			<Card>
-				<CardHeader className="pb-4 px-2 sm:px-6 max-sm:pt-5 max-sm:pb-1">
-					<div className="px-2 sm:px-1">
-						<CardTitle>
-							<Trans>Active Alerts</Trans>
-						</CardTitle>
-					</div>
-				</CardHeader>
-				<CardContent className="max-sm:p-2">
-					{activeAlerts.length > 0 && (
-						<div className="grid sm:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4 gap-3">
-							{activeAlerts.map((alert) => {
-								const info = alertInfo[alert.name as keyof typeof alertInfo]
-								return (
-									<Alert
-										key={alert.id}
-										className="hover:-translate-y-px duration-200 bg-transparent border-foreground/10 hover:shadow-md shadow-black/5"
-									>
-										<info.icon className="h-4 w-4" />
-										<AlertTitle>
-											{systems[alert.system]?.name} {info.name().toLowerCase().replace("cpu", "CPU")}
-										</AlertTitle>
-										<AlertDescription>
-											{alert.name === "Status" ? (
-												<Trans>Connection is down</Trans>
-											) : (
-												<Trans>
-													Exceeds {alert.value}
-													{info.unit} in last <Plural value={alert.min} one="# minute" other="# minutes" />
-												</Trans>
-											)}
-										</AlertDescription>
-										<Link
-											href={getPagePath($router, "system", { id: systems[alert.system]?.id })}
-											className="absolute inset-0 w-full h-full"
-											aria-label="View system"
-										></Link>
-									</Alert>
-								)
-							})}
-						</div>
-					)}
-				</CardContent>
-			</Card>
-		)
-	}, [alertsKey.join("")])
-}

internal/site/src/components/charts/chart-time-select.tsx

@@ -2,27 +2,12 @@ import { useStore } from "@nanostores/react"
 import { HistoryIcon } from "lucide-react"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 import { $chartTime } from "@/lib/stores"
-import { chartTimeData, cn, compareSemVer, parseSemVer } from "@/lib/utils"
-import type { ChartTimes, SemVer } from "@/types"
-import { memo } from "react"
+import { chartTimeData, cn } from "@/lib/utils"
+import type { ChartTimes } from "@/types"
 
-export default memo(function ChartTimeSelect({
-	className,
-	agentVersion,
-}: {
-	className?: string
-	agentVersion: SemVer
-}) {
+export default function ChartTimeSelect({ className }: { className?: string }) {
 	const chartTime = useStore($chartTime)
 
-	// remove chart times that are not supported by the system agent version
-	const availableChartTimes = Object.entries(chartTimeData).filter(([_, { minVersion }]) => {
-		if (!minVersion) {
-			return true
-		}
-		return compareSemVer(agentVersion, parseSemVer(minVersion)) >= 0
-	})
-
 	return (
 		<Select defaultValue="1h" value={chartTime} onValueChange={(value: ChartTimes) => $chartTime.set(value)}>
 			<SelectTrigger className={cn(className, "relative ps-10 pe-5")}>
@@ -30,7 +15,7 @@ export default memo(function ChartTimeSelect({
 				<SelectValue />
 			</SelectTrigger>
 			<SelectContent>
-				{availableChartTimes.map(([value, { label }]) => (
+				{Object.entries(chartTimeData).map(([value, { label }]) => (
 					<SelectItem key={value} value={value}>
 						{label()}
 					</SelectItem>
@@ -38,4 +23,4 @@ export default memo(function ChartTimeSelect({
 			</SelectContent>
 		</Select>
 	)
-})
+}

internal/site/src/components/charts/container-chart.tsx

@@ -94,11 +94,8 @@ export default memo(function ContainerChart({
 		if (!filter) {
 			return new Set<string>()
 		}
-		const filterTerms = filter.toLowerCase().split(" ").filter(term => term.length > 0)
-		return new Set(Object.keys(chartConfig).filter((key) => {
-			const keyLower = key.toLowerCase()
-			return !filterTerms.some(term => keyLower.includes(term))
-		}))
+		const filterLower = filter.toLowerCase()
+		return new Set(Object.keys(chartConfig).filter((key) => !key.toLowerCase().includes(filterLower)))
 	}, [chartConfig, filter])
 
 	// console.log('rendered at', new Date())

internal/site/src/components/charts/disk-chart.tsx

@@ -4,7 +4,7 @@ import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
 import { Unit } from "@/lib/enums"
 import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData, SystemStatsRecord } from "@/types"
+import type { ChartData } from "@/types"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function DiskChart({
@@ -12,7 +12,7 @@ export default memo(function DiskChart({
 	diskSize,
 	chartData,
 }: {
-	dataKey: string | ((data: SystemStatsRecord) => number | undefined)
+	dataKey: string
 	diskSize: number
 	chartData: ChartData
 }) {

internal/site/src/components/charts/gpu-power-chart.tsx

@@ -9,58 +9,46 @@ import {
 	xAxis,
 } from "@/components/ui/chart"
 import { chartMargin, cn, decimalString, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData, GPUData } from "@/types"
+import type { ChartData } from "@/types"
 import { useYAxisWidth } from "./hooks"
-import type { DataPoint } from "./line-chart"
 
 export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-	const packageKey = " package"
-
-	const { gpuData, dataPoints } = useMemo(() => {
-		const dataPoints = [] as DataPoint[]
-		const gpuData = [] as Record<string, GPUData | string>[]
-		const addedKeys = new Map<string, number>()
-
-		const addKey = (key: string, value: number) => {
-			addedKeys.set(key, (addedKeys.get(key) ?? 0) + value)
-		}
-
-		for (const stats of chartData.systemStats) {
-			const gpus = stats.stats?.g ?? {}
-			const data = { created: stats.created } as Record<string, GPUData | string>
-			for (const id in gpus) {
-				const gpu = gpus[id] as GPUData
-				data[gpu.n] = gpu
-				addKey(gpu.n, gpu.p ?? 0)
-				if (gpu.pp) {
-					data[`${gpu.n}${packageKey}`] = gpu
-					addKey(`${gpu.n}${packageKey}`, gpu.pp ?? 0)
-				}
-			}
-			gpuData.push(data)
-		}
-		const sortedKeys = Array.from(addedKeys.entries())
-			.sort(([, a], [, b]) => b - a)
-			.map(([key]) => key)
-
-		for (let i = 0; i < sortedKeys.length; i++) {
-			const id = sortedKeys[i]
-			dataPoints.push({
-				label: id,
-				dataKey: (gpuData: Record<string, GPUData>) => {
-					return id.endsWith(packageKey) ? (gpuData[id]?.pp ?? 0) : (gpuData[id]?.p ?? 0)
-				},
-				color: `hsl(${226 + (((i * 360) / addedKeys.size) % 360)}, 65%, 52%)`,
-			})
-		}
-		return { gpuData, dataPoints }
-	}, [chartData])
 
 	if (chartData.systemStats.length === 0) {
 		return null
 	}
 
+	/** Format temperature data for chart and assign colors */
+	const newChartData = useMemo(() => {
+		const newChartData = { data: [], colors: {} } as {
+			data: Record<string, number | string>[]
+			colors: Record<string, string>
+		}
+		const powerSums = {} as Record<string, number>
+		for (const data of chartData.systemStats) {
+			const newData = { created: data.created } as Record<string, number | string>
+
+			for (const gpu of Object.values(data.stats?.g ?? {})) {
+				if (gpu.p) {
+					const name = gpu.n
+					newData[name] = gpu.p
+					powerSums[name] = (powerSums[name] ?? 0) + newData[name]
+				}
+			}
+			newChartData.data.push(newData)
+		}
+		const keys = Object.keys(powerSums).sort((a, b) => powerSums[b] - powerSums[a])
+		for (const key of keys) {
+			newChartData.colors[key] = `hsl(${((keys.indexOf(key) * 360) / keys.length) % 360}, 60%, 55%)`
+		}
+		return newChartData
+	}, [chartData])
+
+	const colors = Object.keys(newChartData.colors)
+
+	// console.log('rendered at', new Date())
+
 	return (
 		<div>
 			<ChartContainer
@@ -68,7 +56,7 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 					"opacity-100": yAxisWidth,
 				})}
 			>
-				<LineChart accessibilityLayer data={gpuData} margin={chartMargin}>
+				<LineChart accessibilityLayer data={newChartData.data} margin={chartMargin}>
 					<CartesianGrid vertical={false} />
 					<YAxis
 						direction="ltr"
@@ -97,19 +85,19 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 							/>
 						}
 					/>
-					{dataPoints.map((dataPoint) => (
+					{colors.map((key) => (
 						<Line
-							key={dataPoint.label}
-							dataKey={dataPoint.dataKey}
-							name={dataPoint.label}
+							key={key}
+							dataKey={key}
+							name={key}
 							type="monotoneX"
 							dot={false}
 							strokeWidth={1.5}
-							stroke={dataPoint.color as string}
+							stroke={newChartData.colors[key]}
 							isAnimationActive={false}
 						/>
 					))}
-					{dataPoints.length > 1 && <ChartLegend content={<ChartLegendContent />} />}
+					{colors.length > 1 && <ChartLegend content={<ChartLegendContent />} />}
 				</LineChart>
 			</ChartContainer>
 		</div>

internal/site/src/components/charts/load-average-chart.tsx

@@ -59,6 +59,8 @@ export default memo(function LoadAverageChart({ chartData }: { chartData: ChartD
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
+						// @ts-expect-error
+						// itemSorter={(a, b) => b.value - a.value}
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
@@ -68,15 +70,14 @@ export default memo(function LoadAverageChart({ chartData }: { chartData: ChartD
 					/>
 					{keys.map(({ legacy, color, label }, i) => {
 						const dataKey = (value: { stats: SystemStats }) => {
-							const { minor, patch } = chartData.agentVersion
-							if (minor <= 12 && patch < 1) {
+							if (chartData.agentVersion.patch < 1) {
 								return value.stats?.[legacy]
 							}
 							return value.stats?.la?.[i] ?? value.stats?.[legacy]
 						}
 						return (
 							<Line
-								key={label}
+								key={i}
 								dataKey={dataKey}
 								name={label}
 								type="monotoneX"

internal/site/src/components/charts/temperature-chart.tsx

@@ -64,7 +64,7 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 						direction="ltr"
 						orientation={chartData.orientation}
 						className="tracking-tighter"
-						domain={["auto", "auto"]}
+						domain={[0, "auto"]}
 						width={yAxisWidth}
 						tickFormatter={(val) => {
 							const { value, unit } = formatTemperature(val, userSettings.unitTemp)
@@ -91,8 +91,7 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 						}
 					/>
 					{colors.map((key) => {
-						const filterTerms = filter ? filter.toLowerCase().split(" ").filter(term => term.length > 0) : []
-						const filtered = filterTerms.length > 0 && !filterTerms.some(term => key.toLowerCase().includes(term))
+						const filtered = filter && !key.toLowerCase().includes(filter.toLowerCase())
 						const strokeOpacity = filtered ? 0.1 : 1
 						return (
 							<Line
@@ -114,4 +113,4 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 			</ChartContainer>
 		</div>
 	)
-})
+})

internal/site/src/components/command-palette.tsx

@@ -5,7 +5,6 @@ import { DialogDescription } from "@radix-ui/react-dialog"
 import {
 	AlertOctagonIcon,
 	BookIcon,
-	ContainerIcon,
 	DatabaseBackupIcon,
 	FingerprintIcon,
 	LayoutDashboard,
@@ -66,7 +65,7 @@ export default memo(function CommandPalette({ open, setOpen }: { open: boolean;
 									<CommandItem
 										key={system.id}
 										onSelect={() => {
-											navigate(getPagePath($router, "system", { id: system.id }))
+											navigate(getPagePath($router, "system", { name: system.name }))
 											setOpen(false)
 										}}
 									>
@@ -81,7 +80,7 @@ export default memo(function CommandPalette({ open, setOpen }: { open: boolean;
 					)}
 					<CommandGroup heading={t`Pages / Settings`}>
 						<CommandItem
-							keywords={["home", t`All Systems`]}
+							keywords={["home"]}
 							onSelect={() => {
 								navigate(basePath)
 								setOpen(false)
@@ -95,20 +94,6 @@ export default memo(function CommandPalette({ open, setOpen }: { open: boolean;
 								<Trans>Page</Trans>
 							</CommandShortcut>
 						</CommandItem>
-						<CommandItem
-							onSelect={() => {
-								navigate(getPagePath($router, "containers"))
-								setOpen(false)
-							}}
-						>
-							<ContainerIcon className="me-2 size-4" />
-							<span>
-								<Trans>All Containers</Trans>
-							</span>
-							<CommandShortcut>
-								<Trans>Page</Trans>
-							</CommandShortcut>
-						</CommandItem>
 						<CommandItem
 							onSelect={() => {
 								navigate(getPagePath($router, "settings", { name: "general" }))

internal/site/src/components/containers-table/containers-table-columns.tsx

@@ -1,176 +0,0 @@
-import type { Column, ColumnDef } from "@tanstack/react-table"
-import { Button } from "@/components/ui/button"
-import { cn, decimalString, formatBytes, hourWithSeconds } from "@/lib/utils"
-import type { ContainerRecord } from "@/types"
-import { ContainerHealth, ContainerHealthLabels } from "@/lib/enums"
-import {
-	ArrowUpDownIcon,
-	ClockIcon,
-	ContainerIcon,
-	CpuIcon,
-	LayersIcon,
-	MemoryStickIcon,
-	ServerIcon,
-	ShieldCheckIcon,
-} from "lucide-react"
-import { EthernetIcon, HourglassIcon } from "../ui/icons"
-import { Badge } from "../ui/badge"
-import { t } from "@lingui/core/macro"
-import { $allSystemsById } from "@/lib/stores"
-import { useStore } from "@nanostores/react"
-
-// Unit names and their corresponding number of seconds for converting docker status strings
-const unitSeconds = [["s", 1], ["mi", 60], ["h", 3600], ["d", 86400], ["w", 604800], ["mo", 2592000]] as const
-// Convert docker status string to number of seconds ("Up X minutes", "Up X hours", etc.)
-function getStatusValue(status: string): number {
-	const [_, num, unit] = status.split(" ")
-	const numValue = Number(num)
-	for (const [unitName, value] of unitSeconds) {
-		if (unit.startsWith(unitName)) {
-			return numValue * value
-		}
-	}
-	return 0
-}
-
-export const containerChartCols: ColumnDef<ContainerRecord>[] = [
-	{
-		id: "name",
-		sortingFn: (a, b) => a.original.name.localeCompare(b.original.name),
-		accessorFn: (record) => record.name,
-		header: ({ column }) => <HeaderButton column={column} name={t`Name`} Icon={ContainerIcon} />,
-		cell: ({ getValue }) => {
-			return <span className="ms-1.5 xl:w-48 block truncate">{getValue() as string}</span>
-		},
-	},
-	{
-		id: "system",
-		accessorFn: (record) => record.system,
-		sortingFn: (a, b) => {
-			const allSystems = $allSystemsById.get()
-			const systemNameA = allSystems[a.original.system]?.name ?? ""
-			const systemNameB = allSystems[b.original.system]?.name ?? ""
-			return systemNameA.localeCompare(systemNameB)
-		},
-		header: ({ column }) => <HeaderButton column={column} name={t`System`} Icon={ServerIcon} />,
-		cell: ({ getValue }) => {
-			const allSystems = useStore($allSystemsById)
-			return <span className="ms-1.5 xl:w-34 block truncate">{allSystems[getValue() as string]?.name ?? ""}</span>
-		},
-	},
-	// {
-	// 	id: "id",
-	// 	accessorFn: (record) => record.id,
-	// 	sortingFn: (a, b) => a.original.id.localeCompare(b.original.id),
-	// 	header: ({ column }) => <HeaderButton column={column} name="ID" Icon={HashIcon} />,
-	// 	cell: ({ getValue }) => {
-	// 		return <span className="ms-1.5 me-3 font-mono">{getValue() as string}</span>
-	// 	},
-	// },
-	{
-		id: "cpu",
-		accessorFn: (record) => record.cpu,
-		invertSorting: true,
-		header: ({ column }) => <HeaderButton column={column} name={t`CPU`} Icon={CpuIcon} />,
-		cell: ({ getValue }) => {
-			const val = getValue() as number
-			return <span className="ms-1.5 tabular-nums">{`${decimalString(val, val >= 10 ? 1 : 2)}%`}</span>
-		},
-	},
-	{
-		id: "memory",
-		accessorFn: (record) => record.memory,
-		invertSorting: true,
-		header: ({ column }) => <HeaderButton column={column} name={t`Memory`} Icon={MemoryStickIcon} />,
-		cell: ({ getValue }) => {
-			const val = getValue() as number
-			const formatted = formatBytes(val, false, undefined, true)
-			return (
-				<span className="ms-1.5 tabular-nums">{`${decimalString(formatted.value, formatted.value >= 10 ? 1 : 2)} ${formatted.unit}`}</span>
-			)
-		},
-	},
-	{
-		id: "net",
-		accessorFn: (record) => record.net,
-		invertSorting: true,
-		header: ({ column }) => <HeaderButton column={column} name={t`Net`} Icon={EthernetIcon} />,
-		cell: ({ getValue }) => {
-			const val = getValue() as number
-			const formatted = formatBytes(val, true, undefined, true)
-			return (
-				<span className="ms-1.5 tabular-nums">{`${decimalString(formatted.value, formatted.value >= 10 ? 1 : 2)} ${formatted.unit}`}</span>
-			)
-		},
-	},
-	{
-		id: "health",
-		invertSorting: true,
-		accessorFn: (record) => record.health,
-		header: ({ column }) => <HeaderButton column={column} name={t`Health`} Icon={ShieldCheckIcon} />,
-		cell: ({ getValue }) => {
-			const healthValue = getValue() as number
-			const healthStatus = ContainerHealthLabels[healthValue] || "Unknown"
-			return (
-				<Badge variant="outline" className="dark:border-white/12">
-					<span className={cn("size-2 me-1.5 rounded-full", {
-						"bg-green-500": healthValue === ContainerHealth.Healthy,
-						"bg-red-500": healthValue === ContainerHealth.Unhealthy,
-						"bg-yellow-500": healthValue === ContainerHealth.Starting,
-						"bg-zinc-500": healthValue === ContainerHealth.None,
-					})}>
-					</span>
-					{healthStatus}
-				</Badge>
-			)
-		},
-	},
-	{
-		id: "image",
-		sortingFn: (a, b) => a.original.image.localeCompare(b.original.image),
-		accessorFn: (record) => record.image,
-		header: ({ column }) => <HeaderButton column={column} name={t({ message: "Image", context: "Docker image" })} Icon={LayersIcon} />,
-		cell: ({ getValue }) => {
-			return <span className="ms-1.5 xl:w-40 block truncate">{getValue() as string}</span>
-		},
-	},
-	{
-		id: "status",
-		accessorFn: (record) => record.status,
-		invertSorting: true,
-		sortingFn: (a, b) => getStatusValue(a.original.status) - getStatusValue(b.original.status),
-		header: ({ column }) => <HeaderButton column={column} name={t`Status`} Icon={HourglassIcon} />,
-		cell: ({ getValue }) => {
-			return <span className="ms-1.5 w-25 block truncate">{getValue() as string}</span>
-		},
-	},
-	{
-		id: "updated",
-		invertSorting: true,
-		accessorFn: (record) => record.updated,
-		header: ({ column }) => <HeaderButton column={column} name={t`Updated`} Icon={ClockIcon} />,
-		cell: ({ getValue }) => {
-			const timestamp = getValue() as number
-			return (
-				<span className="ms-1.5 tabular-nums">
-					{hourWithSeconds(new Date(timestamp).toISOString())}
-				</span>
-			)
-		},
-	},
-]
-
-function HeaderButton({ column, name, Icon }: { column: Column<ContainerRecord>; name: string; Icon: React.ElementType }) {
-	const isSorted = column.getIsSorted()
-	return (
-		<Button
-			className={cn("h-9 px-3 flex items-center gap-2 duration-50", isSorted && "bg-accent/70 light:bg-accent text-accent-foreground/90")}
-			variant="ghost"
-			onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
-		>
-			{Icon && <Icon className="size-4" />}
-			{name}
-			<ArrowUpDownIcon className="size-4" />
-		</Button>
-	)
-}

internal/site/src/components/containers-table/containers-table.tsx

@@ -1,495 +0,0 @@
-import { t } from "@lingui/core/macro"
-import { Trans } from "@lingui/react/macro"
-import {
-	type ColumnFiltersState,
-	flexRender,
-	getCoreRowModel,
-	getFilteredRowModel,
-	getSortedRowModel,
-	type Row,
-	type SortingState,
-	type Table as TableType,
-	useReactTable,
-	type VisibilityState,
-} from "@tanstack/react-table"
-import { useVirtualizer, type VirtualItem } from "@tanstack/react-virtual"
-import { memo, RefObject, useEffect, useRef, useState } from "react"
-import { Input } from "@/components/ui/input"
-import { TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
-import { pb } from "@/lib/api"
-import type { ContainerRecord } from "@/types"
-import { containerChartCols } from "@/components/containers-table/containers-table-columns"
-import { Card, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
-import { type ContainerHealth, ContainerHealthLabels } from "@/lib/enums"
-import { cn, useBrowserStorage } from "@/lib/utils"
-import { Sheet, SheetTitle, SheetHeader, SheetContent, SheetDescription } from "../ui/sheet"
-import { Dialog, DialogContent, DialogTitle } from "../ui/dialog"
-import { Button } from "@/components/ui/button"
-import { $allSystemsById } from "@/lib/stores"
-import { MaximizeIcon, RefreshCwIcon } from "lucide-react"
-import { Separator } from "../ui/separator"
-import { $router, Link } from "../router"
-import { listenKeys } from "nanostores"
-import { getPagePath } from "@nanostores/router"
-
-const syntaxTheme = "github-dark-dimmed"
-
-export default function ContainersTable({ systemId }: { systemId?: string }) {
-	const [data, setData] = useState<ContainerRecord[]>([])
-	const [sorting, setSorting] = useBrowserStorage<SortingState>(
-		`sort-c-${systemId ? 1 : 0}`,
-		[{ id: systemId ? "name" : "system", desc: false }],
-		sessionStorage
-	)
-	const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([])
-	const [columnVisibility, setColumnVisibility] = useState<VisibilityState>({})
-	const [rowSelection, setRowSelection] = useState({})
-	const [globalFilter, setGlobalFilter] = useState("")
-
-	useEffect(() => {
-		const pbOptions = {
-			fields: "id,name,image,cpu,memory,net,health,status,system,updated",
-		}
-
-		const fetchData = (lastXMs: number) => {
-			const updated = Date.now() - lastXMs
-			let filter: string
-			if (systemId) {
-				filter = pb.filter("system={:system} && updated > {:updated}", { system: systemId, updated })
-			} else {
-				filter = pb.filter("updated > {:updated}", { updated })
-			}
-			pb.collection<ContainerRecord>("containers")
-				.getList(0, 2000, {
-					...pbOptions,
-					filter,
-				})
-				.then(({ items }) => setData((curItems) => {
-					const containerIds = new Set(items.map(item => item.id))
-					const now = Date.now()
-					for (const item of curItems) {
-						if (!containerIds.has(item.id) && now - item.updated < 70_000) {
-							items.push(item)
-						}
-					}
-					return items
-				}))
-		}
-
-		// initial load
-		fetchData(70_000)
-
-		// if no systemId, poll every 10 seconds
-		if (!systemId) {
-			// poll every 10 seconds
-			const intervalId = setInterval(() => fetchData(10_500), 10_000)
-			// clear interval on unmount
-			return () => clearInterval(intervalId)
-		}
-
-		// if systemId, fetch containers after the system is updated
-		return listenKeys($allSystemsById, [systemId], (_newSystems) => {
-			setTimeout(() => fetchData(1000), 100)
-		})
-	}, [])
-
-	const table = useReactTable({
-		data,
-		columns: containerChartCols.filter(col => systemId ? col.id !== "system" : true),
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getFilteredRowModel: getFilteredRowModel(),
-		onSortingChange: setSorting,
-		onColumnFiltersChange: setColumnFilters,
-		onColumnVisibilityChange: setColumnVisibility,
-		onRowSelectionChange: setRowSelection,
-		defaultColumn: {
-			sortUndefined: "last",
-			size: 100,
-			minSize: 0,
-		},
-		state: {
-			sorting,
-			columnFilters,
-			columnVisibility,
-			rowSelection,
-			globalFilter,
-		},
-		onGlobalFilterChange: setGlobalFilter,
-		globalFilterFn: (row, _columnId, filterValue) => {
-			const container = row.original
-			const systemName = $allSystemsById.get()[container.system]?.name ?? ""
-			const id = container.id ?? ""
-			const name = container.name ?? ""
-			const status = container.status ?? ""
-			const healthLabel = ContainerHealthLabels[container.health as ContainerHealth] ?? ""
-			const image = container.image ?? ""
-			const searchString = `${systemName} ${id} ${name} ${healthLabel} ${status} ${image}`.toLowerCase()
-
-			return (filterValue as string)
-				.toLowerCase()
-				.split(" ")
-				.every((term) => searchString.includes(term))
-		},
-	})
-
-	const rows = table.getRowModel().rows
-	const visibleColumns = table.getVisibleLeafColumns()
-
-	return (
-		<Card className="p-6 @container w-full">
-			<CardHeader className="p-0 mb-4">
-				<div className="grid md:flex gap-5 w-full items-end">
-					<div className="px-2 sm:px-1">
-						<CardTitle className="mb-2">
-							<Trans>All Containers</Trans>
-						</CardTitle>
-						<CardDescription className="flex">
-							<Trans>Click on a container to view more information.</Trans>
-						</CardDescription>
-					</div>
-					<Input
-						placeholder={t`Filter...`}
-						value={globalFilter}
-						onChange={(e) => setGlobalFilter(e.target.value)}
-						className="ms-auto px-4 w-full max-w-full md:w-64"
-					/>
-				</div>
-			</CardHeader>
-			<div className="rounded-md">
-				<AllContainersTable table={table} rows={rows} colLength={visibleColumns.length} />
-			</div>
-		</Card>
-	)
-}
-
-const AllContainersTable = memo(
-	function AllContainersTable({ table, rows, colLength }: { table: TableType<ContainerRecord>; rows: Row<ContainerRecord>[]; colLength: number }) {
-		// The virtualizer will need a reference to the scrollable container element
-		const scrollRef = useRef<HTMLDivElement>(null)
-		const activeContainer = useRef<ContainerRecord | null>(null)
-		const [sheetOpen, setSheetOpen] = useState(false)
-		const openSheet = (container: ContainerRecord) => {
-			activeContainer.current = container
-			setSheetOpen(true)
-		}
-
-		const virtualizer = useVirtualizer<HTMLDivElement, HTMLTableRowElement>({
-			count: rows.length,
-			estimateSize: () => 54,
-			getScrollElement: () => scrollRef.current,
-			overscan: 5,
-		})
-		const virtualRows = virtualizer.getVirtualItems()
-
-		const paddingTop = Math.max(0, virtualRows[0]?.start ?? 0 - virtualizer.options.scrollMargin)
-		const paddingBottom = Math.max(0, virtualizer.getTotalSize() - (virtualRows[virtualRows.length - 1]?.end ?? 0))
-
-		return (
-			<div
-				className={cn(
-					"h-min max-h-[calc(100dvh-17rem)] max-w-full relative overflow-auto border rounded-md",
-					// don't set min height if there are less than 2 rows, do set if we need to display the empty state
-					(!rows.length || rows.length > 2) && "min-h-50"
-				)}
-				ref={scrollRef}
-			>
-				{/* add header height to table size */}
-				<div style={{ height: `${virtualizer.getTotalSize() + 48}px`, paddingTop, paddingBottom }}>
-					<table className="text-sm w-full h-full text-nowrap">
-						<ContainersTableHead table={table} />
-						<TableBody>
-							{rows.length ? (
-								virtualRows.map((virtualRow) => {
-									const row = rows[virtualRow.index]
-									return (
-										<ContainerTableRow
-											key={row.id}
-											row={row}
-											virtualRow={virtualRow}
-											openSheet={openSheet}
-										/>
-									)
-								})
-							) : (
-								<TableRow>
-									<TableCell colSpan={colLength} className="h-37 text-center pointer-events-none">
-										<Trans>No results.</Trans>
-									</TableCell>
-								</TableRow>
-							)}
-						</TableBody>
-					</table>
-				</div>
-				<ContainerSheet sheetOpen={sheetOpen} setSheetOpen={setSheetOpen} activeContainer={activeContainer} />
-			</div>
-		)
-	}
-)
-
-
-async function getLogsHtml(container: ContainerRecord): Promise<string> {
-	try {
-		const [{ highlighter }, logsHtml] = await Promise.all([import('@/lib/shiki'), pb.send<{ logs: string }>("/api/beszel/containers/logs", {
-			system: container.system,
-			container: container.id,
-		})])
-		return highlighter.codeToHtml(logsHtml.logs, { lang: "log", theme: syntaxTheme })
-	} catch (error) {
-		console.error(error)
-		return ""
-	}
-}
-
-async function getInfoHtml(container: ContainerRecord): Promise<string> {
-	try {
-		let [{ highlighter }, { info }] = await Promise.all([import('@/lib/shiki'), pb.send<{ info: string }>("/api/beszel/containers/info", {
-			system: container.system,
-			container: container.id,
-		})])
-		try {
-			info = JSON.stringify(JSON.parse(info), null, 2)
-		} catch (_) { }
-		return highlighter.codeToHtml(info, { lang: "json", theme: syntaxTheme })
-	} catch (error) {
-		console.error(error)
-		return ""
-	}
-}
-
-function ContainerSheet({ sheetOpen, setSheetOpen, activeContainer }: { sheetOpen: boolean, setSheetOpen: (open: boolean) => void, activeContainer: RefObject<ContainerRecord | null> }) {
-	const container = activeContainer.current
-	if (!container) return null
-
-	const [logsDisplay, setLogsDisplay] = useState<string>("")
-	const [infoDisplay, setInfoDisplay] = useState<string>("")
-	const [logsFullscreenOpen, setLogsFullscreenOpen] = useState<boolean>(false)
-	const [infoFullscreenOpen, setInfoFullscreenOpen] = useState<boolean>(false)
-	const [isRefreshingLogs, setIsRefreshingLogs] = useState<boolean>(false)
-	const logsContainerRef = useRef<HTMLDivElement>(null)
-
-	function scrollLogsToBottom() {
-		if (logsContainerRef.current) {
-			logsContainerRef.current.scrollTo({ top: logsContainerRef.current.scrollHeight })
-		}
-	}
-
-	const refreshLogs = async () => {
-		setIsRefreshingLogs(true)
-		const startTime = Date.now()
-
-		try {
-			const logsHtml = await getLogsHtml(container)
-			setLogsDisplay(logsHtml)
-			setTimeout(scrollLogsToBottom, 20)
-		} catch (error) {
-			console.error(error)
-		} finally {
-			// Ensure minimum spin duration of 800ms
-			const elapsed = Date.now() - startTime
-			const remaining = Math.max(0, 500 - elapsed)
-			setTimeout(() => {
-				setIsRefreshingLogs(false)
-			}, remaining)
-		}
-	}
-
-	useEffect(() => {
-		setLogsDisplay("")
-		setInfoDisplay("");
-		if (!container) return
-		(async () => {
-			const [logsHtml, infoHtml] = await Promise.all([getLogsHtml(container), getInfoHtml(container)])
-			setLogsDisplay(logsHtml)
-			setInfoDisplay(infoHtml)
-			setTimeout(scrollLogsToBottom, 20)
-		})()
-	}, [container])
-
-	return (
-		<>
-			<LogsFullscreenDialog
-				open={logsFullscreenOpen}
-				onOpenChange={setLogsFullscreenOpen}
-				logsDisplay={logsDisplay}
-				containerName={container.name}
-				onRefresh={refreshLogs}
-				isRefreshing={isRefreshingLogs}
-			/>
-			<InfoFullscreenDialog
-				open={infoFullscreenOpen}
-				onOpenChange={setInfoFullscreenOpen}
-				infoDisplay={infoDisplay}
-				containerName={container.name}
-			/>
-			<Sheet open={sheetOpen} onOpenChange={setSheetOpen}>
-				<SheetContent className="w-full sm:max-w-220 p-2">
-					<SheetHeader>
-						<SheetTitle>{container.name}</SheetTitle>
-						<SheetDescription className="flex flex-wrap items-center gap-x-2 gap-y-1">
-							<Link className="hover:underline" href={getPagePath($router, "system", { id: container.system })}>{$allSystemsById.get()[container.system]?.name ?? ""}</Link>
-							<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-							{container.status}
-							<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-							{container.image}
-							<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-							{container.id}
-							<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-							{ContainerHealthLabels[container.health as ContainerHealth]}
-						</SheetDescription>
-					</SheetHeader>
-					<div className="px-3 pb-3 -mt-4 flex flex-col gap-3 h-full items-start">
-						<div className="flex items-center w-full">
-							<h3>{t`Logs`}</h3>
-							<Button
-								variant="ghost"
-								size="sm"
-								onClick={refreshLogs}
-								className="h-8 w-8 p-0 ms-auto"
-								disabled={isRefreshingLogs}
-							>
-								<RefreshCwIcon
-									className={`size-4 transition-transform duration-300 ${isRefreshingLogs ? 'animate-spin' : ''}`}
-								/>
-							</Button>
-							<Button
-								variant="ghost"
-								size="sm"
-								onClick={() => setLogsFullscreenOpen(true)}
-								className="h-8 w-8 p-0"
-							>
-								<MaximizeIcon className="size-4" />
-							</Button>
-						</div>
-						<div ref={logsContainerRef} className={cn("max-h-[calc(50dvh-10rem)] w-full overflow-auto p-3 rounded-md bg-gh-dark text-sm", !logsDisplay && ["animate-pulse", "h-full"])}>
-							<div dangerouslySetInnerHTML={{ __html: logsDisplay }} />
-						</div>
-						<div className="flex items-center w-full">
-							<h3>{t`Detail`}</h3>
-							<Button
-								variant="ghost"
-								size="sm"
-								onClick={() => setInfoFullscreenOpen(true)}
-								className="h-8 w-8 p-0 ms-auto"
-							>
-								<MaximizeIcon className="size-4" />
-							</Button>
-						</div>
-						<div className={cn("grow h-[calc(50dvh-4rem)] w-full overflow-auto p-3 rounded-md bg-gh-dark text-sm", !infoDisplay && "animate-pulse")}>
-							<div dangerouslySetInnerHTML={{ __html: infoDisplay }} />
-						</div>
-
-					</div>
-				</SheetContent>
-			</Sheet>
-		</>
-
-	)
-}
-
-function ContainersTableHead({ table }: { table: TableType<ContainerRecord> }) {
-	return (
-		<TableHeader className="sticky top-0 z-50 w-full border-b-2">
-			{table.getHeaderGroups().map((headerGroup) => (
-				<tr key={headerGroup.id}>
-					{headerGroup.headers.map((header) => {
-						return (
-							<TableHead className="px-2" key={header.id}>
-								{header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())}
-							</TableHead>
-						)
-					})}
-				</tr>
-			))}
-		</TableHeader>
-	)
-}
-
-const ContainerTableRow = memo(
-	function ContainerTableRow({
-		row,
-		virtualRow,
-		openSheet,
-	}: {
-		row: Row<ContainerRecord>
-		virtualRow: VirtualItem
-		openSheet: (container: ContainerRecord) => void
-	}) {
-		return (
-			<TableRow
-				data-state={row.getIsSelected() && "selected"}
-				className="cursor-pointer transition-opacity"
-				onClick={() => openSheet(row.original)}
-			>
-				{row.getVisibleCells().map((cell) => (
-					<TableCell
-						key={cell.id}
-						className="py-0"
-						style={{
-							height: virtualRow.size,
-						}}
-					>
-						{flexRender(cell.column.columnDef.cell, cell.getContext())}
-					</TableCell>
-				))}
-			</TableRow>
-		)
-	}
-)
-
-function LogsFullscreenDialog({ open, onOpenChange, logsDisplay, containerName, onRefresh, isRefreshing }: { open: boolean, onOpenChange: (open: boolean) => void, logsDisplay: string, containerName: string, onRefresh: () => void | Promise<void>, isRefreshing: boolean }) {
-	const outerContainerRef = useRef<HTMLDivElement>(null)
-
-	useEffect(() => {
-		if (open && logsDisplay) {
-			// Scroll the outer container to bottom
-			const scrollToBottom = () => {
-				if (outerContainerRef.current) {
-					outerContainerRef.current.scrollTop = outerContainerRef.current.scrollHeight
-				}
-			}
-			setTimeout(scrollToBottom, 50)
-		}
-	}, [open, logsDisplay])
-
-	return (
-		<Dialog open={open} onOpenChange={onOpenChange}>
-			<DialogContent className="w-[calc(100vw-20px)] h-[calc(100dvh-20px)] max-w-none p-0 bg-gh-dark border-0 text-white">
-				<DialogTitle className="sr-only">{containerName} logs</DialogTitle>
-				<div ref={outerContainerRef} className="h-full overflow-auto">
-					<div className="h-full w-full px-3 leading-relaxed rounded-md bg-gh-dark text-sm">
-						<div className="py-3" dangerouslySetInnerHTML={{ __html: logsDisplay }} />
-					</div>
-				</div>
-				<button
-					onClick={() => {
-						void onRefresh()
-					}}
-					className="absolute top-3 right-11 opacity-60 hover:opacity-100 p-1"
-					disabled={isRefreshing}
-					title={t`Refresh`}
-					aria-label={t`Refresh`}
-				>
-					<RefreshCwIcon
-						className={`size-4 transition-transform duration-300 ${isRefreshing ? 'animate-spin' : ''}`}
-					/>
-				</button>
-			</DialogContent>
-		</Dialog>
-	)
-}
-
-function InfoFullscreenDialog({ open, onOpenChange, infoDisplay, containerName }: { open: boolean, onOpenChange: (open: boolean) => void, infoDisplay: string, containerName: string }) {
-	return (
-		<Dialog open={open} onOpenChange={onOpenChange}>
-			<DialogContent className="w-[calc(100vw-20px)] h-[calc(100dvh-20px)] max-w-none p-0 bg-gh-dark border-0 text-white">
-				<DialogTitle className="sr-only">{containerName} info</DialogTitle>
-				<div className="flex-1 overflow-auto">
-					<div className="h-full w-full overflow-auto p-3 rounded-md bg-gh-dark text-sm leading-relaxed">
-						<div dangerouslySetInnerHTML={{ __html: infoDisplay }} />
-					</div>
-				</div>
-			</DialogContent>
-		</Dialog>
-	)
-}

internal/site/src/components/footer-repo-link.tsx

@@ -1,26 +0,0 @@
-import { GithubIcon } from "lucide-react"
-import { Separator } from "./ui/separator"
-
-export function FooterRepoLink() {
-	return (
-		<div className="flex gap-1.5 justify-end items-center pe-3 sm:pe-6 mt-3.5 mb-4 text-xs opacity-80">
-			<a
-				href="https://github.com/henrygd/beszel"
-				target="_blank"
-				className="flex items-center gap-0.5 text-muted-foreground hover:text-foreground duration-75"
-				rel="noopener"
-			>
-				<GithubIcon className="h-3 w-3" /> GitHub
-			</a>
-			<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-			<a
-				href="https://github.com/henrygd/beszel/releases"
-				target="_blank"
-				className="text-muted-foreground hover:text-foreground duration-75"
-				rel="noopener"
-			>
-				Beszel {globalThis.BESZEL.HUB_VERSION}
-			</a>
-		</div>
-	)
-}

internal/site/src/components/lang-toggle.tsx

@@ -12,7 +12,7 @@ export function LangToggle() {
 	return (
 		<DropdownMenu>
 			<DropdownMenuTrigger asChild>
-				<Button variant={"ghost"} size="icon" className="hidden sm:flex">
+				<Button variant={"ghost"} size="icon" className="hidden 450:flex">
 					<LanguagesIcon className="absolute h-[1.2rem] w-[1.2rem] light:opacity-85" />
 					<span className="sr-only">Language</span>
 				</Button>

internal/site/src/components/logo.tsx

@@ -1,27 +1,16 @@
-import { useId } from "react"
-
-const d = "M146.4 73.1h-30.5V59.8h30.5a3.2 3.2 0 0 0 2.3-1 3.2 3.2 0 0 0 1-2.3q0-.8-.3-1.3a1.5 1.5 0 0 0-.7-.6 4.7 4.7 0 0 0-1-.3l-1.3-.1h-13.9q-3.4 0-6.5-1.3-3-1.3-5.2-3.6a16.9 16.9 0 0 1-3.6-5.3 16.3 16.3 0 0 1-1.3-6.5 16.4 16.4 0 0 1 1.3-6.4q1.3-3.1 3.6-5.4 2.2-2.2 5.2-3.5a16.3 16.3 0 0 1 6.5-1.3h27v13.3h-27a3.2 3.2 0 0 0-2.3 1 3.2 3.2 0 0 0-1 2.3 3.3 3.3 0 0 0 1 2.4 3.3 3.3 0 0 0 1.2.8 3.2 3.2 0 0 0 1.1.2h13.9a18.1 18.1 0 0 1 6 1 17.3 17.3 0 0 1 .4.2q3 1.1 5.3 3.2a15.1 15.1 0 0 1 3.6 4.9 14.7 14.7 0 0 1 1.3 5.4 17.2 17.2 0 0 1 0 .9 16 16 0 0 1-1 5.8 15.4 15.4 0 0 1-.3.7 17.3 17.3 0 0 1-3.6 5.2 16.4 16.4 0 0 1-5.3 3.6 16.2 16.2 0 0 1-6.4 1.3Zm64.5-13.3v13.3h-43.6l22-39h-22V21h43.6l-22 39h22ZM35 73.1H0v-70h35q4.4 0 8.2 1.6a21.4 21.4 0 0 1 6.6 4.6q2.9 2.8 4.5 6.6 1.7 3.8 1.7 8.2a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5 1.4 1.6 2.4 3.5a18.3 18.3 0 0 1 1.5 4A17.4 17.4 0 0 1 56 51a15.3 15.3 0 0 1 0 1.1q0 4.3-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.5-3.8 1.7-8.2 1.7Zm76-43L86 60.4l1.5.3a16.7 16.7 0 0 0 1.6 0q2 0 3.8-.4 1.8-.6 3.4-1.6 1.6-1 2.8-2.4a12.8 12.8 0 0 0 2-3.2l9.8 9.8q-1.9 2.6-4.3 4.7a27 27 0 0 1-5.2 3.6 26.1 26.1 0 0 1-6 2.2 26.8 26.8 0 0 1-6.3.8 26.4 26.4 0 0 1-10.4-2 26.2 26.2 0 0 1-8.5-5.8 26.7 26.7 0 0 1-5.5-8.3 30.4 30.4 0 0 1-.2-.4q-2.1-5-2.1-11.1a31.9 31.9 0 0 1 .7-7 27 27 0 0 1 1.4-4.3 27 27 0 0 1 3.8-6.6 24.5 24.5 0 0 1 2-2.2 26 26 0 0 1 8.4-5.6 27 27 0 0 1 10.4-2 26.3 26.3 0 0 1 6.4.8 26.9 26.9 0 0 1 6 2.2q2.7 1.5 5.2 3.6 2.4 2.1 4.3 4.8Zm152.3 0-25 30.2 1.5.3a16.7 16.7 0 0 0 1.6 0q2 0 3.8-.4 1.8-.6 3.4-1.6 1.5-1 2.8-2.4a12.8 12.8 0 0 0 2-3.2l9.8 9.8q-1.9 2.6-4.3 4.7a27 27 0 0 1-5.2 3.6 26.1 26.1 0 0 1-6 2.2 26.8 26.8 0 0 1-6.3.8 26.4 26.4 0 0 1-10.4-2 26.2 26.2 0 0 1-8.5-5.8A26.7 26.7 0 0 1 217 58a30.4 30.4 0 0 1-.2-.4q-2.1-5-2.1-11.1a31.9 31.9 0 0 1 .7-7 27 27 0 0 1 1.4-4.3 27 27 0 0 1 3.8-6.6 24.5 24.5 0 0 1 2-2.2 26 26 0 0 1 8.4-5.6 27 27 0 0 1 10.4-2 26.3 26.3 0 0 1 6.4.8 26.9 26.9 0 0 1 6 2.2q2.7 1.5 5.2 3.6 2.4 2.1 4.3 4.8ZM283.4 0v73.1H270V0h13.4ZM14 17v14.1h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 30 40 29a6.9 6.9 0 0 0 1.5-2.3q.5-1.3.5-2.7a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.5q-.6-1.2-1.5-2.2a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.5 7.9 7.9 0 0 0-.2 0H14Zm0 28.1v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.2Q39 58 40 57.1a7 7 0 0 0 1.5-2.3 6.9 6.9 0 0 0 .5-2.5 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 48 40 47a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm63.3 8.3 15.5-20.6a8 8 0 0 0-1.4-.4 7 7 0 0 0-.4 0 17.2 17.2 0 0 0-1.6-.1 19.2 19.2 0 0 0-.3 0 13.3 13.3 0 0 0-5.1 1q-2.5 1-4.2 2.8a13.1 13.1 0 0 0-2.5 3.6 15.5 15.5 0 0 0-.3.9 14.7 14.7 0 0 0-1 3.5 18.7 18.7 0 0 0 0 2.4 17.6 17.6 0 0 0 0 .7v.8a29.4 29.4 0 0 0 0 .1 19.2 19.2 0 0 0 .2 2 20.2 20.2 0 0 0 .4 1.6 18.6 18.6 0 0 0 0 .2 7.5 7.5 0 0 0 .4.9 6 6 0 0 0 .3.6Zm152.3 0L245 32.8a8 8 0 0 0-1.4-.4 7 7 0 0 0-.4 0 17.2 17.2 0 0 0-1.6-.1 19.2 19.2 0 0 0-.3 0 13.3 13.3 0 0 0-5.1 1q-2.5 1-4.2 2.8a13.1 13.1 0 0 0-2.5 3.6 15.5 15.5 0 0 0-.4.9 14.7 14.7 0 0 0-.8 3.5 18.7 18.7 0 0 0-.2 2.4 17.6 17.6 0 0 0 0 .7v.8a29.4 29.4 0 0 0 .1.1 19.2 19.2 0 0 0 .2 2 20.2 20.2 0 0 0 .4 1.6 18.6 18.6 0 0 0 0 .2 7.5 7.5 0 0 0 .4.9 6 6 0 0 0 .3.6Z"
-
 export function Logo({ className }: { className?: string }) {
-	const id = useId()
-
 	return (
-		// Righteous font from Google Fonts
+		// Righteous
 		<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 285 75" className={className}>
-			<defs>
-				<linearGradient id={id} x1="0%" y1="20%" x2="100%" y2="120%">
-					<stop offset="10%" style={{ stopColor: "#747bff" }} />
-					<stop offset="90%" style={{ stopColor: "#24eb5c" }} />
+			{/* <defs>
+				<linearGradient id="gradient" x1="0%" y1="20%" x2="100%" y2="120%">
+					<stop offset="0%" style={{ stopColor: "#747bff" }} />
+					<stop offset="100%" style={{ stopColor: "#24eb5c" }} />
 				</linearGradient>
-			</defs>
+			</defs> */}
 			<path
-				className="duration-250 group-hover:opacity-0 group-hover:ease-in ease-out"
-				d={d}
-			/>
-			<path
-				className="opacity-0 duration-250 group-hover:opacity-100 ease-in-out"
-				fill={`url(#${id})`}
-				d={d}
+				// fill="url(#gradient)"
+				d="M146.4 73.1h-30.5V59.8h30.5a3.2 3.2 0 0 0 2.3-1 3.2 3.2 0 0 0 1-2.3q0-.8-.3-1.3a1.5 1.5 0 0 0-.7-.6 4.7 4.7 0 0 0-1-.3l-1.3-.1h-13.9q-3.4 0-6.5-1.3-3-1.3-5.2-3.6a16.9 16.9 0 0 1-3.6-5.3 16.3 16.3 0 0 1-1.3-6.5 16.4 16.4 0 0 1 1.3-6.4q1.3-3.1 3.6-5.4 2.2-2.2 5.2-3.5a16.3 16.3 0 0 1 6.5-1.3h27v13.3h-27a3.2 3.2 0 0 0-2.3 1 3.2 3.2 0 0 0-1 2.3 3.3 3.3 0 0 0 1 2.4 3.3 3.3 0 0 0 1.2.8 3.2 3.2 0 0 0 1.1.2h13.9a18.1 18.1 0 0 1 6 1 17.3 17.3 0 0 1 .4.2q3 1.1 5.3 3.2a15.1 15.1 0 0 1 3.6 4.9 14.7 14.7 0 0 1 1.3 5.4 17.2 17.2 0 0 1 0 .9 16 16 0 0 1-1 5.8 15.4 15.4 0 0 1-.3.7 17.3 17.3 0 0 1-3.6 5.2 16.4 16.4 0 0 1-5.3 3.6 16.2 16.2 0 0 1-6.4 1.3Zm64.5-13.3v13.3h-43.6l22-39h-22V21h43.6l-22 39h22ZM35 73.1H0v-70h35q4.4 0 8.2 1.6a21.4 21.4 0 0 1 6.6 4.6q2.9 2.8 4.5 6.6 1.7 3.8 1.7 8.2a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5 1.4 1.6 2.4 3.5a18.3 18.3 0 0 1 1.5 4A17.4 17.4 0 0 1 56 51a15.3 15.3 0 0 1 0 1.1q0 4.3-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.5-3.8 1.7-8.2 1.7Zm76-43L86 60.4l1.5.3a16.7 16.7 0 0 0 1.6 0q2 0 3.8-.4 1.8-.6 3.4-1.6 1.6-1 2.8-2.4a12.8 12.8 0 0 0 2-3.2l9.8 9.8q-1.9 2.6-4.3 4.7a27 27 0 0 1-5.2 3.6 26.1 26.1 0 0 1-6 2.2 26.8 26.8 0 0 1-6.3.8 26.4 26.4 0 0 1-10.4-2 26.2 26.2 0 0 1-8.5-5.8 26.7 26.7 0 0 1-5.5-8.3 30.4 30.4 0 0 1-.2-.4q-2.1-5-2.1-11.1a31.9 31.9 0 0 1 .7-7 27 27 0 0 1 1.4-4.3 27 27 0 0 1 3.8-6.6 24.5 24.5 0 0 1 2-2.2 26 26 0 0 1 8.4-5.6 27 27 0 0 1 10.4-2 26.3 26.3 0 0 1 6.4.8 26.9 26.9 0 0 1 6 2.2q2.7 1.5 5.2 3.6 2.4 2.1 4.3 4.8Zm152.3 0-25 30.2 1.5.3a16.7 16.7 0 0 0 1.6 0q2 0 3.8-.4 1.8-.6 3.4-1.6 1.5-1 2.8-2.4a12.8 12.8 0 0 0 2-3.2l9.8 9.8q-1.9 2.6-4.3 4.7a27 27 0 0 1-5.2 3.6 26.1 26.1 0 0 1-6 2.2 26.8 26.8 0 0 1-6.3.8 26.4 26.4 0 0 1-10.4-2 26.2 26.2 0 0 1-8.5-5.8A26.7 26.7 0 0 1 217 58a30.4 30.4 0 0 1-.2-.4q-2.1-5-2.1-11.1a31.9 31.9 0 0 1 .7-7 27 27 0 0 1 1.4-4.3 27 27 0 0 1 3.8-6.6 24.5 24.5 0 0 1 2-2.2 26 26 0 0 1 8.4-5.6 27 27 0 0 1 10.4-2 26.3 26.3 0 0 1 6.4.8 26.9 26.9 0 0 1 6 2.2q2.7 1.5 5.2 3.6 2.4 2.1 4.3 4.8ZM283.4 0v73.1H270V0h13.4ZM14 17v14.1h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 30 40 29a6.9 6.9 0 0 0 1.5-2.3q.5-1.3.5-2.7a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.5q-.6-1.2-1.5-2.2a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.5 7.9 7.9 0 0 0-.2 0H14Zm0 28.1v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.2Q39 58 40 57.1a7 7 0 0 0 1.5-2.3 6.9 6.9 0 0 0 .5-2.5 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 48 40 47a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm63.3 8.3 15.5-20.6a8 8 0 0 0-1.4-.4 7 7 0 0 0-.4 0 17.2 17.2 0 0 0-1.6-.1 19.2 19.2 0 0 0-.3 0 13.3 13.3 0 0 0-5.1 1q-2.5 1-4.2 2.8a13.1 13.1 0 0 0-2.5 3.6 15.5 15.5 0 0 0-.3.9 14.7 14.7 0 0 0-1 3.5 18.7 18.7 0 0 0 0 2.4 17.6 17.6 0 0 0 0 .7v.8a29.4 29.4 0 0 0 0 .1 19.2 19.2 0 0 0 .2 2 20.2 20.2 0 0 0 .4 1.6 18.6 18.6 0 0 0 0 .2 7.5 7.5 0 0 0 .4.9 6 6 0 0 0 .3.6Zm152.3 0L245 32.8a8 8 0 0 0-1.4-.4 7 7 0 0 0-.4 0 17.2 17.2 0 0 0-1.6-.1 19.2 19.2 0 0 0-.3 0 13.3 13.3 0 0 0-5.1 1q-2.5 1-4.2 2.8a13.1 13.1 0 0 0-2.5 3.6 15.5 15.5 0 0 0-.4.9 14.7 14.7 0 0 0-.8 3.5 18.7 18.7 0 0 0-.2 2.4 17.6 17.6 0 0 0 0 .7v.8a29.4 29.4 0 0 0 .1.1 19.2 19.2 0 0 0 .2 2 20.2 20.2 0 0 0 .4 1.6 18.6 18.6 0 0 0 0 .2 7.5 7.5 0 0 0 .4.9 6 6 0 0 0 .3.6Z"
 			/>
 		</svg>
 	)

internal/site/src/components/navbar.tsx

@@ -1,7 +1,6 @@
 import { Trans } from "@lingui/react/macro"
 import { getPagePath } from "@nanostores/router"
 import {
-	ContainerIcon,
 	DatabaseBackupIcon,
 	LogOutIcon,
 	LogsIcon,
@@ -40,7 +39,7 @@ export default function Navbar() {
 			<Link
 				href={basePath}
 				aria-label="Home"
-				className="p-2 ps-0 me-3 group"
+				className="p-2 ps-0 me-3"
 				onMouseEnter={runOnce(() => import("@/components/routes/home"))}
 			>
 				<Logo className="h-[1.1rem] md:h-5 fill-foreground" />
@@ -48,25 +47,18 @@ export default function Navbar() {
 			<SearchButton />
 
 			<div className="flex items-center ms-auto" onMouseEnter={() => import("@/components/routes/settings/general")}>
-				<Link
-					href={getPagePath($router, "containers")}
-					className={cn(buttonVariants({ variant: "ghost", size: "icon" }))}
-					aria-label="Containers"
-				>
-					<ContainerIcon className="h-[1.2rem] w-[1.2rem]" strokeWidth={1.5} />
-				</Link>
 				<LangToggle />
 				<ModeToggle />
 				<Link
 					href={getPagePath($router, "settings", { name: "general" })}
 					aria-label="Settings"
-					className={cn(buttonVariants({ variant: "ghost", size: "icon" }))}
+					className={cn("", buttonVariants({ variant: "ghost", size: "icon" }))}
 				>
 					<SettingsIcon className="h-[1.2rem] w-[1.2rem]" />
 				</Link>
 				<DropdownMenu>
 					<DropdownMenuTrigger asChild>
-						<button aria-label="User Actions" className={cn(buttonVariants({ variant: "ghost", size: "icon" }))}>
+						<button aria-label="User Actions" className={cn("", buttonVariants({ variant: "ghost", size: "icon" }))}>
 							<UserIcon className="h-[1.2rem] w-[1.2rem]" />
 						</button>
 					</DropdownMenuTrigger>
@@ -120,7 +112,7 @@ export default function Navbar() {
 						</DropdownMenuItem>
 					</DropdownMenuContent>
 				</DropdownMenu>
-				<AddSystemButton className="ms-2 hidden 450:flex" />
+				<AddSystemButton className="ms-2" />
 			</div>
 		</div>
 	)

internal/site/src/components/router.tsx

@@ -2,8 +2,7 @@ import { createRouter } from "@nanostores/router"
 
 const routes = {
 	home: "/",
-	containers: "/containers",
-	system: `/system/:id`,
+	system: `/system/:name`,
 	settings: `/settings/:name?`,
 	forgot_password: `/forgot-password`,
 	request_otp: `/request-otp`,

internal/site/src/components/routes/containers.tsx

@@ -1,26 +0,0 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo, useEffect, useMemo } from "react"
-import ContainersTable from "@/components/containers-table/containers-table"
-import { ActiveAlerts } from "@/components/active-alerts"
-import { FooterRepoLink } from "@/components/footer-repo-link"
-
-export default memo(() => {
-	const { t } = useLingui()
-
-	useEffect(() => {
-		document.title = `${t`All Containers`} / Beszel`
-	}, [t])
-
-	return useMemo(
-		() => (
-			<>
-				<div className="grid gap-4">
-					<ActiveAlerts />
-					<ContainersTable />
-				</div>
-				<FooterRepoLink />
-			</>
-		),
-		[]
-	)
-})

internal/site/src/components/routes/home.tsx

@@ -1,28 +1,128 @@
-import { useLingui } from "@lingui/react/macro"
+import { Plural, Trans, useLingui } from "@lingui/react/macro"
+import { useStore } from "@nanostores/react"
+import { getPagePath } from "@nanostores/router"
+import { GithubIcon } from "lucide-react"
 import { memo, Suspense, useEffect, useMemo } from "react"
+import { $router, Link } from "@/components/router"
 import SystemsTable from "@/components/systems-table/systems-table"
-import { ActiveAlerts } from "@/components/active-alerts"
-import { FooterRepoLink } from "@/components/footer-repo-link"
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Separator } from "@/components/ui/separator"
+import { alertInfo } from "@/lib/alerts"
+import { $alerts, $allSystemsById } from "@/lib/stores"
+import type { AlertRecord } from "@/types"
 
 export default memo(() => {
 	const { t } = useLingui()
 
 	useEffect(() => {
-		document.title = `${t`All Systems`} / Beszel`
+		document.title = `${t`Dashboard`} / Beszel`
 	}, [t])
 
 	return useMemo(
 		() => (
 			<>
-				<div className="flex flex-col gap-4">
-					<ActiveAlerts />
-					<Suspense>
-						<SystemsTable />
-					</Suspense>
+				<ActiveAlerts />
+				<Suspense>
+					<SystemsTable />
+				</Suspense>
+
+				<div className="flex gap-1.5 justify-end items-center pe-3 sm:pe-6 mt-3.5 mb-4 text-xs opacity-80">
+					<a
+						href="https://github.com/henrygd/beszel"
+						target="_blank"
+						className="flex items-center gap-0.5 text-muted-foreground hover:text-foreground duration-75"
+						rel="noopener"
+					>
+						<GithubIcon className="h-3 w-3" /> GitHub
+					</a>
+					<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
+					<a
+						href="https://github.com/henrygd/beszel/releases"
+						target="_blank"
+						className="text-muted-foreground hover:text-foreground duration-75"
+						rel="noopener"
+					>
+						Beszel {globalThis.BESZEL.HUB_VERSION}
+					</a>
 				</div>
-				<FooterRepoLink />
 			</>
 		),
 		[]
 	)
 })
+
+const ActiveAlerts = () => {
+	const alerts = useStore($alerts)
+	const systems = useStore($allSystemsById)
+
+	const { activeAlerts, alertsKey } = useMemo(() => {
+		const activeAlerts: AlertRecord[] = []
+		// key to prevent re-rendering if alerts change but active alerts didn't
+		const alertsKey: string[] = []
+
+		for (const systemId of Object.keys(alerts)) {
+			for (const alert of alerts[systemId].values()) {
+				if (alert.triggered && alert.name in alertInfo) {
+					activeAlerts.push(alert)
+					alertsKey.push(`${alert.system}${alert.value}${alert.min}`)
+				}
+			}
+		}
+
+		return { activeAlerts, alertsKey }
+	}, [alerts])
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: alertsKey is inclusive
+	return useMemo(() => {
+		if (activeAlerts.length === 0) {
+			return null
+		}
+		return (
+			<Card className="mb-4">
+				<CardHeader className="pb-4 px-2 sm:px-6 max-sm:pt-5 max-sm:pb-1">
+					<div className="px-2 sm:px-1">
+						<CardTitle>
+							<Trans>Active Alerts</Trans>
+						</CardTitle>
+					</div>
+				</CardHeader>
+				<CardContent className="max-sm:p-2">
+					{activeAlerts.length > 0 && (
+						<div className="grid sm:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4 gap-3">
+							{activeAlerts.map((alert) => {
+								const info = alertInfo[alert.name as keyof typeof alertInfo]
+								return (
+									<Alert
+										key={alert.id}
+										className="hover:-translate-y-px duration-200 bg-transparent border-foreground/10 hover:shadow-md shadow-black/5"
+									>
+										<info.icon className="h-4 w-4" />
+										<AlertTitle>
+											{systems[alert.system]?.name} {info.name().toLowerCase().replace("cpu", "CPU")}
+										</AlertTitle>
+										<AlertDescription>
+											{alert.name === "Status" ? (
+												<Trans>Connection is down</Trans>
+											) : (
+												<Trans>
+													Exceeds {alert.value}
+													{info.unit} in last <Plural value={alert.min} one="# minute" other="# minutes" />
+												</Trans>
+											)}
+										</AlertDescription>
+										<Link
+											href={getPagePath($router, "system", { name: systems[alert.system]?.name })}
+											className="absolute inset-0 w-full h-full"
+											aria-label="View system"
+										></Link>
+									</Alert>
+								)
+							})}
+						</div>
+					)}
+				</CardContent>
+			</Card>
+		)
+	}, [alertsKey.join("")])
+}

internal/site/src/components/routes/settings/config-yaml.tsx

@@ -63,7 +63,7 @@ export default function ConfigYaml() {
 						</Trans>
 					</p>
 					<Alert className="my-4 border-destructive text-destructive w-auto table md:pe-6">
-						<AlertCircleIcon className="size-4.5 stroke-destructive" />
+						<AlertCircleIcon className="h-4 w-4 stroke-destructive" />
 						<AlertTitle>
 							<Trans>Caution - potential data loss</Trans>
 						</AlertTitle>

internal/site/src/components/routes/system.tsx

@@ -13,8 +13,8 @@ import {
 	XIcon,
 } from "lucide-react"
 import { subscribeKeys } from "nanostores"
-import React, { type JSX, lazy, memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
-import AreaChartDefault, { type DataPoint } from "@/components/charts/area-chart"
+import React, { type JSX, memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
+import AreaChartDefault from "@/components/charts/area-chart"
 import ContainerChart from "@/components/charts/container-chart"
 import DiskChart from "@/components/charts/disk-chart"
 import GpuPowerChart from "@/components/charts/gpu-power-chart"
@@ -24,10 +24,9 @@ import MemChart from "@/components/charts/mem-chart"
 import SwapChart from "@/components/charts/swap-chart"
 import TemperatureChart from "@/components/charts/temperature-chart"
 import { getPbTimestamp, pb } from "@/lib/api"
-import { ChartType, ConnectionType, connectionTypeLabels, Os, SystemStatus, Unit } from "@/lib/enums"
+import { ChartType, ConnectionType, Os, SystemStatus, Unit } from "@/lib/enums"
 import { batteryStateTranslations } from "@/lib/i18n"
 import {
-	$allSystemsById,
 	$allSystemsByName,
 	$chartTime,
 	$containerFilter,
@@ -41,7 +40,6 @@ import { useIntersectionObserver } from "@/lib/use-intersection-observer"
 import {
 	chartTimeData,
 	cn,
-	compareSemVer,
 	debounce,
 	decimalString,
 	formatBytes,
@@ -51,16 +49,7 @@ import {
 	toFixedFloat,
 	useBrowserStorage,
 } from "@/lib/utils"
-import type {
-	ChartData,
-	ChartTimes,
-	ContainerStatsRecord,
-	GPUData,
-	SystemInfo,
-	SystemRecord,
-	SystemStats,
-	SystemStatsRecord,
-} from "@/types"
+import type { ChartData, ChartTimes, ContainerStatsRecord, GPUData, SystemRecord, SystemStatsRecord } from "@/types"
 import ChartTimeSelect from "../charts/chart-time-select"
 import { $router, navigate } from "../router"
 import Spinner from "../spinner"
@@ -74,8 +63,6 @@ import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../ui/
 import NetworkSheet from "./system/network-sheet"
 import LineChartDefault from "../charts/line-chart"
 
-
-
 type ChartTimeData = {
 	time: number
 	data: {
@@ -96,8 +83,7 @@ function getTimeData(chartTime: ChartTimes, lastCreated: number) {
 		}
 	}
 
-	const buffer = chartTime === "1m" ? 400 : 20_000
-	const now = new Date(Date.now() + buffer)
+	const now = new Date()
 	const startTime = chartTimeData[chartTime].getOffset(now)
 	const ticks = timeTicks(startTime, now, chartTimeData[chartTime].ticks ?? 12).map((date) => date.getTime())
 	const data = {
@@ -109,28 +95,25 @@ function getTimeData(chartTime: ChartTimes, lastCreated: number) {
 }
 
 // add empty values between records to make gaps if interval is too large
-function addEmptyValues<T extends { created: string | number | null }>(
+function addEmptyValues<T extends SystemStatsRecord | ContainerStatsRecord>(
 	prevRecords: T[],
 	newRecords: T[],
 	expectedInterval: number
-): T[] {
+) {
 	const modifiedRecords: T[] = []
 	let prevTime = (prevRecords.at(-1)?.created ?? 0) as number
 	for (let i = 0; i < newRecords.length; i++) {
 		const record = newRecords[i]
-		if (record.created !== null) {
-			record.created = new Date(record.created).getTime()
-		}
-		if (prevTime && record.created !== null) {
+		record.created = new Date(record.created).getTime()
+		if (prevTime) {
 			const interval = record.created - prevTime
 			// if interval is too large, add a null record
 			if (interval > expectedInterval / 2 + expectedInterval) {
-				modifiedRecords.push({ created: null, ...("stats" in record ? { stats: null } : {}) } as T)
+				// @ts-expect-error
+				modifiedRecords.push({ created: null, stats: null })
 			}
 		}
-		if (record.created !== null) {
-			prevTime = record.created
-		}
+		prevTime = record.created
 		modifiedRecords.push(record)
 	}
 	return modifiedRecords
@@ -154,14 +137,14 @@ async function getStats<T extends SystemStatsRecord | ContainerStatsRecord>(
 	})
 }
 
-function dockerOrPodman(str: string, system: SystemRecord): string {
+function dockerOrPodman(str: string, system: SystemRecord) {
 	if (system.info.p) {
 		return str.replace("docker", "podman").replace("Docker", "Podman")
 	}
 	return str
 }
 
-export default memo(function SystemDetail({ id }: { id: string }) {
+export default memo(function SystemDetail({ name }: { name: string }) {
 	const direction = useStore($direction)
 	const { t } = useLingui()
 	const systems = useStore($systems)
@@ -171,15 +154,17 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 	const [system, setSystem] = useState({} as SystemRecord)
 	const [systemStats, setSystemStats] = useState([] as SystemStatsRecord[])
 	const [containerData, setContainerData] = useState([] as ChartData["containerData"])
-	const temperatureChartRef = useRef<HTMLDivElement>(null)
+	const netCardRef = useRef<HTMLDivElement>(null)
 	const persistChartTime = useRef(false)
+	const [containerFilterBar, setContainerFilterBar] = useState(null as null | JSX.Element)
 	const [bottomSpacing, setBottomSpacing] = useState(0)
 	const [chartLoading, setChartLoading] = useState(true)
-	const isLongerChart = !["1m", "1h"].includes(chartTime) // true if chart time is not 1m or 1h
+	const isLongerChart = chartTime !== "1h"
 	const userSettings = $userSettings.get()
 	const chartWrapRef = useRef<HTMLDivElement>(null)
 
 	useEffect(() => {
+		document.title = `${name} / Beszel`
 		return () => {
 			if (!persistChartTime.current) {
 				$chartTime.set($userSettings.get().chartTime)
@@ -187,71 +172,18 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 			persistChartTime.current = false
 			setSystemStats([])
 			setContainerData([])
+			setContainerFilterBar(null)
 			$containerFilter.set("")
 		}
-	}, [id])
+	}, [name])
 
 	// find matching system and update when it changes
 	useEffect(() => {
-		if (!systems.length) {
-			return
-		}
-		// allow old system-name slug to work
-		const store = $allSystemsById.get()[id] ? $allSystemsById : $allSystemsByName
-		return subscribeKeys(store, [id], (newSystems) => {
-			const sys = newSystems[id]
-			if (sys) {
-				setSystem(sys)
-				document.title = `${sys?.name} / Beszel`
-			}
+		return subscribeKeys($allSystemsByName, [name], (newSystems) => {
+			const sys = newSystems[name]
+			sys?.id && setSystem(sys)
 		})
-	}, [id, systems.length])
-
-	// hide 1m chart time if system agent version is less than 0.13.0
-	useEffect(() => {
-		if (parseSemVer(system?.info?.v) < parseSemVer("0.13.0")) {
-			$chartTime.set("1h")
-		}
-	}, [system?.info?.v])
-
-	// subscribe to realtime metrics if chart time is 1m
-	// biome-ignore lint/correctness/useExhaustiveDependencies: not necessary
-	useEffect(() => {
-		let unsub = () => { }
-		if (!system.id || chartTime !== "1m") {
-			return
-		}
-		if (system.status !== SystemStatus.Up || parseSemVer(system?.info?.v).minor < 13) {
-			$chartTime.set("1h")
-			return
-		}
-		pb.realtime
-			.subscribe(
-				`rt_metrics`,
-				(data: { container: ContainerStatsRecord[]; info: SystemInfo; stats: SystemStats }) => {
-					if (data.container?.length > 0) {
-						const newContainerData = makeContainerData([
-							{ created: Date.now(), stats: data.container } as unknown as ContainerStatsRecord,
-						])
-						setContainerData((prevData) => addEmptyValues(prevData, prevData.slice(-59).concat(newContainerData), 1000))
-					}
-					setSystemStats((prevStats) =>
-						addEmptyValues(
-							prevStats,
-							prevStats.slice(-59).concat({ created: Date.now(), stats: data.stats } as SystemStatsRecord),
-							1000
-						)
-					)
-				},
-				{ query: { system: system.id } }
-			)
-			.then((us) => {
-				unsub = us
-			})
-		return () => {
-			unsub?.()
-		}
-	}, [chartTime, system.id])
+	}, [name])
 
 	// biome-ignore lint/correctness/useExhaustiveDependencies: not necessary
 	const chartData: ChartData = useMemo(() => {
@@ -289,13 +221,13 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 			}
 			containerData.push(containerStats)
 		}
-		return containerData
+		setContainerData(containerData)
 	}, [])
 
 	// get stats
 	// biome-ignore lint/correctness/useExhaustiveDependencies: not necessary
 	useEffect(() => {
-		if (!system.id || !chartTime || chartTime === "1m") {
+		if (!system.id || !chartTime) {
 			return
 		}
 		// loading: true
@@ -329,7 +261,12 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 				}
 				cache.set(cs_cache_key, containerData)
 			}
-			setContainerData(makeContainerData(containerData))
+			if (containerData.length) {
+				!containerFilterBar && setContainerFilterBar(<FilterBar />)
+			} else if (containerFilterBar) {
+				setContainerFilterBar(null)
+			}
+			makeContainerData(containerData)
 		})
 	}, [system, chartTime])
 
@@ -398,20 +335,19 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 		}[]
 	}, [system, t])
 
-	/** Space for tooltip if more than 10 sensors and no containers table */
+	/** Space for tooltip if more than 12 containers */
 	useEffect(() => {
-		const sensors = Object.keys(systemStats.at(-1)?.stats.t ?? {})
-		if (!temperatureChartRef.current || sensors.length < 10 || containerData.length > 0) {
+		if (!netCardRef.current || !containerData.length) {
 			setBottomSpacing(0)
 			return
 		}
-		const tooltipHeight = (sensors.length - 10) * 17.8 - 40
+		const tooltipHeight = (Object.keys(containerData[0]).length - 11) * 17.8 - 40
 		const wrapperEl = chartWrapRef.current as HTMLDivElement
 		const wrapperRect = wrapperEl.getBoundingClientRect()
-		const chartRect = temperatureChartRef.current.getBoundingClientRect()
+		const chartRect = netCardRef.current.getBoundingClientRect()
 		const distanceToBottom = wrapperRect.bottom - chartRect.bottom
 		setBottomSpacing(tooltipHeight - distanceToBottom)
-	}, [])
+	}, [containerData])
 
 	// keyboard navigation between systems
 	useEffect(() => {
@@ -428,7 +364,7 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 			) {
 				return
 			}
-			const currentIndex = systems.findIndex((s) => s.id === id)
+			const currentIndex = systems.findIndex((s) => s.name === name)
 			if (currentIndex === -1 || systems.length <= 1) {
 				return
 			}
@@ -437,18 +373,18 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 				case "h": {
 					const prevIndex = (currentIndex - 1 + systems.length) % systems.length
 					persistChartTime.current = true
-					return navigate(getPagePath($router, "system", { id: systems[prevIndex].id }))
+					return navigate(getPagePath($router, "system", { name: systems[prevIndex].name }))
 				}
 				case "ArrowRight":
 				case "l": {
 					const nextIndex = (currentIndex + 1) % systems.length
 					persistChartTime.current = true
-					return navigate(getPagePath($router, "system", { id: systems[nextIndex].id }))
+					return navigate(getPagePath($router, "system", { name: systems[nextIndex].name }))
 				}
 			}
 		}
 		return listen(document, "keyup", handleKeyUp)
-	}, [id, systems])
+	}, [name, systems])
 
 	if (!system.id) {
 		return null
@@ -456,14 +392,13 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 
 	// select field for switching between avg and max values
 	const maxValSelect = isLongerChart ? <SelectAvgMax max={maxValues} /> : null
-	const showMax = maxValues && isLongerChart
-
-	const containerFilterBar = containerData.length ? <FilterBar /> : null
+	const showMax = chartTime !== "1h" && maxValues
 
+	// if no data, show empty message
 	const dataEmpty = !chartLoading && chartData.systemStats.length === 0
 	const lastGpuVals = Object.values(systemStats.at(-1)?.stats.g ?? {})
 	const hasGpuData = lastGpuVals.length > 0
-	const hasGpuPowerData = lastGpuVals.some((gpu) => gpu.p !== undefined || gpu.pp !== undefined)
+	const hasGpuPowerData = lastGpuVals.some((gpu) => gpu.p !== undefined)
 	const hasGpuEnginesData = lastGpuVals.some((gpu) => gpu.e !== undefined)
 
 	let translatedStatus: string = system.status
@@ -507,14 +442,15 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 										</TooltipTrigger>
 										{system.info.ct && (
 											<TooltipContent>
-												<div className="flex gap-1 items-center">
-													{system.info.ct === ConnectionType.WebSocket ? (
-														<WebSocketIcon className="size-4" />
-													) : (
-														<ChevronRightSquareIcon className="size-4" strokeWidth={2} />
-													)}
-													{connectionTypeLabels[system.info.ct as ConnectionType]}
-												</div>
+												{system.info.ct === ConnectionType.WebSocket ? (
+													<div className="flex gap-1 items-center">
+														<WebSocketIcon className="size-4" /> WebSocket
+													</div>
+												) : (
+													<div className="flex gap-1 items-center">
+														<ChevronRightSquareIcon className="size-4" strokeWidth={2} /> SSH
+													</div>
+												)}
 											</TooltipContent>
 										)}
 									</Tooltip>
@@ -548,7 +484,7 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 							</div>
 						</div>
 						<div className="xl:ms-auto flex items-center gap-2 max-sm:-mb-1">
-							<ChartTimeSelect className="w-full xl:w-40" agentVersion={chartData.agentVersion} />
+							<ChartTimeSelect className="w-full xl:w-40" />
 							<TooltipProvider delayDuration={100}>
 								<Tooltip>
 									<TooltipTrigger asChild>
@@ -573,18 +509,6 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 					</div>
 				</Card>
 
-
-				{/* <Tabs defaultValue="overview" className="w-full">
-					<TabsList className="w-full h-11">
-						<TabsTrigger value="overview" className="w-full h-9">Overview</TabsTrigger>
-						<TabsTrigger value="containers" className="w-full h-9">Containers</TabsTrigger>
-						<TabsTrigger value="smart" className="w-full h-9">S.M.A.R.T.</TabsTrigger>
-					</TabsList>
-					<TabsContent value="smart">
-					</TabsContent>
-				</Tabs> */}
-
-
 				{/* main charts */}
 				<div className="grid xl:grid-cols-2 gap-4">
 					<ChartCard
@@ -671,33 +595,23 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 							dataPoints={[
 								{
 									label: t({ message: "Write", comment: "Disk write" }),
-									dataKey: ({ stats }: SystemStatsRecord) => {
-										if (showMax) {
-											return stats?.dio?.[1] ?? (stats?.dwm ?? 0) * 1024 * 1024
-										}
-										return stats?.dio?.[1] ?? (stats?.dw ?? 0) * 1024 * 1024
-									},
+									dataKey: ({ stats }: SystemStatsRecord) => (showMax ? stats?.dwm : stats?.dw),
 									color: 3,
 									opacity: 0.3,
 								},
 								{
 									label: t({ message: "Read", comment: "Disk read" }),
-									dataKey: ({ stats }: SystemStatsRecord) => {
-										if (showMax) {
-											return stats?.diom?.[0] ?? (stats?.drm ?? 0) * 1024 * 1024
-										}
-										return stats?.dio?.[0] ?? (stats?.dr ?? 0) * 1024 * 1024
-									},
+									dataKey: ({ stats }: SystemStatsRecord) => (showMax ? stats?.drm : stats?.dr),
 									color: 1,
 									opacity: 0.3,
 								},
 							]}
 							tickFormatter={(val) => {
-								const { value, unit } = formatBytes(val, true, userSettings.unitDisk, false)
+								const { value, unit } = formatBytes(val, true, userSettings.unitDisk, true)
 								return `${toFixedFloat(value, value >= 10 ? 0 : 1)} ${unit}`
 							}}
 							contentFormatter={({ value }) => {
-								const { value: convertedValue, unit } = formatBytes(value, true, userSettings.unitDisk, false)
+								const { value: convertedValue, unit } = formatBytes(value, true, userSettings.unitDisk, true)
 								return `${decimalString(convertedValue, convertedValue >= 100 ? 1 : 2)} ${unit}`
 							}}
 						/>
@@ -757,20 +671,26 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 					</ChartCard>
 
 					{containerFilterBar && containerData.length > 0 && (
-						<ChartCard
-							empty={dataEmpty}
-							grid={grid}
-							title={dockerOrPodman(t`Docker Network I/O`, system)}
-							description={dockerOrPodman(t`Network traffic of docker containers`, system)}
-							cornerEl={containerFilterBar}
+						<div
+							ref={netCardRef}
+							className={cn({
+								"col-span-full": !grid,
+							})}
 						>
-							<ContainerChart
-								chartData={chartData}
-								chartType={ChartType.Network}
-								dataKey="n"
-								chartConfig={containerChartConfigs.network}
-							/>
-						</ChartCard>
+							<ChartCard
+								empty={dataEmpty}
+								title={dockerOrPodman(t`Docker Network I/O`, system)}
+								description={dockerOrPodman(t`Network traffic of docker containers`, system)}
+								cornerEl={containerFilterBar}
+							>
+								<ContainerChart
+									chartData={chartData}
+									chartType={ChartType.Network}
+									dataKey="n"
+									chartConfig={containerChartConfigs.network}
+								/>
+							</ChartCard>
+						</div>
 					)}
 
 					{/* Swap chart */}
@@ -800,21 +720,16 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 
 					{/* Temperature chart */}
 					{systemStats.at(-1)?.stats.t && (
-						<div
-							ref={temperatureChartRef}
-							className={cn("odd:last-of-type:col-span-full", { "col-span-full": !grid })}
+						<ChartCard
+							empty={dataEmpty}
+							grid={grid}
+							title={t`Temperature`}
+							description={t`Temperatures of system sensors`}
+							cornerEl={<FilterBar store={$temperatureFilter} />}
+							legend={Object.keys(systemStats.at(-1)?.stats.t ?? {}).length < 12}
 						>
-							<ChartCard
-								empty={dataEmpty}
-								grid={grid}
-								title={t`Temperature`}
-								description={t`Temperatures of system sensors`}
-								cornerEl={<FilterBar store={$temperatureFilter} />}
-								legend={Object.keys(systemStats.at(-1)?.stats.t ?? {}).length < 12}
-							>
-								<TemperatureChart chartData={chartData} />
-							</ChartCard>
-						</div>
+							<TemperatureChart chartData={chartData} />
+						</ChartCard>
 					)}
 
 					{/* Battery chart */}
@@ -845,6 +760,13 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 							/>
 						</ChartCard>
 					)}
+
+
+				</div>
+
+				{/* Non-power GPU charts */}
+				{hasGpuData && (
+					<div className="grid xl:grid-cols-2 gap-4">
 					{/* GPU power draw chart */}
 					{hasGpuPowerData && (
 						<ChartCard
@@ -856,14 +778,8 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 							<GpuPowerChart chartData={chartData} />
 						</ChartCard>
 					)}
-				</div>
-
-				{/* Non-power GPU charts */}
-				{hasGpuData && (
-					<div className="grid xl:grid-cols-2 gap-4">
 						{hasGpuEnginesData && (
 							<ChartCard
-								legend={true}
 								empty={dataEmpty}
 								grid={grid}
 								title={t`GPU Engines`}
@@ -877,7 +793,6 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 							return (
 								<div key={id} className="contents">
 									<ChartCard
-										className={cn(grid && "!col-span-1")}
 										empty={dataEmpty}
 										grid={grid}
 										title={`${gpu.n} ${t`Usage`}`}
@@ -899,35 +814,36 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 									</ChartCard>
 
 									{(gpu.mt ?? 0) > 0 && (
-										<ChartCard
-											empty={dataEmpty}
-											grid={grid}
-											title={`${gpu.n} VRAM`}
-											description={t`Precise utilization at the recorded time`}
-										>
-											<AreaChartDefault
-												chartData={chartData}
-												dataPoints={[
-													{
-														label: t`Usage`,
-														dataKey: ({ stats }) => stats?.g?.[id]?.mu ?? 0,
-														color: 2,
-														opacity: 0.25,
-													},
-												]}
-												max={gpu.mt}
-												tickFormatter={(val) => {
-													const { value, unit } = formatBytes(val, false, Unit.Bytes, true)
-													return `${toFixedFloat(value, value >= 10 ? 0 : 1)} ${unit}`
-												}}
-												contentFormatter={({ value }) => {
-													const { value: convertedValue, unit } = formatBytes(value, false, Unit.Bytes, true)
-													return `${decimalString(convertedValue)} ${unit}`
-												}}
-											/>
-										</ChartCard>
-									)}
+									<ChartCard
+										empty={dataEmpty}
+										grid={grid}
+										title={`${gpu.n} VRAM`}
+										description={t`Precise utilization at the recorded time`}
+									>
+										<AreaChartDefault
+											chartData={chartData}
+											dataPoints={[
+												{
+													label: t`Usage`,
+													dataKey: ({ stats }) => stats?.g?.[id]?.mu ?? 0,
+													color: 2,
+													opacity: 0.25,
+												},
+											]}
+											max={gpu.mt}
+											tickFormatter={(val) => {
+												const { value, unit } = formatBytes(val, false, Unit.Bytes, true)
+												return `${toFixedFloat(value, value >= 10 ? 0 : 1)} ${unit}`
+											}}
+											contentFormatter={({ value }) => {
+												const { value: convertedValue, unit } = formatBytes(value, false, Unit.Bytes, true)
+												return `${decimalString(convertedValue)} ${unit}`
+											}}
+										/>
+									</ChartCard>
+						)}
 								</div>
+
 							)
 						})}
 					</div>
@@ -947,7 +863,7 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 									>
 										<DiskChart
 											chartData={chartData}
-											dataKey={({ stats }: SystemStatsRecord) => stats?.efs?.[extraFsName]?.du}
+											dataKey={`stats.efs.${extraFsName}.du`}
 											diskSize={systemStats.at(-1)?.stats.efs?.[extraFsName].d ?? NaN}
 										/>
 									</ChartCard>
@@ -963,36 +879,24 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 											dataPoints={[
 												{
 													label: t`Write`,
-													dataKey: ({ stats }) => {
-														if (showMax) {
-															return stats?.efs?.[extraFsName]?.wb ?? (stats?.efs?.[extraFsName]?.wm ?? 0) * 1024 * 1024
-														}
-														return stats?.efs?.[extraFsName]?.wb ?? (stats?.efs?.[extraFsName]?.w ?? 0) * 1024 * 1024
-													},
+													dataKey: ({ stats }) => stats?.efs?.[extraFsName]?.[showMax ? "wm" : "w"] ?? 0,
 													color: 3,
 													opacity: 0.3,
 												},
 												{
 													label: t`Read`,
-													dataKey: ({ stats }) => {
-														if (showMax) {
-															return (
-																stats?.efs?.[extraFsName]?.rbm ?? (stats?.efs?.[extraFsName]?.rm ?? 0) * 1024 * 1024
-															)
-														}
-														return stats?.efs?.[extraFsName]?.rb ?? (stats?.efs?.[extraFsName]?.r ?? 0) * 1024 * 1024
-													},
+													dataKey: ({ stats }) => stats?.efs?.[extraFsName]?.[showMax ? "rm" : "r"] ?? 0,
 													color: 1,
 													opacity: 0.3,
 												},
 											]}
 											maxToggled={maxValues}
 											tickFormatter={(val) => {
-												const { value, unit } = formatBytes(val, true, userSettings.unitDisk, false)
+												const { value, unit } = formatBytes(val, true, userSettings.unitDisk, true)
 												return `${toFixedFloat(value, value >= 10 ? 0 : 1)} ${unit}`
 											}}
 											contentFormatter={({ value }) => {
-												const { value: convertedValue, unit } = formatBytes(value, true, userSettings.unitDisk, false)
+												const { value: convertedValue, unit } = formatBytes(value, true, userSettings.unitDisk, true)
 												return `${decimalString(convertedValue, convertedValue >= 100 ? 1 : 2)} ${unit}`
 											}}
 										/>
@@ -1002,13 +906,6 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 						})}
 					</div>
 				)}
-
-
-				{containerData.length > 0 && compareSemVer(chartData.agentVersion, parseSemVer("0.14.0")) >= 0 && (
-					<LazyContainersTable systemId={id} />
-				)}
-
-				<LazySmartTable systemId={system.id} />
 			</div>
 
 			{/* add space for tooltip if more than 12 containers */}
@@ -1018,46 +915,42 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 })
 
 function GpuEnginesChart({ chartData }: { chartData: ChartData }) {
-	const dataPoints: DataPoint[] = []
+	const dataPoints = []
 	const engines = Object.keys(chartData.systemStats?.at(-1)?.stats.g?.[0]?.e ?? {}).sort()
 	for (const engine of engines) {
 		dataPoints.push({
 			label: engine,
 			dataKey: ({ stats }: SystemStatsRecord) => stats?.g?.[0]?.e?.[engine] ?? 0,
-			color: `hsl(${140 + (((engines.indexOf(engine) * 360) / engines.length) % 360)}, 65%, 52%)`,
+			color: `hsl(${140 + ((engines.indexOf(engine) * 360) / engines.length) % 360}, 65%, 52%)`,
 			opacity: 0.35,
 		})
 	}
 	return (
-		<LineChartDefault
-			legend={true}
-			chartData={chartData}
-			dataPoints={dataPoints}
-			tickFormatter={(val) => `${toFixedFloat(val, 2)}%`}
-			contentFormatter={({ value }) => `${decimalString(value)}%`}
-		/>
+		<LineChartDefault legend={true} chartData={chartData} dataPoints={dataPoints} tickFormatter={(val) => `${toFixedFloat(val, 2)}%`} contentFormatter={({ value }) => `${decimalString(value)}%`} />
 	)
 }
 
 function FilterBar({ store = $containerFilter }: { store?: typeof $containerFilter }) {
 	const containerFilter = useStore(store)
 	const { t } = useLingui()
+	const inputRef = useRef<HTMLInputElement>(null)
 
-	const debouncedStoreSet = useMemo(() => debounce((value: string) => store.set(value), 80), [store])
+	const debouncedStoreSet = useMemo(() => debounce((value: string) => store.set(value), 150), [store])
 
 	const handleChange = useCallback(
-		(e: React.ChangeEvent<HTMLInputElement>) => debouncedStoreSet(e.target.value),
+		(e: React.ChangeEvent<HTMLInputElement>) => {
+			const value = e.target.value
+			if (inputRef.current) {
+				inputRef.current.value = value
+			}
+			debouncedStoreSet(value)
+		},
 		[debouncedStoreSet]
 	)
 
 	return (
 		<>
-			<Input
-				placeholder={t`Filter...`}
-				className="ps-4 pe-8 w-full sm:w-44"
-				onChange={handleChange}
-				value={containerFilter}
-			/>
+			<Input placeholder={t`Filter...`} className="ps-4 pe-8 w-full sm:w-44" onChange={handleChange} ref={inputRef} />
 			{containerFilter && (
 				<Button
 					type="button"
@@ -1065,7 +958,12 @@ function FilterBar({ store = $containerFilter }: { store?: typeof $containerFilt
 					size="icon"
 					aria-label="Clear"
 					className="absolute right-1 top-1/2 -translate-y-1/2 h-7 w-7 text-gray-500 hover:text-gray-900 dark:text-gray-400 dark:hover:text-gray-100"
-					onClick={() => store.set("")}
+					onClick={() => {
+						if (inputRef.current) {
+							inputRef.current.value = ""
+						}
+						store.set("")
+					}}
 				>
 					<XIcon className="h-4 w-4" />
 				</Button>
@@ -1138,25 +1036,3 @@ export function ChartCard({
 		</Card>
 	)
 }
-
-const ContainersTable = lazy(() => import("../containers-table/containers-table"))
-
-function LazyContainersTable({ systemId }: { systemId: string }) {
-	const { isIntersecting, ref } = useIntersectionObserver({ rootMargin: "90px" })
-	return (
-		<div ref={ref}>
-			{isIntersecting && <ContainersTable systemId={systemId} />}
-		</div>
-	)
-}
-
-const SmartTable = lazy(() => import("./system/smart-table"))
-
-function LazySmartTable({ systemId }: { systemId: string }) {
-	const { isIntersecting, ref } = useIntersectionObserver()
-	return (
-		<div ref={ref}>
-			{isIntersecting && <SmartTable systemId={systemId} />}
-		</div>
-	)
-}

internal/site/src/components/routes/system/network-sheet.tsx

@@ -7,7 +7,6 @@ import ChartTimeSelect from "@/components/charts/chart-time-select"
 import { useNetworkInterfaces } from "@/components/charts/hooks"
 import { Button } from "@/components/ui/button"
 import { Sheet, SheetContent, SheetTrigger } from "@/components/ui/sheet"
-import { DialogTitle } from "@/components/ui/dialog"
 import { $userSettings } from "@/lib/stores"
 import { decimalString, formatBytes, toFixedFloat } from "@/lib/utils"
 import type { ChartData } from "@/types"
@@ -27,7 +26,7 @@ export default memo(function NetworkSheet({
 	const [netInterfacesOpen, setNetInterfacesOpen] = useState(false)
 	const userSettings = useStore($userSettings)
 	const netInterfaces = useNetworkInterfaces(chartData.systemStats.at(-1)?.stats?.ni ?? {})
-	const showNetLegend = netInterfaces.length > 0 && netInterfaces.length < 15
+	const showNetLegend = netInterfaces.length > 0
 	const hasOpened = useRef(false)
 
 	if (netInterfacesOpen && !hasOpened.current) {
@@ -40,10 +39,9 @@ export default memo(function NetworkSheet({
 
 	return (
 		<Sheet open={netInterfacesOpen} onOpenChange={setNetInterfacesOpen}>
-			<DialogTitle className="sr-only">{t`Network traffic of public interfaces`}</DialogTitle>
 			<SheetTrigger asChild>
 				<Button
-					title={t`View more`}
+					aria-label={t`View more`}
 					variant="outline"
 					size="icon"
 					className="shrink-0 max-sm:absolute max-sm:top-3 max-sm:end-3"
@@ -52,8 +50,8 @@ export default memo(function NetworkSheet({
 				</Button>
 			</SheetTrigger>
 			{hasOpened.current && (
-				<SheetContent aria-describedby={undefined} className="overflow-auto w-200 !max-w-full p-4 sm:p-6">
-					<ChartTimeSelect className="w-[calc(100%-2em)]" agentVersion={chartData.agentVersion} />
+				<SheetContent className="overflow-auto w-200 !max-w-full p-4 sm:p-6">
+					<ChartTimeSelect className="w-[calc(100%-2em)]" />
 					<ChartCard
 						empty={dataEmpty}
 						grid={grid}

internal/site/src/components/routes/system/smart-table.tsx

@@ -1,486 +0,0 @@
-import * as React from "react"
-import { t } from "@lingui/core/macro"
-import {
-   ColumnDef,
-   ColumnFiltersState,
-   flexRender,
-   getCoreRowModel,
-   getFilteredRowModel,
-   getSortedRowModel,
-   SortingState,
-   useReactTable,
-} from "@tanstack/react-table"
-import { Activity, Box, Clock, HardDrive, HashIcon, CpuIcon, BinaryIcon, RotateCwIcon, LoaderCircleIcon, CheckCircle2Icon, XCircleIcon, ArrowLeftRightIcon } from "lucide-react"
-import { Card, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"
-import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "@/components/ui/sheet"
-import { Input } from "@/components/ui/input"
-import {
-   Table,
-   TableBody,
-   TableCell,
-   TableHead,
-   TableHeader,
-   TableRow,
-} from "@/components/ui/table"
-import { Badge } from "@/components/ui/badge"
-import { pb } from "@/lib/api"
-import { SmartData, SmartAttribute } from "@/types"
-import { formatBytes, toFixedFloat, formatTemperature } from "@/lib/utils"
-import { Trans } from "@lingui/react/macro"
-import { ThermometerIcon } from "@/components/ui/icons"
-import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
-import { Separator } from "@/components/ui/separator"
-
-// Column definition for S.M.A.R.T. attributes table
-export const smartColumns: ColumnDef<SmartAttribute>[] = [
-   {
-      accessorKey: "id",
-      header: "ID",
-   },
-   {
-      accessorFn: (row) => row.n,
-      header: "Name",
-   },
-   {
-      accessorFn: (row) => row.rs || row.rv?.toString(),
-      header: "Value",
-   },
-   {
-      accessorKey: "v",
-      header: "Normalized",
-   },
-   {
-      accessorKey: "w",
-      header: "Worst",
-   },
-   {
-      accessorKey: "t",
-      header: "Threshold",
-   },
-   {
-      // accessorFn: (row) => row.wf,
-      accessorKey: "wf",
-      header: "Failing",
-   },
-]
-
-
-
-export type DiskInfo = {
-   device: string
-   model: string
-   serialNumber: string
-   firmwareVersion: string
-   capacity: string
-   status: string
-   temperature: number
-   deviceType: string
-   powerOnHours?: number
-   powerCycles?: number
-}
-
-// Function to format capacity display
-function formatCapacity(bytes: number): string {
-   const { value, unit } = formatBytes(bytes)
-   return `${toFixedFloat(value, value >= 10 ? 1 : 2)} ${unit}`
-}
-
-// Function to convert SmartData to DiskInfo
-function convertSmartDataToDiskInfo(smartDataRecord: Record<string, SmartData>): DiskInfo[] {
-   return Object.entries(smartDataRecord).map(([key, smartData]) => ({
-      device: smartData.dn || key,
-      model: smartData.mn || "Unknown",
-      serialNumber: smartData.sn || "Unknown",
-      firmwareVersion: smartData.fv || "Unknown",
-      capacity: smartData.c ? formatCapacity(smartData.c) : "Unknown",
-      status: smartData.s || "Unknown",
-      temperature: smartData.t || 0,
-      deviceType: smartData.dt || "Unknown",
-      // These fields need to be extracted from SmartAttribute if available
-      powerOnHours: smartData.a?.find(attr => attr.n.toLowerCase().includes("poweronhours") || attr.n.toLowerCase().includes("power_on_hours"))?.rv,
-      powerCycles: smartData.a?.find(attr => attr.n.toLowerCase().includes("power") && attr.n.toLowerCase().includes("cycle"))?.rv,
-   }))
-}
-
-
-export const columns: ColumnDef<DiskInfo>[] = [
-   {
-      accessorKey: "device",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <HardDrive className="size-4" />
-            <Trans>Device</Trans>
-         </div>
-      ),
-      cell: ({ row }) => (
-         <div className="font-medium">{row.getValue("device")}</div>
-      ),
-   },
-   {
-      accessorKey: "model",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <Box className="size-4" />
-            <Trans>Model</Trans>
-         </div>
-      ),
-      cell: ({ row }) => (
-         <div className="max-w-50 truncate" title={row.getValue("model")}>
-            {row.getValue("model")}
-         </div>
-      ),
-   },
-   {
-      accessorKey: "capacity",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <BinaryIcon className="size-4" />
-            <Trans>Capacity</Trans>
-         </div>
-      ),
-   },
-   {
-      accessorKey: "temperature",
-      header: () => (
-         <div className="flex items-center gap-2">
-            <ThermometerIcon className="size-4" />
-            <Trans>Temp</Trans>
-         </div>
-      ),
-      cell: ({ getValue }) => {
-         const { value, unit } = formatTemperature(getValue() as number)
-         return `${value} ${unit}`
-      },
-   },
-   {
-      accessorKey: "status",
-      header: () => (
-         <div className="flex items-center gap-2">
-            <Activity className="size-4" />
-            <Trans>Status</Trans>
-         </div>
-      ),
-      cell: ({ getValue }) => {
-         const status = getValue() as string
-         return (
-            <Badge
-               variant={status === "PASSED" ? "success" : status === "FAILED" ? "danger" : "warning"}
-            >
-               {status}
-            </Badge>
-         )
-      },
-   },
-   {
-      accessorKey: "deviceType",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <ArrowLeftRightIcon className="size-4" />
-            <Trans>Type</Trans>
-         </div>
-      ),
-      cell: ({ getValue }) => (
-         <Badge variant="outline" className="uppercase">
-            {getValue() as string}
-         </Badge>
-      ),
-   },
-   {
-      accessorKey: "powerOnHours",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <Clock className="size-4" />
-            <Trans comment="Power On Time">Power On</Trans>
-         </div>
-      ),
-      cell: ({ row }) => {
-         const hours = row.getValue("powerOnHours") as number | undefined
-         if (!hours && hours !== 0) {
-            return (
-               <div className="text-sm text-muted-foreground">
-                  N/A
-               </div>
-            )
-         }
-         const days = Math.floor(hours / 24)
-         return (
-            <div className="text-sm">
-               <div>{hours.toLocaleString()} hours</div>
-               <div className="text-muted-foreground text-xs">{days} days</div>
-            </div>
-         )
-      },
-   },
-   {
-      accessorKey: "powerCycles",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <RotateCwIcon className="size-4" />
-            <Trans comment="Power Cycles">Cycles</Trans>
-         </div>
-      ),
-      cell: ({ getValue }) => {
-         const cycles = getValue() as number | undefined
-         if (!cycles && cycles !== 0) {
-            return (
-               <div className="text-muted-foreground">
-                  N/A
-               </div>
-            )
-         }
-         return cycles
-      },
-   },
-   {
-      accessorKey: "serialNumber",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <HashIcon className="size-4" />
-            <Trans>Serial Number</Trans>
-         </div>
-      ),
-   },
-   {
-      accessorKey: "firmwareVersion",
-      header: () => (
-         <div className="flex items-center gap-1.5">
-            <CpuIcon className="size-4" />
-            <Trans>Firmware</Trans>
-         </div>
-      ),
-   },
-]
-
-export default function DisksTable({ systemId }: { systemId: string }) {
-   const [sorting, setSorting] = React.useState<SortingState>([{ id: "device", desc: false }])
-   const [columnFilters, setColumnFilters] = React.useState<ColumnFiltersState>([])
-   const [rowSelection, setRowSelection] = React.useState({})
-   const [smartData, setSmartData] = React.useState<Record<string, SmartData> | undefined>(undefined)
-   const [activeDisk, setActiveDisk] = React.useState<DiskInfo | null>(null)
-   const [sheetOpen, setSheetOpen] = React.useState(false)
-
-   const openSheet = (disk: DiskInfo) => {
-      setActiveDisk(disk)
-      setSheetOpen(true)
-   }
-
-   // Fetch smart data when component mounts or systemId changes
-   React.useEffect(() => {
-      if (systemId) {
-         pb.send<Record<string, SmartData>>("/api/beszel/smart", { query: { system: systemId } })
-            .then((data) => {
-               setSmartData(data)
-            })
-            .catch(() => setSmartData({}))
-      }
-   }, [systemId])
-
-   // Convert SmartData to DiskInfo, if no data use empty array
-   const diskData = React.useMemo(() => {
-      return smartData ? convertSmartDataToDiskInfo(smartData) : []
-   }, [smartData])
-
-
-   const table = useReactTable({
-      data: diskData,
-      columns: columns,
-      onSortingChange: setSorting,
-      onColumnFiltersChange: setColumnFilters,
-      getCoreRowModel: getCoreRowModel(),
-      getSortedRowModel: getSortedRowModel(),
-      getFilteredRowModel: getFilteredRowModel(),
-      onRowSelectionChange: setRowSelection,
-      state: {
-         sorting,
-         columnFilters,
-         rowSelection,
-      },
-   })
-
-   return (
-      <div>
-         <Card className="p-6 @container w-full">
-            <CardHeader className="p-0 mb-4">
-               <div className="grid md:flex gap-5 w-full items-end">
-                  <div className="px-2 sm:px-1">
-                     <CardTitle className="mb-2">
-                        S.M.A.R.T.
-                     </CardTitle>
-                     <CardDescription className="flex">
-                        <Trans>Click on a device to view more information.</Trans>
-                     </CardDescription>
-                  </div>
-                  <Input
-                     placeholder={t`Filter...`}
-                     value={(table.getColumn("device")?.getFilterValue() as string) ?? ""}
-                     onChange={(event) =>
-                        table.getColumn("device")?.setFilterValue(event.target.value)
-                     }
-                     className="ms-auto px-4 w-full max-w-full md:w-64"
-                  />
-               </div>
-            </CardHeader>
-            <div className="rounded-md border text-nowrap">
-               <Table>
-                  <TableHeader>
-                     {table.getHeaderGroups().map((headerGroup) => (
-                        <TableRow key={headerGroup.id}>
-                           {headerGroup.headers.map((header) => {
-                              return (
-                                 <TableHead key={header.id}>
-                                    {header.isPlaceholder
-                                       ? null
-                                       : flexRender(
-                                          header.column.columnDef.header,
-                                          header.getContext()
-                                       )}
-                                 </TableHead>
-                              )
-                           })}
-                        </TableRow>
-                     ))}
-                  </TableHeader>
-                  <TableBody>
-                     {table.getRowModel().rows?.length ? (
-                        table.getRowModel().rows.map((row) => (
-                           <TableRow
-                              key={row.id}
-                              data-state={row.getIsSelected() && "selected"}
-                              className="cursor-pointer"
-                              onClick={() => openSheet(row.original)}
-                           >
-                              {row.getVisibleCells().map((cell) => (
-                                 <TableCell key={cell.id}>
-                                    {flexRender(
-                                       cell.column.columnDef.cell,
-                                       cell.getContext()
-                                    )}
-                                 </TableCell>
-                              ))}
-                           </TableRow>
-                        ))
-                     ) : (
-                        <TableRow>
-                           <TableCell
-                              colSpan={columns.length}
-                              className="h-24 text-center"
-                           >
-                              {smartData ? t`No results.` : <LoaderCircleIcon className="animate-spin size-10 opacity-60 mx-auto" />}
-
-                           </TableCell>
-                        </TableRow>
-                     )}
-                  </TableBody>
-               </Table>
-            </div>
-         </Card>
-         <DiskSheet disk={activeDisk} smartData={activeDisk && smartData ? Object.values(smartData).find(sd => sd.dn === activeDisk.device || sd.mn === activeDisk.model) : undefined} open={sheetOpen} onOpenChange={setSheetOpen} />
-      </div>
-   )
-}
-
-function DiskSheet({ disk, smartData, open, onOpenChange }: { disk: DiskInfo | null; smartData?: SmartData; open: boolean; onOpenChange: (open: boolean) => void }) {
-   if (!disk) return null
-
-   const smartAttributes = smartData?.a || []
-
-   // Find all attributes where when failed is not empty
-   const failedAttributes = smartAttributes.filter(attr => attr.wf && attr.wf.trim() !== '')
-
-   // Filter columns to only show those that have values in at least one row
-   const visibleColumns = React.useMemo(() => {
-      return smartColumns.filter(column => {
-         const accessorKey = (column as any).accessorKey as keyof SmartAttribute
-         if (!accessorKey) {
-            return true
-         }
-         // Check if any row has a non-empty value for this column
-         return smartAttributes.some(attr => {
-            return attr[accessorKey] !== undefined
-         })
-      })
-   }, [smartAttributes])
-
-   const table = useReactTable({
-      data: smartAttributes,
-      columns: visibleColumns,
-      getCoreRowModel: getCoreRowModel(),
-   })
-
-   return (
-      <Sheet open={open} onOpenChange={onOpenChange}>
-         <SheetContent className="w-full sm:max-w-220 gap-0">
-            <SheetHeader className="mb-0 border-b">
-               <SheetTitle><Trans>S.M.A.R.T. Details</Trans> - {disk.device}</SheetTitle>
-               <SheetDescription className="flex flex-wrap items-center gap-x-2 gap-y-1">
-                  {disk.model} <Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-                  {disk.serialNumber}
-               </SheetDescription>
-            </SheetHeader>
-            <div className="flex-1 overflow-auto p-4 flex flex-col gap-4">
-               <Alert className="pb-3">
-                  {smartData?.s === "PASSED" ? (
-                     <CheckCircle2Icon className="size-4" />
-                  ) : (
-                     <XCircleIcon className="size-4" />
-                  )}
-                  <AlertTitle><Trans>S.M.A.R.T. Self-Test</Trans>: {smartData?.s}</AlertTitle>
-                  {failedAttributes.length > 0 && (
-                     <AlertDescription>
-                        <Trans>Failed Attributes:</Trans> {failedAttributes.map(attr => attr.n).join(", ")}
-                     </AlertDescription>
-                  )}
-               </Alert>
-               {smartAttributes.length > 0 ? (
-                  <div className="rounded-md border overflow-auto">
-                     <Table>
-                        <TableHeader>
-                           {table.getHeaderGroups().map((headerGroup) => (
-                              <TableRow key={headerGroup.id}>
-                                 {headerGroup.headers.map((header) => (
-                                    <TableHead key={header.id}>
-                                       {header.isPlaceholder
-                                          ? null
-                                          : flexRender(
-                                             header.column.columnDef.header,
-                                             header.getContext()
-                                          )}
-                                    </TableHead>
-                                 ))}
-                              </TableRow>
-                           ))}
-                        </TableHeader>
-                        <TableBody>
-                           {table.getRowModel().rows.map((row) => {
-                              // Check if the attribute is failed
-                              const isFailedAttribute = row.original.wf && row.original.wf.trim() !== '';
-
-                              return (
-                                 <TableRow
-                                    key={row.id}
-                                    className={isFailedAttribute ? "text-red-600 dark:text-red-400" : ""}
-                                 >
-                                    {row.getVisibleCells().map((cell) => (
-                                       <TableCell key={cell.id}>
-                                          {flexRender(
-                                             cell.column.columnDef.cell,
-                                             cell.getContext()
-                                          )}
-                                       </TableCell>
-                                    ))}
-                                 </TableRow>
-                              );
-                           })}
-                        </TableBody>
-                     </Table>
-                  </div>
-               ) : (
-                  <div className="text-center py-8 text-muted-foreground">
-                     <Trans>No S.M.A.R.T. attributes available for this device.</Trans>
-                  </div>
-               )}
-            </div>
-         </SheetContent>
-      </Sheet>
-   )
-} 

internal/site/src/components/systems-table/systems-table-columns.tsx

@@ -21,7 +21,7 @@ import {
 } from "lucide-react"
 import { memo, useMemo, useRef, useState } from "react"
 import { isReadOnlyUser, pb } from "@/lib/api"
-import { ConnectionType, connectionTypeLabels, MeterState, SystemStatus } from "@/lib/enums"
+import { ConnectionType, MeterState, SystemStatus } from "@/lib/enums"
 import { $longestSystemNameLen, $userSettings } from "@/lib/stores"
 import {
 	cn,
@@ -77,7 +77,6 @@ export default function SystemsTableColumns(viewMode: "table" | "grid"): ColumnD
 			accessorKey: "name",
 			id: "system",
 			name: () => t`System`,
-			sortingFn: (a, b) => a.original.name.localeCompare(b.original.name),
 			filterFn: (() => {
 				let filterInput = ""
 				let filterInputLower = ""
@@ -111,7 +110,7 @@ export default function SystemsTableColumns(viewMode: "table" | "grid"): ColumnD
 			invertSorting: false,
 			Icon: ServerIcon,
 			cell: (info) => {
-				const { name, id } = info.row.original
+				const { name } = info.row.original
 				const longestName = useStore($longestSystemNameLen)
 				return (
 					<>
@@ -123,7 +122,7 @@ export default function SystemsTableColumns(viewMode: "table" | "grid"): ColumnD
 							</span>
 						</span>
 						<Link
-							href={getPagePath($router, "system", { id })}
+							href={getPagePath($router, "system", { name })}
 							className="inset-0 absolute size-full"
 							aria-label={name}
 						></Link>
@@ -279,25 +278,12 @@ export default function SystemsTableColumns(viewMode: "table" | "grid"): ColumnD
 					"text-red-500": system.status !== SystemStatus.Up,
 				}
 				return (
-					<Link
-						href={getPagePath($router, "system", { id: system.id })}
-						className={cn(
-							"flex gap-1.5 items-center md:pe-5 tabular-nums relative z-10",
-							viewMode === "table" && "ps-0.5"
-						)}
-						tabIndex={-1}
-						title={connectionTypeLabels[system.info.ct as ConnectionType]}
-						role="none"
-					>
-						{system.info.ct === ConnectionType.WebSocket && (
-							<WebSocketIcon className={cn("size-3 pointer-events-none", color)} />
-						)}
-						{system.info.ct === ConnectionType.SSH && (
-							<ChevronRightSquareIcon className={cn("size-3 pointer-events-none", color)} />
-						)}
+					<div className={cn("flex gap-1.5 items-center md:pe-5 tabular-nums", viewMode === "table" && "ps-0.5")}>
+						{system.info.ct === ConnectionType.WebSocket && <WebSocketIcon className={cn("size-3", color)} />}
+						{system.info.ct === ConnectionType.SSH && <ChevronRightSquareIcon className={cn("size-3", color)} />}
 						{!system.info.ct && <IndicatorDot system={system} className={cn(color, "bg-current mx-0.5")} />}
 						<span className="truncate max-w-14">{info.getValue() as string}</span>
-					</Link>
+					</div>
 				)
 			},
 		},

internal/site/src/components/systems-table/systems-table.tsx

@@ -131,6 +131,7 @@ export default function SystemsTable() {
 		return [Object.values(upSystems).length, Object.values(downSystems).length, Object.values(pausedSystems).length]
 	}, [upSystems, downSystems, pausedSystems])
 
+	// TODO: hiding temp then gpu messes up table headers
 	const CardHead = useMemo(() => {
 		return (
 			<CardHeader className="pb-4.5 px-2 sm:px-6 max-sm:pt-5 max-sm:pb-1">
@@ -369,7 +370,7 @@ const AllSystemsTable = memo(
 function SystemsTableHead({ table }: { table: TableType<SystemRecord> }) {
 	const { t } = useLingui()
 	return (
-		<TableHeader className="sticky top-0 z-50 w-full border-b-2">
+		<TableHeader className="sticky top-0 z-20 w-full border-b-2">
 			{table.getHeaderGroups().map((headerGroup) => (
 				<tr key={headerGroup.id}>
 					{headerGroup.headers.map((header) => {
@@ -486,7 +487,7 @@ const SystemCard = memo(
 						</div>
 					</CardContent>
 					<Link
-						href={getPagePath($router, "system", { id: row.original.id })}
+						href={getPagePath($router, "system", { name: row.original.name })}
 						className="inset-0 absolute w-full h-full"
 					>
 						<span className="sr-only">{row.original.name}</span>

internal/site/src/components/ui/badge.tsx

@@ -12,9 +12,6 @@ const badgeVariants = cva(
 				secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
 				destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
 				outline: "text-foreground",
-				success: "border-transparent bg-green-200 text-green-800",
-				danger: "border-transparent bg-red-200 text-red-800",
-				warning: "border-transparent bg-yellow-200 text-yellow-800",
 			},
 		},
 		defaultVariants: {
@@ -23,7 +20,7 @@ const badgeVariants = cva(
 	}
 )
 
-export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> { }
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {}
 
 function Badge({ className, variant, ...props }: BadgeProps) {
 	return <div className={cn(badgeVariants({ variant }), className)} {...props} />

internal/site/src/components/ui/chart.tsx

@@ -91,16 +91,16 @@ const ChartTooltip = RechartsPrimitive.Tooltip
 const ChartTooltipContent = React.forwardRef<
 	HTMLDivElement,
 	React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
-	React.ComponentProps<"div"> & {
-		hideLabel?: boolean
-		indicator?: "line" | "dot" | "dashed"
-		nameKey?: string
-		labelKey?: string
-		unit?: string
-		filter?: string
-		contentFormatter?: (item: any, key: string) => React.ReactNode | string
-		truncate?: boolean
-	}
+		React.ComponentProps<"div"> & {
+			hideLabel?: boolean
+			indicator?: "line" | "dot" | "dashed"
+			nameKey?: string
+			labelKey?: string
+			unit?: string
+			filter?: string
+			contentFormatter?: (item: any, key: string) => React.ReactNode | string
+			truncate?: boolean
+		}
 >(
 	(
 		{
@@ -129,11 +129,7 @@ const ChartTooltipContent = React.forwardRef<
 
 		React.useMemo(() => {
 			if (filter) {
-				const filterTerms = filter.toLowerCase().split(" ").filter(term => term.length > 0)
-				payload = payload?.filter((item) => {
-					const itemName = (item.name as string)?.toLowerCase()
-					return filterTerms.some(term => itemName?.includes(term))
-				})
+				payload = payload?.filter((item) => (item.name as string)?.toLowerCase().includes(filter.toLowerCase()))
 			}
 			if (itemSorter) {
 				// @ts-expect-error
@@ -254,10 +250,10 @@ const ChartLegend = RechartsPrimitive.Legend
 const ChartLegendContent = React.forwardRef<
 	HTMLDivElement,
 	React.ComponentProps<"div"> &
-	Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
-		hideIcon?: boolean
-		nameKey?: string
-	}
+		Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+			hideIcon?: boolean
+			nameKey?: string
+		}
 >(({ className, payload, verticalAlign = "bottom" }, ref) => {
 	// const { config } = useChart()
 

internal/site/src/index.css

@@ -82,8 +82,6 @@
 	--color-green-900: hsl(140 54% 12%);
 	--color-green-950: hsl(140 57% 6%);
 
-	--color-gh-dark: #22272e;
-
 	--color-background: var(--background);
 	--color-foreground: var(--foreground);
 	--color-card: var(--card);
@@ -112,14 +110,12 @@
 }
 
 @layer utilities {
-
 	/* Fonts */
 	@supports (font-variation-settings: normal) {
 		:root {
 			font-family: Inter, InterVariable, sans-serif;
 		}
 	}
-
 	@font-face {
 		font-family: InterVariable;
 		font-style: normal;
@@ -134,18 +130,16 @@
 		@apply border-border outline-ring/50;
 		overflow-anchor: none;
 	}
-
 	body {
 		@apply bg-background text-foreground;
 	}
-
 	button {
 		cursor: pointer;
 	}
 }
 
 @utility container {
-	@apply max-w-370 mx-auto px-4;
+	@apply max-w-360 mx-auto px-4;
 }
 
 @utility link {
@@ -155,17 +149,16 @@
 @utility ns-dialog {
 	/* New system dialog width */
 	min-width: 30.3rem;
-
 	:where(:lang(zh), :lang(zh-CN), :lang(ko)) & {
 		min-width: 27.9rem;
 	}
 }
 
 .recharts-tooltip-wrapper {
-	z-index: 51;
+	z-index: 1;
 	@apply tabular-nums;
 }
 
 .recharts-yAxis {
 	@apply tabular-nums;
-}
+}

internal/site/src/lib/api.ts

@@ -3,7 +3,7 @@ import PocketBase from "pocketbase"
 import { basePath } from "@/components/router"
 import { toast } from "@/components/ui/use-toast"
 import type { ChartTimes, UserSettings } from "@/types"
-import { $alerts, $allSystemsById, $allSystemsByName, $userSettings } from "./stores"
+import { $alerts, $allSystemsByName, $userSettings } from "./stores"
 import { chartTimeData } from "./utils"
 
 /** PocketBase JS Client */
@@ -26,9 +26,8 @@ export const verifyAuth = () => {
 }
 
 /** Logs the user out by clearing the auth store and unsubscribing from realtime updates. */
-export function logOut() {
+export async function logOut() {
 	$allSystemsByName.set({})
-	$allSystemsById.set({})
 	$alerts.set({})
 	$userSettings.set({} as UserSettings)
 	sessionStorage.setItem("lo", "t") // prevent auto login on logout

internal/site/src/lib/enums.ts

@@ -54,20 +54,8 @@ export enum HourFormat {
 	"24h" = "24h",
 }
 
-/** Container health status */
-export enum ContainerHealth {
-	None,
-	Starting,
-	Healthy,
-	Unhealthy,
-}
-
-export const ContainerHealthLabels = ["None", "Starting", "Healthy", "Unhealthy"] as const
-
 /** Connection type */
 export enum ConnectionType {
 	SSH = 1,
 	WebSocket,
 }
-
-export const connectionTypeLabels = ["", "SSH", "WebSocket"] as const

internal/site/src/lib/shiki.ts

@@ -1,28 +0,0 @@
-// https://shiki.style/guide/bundles#fine-grained-bundle
-
-// directly import the theme and language modules, only the ones you imported will be bundled.
-import githubDarkDimmed from '@shikijs/themes/github-dark-dimmed'
-
-// `shiki/core` entry does not include any themes or languages or the wasm binary.
-import { createHighlighterCore } from 'shiki/core'
-import { createOnigurumaEngine } from 'shiki/engine/oniguruma'
-
-export const highlighter = await createHighlighterCore({
-   themes: [
-      // instead of strings, you need to pass the imported module
-      githubDarkDimmed,
-      // or a dynamic import if you want to do chunk splitting
-      //  import('@shikijs/themes/material-theme-ocean')
-   ],
-   langs: [
-      import('@shikijs/langs/log'),
-      import('@shikijs/langs/json'),
-      // shiki will try to interop the module with the default export
-      // () => import('@shikijs/langs/css'),
-   ],
-   // `shiki/wasm` contains the wasm binary inlined as base64 string.
-   engine: createOnigurumaEngine(import('shiki/wasm'))
-})
-
-// optionally, load themes and languages after creation
-// await highlighter.loadTheme(import('@shikijs/themes/vitesse-light'))

internal/site/src/lib/systemsManager.ts

@@ -9,7 +9,7 @@ import {
 	$pausedSystems,
 	$upSystems,
 } from "@/lib/stores"
-import { updateFavicon } from "@/lib/utils"
+import { FAVICON_DEFAULT, FAVICON_GREEN, FAVICON_RED, updateFavicon } from "@/lib/utils"
 import type { SystemRecord } from "@/types"
 import { SystemStatus } from "./enums"
 
@@ -74,7 +74,9 @@ export function init() {
 
 /** Update the longest system name length and favicon based on system status */
 function onSystemsChanged(_: Record<string, SystemRecord>, changedSystem: SystemRecord | undefined) {
+	const upSystemsStore = $upSystems.get()
 	const downSystemsStore = $downSystems.get()
+	const upSystems = Object.values(upSystemsStore)
 	const downSystems = Object.values(downSystemsStore)
 
 	// Update longest system name length
@@ -84,7 +86,14 @@ function onSystemsChanged(_: Record<string, SystemRecord>, changedSystem: System
 		$longestSystemNameLen.set(nameLen)
 	}
 
-	updateFavicon(downSystems.length)
+	// Update favicon based on system status
+	if (downSystems.length > 0) {
+		updateFavicon(FAVICON_RED)
+	} else if (upSystems.length > 0) {
+		updateFavicon(FAVICON_GREEN)
+	} else {
+		updateFavicon(FAVICON_DEFAULT)
+	}
 }
 
 /** Fetch systems from collection */

internal/site/src/lib/utils.ts

@@ -1,14 +1,19 @@
 import { t } from "@lingui/core/macro"
 import { type ClassValue, clsx } from "clsx"
+import { timeDay, timeHour } from "d3-time"
 import { listenKeys } from "nanostores"
-import { timeDay, timeHour, timeMinute } from "d3-time"
 import { useEffect, useState } from "react"
 import { twMerge } from "tailwind-merge"
+import { prependBasePath } from "@/components/router"
 import { toast } from "@/components/ui/use-toast"
 import type { ChartTimeData, FingerprintRecord, SemVer, SystemRecord } from "@/types"
 import { HourFormat, MeterState, Unit } from "./enums"
 import { $copyContent, $userSettings } from "./stores"
 
+export const FAVICON_DEFAULT = "favicon.svg"
+export const FAVICON_GREEN = "favicon-green.svg"
+export const FAVICON_RED = "favicon-red.svg"
+
 export function cn(...inputs: ClassValue[]) {
 	return twMerge(clsx(inputs))
 }
@@ -49,18 +54,9 @@ const createShortDateFormatter = (hour12?: boolean) =>
 		hour12,
 	})
 
-const createHourWithSecondsFormatter = (hour12?: boolean) =>
-	new Intl.DateTimeFormat(undefined, {
-		hour: "numeric",
-		minute: "numeric",
-		second: "numeric",
-		hour12,
-	})
-
 // Initialize formatters with default values
 let hourWithMinutesFormatter = createHourWithMinutesFormatter()
 let shortDateFormatter = createShortDateFormatter()
-let hourWithSecondsFormatter = createHourWithSecondsFormatter()
 
 export const currentHour12 = () => shortDateFormatter.resolvedOptions().hour12
 
@@ -72,10 +68,6 @@ export const formatShortDate = (timestamp: string) => {
 	return shortDateFormatter.format(new Date(timestamp))
 }
 
-export const hourWithSeconds = (timestamp: string) => {
-	return hourWithSecondsFormatter.format(new Date(timestamp))
-}
-
 // Update the time formatters if user changes hourFormat
 listenKeys($userSettings, ["hourFormat"], ({ hourFormat }) => {
 	if (!hourFormat) return
@@ -83,7 +75,6 @@ listenKeys($userSettings, ["hourFormat"], ({ hourFormat }) => {
 	if (currentHour12() !== newHour12) {
 		hourWithMinutesFormatter = createHourWithMinutesFormatter(newHour12)
 		shortDateFormatter = createShortDateFormatter(newHour12)
-		hourWithSecondsFormatter = createHourWithSecondsFormatter(newHour12)
 	}
 })
 
@@ -95,47 +86,11 @@ export const formatDay = (timestamp: string) => {
 	return dayFormatter.format(new Date(timestamp))
 }
 
-export const updateFavicon = (() => {
-	let prevDownCount = 0
-	return (downCount = 0) => {
-		if (downCount === prevDownCount) {
-			return
-		}
-		prevDownCount = downCount
-		const svg = `
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 70">
-  <defs>
-    <linearGradient id="gradient" x1="0%" y1="20%" x2="100%" y2="120%">
-      <stop offset="0%" style="stop-color:#747bff"/>
-      <stop offset="100%" style="stop-color:#24eb5c"/>
-    </linearGradient>
-  </defs>
-  <path fill="url(#gradient)" d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/>
-  ${
-		downCount > 0 &&
-		`
-		<circle cx="40" cy="50" r="22" fill="#f00"/>
-  	<text x="40" y="60" font-size="34" text-anchor="middle" fill="#fff" font-family="Arial" font-weight="bold">${downCount}</text>
-	`
-	}
-</svg>
-	`
-		const blob = new Blob([svg], { type: "image/svg+xml" })
-		const url = URL.createObjectURL(blob)
-		;(document.querySelector("link[rel='icon']") as HTMLLinkElement).href = url
-	}
-})()
+export const updateFavicon = (newIcon: string) => {
+	;(document.querySelector("link[rel='icon']") as HTMLLinkElement).href = prependBasePath(`/static/${newIcon}`)
+}
 
 export const chartTimeData: ChartTimeData = {
-	"1m": {
-		type: "1m",
-		expectedInterval: 2000, // allow a bit of latency for one second updates (#1247)
-		label: () => t`1 minute`,
-		format: (timestamp: string) => hourWithSeconds(timestamp),
-		ticks: 3,
-		getOffset: (endTime: Date) => timeMinute.offset(endTime, -1),
-		minVersion: "0.13.0",
-	},
 	"1h": {
 		type: "1m",
 		expectedInterval: 60_000,
@@ -323,7 +278,7 @@ export const generateToken = () => {
 }
 
 /** Get the hub URL from the global BESZEL object */
-export const getHubURL = () => globalThis.BESZEL?.HUB_URL || window.location.origin
+export const getHubURL = () => BESZEL?.HUB_URL || window.location.origin
 
 /** Map of system IDs to their corresponding tokens (used to avoid fetching in add-system dialog) */
 export const tokenMap = new Map<SystemRecord["id"], FingerprintRecord["token"]>()
@@ -378,17 +333,6 @@ export const parseSemVer = (semVer = ""): SemVer => {
 	return { major: parts?.[0] ?? 0, minor: parts?.[1] ?? 0, patch: parts?.[2] ?? 0 }
 }
 
-/** Compare two semver strings. Returns -1 if a is less than b, 0 if a is equal to b, and 1 if a is greater than b. */
-export function compareSemVer(a: SemVer, b: SemVer) {
-	if (a.major !== b.major) {
-		return a.major - b.major
-	}
-	if (a.minor !== b.minor) {
-		return a.minor - b.minor
-	}
-	return a.patch - b.patch
-}
-
 /** Get meter state from 0-100 value. Used for color coding meters. */
 export function getMeterState(value: number): MeterState {
 	const { colorWarn = 65, colorCrit = 90 } = $userSettings.get()

internal/site/src/locales/ar/ar.po

@@ -48,10 +48,6 @@ msgstr "1 ساعة"
 msgid "1 min"
 msgstr "دقيقة واحدة"
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 دقيقة"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 أسبوع"
@@ -89,7 +85,7 @@ msgstr "إجراءات"
 msgid "Active"
 msgstr "نشط"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "التنبيهات النشطة"
 
@@ -133,15 +129,7 @@ msgstr "سجل التنبيهات"
 msgid "Alerts"
 msgstr "التنبيهات"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "جميع الحاويات"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -185,10 +173,6 @@ msgstr "متوسط استخدام وحدة المعالجة المركزية ع
 msgid "Average utilization of {0}"
 msgstr "متوسط ​​استخدام {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "متوسط استغلال محركات GPU"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -275,10 +259,6 @@ msgstr "تحقق من السجلات لمزيد من التفاصيل."
 msgid "Check your notification service"
 msgstr "تحقق من خدمة الإشعارات الخاصة بك"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "انقر على حاوية لعرض مزيد من المعلومات."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr "انقر على نظام لعرض مزيد من المعلومات."
@@ -301,7 +281,7 @@ msgstr "هيئ التنبيهات الواردة"
 msgid "Confirm password"
 msgstr "تأكيد كلمة المرور"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr "الاتصال مقطوع"
 
@@ -360,7 +340,6 @@ msgstr "انسخ محتوى <0>docker-compose.yml</0> للوكيل أدناه،
 msgid "Copy YAML"
 msgstr "نسخ YAML"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "المعالج"
@@ -398,6 +377,7 @@ msgid "Current state"
 msgstr "الحالة الحالية"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "لوحة التحكم"
 
@@ -414,10 +394,6 @@ msgstr "حذف"
 msgid "Delete fingerprint"
 msgstr "حذف البصمة"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "التفاصيل"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -524,7 +500,7 @@ msgstr "خطأ"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "يتجاوز {0}{1} في آخر {2, plural, one {# دقيقة} other {# دقائق}}"
 
@@ -565,7 +541,6 @@ msgstr "فشل في إرسال إشعار الاختبار"
 msgid "Failed to update alert"
 msgstr "فشل في تحديث التنبيه"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -601,10 +576,6 @@ msgstr "ممتلئة"
 msgid "General"
 msgstr "عام"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "محركات GPU"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "استهلاك طاقة وحدة معالجة الرسوميات"
@@ -613,10 +584,6 @@ msgstr "استهلاك طاقة وحدة معالجة الرسوميات"
 msgid "Grid"
 msgstr "شبكة"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "الصحة"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -636,11 +603,6 @@ msgstr "خاملة"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "إذا فقدت كلمة المرور لحساب المسؤول الخاص بك، يمكنك إعادة تعيينها باستخدام الأمر التالي."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "صورة"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "عنوان البريد الإشباكي غير صالح."
@@ -693,7 +655,6 @@ msgid "Login attempt failed"
 msgstr "فشل محاولة تسجيل الدخول"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "السجلات"
@@ -716,7 +677,6 @@ msgstr "تعليمات الإعداد اليدوي"
 msgid "Max 1 min"
 msgstr "الحد الأقصى دقيقة"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "الذاكرة"
@@ -732,11 +692,9 @@ msgstr "استخدام الذاكرة لحاويات دوكر"
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "الاسم"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "الشبكة"
@@ -748,7 +706,6 @@ msgstr "حركة مرور الشبكة لحاويات الدوكر"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "حركة مرور الشبكة للواجهات العامة"
 
@@ -761,7 +718,6 @@ msgstr "وحدة الشبكة"
 msgid "No results found."
 msgstr "لم يتم العثور على نتائج."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr "لا توجد نتائج."
@@ -803,7 +759,6 @@ msgstr "أو المتابعة باستخدام"
 msgid "Overwrite existing alerts"
 msgstr "الكتابة فوق التنبيهات الحالية"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "صفحة"
@@ -908,11 +863,6 @@ msgstr "قراءة"
 msgid "Received"
 msgstr "تم الاستلام"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "تحديث"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "طلب كلمة مرور لمرة واحدة"
@@ -1004,7 +954,6 @@ msgstr "الترتيب حسب"
 msgid "State"
 msgstr "الحالة"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1019,7 +968,6 @@ msgid "Swap Usage"
 msgstr "استخدام التبديل"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1193,10 +1141,6 @@ msgstr "قيد التشغيل"
 msgid "Up ({upSystemsLength})"
 msgstr "قيد التشغيل ({upSystemsLength})"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "تم التحديث"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
 msgstr "رفع"
@@ -1234,10 +1178,6 @@ msgstr "القيمة"
 msgid "View"
 msgstr "عرض"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "عرض المزيد"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr "عرض أحدث 200 تنبيه."

internal/site/src/locales/bg/bg.po

@@ -48,10 +48,6 @@ msgstr "1 час"
 msgid "1 min"
 msgstr "1 минута"
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 минута"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 седмица"
@@ -89,7 +85,7 @@ msgstr "Действия"
 msgid "Active"
 msgstr "Активен"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "Активни тревоги"
 
@@ -133,15 +129,7 @@ msgstr "История на нотификациите"
 msgid "Alerts"
 msgstr "Тревоги"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "Всички контейнери"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -185,10 +173,6 @@ msgstr "Средно използване на процесора на цяла
 msgid "Average utilization of {0}"
 msgstr "Средно използване на {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "Средно използване на GPU двигатели"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -275,10 +259,6 @@ msgstr "Провери log-овете за повече информация."
 msgid "Check your notification service"
 msgstr "Провери услугата си за удостоверяване"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "Кликнете върху контейнер, за да видите повече информация."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr "Кликнете върху система, за да видите повече информация."
@@ -301,7 +281,7 @@ msgstr "Настрой как получаваш нотификации за т
 msgid "Confirm password"
 msgstr "Потвърди парола"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr "Връзката е прекъсната"
 
@@ -360,7 +340,6 @@ msgstr "Копирайте съдържанието на<0>docker-compose.yml</0
 msgid "Copy YAML"
 msgstr "Копирай YAML"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "Процесор"
@@ -398,6 +377,7 @@ msgid "Current state"
 msgstr "Текущо състояние"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "Табло"
 
@@ -414,10 +394,6 @@ msgstr "Изтрий"
 msgid "Delete fingerprint"
 msgstr "Изтрий пръстов отпечатък"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "Подробности"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -524,7 +500,7 @@ msgstr "Грешка"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "Надвишава {0}{1} в последните {2, plural, one {# минута} other {# минути}}"
 
@@ -565,7 +541,6 @@ msgstr "Неуспешно изпрати тестова нотификация"
 msgid "Failed to update alert"
 msgstr "Неуспешно обнови тревога"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -601,10 +576,6 @@ msgstr "Пълна"
 msgid "General"
 msgstr "Общо"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "GPU двигатели"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "Консумация на ток от графична карта"
@@ -613,10 +584,6 @@ msgstr "Консумация на ток от графична карта"
 msgid "Grid"
 msgstr "Мрежово"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "Здраве"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -636,11 +603,6 @@ msgstr "Неактивна"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "Ако си загубил паролата до администраторския акаунт, можеш да я нулираш със следващата команда."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "Образ"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "Невалиден имейл адрес."
@@ -693,7 +655,6 @@ msgid "Login attempt failed"
 msgstr "Неуспешен опит за вход"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "Логове"
@@ -716,7 +677,6 @@ msgstr "Инструкции за ръчна настройка"
 msgid "Max 1 min"
 msgstr "Максимум 1 минута"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "Памет"
@@ -732,11 +692,9 @@ msgstr "Използването на памет от docker контейнер
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "Име"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "Мрежа"
@@ -748,7 +706,6 @@ msgstr "Мрежов трафик на docker контейнери"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "Мрежов трафик на публични интерфейси"
 
@@ -761,7 +718,6 @@ msgstr "Единица за измерване на скорост"
 msgid "No results found."
 msgstr "Няма намерени резултати."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr "Няма резултати."
@@ -803,7 +759,6 @@ msgstr "Или продължи с"
 msgid "Overwrite existing alerts"
 msgstr "Презапиши съществуващи тревоги"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "Страница"
@@ -908,11 +863,6 @@ msgstr "Прочети"
 msgid "Received"
 msgstr "Получени"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "Опресни"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "Заявка за еднократна парола"
@@ -1004,7 +954,6 @@ msgstr "Сортиране по"
 msgid "State"
 msgstr "Състояние"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1019,7 +968,6 @@ msgid "Swap Usage"
 msgstr "Използване на swap"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1193,10 +1141,6 @@ msgstr "Нагоре"
 msgid "Up ({upSystemsLength})"
 msgstr "Нагоре ({upSystemsLength})"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "Актуализирано"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
 msgstr "Качване"
@@ -1234,10 +1178,6 @@ msgstr "Стойност"
 msgid "View"
 msgstr "Изглед"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "Виж повече"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr "Прегледайте последните си 200 сигнала."

internal/site/src/locales/cs/cs.po

@@ -48,10 +48,6 @@ msgstr "1 hodina"
 msgid "1 min"
 msgstr "1 min"
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 minuta"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 týden"
@@ -89,7 +85,7 @@ msgstr "Akce"
 msgid "Active"
 msgstr "Aktivní"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "Aktivní výstrahy"
 
@@ -133,15 +129,7 @@ msgstr "Historie upozornění"
 msgid "Alerts"
 msgstr "Výstrahy"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "Všechny kontejnery"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -185,10 +173,6 @@ msgstr "Průměrné využití CPU v celém systému"
 msgid "Average utilization of {0}"
 msgstr "Průměrné využití {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "Průměrné využití GPU engine"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -275,10 +259,6 @@ msgstr "Pro více informací zkontrolujte logy."
 msgid "Check your notification service"
 msgstr "Zkontrolujte službu upozornění"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "Klikněte na kontejner pro zobrazení dalších informací."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr "Klikněte na systém pro zobrazení více informací."
@@ -301,7 +281,7 @@ msgstr "Konfigurace způsobu přijímání upozornění."
 msgid "Confirm password"
 msgstr "Potvrdit heslo"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr "Připojení je nedostupné"
 
@@ -360,7 +340,6 @@ msgstr "Zkopírujte obsah <0>docker-compose.yml</0> pro agenta níže nebo autom
 msgid "Copy YAML"
 msgstr "Kopírovat YAML"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "Procesor"
@@ -398,6 +377,7 @@ msgid "Current state"
 msgstr "Aktuální stav"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "Přehled"
 
@@ -414,10 +394,6 @@ msgstr "Odstranit"
 msgid "Delete fingerprint"
 msgstr "Smazat identifikátor"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "Detail"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -524,7 +500,7 @@ msgstr "Chyba"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "Překračuje {0}{1} za {2, plural, one {poslední # minutu} few {poslední # minuty} other {posledních # minut}}"
 
@@ -565,7 +541,6 @@ msgstr "Nepodařilo se odeslat testovací oznámení"
 msgid "Failed to update alert"
 msgstr "Nepodařilo se aktualizovat upozornění"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -601,10 +576,6 @@ msgstr "Plná"
 msgid "General"
 msgstr "Obecné"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "GPU enginy"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "Spotřeba energie GPU"
@@ -613,10 +584,6 @@ msgstr "Spotřeba energie GPU"
 msgid "Grid"
 msgstr "Mřížka"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "Zdraví"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -636,11 +603,6 @@ msgstr "Neaktivní"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "Pokud jste ztratili heslo k vašemu účtu správce, můžete jej obnovit pomocí následujícího příkazu."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "Obraz"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "Neplatná e-mailová adresa."
@@ -693,7 +655,6 @@ msgid "Login attempt failed"
 msgstr "Pokus o přihlášení selhal"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "Logy"
@@ -716,7 +677,6 @@ msgstr "Pokyny k manuálnímu nastavení"
 msgid "Max 1 min"
 msgstr "Max. 1 min"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "Paměť"
@@ -732,11 +692,9 @@ msgstr "Využití paměti docker kontejnerů"
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "Název"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "Síť"
@@ -748,7 +706,6 @@ msgstr "Síťový provoz kontejnerů docker"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "Síťový provoz veřejných rozhraní"
 
@@ -761,7 +718,6 @@ msgstr "Síťová jednotka"
 msgid "No results found."
 msgstr "Nenalezeny žádné výskyty."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr "Žádné výsledky."
@@ -803,7 +759,6 @@ msgstr "Nebo pokračujte s"
 msgid "Overwrite existing alerts"
 msgstr "Přepsat existující upozornění"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "Stránka"
@@ -908,11 +863,6 @@ msgstr "Číst"
 msgid "Received"
 msgstr "Přijato"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "Aktualizovat"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "Požádat o jednorázové heslo"
@@ -1004,7 +954,6 @@ msgstr "Seřadit podle"
 msgid "State"
 msgstr "Stav"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1019,7 +968,6 @@ msgid "Swap Usage"
 msgstr "Swap využití"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1193,10 +1141,6 @@ msgstr "Funkční"
 msgid "Up ({upSystemsLength})"
 msgstr "Funkční ({upSystemsLength})"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "Aktualizováno"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
 msgstr "Odeslání"
@@ -1234,10 +1178,6 @@ msgstr "Hodnota"
 msgid "View"
 msgstr "Zobrazení"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "Zobrazit více"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr "Zobrazit vašich 200 nejnovějších upozornění."

internal/site/src/locales/da/da.po

@@ -48,10 +48,6 @@ msgstr "1 time"
 msgid "1 min"
 msgstr ""
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 minut"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 uge"
@@ -89,7 +85,7 @@ msgstr "Handlinger"
 msgid "Active"
 msgstr ""
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "Aktive Alarmer"
 
@@ -133,15 +129,7 @@ msgstr ""
 msgid "Alerts"
 msgstr "Alarmer"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "Alle containere"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -185,10 +173,6 @@ msgstr "Gennemsnitlig systembaseret CPU-udnyttelse"
 msgid "Average utilization of {0}"
 msgstr "Gennemsnitlig udnyttelse af {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "Gennemsnitlig udnyttelse af GPU-motorer"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -275,10 +259,6 @@ msgstr "Tjek logfiler for flere detaljer."
 msgid "Check your notification service"
 msgstr "Tjek din notifikationstjeneste"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "Klik på en container for at se mere information."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr ""
@@ -301,7 +281,7 @@ msgstr "Konfigurer hvordan du modtager advarselsmeddelelser."
 msgid "Confirm password"
 msgstr "Bekræft adgangskode"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr ""
 
@@ -360,7 +340,6 @@ msgstr ""
 msgid "Copy YAML"
 msgstr ""
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "CPU"
@@ -398,6 +377,7 @@ msgid "Current state"
 msgstr "Nuværende tilstand"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "Oversigtspanel"
 
@@ -414,10 +394,6 @@ msgstr "Slet"
 msgid "Delete fingerprint"
 msgstr ""
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "Detalje"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -524,7 +500,7 @@ msgstr "Fejl"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "Overskrider {0}{1} i sidste {2, plural, one {# minut} other {# minutter}}"
 
@@ -565,7 +541,6 @@ msgstr "Afsendelse af testnotifikation mislykkedes"
 msgid "Failed to update alert"
 msgstr "Kunne ikke opdatere alarm"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -601,10 +576,6 @@ msgstr "Fuldt opladt"
 msgid "General"
 msgstr "Generelt"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "GPU-motorer"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "Gpu Strøm Træk"
@@ -613,10 +584,6 @@ msgstr "Gpu Strøm Træk"
 msgid "Grid"
 msgstr "Gitter"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "Sundhed"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -636,11 +603,6 @@ msgstr "Inaktiv"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "Hvis du har mistet adgangskoden til din administratorkonto, kan du nulstille den ved hjælp af følgende kommando."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "Image"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "Ugyldig email adresse."
@@ -693,7 +655,6 @@ msgid "Login attempt failed"
 msgstr "Loginforsøg mislykkedes"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "Logs"
@@ -716,7 +677,6 @@ msgstr "Manuel opsætningsvejledning"
 msgid "Max 1 min"
 msgstr "Maks. 1 min"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "Hukommelse"
@@ -732,11 +692,9 @@ msgstr "Hukommelsesforbrug af dockercontainere"
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "Navn"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "Net"
@@ -748,7 +706,6 @@ msgstr "Netværkstrafik af dockercontainere"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "Netværkstrafik af offentlige grænseflader"
 
@@ -761,7 +718,6 @@ msgstr ""
 msgid "No results found."
 msgstr "Ingen resultater fundet."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr ""
@@ -803,7 +759,6 @@ msgstr "Eller fortsæt med"
 msgid "Overwrite existing alerts"
 msgstr "Overskriv eksisterende alarmer"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "Side"
@@ -908,11 +863,6 @@ msgstr "Læs"
 msgid "Received"
 msgstr "Modtaget"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "Opdater"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "Anmod om engangsadgangskode"
@@ -1004,7 +954,6 @@ msgstr "Sorter efter"
 msgid "State"
 msgstr ""
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1019,7 +968,6 @@ msgid "Swap Usage"
 msgstr "Swap forbrug"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1193,10 +1141,6 @@ msgstr "Oppe"
 msgid "Up ({upSystemsLength})"
 msgstr ""
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "Opdateret"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
 msgstr "Upload"
@@ -1234,10 +1178,6 @@ msgstr ""
 msgid "View"
 msgstr "Vis"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "Se mere"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr ""

internal/site/src/locales/de/de.po

@@ -8,7 +8,7 @@ msgstr ""
 "Language: de\n"
 "Project-Id-Version: beszel\n"
 "Report-Msgid-Bugs-To: \n"
-"PO-Revision-Date: 2025-10-05 16:13\n"
+"PO-Revision-Date: 2025-08-28 23:21\n"
 "Last-Translator: \n"
 "Language-Team: German\n"
 "Plural-Forms: nplurals=2; plural=(n != 1);\n"
@@ -48,10 +48,6 @@ msgstr "1 Stunde"
 msgid "1 min"
 msgstr "1 Min"
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 Minute"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 Woche"
@@ -89,7 +85,7 @@ msgstr "Aktionen"
 msgid "Active"
 msgstr "Aktiv"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "Aktive Warnungen"
 
@@ -133,15 +129,7 @@ msgstr "Alarm-Verlauf"
 msgid "Alerts"
 msgstr "Warnungen"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "Alle Container"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -185,10 +173,6 @@ msgstr "Durchschnittliche systemweite CPU-Auslastung"
 msgid "Average utilization of {0}"
 msgstr "Durchschnittliche Auslastung von {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "Durchschnittliche Auslastung der GPU-Engines"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -275,10 +259,6 @@ msgstr "Überprüfe die Protokolle für weitere Details."
 msgid "Check your notification service"
 msgstr "Überprüfe deinen Benachrichtigungsdienst"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "Klicken Sie auf einen Container, um weitere Informationen zu sehen."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr "Klicke auf ein System, um weitere Informationen zu sehen."
@@ -301,7 +281,7 @@ msgstr "Konfiguriere, wie du Warnbenachrichtigungen erhältst."
 msgid "Confirm password"
 msgstr "Passwort bestätigen"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr "Verbindung unterbrochen"
 
@@ -360,7 +340,6 @@ msgstr "Kopieren Sie den<0>docker-compose.yml</0> Inhalt für den Agent unten od
 msgid "Copy YAML"
 msgstr "YAML kopieren"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "CPU"
@@ -398,6 +377,7 @@ msgid "Current state"
 msgstr "Aktueller Zustand"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "Dashboard"
 
@@ -414,10 +394,6 @@ msgstr "Löschen"
 msgid "Delete fingerprint"
 msgstr "Fingerabdruck löschen"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "Detail"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -475,7 +451,7 @@ msgstr "Offline ({downSystemsLength})"
 
 #: src/components/routes/system/network-sheet.tsx
 msgid "Download"
-msgstr "Herunterladen"
+msgstr "Download"
 
 #: src/components/alerts-history-columns.tsx
 msgid "Duration"
@@ -524,7 +500,7 @@ msgstr "Fehler"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "Überschreitet {0}{1} in den letzten {2, plural, one {# Minute} other {# Minuten}}"
 
@@ -565,7 +541,6 @@ msgstr "Testbenachrichtigung konnte nicht gesendet werden"
 msgid "Failed to update alert"
 msgstr "Warnung konnte nicht aktualisiert werden"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -601,10 +576,6 @@ msgstr "Voll"
 msgid "General"
 msgstr "Allgemein"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "GPU-Engines"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "GPU-Leistungsaufnahme"
@@ -613,10 +584,6 @@ msgstr "GPU-Leistungsaufnahme"
 msgid "Grid"
 msgstr "Raster"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "Gesundheit"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -636,11 +603,6 @@ msgstr "Untätig"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "Wenn du das Passwort für dein Administratorkonto verloren hast, kannst du es mit dem folgenden Befehl zurücksetzen."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "Image"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "Ungültige E-Mail-Adresse."
@@ -693,7 +655,6 @@ msgid "Login attempt failed"
 msgstr "Anmeldeversuch fehlgeschlagen"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "Protokolle"
@@ -716,7 +677,6 @@ msgstr "Anleitung zur manuellen Einrichtung"
 msgid "Max 1 min"
 msgstr "Max 1 Min"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "Arbeitsspeicher"
@@ -732,11 +692,9 @@ msgstr "Arbeitsspeichernutzung der Docker-Container"
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "Name"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "Netz"
@@ -748,7 +706,6 @@ msgstr "Netzwerkverkehr der Docker-Container"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "Netzwerkverkehr der öffentlichen Schnittstellen"
 
@@ -761,7 +718,6 @@ msgstr "Netzwerkeinheit"
 msgid "No results found."
 msgstr "Keine Ergebnisse gefunden."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr "Keine Ergebnisse."
@@ -803,7 +759,6 @@ msgstr "Oder fortfahren mit"
 msgid "Overwrite existing alerts"
 msgstr "Bestehende Warnungen überschreiben"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "Seite"
@@ -908,11 +863,6 @@ msgstr "Lesen"
 msgid "Received"
 msgstr "Empfangen"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "Aktualisieren"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "Einmalpasswort anfordern"
@@ -1004,7 +954,6 @@ msgstr "Sortieren nach"
 msgid "State"
 msgstr "Status"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1019,7 +968,6 @@ msgid "Swap Usage"
 msgstr "Swap-Nutzung"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1193,13 +1141,9 @@ msgstr "aktiv"
 msgid "Up ({upSystemsLength})"
 msgstr "aktiv ({upSystemsLength})"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "Aktualisiert"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
-msgstr "Hochladen"
+msgstr "Upload"
 
 #: src/components/routes/system.tsx
 msgid "Uptime"
@@ -1234,10 +1178,6 @@ msgstr "Wert"
 msgid "View"
 msgstr "Ansicht"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "Mehr anzeigen"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr "Sieh dir die neusten 200 Alarme an."

internal/site/src/locales/en/en.po

@@ -43,10 +43,6 @@ msgstr "1 hour"
 msgid "1 min"
 msgstr "1 min"
 
-#: src/lib/utils.ts
-msgid "1 minute"
-msgstr "1 minute"
-
 #: src/lib/utils.ts
 msgid "1 week"
 msgstr "1 week"
@@ -84,7 +80,7 @@ msgstr "Actions"
 msgid "Active"
 msgstr "Active"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Active Alerts"
 msgstr "Active Alerts"
 
@@ -128,15 +124,7 @@ msgstr "Alert History"
 msgid "Alerts"
 msgstr "Alerts"
 
-#: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
-#: src/components/routes/containers.tsx
-msgid "All Containers"
-msgstr "All Containers"
-
 #: src/components/alerts/alerts-sheet.tsx
-#: src/components/command-palette.tsx
-#: src/components/routes/home.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/components/systems-table/systems-table.tsx
 msgid "All Systems"
@@ -180,10 +168,6 @@ msgstr "Average system-wide CPU utilization"
 msgid "Average utilization of {0}"
 msgstr "Average utilization of {0}"
 
-#: src/components/routes/system.tsx
-msgid "Average utilization of GPU engines"
-msgstr "Average utilization of GPU engines"
-
 #: src/components/command-palette.tsx
 #: src/components/navbar.tsx
 msgid "Backups"
@@ -270,10 +254,6 @@ msgstr "Check logs for more details."
 msgid "Check your notification service"
 msgstr "Check your notification service"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Click on a container to view more information."
-msgstr "Click on a container to view more information."
-
 #: src/components/systems-table/systems-table.tsx
 msgid "Click on a system to view more information."
 msgstr "Click on a system to view more information."
@@ -296,7 +276,7 @@ msgstr "Configure how you receive alert notifications."
 msgid "Confirm password"
 msgstr "Confirm password"
 
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Connection is down"
 msgstr "Connection is down"
 
@@ -355,7 +335,6 @@ msgstr "Copy the<0>docker-compose.yml</0> content for the agent below, or regist
 msgid "Copy YAML"
 msgstr "Copy YAML"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "CPU"
 msgstr "CPU"
@@ -393,6 +372,7 @@ msgid "Current state"
 msgstr "Current state"
 
 #: src/components/command-palette.tsx
+#: src/components/routes/home.tsx
 msgid "Dashboard"
 msgstr "Dashboard"
 
@@ -409,10 +389,6 @@ msgstr "Delete"
 msgid "Delete fingerprint"
 msgstr "Delete fingerprint"
 
-#: src/components/containers-table/containers-table.tsx
-msgid "Detail"
-msgstr "Detail"
-
 #. Context: Battery state
 #: src/lib/i18n.ts
 msgid "Discharging"
@@ -519,7 +495,7 @@ msgstr "Error"
 #. placeholder {0}: alert.value
 #. placeholder {1}: info.unit
 #. placeholder {2}: alert.min
-#: src/components/active-alerts.tsx
+#: src/components/routes/home.tsx
 msgid "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 msgstr "Exceeds {0}{1} in last {2, plural, one {# minute} other {# minutes}}"
 
@@ -560,7 +536,6 @@ msgstr "Failed to send test notification"
 msgid "Failed to update alert"
 msgstr "Failed to update alert"
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 #: src/components/routes/system.tsx
 #: src/components/systems-table/systems-table.tsx
@@ -596,10 +571,6 @@ msgstr "Full"
 msgid "General"
 msgstr "General"
 
-#: src/components/routes/system.tsx
-msgid "GPU Engines"
-msgstr "GPU Engines"
-
 #: src/components/routes/system.tsx
 msgid "GPU Power Draw"
 msgstr "GPU Power Draw"
@@ -608,10 +579,6 @@ msgstr "GPU Power Draw"
 msgid "Grid"
 msgstr "Grid"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Health"
-msgstr "Health"
-
 #: src/components/add-system.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 msgctxt "Button to copy install command"
@@ -631,11 +598,6 @@ msgstr "Idle"
 msgid "If you've lost the password to your admin account, you may reset it using the following command."
 msgstr "If you've lost the password to your admin account, you may reset it using the following command."
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgctxt "Docker image"
-msgid "Image"
-msgstr "Image"
-
 #: src/components/login/auth-form.tsx
 msgid "Invalid email address."
 msgstr "Invalid email address."
@@ -688,7 +650,6 @@ msgid "Login attempt failed"
 msgstr "Login attempt failed"
 
 #: src/components/command-palette.tsx
-#: src/components/containers-table/containers-table.tsx
 #: src/components/navbar.tsx
 msgid "Logs"
 msgstr "Logs"
@@ -711,7 +672,6 @@ msgstr "Manual setup instructions"
 msgid "Max 1 min"
 msgstr "Max 1 min"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Memory"
 msgstr "Memory"
@@ -727,11 +687,9 @@ msgstr "Memory usage of docker containers"
 
 #: src/components/add-system.tsx
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 msgid "Name"
 msgstr "Name"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 msgid "Net"
 msgstr "Net"
@@ -743,7 +701,6 @@ msgstr "Network traffic of docker containers"
 #: src/components/routes/system.tsx
 #: src/components/routes/system/network-sheet.tsx
 #: src/components/routes/system/network-sheet.tsx
-#: src/components/routes/system/network-sheet.tsx
 msgid "Network traffic of public interfaces"
 msgstr "Network traffic of public interfaces"
 
@@ -756,7 +713,6 @@ msgstr "Network unit"
 msgid "No results found."
 msgstr "No results found."
 
-#: src/components/containers-table/containers-table.tsx
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "No results."
 msgstr "No results."
@@ -798,7 +754,6 @@ msgstr "Or continue with"
 msgid "Overwrite existing alerts"
 msgstr "Overwrite existing alerts"
 
-#: src/components/command-palette.tsx
 #: src/components/command-palette.tsx
 msgid "Page"
 msgstr "Page"
@@ -903,11 +858,6 @@ msgstr "Read"
 msgid "Received"
 msgstr "Received"
 
-#: src/components/containers-table/containers-table.tsx
-#: src/components/containers-table/containers-table.tsx
-msgid "Refresh"
-msgstr "Refresh"
-
 #: src/components/login/login.tsx
 msgid "Request a one-time password"
 msgstr "Request a one-time password"
@@ -999,7 +949,6 @@ msgstr "Sort By"
 msgid "State"
 msgstr "State"
 
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/systems-table/systems-table.tsx
 #: src/lib/alerts.ts
 msgid "Status"
@@ -1014,7 +963,6 @@ msgid "Swap Usage"
 msgstr "Swap Usage"
 
 #: src/components/alerts-history-columns.tsx
-#: src/components/containers-table/containers-table-columns.tsx
 #: src/components/routes/settings/tokens-fingerprints.tsx
 #: src/components/systems-table/systems-table-columns.tsx
 #: src/lib/alerts.ts
@@ -1188,10 +1136,6 @@ msgstr "Up"
 msgid "Up ({upSystemsLength})"
 msgstr "Up ({upSystemsLength})"
 
-#: src/components/containers-table/containers-table-columns.tsx
-msgid "Updated"
-msgstr "Updated"
-
 #: src/components/routes/system/network-sheet.tsx
 msgid "Upload"
 msgstr "Upload"
@@ -1229,10 +1173,6 @@ msgstr "Value"
 msgid "View"
 msgstr "View"
 
-#: src/components/routes/system/network-sheet.tsx
-msgid "View more"
-msgstr "View more"
-
 #: src/components/routes/settings/alerts-history-data-table.tsx
 msgid "View your 200 most recent alerts."
 msgstr "View your 200 most recent alerts."