fix: send battery stats even if some batteries are missing stats (#1287)

Implement battery error reporting mechanism

Added error reporting for battery information retrieval.

Handles cases like bluetooth devices where `battery` finds it but it has incomplete information about that battery, which would have otherwise caused a null pointer error.

Related: #1254

.dockerignore

@@ -0,0 +1,48 @@
+# Node.js dependencies
+node_modules
+internalsite/node_modules
+
+# Go build artifacts and binaries
+build
+dist
+*.exe
+beszel-agent
+beszel_data*
+pb_data
+data
+temp
+
+# Development and IDE files
+.vscode
+.idea*
+*.swc
+__debug_*
+
+# Git and version control
+.git
+.gitignore
+
+# Documentation and supplemental files
+*.md
+supplemental
+freebsd-port
+
+# Test files (exclude from production builds)
+*_test.go
+coverage
+
+# Docker files
+dockerfile_*
+
+# Temporary files
+*.tmp
+*.bak
+*.log
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+# .NET build artifacts
+agent/lhm/obj
+agent/lhm/bin

.github/workflows/docker-images.yml

@@ -12,49 +12,137 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          # henrygd/beszel
           - image: henrygd/beszel
-            context: ./beszel
-            dockerfile: ./beszel/dockerfile_hub
+            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: ./beszel
-            dockerfile: ./beszel/dockerfile_agent
+            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: ./beszel
-            dockerfile: ./beszel/dockerfile_agent_nvidia
+            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: ./beszel
-            dockerfile: ./beszel/dockerfile_hub
+            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: ./beszel
-            dockerfile: ./beszel/dockerfile_agent
+            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: ./beszel
-            dockerfile: ./beszel/dockerfile_agent_nvidia
+            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
@@ -68,10 +156,10 @@ jobs:
         uses: oven-sh/setup-bun@v2
 
       - name: Install dependencies
-        run: bun install --no-save --cwd ./beszel/site
+        run: bun install --no-save --cwd ./internal/site
 
       - name: Build site
-        run: bun run --cwd ./beszel/site build
+        run: bun run --cwd ./internal/site build
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -84,17 +172,12 @@ jobs:
         uses: docker/metadata-action@v5
         with:
           images: ${{ matrix.image }}
-          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' }}
+          tags: ${{ matrix.tags }}
 
       # https://github.com/docker/login-action
       - name: Login to Docker Hub
-        env: 
-            password_secret_exists: ${{ secrets[matrix.password_secret] != '' && 'true' || 'false' }}
+        env:
+          password_secret_exists: ${{ secrets[matrix.password_secret] != '' && 'true' || 'false' }}
         if: github.event_name != 'pull_request' && env.password_secret_exists == 'true'
         uses: docker/login-action@v3
         with:
@@ -107,7 +190,7 @@ jobs:
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
-          context: "${{ matrix.context }}"
+          context: ./
           file: ${{ matrix.dockerfile }}
           platforms: ${{ matrix.platforms || 'linux/amd64,linux/arm64,linux/arm/v7' }}
           push: ${{ github.ref_type == 'tag' && secrets[matrix.password_secret] != '' }}

.github/workflows/release.yml

@@ -21,10 +21,10 @@ jobs:
         uses: oven-sh/setup-bun@v2
 
       - name: Install dependencies
-        run: bun install --no-save --cwd ./beszel/site
+        run: bun install --no-save --cwd ./internal/site
 
       - name: Build site
-        run: bun run --cwd ./beszel/site build
+        run: bun run --cwd ./internal/site build
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -38,13 +38,13 @@ jobs:
 
       - name: Build .NET LHM executable for Windows sensors
         run: |
-          dotnet build -c Release ./beszel/internal/agent/lhm/beszel_lhm.csproj
+          dotnet build -c Release ./agent/lhm/beszel_lhm.csproj
         shell: bash
 
       - name: GoReleaser beszel
         uses: goreleaser/goreleaser-action@v6
         with:
-          workdir: ./beszel
+          workdir: ./
           distribution: goreleaser
           version: latest
           args: release --clean

.github/workflows/vulncheck.yml

@@ -15,7 +15,7 @@ permissions:
 
 jobs:
   vulncheck:
-    name: Analysis
+    name: VulnCheck
     runs-on: ubuntu-latest
     steps:
       - name: Check out code into the Go module directory
@@ -23,11 +23,11 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.24.x
-          cached: false
+          go-version: 1.25.x
+          # cached: false
       - name: Get official govulncheck
         run: go install golang.org/x/vuln/cmd/govulncheck@latest
         shell: bash
       - name: Run govulncheck
-        run: govulncheck -C ./beszel -show verbose ./...
+        run: govulncheck -show verbose ./...
         shell: bash

.gitignore

@@ -8,15 +8,15 @@ beszel_data
 beszel_data*
 dist
 *.exe
-beszel/cmd/hub/hub
-beszel/cmd/agent/agent
+internal/cmd/hub/hub
+internal/cmd/agent/agent
 node_modules
-beszel/build
+build
 *timestamp*
 .swc
-beszel/site/src/locales/**/*.ts
+internal/site/src/locales/**/*.ts
 *.bak
 __debug_*
-beszel/internal/agent/lhm/obj
-beszel/internal/agent/lhm/bin
+agent/lhm/obj
+agent/lhm/bin
 dockerfile_agent_dev

.goreleaser.yml

@@ -9,7 +9,7 @@ before:
 builds:
   - id: beszel
     binary: beszel
-    main: cmd/hub/hub.go
+    main: internal/cmd/hub/hub.go
     env:
       - CGO_ENABLED=0
     goos:
@@ -22,7 +22,7 @@ builds:
 
   - id: beszel-agent
     binary: beszel-agent
-    main: cmd/agent/agent.go
+    main: internal/cmd/agent/agent.go
     env:
       - CGO_ENABLED=0
     goos:
@@ -103,28 +103,28 @@ nfpms:
     formats:
       - deb
     contents:
-      - src: ../supplemental/debian/beszel-agent.service
+      - src: ./supplemental/debian/beszel-agent.service
         dst: lib/systemd/system/beszel-agent.service
         packager: deb
-      - src: ../supplemental/debian/copyright
+      - src: ./supplemental/debian/copyright
         dst: usr/share/doc/beszel-agent/copyright
         packager: deb
-      - src: ../supplemental/debian/lintian-overrides
+      - src: ./supplemental/debian/lintian-overrides
         dst: usr/share/lintian/overrides/beszel-agent
         packager: deb
     scripts:
-      postinstall: ../supplemental/debian/postinstall.sh
-      preremove: ../supplemental/debian/prerm.sh
-      postremove: ../supplemental/debian/postrm.sh
+      postinstall: ./supplemental/debian/postinstall.sh
+      preremove: ./supplemental/debian/prerm.sh
+      postremove: ./supplemental/debian/postrm.sh
     deb:
       predepends:
         - adduser
         - debconf
       scripts:
-        templates: ../supplemental/debian/templates
+        templates: ./supplemental/debian/templates
         # Currently broken due to a bug in goreleaser
         # https://github.com/goreleaser/goreleaser/issues/5487
-        #config: ../supplemental/debian/config.sh
+        #config: ./supplemental/debian/config.sh
 
 scoops:
   - ids: [beszel-agent]
@@ -135,7 +135,7 @@ scoops:
     homepage: "https://beszel.dev"
     description: "Agent for Beszel, a lightweight server monitoring platform."
     license: MIT
-    skip_upload: "{{ if .Env.IS_FORK }}true{{ else }}auto{{ end }}"
+    skip_upload: '{{ if eq (tolower .Env.IS_FORK) "true" }}true{{ else }}auto{{ end }}'
 
 # # Needs choco installed, so doesn't build on linux / default gh workflow :(
 # chocolateys:
@@ -169,7 +169,7 @@ brews:
     homepage: "https://beszel.dev"
     description: "Agent for Beszel, a lightweight server monitoring platform."
     license: MIT
-    skip_upload: "{{ if .Env.IS_FORK }}true{{ else }}auto{{ end }}"
+    skip_upload: '{{ if eq (tolower .Env.IS_FORK) "true" }}true{{ else }}auto{{ end }}'
     extra_install: |
       (bin/"beszel-agent-launcher").write <<~EOS
         #!/bin/bash
@@ -201,7 +201,7 @@ winget:
     release_notes_url: "https://github.com/henrygd/beszel/releases/tag/v{{ .Version }}"
     publisher_support_url: "https://github.com/henrygd/beszel/issues"
     short_description: "Agent for Beszel, a lightweight server monitoring platform."
-    skip_upload: "{{ if .Env.IS_FORK }}true{{ else }}auto{{ end }}"
+    skip_upload: '{{ if eq (tolower .Env.IS_FORK) "true" }}true{{ else }}auto{{ end }}'
     description: |
       Beszel is a lightweight server monitoring platform that includes Docker
       statistics, historical data, and alert functions. It has a friendly web

Makefile

@@ -26,11 +26,11 @@ tidy:
 
 build-web-ui:
 	@if command -v bun >/dev/null 2>&1; then \
-		bun install --cwd ./site && \
-		bun run --cwd ./site build; \
+		bun install --cwd ./internal/site && \
+		bun run --cwd ./internal/site build; \
 	else \
-		npm install --prefix ./site && \
-		npm run --prefix ./site build; \
+		npm install --prefix ./internal/site && \
+		npm run --prefix ./internal/site build; \
 	fi
 
 # Conditional .NET build - only for Windows
@@ -38,8 +38,8 @@ build-dotnet-conditional:
 	@if [ "$(OS)" = "windows" ]; then \
 		echo "Building .NET executable for Windows..."; \
 		if command -v dotnet >/dev/null 2>&1; then \
-			rm -rf ./internal/agent/lhm/bin; \
-			dotnet build -c Release ./internal/agent/lhm/beszel_lhm.csproj; \
+			rm -rf ./agent/lhm/bin; \
+			dotnet build -c Release ./agent/lhm/beszel_lhm.csproj; \
 		else \
 			echo "Error: dotnet not found. Install .NET SDK to build Windows agent."; \
 			exit 1; \
@@ -48,51 +48,51 @@ build-dotnet-conditional:
 
 # Update build-agent to include conditional .NET build
 build-agent: tidy build-dotnet-conditional
-	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel-agent_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" beszel/cmd/agent
+	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel-agent_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/agent
 
 build-hub: tidy $(if $(filter false,$(SKIP_WEB)),build-web-ui)
-	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" beszel/cmd/hub
+	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/hub
 
 build-hub-dev: tidy
-	mkdir -p ./site/dist && touch ./site/dist/index.html
-	GOOS=$(OS) GOARCH=$(ARCH) go build -tags development -o ./build/beszel-dev_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" beszel/cmd/hub
+	mkdir -p ./internal/site/dist && touch ./internal/site/dist/index.html
+	GOOS=$(OS) GOARCH=$(ARCH) go build -tags development -o ./build/beszel-dev_$(OS)_$(ARCH)$(EXE_EXT) -ldflags "-w -s" ./internal/cmd/hub
 
 build: build-agent build-hub
 
 generate-locales:
-	@if [ ! -f ./site/src/locales/en/en.ts ]; then \
+	@if [ ! -f ./internal/site/src/locales/en/en.ts ]; then \
 		echo "Generating locales..."; \
-		command -v bun >/dev/null 2>&1 && cd ./site && bun install && bun run sync || cd ./site && npm install && npm run sync; \
+		command -v bun >/dev/null 2>&1 && cd ./internal/site && bun install && bun run sync || cd ./internal/site && npm install && npm run sync; \
 	fi
 
 dev-server: generate-locales
-	cd ./site
+	cd ./internal/site
 	@if command -v bun >/dev/null 2>&1; then \
-		cd ./site && bun run dev --host 0.0.0.0; \
+		cd ./internal/site && bun run dev --host 0.0.0.0; \
 	else \
-		cd ./site && npm run dev --host 0.0.0.0; \
+		cd ./internal/site && npm run dev --host 0.0.0.0; \
 	fi
 
 dev-hub: export ENV=dev
 dev-hub:
-	mkdir -p ./site/dist && touch ./site/dist/index.html
+	mkdir -p ./internal/site/dist && touch ./internal/site/dist/index.html
 	@if command -v entr >/dev/null 2>&1; then \
-		find ./cmd/hub/*.go ./internal/{alerts,hub,records,users}/*.go | entr -r -s "cd ./cmd/hub && go run -tags development . serve --http 0.0.0.0:8090"; \
+		find ./internal -type f -name '*.go' | entr -r -s "cd ./internal/cmd/hub && go run -tags development . serve --http 0.0.0.0:8090"; \
 	else \
-		cd ./cmd/hub && go run -tags development . serve --http 0.0.0.0:8090; \
+		cd ./internal/cmd/hub && go run -tags development . serve --http 0.0.0.0:8090; \
 	fi
 
 dev-agent:
 	@if command -v entr >/dev/null 2>&1; then \
-		find ./cmd/agent/*.go ./internal/agent/*.go | entr -r go run beszel/cmd/agent; \
+		find ./internal/cmd/agent/*.go ./agent/*.go | entr -r go run github.com/henrygd/beszel/internal/cmd/agent; \
 	else \
-		go run beszel/cmd/agent; \
+		go run github.com/henrygd/beszel/internal/cmd/agent; \
 	fi
 	
 build-dotnet:
 	@if command -v dotnet >/dev/null 2>&1; then \
-		rm -rf ./internal/agent/lhm/bin; \
-		dotnet build -c Release ./internal/agent/lhm/beszel_lhm.csproj; \
+		rm -rf ./agent/lhm/bin; \
+		dotnet build -c Release ./agent/lhm/beszel_lhm.csproj; \
 	else \
 		echo "dotnet not found"; \
 	fi

agent/agent.go

@@ -0,0 +1,207 @@
+// Package agent implements the Beszel monitoring agent that collects and serves system metrics.
+//
+// The agent runs on monitored systems and communicates collected data
+// to the Beszel hub for centralized monitoring and alerting.
+package agent
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/gliderlabs/ssh"
+	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/agent/deltatracker"
+	"github.com/henrygd/beszel/internal/entities/system"
+	"github.com/shirou/gopsutil/v4/host"
+	gossh "golang.org/x/crypto/ssh"
+)
+
+type Agent struct {
+	sync.Mutex                                                                      // Used to lock agent while collecting data
+	debug                     bool                                                  // true if LOG_LEVEL is set to debug
+	zfs                       bool                                                  // true if system has arcstats
+	memCalc                   string                                                // Memory calculation formula
+	fsNames                   []string                                              // List of filesystem device names being monitored
+	fsStats                   map[string]*system.FsStats                            // Keeps track of disk stats for each filesystem
+	diskPrev                  map[uint16]map[string]prevDisk                        // Previous disk I/O counters per cache interval
+	netInterfaces             map[string]struct{}                                   // Stores all valid network interfaces
+	netIoStats                map[uint16]system.NetIoStats                          // Keeps track of bandwidth usage per cache interval
+	netInterfaceDeltaTrackers map[uint16]*deltatracker.DeltaTracker[string, uint64] // Per-cache-time NIC delta trackers
+	dockerManager             *dockerManager                                        // Manages Docker API requests
+	sensorConfig              *SensorConfig                                         // Sensors config
+	systemInfo                system.Info                                           // Host system info
+	gpuManager                *GPUManager                                           // Manages GPU data
+	cache                     *systemDataCache                                      // Cache for system stats based on cache time
+	connectionManager         *ConnectionManager                                    // Channel to signal connection events
+	handlerRegistry           *HandlerRegistry                                      // Registry for routing incoming messages
+	server                    *ssh.Server                                           // SSH server
+	dataDir                   string                                                // Directory for persisting data
+	keys                      []gossh.PublicKey                                     // SSH public keys
+	smartManager              *SmartManager                                         // Manages SMART data
+}
+
+// NewAgent creates a new agent with the given data directory for persisting data.
+// If the data directory is not set, it will attempt to find the optimal directory.
+func NewAgent(dataDir ...string) (agent *Agent, err error) {
+	agent = &Agent{
+		fsStats: make(map[string]*system.FsStats),
+		cache:   NewSystemDataCache(),
+	}
+
+	// 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")
+	} else {
+		slog.Info("Data directory", "path", agent.dataDir)
+	}
+
+	agent.memCalc, _ = GetEnv("MEM_CALC")
+	agent.sensorConfig = agent.newSensorConfig()
+	// Set up slog with a log level determined by the LOG_LEVEL env var
+	if logLevelStr, exists := GetEnv("LOG_LEVEL"); exists {
+		switch strings.ToLower(logLevelStr) {
+		case "debug":
+			agent.debug = true
+			slog.SetLogLoggerLevel(slog.LevelDebug)
+		case "warn":
+			slog.SetLogLoggerLevel(slog.LevelWarn)
+		case "error":
+			slog.SetLogLoggerLevel(slog.LevelError)
+		}
+	}
+
+	slog.Debug(beszel.Version)
+
+	// initialize system info
+	agent.initializeSystemInfo()
+
+	// initialize connection manager
+	agent.connectionManager = newConnectionManager(agent)
+
+	// initialize handler registry
+	agent.handlerRegistry = NewHandlerRegistry()
+
+	// initialize disk info
+	agent.initializeDiskInfo()
+
+	// initialize net io stats
+	agent.initializeNetIoStats()
+
+	// initialize docker manager
+	agent.dockerManager = newDockerManager(agent)
+
+	agent.smartManager, err = NewSmartManager()
+	if err != nil {
+		slog.Debug("SMART", "err", err)
+	}
+
+	// initialize GPU manager
+	agent.gpuManager, err = NewGPUManager()
+	if err != nil {
+		slog.Debug("GPU", "err", err)
+	}
+
+	// if debugging, print stats
+	if agent.debug {
+		slog.Debug("Stats", "data", agent.gatherStats(0))
+	}
+
+	return agent, nil
+}
+
+// GetEnv retrieves an environment variable with a "BESZEL_AGENT_" prefix, or falls back to the unprefixed key.
+func GetEnv(key string) (value string, exists bool) {
+	if value, exists = os.LookupEnv("BESZEL_AGENT_" + key); exists {
+		return value, exists
+	}
+	// Fallback to the old unprefixed key
+	return os.LookupEnv(key)
+}
+
+func (a *Agent) gatherStats(cacheTimeMs uint16) *system.CombinedData {
+	a.Lock()
+	defer a.Unlock()
+
+	data, isCached := a.cache.Get(cacheTimeMs)
+	if isCached {
+		slog.Debug("Cached data", "cacheTimeMs", cacheTimeMs)
+		return data
+	}
+
+	*data = system.CombinedData{
+		Stats: a.getSystemStats(cacheTimeMs),
+		Info:  a.systemInfo,
+	}
+	// slog.Info("System data", "data", data, "cacheTimeMs", cacheTimeMs)
+
+	if a.dockerManager != nil {
+		if containerStats, err := a.dockerManager.getDockerStats(cacheTimeMs); err == nil {
+			data.Containers = containerStats
+			slog.Debug("Containers", "data", data.Containers)
+		} else {
+			slog.Debug("Containers", "err", err)
+		}
+	}
+
+	data.Stats.ExtraFs = make(map[string]*system.FsStats)
+	for name, stats := range a.fsStats {
+		if !stats.Root && stats.DiskTotal > 0 {
+			// Use custom name if available, otherwise use device name
+			key := name
+			if stats.Name != "" {
+				key = stats.Name
+			}
+			data.Stats.ExtraFs[key] = stats
+		}
+	}
+	slog.Debug("Extra FS", "data", data.Stats.ExtraFs)
+
+	a.cache.Set(data, cacheTimeMs)
+	return data
+}
+
+// StartAgent initializes and starts the agent with optional WebSocket connection
+func (a *Agent) Start(serverOptions ServerOptions) error {
+	a.keys = serverOptions.Keys
+	return a.connectionManager.Start(serverOptions)
+}
+
+func (a *Agent) getFingerprint() string {
+	// first look for a fingerprint in the data directory
+	if a.dataDir != "" {
+		if fp, err := os.ReadFile(filepath.Join(a.dataDir, "fingerprint")); err == nil {
+			return string(fp)
+		}
+	}
+
+	// if no fingerprint is found, generate one
+	fingerprint, err := host.HostID()
+	if err != nil || fingerprint == "" {
+		fingerprint = a.systemInfo.Hostname + a.systemInfo.CpuModel
+	}
+
+	// hash fingerprint
+	sum := sha256.Sum256([]byte(fingerprint))
+	fingerprint = hex.EncodeToString(sum[:24])
+
+	// save fingerprint to data directory
+	if a.dataDir != "" {
+		err = os.WriteFile(filepath.Join(a.dataDir, "fingerprint"), []byte(fingerprint), 0644)
+		if err != nil {
+			slog.Warn("Failed to save fingerprint", "err", err)
+		}
+	}
+
+	return fingerprint
+}

agent/agent_cache.go

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

agent/agent_cache_test.go

@@ -0,0 +1,246 @@
+//go:build testing
+// +build testing
+
+package agent
+
+import (
+	"testing"
+	"testing/synctest"
+	"time"
+
+	"github.com/henrygd/beszel/internal/entities/container"
+	"github.com/henrygd/beszel/internal/entities/system"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func createTestCacheData() *system.CombinedData {
+	return &system.CombinedData{
+		Stats: system.Stats{
+			Cpu:       50.5,
+			Mem:       8192,
+			DiskTotal: 100000,
+		},
+		Info: system.Info{
+			Hostname: "test-host",
+		},
+		Containers: []*container.Stats{
+			{
+				Name: "test-container",
+				Cpu:  25.0,
+			},
+		},
+	}
+}
+
+func TestNewSystemDataCache(t *testing.T) {
+	cache := NewSystemDataCache()
+	require.NotNil(t, cache)
+	assert.NotNil(t, cache.cache)
+	assert.Empty(t, cache.cache)
+}
+
+func TestCacheGetSet(t *testing.T) {
+	cache := NewSystemDataCache()
+	data := createTestCacheData()
+
+	// Test setting data
+	cache.Set(data, 1000) // 1 second cache
+
+	// Test getting fresh data
+	retrieved, isCached := cache.Get(1000)
+	assert.True(t, isCached)
+	assert.Equal(t, data, retrieved)
+
+	// Test getting non-existent cache key
+	_, isCached = cache.Get(2000)
+	assert.False(t, isCached)
+}
+
+func TestCacheFreshness(t *testing.T) {
+	cache := NewSystemDataCache()
+	data := createTestCacheData()
+
+	testCases := []struct {
+		name        string
+		cacheTimeMs uint16
+		sleepMs     time.Duration
+		expectFresh bool
+	}{
+		{
+			name:        "fresh data - well within cache time",
+			cacheTimeMs: 1000, // 1 second
+			sleepMs:     100,  // 100ms
+			expectFresh: true,
+		},
+		{
+			name:        "fresh data - at 50% of cache time boundary",
+			cacheTimeMs: 1000, // 1 second, 50% = 500ms
+			sleepMs:     499,  // just under 500ms
+			expectFresh: true,
+		},
+		{
+			name:        "stale data - exactly at 50% cache time",
+			cacheTimeMs: 1000, // 1 second, 50% = 500ms
+			sleepMs:     500,  // exactly 500ms
+			expectFresh: false,
+		},
+		{
+			name:        "stale data - well beyond cache time",
+			cacheTimeMs: 1000, // 1 second
+			sleepMs:     800,  // 800ms
+			expectFresh: false,
+		},
+		{
+			name:        "short cache time",
+			cacheTimeMs: 200, // 200ms, 50% = 100ms
+			sleepMs:     150, // 150ms > 100ms
+			expectFresh: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			synctest.Test(t, func(t *testing.T) {
+				// Set data
+				cache.Set(data, tc.cacheTimeMs)
+
+				// Wait for the specified duration
+				if tc.sleepMs > 0 {
+					time.Sleep(tc.sleepMs * time.Millisecond)
+				}
+
+				// Check freshness
+				_, isCached := cache.Get(tc.cacheTimeMs)
+				assert.Equal(t, tc.expectFresh, isCached)
+			})
+		})
+	}
+}
+
+func TestCacheMultipleIntervals(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		cache := NewSystemDataCache()
+		data1 := createTestCacheData()
+		data2 := &system.CombinedData{
+			Stats: system.Stats{
+				Cpu: 75.0,
+				Mem: 16384,
+			},
+			Info: system.Info{
+				Hostname: "test-host-2",
+			},
+			Containers: []*container.Stats{},
+		}
+
+		// Set data for different intervals
+		cache.Set(data1, 500)  // 500ms cache
+		cache.Set(data2, 1000) // 1000ms cache
+
+		// Both should be fresh immediately
+		retrieved1, isCached1 := cache.Get(500)
+		assert.True(t, isCached1)
+		assert.Equal(t, data1, retrieved1)
+
+		retrieved2, isCached2 := cache.Get(1000)
+		assert.True(t, isCached2)
+		assert.Equal(t, data2, retrieved2)
+
+		// Wait 300ms - 500ms cache should be stale (250ms threshold), 1000ms should still be fresh (500ms threshold)
+		time.Sleep(300 * time.Millisecond)
+
+		_, isCached1 = cache.Get(500)
+		assert.False(t, isCached1)
+
+		_, isCached2 = cache.Get(1000)
+		assert.True(t, isCached2)
+
+		// Wait another 300ms (total 600ms) - now 1000ms cache should also be stale
+		time.Sleep(300 * time.Millisecond)
+		_, isCached2 = cache.Get(1000)
+		assert.False(t, isCached2)
+	})
+}
+
+func TestCacheOverwrite(t *testing.T) {
+	cache := NewSystemDataCache()
+	data1 := createTestCacheData()
+	data2 := &system.CombinedData{
+		Stats: system.Stats{
+			Cpu: 90.0,
+			Mem: 32768,
+		},
+		Info: system.Info{
+			Hostname: "updated-host",
+		},
+		Containers: []*container.Stats{},
+	}
+
+	// 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

@@ -0,0 +1,81 @@
+//go:build !freebsd
+
+// Package battery provides functions to check if the system has a battery and to get the battery stats.
+package battery
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"log/slog"
+
+	"github.com/distatus/battery"
+)
+
+var systemHasBattery = false
+var haveCheckedBattery = false
+
+// HasReadableBattery checks if the system has a battery and returns true if it does.
+func HasReadableBattery() bool {
+	if haveCheckedBattery {
+		return systemHasBattery
+	}
+	haveCheckedBattery = true
+	batteries,err := battery.GetAll()
+	if err != nil {
+		// even if there's errors getting some batteries, the system
+		// definitely has a battery if the list is not empty.
+		// This list will include everything `battery` can find,
+		// including things like bluetooth devices.
+		fmt.Fprintln(os.Stderr, err)
+	}
+	systemHasBattery = len(batteries) > 0
+	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() {
+		return batteryPercent, batteryState, errors.ErrUnsupported
+	}
+	batteries, err := battery.GetAll()
+	// we'll handle errors later by skipping batteries with errors, rather
+	// than skipping everything because of the presence of some errors.
+	if len(batteries) == 0 {
+		return batteryPercent, batteryState, errors.New("no batteries")
+	}
+
+	totalCapacity := float64(0)
+	totalCharge := float64(0)
+	errs, partialErrs := err.(battery.Errors)
+
+	for i, bat := range batteries {
+		if partialErrs && errs[i] != nil {
+			// if there were some errors, like missing data, skip it
+			continue
+		}
+		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

@@ -1,8 +1,6 @@
 package agent
 
 import (
-	"beszel"
-	"beszel/internal/common"
 	"crypto/tls"
 	"errors"
 	"fmt"
@@ -15,6 +13,11 @@ import (
 	"strings"
 	"time"
 
+	"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"
 	"golang.org/x/crypto/ssh"
@@ -84,7 +87,7 @@ func getToken() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return string(tokenBytes), nil
+	return strings.TrimSpace(string(tokenBytes)), nil
 }
 
 // getOptions returns the WebSocket client options, creating them if necessary.
@@ -141,7 +144,9 @@ 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) {
-	slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
+	if err != nil {
+		slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
+	}
 	client.agent.connectionManager.eventChan <- WebSocketDisconnect
 }
 
@@ -155,11 +160,15 @@ func (client *WebSocketClient) OnMessage(conn *gws.Conn, message *gws.Message) {
 		return
 	}
 
-	if err := cbor.NewDecoder(message.Data).Decode(client.hubRequest); err != nil {
+	var HubRequest common.HubRequest[cbor.RawMessage]
+
+	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)
 	}
 }
@@ -172,7 +181,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]) (err error) {
+func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) (err error) {
 	var authRequest common.FingerprintRequest
 	if err := cbor.Unmarshal(msg.Data, &authRequest); err != nil {
 		return err
@@ -190,12 +199,13 @@ 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.sendMessage(response)
+	return client.sendResponse(response, requestID)
 }
 
 // verifySignature verifies the signature of the token using the public keys.
@@ -220,25 +230,17 @@ func (client *WebSocketClient) Close() {
 	}
 }
 
-// handleHubRequest routes the request to the appropriate handler.
-// It ensures the hub is verified before processing most requests.
-func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage]) error {
-	if !client.hubVerified && msg.Action != common.CheckFingerprint {
-		return errors.New("hub not verified")
+// handleHubRequest routes the request to the appropriate handler using the handler registry.
+func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) error {
+	ctx := &HandlerContext{
+		Client:       client,
+		Agent:        client.agent,
+		Request:      msg,
+		RequestID:    requestID,
+		HubVerified:  client.hubVerified,
+		SendResponse: client.sendResponse,
 	}
-	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)
+	return client.agent.handlerRegistry.Handle(ctx)
 }
 
 // sendMessage encodes the given data to CBOR and sends it as a binary message over the WebSocket connection to the hub.
@@ -247,7 +249,47 @@ func (client *WebSocketClient) sendMessage(data any) error {
 	if err != nil {
 		return err
 	}
-	return client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
+	err = client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
+	if err != nil {
+		// If writing fails (e.g., broken pipe due to network issues),
+		// close the connection to trigger reconnection logic (#1263)
+		client.Close()
+	}
+	return err
+}
+
+// sendResponse sends a response with optional request ID for the new protocol
+func (client *WebSocketClient) sendResponse(data any, requestID *uint32) error {
+	if requestID != nil {
+		// New format with ID - use typed fields
+		response := common.AgentResponse{
+			Id: requestID,
+		}
+
+		// Set the appropriate typed field based on data type
+		switch v := data.(type) {
+		case *system.CombinedData:
+			response.SystemData = v
+		case *common.FingerprintResponse:
+			response.Fingerprint = v
+		case string:
+			response.String = &v
+		case map[string]smart.SmartData:
+			response.SmartData = v
+		// case []byte:
+		// 	response.RawBytes = v
+		// case string:
+		// 	response.RawBytes = []byte(v)
+		default:
+			// For any other type, convert to error
+			response.Error = fmt.Sprintf("unsupported response type: %T", data)
+		}
+
+		return client.sendMessage(response)
+	} else {
+		// Legacy format - send data directly
+		return client.sendMessage(data)
+	}
 }
 
 // getUserAgent returns one of two User-Agent strings based on current time.

agent/client_test.go

@@ -4,8 +4,6 @@
 package agent
 
 import (
-	"beszel"
-	"beszel/internal/common"
 	"crypto/ed25519"
 	"net/url"
 	"os"
@@ -13,6 +11,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/henrygd/beszel"
+
+	"github.com/henrygd/beszel/internal/common"
+
 	"github.com/fxamacker/cbor/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -299,7 +301,7 @@ func TestWebSocketClient_HandleHubRequest(t *testing.T) {
 				Data:   cbor.RawMessage{},
 			}
 
-			err := client.handleHubRequest(hubRequest)
+			err := client.handleHubRequest(hubRequest, nil)
 
 			if tc.expectError {
 				assert.Error(t, err)
@@ -535,4 +537,25 @@ func TestGetToken(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, "", token, "Empty file should return empty string")
 	})
+
+	t.Run("strips whitespace from TOKEN_FILE", func(t *testing.T) {
+		unsetEnvVars()
+
+		tokenWithWhitespace := "  test-token-with-whitespace  \n\t"
+		expectedToken := "test-token-with-whitespace"
+		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
+		require.NoError(t, err)
+		defer os.Remove(tokenFile.Name())
+
+		_, err = tokenFile.WriteString(tokenWithWhitespace)
+		require.NoError(t, err)
+		tokenFile.Close()
+
+		os.Setenv("TOKEN_FILE", tokenFile.Name())
+		defer os.Unsetenv("TOKEN_FILE")
+
+		token, err := getToken()
+		assert.NoError(t, err)
+		assert.Equal(t, expectedToken, token, "Whitespace should be stripped from token file content")
+	})
 }

agent/connection_manager.go

@@ -1,26 +1,29 @@
 package agent
 
 import (
-	"beszel/internal/agent/health"
 	"errors"
 	"log/slog"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
+
+	"github.com/henrygd/beszel/agent/health"
+	"github.com/henrygd/beszel/internal/entities/system"
 )
 
 // ConnectionManager manages the connection state and events for the agent.
 // It handles both WebSocket and SSH connections, automatically switching between
 // them based on availability and managing reconnection attempts.
 type ConnectionManager struct {
-	agent         *Agent               // Reference to the parent agent
-	State         ConnectionState      // Current connection state
-	eventChan     chan ConnectionEvent // Channel for connection events
-	wsClient      *WebSocketClient     // WebSocket client for hub communication
-	serverOptions ServerOptions        // Configuration for SSH server
-	wsTicker      *time.Ticker         // Ticker for WebSocket connection attempts
-	isConnecting  bool                 // Prevents multiple simultaneous reconnection attempts
+	agent          *Agent               // Reference to the parent agent
+	State          ConnectionState      // Current connection state
+	eventChan      chan ConnectionEvent // Channel for connection events
+	wsClient       *WebSocketClient     // WebSocket client for hub communication
+	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.
@@ -143,15 +146,18 @@ 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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,100 @@
+// 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

@@ -0,0 +1,217 @@
+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

@@ -1,7 +1,6 @@
 package agent
 
 import (
-	"beszel/internal/entities/system"
 	"log/slog"
 	"os"
 	"path/filepath"
@@ -9,9 +8,24 @@ import (
 	"strings"
 	"time"
 
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"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")
@@ -36,7 +50,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) {
+	addFsStat := func(device, mountpoint string, root bool, customName ...string) {
 		var key string
 		if runtime.GOOS == "windows" {
 			key = device
@@ -65,7 +79,11 @@ func (a *Agent) initializeDiskInfo() {
 					}
 				}
 			}
-			a.fsStats[key] = &system.FsStats{Root: root, Mountpoint: mountpoint}
+			fsStats := &system.FsStats{Root: root, Mountpoint: mountpoint}
+			if len(customName) > 0 && customName[0] != "" {
+				fsStats.Name = customName[0]
+			}
+			a.fsStats[key] = fsStats
 		}
 	}
 
@@ -85,11 +103,14 @@ func (a *Agent) initializeDiskInfo() {
 
 	// Add EXTRA_FILESYSTEMS env var values to fsStats
 	if extraFilesystems, exists := GetEnv("EXTRA_FILESYSTEMS"); exists {
-		for _, fs := range strings.Split(extraFilesystems, ",") {
+		for _, fsEntry := 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)
+					addFsStat(p.Device, p.Mountpoint, false, customName)
 					found = true
 					break
 				}
@@ -97,7 +118,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)
+					addFsStat(filepath.Base(fs), fs, false, customName)
 				} else {
 					slog.Error("Invalid filesystem", "name", fs, "err", err)
 				}
@@ -119,7 +140,8 @@ func (a *Agent) initializeDiskInfo() {
 
 		// Check if device is in /extra-filesystems
 		if strings.HasPrefix(p.Mountpoint, efPath) {
-			addFsStat(p.Device, p.Mountpoint, false)
+			device, customName := parseFilesystemEntry(p.Mountpoint)
+			addFsStat(device, p.Mountpoint, false, customName)
 		}
 	}
 
@@ -134,7 +156,8 @@ func (a *Agent) initializeDiskInfo() {
 				mountpoint := filepath.Join(efPath, folder.Name())
 				slog.Debug("/extra-filesystems", "mountpoint", mountpoint)
 				if !existingMountpoints[mountpoint] {
-					addFsStat(folder.Name(), mountpoint, false)
+					device, customName := parseFilesystemEntry(folder.Name())
+					addFsStat(device, mountpoint, false, customName)
 				}
 			}
 		}
@@ -188,3 +211,96 @@ 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

@@ -0,0 +1,235 @@
+//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

@@ -0,0 +1,700 @@
+package agent
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/henrygd/beszel/agent/deltatracker"
+	"github.com/henrygd/beszel/internal/entities/container"
+
+	"github.com/blang/semver"
+)
+
+const (
+	// Docker API timeout in milliseconds
+	dockerTimeoutMs = 2100
+	// Maximum realistic network speed (5 GB/s) to detect bad deltas
+	maxNetworkSpeedBps uint64 = 5e9
+	// Maximum conceivable memory usage of a container (100TB) to detect bad memory stats
+	maxMemoryUsage uint64 = 100 * 1024 * 1024 * 1024 * 1024
+	// Number of log lines to request when fetching container logs
+	dockerLogsTail = 200
+)
+
+type dockerManager struct {
+	client              *http.Client                // Client to query Docker API
+	wg                  sync.WaitGroup              // WaitGroup to wait for all goroutines to finish
+	sem                 chan struct{}               // Semaphore to limit concurrent container requests
+	containerStatsMutex sync.RWMutex                // Mutex to prevent concurrent access to containerStatsMap
+	apiContainerList    []*container.ApiInfo        // List of containers from Docker API
+	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)
+	isWindows           bool                        // Whether the Docker Engine API is running on Windows
+	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
+type userAgentRoundTripper struct {
+	rt        http.RoundTripper
+	userAgent string
+}
+
+// RoundTrip implements the http.RoundTripper interface
+func (u *userAgentRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	req.Header.Set("User-Agent", u.userAgent)
+	return u.rt.RoundTrip(req)
+}
+
+// Add goroutine to the queue
+func (d *dockerManager) queue() {
+	d.wg.Add(1)
+	if d.goodDockerVersion {
+		d.sem <- struct{}{}
+	}
+}
+
+// Remove goroutine from the queue
+func (d *dockerManager) dequeue() {
+	d.wg.Done()
+	if d.goodDockerVersion {
+		<-d.sem
+	}
+}
+
+// Returns stats for all running containers with cache-time-aware delta tracking
+func (dm *dockerManager) getDockerStats(cacheTimeMs uint16) ([]*container.Stats, error) {
+	resp, err := dm.client.Get("http://localhost/containers/json")
+	if err != nil {
+		return nil, err
+	}
+
+	dm.apiContainerList = dm.apiContainerList[:0]
+	if err := dm.decode(resp, &dm.apiContainerList); err != nil {
+		return nil, err
+	}
+
+	dm.isWindows = strings.Contains(resp.Header.Get("Server"), "windows")
+
+	containersLength := len(dm.apiContainerList)
+
+	// store valid ids to clean up old container ids from map
+	if dm.validIds == nil {
+		dm.validIds = make(map[string]struct{}, containersLength)
+	} else {
+		clear(dm.validIds)
+	}
+
+	var failedContainers []*container.ApiInfo
+
+	for _, ctr := range dm.apiContainerList {
+		ctr.IdShort = ctr.Id[:12]
+		dm.validIds[ctr.IdShort] = struct{}{}
+		// check if container is less than 1 minute old (possible restart)
+		// note: can't use Created field because it's not updated on restart
+		if strings.Contains(ctr.Status, "second") {
+			// if so, remove old container data
+			dm.deleteContainerStatsSync(ctr.IdShort)
+		}
+		dm.queue()
+		go func(ctr *container.ApiInfo) {
+			defer dm.dequeue()
+			err := dm.updateContainerStats(ctr, cacheTimeMs)
+			// if error, delete from map and add to failed list to retry
+			if err != nil {
+				dm.containerStatsMutex.Lock()
+				delete(dm.containerStatsMap, ctr.IdShort)
+				failedContainers = append(failedContainers, ctr)
+				dm.containerStatsMutex.Unlock()
+			}
+		}(ctr)
+	}
+
+	dm.wg.Wait()
+
+	// retry failed containers separately so we can run them in parallel (docker 24 bug)
+	if len(failedContainers) > 0 {
+		slog.Debug("Retrying failed containers", "count", len(failedContainers))
+		for i := range failedContainers {
+			ctr := failedContainers[i]
+			dm.queue()
+			go func(ctr *container.ApiInfo) {
+				defer dm.dequeue()
+				if err2 := dm.updateContainerStats(ctr, cacheTimeMs); err2 != nil {
+					slog.Error("Error getting container stats", "err", err2)
+				}
+			}(ctr)
+		}
+		dm.wg.Wait()
+	}
+
+	// populate final stats and remove old / invalid container stats
+	stats := make([]*container.Stats, 0, containersLength)
+	for id, v := range dm.containerStatsMap {
+		if _, exists := dm.validIds[id]; !exists {
+			delete(dm.containerStatsMap, id)
+		} else {
+			stats = append(stats, v)
+		}
+	}
+
+	// prepare network trackers for next interval for this cache time
+	dm.cycleNetworkDeltasForCacheTime(cacheTimeMs)
+
+	return stats, nil
+}
+
+// initializeCpuTracking initializes CPU tracking maps for a specific cache time interval
+func (dm *dockerManager) initializeCpuTracking(cacheTimeMs uint16) {
+	// Initialize cache time maps if they don't exist
+	if dm.lastCpuContainer[cacheTimeMs] == nil {
+		dm.lastCpuContainer[cacheTimeMs] = make(map[string]uint64)
+	}
+	if dm.lastCpuSystem[cacheTimeMs] == nil {
+		dm.lastCpuSystem[cacheTimeMs] = make(map[string]uint64)
+	}
+	// Ensure the outer map exists before indexing
+	if dm.lastCpuReadTime == nil {
+		dm.lastCpuReadTime = make(map[uint16]map[string]time.Time)
+	}
+	if dm.lastCpuReadTime[cacheTimeMs] == nil {
+		dm.lastCpuReadTime[cacheTimeMs] = make(map[string]time.Time)
+	}
+}
+
+// getCpuPreviousValues returns previous CPU values for a container and cache time interval
+func (dm *dockerManager) getCpuPreviousValues(cacheTimeMs uint16, containerId string) (uint64, uint64) {
+	return dm.lastCpuContainer[cacheTimeMs][containerId], dm.lastCpuSystem[cacheTimeMs][containerId]
+}
+
+// setCpuCurrentValues stores current CPU values for a container and cache time interval
+func (dm *dockerManager) setCpuCurrentValues(cacheTimeMs uint16, containerId string, cpuContainer, cpuSystem uint64) {
+	dm.lastCpuContainer[cacheTimeMs][containerId] = cpuContainer
+	dm.lastCpuSystem[cacheTimeMs][containerId] = cpuSystem
+}
+
+// calculateMemoryUsage calculates memory usage from Docker API stats
+func calculateMemoryUsage(apiStats *container.ApiStats, isWindows bool) (uint64, error) {
+	if isWindows {
+		return apiStats.MemoryStats.PrivateWorkingSet, nil
+	}
+
+	memCache := apiStats.MemoryStats.Stats.InactiveFile
+	if memCache == 0 {
+		memCache = apiStats.MemoryStats.Stats.Cache
+	}
+
+	usedDelta := apiStats.MemoryStats.Usage - memCache
+	if usedDelta <= 0 || usedDelta > maxMemoryUsage {
+		return 0, fmt.Errorf("bad memory stats")
+	}
+
+	return usedDelta, nil
+}
+
+// getNetworkTracker returns the DeltaTracker for a specific cache time, creating it if needed
+func (dm *dockerManager) getNetworkTracker(cacheTimeMs uint16, isSent bool) *deltatracker.DeltaTracker[string, uint64] {
+	var trackers map[uint16]*deltatracker.DeltaTracker[string, uint64]
+	if isSent {
+		trackers = dm.networkSentTrackers
+	} else {
+		trackers = dm.networkRecvTrackers
+	}
+
+	if trackers[cacheTimeMs] == nil {
+		trackers[cacheTimeMs] = deltatracker.NewDeltaTracker[string, uint64]()
+	}
+
+	return trackers[cacheTimeMs]
+}
+
+// cycleNetworkDeltasForCacheTime cycles the network delta trackers for a specific cache time
+func (dm *dockerManager) cycleNetworkDeltasForCacheTime(cacheTimeMs uint16) {
+	if dm.networkSentTrackers[cacheTimeMs] != nil {
+		dm.networkSentTrackers[cacheTimeMs].Cycle()
+	}
+	if dm.networkRecvTrackers[cacheTimeMs] != nil {
+		dm.networkRecvTrackers[cacheTimeMs].Cycle()
+	}
+}
+
+// calculateNetworkStats calculates network sent/receive deltas using DeltaTracker
+func (dm *dockerManager) calculateNetworkStats(ctr *container.ApiInfo, apiStats *container.ApiStats, stats *container.Stats, initialized bool, name string, cacheTimeMs uint16) (uint64, uint64) {
+	var total_sent, total_recv uint64
+	for _, v := range apiStats.Networks {
+		total_sent += v.TxBytes
+		total_recv += v.RxBytes
+	}
+
+	// Get the DeltaTracker for this specific cache time
+	sentTracker := dm.getNetworkTracker(cacheTimeMs, true)
+	recvTracker := dm.getNetworkTracker(cacheTimeMs, false)
+
+	// Set current values in the cache-time-specific DeltaTracker
+	sentTracker.Set(ctr.IdShort, total_sent)
+	recvTracker.Set(ctr.IdShort, total_recv)
+
+	// Get deltas (bytes since last measurement)
+	sent_delta_raw := sentTracker.Delta(ctr.IdShort)
+	recv_delta_raw := recvTracker.Delta(ctr.IdShort)
+
+	// Calculate bytes per second independently for Tx and Rx if we have previous data
+	var sent_delta, recv_delta uint64
+	if initialized {
+		millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
+		if millisecondsElapsed > 0 {
+			if sent_delta_raw > 0 {
+				sent_delta = sent_delta_raw * 1000 / millisecondsElapsed
+				if sent_delta > maxNetworkSpeedBps {
+					slog.Warn("Bad network delta", "container", name)
+					sent_delta = 0
+				}
+			}
+			if recv_delta_raw > 0 {
+				recv_delta = recv_delta_raw * 1000 / millisecondsElapsed
+				if recv_delta > maxNetworkSpeedBps {
+					slog.Warn("Bad network delta", "container", name)
+					recv_delta = 0
+				}
+			}
+		}
+	}
+
+	return sent_delta, recv_delta
+}
+
+// validateCpuPercentage checks if CPU percentage is within valid range
+func validateCpuPercentage(cpuPct float64, containerName string) error {
+	if cpuPct > 100 {
+		return fmt.Errorf("%s cpu pct greater than 100: %+v", containerName, cpuPct)
+	}
+	return nil
+}
+
+// updateContainerStatsValues updates the final stats values
+func updateContainerStatsValues(stats *container.Stats, cpuPct float64, usedMemory uint64, sent_delta, recv_delta uint64, readTime time.Time) {
+	stats.Cpu = twoDecimals(cpuPct)
+	stats.Mem = bytesToMegabytes(float64(usedMemory))
+	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
+	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
+	stats.PrevReadTime = readTime
+}
+
+func parseDockerStatus(status string) (string, container.DockerHealth) {
+	trimmed := strings.TrimSpace(status)
+	if trimmed == "" {
+		return "", container.DockerHealthNone
+	}
+
+	// Remove "About " from status
+	trimmed = strings.Replace(trimmed, "About ", "", 1)
+
+	openIdx := strings.LastIndex(trimmed, "(")
+	if openIdx == -1 || !strings.HasSuffix(trimmed, ")") {
+		return trimmed, container.DockerHealthNone
+	}
+
+	statusText := strings.TrimSpace(trimmed[:openIdx])
+	if statusText == "" {
+		statusText = trimmed
+	}
+
+	healthText := strings.ToLower(strings.TrimSpace(strings.TrimSuffix(trimmed[openIdx+1:], ")")))
+	// Some Docker statuses include a "health:" prefix inside the parentheses.
+	// Strip it so it maps correctly to the known health states.
+	if colonIdx := strings.IndexRune(healthText, ':'); colonIdx != -1 {
+		prefix := strings.TrimSpace(healthText[:colonIdx])
+		if prefix == "health" || prefix == "health status" {
+			healthText = strings.TrimSpace(healthText[colonIdx+1:])
+		}
+	}
+	if health, ok := container.DockerHealthStrings[healthText]; ok {
+		return statusText, health
+	}
+
+	return trimmed, container.DockerHealthNone
+}
+
+// Updates stats for individual container with cache-time-aware delta tracking
+func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo, cacheTimeMs uint16) error {
+	name := ctr.Names[0][1:]
+
+	resp, err := dm.client.Get(fmt.Sprintf("http://localhost/containers/%s/stats?stream=0&one-shot=1", ctr.IdShort))
+	if err != nil {
+		return err
+	}
+
+	dm.containerStatsMutex.Lock()
+	defer dm.containerStatsMutex.Unlock()
+
+	// 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}
+		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
+
+	res := dm.apiStats
+	res.Networks = nil
+	if err := dm.decode(resp, res); err != nil {
+		return err
+	}
+
+	// Initialize CPU tracking for this cache time interval
+	dm.initializeCpuTracking(cacheTimeMs)
+
+	// Get previous CPU values
+	prevCpuContainer, prevCpuSystem := dm.getCpuPreviousValues(cacheTimeMs, ctr.IdShort)
+
+	// Calculate CPU percentage based on platform
+	var cpuPct float64
+	if dm.isWindows {
+		prevRead := dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort]
+		cpuPct = res.CalculateCpuPercentWindows(prevCpuContainer, prevRead)
+	} else {
+		cpuPct = res.CalculateCpuPercentLinux(prevCpuContainer, prevCpuSystem)
+	}
+
+	// Calculate memory usage
+	usedMemory, err := calculateMemoryUsage(res, dm.isWindows)
+	if err != nil {
+		return fmt.Errorf("%s - %w - see https://github.com/henrygd/beszel/issues/144", name, err)
+	}
+
+	// Store current CPU stats for next calculation
+	currentCpuContainer := res.CPUStats.CPUUsage.TotalUsage
+	currentCpuSystem := res.CPUStats.SystemUsage
+	dm.setCpuCurrentValues(cacheTimeMs, ctr.IdShort, currentCpuContainer, currentCpuSystem)
+
+	// Validate CPU percentage
+	if err := validateCpuPercentage(cpuPct, name); err != nil {
+		return err
+	}
+
+	// Calculate network stats using DeltaTracker
+	sent_delta, recv_delta := dm.calculateNetworkStats(ctr, res, stats, initialized, name, cacheTimeMs)
+
+	// Store current network values for legacy compatibility
+	var total_sent, total_recv uint64
+	for _, v := range res.Networks {
+		total_sent += v.TxBytes
+		total_recv += v.RxBytes
+	}
+	stats.PrevNet.Sent, stats.PrevNet.Recv = total_sent, total_recv
+
+	// Update final stats values
+	updateContainerStatsValues(stats, cpuPct, usedMemory, sent_delta, recv_delta, res.Read)
+	// store per-cache-time read time for Windows CPU percent calc
+	dm.lastCpuReadTime[cacheTimeMs][ctr.IdShort] = res.Read
+
+	return nil
+}
+
+// Delete container stats from map using mutex
+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
+func newDockerManager(a *Agent) *dockerManager {
+	dockerHost, exists := GetEnv("DOCKER_HOST")
+	if exists {
+		// return nil if set to empty string
+		if dockerHost == "" {
+			return nil
+		}
+	} else {
+		dockerHost = getDockerHost()
+	}
+
+	parsedURL, err := url.Parse(dockerHost)
+	if err != nil {
+		os.Exit(1)
+	}
+
+	transport := &http.Transport{
+		DisableCompression: true,
+		MaxConnsPerHost:    0,
+	}
+
+	switch parsedURL.Scheme {
+	case "unix":
+		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
+			return (&net.Dialer{}).DialContext(ctx, "unix", parsedURL.Path)
+		}
+	case "tcp", "http", "https":
+		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
+			return (&net.Dialer{}).DialContext(ctx, "tcp", parsedURL.Host)
+		}
+	default:
+		slog.Error("Invalid DOCKER_HOST", "scheme", parsedURL.Scheme)
+		os.Exit(1)
+	}
+
+	// configurable timeout
+	timeout := time.Millisecond * time.Duration(dockerTimeoutMs)
+	if t, set := GetEnv("DOCKER_TIMEOUT"); set {
+		timeout, err = time.ParseDuration(t)
+		if err != nil {
+			slog.Error(err.Error())
+			os.Exit(1)
+		}
+		slog.Info("DOCKER_TIMEOUT", "timeout", timeout)
+	}
+
+	// Custom user-agent to avoid docker bug: https://github.com/docker/for-mac/issues/7575
+	userAgentTransport := &userAgentRoundTripper{
+		rt:        transport,
+		userAgent: "Docker-Client/",
+	}
+
+	manager := &dockerManager{
+		client: &http.Client{
+			Timeout:   timeout,
+			Transport: userAgentTransport,
+		},
+		containerStatsMap: make(map[string]*container.Stats),
+		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
+	if strings.Contains(dockerHost, "podman") {
+		a.systemInfo.Podman = true
+		manager.goodDockerVersion = true
+		return manager
+	}
+
+	// this can take up to 5 seconds with retry, so run in goroutine
+	go manager.checkDockerVersion()
+
+	// give version check a chance to complete before returning
+	time.Sleep(50 * time.Millisecond)
+
+	return manager
+}
+
+// checkDockerVersion checks Docker version and sets goodDockerVersion if at least 25.0.0.
+// Versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch.
+func (dm *dockerManager) checkDockerVersion() {
+	var err error
+	var resp *http.Response
+	var versionInfo struct {
+		Version string `json:"Version"`
+	}
+	const versionMaxTries = 2
+	for i := 1; i <= versionMaxTries; i++ {
+		resp, err = dm.client.Get("http://localhost/version")
+		if err == nil {
+			break
+		}
+		if resp != nil {
+			resp.Body.Close()
+		}
+		if i < versionMaxTries {
+			slog.Debug("Failed to get Docker version; retrying", "attempt", i, "error", err)
+			time.Sleep(5 * time.Second)
+		}
+	}
+	if err != nil {
+		return
+	}
+	if err := dm.decode(resp, &versionInfo); err != nil {
+		return
+	}
+	// 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
+	} else {
+		slog.Info(fmt.Sprintf("Docker %s is outdated. Upgrade if possible. See https://github.com/henrygd/beszel/issues/58", versionInfo.Version))
+	}
+}
+
+// Decodes Docker API JSON response using a reusable buffer and decoder. Not thread safe.
+func (dm *dockerManager) decode(resp *http.Response, d any) error {
+	if dm.buf == nil {
+		// initialize buffer with 256kb starting size
+		dm.buf = bytes.NewBuffer(make([]byte, 0, 1024*256))
+		dm.decoder = json.NewDecoder(dm.buf)
+	}
+	defer resp.Body.Close()
+	defer dm.buf.Reset()
+	_, err := dm.buf.ReadFrom(resp.Body)
+	if err != nil {
+		return err
+	}
+	return dm.decoder.Decode(d)
+}
+
+// Test docker / podman sockets and return if one exists
+func getDockerHost() string {
+	scheme := "unix://"
+	socks := []string{"/var/run/docker.sock", fmt.Sprintf("/run/user/%v/podman/podman.sock", os.Getuid())}
+	for _, sock := range socks {
+		if _, err := os.Stat(sock); err == nil {
+			return scheme + sock
+		}
+	}
+	return scheme + socks[0]
+}
+
+// getContainerInfo fetches the inspection data for a container
+func (dm *dockerManager) getContainerInfo(ctx context.Context, containerID string) ([]byte, error) {
+	endpoint := fmt.Sprintf("http://localhost/containers/%s/json", containerID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := dm.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+		return nil, fmt.Errorf("container info request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
+
+	// Remove sensitive environment variables from Config.Env
+	var containerInfo map[string]any
+	if err := json.NewDecoder(resp.Body).Decode(&containerInfo); err != nil {
+		return nil, err
+	}
+	if config, ok := containerInfo["Config"].(map[string]any); ok {
+		delete(config, "Env")
+	}
+
+	return json.Marshal(containerInfo)
+}
+
+// getLogs fetches the logs for a container
+func (dm *dockerManager) getLogs(ctx context.Context, containerID string) (string, error) {
+	endpoint := fmt.Sprintf("http://localhost/containers/%s/logs?stdout=1&stderr=1&tail=%d", containerID, dockerLogsTail)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := dm.client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+		return "", fmt.Errorf("logs request failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
+
+	var builder strings.Builder
+	if err := decodeDockerLogStream(resp.Body, &builder); err != nil {
+		return "", err
+	}
+
+	return builder.String(), nil
+}
+
+func decodeDockerLogStream(reader io.Reader, builder *strings.Builder) error {
+	const headerSize = 8
+	var header [headerSize]byte
+	buf := make([]byte, 0, dockerLogsTail*200)
+
+	for {
+		if _, err := io.ReadFull(reader, header[:]); err != nil {
+			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				return nil
+			}
+			return err
+		}
+
+		frameLen := binary.BigEndian.Uint32(header[4:])
+		if frameLen == 0 {
+			continue
+		}
+
+		buf = allocateBuffer(buf, int(frameLen))
+		if _, err := io.ReadFull(reader, buf[:frameLen]); err != nil {
+			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				if len(buf) > 0 {
+					builder.Write(buf[:min(int(frameLen), len(buf))])
+				}
+				return nil
+			}
+			return err
+		}
+		builder.Write(buf[:frameLen])
+	}
+}
+
+func allocateBuffer(current []byte, needed int) []byte {
+	if cap(current) >= needed {
+		return current[:needed]
+	}
+	return make([]byte, needed)
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

agent/docker_test.go

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

agent/gpu.go

@@ -1,11 +1,11 @@
 package agent
 
 import (
-	"beszel/internal/entities/system"
 	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"maps"
 	"os/exec"
 	"regexp"
 	"strconv"
@@ -13,6 +13,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"golang.org/x/exp/slog"
 )
 
@@ -26,13 +28,10 @@ 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
@@ -41,10 +40,26 @@ const (
 // GPUManager manages data collection for GPUs (either Nvidia or AMD)
 type GPUManager struct {
 	sync.Mutex
-	nvidiaSmi  bool
-	rocmSmi    bool
-	tegrastats bool
-	GpuDataMap map[string]*system.GPUData
+	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
@@ -65,6 +80,7 @@ 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
@@ -98,7 +114,7 @@ func (c *gpuCollector) collect() error {
 
 	scanner := bufio.NewScanner(stdout)
 	if c.buf == nil {
-		c.buf = make([]byte, 0, cmdBufferSize)
+		c.buf = make([]byte, 0, c.bufSize)
 	}
 	scanner.Buffer(c.buf, bufio.MaxScanTokenSize)
 
@@ -229,36 +245,21 @@ func (gm *GPUManager) parseAmdData(output []byte) bool {
 	return true
 }
 
-// sums and resets the current GPU utilization data since the last update
-func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
+// GetCurrentData returns GPU utilization data averaged since the last call with this cacheKey
+func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData {
 	gm.Lock()
 	defer gm.Unlock()
 
-	// check for GPUs with the same name
-	nameCounts := make(map[string]int)
-	for _, gpu := range gm.GpuDataMap {
-		nameCounts[gpu.Name]++
-	}
+	gm.initializeSnapshots(cacheKey)
+	nameCounts := gm.countGPUNames()
 
-	// copy / reset the data
 	gpuData := make(map[string]system.GPUData, len(gm.GpuDataMap))
 	for id, gpu := range gm.GpuDataMap {
-		gpuAvg := *gpu
+		gpuAvg := gm.calculateGPUAverage(id, gpu, cacheKey)
+		gm.updateInstantaneousValues(&gpuAvg, gpu)
+		gm.storeSnapshot(id, gpu, cacheKey)
 
-		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
+		// Append id to name if there are multiple GPUs with the same name
 		if nameCounts[gpu.Name] > 1 {
 			gpuAvg.Name = fmt.Sprintf("%s %s", gpu.Name, id)
 		}
@@ -268,6 +269,115 @@ func (gm *GPUManager) GetCurrentData() 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
@@ -283,18 +393,37 @@ func (gm *GPUManager) detectGPUs() error {
 		gm.tegrastats = true
 		gm.nvidiaSmi = false
 	}
-	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats {
+	if _, err := exec.LookPath(intelGpuStatsCmd); err == nil {
+		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, or tegrastats")
+	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, tegrastats, or intel_gpu_top")
 }
 
 // startCollector starts the appropriate GPU data collector based on the command
 func (gm *GPUManager) startCollector(command string) {
 	collector := gpuCollector{
-		name: command,
+		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,
@@ -328,6 +457,9 @@ 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
@@ -343,6 +475,9 @@ func NewGPUManager() (*GPUManager, error) {
 	if gm.tegrastats {
 		gm.startCollector(tegraStatsCmd)
 	}
+	if gm.intelGpuStats {
+		gm.startCollector(intelGpuStatsCmd)
+	}
 
 	return &gm, nil
 }

agent/gpu_intel.go

@@ -0,0 +1,199 @@
+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/handlers.go

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,112 @@
+//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

@@ -0,0 +1,259 @@
+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)
+
+	// parse NICS env var for whitelist / blacklist
+	nicsEnvVal, nicsEnvExists := GetEnv("NICS")
+	var nicCfg *NicConfig
+	if nicsEnvExists {
+		nicCfg = newNicConfig(nicsEnvVal)
+	}
+
+	// get current network I/O stats and record valid interfaces
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		for _, v := range netIO {
+			if nicsEnvExists && !isValidNic(v.Name, nicCfg) {
+				continue
+			}
+			if a.skipNetworkInterface(v) {
+				continue
+			}
+			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
+			// store as a valid network interface
+			a.netInterfaces[v.Name] = struct{}{}
+		}
+	}
+
+	// Reset per-cache-time trackers and baselines so they will reinitialize on next use
+	a.netInterfaceDeltaTrackers = make(map[uint16]*deltatracker.DeltaTracker[string, uint64])
+	a.netIoStats = make(map[uint16]system.NetIoStats)
+}
+
+// ensureNetInterfacesInitialized re-initializes NICs if none are currently tracked
+func (a *Agent) ensureNetInterfacesInitialized() {
+	if len(a.netInterfaces) == 0 {
+		// if no network interfaces, initialize again
+		// this is a fix if agent started before network is online (#466)
+		// 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 {
+	switch {
+	case strings.HasPrefix(v.Name, "lo"),
+		strings.HasPrefix(v.Name, "docker"),
+		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
+	default:
+		return false
+	}
+}

agent/network_test.go

@@ -0,0 +1,502 @@
+//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/sensors.go

@@ -1,7 +1,6 @@
 package agent
 
 import (
-	"beszel/internal/entities/system"
 	"context"
 	"fmt"
 	"log/slog"
@@ -11,6 +10,8 @@ import (
 	"strings"
 	"unicode/utf8"
 
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/shirou/gopsutil/v4/common"
 	"github.com/shirou/gopsutil/v4/sensors"
 )

agent/sensors_test.go

@@ -4,12 +4,13 @@
 package agent
 
 import (
-	"beszel/internal/entities/system"
 	"context"
 	"fmt"
 	"os"
 	"testing"
 
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/shirou/gopsutil/v4/common"
 	"github.com/shirou/gopsutil/v4/sensors"
 	"github.com/stretchr/testify/assert"

agent/sensors_windows.go

@@ -46,9 +46,10 @@ var lhmFs embed.FS
 var (
 	beszelLhm     *lhmProcess
 	beszelLhmOnce sync.Once
+	useLHM        = os.Getenv("LHM") == "true"
 )
 
-var errNoSensors = errors.New("no sensors found (try running as admin)")
+var errNoSensors = errors.New("no sensors found (try running as admin with LHM=true)")
 
 // newlhmProcess copies the embedded LHM executable to a temporary directory and starts it.
 func newlhmProcess() (*lhmProcess, error) {
@@ -139,7 +140,7 @@ func (lhm *lhmProcess) cleanupProcess() {
 }
 
 func (lhm *lhmProcess) getTemps(ctx context.Context) (temps []sensors.TemperatureStat, err error) {
-	if lhm.stoppedNoSensors {
+	if !useLHM || lhm.stoppedNoSensors {
 		// Fall back to gopsutil if we can't get sensors from LHM
 		return sensors.TemperaturesWithContext(ctx)
 	}
@@ -222,6 +223,10 @@ func getSensorTemps(ctx context.Context) (temps []sensors.TemperatureStat, err e
 		}
 	}()
 
+	if !useLHM {
+		return sensors.TemperaturesWithContext(ctx)
+	}
+
 	// Initialize process once
 	beszelLhmOnce.Do(func() {
 		beszelLhm, err = newlhmProcess()

agent/server.go

@@ -1,9 +1,6 @@
 package agent
 
 import (
-	"beszel"
-	"beszel/internal/common"
-	"beszel/internal/entities/system"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -14,6 +11,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/blang/semver"
 	"github.com/fxamacker/cbor/v2"
 	"github.com/gliderlabs/ssh"
@@ -126,15 +127,77 @@ func (a *Agent) handleSession(s ssh.Session) {
 
 	hubVersion := a.getHubVersion(sessionID, sessionCtx)
 
-	stats := a.gatherStats(sessionID)
-
-	err := a.writeToSession(s, stats, hubVersion)
-	if err != nil {
-		slog.Error("Error encoding stats", "err", err, "stats", stats)
-		s.Exit(1)
-	} else {
-		s.Exit(0)
+	// Legacy one-shot behavior for older hubs
+	if hubVersion.LT(beszel.MinVersionAgentResponse) {
+		if err := a.handleLegacyStats(s, hubVersion); err != nil {
+			slog.Error("Error encoding stats", "err", err)
+			s.Exit(1)
+			return
+		}
 	}
+
+	var req common.HubRequest[cbor.RawMessage]
+	if err := cbor.NewDecoder(s).Decode(&req); err != nil {
+		// Fallback to legacy one-shot if the first decode fails
+		if err2 := a.handleLegacyStats(s, hubVersion); err2 != nil {
+			slog.Error("Error encoding stats (fallback)", "err", err2)
+			s.Exit(1)
+			return
+		}
+		s.Exit(0)
+		return
+	}
+	if err := a.handleSSHRequest(s, &req); err != nil {
+		slog.Error("SSH request handling failed", "err", err)
+		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
+		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/server_test.go

@@ -1,8 +1,6 @@
 package agent
 
 import (
-	"beszel/internal/entities/container"
-	"beszel/internal/entities/system"
 	"context"
 	"crypto/ed25519"
 	"encoding/json"
@@ -15,6 +13,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/henrygd/beszel/internal/entities/container"
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/blang/semver"
 	"github.com/fxamacker/cbor/v2"
 	"github.com/gliderlabs/ssh"

agent/smart.go

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

agent/system.go

@@ -1,9 +1,6 @@
 package agent
 
 import (
-	"beszel"
-	"beszel/internal/agent/battery"
-	"beszel/internal/entities/system"
 	"bufio"
 	"fmt"
 	"log/slog"
@@ -12,14 +9,23 @@ import (
 	"strings"
 	"time"
 
+	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/agent/battery"
+	"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
@@ -31,7 +37,7 @@ func (a *Agent) initializeSystemInfo() {
 		a.systemInfo.KernelVersion = version
 		a.systemInfo.Os = system.Darwin
 	} else if strings.Contains(platform, "indows") {
-		a.systemInfo.KernelVersion = strings.Replace(platform, "Microsoft ", "", 1) + " " + version
+		a.systemInfo.KernelVersion = fmt.Sprintf("%s %s", strings.Replace(platform, "Microsoft ", "", 1), version)
 		a.systemInfo.Os = system.Windows
 	} else if platform == "freebsd" {
 		a.systemInfo.Os = system.Freebsd
@@ -68,20 +74,21 @@ func (a *Agent) initializeSystemInfo() {
 }
 
 // Returns current info, stats about the host system
-func (a *Agent) getSystemStats() system.Stats {
-	systemStats := system.Stats{}
+func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
+	var systemStats system.Stats
 
 	// battery
-	if battery.HasReadableBattery() {
-		systemStats.Battery[0], systemStats.Battery[1], _ = battery.GetBatteryStats()
+	if batteryPercent, batteryState, err := battery.GetBatteryStats(); err == nil {
+		systemStats.Battery[0] = batteryPercent
+		systemStats.Battery[1] = batteryState
 	}
 
 	// cpu percent
-	cpuPct, err := cpu.Percent(0, false)
-	if err != nil {
+	cpuPercent, err := getCpuPercent(cacheTimeMs)
+	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
@@ -100,14 +107,22 @@ func (a *Agent) getSystemStats() system.Stats {
 		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
 		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
 		// cache + buffers value for default mem calculation
-		cacheBuff := v.Total - v.Free - v.Used
-		// htop memory calculation overrides
+		// note: gopsutil automatically adds SReclaimable to v.Cached
+		cacheBuff := v.Cached + v.Buffers - v.Shared
+		if cacheBuff <= 0 {
+			cacheBuff = max(v.Total-v.Free-v.Used, 0)
+		}
+		// htop memory calculation overrides (likely outdated as of mid 2025)
 		if a.memCalc == "htop" {
-			// note: gopsutil automatically adds SReclaimable to v.Cached
-			cacheBuff = v.Cached + v.Buffers - v.Shared
+			// 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 {
@@ -123,104 +138,13 @@ func (a *Agent) getSystemStats() 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
-		}
-	}
+	a.updateDiskUsage(&systemStats)
 
-	// disk i/o
-	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
-		for _, d := range ioCounters {
-			stats := a.fsStats[d.Name]
-			if stats == nil {
-				continue
-			}
-			secondsElapsed := time.Since(stats.Time).Seconds()
-			readPerSecond := bytesToMegabytes(float64(d.ReadBytes-stats.TotalRead) / secondsElapsed)
-			writePerSecond := bytesToMegabytes(float64(d.WriteBytes-stats.TotalWrite) / secondsElapsed)
-			// check for invalid values and reset stats if so
-			if readPerSecond < 0 || writePerSecond < 0 || readPerSecond > 50_000 || writePerSecond > 50_000 {
-				slog.Warn("Invalid disk I/O. Resetting.", "name", d.Name, "read", readPerSecond, "write", writePerSecond)
-				a.initializeDiskIoStats(ioCounters)
-				break
-			}
-			stats.Time = time.Now()
-			stats.DiskReadPs = readPerSecond
-			stats.DiskWritePs = writePerSecond
-			stats.TotalRead = d.ReadBytes
-			stats.TotalWrite = d.WriteBytes
-			// if root filesystem, update system stats
-			if stats.Root {
-				systemStats.DiskReadPs = stats.DiskReadPs
-				systemStats.DiskWritePs = stats.DiskWritePs
-			}
-		}
-	}
+	// disk i/o (cache-aware per interval)
+	a.updateDiskIo(cacheTimeMs, &systemStats)
 
-	// network stats
-	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()
-	}
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		msElapsed := uint64(time.Since(a.netIoStats.Time).Milliseconds())
-		a.netIoStats.Time = time.Now()
-		totalBytesSent := uint64(0)
-		totalBytesRecv := uint64(0)
-		// sum all bytes sent and received
-		for _, v := range netIO {
-			// skip if not in valid network interfaces list
-			if _, exists := a.netInterfaces[v.Name]; !exists {
-				continue
-			}
-			totalBytesSent += v.BytesSent
-			totalBytesRecv += v.BytesRecv
-		}
-		// add to systemStats
-		var bytesSentPerSecond, bytesRecvPerSecond uint64
-		if msElapsed > 0 {
-			bytesSentPerSecond = (totalBytesSent - a.netIoStats.BytesSent) * 1000 / msElapsed
-			bytesRecvPerSecond = (totalBytesRecv - a.netIoStats.BytesRecv) * 1000 / msElapsed
-		}
-		networkSentPs := bytesToMegabytes(float64(bytesSentPerSecond))
-		networkRecvPs := bytesToMegabytes(float64(bytesRecvPerSecond))
-		// add check for issue (#150) where sent is a massive number
-		if networkSentPs > 10_000 || networkRecvPs > 10_000 {
-			slog.Warn("Invalid net stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
-			for _, v := range netIO {
-				if _, exists := a.netInterfaces[v.Name]; !exists {
-					continue
-				}
-				slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
-			}
-			// reset network I/O stats
-			a.initializeNetIoStats()
-		} else {
-			systemStats.NetworkSent = networkSentPs
-			systemStats.NetworkRecv = networkRecvPs
-			systemStats.Bandwidth[0], systemStats.Bandwidth[1] = bytesSentPerSecond, bytesRecvPerSecond
-			// update netIoStats
-			a.netIoStats.BytesSent = totalBytesSent
-			a.netIoStats.BytesRecv = totalBytesRecv
-		}
-	}
+	// network stats (per cache interval)
+	a.updateNetworkStats(cacheTimeMs, &systemStats)
 
 	// temperatures
 	// TODO: maybe refactor to methods on systemStats
@@ -231,7 +155,7 @@ func (a *Agent) getSystemStats() system.Stats {
 		// reset high gpu percent
 		a.systemInfo.GpuPct = 0
 		// get current GPU data
-		if gpuData := a.gpuManager.GetCurrentData(); len(gpuData) > 0 {
+		if gpuData := a.gpuManager.GetCurrentData(cacheTimeMs); len(gpuData) > 0 {
 			systemStats.GPUData = gpuData
 
 			// add temperatures
@@ -260,6 +184,7 @@ func (a *Agent) getSystemStats() 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

agent/test-data/container.json

@@ -0,0 +1,24 @@
+{
+	"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

@@ -0,0 +1,24 @@
+{
+	"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

@@ -1,12 +1,14 @@
 package agent
 
 import (
-	"beszel/internal/ghupdate"
 	"fmt"
 	"log"
 	"os"
 	"os/exec"
+	"runtime"
 	"strings"
+
+	"github.com/henrygd/beszel/internal/ghupdate"
 )
 
 // restarter knows how to restart the beszel-agent service.
@@ -28,21 +30,32 @@ func (s *systemdRestarter) Restart() error {
 type openRCRestarter struct{ cmd string }
 
 func (o *openRCRestarter) Restart() error {
-	if err := exec.Command(o.cmd, "status", "beszel-agent").Run(); err != nil {
+	if err := exec.Command(o.cmd, "beszel-agent", "status").Run(); err != nil {
 		return nil
 	}
 	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via OpenRC…")
-	return exec.Command(o.cmd, "restart", "beszel-agent").Run()
+	return exec.Command(o.cmd, "beszel-agent", "restart").Run()
 }
 
 type openWRTRestarter struct{ cmd string }
 
 func (w *openWRTRestarter) Restart() error {
-	if err := exec.Command(w.cmd, "running", "beszel-agent").Run(); err != nil {
+	// https://openwrt.org/docs/guide-user/base-system/managing_services?s[]=service
+	if err := exec.Command("/etc/init.d/beszel-agent", "running").Run(); err != nil {
 		return nil
 	}
 	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via procd…")
-	return exec.Command(w.cmd, "restart", "beszel-agent").Run()
+	return exec.Command("/etc/init.d/beszel-agent", "restart").Run()
+}
+
+type freeBSDRestarter struct{ cmd string }
+
+func (f *freeBSDRestarter) Restart() error {
+	if err := exec.Command(f.cmd, "beszel-agent", "status").Run(); err != nil {
+		return nil
+	}
+	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via FreeBSD rc…")
+	return exec.Command(f.cmd, "beszel-agent", "restart").Run()
 }
 
 func detectRestarter() restarter {
@@ -52,8 +65,13 @@ 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 {
-		return &openWRTRestarter{cmd: path}
+		if runtime.GOOS == "freebsd" {
+			return &freeBSDRestarter{cmd: path}
+		}
 	}
 	return nil
 }

beszel.go

@@ -0,0 +1,18 @@
+// Package beszel provides core application constants and version information
+// which are used throughout the application.
+package beszel
+
+import "github.com/blang/semver"
+
+const (
+	// Version is the current version of the application.
+	Version = "0.14.1"
+	// 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")

beszel/dockerfile_agent_nvidia

@@ -1,21 +0,0 @@
-FROM --platform=$BUILDPLATFORM golang:alpine AS builder
-
-WORKDIR /app
-
-COPY go.mod go.sum ./
-# RUN go mod download
-COPY *.go ./
-COPY cmd ./cmd
-COPY internal ./internal
-
-# Build
-ARG TARGETOS TARGETARCH
-RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./cmd/agent
-
-# --------------------------
-# Final image: GPU-enabled agent with nvidia-smi
-# --------------------------
-FROM nvidia/cuda:12.2.2-base-ubuntu22.04
-COPY --from=builder /agent /agent
-
-ENTRYPOINT ["/agent"]

beszel/internal/agent/agent.go

@@ -1,182 +0,0 @@
-// Package agent handles the agent's SSH server and system stats collection.
-package agent
-
-import (
-	"beszel"
-	"beszel/internal/entities/system"
-	"crypto/sha256"
-	"encoding/hex"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/gliderlabs/ssh"
-	"github.com/shirou/gopsutil/v4/host"
-	gossh "golang.org/x/crypto/ssh"
-)
-
-type Agent struct {
-	sync.Mutex                                   // Used to lock agent while collecting data
-	debug             bool                       // true if LOG_LEVEL is set to debug
-	zfs               bool                       // true if system has arcstats
-	memCalc           string                     // Memory calculation formula
-	fsNames           []string                   // List of filesystem device names being monitored
-	fsStats           map[string]*system.FsStats // Keeps track of disk stats for each filesystem
-	netInterfaces     map[string]struct{}        // Stores all valid network interfaces
-	netIoStats        system.NetIoStats          // Keeps track of bandwidth usage
-	dockerManager     *dockerManager             // Manages Docker API requests
-	sensorConfig      *SensorConfig              // Sensors config
-	systemInfo        system.Info                // Host system info
-	gpuManager        *GPUManager                // Manages GPU data
-	cache             *SessionCache              // Cache for system stats based on primary session ID
-	connectionManager *ConnectionManager         // Channel to signal connection events
-	server            *ssh.Server                // SSH server
-	dataDir           string                     // Directory for persisting data
-	keys              []gossh.PublicKey          // SSH public keys
-}
-
-// NewAgent creates a new agent with the given data directory for persisting data.
-// If the data directory is not set, it will attempt to find the optimal directory.
-func NewAgent(dataDir ...string) (agent *Agent, err error) {
-	agent = &Agent{
-		fsStats: make(map[string]*system.FsStats),
-		cache:   NewSessionCache(69 * time.Second),
-	}
-
-	agent.dataDir, err = getDataDir(dataDir...)
-	if err != nil {
-		slog.Warn("Data directory not found")
-	} else {
-		slog.Info("Data directory", "path", agent.dataDir)
-	}
-
-	agent.memCalc, _ = GetEnv("MEM_CALC")
-	agent.sensorConfig = agent.newSensorConfig()
-	// Set up slog with a log level determined by the LOG_LEVEL env var
-	if logLevelStr, exists := GetEnv("LOG_LEVEL"); exists {
-		switch strings.ToLower(logLevelStr) {
-		case "debug":
-			agent.debug = true
-			slog.SetLogLoggerLevel(slog.LevelDebug)
-		case "warn":
-			slog.SetLogLoggerLevel(slog.LevelWarn)
-		case "error":
-			slog.SetLogLoggerLevel(slog.LevelError)
-		}
-	}
-
-	slog.Debug(beszel.Version)
-
-	// initialize system info
-	agent.initializeSystemInfo()
-
-	// initialize connection manager
-	agent.connectionManager = newConnectionManager(agent)
-
-	// initialize disk info
-	agent.initializeDiskInfo()
-
-	// initialize net io stats
-	agent.initializeNetIoStats()
-
-	// initialize docker manager
-	agent.dockerManager = newDockerManager(agent)
-
-	// initialize GPU manager
-	if gm, err := NewGPUManager(); err != nil {
-		slog.Debug("GPU", "err", err)
-	} else {
-		agent.gpuManager = gm
-	}
-
-	// if debugging, print stats
-	if agent.debug {
-		slog.Debug("Stats", "data", agent.gatherStats(""))
-	}
-
-	return agent, nil
-}
-
-// GetEnv retrieves an environment variable with a "BESZEL_AGENT_" prefix, or falls back to the unprefixed key.
-func GetEnv(key string) (value string, exists bool) {
-	if value, exists = os.LookupEnv("BESZEL_AGENT_" + key); exists {
-		return value, exists
-	}
-	// Fallback to the old unprefixed key
-	return os.LookupEnv(key)
-}
-
-func (a *Agent) gatherStats(sessionID string) *system.CombinedData {
-	a.Lock()
-	defer a.Unlock()
-
-	data, isCached := a.cache.Get(sessionID)
-	if isCached {
-		slog.Debug("Cached data", "session", sessionID)
-		return data
-	}
-
-	*data = system.CombinedData{
-		Stats: a.getSystemStats(),
-		Info:  a.systemInfo,
-	}
-	slog.Debug("System data", "data", data)
-
-	if a.dockerManager != nil {
-		if containerStats, err := a.dockerManager.getDockerStats(); err == nil {
-			data.Containers = containerStats
-			slog.Debug("Containers", "data", data.Containers)
-		} else {
-			slog.Debug("Containers", "err", err)
-		}
-	}
-
-	data.Stats.ExtraFs = make(map[string]*system.FsStats)
-	for name, stats := range a.fsStats {
-		if !stats.Root && stats.DiskTotal > 0 {
-			data.Stats.ExtraFs[name] = stats
-		}
-	}
-	slog.Debug("Extra FS", "data", data.Stats.ExtraFs)
-
-	a.cache.Set(sessionID, data)
-	return data
-}
-
-// StartAgent initializes and starts the agent with optional WebSocket connection
-func (a *Agent) Start(serverOptions ServerOptions) error {
-	a.keys = serverOptions.Keys
-	return a.connectionManager.Start(serverOptions)
-}
-
-func (a *Agent) getFingerprint() string {
-	// first look for a fingerprint in the data directory
-	if a.dataDir != "" {
-		if fp, err := os.ReadFile(filepath.Join(a.dataDir, "fingerprint")); err == nil {
-			return string(fp)
-		}
-	}
-
-	// if no fingerprint is found, generate one
-	fingerprint, err := host.HostID()
-	if err != nil || fingerprint == "" {
-		fingerprint = a.systemInfo.Hostname + a.systemInfo.CpuModel
-	}
-
-	// hash fingerprint
-	sum := sha256.Sum256([]byte(fingerprint))
-	fingerprint = hex.EncodeToString(sum[:24])
-
-	// save fingerprint to data directory
-	if a.dataDir != "" {
-		err = os.WriteFile(filepath.Join(a.dataDir, "fingerprint"), []byte(fingerprint), 0644)
-		if err != nil {
-			slog.Warn("Failed to save fingerprint", "err", err)
-		}
-	}
-
-	return fingerprint
-}

beszel/internal/agent/agent_cache.go

@@ -1,36 +0,0 @@
-package agent
-
-import (
-	"beszel/internal/entities/system"
-	"time"
-)
-
-// Not thread safe since we only access from gatherStats which is already locked
-type SessionCache struct {
-	data           *system.CombinedData
-	lastUpdate     time.Time
-	primarySession string
-	leaseTime      time.Duration
-}
-
-func NewSessionCache(leaseTime time.Duration) *SessionCache {
-	return &SessionCache{
-		leaseTime: leaseTime,
-		data:      &system.CombinedData{},
-	}
-}
-
-func (c *SessionCache) Get(sessionID string) (stats *system.CombinedData, isCached bool) {
-	if sessionID != c.primarySession && time.Since(c.lastUpdate) < c.leaseTime {
-		return c.data, true
-	}
-	return c.data, false
-}
-
-func (c *SessionCache) Set(sessionID string, data *system.CombinedData) {
-	if data != nil {
-		*c.data = *data
-	}
-	c.primarySession = sessionID
-	c.lastUpdate = time.Now()
-}

beszel/internal/agent/agent_cache_test.go

@@ -1,88 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"beszel/internal/entities/system"
-	"testing"
-	"testing/synctest"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestSessionCache_GetSet(t *testing.T) {
-	synctest.Test(t, func(t *testing.T) {
-		cache := NewSessionCache(69 * time.Second)
-
-		testData := &system.CombinedData{
-			Info: system.Info{
-				Hostname: "test-host",
-				Cores:    4,
-			},
-			Stats: system.Stats{
-				Cpu:     50.0,
-				MemPct:  30.0,
-				DiskPct: 40.0,
-			},
-		}
-
-		// Test initial state - should not be cached
-		data, isCached := cache.Get("session1")
-		assert.False(t, isCached, "Expected no cached data initially")
-		assert.NotNil(t, data, "Expected data to be initialized")
-		// Set data for session1
-		cache.Set("session1", testData)
-
-		time.Sleep(15 * time.Second)
-
-		// Get data for a different session - should be cached
-		data, isCached = cache.Get("session2")
-		assert.True(t, isCached, "Expected data to be cached for non-primary session")
-		require.NotNil(t, data, "Expected cached data to be returned")
-		assert.Equal(t, "test-host", data.Info.Hostname, "Hostname should match test data")
-		assert.Equal(t, 4, data.Info.Cores, "Cores should match test data")
-		assert.Equal(t, 50.0, data.Stats.Cpu, "CPU should match test data")
-		assert.Equal(t, 30.0, data.Stats.MemPct, "Memory percentage should match test data")
-		assert.Equal(t, 40.0, data.Stats.DiskPct, "Disk percentage should match test data")
-
-		time.Sleep(10 * time.Second)
-
-		// Get data for the primary session - should not be cached
-		data, isCached = cache.Get("session1")
-		assert.False(t, isCached, "Expected data not to be cached for primary session")
-		require.NotNil(t, data, "Expected data to be returned even if not cached")
-		assert.Equal(t, "test-host", data.Info.Hostname, "Hostname should match test data")
-		// if not cached, agent will update the data
-		cache.Set("session1", testData)
-
-		time.Sleep(45 * time.Second)
-
-		// Get data for a different session - should still be cached
-		_, isCached = cache.Get("session2")
-		assert.True(t, isCached, "Expected data to be cached for non-primary session")
-
-		// Wait for the lease to expire
-		time.Sleep(30 * time.Second)
-
-		// Get data for session2 - should not be cached
-		_, isCached = cache.Get("session2")
-		assert.False(t, isCached, "Expected data not to be cached after lease expiration")
-	})
-}
-
-func TestSessionCache_NilData(t *testing.T) {
-	// Create a new SessionCache
-	cache := NewSessionCache(30 * time.Second)
-
-	// Test setting nil data (should not panic)
-	assert.NotPanics(t, func() {
-		cache.Set("session1", nil)
-	}, "Setting nil data should not panic")
-
-	// Get data - should not be nil even though we set nil
-	data, _ := cache.Get("session2")
-	assert.NotNil(t, data, "Expected data to not be nil after setting nil data")
-}

beszel/internal/agent/battery/battery.go

@@ -1,53 +0,0 @@
-//go:build !freebsd
-
-// Package battery provides functions to check if the system has a battery and to get the battery stats.
-package battery
-
-import (
-	"errors"
-	"log/slog"
-
-	"github.com/distatus/battery"
-)
-
-var systemHasBattery = false
-var haveCheckedBattery = false
-
-// HasReadableBattery checks if the system has a battery and returns true if it does.
-func HasReadableBattery() bool {
-	if haveCheckedBattery {
-		return systemHasBattery
-	}
-	haveCheckedBattery = true
-	bat, err := battery.Get(0)
-	if err == nil && bat != nil {
-		systemHasBattery = true
-	} else {
-		slog.Debug("No battery found", "err", err)
-	}
-	return systemHasBattery
-}
-
-// GetBatteryStats returns the current battery percent and charge state
-func GetBatteryStats() (batteryPercent uint8, batteryState uint8, err error) {
-	if !systemHasBattery {
-		return batteryPercent, batteryState, errors.ErrUnsupported
-	}
-	batteries, err := battery.GetAll()
-	if err != nil || len(batteries) == 0 {
-		return batteryPercent, batteryState, err
-	}
-	totalCapacity := float64(0)
-	totalCharge := float64(0)
-	for _, bat := range batteries {
-		if bat.Design != 0 {
-			totalCapacity += bat.Design
-		} else {
-			totalCapacity += bat.Full
-		}
-		totalCharge += bat.Current
-	}
-	batteryPercent = uint8(totalCharge / totalCapacity * 100)
-	batteryState = uint8(batteries[0].State.Raw)
-	return batteryPercent, batteryState, nil
-}

beszel/internal/agent/docker.go

@@ -1,369 +0,0 @@
-package agent
-
-import (
-	"beszel/internal/entities/container"
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/blang/semver"
-)
-
-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 (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)
-	isWindows           bool                        // Whether the Docker Engine API is running on Windows
-	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
-}
-
-// userAgentRoundTripper is a custom http.RoundTripper that adds a User-Agent header to all requests
-type userAgentRoundTripper struct {
-	rt        http.RoundTripper
-	userAgent string
-}
-
-// RoundTrip implements the http.RoundTripper interface
-func (u *userAgentRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	req.Header.Set("User-Agent", u.userAgent)
-	return u.rt.RoundTrip(req)
-}
-
-// Add goroutine to the queue
-func (d *dockerManager) queue() {
-	d.wg.Add(1)
-	if d.goodDockerVersion {
-		d.sem <- struct{}{}
-	}
-}
-
-// Remove goroutine from the queue
-func (d *dockerManager) dequeue() {
-	d.wg.Done()
-	if d.goodDockerVersion {
-		<-d.sem
-	}
-}
-
-// Returns stats for all running containers
-func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
-	resp, err := dm.client.Get("http://localhost/containers/json")
-	if err != nil {
-		return nil, err
-	}
-
-	dm.apiContainerList = dm.apiContainerList[:0]
-	if err := dm.decode(resp, &dm.apiContainerList); err != nil {
-		return nil, err
-	}
-
-	dm.isWindows = strings.Contains(resp.Header.Get("Server"), "windows")
-
-	containersLength := len(dm.apiContainerList)
-
-	// store valid ids to clean up old container ids from map
-	if dm.validIds == nil {
-		dm.validIds = make(map[string]struct{}, containersLength)
-	} else {
-		clear(dm.validIds)
-	}
-
-	var failedContainers []*container.ApiInfo
-
-	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)
-		// note: can't use Created field because it's not updated on restart
-		if strings.Contains(ctr.Status, "second") {
-			// if so, remove old container data
-			dm.deleteContainerStatsSync(ctr.IdShort)
-		}
-		dm.queue()
-		go func() {
-			defer dm.dequeue()
-			err := dm.updateContainerStats(ctr)
-			// if error, delete from map and add to failed list to retry
-			if err != nil {
-				dm.containerStatsMutex.Lock()
-				delete(dm.containerStatsMap, ctr.IdShort)
-				failedContainers = append(failedContainers, ctr)
-				dm.containerStatsMutex.Unlock()
-			}
-		}()
-	}
-
-	dm.wg.Wait()
-
-	// retry failed containers separately so we can run them in parallel (docker 24 bug)
-	if len(failedContainers) > 0 {
-		slog.Debug("Retrying failed containers", "count", len(failedContainers))
-		for i := range failedContainers {
-			ctr := failedContainers[i]
-			dm.queue()
-			go func() {
-				defer dm.dequeue()
-				err = dm.updateContainerStats(ctr)
-				if err != nil {
-					slog.Error("Error getting container stats", "err", err)
-				}
-			}()
-		}
-		dm.wg.Wait()
-	}
-
-	// populate final stats and remove old / invalid container stats
-	stats := make([]*container.Stats, 0, containersLength)
-	for id, v := range dm.containerStatsMap {
-		if _, exists := dm.validIds[id]; !exists {
-			delete(dm.containerStatsMap, id)
-		} else {
-			stats = append(stats, v)
-		}
-	}
-
-	return stats, nil
-}
-
-// Updates stats for individual container
-func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
-	name := ctr.Names[0][1:]
-
-	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()
-
-	// add empty values if they doesn't exist in map
-	stats, initialized := dm.containerStatsMap[ctr.IdShort]
-	if !initialized {
-		stats = &container.Stats{Name: name}
-		dm.containerStatsMap[ctr.IdShort] = stats
-	}
-
-	// 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
-	}
-
-	// calculate cpu and memory stats
-	var usedMemory uint64
-	var cpuPct float64
-
-	// store current cpu stats
-	prevCpuContainer, prevCpuSystem := stats.CpuContainer, stats.CpuSystem
-	stats.CpuContainer = res.CPUStats.CPUUsage.TotalUsage
-	stats.CpuSystem = res.CPUStats.SystemUsage
-
-	if dm.isWindows {
-		usedMemory = res.MemoryStats.PrivateWorkingSet
-		cpuPct = res.CalculateCpuPercentWindows(prevCpuContainer, stats.PrevReadTime)
-	} else {
-		// check if container has valid data, otherwise may be in restart loop (#103)
-		if res.MemoryStats.Usage == 0 {
-			return fmt.Errorf("%s - no memory stats - see https://github.com/henrygd/beszel/issues/144", name)
-		}
-		memCache := res.MemoryStats.Stats.InactiveFile
-		if memCache == 0 {
-			memCache = res.MemoryStats.Stats.Cache
-		}
-		usedMemory = res.MemoryStats.Usage - memCache
-
-		cpuPct = res.CalculateCpuPercentLinux(prevCpuContainer, prevCpuSystem)
-	}
-
-	if cpuPct > 100 {
-		return fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
-	}
-
-	// network
-	var total_sent, total_recv uint64
-	for _, v := range res.Networks {
-		total_sent += v.TxBytes
-		total_recv += v.RxBytes
-	}
-	var sent_delta, recv_delta uint64
-	millisecondsElapsed := uint64(time.Since(stats.PrevReadTime).Milliseconds())
-	if initialized && millisecondsElapsed > 0 {
-		// get bytes per second
-		sent_delta = (total_sent - stats.PrevNet.Sent) * 1000 / millisecondsElapsed
-		recv_delta = (total_recv - stats.PrevNet.Recv) * 1000 / millisecondsElapsed
-		// check for unrealistic network values (> 5GB/s)
-		if sent_delta > 5e9 || recv_delta > 5e9 {
-			slog.Warn("Bad network delta", "container", name)
-			sent_delta, recv_delta = 0, 0
-		}
-	}
-	stats.PrevNet.Sent, stats.PrevNet.Recv = total_sent, total_recv
-
-	stats.Cpu = twoDecimals(cpuPct)
-	stats.Mem = bytesToMegabytes(float64(usedMemory))
-	stats.NetworkSent = bytesToMegabytes(float64(sent_delta))
-	stats.NetworkRecv = bytesToMegabytes(float64(recv_delta))
-	stats.PrevReadTime = res.Read
-
-	return nil
-}
-
-// Delete container stats from map using mutex
-func (dm *dockerManager) deleteContainerStatsSync(id string) {
-	dm.containerStatsMutex.Lock()
-	defer dm.containerStatsMutex.Unlock()
-	delete(dm.containerStatsMap, id)
-}
-
-// Creates a new http client for Docker or Podman API
-func newDockerManager(a *Agent) *dockerManager {
-	dockerHost, exists := GetEnv("DOCKER_HOST")
-	if exists {
-		// return nil if set to empty string
-		if dockerHost == "" {
-			return nil
-		}
-	} else {
-		dockerHost = getDockerHost()
-	}
-
-	parsedURL, err := url.Parse(dockerHost)
-	if err != nil {
-		os.Exit(1)
-	}
-
-	transport := &http.Transport{
-		DisableCompression: true,
-		MaxConnsPerHost:    0,
-	}
-
-	switch parsedURL.Scheme {
-	case "unix":
-		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
-			return (&net.Dialer{}).DialContext(ctx, "unix", parsedURL.Path)
-		}
-	case "tcp", "http", "https":
-		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
-			return (&net.Dialer{}).DialContext(ctx, "tcp", parsedURL.Host)
-		}
-	default:
-		slog.Error("Invalid DOCKER_HOST", "scheme", parsedURL.Scheme)
-		os.Exit(1)
-	}
-
-	// configurable timeout
-	timeout := time.Millisecond * 2100
-	if t, set := GetEnv("DOCKER_TIMEOUT"); set {
-		timeout, err = time.ParseDuration(t)
-		if err != nil {
-			slog.Error(err.Error())
-			os.Exit(1)
-		}
-		slog.Info("DOCKER_TIMEOUT", "timeout", timeout)
-	}
-
-	// Custom user-agent to avoid docker bug: https://github.com/docker/for-mac/issues/7575
-	userAgentTransport := &userAgentRoundTripper{
-		rt:        transport,
-		userAgent: "Docker-Client/",
-	}
-
-	manager := &dockerManager{
-		client: &http.Client{
-			Timeout:   timeout,
-			Transport: userAgentTransport,
-		},
-		containerStatsMap: make(map[string]*container.Stats),
-		sem:               make(chan struct{}, 5),
-		apiContainerList:  []*container.ApiInfo{},
-		apiStats:          &container.ApiStats{},
-	}
-
-	// If using podman, return client
-	if strings.Contains(dockerHost, "podman") {
-		a.systemInfo.Podman = true
-		manager.goodDockerVersion = true
-		return manager
-	}
-
-	// Check docker version
-	// (versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch)
-	var versionInfo struct {
-		Version string `json:"Version"`
-	}
-	resp, err := manager.client.Get("http://localhost/version")
-	if err != nil {
-		return manager
-	}
-
-	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 {
-		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.
-func (dm *dockerManager) decode(resp *http.Response, d any) error {
-	if dm.buf == nil {
-		// initialize buffer with 256kb starting size
-		dm.buf = bytes.NewBuffer(make([]byte, 0, 1024*256))
-		dm.decoder = json.NewDecoder(dm.buf)
-	}
-	defer resp.Body.Close()
-	defer dm.buf.Reset()
-	_, err := dm.buf.ReadFrom(resp.Body)
-	if err != nil {
-		return err
-	}
-	return dm.decoder.Decode(d)
-}
-
-// Test docker / podman sockets and return if one exists
-func getDockerHost() string {
-	scheme := "unix://"
-	socks := []string{"/var/run/docker.sock", fmt.Sprintf("/run/user/%v/podman/podman.sock", os.Getuid())}
-	for _, sock := range socks {
-		if _, err := os.Stat(sock); err == nil {
-			return scheme + sock
-		}
-	}
-	return scheme + socks[0]
-}

beszel/internal/agent/gpu_test.go

@@ -1,793 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"beszel/internal/entities/system"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestParseNvidiaData(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantData  map[string]system.GPUData
-		wantValid bool
-	}{
-		{
-			name:  "valid multi-gpu data",
-			input: "0, NVIDIA GeForce RTX 3050 Ti Laptop GPU, 48, 12, 4096, 26.3, 12.73\n1, NVIDIA A100-PCIE-40GB, 38, 74, 40960, [N/A], 36.79",
-			wantData: map[string]system.GPUData{
-				"0": {
-					Name:        "GeForce RTX 3050 Ti",
-					Temperature: 48.0,
-					MemoryUsed:  12.0 / 1.024,
-					MemoryTotal: 4096.0 / 1.024,
-					Usage:       26.3,
-					Power:       12.73,
-					Count:       1,
-				},
-				"1": {
-					Name:        "A100-PCIE-40GB",
-					Temperature: 38.0,
-					MemoryUsed:  74.0 / 1.024,
-					MemoryTotal: 40960.0 / 1.024,
-					Usage:       0.0,
-					Power:       36.79,
-					Count:       1,
-				},
-			},
-			wantValid: true,
-		},
-		{
-			name: "more valid multi-gpu data",
-			input: `0, NVIDIA A10, 45, 19676, 23028, 0, 58.98
-1, NVIDIA A10, 45, 19638, 23028, 0, 62.35
-2, NVIDIA A10, 44, 21700, 23028, 0, 59.57
-3, NVIDIA A10, 45, 18222, 23028, 0, 61.76`,
-			wantData: map[string]system.GPUData{
-				"0": {
-					Name:        "A10",
-					Temperature: 45.0,
-					MemoryUsed:  19676.0 / 1.024,
-					MemoryTotal: 23028.0 / 1.024,
-					Usage:       0.0,
-					Power:       58.98,
-					Count:       1,
-				},
-				"1": {
-					Name:        "A10",
-					Temperature: 45.0,
-					MemoryUsed:  19638.0 / 1.024,
-					MemoryTotal: 23028.0 / 1.024,
-					Usage:       0.0,
-					Power:       62.35,
-					Count:       1,
-				},
-				"2": {
-					Name:        "A10",
-					Temperature: 44.0,
-					MemoryUsed:  21700.0 / 1.024,
-					MemoryTotal: 23028.0 / 1.024,
-					Usage:       0.0,
-					Power:       59.57,
-					Count:       1,
-				},
-				"3": {
-					Name:        "A10",
-					Temperature: 45.0,
-					MemoryUsed:  18222.0 / 1.024,
-					MemoryTotal: 23028.0 / 1.024,
-					Usage:       0.0,
-					Power:       61.76,
-					Count:       1,
-				},
-			},
-			wantValid: true,
-		},
-		{
-			name:      "empty input",
-			input:     "",
-			wantData:  map[string]system.GPUData{},
-			wantValid: false,
-		},
-		{
-			name:      "malformed data",
-			input:     "bad, data, here",
-			wantData:  map[string]system.GPUData{},
-			wantValid: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := &GPUManager{
-				GpuDataMap: make(map[string]*system.GPUData),
-			}
-			valid := gm.parseNvidiaData([]byte(tt.input))
-			assert.Equal(t, tt.wantValid, valid)
-
-			if tt.wantValid {
-				for id, want := range tt.wantData {
-					got := gm.GpuDataMap[id]
-					require.NotNil(t, got)
-					assert.Equal(t, want.Name, got.Name)
-					assert.InDelta(t, want.Temperature, got.Temperature, 0.01)
-					assert.InDelta(t, want.MemoryUsed, got.MemoryUsed, 0.01)
-					assert.InDelta(t, want.MemoryTotal, got.MemoryTotal, 0.01)
-					assert.InDelta(t, want.Usage, got.Usage, 0.01)
-					assert.InDelta(t, want.Power, got.Power, 0.01)
-					assert.Equal(t, want.Count, got.Count)
-				}
-			}
-		})
-	}
-}
-
-func TestParseAmdData(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantData  map[string]system.GPUData
-		wantValid bool
-	}{
-		{
-			name: "valid single gpu data",
-			input: `{
-				"card0": {
-					"GUID": "34756",
-					"Temperature (Sensor edge) (C)": "47.0",
-					"Current Socket Graphics Package Power (W)": "9.215",
-					"GPU use (%)": "0",
-					"VRAM Total Memory (B)": "536870912",
-					"VRAM Total Used Memory (B)": "482263040",
-					"Card Series": "Rembrandt [Radeon 680M]"
-				}
-			}`,
-			wantData: map[string]system.GPUData{
-				"34756": {
-					Name:        "Rembrandt [Radeon 680M]",
-					Temperature: 47.0,
-					MemoryUsed:  482263040.0 / (1024 * 1024),
-					MemoryTotal: 536870912.0 / (1024 * 1024),
-					Usage:       0.0,
-					Power:       9.215,
-					Count:       1,
-				},
-			},
-			wantValid: true,
-		},
-		{
-			name: "valid multi gpu data",
-			input: `{
-				"card0": {
-					"GUID": "34756",
-					"Temperature (Sensor edge) (C)": "47.0",
-					"Current Socket Graphics Package Power (W)": "9.215",
-					"GPU use (%)": "0",
-					"VRAM Total Memory (B)": "536870912",
-					"VRAM Total Used Memory (B)": "482263040",
-					"Card Series": "Rembrandt [Radeon 680M]"
-				},
-				"card1": {
-					"GUID": "38294",
-					"Temperature (Sensor edge) (C)": "49.0",
-					"Temperature (Sensor junction) (C)": "49.0",
-					"Temperature (Sensor memory) (C)": "62.0",
-					"Average Graphics Package Power (W)": "19.0",
-					"GPU use (%)": "20.3",
-					"VRAM Total Memory (B)": "25753026560",
-					"VRAM Total Used Memory (B)": "794341376",
-					"Card Series": "Navi 31 [Radeon RX 7900 XT]"
-				}
-			}`,
-			wantData: map[string]system.GPUData{
-				"34756": {
-					Name:        "Rembrandt [Radeon 680M]",
-					Temperature: 47.0,
-					MemoryUsed:  482263040.0 / (1024 * 1024),
-					MemoryTotal: 536870912.0 / (1024 * 1024),
-					Usage:       0.0,
-					Power:       9.215,
-					Count:       1,
-				},
-				"38294": {
-					Name:        "Navi 31 [Radeon RX 7900 XT]",
-					Temperature: 49.0,
-					MemoryUsed:  794341376.0 / (1024 * 1024),
-					MemoryTotal: 25753026560.0 / (1024 * 1024),
-					Usage:       20.3,
-					Power:       19.0,
-					Count:       1,
-				},
-			},
-			wantValid: true,
-		},
-		{
-			name:  "invalid json",
-			input: "{bad json",
-		},
-		{
-			name:      "invalid json",
-			input:     "{bad json",
-			wantData:  map[string]system.GPUData{},
-			wantValid: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := &GPUManager{
-				GpuDataMap: make(map[string]*system.GPUData),
-			}
-			valid := gm.parseAmdData([]byte(tt.input))
-			assert.Equal(t, tt.wantValid, valid)
-
-			if tt.wantValid {
-				for id, want := range tt.wantData {
-					got := gm.GpuDataMap[id]
-					require.NotNil(t, got)
-					assert.Equal(t, want.Name, got.Name)
-					assert.InDelta(t, want.Temperature, got.Temperature, 0.01)
-					assert.InDelta(t, want.MemoryUsed, got.MemoryUsed, 0.01)
-					assert.InDelta(t, want.MemoryTotal, got.MemoryTotal, 0.01)
-					assert.InDelta(t, want.Usage, got.Usage, 0.01)
-					assert.InDelta(t, want.Power, got.Power, 0.01)
-					assert.Equal(t, want.Count, got.Count)
-				}
-			}
-		})
-	}
-}
-
-func TestParseJetsonData(t *testing.T) {
-	tests := []struct {
-		name        string
-		input       string
-		wantMetrics *system.GPUData
-	}{
-		{
-			name:  "valid data",
-			input: "11-14-2024 22:54:33 RAM 4300/30698MB GR3D_FREQ 45% tj@52.468C VDD_GPU_SOC 2171mW",
-			wantMetrics: &system.GPUData{
-				Name:        "GPU",
-				MemoryUsed:  4300.0,
-				MemoryTotal: 30698.0,
-				Usage:       45.0,
-				Temperature: 52.468,
-				Power:       2.171,
-				Count:       1,
-			},
-		},
-		{
-			name:  "more valid data",
-			input: "11-15-2024 08:38:09 RAM 6185/7620MB (lfb 8x2MB) SWAP 851/3810MB (cached 1MB) CPU [15%@729,11%@729,14%@729,13%@729,11%@729,8%@729] EMC_FREQ 43%@2133 GR3D_FREQ 63%@[621] NVDEC off NVJPG off NVJPG1 off VIC off OFA off APE 200 cpu@53.968C soc2@52.437C soc0@50.75C gpu@53.343C tj@53.968C soc1@51.656C VDD_IN 12479mW/12479mW VDD_CPU_GPU_CV 4667mW/4667mW VDD_SOC 2817mW/2817mW",
-			wantMetrics: &system.GPUData{
-				Name:        "GPU",
-				MemoryUsed:  6185.0,
-				MemoryTotal: 7620.0,
-				Usage:       63.0,
-				Temperature: 53.968,
-				Power:       4.667,
-				Count:       1,
-			},
-		},
-		{
-			name:  "orin nano",
-			input: "06-18-2025 11:25:24 RAM 3452/7620MB (lfb 25x4MB) SWAP 1518/16384MB (cached 174MB) CPU [1%@1420,2%@1420,0%@1420,2%@1420,2%@729,1%@729] GR3D_FREQ 0% cpu@50.031C soc2@49.031C soc0@50C gpu@49.031C tj@50.25C soc1@50.25C VDD_IN 4824mW/4824mW VDD_CPU_GPU_CV 518mW/518mW VDD_SOC 1475mW/1475mW",
-			wantMetrics: &system.GPUData{
-				Name:        "GPU",
-				MemoryUsed:  3452.0,
-				MemoryTotal: 7620.0,
-				Usage:       0.0,
-				Temperature: 50.25,
-				Power:       0.518,
-				Count:       1,
-			},
-		},
-		{
-			name:  "missing temperature",
-			input: "11-14-2024 22:54:33 RAM 4300/30698MB GR3D_FREQ 45% VDD_GPU_SOC 2171mW",
-			wantMetrics: &system.GPUData{
-				Name:        "GPU",
-				MemoryUsed:  4300.0,
-				MemoryTotal: 30698.0,
-				Usage:       45.0,
-				Power:       2.171,
-				Count:       1,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gm := &GPUManager{
-				GpuDataMap: make(map[string]*system.GPUData),
-			}
-			parser := gm.getJetsonParser()
-			valid := parser([]byte(tt.input))
-			assert.Equal(t, true, valid)
-
-			got := gm.GpuDataMap["0"]
-			require.NotNil(t, got)
-			assert.Equal(t, tt.wantMetrics.Name, got.Name)
-			assert.InDelta(t, tt.wantMetrics.MemoryUsed, got.MemoryUsed, 0.01)
-			assert.InDelta(t, tt.wantMetrics.MemoryTotal, got.MemoryTotal, 0.01)
-			assert.InDelta(t, tt.wantMetrics.Usage, got.Usage, 0.01)
-			if tt.wantMetrics.Temperature > 0 {
-				assert.InDelta(t, tt.wantMetrics.Temperature, got.Temperature, 0.01)
-			}
-			assert.InDelta(t, tt.wantMetrics.Power, got.Power, 0.01)
-			assert.Equal(t, tt.wantMetrics.Count, got.Count)
-		})
-	}
-}
-
-func TestGetCurrentData(t *testing.T) {
-	t.Run("calculates averages and resets accumulators", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {
-					Name:        "GPU1",
-					Temperature: 50,
-					MemoryUsed:  2048,
-					MemoryTotal: 4096,
-					Usage:       100, // 100 over 2 counts = 50 avg
-					Power:       200, // 200 over 2 counts = 100 avg
-					Count:       2,
-				},
-				"1": {
-					Name:        "GPU1",
-					Temperature: 60,
-					MemoryUsed:  3072,
-					MemoryTotal: 8192,
-					Usage:       30,
-					Power:       60,
-					Count:       1,
-				},
-				"2": {
-					Name:        "GPU 2",
-					Temperature: 70,
-					MemoryUsed:  4096,
-					MemoryTotal: 8192,
-					Usage:       200,
-					Power:       400,
-					Count:       1,
-				},
-			},
-		}
-
-		result := gm.GetCurrentData()
-
-		// Verify name disambiguation
-		assert.Equal(t, "GPU1 0", result["0"].Name)
-		assert.Equal(t, "GPU1 1", result["1"].Name)
-		assert.Equal(t, "GPU 2", result["2"].Name)
-
-		// Check averaged values in the result
-		assert.InDelta(t, 50.0, result["0"].Usage, 0.01)
-		assert.InDelta(t, 100.0, result["0"].Power, 0.01)
-		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 reset
-		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Count, "GPU 0 Count should be reset")
-		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Usage, "GPU 0 Usage should be reset")
-		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Power, "GPU 0 Power should be reset")
-		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Count, "GPU 1 Count should be reset")
-		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Usage, "GPU 1 Usage should be reset")
-		assert.Equal(t, float64(0), gm.GpuDataMap["1"].Power, "GPU 1 Power should be reset")
-	})
-
-	t.Run("handles zero count without panicking", func(t *testing.T) {
-		gm := &GPUManager{
-			GpuDataMap: map[string]*system.GPUData{
-				"0": {
-					Name:  "TestGPU",
-					Count: 0,
-					Usage: 0,
-					Power: 0,
-				},
-			},
-		}
-
-		var result map[string]system.GPUData
-		assert.NotPanics(t, func() {
-			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 reset count
-		assert.Equal(t, float64(0), gm.GpuDataMap["0"].Count)
-	})
-}
-
-func TestDetectGPUs(t *testing.T) {
-	// Save original PATH
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	// Set up temp dir with the commands
-	tempDir := t.TempDir()
-	os.Setenv("PATH", tempDir)
-
-	tests := []struct {
-		name           string
-		setupCommands  func() error
-		wantNvidiaSmi  bool
-		wantRocmSmi    bool
-		wantTegrastats bool
-		wantErr        bool
-	}{
-		{
-			name: "nvidia-smi not available",
-			setupCommands: func() error {
-				return nil
-			},
-			wantNvidiaSmi:  false,
-			wantRocmSmi:    false,
-			wantTegrastats: false,
-			wantErr:        true,
-		},
-		{
-			name: "nvidia-smi available",
-			setupCommands: func() error {
-				path := filepath.Join(tempDir, "nvidia-smi")
-				script := `#!/bin/sh
-echo "test"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			wantNvidiaSmi:  true,
-			wantTegrastats: false,
-			wantRocmSmi:    false,
-			wantErr:        false,
-		},
-		{
-			name: "rocm-smi available",
-			setupCommands: func() error {
-				path := filepath.Join(tempDir, "rocm-smi")
-				script := `#!/bin/sh
-echo "test"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			wantNvidiaSmi:  true,
-			wantRocmSmi:    true,
-			wantTegrastats: false,
-			wantErr:        false,
-		},
-		{
-			name: "tegrastats available",
-			setupCommands: func() error {
-				path := filepath.Join(tempDir, "tegrastats")
-				script := `#!/bin/sh
-echo "test"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			wantNvidiaSmi:  false,
-			wantRocmSmi:    true,
-			wantTegrastats: true,
-			wantErr:        false,
-		},
-		{
-			name: "no gpu tools available",
-			setupCommands: func() error {
-				os.Setenv("PATH", "")
-				return nil
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := tt.setupCommands(); err != nil {
-				t.Fatal(err)
-			}
-
-			gm := &GPUManager{}
-			err := gm.detectGPUs()
-
-			t.Logf("nvidiaSmi: %v, rocmSmi: %v, tegrastats: %v", gm.nvidiaSmi, gm.rocmSmi, gm.tegrastats)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.Equal(t, tt.wantNvidiaSmi, gm.nvidiaSmi)
-			assert.Equal(t, tt.wantRocmSmi, gm.rocmSmi)
-			assert.Equal(t, tt.wantTegrastats, gm.tegrastats)
-		})
-	}
-}
-
-func TestStartCollector(t *testing.T) {
-	// Save original PATH
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	// Set up temp dir with the commands
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-
-	tests := []struct {
-		name     string
-		command  string
-		setup    func(t *testing.T) error
-		validate func(t *testing.T, gm *GPUManager)
-		gm       *GPUManager
-	}{
-		{
-			name:    "nvidia-smi collector",
-			command: "nvidia-smi",
-			setup: func(t *testing.T) error {
-				path := filepath.Join(dir, "nvidia-smi")
-				script := `#!/bin/sh
-echo "0, NVIDIA Test GPU, 50, 1024, 4096, 25, 100"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			validate: func(t *testing.T, gm *GPUManager) {
-				gpu, exists := gm.GpuDataMap["0"]
-				assert.True(t, exists)
-				if exists {
-					assert.Equal(t, "Test GPU", gpu.Name)
-					assert.Equal(t, 50.0, gpu.Temperature)
-
-				}
-			},
-		},
-		{
-			name:    "rocm-smi collector",
-			command: "rocm-smi",
-			setup: func(t *testing.T) error {
-				path := filepath.Join(dir, "rocm-smi")
-				script := `#!/bin/sh
-echo '{"card0": {"Temperature (Sensor edge) (C)": "49.0", "Current Socket Graphics Package Power (W)": "28.159", "GPU use (%)": "0", "VRAM Total Memory (B)": "536870912", "VRAM Total Used Memory (B)": "445550592", "Card Series": "Rembrandt [Radeon 680M]", "Card Model": "0x1681", "Card Vendor": "Advanced Micro Devices, Inc. [AMD/ATI]", "Card SKU": "REMBRANDT", "Subsystem ID": "0x8a22", "Device Rev": "0xc8", "Node ID": "1", "GUID": "34756", "GFX Version": "gfx1035"}}'`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			validate: func(t *testing.T, gm *GPUManager) {
-				gpu, exists := gm.GpuDataMap["34756"]
-				assert.True(t, exists)
-				if exists {
-					assert.Equal(t, "Rembrandt [Radeon 680M]", gpu.Name)
-					assert.InDelta(t, 49.0, gpu.Temperature, 0.01)
-					assert.InDelta(t, 28.159, gpu.Power, 0.01)
-				}
-			},
-		},
-		{
-			name:    "tegrastats collector",
-			command: "tegrastats",
-			setup: func(t *testing.T) error {
-				path := filepath.Join(dir, "tegrastats")
-				script := `#!/bin/sh
-echo "11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 80% tj@70C VDD_GPU_SOC 1000mW"`
-				if err := os.WriteFile(path, []byte(script), 0755); err != nil {
-					return err
-				}
-				return nil
-			},
-			validate: func(t *testing.T, gm *GPUManager) {
-				gpu, exists := gm.GpuDataMap["0"]
-				assert.True(t, exists)
-				if exists {
-					assert.InDelta(t, 70.0, gpu.Temperature, 0.1)
-				}
-			},
-			gm: &GPUManager{
-				GpuDataMap: map[string]*system.GPUData{
-					"0": {},
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := tt.setup(t); err != nil {
-				t.Fatal(err)
-			}
-			if tt.gm == nil {
-				tt.gm = &GPUManager{
-					GpuDataMap: make(map[string]*system.GPUData),
-				}
-			}
-			tt.gm.startCollector(tt.command)
-			time.Sleep(50 * time.Millisecond) // Give collector time to run
-			tt.validate(t, tt.gm)
-		})
-	}
-}
-
-// TestAccumulationTableDriven tests the accumulation behavior for all three GPU types
-func TestAccumulation(t *testing.T) {
-	type expectedGPUValues struct {
-		temperature float64
-		memoryUsed  float64
-		memoryTotal float64
-		usage       float64
-		power       float64
-		count       float64
-		avgUsage    float64
-		avgPower    float64
-	}
-
-	tests := []struct {
-		name           string
-		initialGPUData map[string]*system.GPUData
-		dataSamples    [][]byte
-		parser         func(*GPUManager) func([]byte) bool
-		expectedValues map[string]expectedGPUValues
-	}{
-		{
-			name: "Jetson GPU accumulation",
-			initialGPUData: map[string]*system.GPUData{
-				"0": {
-					Name:        "Jetson",
-					Temperature: 0,
-					Usage:       0,
-					Power:       0,
-					Count:       0,
-				},
-			},
-			dataSamples: [][]byte{
-				[]byte("11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 30% tj@50.5C VDD_GPU_SOC 1000mW"),
-				[]byte("11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 40% tj@60.5C VDD_GPU_SOC 1200mW"),
-				[]byte("11-14-2024 22:54:33 RAM 1024/4096MB GR3D_FREQ 50% tj@70.5C VDD_GPU_SOC 1400mW"),
-			},
-			parser: func(gm *GPUManager) func([]byte) bool {
-				return gm.getJetsonParser()
-			},
-			expectedValues: map[string]expectedGPUValues{
-				"0": {
-					temperature: 70.5,  // Last value
-					memoryUsed:  1024,  // Last value
-					memoryTotal: 4096,  // Last value
-					usage:       120.0, // Accumulated: 30 + 40 + 50
-					power:       3.6,   // Accumulated: 1.0 + 1.2 + 1.4
-					count:       3,
-					avgUsage:    40.0, // 120 / 3
-					avgPower:    1.2,  // 3.6 / 3
-				},
-			},
-		},
-		{
-			name:           "NVIDIA GPU accumulation",
-			initialGPUData: map[string]*system.GPUData{
-				// NVIDIA parser will create the GPU data entries
-			},
-			dataSamples: [][]byte{
-				[]byte("0, NVIDIA GeForce RTX 3080, 50, 5000, 10000, 30, 200"),
-				[]byte("0, NVIDIA GeForce RTX 3080, 60, 6000, 10000, 40, 250"),
-				[]byte("0, NVIDIA GeForce RTX 3080, 70, 7000, 10000, 50, 300"),
-			},
-			parser: func(gm *GPUManager) func([]byte) bool {
-				return gm.parseNvidiaData
-			},
-			expectedValues: map[string]expectedGPUValues{
-				"0": {
-					temperature: 70.0,            // Last value
-					memoryUsed:  7000.0 / 1.024,  // Last value
-					memoryTotal: 10000.0 / 1.024, // Last value
-					usage:       120.0,           // Accumulated: 30 + 40 + 50
-					power:       750.0,           // Accumulated: 200 + 250 + 300
-					count:       3,
-					avgUsage:    40.0,  // 120 / 3
-					avgPower:    250.0, // 750 / 3
-				},
-			},
-		},
-		{
-			name:           "AMD GPU accumulation",
-			initialGPUData: map[string]*system.GPUData{
-				// AMD parser will create the GPU data entries
-			},
-			dataSamples: [][]byte{
-				[]byte(`{"card0": {"GUID": "34756", "Temperature (Sensor edge) (C)": "50.0", "Current Socket Graphics Package Power (W)": "100.0", "GPU use (%)": "30", "VRAM Total Memory (B)": "10737418240", "VRAM Total Used Memory (B)": "1073741824", "Card Series": "Radeon RX 6800"}}`),
-				[]byte(`{"card0": {"GUID": "34756", "Temperature (Sensor edge) (C)": "60.0", "Current Socket Graphics Package Power (W)": "150.0", "GPU use (%)": "40", "VRAM Total Memory (B)": "10737418240", "VRAM Total Used Memory (B)": "2147483648", "Card Series": "Radeon RX 6800"}}`),
-				[]byte(`{"card0": {"GUID": "34756", "Temperature (Sensor edge) (C)": "70.0", "Current Socket Graphics Package Power (W)": "200.0", "GPU use (%)": "50", "VRAM Total Memory (B)": "10737418240", "VRAM Total Used Memory (B)": "3221225472", "Card Series": "Radeon RX 6800"}}`),
-			},
-			parser: func(gm *GPUManager) func([]byte) bool {
-				return gm.parseAmdData
-			},
-			expectedValues: map[string]expectedGPUValues{
-				"34756": {
-					temperature: 70.0,                          // Last value
-					memoryUsed:  3221225472.0 / (1024 * 1024),  // Last value
-					memoryTotal: 10737418240.0 / (1024 * 1024), // Last value
-					usage:       120.0,                         // Accumulated: 30 + 40 + 50
-					power:       450.0,                         // Accumulated: 100 + 150 + 200
-					count:       3,
-					avgUsage:    40.0,  // 120 / 3
-					avgPower:    150.0, // 450 / 3
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create a new GPUManager for each test
-			gm := &GPUManager{
-				GpuDataMap: tt.initialGPUData,
-			}
-
-			// Get the parser function
-			parser := tt.parser(gm)
-
-			// Process each data sample
-			for i, sample := range tt.dataSamples {
-				valid := parser(sample)
-				assert.True(t, valid, "Sample %d should be valid", i)
-			}
-
-			// Check accumulated values
-			for id, expected := range tt.expectedValues {
-				gpu, exists := gm.GpuDataMap[id]
-				assert.True(t, exists, "GPU with ID %s should exist", id)
-				if !exists {
-					continue
-				}
-
-				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature should match")
-				assert.InDelta(t, expected.memoryUsed, gpu.MemoryUsed, 0.01, "Memory used should match")
-				assert.InDelta(t, expected.memoryTotal, gpu.MemoryTotal, 0.01, "Memory total should match")
-				assert.InDelta(t, expected.usage, gpu.Usage, 0.01, "Usage should match")
-				assert.InDelta(t, expected.power, gpu.Power, 0.01, "Power should match")
-				assert.Equal(t, expected.count, gpu.Count, "Count should match")
-			}
-
-			// Verify average calculation in GetCurrentData
-			result := gm.GetCurrentData()
-			for id, expected := range tt.expectedValues {
-				gpu, exists := result[id]
-				assert.True(t, exists, "GPU with ID %s should exist in GetCurrentData result", id)
-				if !exists {
-					continue
-				}
-
-				assert.InDelta(t, expected.temperature, gpu.Temperature, 0.01, "Temperature in GetCurrentData should match")
-				assert.InDelta(t, expected.avgUsage, gpu.Usage, 0.01, "Average usage in GetCurrentData should match")
-				assert.InDelta(t, expected.avgPower, gpu.Power, 0.01, "Average power in GetCurrentData should match")
-			}
-
-			// Verify that accumulators in the original map are reset
-			for id := range tt.expectedValues {
-				gpu, exists := gm.GpuDataMap[id]
-				assert.True(t, exists, "GPU with ID %s should still exist after GetCurrentData", id)
-				if !exists {
-					continue
-				}
-				assert.Equal(t, float64(0), gpu.Count, "Count should be reset for GPU ID %s", id)
-				assert.Equal(t, float64(0), gpu.Usage, "Usage should be reset for GPU ID %s", id)
-				assert.Equal(t, float64(0), gpu.Power, "Power should be reset for GPU ID %s", id)
-			}
-		})
-	}
-}

beszel/internal/agent/network.go

@@ -1,67 +0,0 @@
-package agent
-
-import (
-	"log/slog"
-	"strings"
-	"time"
-
-	psutilNet "github.com/shirou/gopsutil/v4/net"
-)
-
-func (a *Agent) initializeNetIoStats() {
-	// reset valid network interfaces
-	a.netInterfaces = make(map[string]struct{}, 0)
-
-	// map of network interface names passed in via NICS env var
-	var nicsMap map[string]struct{}
-	nics, nicsEnvExists := GetEnv("NICS")
-	if nicsEnvExists {
-		nicsMap = make(map[string]struct{}, 0)
-		for nic := range strings.SplitSeq(nics, ",") {
-			nicsMap[nic] = struct{}{}
-		}
-	}
-
-	// reset network I/O stats
-	a.netIoStats.BytesSent = 0
-	a.netIoStats.BytesRecv = 0
-
-	// get intial network I/O stats
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		a.netIoStats.Time = time.Now()
-		for _, v := range netIO {
-			switch {
-			// skip if nics exists and the interface is not in the list
-			case nicsEnvExists:
-				if _, nameInNics := nicsMap[v.Name]; !nameInNics {
-					continue
-				}
-			// otherwise run the interface name through the skipNetworkInterface function
-			default:
-				if a.skipNetworkInterface(v) {
-					continue
-				}
-			}
-			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
-			a.netIoStats.BytesSent += v.BytesSent
-			a.netIoStats.BytesRecv += v.BytesRecv
-			// store as a valid network interface
-			a.netInterfaces[v.Name] = struct{}{}
-		}
-	}
-}
-
-func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
-	switch {
-	case strings.HasPrefix(v.Name, "lo"),
-		strings.HasPrefix(v.Name, "docker"),
-		strings.HasPrefix(v.Name, "br-"),
-		strings.HasPrefix(v.Name, "veth"),
-		strings.HasPrefix(v.Name, "bond"),
-		v.BytesRecv == 0,
-		v.BytesSent == 0:
-		return true
-	default:
-		return false
-	}
-}

beszel/internal/alerts/alerts_test.go

@@ -1,368 +0,0 @@
-//go:build testing
-// +build testing
-
-package alerts_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	beszelTests "beszel/internal/tests"
-
-	"github.com/pocketbase/dbx"
-	"github.com/pocketbase/pocketbase/core"
-	pbTests "github.com/pocketbase/pocketbase/tests"
-	"github.com/stretchr/testify/assert"
-)
-
-// marshal to json and return an io.Reader (for use in ApiScenario.Body)
-func jsonReader(v any) io.Reader {
-	data, err := json.Marshal(v)
-	if err != nil {
-		panic(err)
-	}
-	return bytes.NewReader(data)
-}
-
-func TestUserAlertsApi(t *testing.T) {
-	hub, _ := beszelTests.NewTestHub(t.TempDir())
-	defer hub.Cleanup()
-
-	hub.StartHub()
-
-	user1, _ := beszelTests.CreateUser(hub, "alertstest@example.com", "password")
-	user1Token, _ := user1.NewAuthToken()
-
-	user2, _ := beszelTests.CreateUser(hub, "alertstest2@example.com", "password")
-	user2Token, _ := user2.NewAuthToken()
-
-	system1, _ := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "system1",
-		"users": []string{user1.Id},
-		"host":  "127.0.0.1",
-	})
-
-	system2, _ := beszelTests.CreateRecord(hub, "systems", map[string]any{
-		"name":  "system2",
-		"users": []string{user1.Id, user2.Id},
-		"host":  "127.0.0.2",
-	})
-
-	userRecords, _ := hub.CountRecords("users")
-	assert.EqualValues(t, 2, userRecords, "all users should be created")
-
-	systemRecords, _ := hub.CountRecords("systems")
-	assert.EqualValues(t, 2, systemRecords, "all systems should be created")
-
-	testAppFactory := func(t testing.TB) *pbTests.TestApp {
-		return hub.TestApp
-	}
-
-	scenarios := []beszelTests.ApiScenario{
-		{
-			Name:            "GET not implemented - returns index",
-			Method:          http.MethodGet,
-			URL:             "/api/beszel/user-alerts",
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"<html ", "globalThis.BESZEL"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:            "POST no auth",
-			Method:          http.MethodPost,
-			URL:             "/api/beszel/user-alerts",
-			ExpectedStatus:  401,
-			ExpectedContent: []string{"requires valid"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "POST no body",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"Bad data"},
-			TestAppFactory:  testAppFactory,
-		},
-		{
-			Name:   "POST bad data",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"Bad data"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"invalidField": "this should cause validation error",
-				"threshold":    "not a number",
-			}),
-		},
-		{
-			Name:   "POST malformed JSON",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  400,
-			ExpectedContent: []string{"Bad data"},
-			TestAppFactory:  testAppFactory,
-			Body:            strings.NewReader(`{"alertType": "cpu", "threshold": 80, "enabled": true,}`),
-		},
-		{
-			Name:   "POST valid alert data multiple systems",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":      "CPU",
-				"value":     69,
-				"min":       9,
-				"systems":   []string{system1.Id, system2.Id},
-				"overwrite": false,
-			}),
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				// check total alerts
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
-				// check alert has correct values
-				matchingAlerts, _ := app.CountRecords("alerts", dbx.HashExp{"name": "CPU", "user": user1.Id, "system": system1.Id, "value": 69, "min": 9})
-				assert.EqualValues(t, 1, matchingAlerts, "should have 1 alert")
-			},
-		},
-		{
-			Name:   "POST valid alert data single system",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":    "Memory",
-				"systems": []string{system1.Id},
-				"value":   90,
-				"min":     10,
-			}),
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				user1Alerts, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
-				assert.EqualValues(t, 3, user1Alerts, "should have 3 alerts")
-			},
-		},
-		{
-			Name:   "Overwrite: false, should not overwrite existing alert",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":      "CPU",
-				"value":     45,
-				"min":       5,
-				"systems":   []string{system1.Id},
-				"overwrite": false,
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				beszelTests.CreateRecord(app, "alerts", map[string]any{
-					"name":   "CPU",
-					"system": system1.Id,
-					"user":   user1.Id,
-					"value":  80,
-					"min":    10,
-				})
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 1, alerts, "should have 1 alert")
-				alert, _ := app.FindFirstRecordByFilter("alerts", "name = 'CPU' && user = {:user}", dbx.Params{"user": user1.Id})
-				assert.EqualValues(t, 80, alert.Get("value"), "should have 80 as value")
-			},
-		},
-		{
-			Name:   "Overwrite: true, should overwrite existing alert",
-			Method: http.MethodPost,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user2Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":      "CPU",
-				"value":     45,
-				"min":       5,
-				"systems":   []string{system2.Id},
-				"overwrite": true,
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				beszelTests.CreateRecord(app, "alerts", map[string]any{
-					"name":   "CPU",
-					"system": system2.Id,
-					"user":   user2.Id,
-					"value":  80,
-					"min":    10,
-				})
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 1, alerts, "should have 1 alert")
-				alert, _ := app.FindFirstRecordByFilter("alerts", "name = 'CPU' && user = {:user}", dbx.Params{"user": user2.Id})
-				assert.EqualValues(t, 45, alert.Get("value"), "should have 45 as value")
-			},
-		},
-		{
-			Name:            "DELETE no auth",
-			Method:          http.MethodDelete,
-			URL:             "/api/beszel/user-alerts",
-			ExpectedStatus:  401,
-			ExpectedContent: []string{"requires valid"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":    "CPU",
-				"systems": []string{system1.Id},
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				beszelTests.CreateRecord(app, "alerts", map[string]any{
-					"name":   "CPU",
-					"system": system1.Id,
-					"user":   user1.Id,
-					"value":  80,
-					"min":    10,
-				})
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 1, alerts, "should have 1 alert")
-			},
-		},
-		{
-			Name:   "DELETE alert",
-			Method: http.MethodDelete,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"count\":1", "\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":    "CPU",
-				"systems": []string{system1.Id},
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				beszelTests.CreateRecord(app, "alerts", map[string]any{
-					"name":   "CPU",
-					"system": system1.Id,
-					"user":   user1.Id,
-					"value":  80,
-					"min":    10,
-				})
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				alerts, _ := app.CountRecords("alerts")
-				assert.Zero(t, alerts, "should have 0 alerts")
-			},
-		},
-		{
-			Name:   "DELETE alert multiple systems",
-			Method: http.MethodDelete,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user1Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"count\":2", "\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":    "Memory",
-				"systems": []string{system1.Id, system2.Id},
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				for _, systemId := range []string{system1.Id, system2.Id} {
-					_, err := beszelTests.CreateRecord(app, "alerts", map[string]any{
-						"name":   "Memory",
-						"system": systemId,
-						"user":   user1.Id,
-						"value":  90,
-						"min":    10,
-					})
-					assert.NoError(t, err, "should create alert")
-				}
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				alerts, _ := app.CountRecords("alerts")
-				assert.Zero(t, alerts, "should have 0 alerts")
-			},
-		},
-		{
-			Name:   "User 2 should not be able to delete alert of user 1",
-			Method: http.MethodDelete,
-			URL:    "/api/beszel/user-alerts",
-			Headers: map[string]string{
-				"Authorization": user2Token,
-			},
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"\"count\":1", "\"success\":true"},
-			TestAppFactory:  testAppFactory,
-			Body: jsonReader(map[string]any{
-				"name":    "CPU",
-				"systems": []string{system2.Id},
-			}),
-			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
-				beszelTests.ClearCollection(t, app, "alerts")
-				for _, user := range []string{user1.Id, user2.Id} {
-					beszelTests.CreateRecord(app, "alerts", map[string]any{
-						"name":   "CPU",
-						"system": system2.Id,
-						"user":   user,
-						"value":  80,
-						"min":    10,
-					})
-				}
-				alerts, _ := app.CountRecords("alerts")
-				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
-				user1AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
-				assert.EqualValues(t, 1, user1AlertCount, "should have 1 alert")
-				user2AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user2.Id})
-				assert.EqualValues(t, 1, user2AlertCount, "should have 1 alert")
-			},
-			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
-				user1AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
-				assert.EqualValues(t, 1, user1AlertCount, "should have 1 alert")
-				user2AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user2.Id})
-				assert.Zero(t, user2AlertCount, "should have 0 alerts")
-			},
-		},
-	}
-
-	for _, scenario := range scenarios {
-		scenario.Test(t)
-	}
-}

beszel/internal/common/common-ws.go

@@ -1,32 +0,0 @@
-package common
-
-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
-)
-
-// 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"`
-	// Error  AgentError      `cbor:"error,omitempty,omitzero"`
-}
-
-type FingerprintRequest struct {
-	Signature   []byte `cbor:"0,keyasint"`
-	NeedSysInfo bool   `cbor:"1,keyasint"` // For universal token system creation
-}
-
-type FingerprintResponse struct {
-	Fingerprint string `cbor:"0,keyasint"`
-	// Optional system info for universal token system creation
-	Hostname string `cbor:"1,keyasint,omitempty,omitzero"`
-	Port     string `cbor:"2,keyasint,omitempty,omitzero"`
-}

beszel/internal/records/records_test_helpers.go

@@ -1,23 +0,0 @@
-//go:build testing
-// +build testing
-
-package records
-
-import (
-	"github.com/pocketbase/pocketbase/core"
-)
-
-// TestDeleteOldSystemStats exposes deleteOldSystemStats for testing
-func TestDeleteOldSystemStats(app core.App) error {
-	return deleteOldSystemStats(app)
-}
-
-// TestDeleteOldAlertsHistory exposes deleteOldAlertsHistory for testing
-func TestDeleteOldAlertsHistory(app core.App, countToKeep, countBeforeDeletion int) error {
-	return deleteOldAlertsHistory(app, countToKeep, countBeforeDeletion)
-}
-
-// TestTwoDecimals exposes twoDecimals for testing
-func TestTwoDecimals(value float64) float64 {
-	return twoDecimals(value)
-}

beszel/migrations/initial-settings.go

@@ -1,29 +0,0 @@
-package migrations
-
-import (
-	"github.com/pocketbase/pocketbase/core"
-	m "github.com/pocketbase/pocketbase/migrations"
-)
-
-const (
-	TempAdminEmail = "_@b.b"
-)
-
-func init() {
-	m.Register(func(app core.App) error {
-		// initial settings
-		settings := app.Settings()
-		settings.Meta.AppName = "Beszel"
-		settings.Meta.HideControls = true
-		settings.Logs.MinLevel = 4
-		if err := app.Save(settings); err != nil {
-			return err
-		}
-		// create superuser
-		collection, _ := app.FindCollectionByNameOrId(core.CollectionNameSuperusers)
-		user := core.NewRecord(collection)
-		user.SetEmail(TempAdminEmail)
-		user.SetRandomPassword()
-		return app.Save(user)
-	}, nil)
-}

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

@@ -1 +0,0 @@
-<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>

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

@@ -1 +0,0 @@
-<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>

beszel/site/public/static/favicon.svg

@@ -1 +0,0 @@
-<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>

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

@@ -1,106 +0,0 @@
-import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
-
-import {
-	ChartContainer,
-	ChartLegend,
-	ChartLegendContent,
-	ChartTooltip,
-	ChartTooltipContent,
-	xAxis,
-} from "@/components/ui/chart"
-import { cn, formatShortDate, toFixedFloat, decimalString, chartMargin } from "@/lib/utils"
-import { ChartData } from "@/types"
-import { memo, useMemo } from "react"
-import { useYAxisWidth } from "./hooks"
-
-export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData }) {
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	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
-				className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
-					"opacity-100": yAxisWidth,
-				})}
-			>
-				<LineChart accessibilityLayer data={newChartData.data} margin={chartMargin}>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						direction="ltr"
-						orientation={chartData.orientation}
-						className="tracking-tighter"
-						domain={[0, "auto"]}
-						width={yAxisWidth}
-						tickFormatter={(value) => {
-							const val = toFixedFloat(value, 2)
-							return updateYAxisWidth(val + "W")
-						}}
-						tickLine={false}
-						axisLine={false}
-					/>
-					{xAxis(chartData)}
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						// @ts-ignore
-						itemSorter={(a, b) => b.value - a.value}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => decimalString(item.value) + "W"}
-								// indicator="line"
-							/>
-						}
-					/>
-					{colors.map((key) => (
-						<Line
-							key={key}
-							dataKey={key}
-							name={key}
-							type="monotoneX"
-							dot={false}
-							strokeWidth={1.5}
-							stroke={newChartData.colors[key]}
-							isAnimationActive={false}
-						/>
-					))}
-					{colors.length > 1 && <ChartLegend content={<ChartLegendContent />} />}
-				</LineChart>
-			</ChartContainer>
-		</div>
-	)
-})

beszel/site/src/components/logo.tsx

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

beszel/site/src/components/ui/toaster.tsx

@@ -1,24 +0,0 @@
-import { Toast, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport } from "@/components/ui/toast"
-import { useToast } from "@/components/ui/use-toast"
-
-export function Toaster() {
-	const { toasts } = useToast()
-
-	return (
-		<ToastProvider>
-			{toasts.map(function ({ id, title, description, action, ...props }) {
-				return (
-					<Toast key={id} {...props}>
-						<div className="grid gap-1">
-							{title && <ToastTitle>{title}</ToastTitle>}
-							{description && <ToastDescription>{description}</ToastDescription>}
-						</div>
-						{action}
-						<ToastClose />
-					</Toast>
-				)
-			})}
-			<ToastViewport />
-		</ToastProvider>
-	)
-}

beszel/version.go

@@ -1,10 +0,0 @@
-package beszel
-
-import "github.com/blang/semver"
-
-const (
-	Version = "0.12.6"
-	AppName = "beszel"
-)
-
-var MinVersionCbor = semver.MustParse("0.12.0")

go.mod

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

go.sum

@@ -1,5 +1,7 @@
 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=
@@ -21,22 +23,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.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
-github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitengine/purego v0.9.0 h1:mh0zpKBIXDceC63hpvPuGLiJ8ZAa3DfrFTudmfi8A4k=
+github.com/ebitengine/purego v0.9.0/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.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
-github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
+github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
 github.com/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.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-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=
@@ -52,14 +54,14 @@ github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArs
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
+github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 h1:EEHtgt9IwisQ2AZ4pIsMjahcegHh6rmhqxzIRQIyepY=
+github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
 github.com/google/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.0 h1:BvhqnH0JAYbNudL2GMJKgOHe2CtKlzJ/5rWKyp+hc2k=
-github.com/jarcoal/httpmock v1.4.0/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
+github.com/jarcoal/httpmock v1.4.1 h1:0Ju+VCFuARfFlhVXFc2HxlcQkfB+Xq12/EotHko+x2A=
+github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
@@ -67,8 +69,8 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d h1:vFzYZc8yji+9DmNRhpEbs8VBK4CgV/DPfGzeVJSSp/8=
-github.com/lufia/plan9stats v0.0.0-20250821153705-5981dea3221d/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
+github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 h1:mFWunSatvkQQDhpdyuFAYwyAan3hzCuma+Pz8sqvOfg=
+github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/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=
@@ -77,19 +79,19 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.8.8 h1:F/oyoatWK5cbHPPgkjRZrA0262TP7KWuUQz9KskRtR8=
-github.com/nicholas-fedor/shoutrrr v0.8.8/go.mod h1:T30Y+eoZFEjDk4HtOItcHQioZSOe3Z6a6aNfSz6jc5c=
-github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus=
-github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8=
-github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
-github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0=
+github.com/nicholas-fedor/shoutrrr v0.9.1 h1:SEBhM6P1favzILO0f55CY3P9JwvM9RZ7B1ZMCl+Injs=
+github.com/nicholas-fedor/shoutrrr v0.9.1/go.mod h1:khue5m8LYyMzdPWuJxDTJeT89l9gjwjA+a+r0e8qxxk=
+github.com/onsi/ginkgo/v2 v2.25.3 h1:Ty8+Yi/ayDAGtk4XxmmfUy4GabvM+MegeB4cDLRi6nw=
+github.com/onsi/ginkgo/v2 v2.25.3/go.mod h1:43uiyQC4Ed2tkOzLsEYm7hnrb7UJTWHYNsuy3bG/snE=
+github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
+github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
 github.com/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.29.3 h1:Mj8o5awsbVJIdIoTuQNhfC2oL/c4aImQ3RyfFZlzFVg=
-github.com/pocketbase/pocketbase v0.29.3/go.mod h1:oGpT67LObxCFK4V2fSL7J9YnPbBnnshOpJ5v3zcneww=
+github.com/pocketbase/pocketbase v0.30.1 h1:8lgfhH+HiSw1PyKVMq2sjtC4ZNvda2f/envTAzWMLOA=
+github.com/pocketbase/pocketbase v0.30.1/go.mod h1:sUI+uekXZam5Wa0eh+DClc+HieKMCeqsHA7Ydd9vwyE=
 github.com/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=
@@ -97,19 +99,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.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
-github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
-github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
-github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
-github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
-github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
-github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/shirou/gopsutil/v4 v4.25.9 h1:JImNpf6gCVhKgZhtaAHJ0serfFGtlfIlSC08eaKdTrU=
+github.com/shirou/gopsutil/v4 v4.25.9/go.mod h1:gxIxoC+7nQRwUl/xNhutXlD8lq+jxTgpIkEf3rADHL8=
+github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
+github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/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.0 h1:ib4sjIrwZKxE5u/Japgo/7SJV3PvgjGiRNAvTVGqQl8=
-github.com/stretchr/testify v1.11.0/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/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=
@@ -120,42 +122,44 @@ 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.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b h1:DXr+pvt3nC887026GRP39Ej11UATqWDmWuS99x26cD0=
-golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9 h1:TQwNpfvNkxAVlItJf6Cr5JTsVZoC/Sj7K3OZv2Pc14A=
+golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.30.0 h1:jD5RhkmVAnjqaCUXfbGBrn3lpxbknfN9w2UhHHU+5B4=
-golang.org/x/image v0.30.0/go.mod h1:SAEUTxCCMWSrJcCy/4HwavEsfZZJlYxeHLc6tTiAe/c=
-golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
-golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
+golang.org/x/image v0.31.0 h1:mLChjE2MV6g1S7oqbXC0/UcKijjm5fnJLUYKIYrLESA=
+golang.org/x/image v0.31.0/go.mod h1:R9ec5Lcp96v9FTF+ajwaH3uGxPH4fKfHHAVbUILxghA=
+golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
+golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
-golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
+golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo=
+golang.org/x/oauth2 v0.31.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/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.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
-golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
+golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
 golang.org/x/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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
-golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
+golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
+golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -185,8 +189,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.38.2 h1:Aclu7+tgjgcQVShZqim41Bbw9Cho0y/7WzYptXqkEek=
-modernc.org/sqlite v1.38.2/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
+modernc.org/sqlite v1.39.0 h1:6bwu9Ooim0yVYA7IZn9demiQk/Ejp0BtTjBWFLymSeY=
+modernc.org/sqlite v1.39.0/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=

i18n.yml

@@ -1,3 +1,3 @@
 files:
-  - source: /beszel/site/src/locales/en/en.po
-    translation: /beszel/site/src/locales/%two_letters_code%/%two_letters_code%.po
+  - source: /internal/site/src/locales/en/
+    translation: /internal/site/src/locales/%two_letters_code%/%two_letters_code%.po

internal/alerts/alerts.go

@@ -87,7 +87,7 @@ var supportsTitle = map[string]struct{}{
 func NewAlertManager(app hubLike) *AlertManager {
 	am := &AlertManager{
 		hub:        app,
-		alertQueue: make(chan alertTask),
+		alertQueue: make(chan alertTask, 5),
 		stopChan:   make(chan struct{}),
 	}
 	am.bindEvents()

internal/alerts/alerts_history.go

@@ -42,21 +42,10 @@ func updateHistoryOnAlertUpdate(e *core.RecordEvent) error {
 
 // resolveAlertHistoryRecord sets the resolved field to the current time
 func resolveAlertHistoryRecord(app core.App, alertRecordID string) error {
-	alertHistoryRecords, err := app.FindRecordsByFilter(
-		"alerts_history",
-		"alert_id={:alert_id} && resolved=null",
-		"-created",
-		1,
-		0,
-		dbx.Params{"alert_id": alertRecordID},
-	)
-	if err != nil {
+	alertHistoryRecord, err := app.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id} && resolved=null", dbx.Params{"alert_id": alertRecordID})
+	if err != nil || alertHistoryRecord == nil {
 		return err
 	}
-	if len(alertHistoryRecords) == 0 {
-		return nil
-	}
-	alertHistoryRecord := alertHistoryRecords[0] // there should be only one record
 	alertHistoryRecord.Set("resolved", time.Now().UTC())
 	err = app.Save(alertHistoryRecord)
 	if err != nil {

internal/alerts/alerts_status.go

@@ -25,7 +25,12 @@ 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() {
-	tick := time.Tick(15 * time.Second)
+	processPendingAlerts := 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:
@@ -41,7 +46,9 @@ func (am *AlertManager) startWorker() {
 			case "cancel":
 				am.pendingAlerts.Delete(task.alertRecord.Id)
 			}
-		case <-tick:
+		case <-checkStatusAlerts:
+			resolveStatusAlerts(am.hub)
+		case <-processPendingAlerts:
 			// Check for expired alerts every tick
 			now := time.Now()
 			for key, value := range am.pendingAlerts.Range {
@@ -170,3 +177,35 @@ 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

@@ -1,12 +1,13 @@
 package alerts
 
 import (
-	"beszel/internal/entities/system"
 	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
 
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/types"

internal/alerts/alerts_test.go

@@ -0,0 +1,680 @@
+//go:build testing
+// +build testing
+
+package alerts_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"testing/synctest"
+	"time"
+
+	"github.com/henrygd/beszel/internal/alerts"
+	beszelTests "github.com/henrygd/beszel/internal/tests"
+
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+	pbTests "github.com/pocketbase/pocketbase/tests"
+	"github.com/stretchr/testify/assert"
+)
+
+// marshal to json and return an io.Reader (for use in ApiScenario.Body)
+func jsonReader(v any) io.Reader {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewReader(data)
+}
+
+func TestUserAlertsApi(t *testing.T) {
+	hub, _ := beszelTests.NewTestHub(t.TempDir())
+	defer hub.Cleanup()
+
+	hub.StartHub()
+
+	user1, _ := beszelTests.CreateUser(hub, "alertstest@example.com", "password")
+	user1Token, _ := user1.NewAuthToken()
+
+	user2, _ := beszelTests.CreateUser(hub, "alertstest2@example.com", "password")
+	user2Token, _ := user2.NewAuthToken()
+
+	system1, _ := beszelTests.CreateRecord(hub, "systems", map[string]any{
+		"name":  "system1",
+		"users": []string{user1.Id},
+		"host":  "127.0.0.1",
+	})
+
+	system2, _ := beszelTests.CreateRecord(hub, "systems", map[string]any{
+		"name":  "system2",
+		"users": []string{user1.Id, user2.Id},
+		"host":  "127.0.0.2",
+	})
+
+	userRecords, _ := hub.CountRecords("users")
+	assert.EqualValues(t, 2, userRecords, "all users should be created")
+
+	systemRecords, _ := hub.CountRecords("systems")
+	assert.EqualValues(t, 2, systemRecords, "all systems should be created")
+
+	testAppFactory := func(t testing.TB) *pbTests.TestApp {
+		return hub.TestApp
+	}
+
+	scenarios := []beszelTests.ApiScenario{
+		// {
+		// 	Name:            "GET not implemented - returns index",
+		// 	Method:          http.MethodGet,
+		// 	URL:             "/api/beszel/user-alerts",
+		// 	ExpectedStatus:  200,
+		// 	ExpectedContent: []string{"<html ", "globalThis.BESZEL"},
+		// 	TestAppFactory:  testAppFactory,
+		// },
+		{
+			Name:            "POST no auth",
+			Method:          http.MethodPost,
+			URL:             "/api/beszel/user-alerts",
+			ExpectedStatus:  401,
+			ExpectedContent: []string{"requires valid"},
+			TestAppFactory:  testAppFactory,
+		},
+		{
+			Name:   "POST no body",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{"Bad data"},
+			TestAppFactory:  testAppFactory,
+		},
+		{
+			Name:   "POST bad data",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{"Bad data"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"invalidField": "this should cause validation error",
+				"threshold":    "not a number",
+			}),
+		},
+		{
+			Name:   "POST malformed JSON",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  400,
+			ExpectedContent: []string{"Bad data"},
+			TestAppFactory:  testAppFactory,
+			Body:            strings.NewReader(`{"alertType": "cpu", "threshold": 80, "enabled": true,}`),
+		},
+		{
+			Name:   "POST valid alert data multiple systems",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":      "CPU",
+				"value":     69,
+				"min":       9,
+				"systems":   []string{system1.Id, system2.Id},
+				"overwrite": false,
+			}),
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				// check total alerts
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
+				// check alert has correct values
+				matchingAlerts, _ := app.CountRecords("alerts", dbx.HashExp{"name": "CPU", "user": user1.Id, "system": system1.Id, "value": 69, "min": 9})
+				assert.EqualValues(t, 1, matchingAlerts, "should have 1 alert")
+			},
+		},
+		{
+			Name:   "POST valid alert data single system",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":    "Memory",
+				"systems": []string{system1.Id},
+				"value":   90,
+				"min":     10,
+			}),
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				user1Alerts, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
+				assert.EqualValues(t, 3, user1Alerts, "should have 3 alerts")
+			},
+		},
+		{
+			Name:   "Overwrite: false, should not overwrite existing alert",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":      "CPU",
+				"value":     45,
+				"min":       5,
+				"systems":   []string{system1.Id},
+				"overwrite": false,
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				beszelTests.CreateRecord(app, "alerts", map[string]any{
+					"name":   "CPU",
+					"system": system1.Id,
+					"user":   user1.Id,
+					"value":  80,
+					"min":    10,
+				})
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 1, alerts, "should have 1 alert")
+				alert, _ := app.FindFirstRecordByFilter("alerts", "name = 'CPU' && user = {:user}", dbx.Params{"user": user1.Id})
+				assert.EqualValues(t, 80, alert.Get("value"), "should have 80 as value")
+			},
+		},
+		{
+			Name:   "Overwrite: true, should overwrite existing alert",
+			Method: http.MethodPost,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user2Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":      "CPU",
+				"value":     45,
+				"min":       5,
+				"systems":   []string{system2.Id},
+				"overwrite": true,
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				beszelTests.CreateRecord(app, "alerts", map[string]any{
+					"name":   "CPU",
+					"system": system2.Id,
+					"user":   user2.Id,
+					"value":  80,
+					"min":    10,
+				})
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 1, alerts, "should have 1 alert")
+				alert, _ := app.FindFirstRecordByFilter("alerts", "name = 'CPU' && user = {:user}", dbx.Params{"user": user2.Id})
+				assert.EqualValues(t, 45, alert.Get("value"), "should have 45 as value")
+			},
+		},
+		{
+			Name:            "DELETE no auth",
+			Method:          http.MethodDelete,
+			URL:             "/api/beszel/user-alerts",
+			ExpectedStatus:  401,
+			ExpectedContent: []string{"requires valid"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":    "CPU",
+				"systems": []string{system1.Id},
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				beszelTests.CreateRecord(app, "alerts", map[string]any{
+					"name":   "CPU",
+					"system": system1.Id,
+					"user":   user1.Id,
+					"value":  80,
+					"min":    10,
+				})
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 1, alerts, "should have 1 alert")
+			},
+		},
+		{
+			Name:   "DELETE alert",
+			Method: http.MethodDelete,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"count\":1", "\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":    "CPU",
+				"systems": []string{system1.Id},
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				beszelTests.CreateRecord(app, "alerts", map[string]any{
+					"name":   "CPU",
+					"system": system1.Id,
+					"user":   user1.Id,
+					"value":  80,
+					"min":    10,
+				})
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				alerts, _ := app.CountRecords("alerts")
+				assert.Zero(t, alerts, "should have 0 alerts")
+			},
+		},
+		{
+			Name:   "DELETE alert multiple systems",
+			Method: http.MethodDelete,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user1Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"count\":2", "\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":    "Memory",
+				"systems": []string{system1.Id, system2.Id},
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				for _, systemId := range []string{system1.Id, system2.Id} {
+					_, err := beszelTests.CreateRecord(app, "alerts", map[string]any{
+						"name":   "Memory",
+						"system": systemId,
+						"user":   user1.Id,
+						"value":  90,
+						"min":    10,
+					})
+					assert.NoError(t, err, "should create alert")
+				}
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				alerts, _ := app.CountRecords("alerts")
+				assert.Zero(t, alerts, "should have 0 alerts")
+			},
+		},
+		{
+			Name:   "User 2 should not be able to delete alert of user 1",
+			Method: http.MethodDelete,
+			URL:    "/api/beszel/user-alerts",
+			Headers: map[string]string{
+				"Authorization": user2Token,
+			},
+			ExpectedStatus:  200,
+			ExpectedContent: []string{"\"count\":1", "\"success\":true"},
+			TestAppFactory:  testAppFactory,
+			Body: jsonReader(map[string]any{
+				"name":    "CPU",
+				"systems": []string{system2.Id},
+			}),
+			BeforeTestFunc: func(t testing.TB, app *pbTests.TestApp, e *core.ServeEvent) {
+				beszelTests.ClearCollection(t, app, "alerts")
+				for _, user := range []string{user1.Id, user2.Id} {
+					beszelTests.CreateRecord(app, "alerts", map[string]any{
+						"name":   "CPU",
+						"system": system2.Id,
+						"user":   user,
+						"value":  80,
+						"min":    10,
+					})
+				}
+				alerts, _ := app.CountRecords("alerts")
+				assert.EqualValues(t, 2, alerts, "should have 2 alerts")
+				user1AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
+				assert.EqualValues(t, 1, user1AlertCount, "should have 1 alert")
+				user2AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user2.Id})
+				assert.EqualValues(t, 1, user2AlertCount, "should have 1 alert")
+			},
+			AfterTestFunc: func(t testing.TB, app *pbTests.TestApp, res *http.Response) {
+				user1AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user1.Id})
+				assert.EqualValues(t, 1, user1AlertCount, "should have 1 alert")
+				user2AlertCount, _ := app.CountRecords("alerts", dbx.HashExp{"user": user2.Id})
+				assert.Zero(t, user2AlertCount, "should have 0 alerts")
+			},
+		},
+	}
+
+	for _, scenario := range scenarios {
+		scenario.Test(t)
+	}
+}
+
+func TestStatusAlerts(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		hub, user := beszelTests.GetHubWithUser(t)
+		defer hub.Cleanup()
+
+		systems, err := beszelTests.CreateSystems(hub, 4, user.Id, "paused")
+		assert.NoError(t, err)
+
+		var alerts []*core.Record
+		for i, system := range systems {
+			alert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+				"name":   "Status",
+				"system": system.Id,
+				"user":   user.Id,
+				"min":    i + 1,
+			})
+			assert.NoError(t, err)
+			alerts = append(alerts, alert)
+		}
+
+		time.Sleep(10 * time.Millisecond)
+
+		for _, alert := range alerts {
+			assert.False(t, alert.GetBool("triggered"), "Alert should not be triggered immediately")
+		}
+		if hub.TestMailer.TotalSend() != 0 {
+			assert.Zero(t, hub.TestMailer.TotalSend(), "Expected 0 messages, got %d", hub.TestMailer.TotalSend())
+		}
+		for _, system := range systems {
+			assert.EqualValues(t, "paused", system.GetString("status"), "System should be paused")
+		}
+		for _, system := range systems {
+			system.Set("status", "up")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		time.Sleep(time.Second)
+		assert.EqualValues(t, 0, hub.GetPendingAlertsCount(), "should have 0 alerts in the pendingAlerts map")
+		for _, system := range systems {
+			system.Set("status", "down")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		// after 30 seconds, should have 4 alerts in the pendingAlerts map, no triggered alerts
+		time.Sleep(time.Second * 30)
+		assert.EqualValues(t, 4, hub.GetPendingAlertsCount(), "should have 4 alerts in the pendingAlerts map")
+		triggeredCount, err := hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 0, triggeredCount, "should have 0 alert triggered")
+		assert.EqualValues(t, 0, hub.TestMailer.TotalSend(), "should have 0 messages sent")
+		// after 1:30 seconds, should have 1 triggered alert and 3 pending alerts
+		time.Sleep(time.Second * 60)
+		assert.EqualValues(t, 3, hub.GetPendingAlertsCount(), "should have 3 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "should have 1 alert triggered")
+		assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 messages sent")
+		// after 2:30 seconds, should have 2 triggered alerts and 2 pending alerts
+		time.Sleep(time.Second * 60)
+		assert.EqualValues(t, 2, hub.GetPendingAlertsCount(), "should have 2 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 2, triggeredCount, "should have 2 alert triggered")
+		assert.EqualValues(t, 2, hub.TestMailer.TotalSend(), "should have 2 messages sent")
+		// now we will bring the remaning systems back up
+		for _, system := range systems {
+			system.Set("status", "up")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		time.Sleep(time.Second)
+		// should have 0 alerts in the pendingAlerts map and 0 alerts triggered
+		assert.EqualValues(t, 0, hub.GetPendingAlertsCount(), "should have 0 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.Zero(t, triggeredCount, "should have 0 alert triggered")
+		// 4 messages sent, 2 down alerts and 2 up alerts for first 2 systems
+		assert.EqualValues(t, 4, hub.TestMailer.TotalSend(), "should have 4 messages sent")
+	})
+}
+
+func TestAlertsHistory(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		hub, user := beszelTests.GetHubWithUser(t)
+		defer hub.Cleanup()
+
+		// Create systems and alerts
+		systems, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
+		assert.NoError(t, err)
+		system := systems[0]
+
+		alert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+			"name":   "Status",
+			"system": system.Id,
+			"user":   user.Id,
+			"min":    1,
+		})
+		assert.NoError(t, err)
+
+		// Initially, no alert history records should exist
+		initialHistoryCount, err := hub.CountRecords("alerts_history", nil)
+		assert.NoError(t, err)
+		assert.Zero(t, initialHistoryCount, "Should have 0 alert history records initially")
+
+		// Set system to up initially
+		system.Set("status", "up")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+		time.Sleep(10 * time.Millisecond)
+
+		// Set system to down to trigger alert
+		system.Set("status", "down")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+
+		// Wait for alert to trigger (after the downtime delay)
+		// With 1 minute delay, we need to wait at least 1 minute + some buffer
+		time.Sleep(time.Second * 75)
+
+		// Check that alert is triggered
+		triggeredCount, err := hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "Alert should be triggered")
+
+		// Check that alert history record was created
+		historyCount, err := hub.CountRecords("alerts_history", dbx.HashExp{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, historyCount, "Should have 1 alert history record for triggered alert")
+
+		// Get the alert history record and verify it's not resolved immediately
+		historyRecord, err := hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord, "Alert history record should exist")
+		assert.Equal(t, alert.Id, historyRecord.GetString("alert_id"), "Alert history should reference correct alert")
+		assert.Equal(t, system.Id, historyRecord.GetString("system"), "Alert history should reference correct system")
+		assert.Equal(t, "Status", historyRecord.GetString("name"), "Alert history should have correct name")
+
+		// The alert history might be resolved immediately in some cases, so let's check the alert's triggered status
+		alertRecord, err := hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alert.Id})
+		assert.NoError(t, err)
+		assert.True(t, alertRecord.GetBool("triggered"), "Alert should still be triggered when checking history")
+
+		// Now resolve the alert by setting system back to up
+		system.Set("status", "up")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+		time.Sleep(200 * time.Millisecond)
+
+		// Check that alert is no longer triggered
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert.Id})
+		assert.NoError(t, err)
+		assert.Zero(t, triggeredCount, "Alert should not be triggered after system is back up")
+
+		// Check that alert history record is now resolved
+		historyRecord, err = hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord, "Alert history record should still exist")
+		assert.NotNil(t, historyRecord.Get("resolved"), "Alert history should be resolved")
+
+		// Test deleting a triggered alert resolves its history
+		// Create another system and alert
+		systems2, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
+		assert.NoError(t, err)
+		system2 := systems2[0]
+		system2.Set("name", "test-system-2") // Rename for clarity
+		err = hub.SaveNoValidate(system2)
+		assert.NoError(t, err)
+
+		alert2, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+			"name":   "Status",
+			"system": system2.Id,
+			"user":   user.Id,
+			"min":    1,
+		})
+		assert.NoError(t, err)
+
+		// Set system2 to down to trigger alert
+		system2.Set("status", "down")
+		err = hub.SaveNoValidate(system2)
+		assert.NoError(t, err)
+
+		// Wait for alert to trigger
+		time.Sleep(time.Second * 75)
+
+		// Verify alert is triggered and history record exists
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert2.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "Second alert should be triggered")
+
+		historyCount, err = hub.CountRecords("alerts_history", dbx.HashExp{"alert_id": alert2.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, historyCount, "Should have 1 alert history record for second alert")
+
+		// Delete the triggered alert
+		err = hub.Delete(alert2)
+		assert.NoError(t, err)
+
+		// Check that alert history record is resolved after deletion
+		historyRecord2, err := hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert2.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord2, "Alert history record should still exist after alert deletion")
+		assert.NotNil(t, historyRecord2.Get("resolved"), "Alert history should be resolved after alert deletion")
+
+		// Verify total history count is correct (2 records total)
+		totalHistoryCount, err := hub.CountRecords("alerts_history", nil)
+		assert.NoError(t, err)
+		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

@@ -0,0 +1,62 @@
+//go:build testing
+// +build testing
+
+package alerts
+
+import (
+	"sync"
+	"time"
+
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func (am *AlertManager) GetAlertManager() *AlertManager {
+	return am
+}
+
+func (am *AlertManager) GetPendingAlerts() *sync.Map {
+	return &am.pendingAlerts
+}
+
+func (am *AlertManager) GetPendingAlertsCount() int {
+	count := 0
+	am.pendingAlerts.Range(func(key, value any) bool {
+		count++
+		return true
+	})
+	return count
+}
+
+// ProcessPendingAlerts manually processes all expired alerts (for testing)
+func (am *AlertManager) ProcessPendingAlerts() ([]*core.Record, error) {
+	now := time.Now()
+	var lastErr error
+	var processedAlerts []*core.Record
+	am.pendingAlerts.Range(func(key, value any) bool {
+		info := value.(*alertInfo)
+		if now.After(info.expireTime) {
+			// Downtime delay has passed, process alert
+			if err := am.sendStatusAlert("down", info.systemName, info.alertRecord); err != nil {
+				lastErr = err
+			}
+			processedAlerts = append(processedAlerts, info.alertRecord)
+			am.pendingAlerts.Delete(key)
+		}
+		return true
+	})
+	return processedAlerts, lastErr
+}
+
+// ForceExpirePendingAlerts sets all pending alerts to expire immediately (for testing)
+func (am *AlertManager) ForceExpirePendingAlerts() {
+	now := time.Now()
+	am.pendingAlerts.Range(func(key, value any) bool {
+		info := value.(*alertInfo)
+		info.expireTime = now.Add(-time.Second) // Set to 1 second ago
+		return true
+	})
+}
+
+func ResolveStatusAlerts(app core.App) error {
+	return resolveStatusAlerts(app)
+}

internal/cmd/agent/agent.go

@@ -1,14 +1,14 @@
 package main
 
 import (
-	"beszel"
-	"beszel/internal/agent"
-	"beszel/internal/agent/health"
 	"fmt"
 	"log"
 	"os"
 	"strings"
 
+	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/agent"
+	"github.com/henrygd/beszel/agent/health"
 	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh"
 )

internal/cmd/agent/agent_test.go

@@ -1,12 +1,13 @@
 package main
 
 import (
-	"beszel/internal/agent"
 	"crypto/ed25519"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/henrygd/beszel/agent"
+
 	"github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

internal/cmd/hub/hub.go

@@ -1,15 +1,16 @@
 package main
 
 import (
-	"beszel"
-	"beszel/internal/hub"
-	_ "beszel/migrations"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"time"
 
+	"github.com/henrygd/beszel"
+	"github.com/henrygd/beszel/internal/hub"
+	_ "github.com/henrygd/beszel/internal/migrations"
+
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/plugins/migratecmd"
 	"github.com/spf13/cobra"

internal/common/common-ws.go

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

internal/dockerfile_agent

@@ -2,15 +2,15 @@ FROM --platform=$BUILDPLATFORM golang:alpine AS builder
 
 WORKDIR /app
 
-COPY go.mod go.sum ./
-# RUN go mod download
-COPY *.go ./
-COPY cmd ./cmd
-COPY internal ./internal
+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 ./cmd/agent
+RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /agent ./internal/cmd/agent
 
 RUN rm -rf /tmp/*
 
@@ -23,4 +23,7 @@ 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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,32 @@
+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: GPU-enabled agent with nvidia-smi
+# --------------------------
+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

@@ -3,16 +3,11 @@ FROM --platform=$BUILDPLATFORM golang:alpine AS builder
 WORKDIR /app
 
 # Download Go modules
-COPY go.mod go.sum ./
+COPY ../go.mod ../go.sum ./
 RUN go mod download
 
 # Copy source files
-COPY *.go ./
-COPY cmd ./cmd
-COPY internal ./internal
-COPY migrations ./migrations
-COPY site/dist ./site/dist
-COPY site/*.go ./site
+COPY . ./
 
 RUN apk add --no-cache \
     unzip \
@@ -22,7 +17,7 @@ RUN update-ca-certificates
 
 # Build
 ARG TARGETOS TARGETARCH
-RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /beszel ./cmd/hub
+RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /beszel ./internal/cmd/hub
 
 # ? -------------------------
 FROM scratch
@@ -30,6 +25,9 @@ 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,7 +8,8 @@ type ApiInfo struct {
 	IdShort string
 	Names   []string
 	Status  string
-	// Image   string
+	State   string
+	Image   string
 	// ImageID string
 	// Command string
 	// Created int64
@@ -16,7 +17,6 @@ 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,6 +103,22 @@ 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"`
@@ -110,6 +126,11 @@ 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

@@ -0,0 +1,362 @@
+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

@@ -3,8 +3,9 @@ package system
 // TODO: this is confusing, make common package with common/types common/helpers etc
 
 import (
-	"beszel/internal/entities/container"
 	"time"
+
+	"github.com/henrygd/beszel/internal/entities/container"
 )
 
 type Stats struct {
@@ -37,25 +38,31 @@ type Stats struct {
 	Bandwidth      [2]uint64           `json:"b,omitzero" cbor:"26,keyasint,omitzero"`  // [sent bytes, recv bytes]
 	MaxBandwidth   [2]uint64           `json:"bm,omitzero" cbor:"27,keyasint,omitzero"` // [sent bytes, recv bytes]
 	// TODO: remove other load fields in future release in favor of load avg array
-	LoadAvg [3]float64 `json:"la,omitempty" cbor:"28,keyasint"`
-	Battery [2]uint8   `json:"bat,omitzero" cbor:"29,keyasint,omitzero"` // [percent, charge state, current]
-	MaxMem  float64    `json:"mm,omitempty" cbor:"30,keyasint,omitempty"`
+	LoadAvg           [3]float64           `json:"la,omitempty" cbor:"28,keyasint"`
+	Battery           [2]uint8             `json:"bat,omitzero" cbor:"29,keyasint,omitzero"` // [percent, charge state, current]
+	MaxMem            float64              `json:"mm,omitempty" cbor:"30,keyasint,omitempty"`
+	NetworkInterfaces map[string][4]uint64 `json:"ni,omitempty" cbor:"31,keyasint,omitempty"` // [upload bytes, download bytes, total upload, total download]
+	DiskIO            [2]uint64            `json:"dio,omitzero" cbor:"32,keyasint,omitzero"`  // [read bytes, write bytes]
+	MaxDiskIO         [2]uint64            `json:"diom,omitzero" cbor:"-"`                    // [max read bytes, max write bytes]
 }
 
 type GPUData struct {
-	Name        string  `json:"n" cbor:"0,keyasint"`
-	Temperature float64 `json:"-"`
-	MemoryUsed  float64 `json:"mu,omitempty" cbor:"1,keyasint,omitempty"`
-	MemoryTotal float64 `json:"mt,omitempty" cbor:"2,keyasint,omitempty"`
-	Usage       float64 `json:"u" cbor:"3,keyasint"`
-	Power       float64 `json:"p,omitempty" cbor:"4,keyasint,omitempty"`
-	Count       float64 `json:"-"`
+	Name        string             `json:"n" cbor:"0,keyasint"`
+	Temperature float64            `json:"-"`
+	MemoryUsed  float64            `json:"mu,omitempty,omitzero" cbor:"1,keyasint,omitempty,omitzero"`
+	MemoryTotal float64            `json:"mt,omitempty,omitzero" cbor:"2,keyasint,omitempty,omitzero"`
+	Usage       float64            `json:"u" cbor:"3,keyasint,omitempty"`
+	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:"-"`
@@ -64,6 +71,11 @@ 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 {
@@ -82,6 +94,14 @@ 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"`
@@ -103,7 +123,8 @@ type Info struct {
 	LoadAvg15      float64 `json:"l15,omitempty" cbor:"17,keyasint,omitempty"`
 	BandwidthBytes uint64  `json:"bb" cbor:"18,keyasint"`
 	// TODO: remove load fields in future release in favor of load avg array
-	LoadAvg [3]float64 `json:"la,omitempty" cbor:"19,keyasint"`
+	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/ghupdate/ghupdate.go

@@ -4,7 +4,6 @@
 package ghupdate
 
 import (
-	"beszel"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -16,6 +15,8 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/henrygd/beszel"
+
 	"github.com/blang/semver"
 )
 

internal/hub/agent_connect.go

@@ -1,9 +1,7 @@
 package hub
 
 import (
-	"beszel/internal/common"
-	"beszel/internal/hub/expirymap"
-	"beszel/internal/hub/ws"
+	"context"
 	"errors"
 	"net"
 	"net/http"
@@ -11,6 +9,10 @@ import (
 	"sync"
 	"time"
 
+	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/hub/expirymap"
+	"github.com/henrygd/beszel/internal/hub/ws"
+
 	"github.com/blang/semver"
 	"github.com/lxzan/gws"
 	"github.com/pocketbase/dbx"
@@ -92,7 +94,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)
+	wsConn := ws.NewWsConnection(conn, acr.agentSemVer)
 
 	// must set wsConn in connection store before the read loop
 	conn.Session().Store("wsConn", wsConn)
@@ -111,7 +113,7 @@ func (acr *agentConnectRequest) verifyWsConn(conn *gws.Conn, fpRecords []ws.Fing
 		return err
 	}
 
-	agentFingerprint, err := wsConn.GetFingerprint(acr.token, signer, acr.isUniversalToken)
+	agentFingerprint, err := wsConn.GetFingerprint(context.Background(), acr.token, signer, acr.isUniversalToken)
 	if err != nil {
 		return err
 	}
@@ -266,9 +268,12 @@ 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.Hostname)
+	systemRecord.Set("name", agentFingerprint.Name)
 	systemRecord.Set("host", remoteAddr)
 	systemRecord.Set("port", agentFingerprint.Port)
 	systemRecord.Set("users", []string{acr.userId})

internal/hub/agent_connect_test.go

@@ -4,9 +4,6 @@
 package hub
 
 import (
-	"beszel/internal/agent"
-	"beszel/internal/common"
-	"beszel/internal/hub/ws"
 	"crypto/ed25519"
 	"fmt"
 	"net/http"
@@ -17,6 +14,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/henrygd/beszel/agent"
+	"github.com/henrygd/beszel/internal/common"
+	"github.com/henrygd/beszel/internal/hub/ws"
+
 	"github.com/pocketbase/pocketbase/core"
 	pbtests "github.com/pocketbase/pocketbase/tests"
 	"github.com/stretchr/testify/assert"

internal/hub/config/config.go

@@ -2,13 +2,14 @@
 package config
 
 import (
-	"beszel/internal/entities/system"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
 
 	"github.com/google/uuid"
+	"github.com/henrygd/beszel/internal/entities/system"
+
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/spf13/cast"