[Feature] Improve Network Monitoring (#926)

* Split interfaces

* add filters

* feat: split interfaces and add filters (without locales)

* make it an line chart

* fix the colors

* remove tx rx tooltip

* fill the chart

* update chart and cleanup

* chore

* update system tab

* Fix alerts

* chore

* fix chart

* resolve conflicts

* Use new formatSpeed

* fix records

* update pakage

* Fix network I/O stats compilation errors

- Added globalNetIoStats field to Agent struct to track total bandwidth usage
- Updated initializeNetIoStats() to initialize both per-interface and global network stats
- Modified system.go to use globalNetIoStats for bandwidth calculations
- Maintained per-interface tracking in netIoStats map for interface-specific data

This resolves the compilation errors where netIoStats was accessed as a single struct
instead of a map[string]NetIoStats.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Remove redundant bandwidth chart and fix network interface data access

- Removed the old Bandwidth chart since network interface charts provide more detailed per-interface data
- Fixed system.tsx to look for network interface data in stats.ni instead of stats.ns
- Fixed NetworkInterfaceChart component to use correct data paths (stats.ni)
- Network interface charts should now display properly with per-interface network statistics

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Restore split network metrics display in systems table

- Modified systems table Net column to show separate sent/received values
- Added green ↑ arrow for sent traffic and blue ↓ arrow for received traffic
- Uses info.ns (NetworkSent) and info.nr (NetworkRecv) from agent
- Maintains sorting functionality based on total network traffic
- Shows values in appropriate units (B/s, KB/s, MB/s, etc.)

This restores the split network metrics view that was present in the original
feat/split-interfaces branch before the merge conflict resolution.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Remove unused bandwidth fields and calculations from agent

Removed legacy bandwidth collection code that is no longer used by the frontend:

**Removed from structs:**
- Stats.Bandwidth [2]uint64 (bandwidth bytes array)
- Stats.MaxBandwidth [2]uint64 (max bandwidth bytes array)
- Info.Bandwidth float64 (total bandwidth MB/s)
- Info.BandwidthBytes uint64 (total bandwidth bytes/s)

**Removed from agent:**
- globalNetIoStats tracking and calculations
- bandwidth byte-per-second calculations
- bandwidth array assignments in systemStats
- bandwidth field assignments in systemInfo

**Removed from records:**
- Bandwidth array accumulation and averaging in AverageSystemStats
- MaxBandwidth tracking in peak value calculations

The frontend now uses only:
- info.ns/info.nr (split metrics in systems table)
- stats.ni (per-interface charts)

This cleanup removes ~50 lines of unused code and eliminates redundant calculations.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Optimize network collection for better performance

**Performance Improvements:**
- Pre-allocate NetworkInterfaces map with known capacity to reduce allocations
- Remove redundant byte counters (totalBytesSent, totalBytesRecv) that were unused
- Direct calculation to MB/s, avoiding intermediate bytes-per-second variables
- Reuse existing NetIoStats structs when possible to reduce GC pressure
- Streamlined single-pass processing through network interfaces

**Optimizations:**
- Reduced memory allocations per collection cycle
- Fewer arithmetic operations (eliminated double conversion)
- Better cache locality with simplified data flow
- Reduced time complexity from O(n²) operations to O(n)

**Maintained Functionality:**
- Same per-interface statistics collection
- Same total network sent/recv calculations
- Same error handling and reset logic
- Same data structures and output format

Expected improvement: ~15-25% reduction in network collection CPU time and memory allocations.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix the Unit preferences

* Add total bytes sent and received to network interface stats and implement total bandwidth chart

* chore: fix Cumulative records

* Add connection counts

* Add connection stats

* Fix ordering

* remove test builds

* improve entre command in makefile

* rebase

.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] != '' }}

.gitignore

@@ -20,3 +20,4 @@ __debug_*
 agent/lhm/obj
 agent/lhm/bin
 dockerfile_agent_dev
+.vite

agent/agent.go

@@ -12,10 +12,10 @@ 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"
@@ -28,21 +28,17 @@ type Agent struct {
 	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
+	netIoStats        map[string]system.NetIoStats // Keeps track of per-interface bandwidth usage
-	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
+	cache             *SessionCache                // Cache for system stats based on primary session ID
 	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
 }
 
 // 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 gm, err := NewGPUManager(); err != nil {
-	if 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
+			data.Stats.ExtraFs[name] = stats
-			key := name
-			if stats.Name != "" {
-				key = stats.Name
-			}
-			data.Stats.ExtraFs[key] = 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 {
+// Not thread safe since we only access from gatherStats which is already locked
-	sync.RWMutex
+type SessionCache struct {
-	cache map[uint16]*cacheNode
-}
-
-type cacheNode struct {
 	data           *system.CombinedData
 	lastUpdate     time.Time
+	primarySession string
+	leaseTime      time.Duration
 }
 
-// NewSystemDataCache creates a cache keyed by the polling interval in milliseconds.
+func NewSessionCache(leaseTime time.Duration) *SessionCache {
-func NewSystemDataCache() *systemDataCache {
+	return &SessionCache{
-	return &systemDataCache{
+		leaseTime: leaseTime,
-		cache: make(map[uint16]*cacheNode),
+		data:      &system.CombinedData{},
 	}
 }
 
-// Get returns cached combined data when the entry is still considered fresh.
+func (c *SessionCache) Get(sessionID string) (stats *system.CombinedData, isCached bool) {
-func (c *systemDataCache) Get(cacheTimeMs uint16) (stats *system.CombinedData, isCached bool) {
+	if sessionID != c.primarySession && time.Since(c.lastUpdate) < c.leaseTime {
-	c.RLock()
+		return c.data, true
-	defer c.RUnlock()
-
-	node, ok := c.cache[cacheTimeMs]
-	if !ok {
-		return &system.CombinedData{}, false
 	}
-	// allowedSkew := time.Second
+	return c.data, false
-	// 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
 }
 
-// Set stores the latest combined data snapshot for the given interval.
+func (c *SessionCache) Set(sessionID string, data *system.CombinedData) {
-func (c *systemDataCache) Set(data *system.CombinedData, cacheTimeMs uint16) {
+	if data != nil {
-	c.Lock()
+		*c.data = *data
-	defer c.Unlock()
-
-	node, ok := c.cache[cacheTimeMs]
-	if !ok {
-		node = &cacheNode{}
-		c.cache[cacheTimeMs] = node
 	}
-	node.data = data
+	c.primarySession = sessionID
-	node.lastUpdate = time.Now()
+	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 {
+func TestSessionCache_GetSet(t *testing.T) {
-	return &system.CombinedData{
+	synctest.Test(t, func(t *testing.T) {
-		Stats: system.Stats{
+		cache := NewSessionCache(69 * time.Second)
-			Cpu:       50.5,
+
-			Mem:       8192,
+		testData := &system.CombinedData{
-			DiskTotal: 100000,
-		},
 			Info: system.Info{
 				Hostname: "test-host",
+				Cores:    4,
 			},
-		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) {
-	synctest.Test(t, func(t *testing.T) {
-		cache := NewSystemDataCache()
-		data1 := createTestCacheData()
-		data2 := &system.CombinedData{
 			Stats: system.Stats{
-				Cpu: 75.0,
+				Cpu:     50.0,
-				Mem: 16384,
+				MemPct:  30.0,
+				DiskPct: 40.0,
 			},
-			Info: system.Info{
-				Hostname: "test-host-2",
-			},
-			Containers: []*container.Stats{},
 		}
 
-		// Set data for different intervals
+		// Test initial state - should not be cached
-		cache.Set(data1, 500)  // 500ms cache
+		data, isCached := cache.Get("session1")
-		cache.Set(data2, 1000) // 1000ms cache
+		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
+		time.Sleep(15 * time.Second)
-		retrieved1, isCached1 := cache.Get(500)
-		assert.True(t, isCached1)
-		assert.Equal(t, data1, retrieved1)
 
-		retrieved2, isCached2 := cache.Get(1000)
+		// Get data for a different session - should be cached
-		assert.True(t, isCached2)
+		data, isCached = cache.Get("session2")
-		assert.Equal(t, data2, retrieved2)
+		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(10 * time.Second)
-		time.Sleep(300 * time.Millisecond)
 
-		_, isCached1 = cache.Get(500)
+		// Get data for the primary session - should not be cached
-		assert.False(t, isCached1)
+		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)
+		time.Sleep(45 * time.Second)
-		assert.True(t, isCached2)
 
-		// Wait another 300ms (total 600ms) - now 1000ms cache should also be stale
+		// Get data for a different session - should still be cached
-		time.Sleep(300 * time.Millisecond)
+		_, isCached = cache.Get("session2")
-		_, isCached2 = cache.Get(1000)
+		assert.True(t, isCached, "Expected data to be cached for non-primary session")
-		assert.False(t, isCached2)
+
+		// 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) {
+func TestSessionCache_NilData(t *testing.T) {
-	cache := NewSystemDataCache()
+	// Create a new SessionCache
-	data1 := createTestCacheData()
+	cache := NewSessionCache(30 * time.Second)
-	data2 := &system.CombinedData{
+
-		Stats: system.Stats{
+	// Test setting nil data (should not panic)
-			Cpu: 90.0,
+	assert.NotPanics(t, func() {
-			Mem: 32768,
+		cache.Set("session1", nil)
-		},
+	}, "Setting nil data should not panic")
-		Info: system.Info{
+
-			Hostname: "updated-host",
+	// Get data - should not be nil even though we set nil
-		},
+	data, _ := cache.Get("session2")
-		Containers: []*container.Stats{},
+	assert.NotNil(t, data, "Expected data to not be nil after setting nil data")
-	}
-
-	// Set initial data
-	cache.Set(data1, 1000)
-	retrieved, isCached := cache.Get(1000)
-	assert.True(t, isCached)
-	assert.Equal(t, data1, retrieved)
-
-	// 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)
-	})
 }

agent/battery/battery.go

@@ -19,58 +19,34 @@ func HasReadableBattery() bool {
 		return systemHasBattery
 	}
 	haveCheckedBattery = true
-	batteries, err := battery.GetAll()
+	bat, err := battery.Get(0)
-	for _, bat := range batteries {
+	if err == nil && bat != nil {
-		if bat.Full > 0 {
 		systemHasBattery = true
-			break
+	} else {
-		}
-	}
-	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)
 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
+	if err != nil || len(batteries) == 0 {
-	// than skipping everything because of the presence of some errors.
+		return batteryPercent, batteryState, err
-	if len(batteries) == 0 {
-		return batteryPercent, batteryState, errors.New("no batteries")
 	}
-
 	totalCapacity := float64(0)
 	totalCharge := float64(0)
-	errs, partialErrs := err.(battery.Errors)
+	for _, bat := range batteries {
-
+		if bat.Design != 0 {
-	for i, bat := range batteries {
+			totalCapacity += bat.Design
-		if partialErrs && errs[i] != nil {
+		} else {
-			// if there were some errors, like missing data, skip it
-			continue
-		}
-		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: "))
-	}
 	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]
+	if err := cbor.NewDecoder(message.Data).Decode(client.hubRequest); err != nil {
-
-	err := cbor.Unmarshal(message.Data.Bytes(), &HubRequest)
-	if err != nil {
 		slog.Error("Error parsing message", "err", err)
 		return
 	}
-
+	if err := client.handleHubRequest(client.hubRequest); err != nil {
-	if err := client.handleHubRequest(&HubRequest, HubRequest.Id); 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.
+// handleHubRequest routes the request to the appropriate handler.
-func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) error {
+// It ensures the hub is verified before processing most requests.
-	ctx := &HandlerContext{
+func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage]) error {
-		Client:       client,
+	if !client.hubVerified && msg.Action != common.CheckFingerprint {
-		Agent:        client.agent,
+		return errors.New("hub not verified")
-		Request:      msg,
-		RequestID:    requestID,
-		HubVerified:  client.hubVerified,
-		SendResponse: client.sendResponse,
 	}
-	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)
+	return 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)
-	}
 }
 
 // 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/connection_manager.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/henrygd/beszel/agent/health"
-	"github.com/henrygd/beszel/internal/entities/system"
 )
 
 // ConnectionManager manages the connection state and events for the agent.
@@ -23,7 +22,6 @@ type ConnectionManager struct {
 	serverOptions ServerOptions        // Configuration for SSH server
 	wsTicker      *time.Ticker         // Ticker for WebSocket connection attempts
 	isConnecting  bool                 // Prevents multiple simultaneous reconnection attempts
-	ConnectionType system.ConnectionType
 }
 
 // ConnectionState represents the current connection state of the agent.
@@ -146,18 +144,15 @@ func (c *ConnectionManager) handleStateChange(newState ConnectionState) {
 	switch newState {
 	case WebSocketConnected:
 		slog.Info("WebSocket connected", "host", c.wsClient.hubURL.Host)
-		c.ConnectionType = system.ConnectionTypeWebSocket
 		c.stopWsTicker()
 		_ = c.agent.StopServer()
 		c.isConnecting = false
 	case SSHConnected:
 		// stop new ws connection attempts
 		slog.Info("SSH connection established")
-		c.ConnectionType = system.ConnectionTypeSSH
 		c.stopWsTicker()
 		c.isConnecting = false
 	case Disconnected:
-		c.ConnectionType = system.ConnectionTypeNone
 		if c.isConnecting {
 			// Already handling reconnection, avoid duplicate attempts
 			return

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

@@ -1,100 +0,0 @@
-// Package deltatracker provides a tracker for calculating differences in numeric values over time.
-package deltatracker
-
-import (
-	"sync"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Numeric is a constraint that permits any integer or floating-point type.
-type Numeric interface {
-	constraints.Integer | constraints.Float
-}
-
-// DeltaTracker is a generic, thread-safe tracker for calculating differences
-// in numeric values over time.
-// K is the key type (e.g., int, string).
-// V is the value type (e.g., int, int64, float32, float64).
-type DeltaTracker[K comparable, V Numeric] struct {
-	sync.RWMutex
-	current  map[K]V
-	previous map[K]V
-}
-
-// NewDeltaTracker creates a new generic tracker.
-func NewDeltaTracker[K comparable, V Numeric]() *DeltaTracker[K, V] {
-	return &DeltaTracker[K, V]{
-		current:  make(map[K]V),
-		previous: make(map[K]V),
-	}
-}
-
-// Set records the current value for a given ID.
-func (t *DeltaTracker[K, V]) Set(id K, value V) {
-	t.Lock()
-	defer t.Unlock()
-	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()
-	defer t.RUnlock()
-
-	deltas := make(map[K]V)
-	for id, currentVal := range t.current {
-		if previousVal, ok := t.previous[id]; ok {
-			deltas[id] = currentVal - previousVal
-		} else {
-			deltas[id] = 0
-		}
-	}
-	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 {
-	t.RLock()
-	defer t.RUnlock()
-
-	currentVal, currentOk := t.current[id]
-	if !currentOk {
-		return 0
-	}
-
-	previousVal, previousOk := t.previous[id]
-	if !previousOk {
-		return 0
-	}
-
-	return currentVal - previousVal
-}
-
-// Cycle prepares the tracker for the next interval.
-func (t *DeltaTracker[K, V]) Cycle() {
-	t.Lock()
-	defer t.Unlock()
-	t.previous = t.current
-	t.current = make(map[K]V)
-}

agent/deltatracker/deltatracker_test.go

@@ -1,217 +0,0 @@
-package deltatracker
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func ExampleDeltaTracker() {
-	tracker := NewDeltaTracker[string, int]()
-	tracker.Set("key1", 10)
-	tracker.Set("key2", 20)
-	tracker.Cycle()
-	tracker.Set("key1", 15)
-	tracker.Set("key2", 30)
-	fmt.Println(tracker.Delta("key1"))
-	fmt.Println(tracker.Delta("key2"))
-	fmt.Println(tracker.Deltas())
-	// Output: 5
-	// 10
-	// map[key1:5 key2:10]
-}
-
-func TestNewDeltaTracker(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-	assert.NotNil(t, tracker)
-	assert.Empty(t, tracker.current)
-	assert.Empty(t, tracker.previous)
-}
-
-func TestSet(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-	tracker.Set("key1", 10)
-
-	tracker.RLock()
-	defer tracker.RUnlock()
-
-	assert.Equal(t, 10, tracker.current["key1"])
-}
-
-func TestDeltas(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-
-	// Test with no previous values
-	tracker.Set("key1", 10)
-	tracker.Set("key2", 20)
-
-	deltas := tracker.Deltas()
-	assert.Equal(t, 0, deltas["key1"])
-	assert.Equal(t, 0, deltas["key2"])
-
-	// Cycle to move current to previous
-	tracker.Cycle()
-
-	// Set new values and check deltas
-	tracker.Set("key1", 15) // Delta should be 5 (15-10)
-	tracker.Set("key2", 25) // Delta should be 5 (25-20)
-	tracker.Set("key3", 30) // New key, delta should be 0
-
-	deltas = tracker.Deltas()
-	assert.Equal(t, 5, deltas["key1"])
-	assert.Equal(t, 5, deltas["key2"])
-	assert.Equal(t, 0, deltas["key3"])
-}
-
-func TestCycle(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-
-	tracker.Set("key1", 10)
-	tracker.Set("key2", 20)
-
-	// Verify current has values
-	tracker.RLock()
-	assert.Equal(t, 10, tracker.current["key1"])
-	assert.Equal(t, 20, tracker.current["key2"])
-	assert.Empty(t, tracker.previous)
-	tracker.RUnlock()
-
-	tracker.Cycle()
-
-	// After cycle, previous should have the old current values
-	// and current should be empty
-	tracker.RLock()
-	assert.Empty(t, tracker.current)
-	assert.Equal(t, 10, tracker.previous["key1"])
-	assert.Equal(t, 20, tracker.previous["key2"])
-	tracker.RUnlock()
-}
-
-func TestCompleteWorkflow(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-
-	// First interval
-	tracker.Set("server1", 100)
-	tracker.Set("server2", 200)
-
-	// Get deltas for first interval (should be zero)
-	firstDeltas := tracker.Deltas()
-	assert.Equal(t, 0, firstDeltas["server1"])
-	assert.Equal(t, 0, firstDeltas["server2"])
-
-	// Cycle to next interval
-	tracker.Cycle()
-
-	// Second interval
-	tracker.Set("server1", 150) // Delta: 50
-	tracker.Set("server2", 180) // Delta: -20
-	tracker.Set("server3", 300) // New server, delta: 300
-
-	secondDeltas := tracker.Deltas()
-	assert.Equal(t, 50, secondDeltas["server1"])
-	assert.Equal(t, -20, secondDeltas["server2"])
-	assert.Equal(t, 0, secondDeltas["server3"])
-}
-
-func TestDeltaTrackerWithDifferentTypes(t *testing.T) {
-	// Test with int64
-	intTracker := NewDeltaTracker[string, int64]()
-	intTracker.Set("pid1", 1000)
-	intTracker.Cycle()
-	intTracker.Set("pid1", 1200)
-	intDeltas := intTracker.Deltas()
-	assert.Equal(t, int64(200), intDeltas["pid1"])
-
-	// Test with float64
-	floatTracker := NewDeltaTracker[string, float64]()
-	floatTracker.Set("cpu1", 1.5)
-	floatTracker.Cycle()
-	floatTracker.Set("cpu1", 2.7)
-	floatDeltas := floatTracker.Deltas()
-	assert.InDelta(t, 1.2, floatDeltas["cpu1"], 0.0001)
-
-	// Test with int keys
-	pidTracker := NewDeltaTracker[int, int64]()
-	pidTracker.Set(101, 20000)
-	pidTracker.Cycle()
-	pidTracker.Set(101, 22500)
-	pidDeltas := pidTracker.Deltas()
-	assert.Equal(t, int64(2500), pidDeltas[101])
-}
-
-func TestDelta(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-
-	// Test getting delta for non-existent key
-	result := tracker.Delta("nonexistent")
-	assert.Equal(t, 0, result)
-
-	// Test getting delta for key with no previous value
-	tracker.Set("key1", 10)
-	result = tracker.Delta("key1")
-	assert.Equal(t, 0, result)
-
-	// Cycle to move current to previous
-	tracker.Cycle()
-
-	// Test getting delta for key with previous value
-	tracker.Set("key1", 15)
-	result = tracker.Delta("key1")
-	assert.Equal(t, 5, result)
-
-	// Test getting delta for key that exists in previous but not current
-	result = tracker.Delta("key1")
-	assert.Equal(t, 5, result) // Should still return 5
-
-	// Test getting delta for key that exists in current but not previous
-	tracker.Set("key2", 20)
-	result = tracker.Delta("key2")
-	assert.Equal(t, 0, result)
-}
-
-func TestDeltaWithDifferentTypes(t *testing.T) {
-	// Test with int64
-	intTracker := NewDeltaTracker[string, int64]()
-	intTracker.Set("pid1", 1000)
-	intTracker.Cycle()
-	intTracker.Set("pid1", 1200)
-	result := intTracker.Delta("pid1")
-	assert.Equal(t, int64(200), result)
-
-	// Test with float64
-	floatTracker := NewDeltaTracker[string, float64]()
-	floatTracker.Set("cpu1", 1.5)
-	floatTracker.Cycle()
-	floatTracker.Set("cpu1", 2.7)
-	floatResult := floatTracker.Delta("cpu1")
-	assert.InDelta(t, 1.2, floatResult, 0.0001)
-
-	// Test with int keys
-	pidTracker := NewDeltaTracker[int, int64]()
-	pidTracker.Set(101, 20000)
-	pidTracker.Cycle()
-	pidTracker.Set(101, 22500)
-	pidResult := pidTracker.Delta(101)
-	assert.Equal(t, int64(2500), pidResult)
-}
-
-func TestDeltaConcurrentAccess(t *testing.T) {
-	tracker := NewDeltaTracker[string, int]()
-
-	// Set initial values
-	tracker.Set("key1", 10)
-	tracker.Set("key2", 20)
-	tracker.Cycle()
-
-	// Set new values
-	tracker.Set("key1", 15)
-	tracker.Set("key2", 25)
-
-	// Test concurrent access safety
-	result1 := tracker.Delta("key1")
-	result2 := tracker.Delta("key2")
-
-	assert.Equal(t, 5, result1)
-	assert.Equal(t, 5, result2)
-}

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}
+			a.fsStats[key] = &system.FsStats{Root: root, Mountpoint: mountpoint}
-			if len(customName) > 0 && customName[0] != "" {
-				fsStats.Name = customName[0]
-			}
-			a.fsStats[key] = fsStats
 		}
 	}
 
@@ -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, ",") {
+		for _, fs := range strings.Split(extraFilesystems, ",") {
-			// Parse custom name from format: device__customname
-			fs, customName := parseFilesystemEntry(fsEntry)
-
 			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(p.Device, p.Mountpoint, false)
-			addFsStat(device, p.Mountpoint, false, customName)
 		}
 	}
 
@@ -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(folder.Name(), mountpoint, false)
-					addFsStat(device, mountpoint, false, customName)
 				}
 			}
 		}
@@ -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,35 +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
-	// Maximum size of a single log frame (1MB) to prevent memory exhaustion
-	// A single log line larger than 1MB is likely an error or misconfiguration
-	maxLogFrameSize = 1024 * 1024
-	// Maximum total log content size (5MB) to prevent memory exhaustion
-	// This provides a reasonable limit for network transfer and browser rendering
-	maxTotalLogSize = 5 * 1024 * 1024
-)
-
 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)
@@ -53,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
@@ -94,8 +62,8 @@ func (d *dockerManager) dequeue() {
 	}
 }
 
-// Returns stats for all running containers with cache-time-aware delta tracking
+// Returns stats for all running containers
-func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats, error) {
+func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 	resp, err := dm.client.Get("http://localhost/containers/json")
 	if err != nil {
 		return nil, err
@@ -119,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)
@@ -129,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()
@@ -139,7 +108,7 @@ func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats,
 				failedContainers = append(failedContainers, ctr)
 				dm.containerStatsMutex.Unlock()
 			}
-		}(ctr)
+		}()
 	}
 
 	dm.wg.Wait()
@@ -150,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 {
+				err = dm.updateContainerStats(ctr)
-					slog.Error("Error getting container stats", "err", err2)
+				if err != nil {
+					slog.Error("Error getting container stats", "err", err)
 				}
-			}(ctr)
+			}()
 		}
 		dm.wg.Wait()
 	}
@@ -170,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
+// Updates stats for individual container
-func (dm *dockerManager) initializeCpuTracking(cacheTimeMs uint16) {
+func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
-	// 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 {
 	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()
@@ -362,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
+	// calculate cpu and memory stats
-	dm.initializeCpuTracking(cacheTimeMs)
+	var usedMemory uint64
-
-	// Get previous CPU values
-	prevCpuContainer, prevCpuSystem := dm.getCpuPreviousValues(cacheTimeMs, ctr.IdShort)
-
-	// Calculate CPU percentage based on platform
 	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]
+		usedMemory = res.MemoryStats.PrivateWorkingSet
-		cpuPct = res.CalculateCpuPercentWindows(prevCpuContainer, prevRead)
+		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
+	if cpuPct > 100 {
-	usedMemory, err := calculateMemoryUsage(res, dm.isWindows)
+		return fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
-	if err != nil {
-		return fmt.Errorf("%s - %w - see https://github.com/henrygd/beszel/issues/144", name, err)
 	}
 
-	// Store current CPU stats for next calculation
+	// network
-	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
 	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
+	stats.Cpu = twoDecimals(cpuPct)
-	updateContainerStatsValues(stats, cpuPct, usedMemory, sent_delta, recv_delta, res.Read)
+	stats.Mem = bytesToMegabytes(float64(usedMemory))
-	// store per-cache-time read time for Windows CPU percent calc
+	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
-	dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort] = res.Read
+	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
+	stats.PrevReadTime = res.Read
 
 	return nil
 }
@@ -439,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
@@ -487,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 {
@@ -512,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
@@ -528,49 +317,28 @@ func newDockerManager(a *Agent) *dockerManager {
 		return manager
 	}
 
-	// this can take up to 5 seconds with retry, so run in goroutine
+	// Check docker version
-	go manager.checkDockerVersion()
+	// (versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch)
-
-	// 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
 	var versionInfo struct {
 		Version string `json:"Version"`
 	}
-	const versionMaxTries = 2
+	resp, err := manager.client.Get("http://localhost/version")
-	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)
-		}
-	}
 	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.
@@ -600,122 +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)
-	totalBytesRead := 0
-
-	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
-		}
-
-		// Prevent memory exhaustion from excessively large frames
-		if frameLen > maxLogFrameSize {
-			return fmt.Errorf("log frame size (%d) exceeds maximum (%d)", frameLen, maxLogFrameSize)
-		}
-
-		// Check if reading this frame would exceed total log size limit
-		if totalBytesRead+int(frameLen) > maxTotalLogSize {
-			// Read and discard remaining data to avoid blocking
-			_, _ = io.Copy(io.Discard, io.LimitReader(reader, int64(frameLen)))
-			slog.Debug("Truncating logs: limit reached", "read", totalBytesRead, "limit", maxTotalLogSize)
-			return nil
-		}
-
-		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])
-		totalBytesRead += int(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/gpu.go

@@ -5,7 +5,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"maps"
 	"os/exec"
 	"regexp"
 	"strconv"
@@ -28,10 +27,13 @@ const (
 	nvidiaSmiInterval  string        = "4"    // in seconds
 	tegraStatsInterval string        = "3700" // in milliseconds
 	rocmSmiInterval    time.Duration = 4300 * time.Millisecond
+
 	// Command retry and timeout constants
 	retryWaitTime     time.Duration = 5 * time.Second
 	maxFailureRetries int           = 5
 
+	cmdBufferSize uint16 = 10 * 1024
+
 	// Unit Conversions
 	mebibytesInAMegabyte float64 = 1.024  // nvidia-smi reports memory in MiB
 	milliwattsInAWatt    float64 = 1000.0 // tegrastats reports power in mW
@@ -43,23 +45,7 @@ type GPUManager struct {
 	nvidiaSmi  bool
 	rocmSmi    bool
 	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
@@ -80,7 +66,6 @@ type gpuCollector struct {
 	cmdArgs []string
 	parse   func([]byte) bool // returns true if valid data was found
 	buf     []byte
-	bufSize uint16
 }
 
 var errNoValidData = fmt.Errorf("no valid GPU data found") // Error for missing data
@@ -114,7 +99,7 @@ func (c *gpuCollector) collect() error {
 
 	scanner := bufio.NewScanner(stdout)
 	if c.buf == nil {
-		c.buf = make([]byte, 0, c.bufSize)
+		c.buf = make([]byte, 0, cmdBufferSize)
 	}
 	scanner.Buffer(c.buf, bufio.MaxScanTokenSize)
 
@@ -245,21 +230,36 @@ func (gm *GPUManager) parseAmdData(output []byte) bool {
 	return true
 }
 
-// GetCurrentData returns GPU utilization data averaged since the last call with this cacheKey
+// sums and resets the current GPU utilization data since the last update
-func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData {
+func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
 	gm.Lock()
 	defer gm.Unlock()
 
-	gm.initializeSnapshots(cacheKey)
+	// check for GPUs with the same name
-	nameCounts := gm.countGPUNames()
+	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)
+		gpuAvg := *gpu
-		gm.updateInstantaneousValues(&gpuAvg, gpu)
-		gm.storeSnapshot(id, gpu, cacheKey)
 
-		// Append id to name if there are multiple GPUs with the same name
+		gpuAvg.Temperature = twoDecimals(gpu.Temperature)
+		gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
+		gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
+
+		// avoid division by zero
+		if gpu.Count > 0 {
+			gpuAvg.Usage = twoDecimals(gpu.Usage / gpu.Count)
+			gpuAvg.Power = twoDecimals(gpu.Power / gpu.Count)
+		}
+
+		// reset accumulators in the original
+		gpu.Usage, gpu.Power, gpu.Count = 0, 0, 0
+
+		// 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 +269,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
@@ -393,37 +284,18 @@ func (gm *GPUManager) detectGPUs() error {
 		gm.tegrastats = true
 		gm.nvidiaSmi = false
 	}
-	if _, err := exec.LookPath(intelGpuStatsCmd); err == nil {
+	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats {
-		gm.intelGpuStats = true
-	}
-	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats || gm.intelGpuStats {
 		return nil
 	}
-	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, tegrastats, or intel_gpu_top")
+	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, or tegrastats")
 }
 
 // startCollector starts the appropriate GPU data collector based on the command
 func (gm *GPUManager) startCollector(command string) {
 	collector := gpuCollector{
 		name: command,
-		bufSize: 10 * 1024,
 	}
 	switch command {
-	case intelGpuStatsCmd:
-		go func() {
-			failures := 0
-			for {
-				if err := gm.collectIntelStats(); err != nil {
-					failures++
-					if failures > maxFailureRetries {
-						break
-					}
-					slog.Warn("Error collecting Intel GPU data; see https://beszel.dev/guide/gpu", "err", err)
-					time.Sleep(retryWaitTime)
-					continue
-				}
-			}
-		}()
 	case nvidiaSmiCmd:
 		collector.cmdArgs = []string{
 			"-l", nvidiaSmiInterval,
@@ -457,9 +329,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
@@ -475,9 +344,6 @@ func NewGPUManager() (*GPUManager, error) {
 	if gm.tegrastats {
 		gm.startCollector(tegraStatsCmd)
 	}
-	if gm.intelGpuStats {
-		gm.startCollector(intelGpuStatsCmd)
-	}
 
 	return &gm, nil
 }

agent/gpu_intel.go

@@ -1,199 +0,0 @@
-package agent
-
-import (
-	"bufio"
-	"io"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-const (
-	intelGpuStatsCmd      string = "intel_gpu_top"
-	intelGpuStatsInterval string = "3300" // in milliseconds
-)
-
-type intelGpuStats struct {
-	PowerGPU float64
-	PowerPkg float64
-	Engines  map[string]float64
-}
-
-// updateIntelFromStats updates aggregated GPU data from a single intelGpuStats sample
-func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {
-	gm.Lock()
-	defer gm.Unlock()
-
-	// only one gpu for now - cmd doesn't provide all by default
-	gpuData, ok := gm.GpuDataMap["0"]
-	if !ok {
-		gpuData = &system.GPUData{Name: "GPU", Engines: make(map[string]float64)}
-		gm.GpuDataMap["0"] = gpuData
-	}
-
-	gpuData.Power += sample.PowerGPU
-	gpuData.PowerPkg += sample.PowerPkg
-
-	if gpuData.Engines == nil {
-		gpuData.Engines = make(map[string]float64, len(sample.Engines))
-	}
-	for name, engine := range sample.Engines {
-		gpuData.Engines[name] += engine
-	}
-
-	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
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		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
-		}
-	}()
-
-	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
-
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" {
-			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)
-		if err != nil {
-			return err
-		}
-		hadDataRow = true
-		gm.updateIntelFromStats(&sample)
-	}
-	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
-}

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()
-		result := gm.GetCurrentData(cacheKey)
 
 		// 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)
+		// Verify that accumulators in the original map are reset
-		assert.EqualValues(t, 2, gm.GpuDataMap["0"].Count, "GPU 0 Count should remain at 2")
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Count, "GPU 0 Count should be reset")
-		assert.EqualValues(t, 100, gm.GpuDataMap["0"].Usage, "GPU 0 Usage should remain at 100")
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Usage, "GPU 0 Usage should be reset")
-		assert.Equal(t, 200.0, gm.GpuDataMap["0"].Power, "GPU 0 Power should remain at 200")
+		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Power, "GPU 0 Power should be reset")
-		assert.Equal(t, 1.0, gm.GpuDataMap["1"].Count, "GPU 1 Count should remain at 1")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Count, "GPU 1 Count should be reset")
-		assert.Equal(t, 30.0, gm.GpuDataMap["1"].Usage, "GPU 1 Usage should remain at 30")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Usage, "GPU 1 Usage should be reset")
-		assert.Equal(t, 60.0, gm.GpuDataMap["1"].Power, "GPU 1 Power should remain at 60")
+		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Power, "GPU 1 Power should be reset")
-
-		// 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)
 	})
 
 	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
+		// Verify reset count
-		assert.EqualValues(t, 0, gm.GpuDataMap["0"].Count)
+		assert.Equal(t, float64(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")
 	})
 }
 
@@ -1289,17 +756,16 @@ func TestAccumulation(t *testing.T) {
 					continue
 				}
 
-				assert.EqualValues(t, expected.temperature, gpu.Temperature, "Temperature should match")
+				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature should match")
-				assert.EqualValues(t, expected.memoryUsed, gpu.MemoryUsed, "Memory used should match")
+				assert.InDelta(t, expected.memoryUsed, gpu.MemoryUsed, 0.01, "Memory used should match")
-				assert.EqualValues(t, expected.memoryTotal, gpu.MemoryTotal, "Memory total should match")
+				assert.InDelta(t, expected.memoryTotal, gpu.MemoryTotal, 0.01, "Memory total should match")
-				assert.EqualValues(t, expected.usage, gpu.Usage, "Usage should match")
+				assert.InDelta(t, expected.usage, gpu.Usage, 0.01, "Usage should match")
-				assert.EqualValues(t, expected.power, gpu.Power, "Power 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()
-			result := gm.GetCurrentData(cacheKey)
 			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,320 +773,22 @@ func TestAccumulation(t *testing.T) {
 					continue
 				}
 
-				assert.EqualValues(t, expected.temperature, gpu.Temperature, "Temperature in GetCurrentData should match")
+				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature in GetCurrentData should match")
-				assert.EqualValues(t, expected.avgUsage, gpu.Usage, "Average usage in GetCurrentData should match")
+				assert.InDelta(t, expected.avgUsage, gpu.Usage, 0.01, "Average usage in GetCurrentData should match")
-				assert.EqualValues(t, expected.avgPower, gpu.Power, "Average power 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)
+			// Verify that accumulators in the original map are reset
-			for id, expected := range tt.expectedValues {
+			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.Equal(t, float64(0), gpu.Count, "Count should be reset for GPU ID %s", id)
-				assert.EqualValues(t, expected.usage, gpu.Usage, "Usage should remain at accumulated value for GPU ID %s", id)
+				assert.Equal(t, float64(0), gpu.Usage, "Usage should be reset 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.Power, "Power should be reset for GPU ID %s", id)
 			}
 		})
 	}
 }
-
-func TestIntelUpdateFromStats(t *testing.T) {
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-
-	// First sample with power and two engines
-	sample1 := intelGpuStats{
-		PowerGPU: 10.5,
-		Engines: map[string]float64{
-			"Render/3D": 20.0,
-			"Video":     5.0,
-		},
-	}
-
-	ok := gm.updateIntelFromStats(&sample1)
-	assert.True(t, ok)
-
-	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.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,
-		},
-	}
-	// zero power should not increment power accumulator
-
-	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.Equal(t, float64(2), gpu.Count)
-}
-
-func TestIntelCollectorStreaming(t *testing.T) {
-	// Save and override PATH
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	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
-	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"`
-	if err := os.WriteFile(scriptPath, []byte(script), 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-
-	// Run the collector once; it should read four samples but skip the first 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)
-		})
-	}
-}

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

@@ -1,245 +1,60 @@
 package agent
 
 import (
-	"fmt"
 	"log/slog"
-	"path"
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel/agent/deltatracker"
 	"github.com/henrygd/beszel/internal/entities/system"
+
 	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
-}
-
-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) {
-	// 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)
+	// reset network I/O stats per interface
+	a.netIoStats = make(map[string]system.NetIoStats, 0)
 
-	// parse NICS env var for whitelist / blacklist
+	// map of network interface names passed in via NICS env var
-	nicsEnvVal, nicsEnvExists := GetEnv("NICS")
+	var nicsMap map[string]struct{}
-	var nicCfg *NicConfig
+	nics, nicsEnvExists := GetEnv("NICS")
 	if nicsEnvExists {
-		nicCfg = newNicConfig(nicsEnvVal)
+		nicsMap = make(map[string]struct{}, 0)
+		for nic := range strings.SplitSeq(nics, ",") {
+			nicsMap[nic] = struct{}{}
+		}
 	}
 
-	// get current network I/O stats and record valid interfaces
+	// get intial network I/O stats
 	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		now := time.Now()
+
 		for _, v := range netIO {
-			if nicsEnvExists && !isValidNic(v.Name, nicCfg) {
+			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)
 			// store as a valid network interface
 			a.netInterfaces[v.Name] = struct{}{}
+			// initialize per-interface stats
+			a.netIoStats[v.Name] = system.NetIoStats{
+				BytesRecv: v.BytesRecv,
+				BytesSent: v.BytesSent,
+				Time:      now,
+				Name:      v.Name,
 			}
 		}
-
-	// 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)
-		// maybe refactor this in the future to not cache interface names at all so we
-		// 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)
-		for _, v := range netIO {
-			if _, exists := a.netInterfaces[v.Name]; !exists {
-				continue
-			}
-			slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
-		}
-		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
 }
 
 func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
@@ -249,7 +64,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

@@ -13,7 +13,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/blang/semver"
@@ -128,79 +127,15 @@ func (a *Agent) handleSession(s ssh.Session) {
 
 	hubVersion := a.getHubVersion(sessionID, sessionCtx)
 
-	// Legacy one-shot behavior for older hubs
+	stats := a.gatherStats(sessionID)
-	if hubVersion.LT(beszel.MinVersionAgentResponse) {
-		if err := a.handleLegacyStats(s, hubVersion); err != nil {
-			slog.Error("Error encoding stats", "err", err)
-			s.Exit(1)
-			return
-		}
-	}
 
-	var req common.HubRequest[cbor.RawMessage]
+	err := a.writeToSession(s, stats, hubVersion)
-	if err := cbor.NewDecoder(s).Decode(&req); err != nil {
+	if err != nil {
-		// Fallback to legacy one-shot if the first decode fails
+		slog.Error("Error encoding stats", "err", err, "stats", stats)
-		if err2 := a.handleLegacyStats(s, hubVersion); err2 != nil {
-			slog.Error("Error encoding stats (fallback)", "err", err2)
 		s.Exit(1)
-			return
+	} else {
-		}
-		s.Exit(0)
-		return
-	}
-	if err := a.handleSSHRequest(s, &req); err != nil {
-		slog.Error("SSH request handling failed", "err", err)
-		s.Exit(1)
-		return
-	}
 		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
-		case map[string]smart.SmartData:
-			response.SmartData = 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.Debug("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.Debug("smartctl collect failed, 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.Debug("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.Debug("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.Debug("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("smartctl not found")
-}
-
-// 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,13 @@ 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"
+	psutilNet "github.com/shirou/gopsutil/v4/net"
 )
 
-// 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
@@ -37,7 +32,7 @@ func (a *Agent) initializeSystemInfo() {
 		a.systemInfo.KernelVersion = version
 		a.systemInfo.Os = system.Darwin
 	} else if strings.Contains(platform, "indows") {
-		a.systemInfo.KernelVersion = fmt.Sprintf("%s %s", strings.Replace(platform, "Microsoft ", "", 1), version)
+		a.systemInfo.KernelVersion = strings.Replace(platform, "Microsoft ", "", 1) + " " + version
 		a.systemInfo.Os = system.Windows
 	} else if platform == "freebsd" {
 		a.systemInfo.Os = system.Freebsd
@@ -74,21 +69,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
+	systemStats := system.Stats{}
 
 	// battery
-	if batteryPercent, batteryState, err := battery.GetBatteryStats(); err == nil {
+	if battery.HasReadableBattery() {
-		systemStats.Battery[0] = batteryPercent
+		systemStats.Battery[0], systemStats.Battery[1], _ = battery.GetBatteryStats()
-		systemStats.Battery[1] = batteryState
 	}
 
 	// cpu percent
-	cpuPercent, err := getCpuPercent(cacheTimeMs)
+	cpuPct, err := cpu.Percent(0, false)
-	if err == nil {
+	if err != nil {
-		systemStats.Cpu = twoDecimals(cpuPercent)
-	} else {
 		slog.Error("Error getting cpu percent", "err", err)
+	} else if len(cpuPct) > 0 {
+		systemStats.Cpu = twoDecimals(cpuPct[0])
 	}
 
 	// load average
@@ -107,22 +101,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.Total - v.Free - v.Used
-		cacheBuff := v.Cached + v.Buffers - v.Shared
+		// htop memory calculation overrides
-		if cacheBuff <= 0 {
-			cacheBuff = max(v.Total-v.Free-v.Used, 0)
-		}
-		// htop memory calculation overrides (likely outdated as of mid 2025)
 		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 +124,136 @@ 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)
+	// disk i/o
-	a.updateDiskIo(cacheTimeMs, &systemStats)
+	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)
+	// network stats
-	a.updateNetworkStats(cacheTimeMs, &systemStats)
+	if len(a.netInterfaces) == 0 {
+		// if no network interfaces, initialize again
+		// this is a fix if agent started before network is online (#466)
+		a.initializeNetIoStats()
+	}
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		now := time.Now()
+
+		// pre-allocate maps with known capacity
+		interfaceCount := len(a.netInterfaces)
+		if systemStats.NetworkInterfaces == nil || len(systemStats.NetworkInterfaces) != interfaceCount {
+			systemStats.NetworkInterfaces = make(map[string]system.NetworkInterfaceStats, interfaceCount)
+		}
+
+		var totalSent, totalRecv float64
+
+		// single pass through interfaces
+		for _, v := range netIO {
+			// skip if not in valid network interfaces list
+			if _, exists := a.netInterfaces[v.Name]; !exists {
+				continue
+			}
+
+			// get previous stats for this interface
+			prevStats, exists := a.netIoStats[v.Name]
+			var networkSentPs, networkRecvPs float64
+
+			if exists {
+				secondsElapsed := time.Since(prevStats.Time).Seconds()
+				if secondsElapsed > 0 {
+					// direct calculation to MB/s, avoiding intermediate bytes/sec
+					networkSentPs = bytesToMegabytes(float64(v.BytesSent-prevStats.BytesSent) / secondsElapsed)
+					networkRecvPs = bytesToMegabytes(float64(v.BytesRecv-prevStats.BytesRecv) / secondsElapsed)
+				}
+			}
+
+			// accumulate totals
+			totalSent += networkSentPs
+			totalRecv += networkRecvPs
+
+			// store per-interface stats
+			systemStats.NetworkInterfaces[v.Name] = system.NetworkInterfaceStats{
+				NetworkSent:    networkSentPs,
+				NetworkRecv:    networkRecvPs,
+				TotalBytesSent: v.BytesSent,
+				TotalBytesRecv: v.BytesRecv,
+			}
+
+			// update previous stats (reuse existing struct if possible)
+			if prevStats.Name == v.Name {
+				prevStats.BytesRecv = v.BytesRecv
+				prevStats.BytesSent = v.BytesSent
+				prevStats.PacketsSent = v.PacketsSent
+				prevStats.PacketsRecv = v.PacketsRecv
+				prevStats.Time = now
+				a.netIoStats[v.Name] = prevStats
+			} else {
+				a.netIoStats[v.Name] = system.NetIoStats{
+					BytesRecv:   v.BytesRecv,
+					BytesSent:   v.BytesSent,
+					PacketsSent: v.PacketsSent,
+					PacketsRecv: v.PacketsRecv,
+					Time:        now,
+					Name:        v.Name,
+				}
+			}
+		}
+
+		// add check for issue (#150) where sent is a massive number
+		if totalSent > 10_000 || totalRecv > 10_000 {
+			slog.Warn("Invalid net stats. Resetting.", "sent", totalSent, "recv", totalRecv)
+			// reset network I/O stats
+			a.initializeNetIoStats()
+		} else {
+			systemStats.NetworkSent = totalSent
+			systemStats.NetworkRecv = totalRecv
+		}
+	}
+
+	// connection counts
+	a.updateConnectionCounts(&systemStats)
 
 	// temperatures
 	// TODO: maybe refactor to methods on systemStats
@@ -155,7 +264,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
@@ -184,7 +293,6 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	}
 
 	// update base system info
-	a.systemInfo.ConnectionType = a.connectionManager.ConnectionType
 	a.systemInfo.Cpu = systemStats.Cpu
 	a.systemInfo.LoadAvg = systemStats.LoadAvg
 	// TODO: remove these in future release in favor of load avg array
@@ -194,14 +302,109 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	a.systemInfo.MemPct = systemStats.MemPct
 	a.systemInfo.DiskPct = systemStats.DiskPct
 	a.systemInfo.Uptime, _ = host.Uptime()
-	// TODO: in future release, remove MB bandwidth values in favor of bytes
+
-	a.systemInfo.Bandwidth = twoDecimals(systemStats.NetworkSent + systemStats.NetworkRecv)
+	// Sum all per-interface network sent/recv and assign to systemInfo
-	a.systemInfo.BandwidthBytes = systemStats.Bandwidth[0] + systemStats.Bandwidth[1]
+	var totalSent, totalRecv float64
+	for _, iface := range systemStats.NetworkInterfaces {
+		totalSent += iface.NetworkSent
+		totalRecv += iface.NetworkRecv
+	}
+	a.systemInfo.NetworkSent = twoDecimals(totalSent)
+	a.systemInfo.NetworkRecv = twoDecimals(totalRecv)
 	slog.Debug("sysinfo", "data", a.systemInfo)
 
 	return systemStats
 }
 
+func (a *Agent) updateConnectionCounts(systemStats *system.Stats) {
+	// Get IPv4 connections
+	connectionsIPv4, err := psutilNet.Connections("inet")
+	if err != nil {
+		slog.Debug("Failed to get IPv4 connection stats", "err", err)
+		return
+	}
+
+	// Get IPv6 connections
+	connectionsIPv6, err := psutilNet.Connections("inet6")
+	if err != nil {
+		slog.Debug("Failed to get IPv6 connection stats", "err", err)
+		// Continue with IPv4 only if IPv6 fails
+	}
+
+	// Initialize Nets map if needed
+	if systemStats.Nets == nil {
+		systemStats.Nets = make(map[string]float64)
+	}
+
+	// Count IPv4 connection states
+	connStatsIPv4 := map[string]int{
+		"established": 0,
+		"listen":      0,
+		"time_wait":   0,
+		"close_wait":  0,
+		"syn_recv":    0,
+	}
+
+	for _, conn := range connectionsIPv4 {
+		// Only count TCP connections (Type 1 = SOCK_STREAM)
+		if conn.Type == 1 {
+			switch strings.ToUpper(conn.Status) {
+			case "ESTABLISHED":
+				connStatsIPv4["established"]++
+			case "LISTEN":
+				connStatsIPv4["listen"]++
+			case "TIME_WAIT":
+				connStatsIPv4["time_wait"]++
+			case "CLOSE_WAIT":
+				connStatsIPv4["close_wait"]++
+			case "SYN_RECV":
+				connStatsIPv4["syn_recv"]++
+			}
+		}
+	}
+
+	// Count IPv6 connection states
+	connStatsIPv6 := map[string]int{
+		"established": 0,
+		"listen":      0,
+		"time_wait":   0,
+		"close_wait":  0,
+		"syn_recv":    0,
+	}
+
+	for _, conn := range connectionsIPv6 {
+		// Only count TCP connections (Type 1 = SOCK_STREAM)
+		if conn.Type == 1 {
+			switch strings.ToUpper(conn.Status) {
+			case "ESTABLISHED":
+				connStatsIPv6["established"]++
+			case "LISTEN":
+				connStatsIPv6["listen"]++
+			case "TIME_WAIT":
+				connStatsIPv6["time_wait"]++
+			case "CLOSE_WAIT":
+				connStatsIPv6["close_wait"]++
+			case "SYN_RECV":
+				connStatsIPv6["syn_recv"]++
+			}
+		}
+	}
+
+	// Add IPv4 connection counts to Nets
+	systemStats.Nets["conn_established"] = float64(connStatsIPv4["established"])
+	systemStats.Nets["conn_listen"] = float64(connStatsIPv4["listen"])
+	systemStats.Nets["conn_timewait"] = float64(connStatsIPv4["time_wait"])
+	systemStats.Nets["conn_closewait"] = float64(connStatsIPv4["close_wait"])
+	systemStats.Nets["conn_synrecv"] = float64(connStatsIPv4["syn_recv"])
+
+	// Add IPv6 connection counts to Nets
+	systemStats.Nets["conn6_established"] = float64(connStatsIPv6["established"])
+	systemStats.Nets["conn6_listen"] = float64(connStatsIPv6["listen"])
+	systemStats.Nets["conn6_timewait"] = float64(connStatsIPv6["time_wait"])
+	systemStats.Nets["conn6_closewait"] = float64(connStatsIPv6["close_wait"])
+	systemStats.Nets["conn6_synrecv"] = float64(connStatsIPv6["syn_recv"])
+}
+
 // Returns the size of the ZFS ARC memory cache in bytes
 func getARCSize() (uint64, error) {
 	file, err := os.Open("/proc/spl/kstat/zfs/arcstats")

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(w.cmd, "running", "beszel-agent").Run(); err != nil {
-	if err := exec.Command("/etc/init.d/beszel-agent", "running").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.15.0"
+	Version = "0.12.7"
 	// 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

@@ -1,6 +1,9 @@
 module github.com/henrygd/beszel
 
-go 1.25.3
+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.8.8
 
 require (
 	github.com/blang/semver v3.5.1+incompatible
@@ -9,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.11.0
+	github.com/nicholas-fedor/shoutrrr v0.8.17
 	github.com/pocketbase/dbx v1.11.0
-	github.com/pocketbase/pocketbase v0.31.0
+	github.com/pocketbase/pocketbase v0.29.3
-	github.com/shirou/gopsutil/v4 v4.25.9
+	github.com/shirou/gopsutil/v4 v4.25.6
-	github.com/spf13/cast v1.10.0
+	github.com/spf13/cast v1.9.2
-	github.com/spf13/cobra v1.10.1
+	github.com/spf13/cobra v1.9.1
-	github.com/spf13/pflag v1.0.10
+	github.com/spf13/pflag v1.0.7
-	github.com/stretchr/testify v1.11.1
+	github.com/stretchr/testify v1.11.0
-	golang.org/x/crypto v0.43.0
+	golang.org/x/crypto v0.41.0
-	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546
+	golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -30,20 +33,20 @@ 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
 	github.com/go-sql-driver/mysql v1.9.1 // indirect
 	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // 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 v1.0.0 // indirect
+	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
@@ -51,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.32.0 // indirect
+	golang.org/x/image v0.30.0 // indirect
-	golang.org/x/net v0.46.0 // indirect
+	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/oauth2 v0.32.0 // indirect
+	golang.org/x/oauth2 v0.30.0 // indirect
-	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
-	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/term v0.36.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
-	golang.org/x/text v0.30.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	howett.net/plist v1.0.1 // indirect
-	modernc.org/libc v1.66.10 // 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.1 // 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.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
-github.com/ebitengine/purego v0.9.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+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.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
-github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+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.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+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,44 +52,44 @@ 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-20251007162407-5df77e3f7d1d h1:KJIErDwbSHjnp/SGzE5ed8Aol7JsKiI5X7yWKAtzhM0=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
-github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
+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.0 h1:BvhqnH0JAYbNudL2GMJKgOHe2CtKlzJ/5rWKyp+hc2k=
-github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
+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.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 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-20251013123823-9fd1530e3ec3 h1:PwQumkgq4/acIiZhtifTV5OUqqiP82UAl0h87xj/l9k=
+github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d h1:vFzYZc8yji+9DmNRhpEbs8VBK4CgV/DPfGzeVJSSp/8=
-github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
+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=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
-github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.11.0 h1:hAMv2uM8OfFXkMHVP977elkP3Wgw5/YpVX5GxXQwiWA=
+github.com/nicholas-fedor/shoutrrr v0.8.8 h1:F/oyoatWK5cbHPPgkjRZrA0262TP7KWuUQz9KskRtR8=
-github.com/nicholas-fedor/shoutrrr v0.11.0/go.mod h1:0kRF9ral22xUn/0BlxfhLQUeJDTySCPsuNvaclyagb4=
+github.com/nicholas-fedor/shoutrrr v0.8.8/go.mod h1:T30Y+eoZFEjDk4HtOItcHQioZSOe3Z6a6aNfSz6jc5c=
-github.com/onsi/ginkgo/v2 v2.27.1 h1:0LJC8MpUSQnfnp4n/3W3GdlmJP3ENGF0ZPzjQGLPP7s=
+github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus=
-github.com/onsi/ginkgo/v2 v2.27.1/go.mod h1:wmy3vCqiBjirARfVhAqFpYt8uvX0yaFe+GudAqqcCqA=
+github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8=
-github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
+github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
-github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
+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.31.0 h1:JaOtSDytdA+a0r4689Mrjda4rmq+BaHgEJkPeOIydms=
+github.com/pocketbase/pocketbase v0.29.3 h1:Mj8o5awsbVJIdIoTuQNhfC2oL/c4aImQ3RyfFZlzFVg=
-github.com/pocketbase/pocketbase v0.31.0/go.mod h1:p4a83n+DlBcTvvqhC7QDy0KDmQ2la2c6dgxdIBWwKiE=
+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.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
-github.com/shirou/gopsutil/v4 v4.25.9/go.mod h1:gxIxoC+7nQRwUl/xNhutXlD8lq+jxTgpIkEf3rADHL8=
+github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
+github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
-github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
-github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+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.0 h1:ib4sjIrwZKxE5u/Japgo/7SJV3PvgjGiRNAvTVGqQl8=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+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,65 +120,63 @@ 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.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
+golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b h1:DXr+pvt3nC887026GRP39Ej11UATqWDmWuS99x26cD0=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=
+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.32.0 h1:6lZQWq75h7L5IWNk0r+SCpUJ6tUVd3v4ZHnbRKLkUDQ=
+golang.org/x/image v0.30.0 h1:jD5RhkmVAnjqaCUXfbGBrn3lpxbknfN9w2UhHHU+5B4=
-golang.org/x/image v0.32.0/go.mod h1:/R37rrQmKXtO6tYXAjtDLwQgFLHmhW+V6ayXlxzP2Pc=
+golang.org/x/image v0.30.0/go.mod h1:SAEUTxCCMWSrJcCy/4HwavEsfZZJlYxeHLc6tTiAe/c=
-golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
-golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
+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.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
-golang.org/x/oauth2 v0.32.0 h1:jsCblLleRMDrxMN29H3z/k1KliIvpLgCkE6R8FXXNgY=
+golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
-golang.org/x/oauth2 v0.32.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
+golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+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.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
-golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
+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.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
+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.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
-golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
+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.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+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-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 howett.net/plist v1.0.1 h1:37GdZ8tP09Q35o9ych3ehygcsL+HqKSwzctveSlarvM=
 howett.net/plist v1.0.1/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
-modernc.org/cc/v4 v4.26.5 h1:xM3bX7Mve6G8K8b+T11ReenJOT+BmVqQj0FY5T4+5Y4=
+modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM=
-modernc.org/cc/v4 v4.26.5/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/cc/v4 v4.26.2/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
-modernc.org/ccgo/v4 v4.28.1 h1:wPKYn5EC/mYTqBO373jKjvX2n+3+aK7+sICCv4Fjy1A=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
-modernc.org/ccgo/v4 v4.28.1/go.mod h1:uD+4RnfrVgE6ec9NGguUNdhqzNIeeomeXf6CL0GTE5Q=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
-modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA=
+modernc.org/fileutil v1.3.8 h1:qtzNm7ED75pd1C7WgAGcK4edm4fvhtBsEiI/0NQ54YM=
-modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/fileutil v1.3.8/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
 modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
+modernc.org/libc v1.66.3 h1:cfCbjTUcdsKyyZZfEUKfoHcP3S0Wkvz3jgSzByEWVCQ=
-modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
+modernc.org/libc v1.66.3/go.mod h1:XD9zO8kt59cANKvHPXpx7yS2ELPheAey0vjIuZOhOU8=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
@@ -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.1 h1:H+/wGFzuSCIEVCvXYVHX5RQglwhMOvtHSv+VtidL2r4=
+modernc.org/sqlite v1.38.2 h1:Aclu7+tgjgcQVShZqim41Bbw9Cho0y/7WzYptXqkEek=
-modernc.org/sqlite v1.39.1/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE=
+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/alerts/alerts_status.go

@@ -25,12 +25,7 @@ type alertInfo struct {
 // startWorker is a long-running goroutine that processes alert tasks
 // every x seconds. It must be running to process status alerts.
 func (am *AlertManager) startWorker() {
-	processPendingAlerts := time.Tick(15 * time.Second)
+	tick := time.Tick(15 * time.Second)
-
-	// check for status alerts that are not resolved when system comes up
-	// (can be removed if we figure out core bug in #1052)
-	checkStatusAlerts := time.Tick(561 * time.Second)
-
 	for {
 		select {
 		case <-am.stopChan:
@@ -46,9 +41,7 @@ func (am *AlertManager) startWorker() {
 			case "cancel":
 				am.pendingAlerts.Delete(task.alertRecord.Id)
 			}
-		case <-checkStatusAlerts:
+		case <-tick:
-			resolveStatusAlerts(am.hub)
-		case <-processPendingAlerts:
 			// Check for expired alerts every tick
 			now := time.Now()
 			for key, value := range am.pendingAlerts.Range {
@@ -177,35 +170,3 @@ func (am *AlertManager) sendStatusAlert(alertStatus string, systemName string, a
 		LinkText: "View " + systemName,
 	})
 }
-
-// resolveStatusAlerts resolves any status alerts that weren't resolved
-// when system came up (https://github.com/henrygd/beszel/issues/1052)
-func resolveStatusAlerts(app core.App) error {
-	db := app.DB()
-	// Find all active status alerts where the system is actually up
-	var alertIds []string
-	err := db.NewQuery(`
-		SELECT a.id 
-		FROM alerts a
-		JOIN systems s ON a.system = s.id
-		WHERE a.name = 'Status' 
-		AND a.triggered = true
-		AND s.status = 'up'
-	`).Column(&alertIds)
-	if err != nil {
-		return err
-	}
-	// resolve all matching alert records
-	for _, alertId := range alertIds {
-		alert, err := app.FindRecordById("alerts", alertId)
-		if err != nil {
-			return err
-		}
-		alert.Set("triggered", false)
-		err = app.Save(alert)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

internal/alerts/alerts_system.go

@@ -38,7 +38,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 		case "Memory":
 			val = data.Info.MemPct
 		case "Bandwidth":
-			val = data.Info.Bandwidth
+			val = data.Info.NetworkSent + data.Info.NetworkRecv
 			unit = " MB/s"
 		case "Disk":
 			maxUsedPct := data.Info.DiskPct

internal/alerts/alerts_test.go

@@ -13,7 +13,6 @@ import (
 	"testing/synctest"
 	"time"
 
-	"github.com/henrygd/beszel/internal/alerts"
 	beszelTests "github.com/henrygd/beszel/internal/tests"
 
 	"github.com/pocketbase/dbx"
@@ -370,9 +369,33 @@ func TestUserAlertsApi(t *testing.T) {
 	}
 }
 
+func getHubWithUser(t *testing.T) (*beszelTests.TestHub, *core.Record) {
+	hub, err := beszelTests.NewTestHub(t.TempDir())
+	assert.NoError(t, err)
+	hub.StartHub()
+
+	// Manually initialize the system manager to bind event hooks
+	err = hub.GetSystemManager().Initialize()
+	assert.NoError(t, err)
+
+	// Create a test user
+	user, err := beszelTests.CreateUser(hub, "test@example.com", "password")
+	assert.NoError(t, err)
+
+	// Create user settings for the test user (required for alert notifications)
+	userSettingsData := map[string]any{
+		"user":     user.Id,
+		"settings": `{"emails":[test@example.com],"webhooks":[]}`,
+	}
+	_, err = beszelTests.CreateRecord(hub, "user_settings", userSettingsData)
+	assert.NoError(t, err)
+
+	return hub, user
+}
+
 func TestStatusAlerts(t *testing.T) {
 	synctest.Test(t, func(t *testing.T) {
-		hub, user := beszelTests.GetHubWithUser(t)
+		hub, user := getHubWithUser(t)
 		defer hub.Cleanup()
 
 		systems, err := beszelTests.CreateSystems(hub, 4, user.Id, "paused")
@@ -453,7 +476,7 @@ func TestStatusAlerts(t *testing.T) {
 
 func TestAlertsHistory(t *testing.T) {
 	synctest.Test(t, func(t *testing.T) {
-		hub, user := beszelTests.GetHubWithUser(t)
+		hub, user := getHubWithUser(t)
 		defer hub.Cleanup()
 
 		// Create systems and alerts
@@ -579,102 +602,3 @@ func TestAlertsHistory(t *testing.T) {
 		assert.EqualValues(t, 2, totalHistoryCount, "Should have 2 total alert history records")
 	})
 }
-func TestResolveStatusAlerts(t *testing.T) {
-	hub, user := beszelTests.GetHubWithUser(t)
-	defer hub.Cleanup()
-
-	// Create a systemUp
-	systemUp, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":   "test-system",
-		"users":  []string{user.Id},
-		"host":   "127.0.0.1",
-		"status": "up",
-	})
-	assert.NoError(t, err)
-
-	systemDown, err := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":   "test-system-2",
-		"users":  []string{user.Id},
-		"host":   "127.0.0.2",
-		"status": "up",
-	})
-	assert.NoError(t, err)
-
-	// Create a status alertUp for the system
-	alertUp, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
-		"name":   "Status",
-		"system": systemUp.Id,
-		"user":   user.Id,
-		"min":    1,
-	})
-	assert.NoError(t, err)
-
-	alertDown, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
-		"name":   "Status",
-		"system": systemDown.Id,
-		"user":   user.Id,
-		"min":    1,
-	})
-	assert.NoError(t, err)
-
-	// Verify alert is not triggered initially
-	assert.False(t, alertUp.GetBool("triggered"), "Alert should not be triggered initially")
-
-	// Set the system to 'up' (this should not trigger the alert)
-	systemUp.Set("status", "up")
-	err = hub.SaveNoValidate(systemUp)
-	assert.NoError(t, err)
-
-	systemDown.Set("status", "down")
-	err = hub.SaveNoValidate(systemDown)
-	assert.NoError(t, err)
-
-	// Wait a moment for any processing
-	time.Sleep(10 * time.Millisecond)
-
-	// Verify alertUp is still not triggered after setting system to up
-	alertUp, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alertUp.Id})
-	assert.NoError(t, err)
-	assert.False(t, alertUp.GetBool("triggered"), "Alert should not be triggered when system is up")
-
-	// Manually set both alerts triggered to true
-	alertUp.Set("triggered", true)
-	err = hub.SaveNoValidate(alertUp)
-	assert.NoError(t, err)
-	alertDown.Set("triggered", true)
-	err = hub.SaveNoValidate(alertDown)
-	assert.NoError(t, err)
-
-	// Verify we have exactly one alert with triggered true
-	triggeredCount, err := hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 2, triggeredCount, "Should have exactly two alerts with triggered true")
-
-	// Verify the specific alertUp is triggered
-	alertUp, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alertUp.Id})
-	assert.NoError(t, err)
-	assert.True(t, alertUp.GetBool("triggered"), "Alert should be triggered")
-
-	// Verify we have two unresolved alert history records
-	alertHistoryCount, err := hub.CountRecords("alerts_history", dbx.HashExp{"resolved": ""})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 2, alertHistoryCount, "Should have exactly two unresolved alert history records")
-
-	err = alerts.ResolveStatusAlerts(hub)
-	assert.NoError(t, err)
-
-	// Verify alertUp is not triggered after resolving
-	alertUp, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alertUp.Id})
-	assert.NoError(t, err)
-	assert.False(t, alertUp.GetBool("triggered"), "Alert should not be triggered after resolving")
-	// Verify alertDown is still triggered
-	alertDown, err = hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alertDown.Id})
-	assert.NoError(t, err)
-	assert.True(t, alertDown.GetBool("triggered"), "Alert should still be triggered after resolving")
-
-	// Verify we have one unresolved alert history record
-	alertHistoryCount, err = hub.CountRecords("alerts_history", dbx.HashExp{"resolved": ""})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, alertHistoryCount, "Should have exactly one unresolved alert history record")
-
-}

internal/alerts/alerts_test_helpers.go

@@ -1,6 +1,3 @@
-//go:build testing
-// +build testing
-
 package alerts
 
 import (
@@ -56,7 +53,3 @@ func (am *AlertManager) ForceExpirePendingAlerts() {
 		return true
 	})
 }
-
-func ResolveStatusAlerts(app core.App) error {
-	return resolveStatusAlerts(app)
-}

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"`
+	// Error  AgentError      `cbor:"error,omitempty,omitzero"`
-}
-
-// 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"`
 }
 
 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"`
+	Hostname string `cbor:"1,keyasint,omitempty,omitzero"`
-	Port     string `cbor:"2,keyasint,omitzero"`
+	Port     string `cbor:"2,keyasint,omitempty,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"`
 }

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

@@ -2,18 +2,15 @@ FROM --platform=$BUILDPLATFORM golang:alpine AS builder
 
 WORKDIR /app
 
-
+COPY go.mod go.sum ./
-COPY ../go.mod ../go.sum ./
+# RUN go mod download
-RUN go mod download
+COPY *.go ./
-
+COPY cmd ./cmd
-# Copy source files
+COPY internal ./internal
-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 CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./cmd/agent
-
-RUN rm -rf /tmp/*
 
 # --------------------------
 # Final image: GPU-enabled agent with nvidia-smi
@@ -21,12 +18,4 @@ RUN rm -rf /tmp/*
 FROM nvidia/cuda:12.2.2-base-ubuntu22.04
 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

@@ -8,6 +8,15 @@ import (
 	"github.com/henrygd/beszel/internal/entities/container"
 )
 
+type NetworkInterfaceStats struct {
+	NetworkSent    float64 `json:"ns"`
+	NetworkRecv    float64 `json:"nr"`
+	MaxNetworkSent float64 `json:"nsm,omitempty"`
+	MaxNetworkRecv float64 `json:"nrm,omitempty"`
+	TotalBytesSent uint64  `json:"tbs,omitempty"` // Total bytes sent since boot
+	TotalBytesRecv uint64  `json:"tbr,omitempty"` // Total bytes received since boot
+}
+
 type Stats struct {
 	Cpu               float64                          `json:"cpu" cbor:"0,keyasint"`
 	MaxCpu            float64                          `json:"cpum,omitempty" cbor:"1,keyasint,omitempty"`
@@ -25,44 +34,37 @@ type Stats struct {
 	DiskWritePs       float64                          `json:"dw" cbor:"13,keyasint"`
 	MaxDiskReadPs     float64                          `json:"drm,omitempty" cbor:"14,keyasint,omitempty"`
 	MaxDiskWritePs    float64                          `json:"dwm,omitempty" cbor:"15,keyasint,omitempty"`
-	NetworkSent    float64             `json:"ns" cbor:"16,keyasint"`
+	NetworkInterfaces map[string]NetworkInterfaceStats `json:"ni" cbor:"16,omitempty"` // Per-interface network stats
-	NetworkRecv    float64             `json:"nr" cbor:"17,keyasint"`
+	NetworkSent       float64                          `json:"ns" cbor:"17,keyasint"`  // Total network sent (MB/s)
-	MaxNetworkSent float64             `json:"nsm,omitempty" cbor:"18,keyasint,omitempty"`
+	NetworkRecv       float64                          `json:"nr" cbor:"18,keyasint"`  // Total network recv (MB/s)
-	MaxNetworkRecv float64             `json:"nrm,omitempty" cbor:"19,keyasint,omitempty"`
+	MaxNetworkSent    float64                          `json:"nsm,omitempty" cbor:"19,keyasint,omitempty"`
-	Temperatures   map[string]float64  `json:"t,omitempty" cbor:"20,keyasint,omitempty"`
+	MaxNetworkRecv    float64                          `json:"nrm,omitempty" cbor:"20,keyasint,omitempty"`
-	ExtraFs        map[string]*FsStats `json:"efs,omitempty" cbor:"21,keyasint,omitempty"`
+	Temperatures      map[string]float64               `json:"t,omitempty" cbor:"21,keyasint,omitempty"`
-	GPUData        map[string]GPUData  `json:"g,omitempty" cbor:"22,keyasint,omitempty"`
+	ExtraFs           map[string]*FsStats              `json:"efs,omitempty" cbor:"22,keyasint,omitempty"`
-	LoadAvg1       float64             `json:"l1,omitempty" cbor:"23,keyasint,omitempty"`
+	GPUData           map[string]GPUData               `json:"g,omitempty" cbor:"23,keyasint,omitempty"`
-	LoadAvg5       float64             `json:"l5,omitempty" cbor:"24,keyasint,omitempty"`
+	LoadAvg1          float64                          `json:"l1,omitempty" cbor:"24,keyasint,omitempty"`
-	LoadAvg15      float64             `json:"l15,omitempty" cbor:"25,keyasint,omitempty"`
+	LoadAvg5          float64                          `json:"l5,omitempty" cbor:"25,keyasint,omitempty"`
-	Bandwidth      [2]uint64           `json:"b,omitzero" cbor:"26,keyasint,omitzero"`  // [sent bytes, recv bytes]
+	LoadAvg15         float64                          `json:"l15,omitempty" cbor:"26,keyasint,omitempty"`
-	MaxBandwidth   [2]uint64           `json:"bm,omitzero" cbor:"27,keyasint,omitzero"` // [sent bytes, recv bytes]
+	LoadAvg           [3]float64                       `json:"la,omitempty" cbor:"27,keyasint"`          // [1min, 5min, 15min]
-	// TODO: remove other load fields in future release in favor of load avg array
+	Battery           [2]uint8                         `json:"bat,omitzero" cbor:"28,keyasint,omitzero"` // [percent, charge state]
-	LoadAvg           [3]float64           `json:"la,omitempty" cbor:"28,keyasint"`
+	MaxMem            float64                          `json:"mm,omitempty" cbor:"29,keyasint,omitempty"`
-	Battery           [2]uint8             `json:"bat,omitzero" cbor:"29,keyasint,omitzero"` // [percent, charge state, current]
+	Nets              map[string]float64               `json:"nets,omitempty" cbor:"30,keyasint,omitempty"` // Network connection statistics
-	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 {
 	Name        string  `json:"n" cbor:"0,keyasint"`
 	Temperature float64 `json:"-"`
-	MemoryUsed  float64            `json:"mu,omitempty,omitzero" cbor:"1,keyasint,omitempty,omitzero"`
+	MemoryUsed  float64 `json:"mu,omitempty" cbor:"1,keyasint,omitempty"`
-	MemoryTotal float64            `json:"mt,omitempty,omitzero" cbor:"2,keyasint,omitempty,omitzero"`
+	MemoryTotal float64 `json:"mt,omitempty" cbor:"2,keyasint,omitempty"`
-	Usage       float64            `json:"u" cbor:"3,keyasint,omitempty"`
+	Usage       float64 `json:"u" cbor:"3,keyasint"`
 	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,16 +73,13 @@ 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 {
 	BytesRecv   uint64
 	BytesSent   uint64
+	PacketsSent uint64
+	PacketsRecv uint64
 	Time        time.Time
 	Name        string
 }
@@ -94,14 +93,6 @@ const (
 	Freebsd
 )
 
-type ConnectionType = uint8
-
-const (
-	ConnectionTypeNone ConnectionType = iota
-	ConnectionTypeSSH
-	ConnectionTypeWebSocket
-)
-
 type Info struct {
 	Hostname      string     `json:"h" cbor:"0,keyasint"`
 	KernelVersion string     `json:"k,omitempty" cbor:"1,keyasint,omitempty"`
@@ -112,19 +103,17 @@ type Info struct {
 	Cpu           float64    `json:"cpu" cbor:"6,keyasint"`
 	MemPct        float64    `json:"mp" cbor:"7,keyasint"`
 	DiskPct       float64    `json:"dp" cbor:"8,keyasint"`
-	Bandwidth      float64 `json:"b" cbor:"9,keyasint"`
+	NetworkSent   float64    `json:"ns" cbor:"9,keyasint"`  // Per-interface total (MB/s)
-	AgentVersion   string  `json:"v" cbor:"10,keyasint"`
+	NetworkRecv   float64    `json:"nr" cbor:"10,keyasint"` // Per-interface total (MB/s)
-	Podman         bool    `json:"p,omitempty" cbor:"11,keyasint,omitempty"`
+	AgentVersion  string     `json:"v" cbor:"11,keyasint"`
-	GpuPct         float64 `json:"g,omitempty" cbor:"12,keyasint,omitempty"`
+	Podman        bool       `json:"p,omitempty" cbor:"12,keyasint,omitempty"`
-	DashboardTemp  float64 `json:"dt,omitempty" cbor:"13,keyasint,omitempty"`
+	GpuPct        float64    `json:"g,omitempty" cbor:"13,keyasint,omitempty"`
-	Os             Os      `json:"os" cbor:"14,keyasint"`
+	DashboardTemp float64    `json:"dt,omitempty" cbor:"14,keyasint,omitempty"`
-	LoadAvg1       float64 `json:"l1,omitempty" cbor:"15,keyasint,omitempty"`
+	Os            Os         `json:"os" cbor:"15,keyasint"`
-	LoadAvg5       float64 `json:"l5,omitempty" cbor:"16,keyasint,omitempty"`
+	LoadAvg1      float64    `json:"l1,omitempty" cbor:"16,keyasint,omitempty"`
-	LoadAvg15      float64 `json:"l15,omitempty" cbor:"17,keyasint,omitempty"`
+	LoadAvg5      float64    `json:"l5,omitempty" cbor:"17,keyasint,omitempty"`
-	BandwidthBytes uint64  `json:"bb" cbor:"18,keyasint"`
+	LoadAvg15     float64    `json:"l15,omitempty" cbor:"18,keyasint,omitempty"`
-	// TODO: remove load fields in future release in favor of load avg array
+	LoadAvg       [3]float64 `json:"la,omitempty" cbor:"19,keyasint"` // [1min, 5min, 15min]
-	LoadAvg        [3]float64     `json:"la,omitempty" cbor:"19,keyasint"`
-	ConnectionType ConnectionType `json:"ct,omitempty" cbor:"20,keyasint,omitempty,omitzero"`
 }
 
 // Final data structure to return to the hub

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 {
+	usersCollection, err := e.App.FindCollectionByNameOrId("users")
-		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)
 	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
+	if err := e.App.Save(usersCollection); err != nil {
-	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 {
 		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,15 +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 SMART data
+
-	apiAuth.GET("/smart", h.getSmartData)
-	// /containers routes
-	if enabled, _ := GetEnv("CONTAINER_DETAILS"); enabled != "false" {
-		// get container logs
-		apiAuth.GET("/containers/logs", h.getContainerLogs)
-		// get container info
-		apiAuth.GET("/containers/info", h.getContainerInfo)
-	}
 	return nil
 }
 
@@ -291,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.StatusNotFound, 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.StatusNotFound, 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")
+	systemStatsCollection, err := hub.FindCachedCollectionByNameOrId("system_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 {
+	if err := hub.SaveNoValidate(systemStatsRecord); err != nil {
-			return err
+		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 len(data.Containers) > 0 {
+		containerStatsCollection, err := hub.FindCachedCollectionByNameOrId("container_stats")
 		if err != nil {
-				return err
+			return nil, 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 {
+		if err := hub.SaveNoValidate(containerStatsRecord); err != nil {
-				return err
+			return nil, 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 {
+	if err := hub.SaveNoValidate(systemRecord); err != nil {
-			return err
+		return nil, err
 	}
-		return nil
+	return systemRecord, 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(),
-	}
-	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
 }
 
 // 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) {
+func (sys *System) fetchDataViaSSH() (*system.CombinedData, error) {
-	err := sys.runSSHOperation(4*time.Second, 1, func(session *ssh.Session) (bool, 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 {
+			sys.closeSSHConnection()
+			if attempt < maxRetries {
+				continue
+			}
+			return nil, err
+		}
+
+		// wait for the session to complete
+		if err := session.Wait(); err != nil {
 			return nil, err
 		}
 
 		return sys.data, nil
 	}
 
-// runSSHOperation establishes an SSH session and executes the provided operation.
+	// this should never be reached due to the return in the loop
-// The operation can request a retry by returning true as the first return value.
+	return nil, fmt.Errorf("failed to fetch data")
-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 {
-				continue
-			}
-		}
-
-		return opErr
-	}
-
-	return fmt.Errorf("ssh operation failed")
 }
 
 // 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
+	minPercent := 40
-	maxPercent := 95
+	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,9 +35,12 @@ func Update(cmd *cobra.Command, _ []string) {
 	}
 
 	// make sure the file is executable
+	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
 	restartService()

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/internal/entities/system"
-	"github.com/henrygd/beszel"
 
 	"github.com/henrygd/beszel/internal/common"
 
 	"github.com/fxamacker/cbor/v2"
 	"github.com/lxzan/gws"
+	"golang.org/x/crypto/ssh"
 )
 
 const (
@@ -26,9 +26,8 @@ type Handler struct {
 // WsConn represents a WebSocket connection to an agent.
 type WsConn struct {
 	conn         *gws.Conn
-	requestManager *RequestManager
+	responseChan chan *gws.Message
 	DownChan     chan struct{}
-	agentVersion   semver.Version
 }
 
 // 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.
+// NewWsConnection creates a new WebSocket connection wrapper.
-func NewWsConnection(conn *gws.Conn, agentVersion semver.Version) *WsConn {
+func NewWsConnection(conn *gws.Conn) *WsConn {
 	return &WsConn{
 		conn:         conn,
-		requestManager: NewRequestManager(conn),
+		responseChan: make(chan *gws.Message, 1),
 		DownChan:     make(chan struct{}, 1),
-		agentVersion:   agentVersion,
 	}
 }
 
-// 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.
+// RequestSystemData requests system metrics from the agent and unmarshals the response.
-func (ws *WsConn) handleAgentRequest(req *PendingRequest, handler ResponseHandler) error {
+func (ws *WsConn) RequestSystemData(data *system.CombinedData) error {
-	// Wait for response
+	var message *gws.Message
+
+	ws.sendMessage(common.HubRequest[any]{
+		Action: common.GetData,
+	})
 	select {
-	case message := <-req.ResponseCh:
+	case <-time.After(10 * time.Second):
+		ws.Close(nil)
+		return gws.ErrConnClosed
+	case message = <-ws.responseChan:
+	}
 	defer message.Close()
-		// Cancel request context to stop timeout watcher promptly
+	return cbor.Unmarshal(message.Data.Bytes(), data)
-		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
+// GetFingerprint authenticates with the agent using SSH signature and returns the agent's fingerprint.
-		var agentResponse common.AgentResponse
+func (ws *WsConn) GetFingerprint(token string, signer ssh.Signer, needSysInfo bool) (common.FingerprintResponse, error) {
-		if err := cbor.Unmarshal(data, &agentResponse); err != nil {
+	var clientFingerprint common.FingerprintResponse
-			return err
+	challenge := []byte(token)
-		}
-		if agentResponse.Error != "" {
-			return errors.New(agentResponse.Error)
-		}
-		return handler.Handle(agentResponse)
 
-	case <-req.Context.Done():
+	signature, err := signer.Sign(nil, challenge)
-		return req.Context.Err()
+	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
+	// Response channel should be empty initially
-	assert.Equal(t, 0, wsConn.requestManager.GetPendingCount(), "Should have no pending requests 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

@@ -206,17 +206,51 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.DiskPct += stats.DiskPct
 		sum.DiskReadPs += stats.DiskReadPs
 		sum.DiskWritePs += stats.DiskWritePs
+		sum.LoadAvg1 += stats.LoadAvg1
+		sum.LoadAvg5 += stats.LoadAvg5
+		sum.LoadAvg15 += stats.LoadAvg15
 		sum.NetworkSent += stats.NetworkSent
 		sum.NetworkRecv += stats.NetworkRecv
 		sum.LoadAvg[0] += stats.LoadAvg[0]
 		sum.LoadAvg[1] += stats.LoadAvg[1]
 		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]
+
+		if stats.NetworkInterfaces != nil {
+			if sum.NetworkInterfaces == nil {
+				sum.NetworkInterfaces = make(map[string]system.NetworkInterfaceStats, len(stats.NetworkInterfaces))
+			}
+			for key, value := range stats.NetworkInterfaces {
+				if _, ok := sum.NetworkInterfaces[key]; !ok {
+					sum.NetworkInterfaces[key] = system.NetworkInterfaceStats{}
+				}
+				ni := sum.NetworkInterfaces[key]
+				ni.NetworkSent += value.NetworkSent
+				ni.NetworkRecv += value.NetworkRecv
+				ni.MaxNetworkSent += value.MaxNetworkSent
+				ni.MaxNetworkRecv += value.MaxNetworkRecv
+				// For cumulative totals, use the maximum value (most recent)
+				if value.TotalBytesSent > ni.TotalBytesSent {
+					ni.TotalBytesSent = value.TotalBytesSent
+				}
+				if value.TotalBytesRecv > ni.TotalBytesRecv {
+					ni.TotalBytesRecv = value.TotalBytesRecv
+				}
+				sum.NetworkInterfaces[key] = ni
+			}
+		}
+
+		// Handle network connection stats - use the latest values (most recent sample)
+		if stats.Nets != nil {
+			if sum.Nets == nil {
+				sum.Nets = make(map[string]float64)
+			}
+			for key, value := range stats.Nets {
+				sum.Nets[key] = value
+			}
+		}
+
 		// Set peak values
 		sum.MaxCpu = max(sum.MaxCpu, stats.MaxCpu, stats.Cpu)
 		sum.MaxMem = max(sum.MaxMem, stats.MaxMem, stats.MemUsed)
@@ -224,23 +258,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.MaxNetworkRecv = max(sum.MaxNetworkRecv, stats.MaxNetworkRecv, stats.NetworkRecv)
 		sum.MaxDiskReadPs = max(sum.MaxDiskReadPs, stats.MaxDiskReadPs, stats.DiskReadPs)
 		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 {
-			sum.NetworkInterfaces = make(map[string][4]uint64, len(stats.NetworkInterfaces))
-		}
-		for key, value := range stats.NetworkInterfaces {
-			sum.NetworkInterfaces[key] = [4]uint64{
-				sum.NetworkInterfaces[key][0] + value[0],
-				sum.NetworkInterfaces[key][1] + value[1],
-				max(sum.NetworkInterfaces[key][2], value[2]),
-				max(sum.NetworkInterfaces[key][3], value[3]),
-			}
-		}
 
 		// Accumulate temperatures
 		if stats.Temperatures != nil {
@@ -288,16 +305,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 				gpu.Usage += value.Usage
 				gpu.Power += value.Power
 				gpu.Count += value.Count
-
-				if value.Engines != nil {
-					if gpu.Engines == nil {
-						gpu.Engines = make(map[string]float64, len(value.Engines))
-					}
-					for engineKey, engineValue := range value.Engines {
-						gpu.Engines[engineKey] += engineValue
-					}
-				}
-
 				sum.GPUData[id] = gpu
 			}
 		}
@@ -318,29 +325,26 @@ 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.LoadAvg1 = twoDecimals(sum.LoadAvg1 / count)
-		sum.DiskIO[1] = sum.DiskIO[1] / uint64(count)
+		sum.LoadAvg5 = twoDecimals(sum.LoadAvg5 / count)
+		sum.LoadAvg15 = twoDecimals(sum.LoadAvg15 / count)
 		sum.NetworkSent = twoDecimals(sum.NetworkSent / count)
 		sum.NetworkRecv = twoDecimals(sum.NetworkRecv / count)
 		sum.LoadAvg[0] = twoDecimals(sum.LoadAvg[0] / count)
 		sum.LoadAvg[1] = twoDecimals(sum.LoadAvg[1] / count)
 		sum.LoadAvg[2] = twoDecimals(sum.LoadAvg[2] / count)
-		sum.Bandwidth[0] = sum.Bandwidth[0] / uint64(count)
-		sum.Bandwidth[1] = sum.Bandwidth[1] / uint64(count)
 		sum.Battery[0] = uint8(batterySum / int(count))
 
-		// Average network interfaces
 		if sum.NetworkInterfaces != nil {
 			for key := range sum.NetworkInterfaces {
-				sum.NetworkInterfaces[key] = [4]uint64{
+				ni := sum.NetworkInterfaces[key]
-					sum.NetworkInterfaces[key][0] / uint64(count),
+				ni.NetworkSent = twoDecimals(ni.NetworkSent / count)
-					sum.NetworkInterfaces[key][1] / uint64(count),
+				ni.NetworkRecv = twoDecimals(ni.NetworkRecv / count)
-					sum.NetworkInterfaces[key][2],
+				ni.MaxNetworkSent = twoDecimals(max(ni.MaxNetworkSent, ni.NetworkSent))
-					sum.NetworkInterfaces[key][3],
+				ni.MaxNetworkRecv = twoDecimals(max(ni.MaxNetworkRecv, ni.NetworkRecv))
+				sum.NetworkInterfaces[key] = ni
 			}
 		}
-		}
-
 		// Average temperatures
 		if sum.Temperatures != nil && tempCount > 0 {
 			for key := range sum.Temperatures {
@@ -369,13 +373,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 				gpu.Usage = twoDecimals(gpu.Usage / count)
 				gpu.Power = twoDecimals(gpu.Power / count)
 				gpu.Count = twoDecimals(gpu.Count / count)
-
-				if gpu.Engines != nil {
-					for engineKey := range gpu.Engines {
-						gpu.Engines[engineKey] = twoDecimals(gpu.Engines[engineKey] / count)
-					}
-				}
-
 				sum.GPUData[id] = gpu
 			}
 		}
@@ -412,8 +409,6 @@ func (rm *RecordManager) AverageContainerStats(db dbx.Builder, records RecordIds
 			}
 			sums[stat.Name].Cpu += stat.Cpu
 			sums[stat.Name].Mem += stat.Mem
-			sums[stat.Name].NetworkSent += stat.NetworkSent
-			sums[stat.Name].NetworkRecv += stat.NetworkRecv
 		}
 	}
 
@@ -423,8 +418,6 @@ func (rm *RecordManager) AverageContainerStats(db dbx.Builder, records RecordIds
 			Name: value.Name,
 			Cpu:  twoDecimals(value.Cpu / count),
 			Mem:  twoDecimals(value.Mem / count),
-			NetworkSent: twoDecimals(value.NetworkSent / count),
-			NetworkRecv: twoDecimals(value.NetworkRecv / count),
 		})
 	}
 	return result
@@ -437,10 +430,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 +499,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/records/records_test.go

@@ -175,7 +175,7 @@ func TestDeleteOldSystemStats(t *testing.T) {
 	}
 
 	// Run deletion
-	err = records.DeleteOldSystemStats(hub)
+	err = records.TestDeleteOldSystemStats(hub)
 	require.NoError(t, err)
 
 	// Verify results
@@ -268,7 +268,7 @@ func TestDeleteOldAlertsHistory(t *testing.T) {
 			assert.Equal(t, int64(tc.alertCount), countBefore, "Initial count should match")
 
 			// Run deletion
-			err = records.DeleteOldAlertsHistory(hub, tc.countToKeep, tc.countBeforeDeletion)
+			err = records.TestDeleteOldAlertsHistory(hub, tc.countToKeep, tc.countBeforeDeletion)
 			require.NoError(t, err)
 
 			// Count after deletion
@@ -332,7 +332,7 @@ func TestDeleteOldAlertsHistoryEdgeCases(t *testing.T) {
 		}
 
 		// Should not error and should not delete anything
-		err = records.DeleteOldAlertsHistory(hub, 10, 20)
+		err = records.TestDeleteOldAlertsHistory(hub, 10, 20)
 		require.NoError(t, err)
 
 		count, err := hub.CountRecords("alerts_history")
@@ -346,7 +346,7 @@ func TestDeleteOldAlertsHistoryEdgeCases(t *testing.T) {
 		require.NoError(t, err)
 
 		// Should not error with empty table
-		err = records.DeleteOldAlertsHistory(hub, 10, 20)
+		err = records.TestDeleteOldAlertsHistory(hub, 10, 20)
 		require.NoError(t, err)
 	})
 }
@@ -376,7 +376,7 @@ func TestTwoDecimals(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		result := records.TwoDecimals(tc.input)
+		result := records.TestTwoDecimals(tc.input)
 		assert.InDelta(t, tc.expected, result, 0.02, "twoDecimals(%f) should equal %f", tc.input, tc.expected)
 	}
 }

internal/records/records_test_helpers.go

@@ -7,17 +7,17 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )
 
-// DeleteOldSystemStats exposes deleteOldSystemStats for testing
+// TestDeleteOldSystemStats exposes deleteOldSystemStats for testing
-func DeleteOldSystemStats(app core.App) error {
+func TestDeleteOldSystemStats(app core.App) error {
 	return deleteOldSystemStats(app)
 }
 
-// DeleteOldAlertsHistory exposes deleteOldAlertsHistory for testing
+// TestDeleteOldAlertsHistory exposes deleteOldAlertsHistory for testing
-func DeleteOldAlertsHistory(app core.App, countToKeep, countBeforeDeletion int) error {
+func TestDeleteOldAlertsHistory(app core.App, countToKeep, countBeforeDeletion int) error {
 	return deleteOldAlertsHistory(app, countToKeep, countBeforeDeletion)
 }
 
-// TwoDecimals exposes twoDecimals for testing
+// TestTwoDecimals exposes twoDecimals for testing
-func TwoDecimals(value float64) float64 {
+func TestTwoDecimals(value float64) float64 {
 	return twoDecimals(value)
 }

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,
+		"useIgnoreFile": false
-		"defaultBranch": "main"
+	},
+	"files": {
+		"ignoreUnknown": false
 	},
 	"formatter": {
 		"enabled": true,
 		"indentStyle": "tab",
-		"lineWidth": 120,
+		"indentWidth": 2,
-		"formatWithErrors": true
+		"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",
+				"useUniqueElementIds": "off"
-				"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"
 			}
 		}
 	},
 	"javascript": {
 		"formatter": {
 			"quoteStyle": "double",
-			"trailingCommas": "es5",
+			"semicolons": "asNeeded",
-			"semicolons": "asNeeded"
+			"trailingCommas": "es5"
 		}
 	},
-	"overrides": [
+	"assist": {
-		{
+		"enabled": true,
-			"includes": ["**/*.jsx", "**/*.tsx"],
+		"actions": {
-			"linter": {
+			"source": {
-				"rules": {
+				"organizeImports": "on"
-					"style": {
-						"noParameterAssign": "error"
-					}
-				}
-			}
-		},
-		{
-			"includes": ["**/*.ts", "**/*.tsx"],
-			"linter": {
-				"rules": {
-					"correctness": {
-						"noUnusedVariables": "off"
 			}
 		}
 	}
 }
-	]
-}

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/lingui.config.ts

@@ -14,6 +14,7 @@ export default defineConfig({
 		"hr",
 		"hu",
 		"it",
+		"is",
 		"ja",
 		"ko",
 		"nl",

internal/site/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "beszel",
 	"private": true,
-	"version": "0.15.0",
+	"version": "0.12.7",
 	"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",

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/add-system.tsx

@@ -1,9 +1,5 @@
-import { t } from "@lingui/core/macro"
 import { Trans } from "@lingui/react/macro"
-import { useStore } from "@nanostores/react"
+import { t } from "@lingui/core/macro"
-import { getPagePath } from "@nanostores/router"
-import { ChevronDownIcon, ExternalLinkIcon, PlusIcon } from "lucide-react"
-import { memo, useEffect, useRef, useState } from "react"
 import { Button } from "@/components/ui/button"
 import {
 	Dialog,
@@ -14,30 +10,34 @@ import {
 	DialogTitle,
 	DialogTrigger,
 } from "@/components/ui/dialog"
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
 import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
-import { isReadOnlyUser, pb } from "@/lib/api"
-import { SystemStatus } from "@/lib/enums"
 import { $publicKey } from "@/lib/stores"
 import { cn, generateToken, tokenMap, useBrowserStorage } from "@/lib/utils"
-import type { SystemRecord } from "@/types"
+import { pb, isReadOnlyUser } from "@/lib/api"
+import { useStore } from "@nanostores/react"
+import { ChevronDownIcon, ExternalLinkIcon, PlusIcon } from "lucide-react"
+import { memo, useEffect, useRef, useState } from "react"
+import { $router, basePath, Link, navigate } from "./router"
+import { SystemRecord } from "@/types"
+import { SystemStatus } from "@/lib/enums"
+import { AppleIcon, DockerIcon, FreeBsdIcon, TuxIcon, WindowsIcon } from "./ui/icons"
+import { InputCopy } from "./ui/input-copy"
+import { getPagePath } from "@nanostores/router"
 import {
 	copyDockerCompose,
 	copyDockerRun,
 	copyLinuxCommand,
 	copyWindowsCommand,
-	type DropdownItem,
+	DropdownItem,
 	InstallDropdown,
 } from "./install-dropdowns"
-import { $router, basePath, Link, navigate } from "./router"
 import { DropdownMenu, DropdownMenuTrigger } from "./ui/dropdown-menu"
-import { AppleIcon, DockerIcon, FreeBsdIcon, TuxIcon, WindowsIcon } from "./ui/icons"
-import { InputCopy } from "./ui/input-copy"
 
 export function AddSystemButton({ className }: { className?: string }) {
 	const [open, setOpen] = useState(false)
-	const opened = useRef(false)
+	let opened = useRef(false)
 	if (open) {
 		opened.current = true
 	}

internal/site/src/components/alerts-history-columns.tsx

@@ -1,11 +1,11 @@
-import { t } from "@lingui/core/macro"
+import { ColumnDef } from "@tanstack/react-table"
-import { Trans } from "@lingui/react/macro"
+import { AlertsHistoryRecord } from "@/types"
-import type { ColumnDef } from "@tanstack/react-table"
-import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
+import { Badge } from "@/components/ui/badge"
+import { formatShortDate, toFixedFloat, formatDuration, cn } from "@/lib/utils"
 import { alertInfo } from "@/lib/alerts"
-import { cn, formatDuration, formatShortDate, toFixedFloat } from "@/lib/utils"
+import { Trans } from "@lingui/react/macro"
-import type { AlertsHistoryRecord } from "@/types"
+import { t } from "@lingui/core/macro"
 
 export const alertsHistoryColumns: ColumnDef<AlertsHistoryRecord>[] = [
 	{
@@ -38,7 +38,7 @@ export const alertsHistoryColumns: ColumnDef<AlertsHistoryRecord>[] = [
 			</Button>
 		),
 		cell: ({ getValue, row }) => {
-			const name = getValue() as string
+			let name = getValue() as string
 			const info = alertInfo[row.original.name]
 			const Icon = info?.icon
 

internal/site/src/components/alerts/alert-button.tsx

@@ -1,13 +1,13 @@
 import { t } from "@lingui/core/macro"
-import { useStore } from "@nanostores/react"
-import { BellIcon } from "lucide-react"
 import { memo, useMemo, useState } from "react"
-import { Button } from "@/components/ui/button"
+import { useStore } from "@nanostores/react"
-import { Sheet, SheetContent, SheetTrigger } from "@/components/ui/sheet"
 import { $alerts } from "@/lib/stores"
+import { BellIcon } from "lucide-react"
 import { cn } from "@/lib/utils"
-import type { SystemRecord } from "@/types"
+import { Button } from "@/components/ui/button"
+import { SystemRecord } from "@/types"
 import { AlertDialogContent } from "./alerts-sheet"
+import { Sheet, SheetContent, SheetTrigger } from "@/components/ui/sheet"
 
 export default memo(function AlertsButton({ system }: { system: SystemRecord }) {
 	const [opened, setOpened] = useState(false)
@@ -26,7 +26,7 @@ export default memo(function AlertsButton({ system }: { system: SystemRecord })
 						/>
 					</Button>
 				</SheetTrigger>
-				<SheetContent className="max-h-full overflow-auto w-150 !max-w-full p-4 sm:p-6">
+				<SheetContent className="max-h-full overflow-auto w-145 !max-w-full p-4 sm:p-6">
 					{opened && <AlertDialogContent system={system} />}
 				</SheetContent>
 			</Sheet>

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

@@ -1,20 +1,21 @@
 import { t } from "@lingui/core/macro"
-import { Plural, Trans } from "@lingui/react/macro"
+import { Trans, Plural } from "@lingui/react/macro"
-import { useStore } from "@nanostores/react"
-import { getPagePath } from "@nanostores/router"
-import { GlobeIcon, ServerIcon } from "lucide-react"
-import { lazy, memo, Suspense, useMemo, useState } from "react"
-import { $router, Link } from "@/components/router"
-import { Checkbox } from "@/components/ui/checkbox"
-import { DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
-import { Switch } from "@/components/ui/switch"
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
-import { toast } from "@/components/ui/use-toast"
-import { alertInfo } from "@/lib/alerts"
-import { pb } from "@/lib/api"
 import { $alerts, $systems } from "@/lib/stores"
 import { cn, debounce } from "@/lib/utils"
-import type { AlertInfo, AlertRecord, SystemRecord } from "@/types"
+import { alertInfo } from "@/lib/alerts"
+import { Switch } from "@/components/ui/switch"
+import { AlertInfo, AlertRecord, SystemRecord } from "@/types"
+import { lazy, memo, Suspense, useMemo, useState } from "react"
+import { toast } from "@/components/ui/use-toast"
+import { useStore } from "@nanostores/react"
+import { getPagePath } from "@nanostores/router"
+import { Checkbox } from "@/components/ui/checkbox"
+import { DialogTitle, DialogDescription } from "@/components/ui/dialog"
+import { Tabs, TabsList, TabsTrigger, TabsContent } from "@/components/ui/tabs"
+import { ServerIcon, GlobeIcon } from "lucide-react"
+import { $router, Link } from "@/components/router"
+import { DialogHeader } from "@/components/ui/dialog"
+import { pb } from "@/lib/api"
 
 const Slider = lazy(() => import("@/components/ui/slider"))
 
@@ -171,7 +172,7 @@ export function AlertContent({
 
 	const [checked, setChecked] = useState(global ? false : !!alert)
 	const [min, setMin] = useState(alert?.min || 10)
-	const [value, setValue] = useState(alert?.value || (singleDescription ? 0 : (alertData.start ?? 80)))
+	const [value, setValue] = useState(alert?.value || (singleDescription ? 0 : alertData.start ?? 80))
 
 	const Icon = alertData.icon
 

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

@@ -1,16 +1,9 @@
-import { useMemo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
-import {
+import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-	ChartContainer,
+import { cn, formatShortDate, chartMargin } from "@/lib/utils"
-	ChartLegend,
-	ChartLegendContent,
-	ChartTooltip,
-	ChartTooltipContent,
-	xAxis,
-} from "@/components/ui/chart"
-import { chartMargin, cn, formatShortDate } from "@/lib/utils"
-import type { ChartData, SystemStatsRecord } from "@/types"
 import { useYAxisWidth } from "./hooks"
+import { ChartData, SystemStatsRecord } from "@/types"
+import { useMemo } from "react"
 
 export type DataPoint = {
 	label: string
@@ -27,8 +20,6 @@ export default function AreaChartDefault({
 	contentFormatter,
 	dataPoints,
 	domain,
-	legend,
-	itemSorter,
 }: // logRender = false,
 {
 	chartData: ChartData
@@ -38,13 +29,10 @@ export default function AreaChartDefault({
 	contentFormatter: ({ value, payload }: { value: number; payload: SystemStatsRecord }) => string
 	dataPoints?: DataPoint[]
 	domain?: [number, number]
-	legend?: boolean
-	itemSorter?: (a: any, b: any) => number
 	// logRender?: boolean
 }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
 
-	// biome-ignore lint/correctness/useExhaustiveDependencies: ignore
 	return useMemo(() => {
 		if (chartData.systemStats.length === 0) {
 			return null
@@ -75,8 +63,6 @@ export default function AreaChartDefault({
 						<ChartTooltip
 							animationEasing="ease-out"
 							animationDuration={150}
-							// @ts-expect-error
-							itemSorter={itemSorter}
 							content={
 								<ChartTooltipContent
 									labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
@@ -84,14 +70,11 @@ export default function AreaChartDefault({
 								/>
 							}
 						/>
-						{dataPoints?.map((dataPoint) => {
+						{dataPoints?.map((dataPoint, i) => {
-							let { color } = dataPoint
+							const color = `var(--chart-${dataPoint.color})`
-							if (typeof color === "number") {
-								color = `var(--chart-${color})`
-							}
 							return (
 								<Area
-									key={dataPoint.label}
+									key={i}
 									dataKey={dataPoint.dataKey}
 									name={dataPoint.label}
 									type="monotoneX"
@@ -102,7 +85,7 @@ export default function AreaChartDefault({
 								/>
 							)
 						})}
-						{legend && <ChartLegend content={<ChartLegendContent />} />}
+						{/* <ChartLegend content={<ChartLegendContent />} /> */}
 					</AreaChart>
 				</ChartContainer>
 			</div>

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

@@ -1,28 +1,13 @@
-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 { chartTimeData, cn } from "@/lib/utils"
-import type { ChartTimes, SemVer } from "@/types"
+import { ChartTimes } from "@/types"
-import { memo } from "react"
+import { useStore } from "@nanostores/react"
+import { HistoryIcon } from "lucide-react"
 
-export default memo(function ChartTimeSelect({
+export default function ChartTimeSelect({ className }: { className?: string }) {
-	className,
-	agentVersion,
-}: {
-	className?: string
-	agentVersion: SemVer
-}) {
 	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/connection-chart.tsx

@@ -0,0 +1,124 @@
+import { memo } from "react"
+import { useLingui } from "@lingui/react/macro"
+import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+import {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	ChartLegend,
+	ChartLegendContent,
+	xAxis,
+} from "@/components/ui/chart"
+import { cn, formatShortDate, chartMargin } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { useYAxisWidth } from "./hooks"
+
+export default memo(function ConnectionChart({ chartData }: { chartData: ChartData }) {
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+	const { t } = useLingui()
+
+	if (chartData.systemStats.length === 0) {
+		return null
+	}
+
+	const dataKeys = [
+		{
+			name: t`IPv4 Established`,
+			dataKey: "stats.nets.conn_established",
+			color: "hsl(220, 70%, 50%)", // Blue
+		},
+		{
+			name: t`IPv4 Listen`,
+			dataKey: "stats.nets.conn_listen",
+			color: "hsl(142, 70%, 45%)", // Green
+		},
+		{
+			name: t`IPv4 Time Wait`,
+			dataKey: "stats.nets.conn_timewait",
+			color: "hsl(48, 96%, 53%)", // Yellow
+		},
+		{
+			name: t`IPv4 Close Wait`,
+			dataKey: "stats.nets.conn_closewait",
+			color: "hsl(271, 81%, 56%)", // Purple
+		},
+		{
+			name: t`IPv4 Syn Recv`,
+			dataKey: "stats.nets.conn_synrecv",
+			color: "hsl(9, 78%, 56%)", // Red
+		},
+		{
+			name: t`IPv6 Established`,
+			dataKey: "stats.nets.conn6_established",
+			color: "hsl(220, 70%, 65%)", // Light Blue
+		},
+		{
+			name: t`IPv6 Listen`,
+			dataKey: "stats.nets.conn6_listen",
+			color: "hsl(142, 70%, 60%)", // Light Green
+		},
+		{
+			name: t`IPv6 Time Wait`,
+			dataKey: "stats.nets.conn6_timewait",
+			color: "hsl(48, 96%, 68%)", // Light Yellow
+		},
+		{
+			name: t`IPv6 Close Wait`,
+			dataKey: "stats.nets.conn6_closewait",
+			color: "hsl(271, 81%, 71%)", // Light Purple
+		},
+		{
+			name: t`IPv6 Syn Recv`,
+			dataKey: "stats.nets.conn6_synrecv",
+			color: "hsl(9, 78%, 71%)", // Light Red
+		},
+	]
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
+					"opacity-100": yAxisWidth,
+				})}
+			>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						direction="ltr"
+						orientation={chartData.orientation}
+						className="tracking-tighter"
+						width={yAxisWidth}
+						tickFormatter={(value) => updateYAxisWidth(value.toString())}
+						tickLine={false}
+						axisLine={false}
+					/>
+					{xAxis(chartData)}
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						content={
+							<ChartTooltipContent
+								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
+								contentFormatter={({ value }) => value.toString()}
+							/>
+						}
+					/>
+					<ChartLegend content={<ChartLegendContent />} />
+					{dataKeys.map((key, i) => (
+						<Area
+							key={i}
+							dataKey={key.dataKey}
+							name={key.name}
+							type="monotoneX"
+							fill={key.color}
+							fillOpacity={0.3}
+							stroke={key.color}
+							strokeOpacity={1}
+							isAnimationActive={false}
+						/>
+					))}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})

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

@@ -1,13 +1,13 @@
-// import Spinner from '../spinner'
-import { useStore } from "@nanostores/react"
-import { memo, useMemo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
 import { type ChartConfig, ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-import { ChartType, Unit } from "@/lib/enums"
+import { memo, useMemo } from "react"
+import { cn, formatShortDate, chartMargin, toFixedFloat, formatBytes, decimalString } from "@/lib/utils"
+// import Spinner from '../spinner'
+import { useStore } from "@nanostores/react"
 import { $containerFilter, $userSettings } from "@/lib/stores"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
 import type { ChartData } from "@/types"
 import { Separator } from "../ui/separator"
+import { ChartType, Unit } from "@/lib/enums"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function ContainerChart({
@@ -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)
+		const filterLower = filter.toLowerCase()
-		return new Set(Object.keys(chartConfig).filter((key) => {
+		return new Set(Object.keys(chartConfig).filter((key) => !key.toLowerCase().includes(filterLower)))
-			const keyLower = key.toLowerCase()
-			return !filterTerms.some(term => keyLower.includes(term))
-		}))
 	}, [chartConfig, filter])
 
 	// console.log('rendered at', new Date())

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

@@ -1,10 +1,10 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import { cn, formatShortDate, decimalString, chartMargin, formatBytes, toFixedFloat } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo } from "react"
+import { useLingui } from "@lingui/react/macro"
 import { Unit } from "@/lib/enums"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData, SystemStatsRecord } 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

@@ -1,5 +1,5 @@
-import { memo, useMemo } from "react"
 import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
+
 import {
 	ChartContainer,
 	ChartLegend,
@@ -8,59 +8,48 @@ import {
 	ChartTooltipContent,
 	xAxis,
 } from "@/components/ui/chart"
-import { chartMargin, cn, decimalString, formatShortDate, toFixedFloat } from "@/lib/utils"
+import { cn, formatShortDate, toFixedFloat, decimalString, chartMargin } from "@/lib/utils"
-import type { ChartData, GPUData } from "@/types"
+import { ChartData } from "@/types"
+import { memo, useMemo } from "react"
 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 (let data of chartData.systemStats) {
+			let newData = { created: data.created } as Record<string, number | string>
+
+			for (let 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 (let 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 +57,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"
@@ -78,7 +67,7 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 						width={yAxisWidth}
 						tickFormatter={(value) => {
 							const val = toFixedFloat(value, 2)
-							return updateYAxisWidth(`${val}W`)
+							return updateYAxisWidth(val + "W")
 						}}
 						tickLine={false}
 						axisLine={false}
@@ -87,29 +76,29 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
-						// @ts-expect-error
+						// @ts-ignore
 						itemSorter={(a, b) => b.value - a.value}
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => `${decimalString(item.value)}W`}
+								contentFormatter={(item) => decimalString(item.value) + "W"}
 								// indicator="line"
 							/>
 						}
 					/>
-					{dataPoints.map((dataPoint) => (
+					{colors.map((key) => (
 						<Line
-							key={dataPoint.label}
+							key={key}
-							dataKey={dataPoint.dataKey}
+							dataKey={key}
-							name={dataPoint.label}
+							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/hooks.ts

@@ -1,6 +1,6 @@
 import { useMemo, useState } from "react"
-import type { ChartConfig } from "@/components/ui/chart"
+import { ChartConfig } from "@/components/ui/chart"
-import type { ChartData, SystemStats, SystemStatsRecord } from "@/types"
+import { ChartData } from "@/types"
 
 /** Chart configurations for CPU, memory, and network usage charts */
 export interface ContainerChartConfigs {
@@ -105,21 +105,3 @@ export function useYAxisWidth() {
 	}
 	return { yAxisWidth, updateYAxisWidth }
 }
-
-// Assures consistent colors for network interfaces
-export function useNetworkInterfaces(interfaces: SystemStats["ni"]) {
-	const keys = Object.keys(interfaces ?? {})
-	const sortedKeys = keys.sort((a, b) => (interfaces?.[b]?.[3] ?? 0) - (interfaces?.[a]?.[3] ?? 0))
-	return {
-		length: sortedKeys.length,
-		data: (index = 3) => {
-			return sortedKeys.map((key) => ({
-				label: key,
-				dataKey: ({ stats }: SystemStatsRecord) => stats?.ni?.[key]?.[index],
-				color: `hsl(${220 + (((sortedKeys.indexOf(key) * 360) / sortedKeys.length) % 360)}, 70%, 50%)`,
-
-				opacity: 0.3,
-			}))
-		},
-	}
-}

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

@@ -1,110 +0,0 @@
-import { useMemo } from "react"
-import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
-import {
-	ChartContainer,
-	ChartLegend,
-	ChartLegendContent,
-	ChartTooltip,
-	ChartTooltipContent,
-	xAxis,
-} from "@/components/ui/chart"
-import { chartMargin, cn, formatShortDate } from "@/lib/utils"
-import type { ChartData, SystemStatsRecord } from "@/types"
-import { useYAxisWidth } from "./hooks"
-
-export type DataPoint = {
-	label: string
-	dataKey: (data: SystemStatsRecord) => number | undefined
-	color: number | string
-}
-
-export default function LineChartDefault({
-	chartData,
-	max,
-	maxToggled,
-	tickFormatter,
-	contentFormatter,
-	dataPoints,
-	domain,
-	legend,
-	itemSorter,
-}: // logRender = false,
-{
-	chartData: ChartData
-	max?: number
-	maxToggled?: boolean
-	tickFormatter: (value: number, index: number) => string
-	contentFormatter: ({ value, payload }: { value: number; payload: SystemStatsRecord }) => string
-	dataPoints?: DataPoint[]
-	domain?: [number, number]
-	legend?: boolean
-	itemSorter?: (a: any, b: any) => number
-	// logRender?: boolean
-}) {
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: ignore
-	return useMemo(() => {
-		if (chartData.systemStats.length === 0) {
-			return null
-		}
-		// if (logRender) {
-		// 	console.log("Rendered at", new Date())
-		// }
-		return (
-			<div>
-				<ChartContainer
-					className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
-						"opacity-100": yAxisWidth,
-					})}
-				>
-					<LineChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
-						<CartesianGrid vertical={false} />
-						<YAxis
-							direction="ltr"
-							orientation={chartData.orientation}
-							className="tracking-tighter"
-							width={yAxisWidth}
-							domain={domain ?? [0, max ?? "auto"]}
-							tickFormatter={(value, index) => updateYAxisWidth(tickFormatter(value, index))}
-							tickLine={false}
-							axisLine={false}
-						/>
-						{xAxis(chartData)}
-						<ChartTooltip
-							animationEasing="ease-out"
-							animationDuration={150}
-							// @ts-expect-error
-							itemSorter={itemSorter}
-							content={
-								<ChartTooltipContent
-									labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-									contentFormatter={contentFormatter}
-								/>
-							}
-						/>
-						{dataPoints?.map((dataPoint) => {
-							let { color } = dataPoint
-							if (typeof color === "number") {
-								color = `var(--chart-${color})`
-							}
-							return (
-								<Line
-									key={dataPoint.label}
-									dataKey={dataPoint.dataKey}
-									name={dataPoint.label}
-									type="monotoneX"
-									dot={false}
-									strokeWidth={1.5}
-									stroke={color}
-									isAnimationActive={false}
-								/>
-							)
-						})}
-						{legend && <ChartLegend content={<ChartLegendContent />} />}
-					</LineChart>
-				</ChartContainer>
-			</div>
-		)
-	}, [chartData.systemStats.at(-1), yAxisWidth, maxToggled])
-}

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

@@ -1,6 +1,5 @@
-import { t } from "@lingui/core/macro"
-import { memo } from "react"
 import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
+
 import {
 	ChartContainer,
 	ChartLegend,
@@ -9,8 +8,10 @@ import {
 	ChartTooltipContent,
 	xAxis,
 } from "@/components/ui/chart"
-import { chartMargin, cn, decimalString, formatShortDate, toFixedFloat } from "@/lib/utils"
+import { cn, formatShortDate, toFixedFloat, decimalString, chartMargin } from "@/lib/utils"
-import type { ChartData, SystemStats } from "@/types"
+import { ChartData, SystemStats } from "@/types"
+import { memo } from "react"
+import { t } from "@lingui/core/macro"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function LoadAverageChart({ chartData }: { chartData: ChartData }) {
@@ -59,6 +60,8 @@ export default memo(function LoadAverageChart({ chartData }: { chartData: ChartD
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
+						// @ts-ignore
+						// itemSorter={(a, b) => b.value - a.value}
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
@@ -68,15 +71,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 (chartData.agentVersion.patch < 1) {
-							if (minor <= 12 && 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/mem-chart.tsx

@@ -1,10 +1,10 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import { cn, decimalString, formatShortDate, chartMargin, formatBytes, toFixedFloat } from "@/lib/utils"
+import { memo } from "react"
+import { ChartData } from "@/types"
+import { useLingui } from "@lingui/react/macro"
 import { Unit } from "@/lib/enums"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function MemChart({ chartData, showMax }: { chartData: ChartData; showMax: boolean }) {
@@ -53,7 +53,7 @@ export default memo(function MemChart({ chartData, showMax }: { chartData: Chart
 						animationDuration={150}
 						content={
 							<ChartTooltipContent
-								// @ts-expect-error
+								// @ts-ignore
 								itemSorter={(a, b) => a.order - b.order}
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
 								contentFormatter={({ value }) => {

internal/site/src/components/charts/network-interface-chart.tsx

@@ -0,0 +1,164 @@
+import { memo, useMemo } from "react"
+import { useLingui } from "@lingui/react/macro"
+import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+import {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	xAxis,
+	ChartLegend,
+	ChartLegendContent,
+} from "@/components/ui/chart"
+import { cn, formatShortDate, chartMargin, formatBytes, toFixedFloat, decimalString } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { useStore } from "@nanostores/react"
+import { $networkInterfaceFilter, $userSettings } from "@/lib/stores"
+import { Unit } from "@/lib/enums"
+import { useYAxisWidth } from "./hooks"
+
+const getNestedValue = (path: string, max = false, data: any): number | null => {
+	// path format is like "eth0.ns" or "eth0.nr"
+	// need to access data.stats.ni[interface][property]
+	const parts = path.split(".")
+	if (parts.length !== 2) return null
+
+	const [interfaceName, property] = parts
+	const propertyKey = property + (max ? "m" : "")
+
+	return data?.stats?.ni?.[interfaceName]?.[propertyKey] ?? null
+}
+
+export default memo(function NetworkInterfaceChart({
+	chartData,
+	maxToggled = false,
+	max,
+}: {
+	chartData: ChartData
+	maxToggled?: boolean
+	max?: number
+}) {
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+	const { i18n } = useLingui()
+	const networkInterfaceFilter = useStore($networkInterfaceFilter)
+	const userSettings = useStore($userSettings)
+
+	const { chartTime } = chartData
+	const showMax = chartTime !== "1h" && maxToggled
+
+	// Get network interface names from the latest stats
+	const networkInterfaces = useMemo(() => {
+		if (chartData.systemStats.length === 0) return []
+		const latestStats = chartData.systemStats[chartData.systemStats.length - 1]
+		const allInterfaces = Object.keys(latestStats.stats.ni || {})
+
+		// Filter interfaces based on filter value
+		if (networkInterfaceFilter) {
+			return allInterfaces.filter((iface) => iface.toLowerCase().includes(networkInterfaceFilter.toLowerCase()))
+		}
+
+		return allInterfaces
+	}, [chartData.systemStats, networkInterfaceFilter])
+
+	const dataKeys = useMemo(() => {
+		// Generate colors for each interface - each interface gets a unique hue
+		// and sent/received use different shades of that hue
+		const interfaceColors = networkInterfaces.map((iface, index) => {
+			const hue = ((index * 360) / Math.max(networkInterfaces.length, 1)) % 360
+			return {
+				interface: iface,
+				sentColor: `hsl(${hue}, 70%, 45%)`, // Darker shade for sent
+				receivedColor: `hsl(${hue}, 70%, 65%)`, // Lighter shade for received
+			}
+		})
+
+		return interfaceColors.flatMap(({ interface: iface, sentColor, receivedColor }) => [
+			{
+				name: `${iface} Sent`,
+				dataKey: `${iface}.ns`,
+				color: sentColor,
+				type: "sent" as const,
+				interface: iface,
+			},
+			{
+				name: `${iface} Received`,
+				dataKey: `${iface}.nr`,
+				color: receivedColor,
+				type: "received" as const,
+				interface: iface,
+			},
+		])
+	}, [networkInterfaces, i18n.locale])
+
+	const colors = dataKeys.map((key) => key.name)
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
+					"opacity-100": yAxisWidth,
+				})}
+			>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						direction="ltr"
+						orientation={chartData.orientation}
+						className="tracking-tighter"
+						width={yAxisWidth}
+						tickFormatter={(value) => {
+							const { value: formattedValue, unit } = formatBytes(value, true, userSettings.unitNet ?? Unit.Bits, true)
+							const rounded = toFixedFloat(formattedValue, formattedValue >= 10 ? 1 : 2)
+							return updateYAxisWidth(`${rounded} ${unit}`)
+						}}
+						tickLine={false}
+						axisLine={false}
+					/>
+					{xAxis(chartData)}
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						content={
+							<ChartTooltipContent
+								labelFormatter={(_: any, data: any) => formatShortDate(data[0].payload.created)}
+								contentFormatter={({ value }: any) => {
+									const { value: formattedValue, unit } = formatBytes(
+										value,
+										true,
+										userSettings.unitNet ?? Unit.Bits,
+										true
+									)
+									return (
+										<span className="flex">
+											{decimalString(formattedValue, formattedValue >= 10 ? 1 : 2)} {unit}
+										</span>
+									)
+								}}
+							/>
+						}
+					/>
+					{dataKeys.map((key, i) => {
+						const filtered =
+							networkInterfaceFilter && !key.interface.toLowerCase().includes(networkInterfaceFilter.toLowerCase())
+						let fillOpacity = filtered ? 0.05 : 0.4
+						let strokeOpacity = filtered ? 0.1 : 1
+						return (
+							<Area
+								key={i}
+								dataKey={getNestedValue.bind(null, key.dataKey, showMax)}
+								name={key.name}
+								type="monotoneX"
+								fill={key.color}
+								fillOpacity={fillOpacity}
+								stroke={key.color}
+								strokeOpacity={strokeOpacity}
+								activeDot={{ opacity: filtered ? 0 : 1 }}
+								isAnimationActive={false}
+							/>
+						)
+					})}
+					{colors.length < 12 && <ChartLegend content={<ChartLegendContent />} />}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})

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

@@ -1,11 +1,12 @@
 import { t } from "@lingui/core/macro"
-import { useStore } from "@nanostores/react"
+
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import { cn, formatShortDate, decimalString, chartMargin, formatBytes, toFixedFloat } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo } from "react"
 import { $userSettings } from "@/lib/stores"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
+import { useStore } from "@nanostores/react"
-import type { ChartData } from "@/types"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function SwapChart({ chartData }: { chartData: ChartData }) {

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

@@ -1,6 +1,5 @@
-import { useStore } from "@nanostores/react"
-import { memo, useMemo } from "react"
 import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
+
 import {
 	ChartContainer,
 	ChartLegend,
@@ -9,9 +8,11 @@ import {
 	ChartTooltipContent,
 	xAxis,
 } from "@/components/ui/chart"
+import { cn, formatShortDate, toFixedFloat, chartMargin, formatTemperature, decimalString } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo, useMemo } from "react"
 import { $temperatureFilter, $userSettings } from "@/lib/stores"
-import { chartMargin, cn, decimalString, formatShortDate, formatTemperature, toFixedFloat } from "@/lib/utils"
+import { useStore } from "@nanostores/react"
-import type { ChartData } from "@/types"
 import { useYAxisWidth } from "./hooks"
 
 export default memo(function TemperatureChart({ chartData }: { chartData: ChartData }) {
@@ -30,18 +31,18 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 			colors: Record<string, string>
 		}
 		const tempSums = {} as Record<string, number>
-		for (const data of chartData.systemStats) {
+		for (let data of chartData.systemStats) {
-			const newData = { created: data.created } as Record<string, number | string>
+			let newData = { created: data.created } as Record<string, number | string>
-			const keys = Object.keys(data.stats?.t ?? {})
+			let keys = Object.keys(data.stats?.t ?? {})
 			for (let i = 0; i < keys.length; i++) {
-				const key = keys[i]
+				let key = keys[i]
 				newData[key] = data.stats.t![key]
 				tempSums[key] = (tempSums[key] ?? 0) + newData[key]
 			}
 			newChartData.data.push(newData)
 		}
 		const keys = Object.keys(tempSums).sort((a, b) => tempSums[b] - tempSums[a])
-		for (const key of keys) {
+		for (let key of keys) {
 			newChartData.colors[key] = `hsl(${((keys.indexOf(key) * 360) / keys.length) % 360}, 60%, 55%)`
 		}
 		return newChartData
@@ -64,7 +65,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)
@@ -77,7 +78,7 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
-						// @ts-expect-error
+						// @ts-ignore
 						itemSorter={(a, b) => b.value - a.value}
 						content={
 							<ChartTooltipContent
@@ -91,9 +92,8 @@ export default memo(function TemperatureChart({ chartData }: { chartData: ChartD
 						}
 					/>
 					{colors.map((key) => {
-						const filterTerms = filter ? filter.toLowerCase().split(" ").filter(term => term.length > 0) : []
+						const filtered = filter && !key.toLowerCase().includes(filter.toLowerCase())
-						const filtered = filterTerms.length > 0 && !filterTerms.some(term => key.toLowerCase().includes(term))
+						let strokeOpacity = filtered ? 0.1 : 1
-						const strokeOpacity = filtered ? 0.1 : 1
 						return (
 							<Line
 								key={key}

internal/site/src/components/charts/total-bandwidth-chart.tsx

@@ -0,0 +1,159 @@
+import { memo, useMemo } from "react"
+import { useLingui } from "@lingui/react/macro"
+import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+import {
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+	ChartLegend,
+	ChartLegendContent,
+	xAxis,
+} from "@/components/ui/chart"
+import { cn, formatShortDate, chartMargin, formatBytes, toFixedFloat, decimalString } from "@/lib/utils"
+import { ChartData } from "@/types"
+import { useStore } from "@nanostores/react"
+import { $userSettings } from "@/lib/stores"
+import { Unit } from "@/lib/enums"
+import { useYAxisWidth } from "./hooks"
+
+const getPerInterfaceBandwidth = (data: any): Record<string, { sent: number; recv: number }> | null => {
+	const networkInterfaces = data?.stats?.ni
+	if (!networkInterfaces) {
+		return null
+	}
+
+	const interfaceData: Record<string, { sent: number; recv: number }> = {}
+	let hasData = false
+
+	Object.entries(networkInterfaces).forEach(([name, iface]: [string, any]) => {
+		if (iface.tbs || iface.tbr) {
+			interfaceData[name] = {
+				sent: iface.tbs || 0,
+				recv: iface.tbr || 0,
+			}
+			hasData = true
+		}
+	})
+
+	return hasData ? interfaceData : null
+}
+
+export default memo(function TotalBandwidthChart({ chartData }: { chartData: ChartData }) {
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+	const { i18n } = useLingui()
+	const userSettings = useStore($userSettings)
+
+	// Transform data to include per-interface bandwidth
+	const { transformedData, interfaceNames } = useMemo(() => {
+		const allInterfaces = new Set<string>()
+
+		// First pass: collect all interface names
+		chartData.systemStats.forEach((dataPoint) => {
+			const interfaceData = getPerInterfaceBandwidth(dataPoint)
+			if (interfaceData) {
+				Object.keys(interfaceData).forEach((name) => allInterfaces.add(name))
+			}
+		})
+
+		const interfaceNames = Array.from(allInterfaces).sort()
+
+		// Second pass: transform data with per-interface values
+		const transformedData = chartData.systemStats.map((dataPoint) => {
+			const interfaceData = getPerInterfaceBandwidth(dataPoint)
+			const result: any = { ...dataPoint }
+
+			interfaceNames.forEach((interfaceName) => {
+				const data = interfaceData?.[interfaceName]
+				result[`${interfaceName}_sent`] = data?.sent || 0
+				result[`${interfaceName}_recv`] = data?.recv || 0
+			})
+
+			return result
+		})
+
+		return { transformedData, interfaceNames }
+	}, [chartData.systemStats])
+
+	// Generate dynamic data keys for each interface using same color scheme as NetworkInterfaceChart
+	const dataKeys = useMemo(() => {
+		const keys: Array<{ name: string; dataKey: string; color: string }> = []
+
+		interfaceNames.forEach((interfaceName, index) => {
+			// Use the same color calculation as NetworkInterfaceChart
+			const hue = ((index * 360) / Math.max(interfaceNames.length, 1)) % 360
+
+			keys.push({
+				name: `${interfaceName} Sent`,
+				dataKey: `${interfaceName}_sent`,
+				color: `hsl(${hue}, 70%, 45%)`, // Darker shade for sent (same as NetworkInterfaceChart)
+			})
+
+			keys.push({
+				name: `${interfaceName} Received`,
+				dataKey: `${interfaceName}_recv`,
+				color: `hsl(${hue}, 70%, 65%)`, // Lighter shade for received (same as NetworkInterfaceChart)
+			})
+		})
+
+		return keys
+	}, [interfaceNames])
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
+					"opacity-100": yAxisWidth,
+				})}
+			>
+				<AreaChart accessibilityLayer data={transformedData} margin={chartMargin}>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						direction="ltr"
+						orientation={chartData.orientation}
+						className="tracking-tighter"
+						width={yAxisWidth}
+						tickFormatter={(value) => {
+							const { value: formattedValue, unit } = formatBytes(value, false, userSettings.unitNet ?? Unit.Bytes)
+							const rounded = toFixedFloat(formattedValue, formattedValue >= 10 ? 1 : 2)
+							return updateYAxisWidth(`${rounded} ${unit}`)
+						}}
+						tickLine={false}
+						axisLine={false}
+					/>
+					{xAxis(chartData)}
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						content={
+							<ChartTooltipContent
+								labelFormatter={(_: any, data: any) => formatShortDate(data[0].payload.created)}
+								contentFormatter={({ value }: any) => {
+									const { value: formattedValue, unit } = formatBytes(value, false, userSettings.unitNet ?? Unit.Bytes)
+									return (
+										<span className="flex">
+											{decimalString(formattedValue, formattedValue >= 10 ? 1 : 2)} {unit}
+										</span>
+									)
+								}}
+							/>
+						}
+					/>
+					<ChartLegend content={<ChartLegendContent />} />
+					{dataKeys.map((key, i) => (
+						<Area
+							key={i}
+							dataKey={key.dataKey}
+							name={key.name}
+							type="monotoneX"
+							fill={key.color}
+							fillOpacity={0.3}
+							stroke={key.color}
+							strokeOpacity={1}
+							isAnimationActive={false}
+						/>
+					))}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})

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

@@ -1,11 +1,6 @@
-import { t } from "@lingui/core/macro"
-import { Trans } from "@lingui/react/macro"
-import { getPagePath } from "@nanostores/router"
-import { DialogDescription } from "@radix-ui/react-dialog"
 import {
 	AlertOctagonIcon,
 	BookIcon,
-	ContainerIcon,
 	DatabaseBackupIcon,
 	FingerprintIcon,
 	LayoutDashboard,
@@ -15,7 +10,7 @@ import {
 	SettingsIcon,
 	UsersIcon,
 } from "lucide-react"
-import { memo, useEffect, useMemo } from "react"
+
 import {
 	CommandDialog,
 	CommandEmpty,
@@ -26,10 +21,15 @@ import {
 	CommandSeparator,
 	CommandShortcut,
 } from "@/components/ui/command"
-import { isAdmin } from "@/lib/api"
+import { memo, useEffect, useMemo } from "react"
 import { $systems } from "@/lib/stores"
 import { getHostDisplayValue, listen } from "@/lib/utils"
 import { $router, basePath, navigate, prependBasePath } from "./router"
+import { Trans } from "@lingui/react/macro"
+import { t } from "@lingui/core/macro"
+import { getPagePath } from "@nanostores/router"
+import { DialogDescription } from "@radix-ui/react-dialog"
+import { isAdmin } from "@/lib/api"
 
 export default memo(function CommandPalette({ open, setOpen }: { open: boolean; setOpen: (open: boolean) => void }) {
 	useEffect(() => {
@@ -66,7 +66,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 +81,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 +95,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,496 +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) => {
-			const changeTime = Date.now()
-			setTimeout(() => fetchData(Date.now() - changeTime + 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 logsHtml.logs ? highlighter.codeToHtml(logsHtml.logs, { lang: "log", theme: syntaxTheme }) : t`No results.`
-	} 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 info ? highlighter.codeToHtml(info, { lang: "json", theme: syntaxTheme }) : t`No results.`
-	} 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/copy-to-clipboard.tsx

@@ -1,8 +1,8 @@
-import { Trans } from "@lingui/react/macro"
+import { Trans } from "@lingui/react/macro";
 import { useEffect, useMemo, useRef } from "react"
-import { $copyContent } from "@/lib/stores"
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "./ui/dialog"
 import { Textarea } from "./ui/textarea"
+import { $copyContent } from "@/lib/stores"
 
 export default function CopyToClipboard({ content }: { content: string }) {
 	return (

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/install-dropdowns.tsx

@@ -1,7 +1,7 @@
-import { i18n } from "@lingui/core"
 import { memo } from "react"
-import { copyToClipboard, getHubURL } from "@/lib/utils"
 import { DropdownMenuContent, DropdownMenuItem } from "./ui/dropdown-menu"
+import { copyToClipboard, getHubURL } from "@/lib/utils"
+import { i18n } from "@lingui/core"
 
 // const isbeta = beszel.hub_version.includes("beta")
 // const imagetag = isbeta ? ":edge" : ""

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

@@ -1,10 +1,11 @@
-import { useLingui } from "@lingui/react/macro"
 import { LanguagesIcon } from "lucide-react"
+
 import { Button } from "@/components/ui/button"
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu"
-import { dynamicActivate } from "@/lib/i18n"
 import languages from "@/lib/languages"
 import { cn } from "@/lib/utils"
+import { useLingui } from "@lingui/react/macro"
+import { dynamicActivate } from "@/lib/i18n"
 
 export function LangToggle() {
 	const { i18n } = useLingui()
@@ -12,7 +13,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/login/auth-form.tsx

@@ -1,19 +1,19 @@
 import { t } from "@lingui/core/macro"
 import { Trans } from "@lingui/react/macro"
-import { getPagePath } from "@nanostores/router"
+import { cn } from "@/lib/utils"
-import { KeyIcon, LoaderCircle, LockIcon, LogInIcon, MailIcon } from "lucide-react"
-import type { AuthMethodsList, AuthProviderInfo, OAuth2AuthConfig } from "pocketbase"
-import { useCallback, useEffect, useState } from "react"
-import * as v from "valibot"
 import { buttonVariants } from "@/components/ui/button"
-import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog"
 import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
-import { pb } from "@/lib/api"
+import { KeyIcon, LoaderCircle, LockIcon, LogInIcon, MailIcon } from "lucide-react"
 import { $authenticated } from "@/lib/stores"
-import { cn } from "@/lib/utils"
+import * as v from "valibot"
-import { $router, Link, prependBasePath } from "../router"
 import { toast } from "../ui/use-toast"
+import { Dialog, DialogContent, DialogTrigger, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { useCallback, useEffect, useState } from "react"
+import { AuthMethodsList, AuthProviderInfo, OAuth2AuthConfig } from "pocketbase"
+import { $router, Link, prependBasePath } from "../router"
+import { getPagePath } from "@nanostores/router"
+import { pb } from "@/lib/api"
 import { OtpInputForm } from "./otp-forms"
 
 const honeypot = v.literal("")
@@ -83,9 +83,9 @@ export function UserAuthForm({
 				const result = v.safeParse(Schema, data)
 				if (!result.success) {
 					console.log(result)
-					const errors = {}
+					let errors = {}
 					for (const issue of result.issues) {
-						// @ts-expect-error
+						// @ts-ignore
 						errors[issue.path[0].key] = issue.message
 					}
 					setErrors(errors)
@@ -96,7 +96,7 @@ export function UserAuthForm({
 				if (isFirstRun) {
 					// check that passwords match
 					if (password !== passwordConfirm) {
-						const msg = "Passwords do not match"
+						let msg = "Passwords do not match"
 						setErrors({ passwordConfirm: msg })
 						return
 					}