updates

.dockerignore

@@ -1,48 +0,0 @@
-# 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,138 +12,30 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # henrygd/beszel
           - image: henrygd/beszel
-            dockerfile: ./internal/dockerfile_hub
+            context: ./beszel
+            dockerfile: ./beszel/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
-            dockerfile: ./internal/dockerfile_agent
+            context: ./beszel
+            dockerfile: ./beszel/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
-            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
-            dockerfile: ./internal/dockerfile_hub
+            context: ./beszel
+            dockerfile: ./beszel/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
-            dockerfile: ./internal/dockerfile_agent
+            context: ./beszel
+            dockerfile: ./beszel/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
-            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
       packages: write
@@ -156,10 +48,10 @@ jobs:
         uses: oven-sh/setup-bun@v2
 
       - name: Install dependencies
-        run: bun install --no-save --cwd ./internal/site
+        run: bun install --no-save --cwd ./beszel/site
 
       - name: Build site
-        run: bun run --cwd ./internal/site build
+        run: bun run --cwd ./beszel/site build
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -172,13 +64,16 @@ jobs:
         uses: docker/metadata-action@v5
         with:
           images: ${{ matrix.image }}
-          tags: ${{ matrix.tags }}
+          tags: |
+            type=raw,value=edge
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value={{sha}},enable=${{ github.ref_type != 'tag' }}
 
       # https://github.com/docker/login-action
       - name: Login to Docker Hub
-        env:
-          password_secret_exists: ${{ secrets[matrix.password_secret] != '' && 'true' || 'false' }}
-        if: github.event_name != 'pull_request' && env.password_secret_exists == 'true'
+        if: github.event_name != 'pull_request'
         uses: docker/login-action@v3
         with:
           username: ${{ matrix.username || secrets[matrix.username_secret] }}
@@ -190,9 +85,9 @@ jobs:
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
-          context: ./
+          context: "${{ matrix.context }}"
           file: ${{ matrix.dockerfile }}
-          platforms: ${{ matrix.platforms || 'linux/amd64,linux/arm64,linux/arm/v7' }}
-          push: ${{ github.ref_type == 'tag' && secrets[matrix.password_secret] != '' }}
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          push: ${{ github.ref_type == 'tag' }}
           tags: ${{ steps.metadata.outputs.tags }}
           labels: ${{ steps.metadata.outputs.labels }}

.github/workflows/release.yml

@@ -3,7 +3,7 @@ name: Make release and binaries
 on:
   push:
     tags:
-      - "v*"
+      - 'v*'
 
 permissions:
   contents: write
@@ -21,34 +21,22 @@ jobs:
         uses: oven-sh/setup-bun@v2
 
       - name: Install dependencies
-        run: bun install --no-save --cwd ./internal/site
+        run: bun install --no-save --cwd ./beszel/site
 
       - name: Build site
-        run: bun run --cwd ./internal/site build
+        run: bun run --cwd ./beszel/site build
 
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: "^1.22.1"
-
-      - name: Set up .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: "9.0.x"
-
-      - name: Build .NET LHM executable for Windows sensors
-        run: |
-          dotnet build -c Release ./agent/lhm/beszel_lhm.csproj
-        shell: bash
+          go-version: '^1.22.1'
 
       - name: GoReleaser beszel
         uses: goreleaser/goreleaser-action@v6
         with:
-          workdir: ./
+          workdir: ./beszel
           distribution: goreleaser
           version: latest
           args: release --clean
         env:
           GITHUB_TOKEN: ${{ secrets.TOKEN || secrets.GITHUB_TOKEN }}
-          WINGET_TOKEN: ${{ secrets.WINGET_TOKEN }}
-          IS_FORK: ${{ github.repository_owner != 'henrygd' }}

.github/workflows/vulncheck.yml

@@ -15,7 +15,7 @@ permissions:
 
 jobs:
   vulncheck:
-    name: VulnCheck
+    name: Analysis
     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.25.x
-          # cached: false
+          go-version: 1.24.x
+          cached: false
       - name: Get official govulncheck
         run: go install golang.org/x/vuln/cmd/govulncheck@latest
         shell: bash
       - name: Run govulncheck
-        run: govulncheck -show verbose ./...
+        run: govulncheck -C ./beszel -show verbose ./...
         shell: bash

.gitignore

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

Makefile

@@ -1,102 +0,0 @@
-# Default OS/ARCH values
-OS ?= $(shell go env GOOS)
-ARCH ?= $(shell go env GOARCH)
-# Skip building the web UI if true
-SKIP_WEB ?= false
-
-# Set executable extension based on target OS
-EXE_EXT := $(if $(filter windows,$(OS)),.exe,)
-
-.PHONY: tidy build-agent build-hub build-hub-dev build clean lint dev-server dev-agent dev-hub dev generate-locales
-.DEFAULT_GOAL := build
-
-clean:
-	go clean
-	rm -rf ./build
-
-lint:
-	golangci-lint run
-
-test: export GOEXPERIMENT=synctest
-test:
-	go test -tags=testing ./...
-
-tidy:
-	go mod tidy
-
-build-web-ui:
-	@if command -v bun >/dev/null 2>&1; then \
-		bun install --cwd ./internal/site && \
-		bun run --cwd ./internal/site build; \
-	else \
-		npm install --prefix ./internal/site && \
-		npm run --prefix ./internal/site build; \
-	fi
-
-# Conditional .NET build - only for Windows
-build-dotnet-conditional:
-	@if [ "$(OS)" = "windows" ]; then \
-		echo "Building .NET executable for Windows..."; \
-		if command -v dotnet >/dev/null 2>&1; then \
-			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; \
-		fi; \
-	fi
-
-# 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" ./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" ./internal/cmd/hub
-
-build-hub-dev: tidy
-	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 ./internal/site/src/locales/en/en.ts ]; then \
-		echo "Generating locales..."; \
-		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 ./internal/site
-	@if command -v bun >/dev/null 2>&1; then \
-		cd ./internal/site && bun run dev --host 0.0.0.0; \
-	else \
-		cd ./internal/site && npm run dev --host 0.0.0.0; \
-	fi
-
-dev-hub: export ENV=dev
-dev-hub:
-	mkdir -p ./internal/site/dist && touch ./internal/site/dist/index.html
-	@if command -v entr >/dev/null 2>&1; then \
-		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 ./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 ./internal/cmd/agent/*.go ./agent/*.go | entr -r go run github.com/henrygd/beszel/internal/cmd/agent; \
-	else \
-		go run github.com/henrygd/beszel/internal/cmd/agent; \
-	fi
-	
-build-dotnet:
-	@if command -v dotnet >/dev/null 2>&1; then \
-		rm -rf ./agent/lhm/bin; \
-		dotnet build -c Release ./agent/lhm/beszel_lhm.csproj; \
-	else \
-		echo "dotnet not found"; \
-	fi
-
-
-# KEY="..." make -j dev
-dev: dev-server dev-hub dev-agent

agent/agent.go

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

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

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

@@ -1,81 +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"
-	"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/battery/battery_freebsd.go

@@ -1,13 +0,0 @@
-//go:build freebsd
-
-package battery
-
-import "errors"
-
-func HasReadableBattery() bool {
-	return false
-}
-
-func GetBatteryStats() (uint8, uint8, error) {
-	return 0, 0, errors.ErrUnsupported
-}

agent/client_test.go

@@ -1,561 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"crypto/ed25519"
-	"net/url"
-	"os"
-	"strings"
-	"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"
-	"golang.org/x/crypto/ssh"
-)
-
-// TestNewWebSocketClient tests WebSocket client creation
-func TestNewWebSocketClient(t *testing.T) {
-	agent := createTestAgent(t)
-
-	testCases := []struct {
-		name        string
-		hubURL      string
-		token       string
-		expectError bool
-		errorMsg    string
-	}{
-		{
-			name:        "valid configuration",
-			hubURL:      "http://localhost:8080",
-			token:       "test-token-123",
-			expectError: false,
-		},
-		{
-			name:        "valid https URL",
-			hubURL:      "https://hub.example.com",
-			token:       "secure-token",
-			expectError: false,
-		},
-		{
-			name:        "missing hub URL",
-			hubURL:      "",
-			token:       "test-token",
-			expectError: true,
-			errorMsg:    "HUB_URL environment variable not set",
-		},
-		{
-			name:        "invalid URL",
-			hubURL:      "ht\ttp://invalid",
-			token:       "test-token",
-			expectError: true,
-			errorMsg:    "invalid hub URL",
-		},
-		{
-			name:        "missing token",
-			hubURL:      "http://localhost:8080",
-			token:       "",
-			expectError: true,
-			errorMsg:    "must set TOKEN or TOKEN_FILE",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Set up environment
-			if tc.hubURL != "" {
-				os.Setenv("BESZEL_AGENT_HUB_URL", tc.hubURL)
-			} else {
-				os.Unsetenv("BESZEL_AGENT_HUB_URL")
-			}
-			if tc.token != "" {
-				os.Setenv("BESZEL_AGENT_TOKEN", tc.token)
-			} else {
-				os.Unsetenv("BESZEL_AGENT_TOKEN")
-			}
-			defer func() {
-				os.Unsetenv("BESZEL_AGENT_HUB_URL")
-				os.Unsetenv("BESZEL_AGENT_TOKEN")
-			}()
-
-			client, err := newWebSocketClient(agent)
-
-			if tc.expectError {
-				assert.Error(t, err)
-				if err != nil && tc.errorMsg != "" {
-					assert.Contains(t, err.Error(), tc.errorMsg)
-				}
-				assert.Nil(t, client)
-			} else {
-				require.NoError(t, err)
-				assert.NotNil(t, client)
-				assert.Equal(t, agent, client.agent)
-				assert.Equal(t, tc.token, client.token)
-				assert.Equal(t, tc.hubURL, client.hubURL.String())
-				assert.NotEmpty(t, client.fingerprint)
-				assert.NotNil(t, client.hubRequest)
-			}
-		})
-	}
-}
-
-// TestWebSocketClient_GetOptions tests WebSocket client options configuration
-func TestWebSocketClient_GetOptions(t *testing.T) {
-	agent := createTestAgent(t)
-
-	testCases := []struct {
-		name           string
-		inputURL       string
-		expectedScheme string
-		expectedPath   string
-	}{
-		{
-			name:           "http to ws conversion",
-			inputURL:       "http://localhost:8080",
-			expectedScheme: "ws",
-			expectedPath:   "/api/beszel/agent-connect",
-		},
-		{
-			name:           "https to wss conversion",
-			inputURL:       "https://hub.example.com",
-			expectedScheme: "wss",
-			expectedPath:   "/api/beszel/agent-connect",
-		},
-		{
-			name:           "existing path preservation",
-			inputURL:       "http://localhost:8080/custom/path",
-			expectedScheme: "ws",
-			expectedPath:   "/custom/path/api/beszel/agent-connect",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Set up environment
-			os.Setenv("BESZEL_AGENT_HUB_URL", tc.inputURL)
-			os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-			defer func() {
-				os.Unsetenv("BESZEL_AGENT_HUB_URL")
-				os.Unsetenv("BESZEL_AGENT_TOKEN")
-			}()
-
-			client, err := newWebSocketClient(agent)
-			require.NoError(t, err)
-
-			options := client.getOptions()
-
-			// Parse the WebSocket URL
-			wsURL, err := url.Parse(options.Addr)
-			require.NoError(t, err)
-
-			assert.Equal(t, tc.expectedScheme, wsURL.Scheme)
-			assert.Equal(t, tc.expectedPath, wsURL.Path)
-
-			// Check headers
-			assert.Equal(t, "test-token", options.RequestHeader.Get("X-Token"))
-			assert.Equal(t, beszel.Version, options.RequestHeader.Get("X-Beszel"))
-			assert.Contains(t, options.RequestHeader.Get("User-Agent"), "Mozilla/5.0")
-
-			// Test options caching
-			options2 := client.getOptions()
-			assert.Same(t, options, options2, "Options should be cached")
-		})
-	}
-}
-
-// TestWebSocketClient_VerifySignature tests signature verification
-func TestWebSocketClient_VerifySignature(t *testing.T) {
-	agent := createTestAgent(t)
-
-	// Generate test key pairs
-	_, goodPrivKey, err := ed25519.GenerateKey(nil)
-	require.NoError(t, err)
-	goodPubKey, err := ssh.NewPublicKey(goodPrivKey.Public().(ed25519.PublicKey))
-	require.NoError(t, err)
-
-	_, badPrivKey, err := ed25519.GenerateKey(nil)
-	require.NoError(t, err)
-	badPubKey, err := ssh.NewPublicKey(badPrivKey.Public().(ed25519.PublicKey))
-	require.NoError(t, err)
-
-	// Set up environment
-	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	client, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name        string
-		keys        []ssh.PublicKey
-		token       string
-		signWith    ed25519.PrivateKey
-		expectError bool
-	}{
-		{
-			name:        "valid signature with correct key",
-			keys:        []ssh.PublicKey{goodPubKey},
-			token:       "test-token",
-			signWith:    goodPrivKey,
-			expectError: false,
-		},
-		{
-			name:        "invalid signature with wrong key",
-			keys:        []ssh.PublicKey{goodPubKey},
-			token:       "test-token",
-			signWith:    badPrivKey,
-			expectError: true,
-		},
-		{
-			name:        "valid signature with multiple keys",
-			keys:        []ssh.PublicKey{badPubKey, goodPubKey},
-			token:       "test-token",
-			signWith:    goodPrivKey,
-			expectError: false,
-		},
-		{
-			name:        "no valid keys",
-			keys:        []ssh.PublicKey{badPubKey},
-			token:       "test-token",
-			signWith:    goodPrivKey,
-			expectError: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Set up agent with test keys
-			agent.keys = tc.keys
-			client.token = tc.token
-
-			// Create signature
-			signature := ed25519.Sign(tc.signWith, []byte(tc.token))
-
-			err := client.verifySignature(signature)
-
-			if tc.expectError {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), "invalid signature")
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-// TestWebSocketClient_HandleHubRequest tests hub request routing (basic verification logic)
-func TestWebSocketClient_HandleHubRequest(t *testing.T) {
-	agent := createTestAgent(t)
-
-	// Set up environment
-	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	client, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name        string
-		action      common.WebSocketAction
-		hubVerified bool
-		expectError bool
-		errorMsg    string
-	}{
-		{
-			name:        "CheckFingerprint without verification",
-			action:      common.CheckFingerprint,
-			hubVerified: false,
-			expectError: false, // CheckFingerprint is allowed without verification
-		},
-		{
-			name:        "GetData without verification",
-			action:      common.GetData,
-			hubVerified: false,
-			expectError: true,
-			errorMsg:    "hub not verified",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			client.hubVerified = tc.hubVerified
-
-			// Create minimal request
-			hubRequest := &common.HubRequest[cbor.RawMessage]{
-				Action: tc.action,
-				Data:   cbor.RawMessage{},
-			}
-
-			err := client.handleHubRequest(hubRequest, nil)
-
-			if tc.expectError {
-				assert.Error(t, err)
-				if tc.errorMsg != "" {
-					assert.Contains(t, err.Error(), tc.errorMsg)
-				}
-			} else {
-				// For CheckFingerprint, we expect a decode error since we're not providing valid data,
-				// but it shouldn't be the "hub not verified" error
-				if err != nil && tc.errorMsg != "" {
-					assert.NotContains(t, err.Error(), tc.errorMsg)
-				}
-			}
-		})
-	}
-}
-
-// TestWebSocketClient_GetUserAgent tests user agent generation
-func TestGetUserAgent(t *testing.T) {
-	// Run multiple times to check both variants
-	userAgents := make(map[string]bool)
-
-	for range 20 {
-		ua := getUserAgent()
-		userAgents[ua] = true
-
-		// Check that it's a valid Mozilla user agent
-		assert.Contains(t, ua, "Mozilla/5.0")
-		assert.Contains(t, ua, "AppleWebKit/537.36")
-		assert.Contains(t, ua, "Chrome/124.0.0.0")
-		assert.Contains(t, ua, "Safari/537.36")
-
-		// Should contain either Windows or Mac
-		isWindows := strings.Contains(ua, "Windows NT 11.0")
-		isMac := strings.Contains(ua, "Macintosh; Intel Mac OS X 14_0_0")
-		assert.True(t, isWindows || isMac, "User agent should contain either Windows or Mac identifier")
-	}
-
-	// With enough iterations, we should see both variants
-	// though this might occasionally fail
-	if len(userAgents) == 1 {
-		t.Log("Note: Only one user agent variant was generated in this test run")
-	}
-}
-
-// TestWebSocketClient_Close tests connection closing
-func TestWebSocketClient_Close(t *testing.T) {
-	agent := createTestAgent(t)
-
-	// Set up environment
-	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	client, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-
-	// Test closing with nil connection (should not panic)
-	assert.NotPanics(t, func() {
-		client.Close()
-	})
-}
-
-// TestWebSocketClient_ConnectRateLimit tests connection rate limiting
-func TestWebSocketClient_ConnectRateLimit(t *testing.T) {
-	agent := createTestAgent(t)
-
-	// Set up environment
-	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	client, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-
-	// Set recent connection attempt
-	client.lastConnectAttempt = time.Now()
-
-	// Test that connection fails quickly due to rate limiting
-	// This won't actually connect but should fail fast
-	err = client.Connect()
-	assert.Error(t, err, "Connection should fail but not hang")
-}
-
-// TestGetToken tests the getToken function with various scenarios
-func TestGetToken(t *testing.T) {
-	unsetEnvVars := func() {
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-		os.Unsetenv("TOKEN")
-		os.Unsetenv("BESZEL_AGENT_TOKEN_FILE")
-		os.Unsetenv("TOKEN_FILE")
-	}
-
-	t.Run("token from TOKEN environment variable", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Set TOKEN env var
-		expectedToken := "test-token-from-env"
-		os.Setenv("TOKEN", expectedToken)
-		defer os.Unsetenv("TOKEN")
-
-		token, err := getToken()
-		assert.NoError(t, err)
-		assert.Equal(t, expectedToken, token)
-	})
-
-	t.Run("token from BESZEL_AGENT_TOKEN environment variable", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Set BESZEL_AGENT_TOKEN env var (should take precedence)
-		expectedToken := "test-token-from-beszel-env"
-		os.Setenv("BESZEL_AGENT_TOKEN", expectedToken)
-		defer os.Unsetenv("BESZEL_AGENT_TOKEN")
-
-		token, err := getToken()
-		assert.NoError(t, err)
-		assert.Equal(t, expectedToken, token)
-	})
-
-	t.Run("token from TOKEN_FILE", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Create a temporary token file
-		expectedToken := "test-token-from-file"
-		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
-		require.NoError(t, err)
-		defer os.Remove(tokenFile.Name())
-
-		_, err = tokenFile.WriteString(expectedToken)
-		require.NoError(t, err)
-		tokenFile.Close()
-
-		// Set TOKEN_FILE env var
-		os.Setenv("TOKEN_FILE", tokenFile.Name())
-		defer os.Unsetenv("TOKEN_FILE")
-
-		token, err := getToken()
-		assert.NoError(t, err)
-		assert.Equal(t, expectedToken, token)
-	})
-
-	t.Run("token from BESZEL_AGENT_TOKEN_FILE", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Create a temporary token file
-		expectedToken := "test-token-from-beszel-file"
-		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
-		require.NoError(t, err)
-		defer os.Remove(tokenFile.Name())
-
-		_, err = tokenFile.WriteString(expectedToken)
-		require.NoError(t, err)
-		tokenFile.Close()
-
-		// Set BESZEL_AGENT_TOKEN_FILE env var (should take precedence)
-		os.Setenv("BESZEL_AGENT_TOKEN_FILE", tokenFile.Name())
-		defer os.Unsetenv("BESZEL_AGENT_TOKEN_FILE")
-
-		token, err := getToken()
-		assert.NoError(t, err)
-		assert.Equal(t, expectedToken, token)
-	})
-
-	t.Run("TOKEN takes precedence over TOKEN_FILE", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Create a temporary token file
-		fileToken := "token-from-file"
-		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
-		require.NoError(t, err)
-		defer os.Remove(tokenFile.Name())
-
-		_, err = tokenFile.WriteString(fileToken)
-		require.NoError(t, err)
-		tokenFile.Close()
-
-		// Set both TOKEN and TOKEN_FILE
-		envToken := "token-from-env"
-		os.Setenv("TOKEN", envToken)
-		os.Setenv("TOKEN_FILE", tokenFile.Name())
-		defer func() {
-			os.Unsetenv("TOKEN")
-			os.Unsetenv("TOKEN_FILE")
-		}()
-
-		token, err := getToken()
-		assert.NoError(t, err)
-		assert.Equal(t, envToken, token, "TOKEN should take precedence over TOKEN_FILE")
-	})
-
-	t.Run("error when neither TOKEN nor TOKEN_FILE is set", func(t *testing.T) {
-		unsetEnvVars()
-
-		token, err := getToken()
-		assert.Error(t, err)
-		assert.Equal(t, "", token)
-		assert.Contains(t, err.Error(), "must set TOKEN or TOKEN_FILE")
-	})
-
-	t.Run("error when TOKEN_FILE points to non-existent file", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Set TOKEN_FILE to a non-existent file
-		os.Setenv("TOKEN_FILE", "/non/existent/file.txt")
-		defer os.Unsetenv("TOKEN_FILE")
-
-		token, err := getToken()
-		assert.Error(t, err)
-		assert.Equal(t, "", token)
-		assert.Contains(t, err.Error(), "no such file or directory")
-	})
-
-	t.Run("handles empty token file", func(t *testing.T) {
-		unsetEnvVars()
-
-		// Create an empty token file
-		tokenFile, err := os.CreateTemp("", "token-test-*.txt")
-		require.NoError(t, err)
-		defer os.Remove(tokenFile.Name())
-		tokenFile.Close()
-
-		// Set TOKEN_FILE env var
-		os.Setenv("TOKEN_FILE", tokenFile.Name())
-		defer os.Unsetenv("TOKEN_FILE")
-
-		token, err := getToken()
-		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/cpu.go

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

agent/deltatracker/deltatracker.go

@@ -1,100 +0,0 @@
-// Package deltatracker provides a tracker for calculating differences in numeric values over time.
-package deltatracker
-
-import (
-	"sync"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Numeric is a constraint that permits any integer or floating-point type.
-type Numeric interface {
-	constraints.Integer | constraints.Float
-}
-
-// DeltaTracker is a generic, thread-safe tracker for calculating differences
-// in numeric values over time.
-// K is the key type (e.g., int, string).
-// V is the value type (e.g., int, int64, float32, float64).
-type DeltaTracker[K comparable, V Numeric] struct {
-	sync.RWMutex
-	current  map[K]V
-	previous map[K]V
-}
-
-// NewDeltaTracker creates a new generic tracker.
-func NewDeltaTracker[K comparable, V Numeric]() *DeltaTracker[K, V] {
-	return &DeltaTracker[K, V]{
-		current:  make(map[K]V),
-		previous: make(map[K]V),
-	}
-}
-
-// Set records the current value for a given ID.
-func (t *DeltaTracker[K, V]) Set(id K, value V) {
-	t.Lock()
-	defer t.Unlock()
-	t.current[id] = value
-}
-
-// Snapshot returns a copy of the current map.
-// func (t *DeltaTracker[K, V]) Snapshot() map[K]V {
-// 	t.RLock()
-// 	defer t.RUnlock()
-
-// 	copyMap := make(map[K]V, len(t.current))
-// 	maps.Copy(copyMap, t.current)
-// 	return copyMap
-// }
-
-// Deltas returns a map of all calculated deltas for the current interval.
-func (t *DeltaTracker[K, V]) Deltas() map[K]V {
-	t.RLock()
-	defer t.RUnlock()
-
-	deltas := make(map[K]V)
-	for id, currentVal := range t.current {
-		if previousVal, ok := t.previous[id]; ok {
-			deltas[id] = currentVal - previousVal
-		} else {
-			deltas[id] = 0
-		}
-	}
-	return deltas
-}
-
-// Previous returns the previously recorded value for the given key, if it exists.
-func (t *DeltaTracker[K, V]) Previous(id K) (V, bool) {
-	t.RLock()
-	defer t.RUnlock()
-
-	value, ok := t.previous[id]
-	return value, ok
-}
-
-// Delta returns the delta for a single key.
-// Returns 0 if the key doesn't exist or has no previous value.
-func (t *DeltaTracker[K, V]) Delta(id K) V {
-	t.RLock()
-	defer t.RUnlock()
-
-	currentVal, currentOk := t.current[id]
-	if !currentOk {
-		return 0
-	}
-
-	previousVal, previousOk := t.previous[id]
-	if !previousOk {
-		return 0
-	}
-
-	return currentVal - previousVal
-}
-
-// Cycle prepares the tracker for the next interval.
-func (t *DeltaTracker[K, V]) Cycle() {
-	t.Lock()
-	defer t.Unlock()
-	t.previous = t.current
-	t.current = make(map[K]V)
-}

agent/deltatracker/deltatracker_test.go

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

agent/disk_test.go

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

agent/docker.go

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

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

agent/gpu_intel.go

@@ -1,199 +0,0 @@
-package agent
-
-import (
-	"bufio"
-	"io"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-const (
-	intelGpuStatsCmd      string = "intel_gpu_top"
-	intelGpuStatsInterval string = "3300" // in milliseconds
-)
-
-type intelGpuStats struct {
-	PowerGPU float64
-	PowerPkg float64
-	Engines  map[string]float64
-}
-
-// updateIntelFromStats updates aggregated GPU data from a single intelGpuStats sample
-func (gm *GPUManager) updateIntelFromStats(sample *intelGpuStats) bool {
-	gm.Lock()
-	defer gm.Unlock()
-
-	// only one gpu for now - cmd doesn't provide all by default
-	gpuData, ok := gm.GpuDataMap["0"]
-	if !ok {
-		gpuData = &system.GPUData{Name: "GPU", Engines: make(map[string]float64)}
-		gm.GpuDataMap["0"] = gpuData
-	}
-
-	gpuData.Power += sample.PowerGPU
-	gpuData.PowerPkg += sample.PowerPkg
-
-	if gpuData.Engines == nil {
-		gpuData.Engines = make(map[string]float64, len(sample.Engines))
-	}
-	for name, engine := range sample.Engines {
-		gpuData.Engines[name] += engine
-	}
-
-	gpuData.Count++
-	return true
-}
-
-// collectIntelStats executes intel_gpu_top in text mode (-l) and parses the output
-func (gm *GPUManager) collectIntelStats() (err error) {
-	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-l")
-	// Avoid blocking if intel_gpu_top writes to stderr
-	cmd.Stderr = io.Discard
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	// Ensure we always reap the child to avoid zombies on any return path and
-	// propagate a non-zero exit code if no other error was set.
-	defer func() {
-		// Best-effort close of the pipe (unblock the child if it writes)
-		_ = stdout.Close()
-		if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
-			_ = cmd.Process.Kill()
-		}
-		if waitErr := cmd.Wait(); err == nil && waitErr != nil {
-			err = waitErr
-		}
-	}()
-
-	scanner := bufio.NewScanner(stdout)
-	var header1 string
-	var engineNames []string
-	var friendlyNames []string
-	var preEngineCols int
-	var powerIndex int
-	var hadDataRow bool
-	// skip first data row because it sometimes has erroneous data
-	var skippedFirstDataRow bool
-
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" {
-			continue
-		}
-
-		// first header line
-		if strings.HasPrefix(line, "Freq") {
-			header1 = line
-			continue
-		}
-
-		// second header line
-		if strings.HasPrefix(line, "req") {
-			engineNames, friendlyNames, powerIndex, preEngineCols = gm.parseIntelHeaders(header1, line)
-			continue
-		}
-
-		// Data row
-		if !skippedFirstDataRow {
-			skippedFirstDataRow = true
-			continue
-		}
-		sample, err := gm.parseIntelData(line, engineNames, friendlyNames, powerIndex, preEngineCols)
-		if err != nil {
-			return err
-		}
-		hadDataRow = true
-		gm.updateIntelFromStats(&sample)
-	}
-	if scanErr := scanner.Err(); scanErr != nil {
-		return scanErr
-	}
-	if !hadDataRow {
-		return errNoValidData
-	}
-	return nil
-}
-
-func (gm *GPUManager) parseIntelHeaders(header1 string, header2 string) (engineNames []string, friendlyNames []string, powerIndex int, preEngineCols int) {
-	// Build indexes
-	h1 := strings.Fields(header1)
-	h2 := strings.Fields(header2)
-	powerIndex = -1 // Initialize to -1, will be set to actual index if found
-	// Collect engine names from header1
-	for _, col := range h1 {
-		key := strings.TrimRightFunc(col, func(r rune) bool { return r >= '0' && r <= '9' })
-		var friendly string
-		switch key {
-		case "RCS":
-			friendly = "Render/3D"
-		case "BCS":
-			friendly = "Blitter"
-		case "VCS":
-			friendly = "Video"
-		case "VECS":
-			friendly = "VideoEnhance"
-		case "CCS":
-			friendly = "Compute"
-		default:
-			continue
-		}
-		engineNames = append(engineNames, key)
-		friendlyNames = append(friendlyNames, friendly)
-	}
-	// find power gpu index among pre-engine columns
-	if n := len(engineNames); n > 0 {
-		preEngineCols = max(len(h2)-3*n, 0)
-		limit := min(len(h2), preEngineCols)
-		for i := range limit {
-			if strings.EqualFold(h2[i], "gpu") {
-				powerIndex = i
-				break
-			}
-		}
-	}
-	return engineNames, friendlyNames, powerIndex, preEngineCols
-}
-
-func (gm *GPUManager) parseIntelData(line string, engineNames []string, friendlyNames []string, powerIndex int, preEngineCols int) (sample intelGpuStats, err error) {
-	fields := strings.Fields(line)
-	if len(fields) == 0 {
-		return sample, errNoValidData
-	}
-	// Make sure row has enough columns for engines
-	if need := preEngineCols + 3*len(engineNames); len(fields) < need {
-		return sample, errNoValidData
-	}
-	if powerIndex >= 0 && powerIndex < len(fields) {
-		if v, perr := strconv.ParseFloat(fields[powerIndex], 64); perr == nil {
-			sample.PowerGPU = v
-		}
-		if v, perr := strconv.ParseFloat(fields[powerIndex+1], 64); perr == nil {
-			sample.PowerPkg = v
-		}
-	}
-	if len(engineNames) > 0 {
-		sample.Engines = make(map[string]float64, len(engineNames))
-		for k := range engineNames {
-			base := preEngineCols + 3*k
-			if base < len(fields) {
-				busy := 0.0
-				if v, e := strconv.ParseFloat(fields[base], 64); e == nil {
-					busy = v
-				}
-				cur := sample.Engines[friendlyNames[k]]
-				sample.Engines[friendlyNames[k]] = cur + busy
-			} else {
-				sample.Engines[friendlyNames[k]] = 0
-			}
-		}
-	}
-	return sample, nil
-}

agent/handlers.go

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

agent/handlers_test.go

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

agent/lhm/beszel_lhm.cs

@@ -1,80 +0,0 @@
-using System;
-using System.Globalization;
-using LibreHardwareMonitor.Hardware;
-
-class Program
-{
-  static void Main()
-  {
-    var computer = new Computer
-    {
-      IsCpuEnabled = true,
-      IsGpuEnabled = true,
-      IsMemoryEnabled = true,
-      IsMotherboardEnabled = true,
-      IsStorageEnabled = true,
-      // IsPsuEnabled = true,
-      // IsNetworkEnabled = true,
-    };
-    computer.Open();
-
-    var reader = Console.In;
-    var writer = Console.Out;
-
-    string line;
-    while ((line = reader.ReadLine()) != null)
-    {
-      if (line.Trim().Equals("getTemps", StringComparison.OrdinalIgnoreCase))
-      {
-        foreach (var hw in computer.Hardware)
-        {
-          // process main hardware sensors
-          ProcessSensors(hw, writer);
-
-          // process subhardware sensors
-          foreach (var subhardware in hw.SubHardware)
-          {
-            ProcessSensors(subhardware, writer);
-          }
-        }
-        // send empty line to signal end of sensor data
-        writer.WriteLine();
-        writer.Flush();
-      }
-    }
-
-    computer.Close();
-  }
-
-  static void ProcessSensors(IHardware hardware, System.IO.TextWriter writer)
-  {
-    var updated = false;
-    foreach (var sensor in hardware.Sensors)
-    {
-      var validTemp = sensor.SensorType == SensorType.Temperature && sensor.Value.HasValue;
-      if (!validTemp || sensor.Name.Contains("Distance"))
-      {
-        continue;
-      }
-
-      if (!updated)
-      {
-        hardware.Update();
-        updated = true;
-      }
-
-      var name = sensor.Name;
-      // if sensor.Name starts with "Temperature" replace with hardware.Identifier but retain the rest of the name.
-      // usually this is a number like Temperature 3
-      if (sensor.Name.StartsWith("Temperature"))
-      {
-        name = hardware.Identifier.ToString().Replace("/", "_").TrimStart('_') + sensor.Name.Substring(11);
-      }
-
-      // invariant culture assures the value is parsable as a float
-      var value = sensor.Value.Value.ToString("0.##", CultureInfo.InvariantCulture);
-      // write the name and value to the writer
-      writer.WriteLine($"{name}|{value}");
-    }
-  }
-}

agent/lhm/beszel_lhm.csproj

@@ -1,11 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net48</TargetFramework>
-    <Platforms>x64</Platforms>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="LibreHardwareMonitorLib" Version="0.9.4" />
-  </ItemGroup>
-</Project>

agent/network.go

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

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

agent/sensors_default.go

@@ -1,9 +0,0 @@
-//go:build !windows
-
-package agent
-
-import (
-	"github.com/shirou/gopsutil/v4/sensors"
-)
-
-var getSensorTemps = sensors.TemperaturesWithContext

agent/sensors_windows.go

@@ -1,286 +0,0 @@
-//go:build windows
-
-//go:generate dotnet build -c Release lhm/beszel_lhm.csproj
-
-package agent
-
-import (
-	"bufio"
-	"context"
-	"embed"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/shirou/gopsutil/v4/sensors"
-)
-
-// Note: This is always called from Agent.gatherStats() which holds Agent.Lock(),
-// so no internal concurrency protection is needed.
-
-// lhmProcess is a wrapper around the LHM .NET process.
-type lhmProcess struct {
-	cmd                  *exec.Cmd
-	stdin                io.WriteCloser
-	stdout               io.ReadCloser
-	scanner              *bufio.Scanner
-	isRunning            bool
-	stoppedNoSensors     bool
-	consecutiveNoSensors uint8
-	execPath             string
-	tempDir              string
-}
-
-//go:embed all:lhm/bin/Release/net48
-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 with LHM=true)")
-
-// newlhmProcess copies the embedded LHM executable to a temporary directory and starts it.
-func newlhmProcess() (*lhmProcess, error) {
-	destDir := filepath.Join(os.TempDir(), "beszel")
-	execPath := filepath.Join(destDir, "beszel_lhm.exe")
-
-	if err := os.MkdirAll(destDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create temp directory: %w", err)
-	}
-
-	// Only copy if executable doesn't exist
-	if _, err := os.Stat(execPath); os.IsNotExist(err) {
-		if err := copyEmbeddedDir(lhmFs, "lhm/bin/Release/net48", destDir); err != nil {
-			return nil, fmt.Errorf("failed to copy embedded directory: %w", err)
-		}
-	}
-
-	lhm := &lhmProcess{
-		execPath: execPath,
-		tempDir:  destDir,
-	}
-
-	if err := lhm.startProcess(); err != nil {
-		return nil, fmt.Errorf("failed to start process: %w", err)
-	}
-
-	return lhm, nil
-}
-
-// startProcess starts the external LHM process
-func (lhm *lhmProcess) startProcess() error {
-	// Clean up any existing process
-	lhm.cleanupProcess()
-
-	cmd := exec.Command(lhm.execPath)
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return err
-	}
-
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		stdin.Close()
-		return err
-	}
-
-	if err := cmd.Start(); err != nil {
-		stdin.Close()
-		stdout.Close()
-		return err
-	}
-
-	// Update process state
-	lhm.cmd = cmd
-	lhm.stdin = stdin
-	lhm.stdout = stdout
-	lhm.scanner = bufio.NewScanner(stdout)
-	lhm.isRunning = true
-
-	// Give process a moment to initialize
-	time.Sleep(100 * time.Millisecond)
-
-	return nil
-}
-
-// cleanupProcess terminates the process and closes resources but preserves files
-func (lhm *lhmProcess) cleanupProcess() {
-	lhm.isRunning = false
-
-	if lhm.cmd != nil && lhm.cmd.Process != nil {
-		lhm.cmd.Process.Kill()
-		lhm.cmd.Wait()
-	}
-
-	if lhm.stdin != nil {
-		lhm.stdin.Close()
-		lhm.stdin = nil
-	}
-	if lhm.stdout != nil {
-		lhm.stdout.Close()
-		lhm.stdout = nil
-	}
-
-	lhm.cmd = nil
-	lhm.scanner = nil
-	lhm.stoppedNoSensors = false
-	lhm.consecutiveNoSensors = 0
-}
-
-func (lhm *lhmProcess) getTemps(ctx context.Context) (temps []sensors.TemperatureStat, err error) {
-	if !useLHM || lhm.stoppedNoSensors {
-		// Fall back to gopsutil if we can't get sensors from LHM
-		return sensors.TemperaturesWithContext(ctx)
-	}
-
-	// Start process if it's not running
-	if !lhm.isRunning || lhm.stdin == nil || lhm.scanner == nil {
-		err := lhm.startProcess()
-		if err != nil {
-			return temps, err
-		}
-	}
-
-	// Send command to process
-	_, err = fmt.Fprintln(lhm.stdin, "getTemps")
-	if err != nil {
-		lhm.isRunning = false
-		return temps, fmt.Errorf("failed to send command: %w", err)
-	}
-
-	// Read all sensor lines until we hit an empty line or EOF
-	for lhm.scanner.Scan() {
-		line := strings.TrimSpace(lhm.scanner.Text())
-		if line == "" {
-			break
-		}
-
-		parts := strings.Split(line, "|")
-		if len(parts) != 2 {
-			slog.Debug("Invalid sensor format", "line", line)
-			continue
-		}
-
-		name := strings.TrimSpace(parts[0])
-		valueStr := strings.TrimSpace(parts[1])
-
-		value, err := strconv.ParseFloat(valueStr, 64)
-		if err != nil {
-			slog.Debug("Failed to parse sensor", "err", err, "line", line)
-			continue
-		}
-
-		if name == "" || value <= 0 || value > 150 {
-			slog.Debug("Invalid sensor", "name", name, "val", value, "line", line)
-			continue
-		}
-
-		temps = append(temps, sensors.TemperatureStat{
-			SensorKey:   name,
-			Temperature: value,
-		})
-	}
-
-	if err := lhm.scanner.Err(); err != nil {
-		lhm.isRunning = false
-		return temps, err
-	}
-
-	// Handle no sensors case
-	if len(temps) == 0 {
-		lhm.consecutiveNoSensors++
-		if lhm.consecutiveNoSensors >= 3 {
-			lhm.stoppedNoSensors = true
-			slog.Warn(errNoSensors.Error())
-			lhm.cleanup()
-		}
-		return sensors.TemperaturesWithContext(ctx)
-	}
-
-	lhm.consecutiveNoSensors = 0
-
-	return temps, nil
-}
-
-// getSensorTemps attempts to pull sensor temperatures from the embedded LHM process.
-// NB: LibreHardwareMonitorLib requires admin privileges to access all available sensors.
-func getSensorTemps(ctx context.Context) (temps []sensors.TemperatureStat, err error) {
-	defer func() {
-		if err != nil {
-			slog.Debug("Error reading sensors", "err", err)
-		}
-	}()
-
-	if !useLHM {
-		return sensors.TemperaturesWithContext(ctx)
-	}
-
-	// Initialize process once
-	beszelLhmOnce.Do(func() {
-		beszelLhm, err = newlhmProcess()
-	})
-
-	if err != nil {
-		return temps, fmt.Errorf("failed to initialize lhm: %w", err)
-	}
-
-	if beszelLhm == nil {
-		return temps, fmt.Errorf("lhm not available")
-	}
-
-	return beszelLhm.getTemps(ctx)
-}
-
-// cleanup terminates the process and closes resources
-func (lhm *lhmProcess) cleanup() {
-	lhm.cleanupProcess()
-	if lhm.tempDir != "" {
-		os.RemoveAll(lhm.tempDir)
-	}
-}
-
-// copyEmbeddedDir copies the embedded directory to the destination path
-func copyEmbeddedDir(fs embed.FS, srcPath, destPath string) error {
-	entries, err := fs.ReadDir(srcPath)
-	if err != nil {
-		return err
-	}
-	if err := os.MkdirAll(destPath, 0755); err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		srcEntryPath := path.Join(srcPath, entry.Name())
-		destEntryPath := filepath.Join(destPath, entry.Name())
-
-		if entry.IsDir() {
-			if err := copyEmbeddedDir(fs, srcEntryPath, destEntryPath); err != nil {
-				return err
-			}
-			continue
-		}
-
-		data, err := fs.ReadFile(srcEntryPath)
-		if err != nil {
-			return err
-		}
-
-		if err := os.WriteFile(destEntryPath, data, 0755); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

agent/smart.go

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

agent/test-data/container.json

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

agent/test-data/container2.json

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

agent/update.go

@@ -1,168 +0,0 @@
-package agent
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"os/exec"
-	"runtime"
-	"strings"
-
-	"github.com/henrygd/beszel/internal/ghupdate"
-)
-
-// restarter knows how to restart the beszel-agent service.
-type restarter interface {
-	Restart() error
-}
-
-type systemdRestarter struct{ cmd string }
-
-func (s *systemdRestarter) Restart() error {
-	// Only restart if the service is active
-	if err := exec.Command(s.cmd, "is-active", "beszel-agent.service").Run(); err != nil {
-		return nil
-	}
-	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent.service via systemd…")
-	return exec.Command(s.cmd, "restart", "beszel-agent.service").Run()
-}
-
-type openRCRestarter struct{ cmd string }
-
-func (o *openRCRestarter) Restart() error {
-	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, "beszel-agent", "restart").Run()
-}
-
-type openWRTRestarter struct{ cmd string }
-
-func (w *openWRTRestarter) Restart() error {
-	// https://openwrt.org/docs/guide-user/base-system/managing_services?s[]=service
-	if err := exec.Command("/etc/init.d/beszel-agent", "running").Run(); err != nil {
-		return nil
-	}
-	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via procd…")
-	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 {
-	if path, err := exec.LookPath("systemctl"); err == nil {
-		return &systemdRestarter{cmd: path}
-	}
-	if path, err := exec.LookPath("rc-service"); err == nil {
-		return &openRCRestarter{cmd: path}
-	}
-    if path, err := exec.LookPath("procd"); err == nil {
-        return &openWRTRestarter{cmd: path}
-    }
-	if path, err := exec.LookPath("service"); err == nil {
-		if runtime.GOOS == "freebsd" {
-			return &freeBSDRestarter{cmd: path}
-		}
-	}
-	return nil
-}
-
-// Update checks GitHub for a newer release of beszel-agent, applies it,
-// fixes SELinux context if needed, and restarts the service.
-func Update(useMirror bool) error {
-	exePath, _ := os.Executable()
-
-	dataDir, err := getDataDir()
-	if err != nil {
-		dataDir = os.TempDir()
-	}
-	updated, err := ghupdate.Update(ghupdate.Config{
-		ArchiveExecutable: "beszel-agent",
-		DataDir:           dataDir,
-		UseMirror:         useMirror,
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	if !updated {
-		return nil
-	}
-
-	// make sure the file is executable
-	if err := os.Chmod(exePath, 0755); err != nil {
-		ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: failed to set executable permissions: %v", err)
-	}
-	// set ownership to beszel:beszel if possible
-	if chownPath, err := exec.LookPath("chown"); err == nil {
-		if err := exec.Command(chownPath, "beszel:beszel", exePath).Run(); err != nil {
-			ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: failed to set file ownership: %v", err)
-		}
-	}
-
-	// 6) Fix SELinux context if necessary
-	if err := handleSELinuxContext(exePath); err != nil {
-		ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: SELinux context handling: %v", err)
-	}
-
-	// 7) Restart service if running under a recognised init system
-	if r := detectRestarter(); r != nil {
-		if err := r.Restart(); err != nil {
-			ghupdate.ColorPrintf(ghupdate.ColorYellow, "Warning: failed to restart service: %v", err)
-			ghupdate.ColorPrint(ghupdate.ColorYellow, "Please restart the service manually.")
-		} else {
-			ghupdate.ColorPrint(ghupdate.ColorGreen, "Service restarted successfully")
-		}
-	} else {
-		ghupdate.ColorPrint(ghupdate.ColorYellow, "No supported init system detected; please restart manually if needed.")
-	}
-
-	return nil
-}
-
-// handleSELinuxContext restores or applies the correct SELinux label to the binary.
-func handleSELinuxContext(path string) error {
-	out, err := exec.Command("getenforce").Output()
-	if err != nil {
-		// SELinux not enabled or getenforce not available
-		return nil
-	}
-	state := strings.TrimSpace(string(out))
-	if state == "Disabled" {
-		return nil
-	}
-
-	ghupdate.ColorPrint(ghupdate.ColorYellow, "SELinux is enabled; applying context…")
-	var errs []string
-
-	// Try persistent context via semanage+restorecon
-	if semanagePath, err := exec.LookPath("semanage"); err == nil {
-		if err := exec.Command(semanagePath, "fcontext", "-a", "-t", "bin_t", path).Run(); err != nil {
-			errs = append(errs, "semanage fcontext failed: "+err.Error())
-		} else if restoreconPath, err := exec.LookPath("restorecon"); err == nil {
-			if err := exec.Command(restoreconPath, "-v", path).Run(); err != nil {
-				errs = append(errs, "restorecon failed: "+err.Error())
-			}
-		}
-	}
-
-	// Fallback to temporary context via chcon
-	if chconPath, err := exec.LookPath("chcon"); err == nil {
-		if err := exec.Command(chconPath, "-t", "bin_t", path).Run(); err != nil {
-			errs = append(errs, "chcon failed: "+err.Error())
-		}
-	}
-
-	if len(errs) > 0 {
-		return fmt.Errorf("SELinux context errors: %s", strings.Join(errs, "; "))
-	}
-	return nil
-}

beszel.go

@@ -1,18 +0,0 @@
-// 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/.goreleaser.yml

@@ -9,7 +9,7 @@ before:
 builds:
   - id: beszel
     binary: beszel
-    main: internal/cmd/hub/hub.go
+    main: cmd/hub/hub.go
     env:
       - CGO_ENABLED=0
     goos:
@@ -22,7 +22,7 @@ builds:
 
   - id: beszel-agent
     binary: beszel-agent
-    main: internal/cmd/agent/agent.go
+    main: cmd/agent/agent.go
     env:
       - CGO_ENABLED=0
     goos:
@@ -38,25 +38,12 @@ builds:
       - mips64
       - riscv64
       - mipsle
-      - mips
       - ppc64le
-    gomips:
-      - hardfloat
-      - softfloat
     ignore:
       - goos: freebsd
         goarch: arm
       - goos: openbsd
         goarch: arm
-      - goos: linux
-        goarch: mips64
-        gomips: softfloat
-      - goos: linux
-        goarch: mipsle
-        gomips: hardfloat
-      - goos: linux
-        goarch: mips
-        gomips: hardfloat
       - goos: windows
         goarch: arm
       - goos: darwin
@@ -67,7 +54,7 @@ builds:
 archives:
   - id: beszel-agent
     formats: [tar.gz]
-    ids:
+    builds:
       - beszel-agent
     name_template: >-
       {{ .Binary }}_
@@ -79,7 +66,7 @@ archives:
 
   - id: beszel
     formats: [tar.gz]
-    ids:
+    builds:
       - beszel
     name_template: >-
       {{ .Binary }}_
@@ -98,33 +85,33 @@ nfpms:
       API access.
     maintainer: henrygd <hank@henrygd.me>
     section: net
-    ids:
+    builds:
       - beszel-agent
     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 +122,6 @@ scoops:
     homepage: "https://beszel.dev"
     description: "Agent for Beszel, a lightweight server monitoring platform."
     license: MIT
-    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 +155,7 @@ brews:
     homepage: "https://beszel.dev"
     description: "Agent for Beszel, a lightweight server monitoring platform."
     license: MIT
-    skip_upload: '{{ if eq (tolower .Env.IS_FORK) "true" }}true{{ else }}auto{{ end }}'
+    skip_upload: auto
     extra_install: |
       (bin/"beszel-agent-launcher").write <<~EOS
         #!/bin/bash
@@ -187,6 +173,7 @@ brews:
       error_log_path "#{Dir.home}/.cache/beszel/beszel-agent.log"
       keep_alive true
       restart_delay 5
+      name beszel-agent
       process_type :background
 
 winget:
@@ -201,7 +188,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 eq (tolower .Env.IS_FORK) "true" }}true{{ else }}auto{{ end }}'
+    skip_upload: auto
     description: |
       Beszel is a lightweight server monitoring platform that includes Docker
       statistics, historical data, and alert functions. It has a friendly web
@@ -216,14 +203,13 @@ winget:
       owner: henrygd
       name: beszel-winget
       branch: henrygd.beszel-agent-{{ .Version }}
-      token: "{{ .Env.WINGET_TOKEN }}"
-      # pull_request:
-      #   enabled: true
-      #   draft: false
-      #   base:
-      #     owner: microsoft
-      #     name: winget-pkgs
-      #     branch: master
+      pull_request:
+        enabled: false
+        draft: false
+        base:
+          owner: microsoft
+          name: winget-pkgs
+          branch: master
 
 release:
   draft: true

beszel/Makefile

@@ -0,0 +1,72 @@
+# Default OS/ARCH values
+OS ?= $(shell go env GOOS)
+ARCH ?= $(shell go env GOARCH)
+# Skip building the web UI if true
+SKIP_WEB ?= false
+
+.PHONY: tidy build-agent build-hub build clean lint dev-server dev-agent dev-hub dev generate-locales
+.DEFAULT_GOAL := build
+
+clean:
+	go clean
+	rm -rf ./build
+
+lint:
+	golangci-lint run
+
+test: export GOEXPERIMENT=synctest
+test:
+	go test -tags=testing ./...
+
+tidy:
+	go mod tidy
+
+build-web-ui:
+	@if command -v bun >/dev/null 2>&1; then \
+		bun install --cwd ./site && \
+		bun run --cwd ./site build; \
+	else \
+		npm install --prefix ./site && \
+		npm run --prefix ./site build; \
+	fi
+
+build-agent: tidy
+	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel-agent_$(OS)_$(ARCH) -ldflags "-w -s" beszel/cmd/agent
+
+build-hub: tidy $(if $(filter false,$(SKIP_WEB)),build-web-ui)
+	GOOS=$(OS) GOARCH=$(ARCH) go build -o ./build/beszel_$(OS)_$(ARCH) -ldflags "-w -s" beszel/cmd/hub
+
+build: build-agent build-hub
+
+generate-locales:
+	@if [ ! -f ./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; \
+	fi
+
+dev-server: generate-locales
+	cd ./site
+	@if command -v bun >/dev/null 2>&1; then \
+		cd ./site && bun run dev --host 0.0.0.0; \
+	else \
+		cd ./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
+	@if command -v entr >/dev/null 2>&1; then \
+		find ./cmd/hub ./internal/{alerts,hub,records,users} -name "*.go" | entr -r -s "cd ./cmd/hub && go run . serve"; \
+	else \
+		cd ./cmd/hub && go run . 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; \
+	else \
+		go run beszel/cmd/agent; \
+	fi
+
+# KEY="..." make -j dev
+dev: dev-server dev-hub dev-agent

beszel/cmd/agent/agent.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"beszel"
+	"beszel/internal/agent"
+	"beszel/internal/agent/health"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// cli options
+type cmdOptions struct {
+	key    string // key is the public key(s) for SSH authentication.
+	listen string // listen is the address or port to listen on.
+}
+
+// parse parses the command line flags and populates the config struct.
+// It returns true if a subcommand was handled and the program should exit.
+func (opts *cmdOptions) parse() bool {
+	flag.StringVar(&opts.key, "key", "", "Public key(s) for SSH authentication")
+	flag.StringVar(&opts.listen, "listen", "", "Address or port to listen on")
+
+	flag.Usage = func() {
+		fmt.Printf("Usage: %s [command] [flags]\n", os.Args[0])
+		fmt.Println("\nCommands:")
+		fmt.Println("  health    Check if the agent is running")
+		fmt.Println("  help      Display this help message")
+		fmt.Println("  update    Update to the latest version")
+		fmt.Println("  version   Display the version")
+		fmt.Println("\nFlags:")
+		flag.PrintDefaults()
+	}
+
+	subcommand := ""
+	if len(os.Args) > 1 {
+		subcommand = os.Args[1]
+	}
+
+	switch subcommand {
+	case "-v", "version":
+		fmt.Println(beszel.AppName+"-agent", beszel.Version)
+		return true
+	case "help":
+		flag.Usage()
+		return true
+	case "update":
+		agent.Update()
+		return true
+	case "health":
+		err := health.Check()
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Print("ok")
+		return true
+	}
+
+	flag.Parse()
+	return false
+}
+
+// loadPublicKeys loads the public keys from the command line flag, environment variable, or key file.
+func (opts *cmdOptions) loadPublicKeys() ([]ssh.PublicKey, error) {
+	// Try command line flag first
+	if opts.key != "" {
+		return agent.ParseKeys(opts.key)
+	}
+
+	// Try environment variable
+	if key, ok := agent.GetEnv("KEY"); ok && key != "" {
+		return agent.ParseKeys(key)
+	}
+
+	// Try key file
+	keyFile, ok := agent.GetEnv("KEY_FILE")
+	if !ok {
+		return nil, fmt.Errorf("no key provided: must set -key flag, KEY env var, or KEY_FILE env var. Use 'beszel-agent help' for usage")
+	}
+
+	pubKey, err := os.ReadFile(keyFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read key file: %w", err)
+	}
+	return agent.ParseKeys(string(pubKey))
+}
+
+func (opts *cmdOptions) getAddress() string {
+	return agent.GetAddress(opts.listen)
+}
+
+func main() {
+	var opts cmdOptions
+	subcommandHandled := opts.parse()
+
+	if subcommandHandled {
+		return
+	}
+
+	var serverConfig agent.ServerOptions
+	var err error
+	serverConfig.Keys, err = opts.loadPublicKeys()
+	if err != nil {
+		log.Fatal("Failed to load public keys:", err)
+	}
+
+	addr := opts.getAddress()
+	serverConfig.Addr = addr
+	serverConfig.Network = agent.GetNetwork(addr)
+
+	agent, err := agent.NewAgent("")
+	if err != nil {
+		log.Fatal("Failed to create agent: ", err)
+	}
+
+	if err := agent.Start(serverConfig); err != nil {
+		log.Fatal("Failed to start server: ", err)
+	}
+}

beszel/cmd/agent/agent_test.go

@@ -1,14 +1,13 @@
 package main
 
 import (
+	"beszel/internal/agent"
 	"crypto/ed25519"
+	"flag"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/henrygd/beszel/agent"
-
-	"github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/crypto/ssh"
@@ -246,7 +245,7 @@ func TestParseFlags(t *testing.T) {
 	oldArgs := os.Args
 	defer func() {
 		os.Args = oldArgs
-		pflag.CommandLine = pflag.NewFlagSet(os.Args[0], pflag.ExitOnError)
+		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 	}()
 
 	tests := []struct {
@@ -270,22 +269,6 @@ func TestParseFlags(t *testing.T) {
 				listen: "",
 			},
 		},
-		{
-			name: "key flag double dash",
-			args: []string{"cmd", "--key", "testkey"},
-			expected: cmdOptions{
-				key:    "testkey",
-				listen: "",
-			},
-		},
-		{
-			name: "key flag short",
-			args: []string{"cmd", "-k", "testkey"},
-			expected: cmdOptions{
-				key:    "testkey",
-				listen: "",
-			},
-		},
 		{
 			name: "addr flag only",
 			args: []string{"cmd", "-listen", ":8080"},
@@ -294,22 +277,6 @@ func TestParseFlags(t *testing.T) {
 				listen: ":8080",
 			},
 		},
-		{
-			name: "addr flag double dash",
-			args: []string{"cmd", "--listen", ":8080"},
-			expected: cmdOptions{
-				key:    "",
-				listen: ":8080",
-			},
-		},
-		{
-			name: "addr flag short",
-			args: []string{"cmd", "-l", ":8080"},
-			expected: cmdOptions{
-				key:    "",
-				listen: ":8080",
-			},
-		},
 		{
 			name: "both flags",
 			args: []string{"cmd", "-key", "testkey", "-listen", ":8080"},
@@ -323,12 +290,12 @@ func TestParseFlags(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			// Reset flags for each test
-			pflag.CommandLine = pflag.NewFlagSet(tt.args[0], pflag.ExitOnError)
+			flag.CommandLine = flag.NewFlagSet(tt.args[0], flag.ExitOnError)
 			os.Args = tt.args
 
 			var opts cmdOptions
 			opts.parse()
-			pflag.Parse()
+			flag.Parse()
 
 			assert.Equal(t, tt.expected, opts)
 		})

beszel/cmd/hub/hub.go

@@ -1,16 +1,15 @@
 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"
@@ -46,13 +45,11 @@ func getBaseApp() *pocketbase.PocketBase {
 	baseApp.RootCmd.Use = beszel.AppName
 	baseApp.RootCmd.Short = ""
 	// add update command
-	updateCmd := &cobra.Command{
+	baseApp.RootCmd.AddCommand(&cobra.Command{
 		Use:   "update",
 		Short: "Update " + beszel.AppName + " to the latest version",
 		Run:   hub.Update,
-	}
-	updateCmd.Flags().Bool("china-mirrors", false, "Use mirror (gh.beszel.dev) instead of GitHub")
-	baseApp.RootCmd.AddCommand(updateCmd)
+	})
 	// add health command
 	baseApp.RootCmd.AddCommand(newHealthCmd())
 

beszel/dockerfile_Agent

@@ -0,0 +1,26 @@
+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
+
+RUN rm -rf /tmp/*
+
+# ? -------------------------
+FROM scratch
+
+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
+
+ENTRYPOINT ["/agent"]

beszel/dockerfile_Hub

@@ -3,11 +3,16 @@ 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 . ./
+COPY *.go ./
+COPY cmd ./cmd
+COPY internal ./internal
+COPY migrations ./migrations
+COPY site/dist ./site/dist
+COPY site/*.go ./site
 
 RUN apk add --no-cache \
     unzip \
@@ -17,7 +22,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 ./internal/cmd/hub
+RUN CGO_ENABLED=0 GOGC=75 GOOS=$TARGETOS GOARCH=$TARGETARCH go build -ldflags "-w -s" -o /beszel ./cmd/hub
 
 # ? -------------------------
 FROM scratch
@@ -25,9 +30,6 @@ FROM scratch
 COPY --from=builder /beszel /
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
-# Ensure data persistence across container recreations
-VOLUME ["/beszel_data"]
-
 EXPOSE 8090
 
 ENTRYPOINT [ "/beszel" ]

beszel/go.mod

@@ -1,27 +1,26 @@
-module github.com/henrygd/beszel
+module beszel
 
-go 1.25.1
+go 1.24.4
 
 // lock shoutrrr to specific version to allow review before updating
-replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.9.1
+replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.8.8
 
 require (
 	github.com/blang/semver v3.5.1+incompatible
-	github.com/distatus/battery v0.11.0
-	github.com/fxamacker/cbor/v2 v2.9.0
+	github.com/fxamacker/cbor/v2 v2.8.0
 	github.com/gliderlabs/ssh v0.3.8
 	github.com/google/uuid v1.6.0
 	github.com/lxzan/gws v1.8.9
-	github.com/nicholas-fedor/shoutrrr v0.10.0
+	github.com/nicholas-fedor/shoutrrr v0.8.15
 	github.com/pocketbase/dbx v1.11.0
-	github.com/pocketbase/pocketbase v0.30.1
-	github.com/shirou/gopsutil/v4 v4.25.9
-	github.com/spf13/cast v1.10.0
-	github.com/spf13/cobra v1.10.1
-	github.com/spf13/pflag v1.0.10
-	github.com/stretchr/testify v1.11.1
-	golang.org/x/crypto v0.42.0
-	golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9
+	github.com/pocketbase/pocketbase v0.28.4
+	github.com/rhysd/go-github-selfupdate v1.2.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/stretchr/testify v1.10.0
+	golang.org/x/crypto v0.39.0
+	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -33,37 +32,41 @@ require (
 	github.com/dolthub/maphash v0.1.0 // indirect
 	github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/ebitengine/purego v0.9.0 // indirect
+	github.com/ebitengine/purego v0.8.4 // indirect
 	github.com/fatih/color v1.18.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.10 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
 	github.com/ganigeorgiev/fexpr v0.5.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
 	github.com/go-sql-driver/mysql v1.9.1 // indirect
-	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.2.2 // indirect
+	github.com/google/go-github/v30 v30.1.0 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 // indirect
+	github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // 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
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/spf13/pflag v1.0.6 // indirect
+	github.com/tcnksm/go-gitconfig v0.1.2 // indirect
 	github.com/tklauser/go-sysconf v0.3.15 // indirect
 	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/ulikunitz/xz v0.5.12 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/image v0.31.0 // indirect
-	golang.org/x/net v0.44.0 // indirect
-	golang.org/x/oauth2 v0.31.0 // indirect
-	golang.org/x/sync v0.17.0 // indirect
-	golang.org/x/sys v0.36.0 // indirect
-	golang.org/x/text v0.29.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
-	howett.net/plist v1.0.1 // indirect
-	modernc.org/libc v1.66.3 // indirect
+	golang.org/x/image v0.28.0 // indirect
+	golang.org/x/net v0.41.0 // indirect
+	golang.org/x/oauth2 v0.30.0 // indirect
+	golang.org/x/sync v0.15.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+	modernc.org/libc v1.65.10 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.39.0 // indirect
+	modernc.org/sqlite v1.38.0 // indirect
 )

beszel/go.sum

@@ -1,7 +1,5 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
-github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg=
@@ -15,30 +13,29 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
 github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
-github.com/distatus/battery v0.11.0 h1:KJk89gz90Iq/wJtbjjM9yUzBXV+ASV/EG2WOOL7N8lc=
-github.com/distatus/battery v0.11.0/go.mod h1:KmVkE8A8hpIX4T78QRdMktYpEp35QfOL8A8dwZBxq2k=
 github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ=
 github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4=
 github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCOBXMn8=
 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/ebitengine/purego v0.9.0 h1:mh0zpKBIXDceC63hpvPuGLiJ8ZAa3DfrFTudmfi8A4k=
-github.com/ebitengine/purego v0.9.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
+github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
-github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
-github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
-github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fxamacker/cbor/v2 v2.8.0 h1:fFtUGXUzXPHTIUdne5+zzMPTfffl3RD5qYnkY40vtxU=
+github.com/fxamacker/cbor/v2 v2.8.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/ganigeorgiev/fexpr v0.5.0 h1:XA9JxtTE/Xm+g/JFI6RfZEHSiQlk+1glLvRK1Lpv/Tk=
 github.com/ganigeorgiev/fexpr v0.5.0/go.mod h1:RyGiGqmeXhEQ6+mlGdnUleLHgtzzu/VGO2WtJkF5drE=
 github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -49,28 +46,41 @@ github.com/go-sql-driver/mysql v1.9.1 h1:FrjNGn/BsJQjVRuSa8CBrM5BWA9BWoXXat3KrtS
 github.com/go-sql-driver/mysql v1.9.1/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
 github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
-github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
-github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 h1:EEHtgt9IwisQ2AZ4pIsMjahcegHh6rmhqxzIRQIyepY=
-github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
+github.com/google/go-github/v30 v30.1.0 h1:VLDx+UolQICEOKu2m4uAoMti1SxuEBAl7RSEG16L+Oo=
+github.com/google/go-github/v30 v30.1.0/go.mod h1:n8jBpHl45a/rlBUtRJMOG4GhNADUQFEufcolZ95JfU8=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf h1:WfD7VjIE6z8dIvMsI4/s+1qr5EL+zoIGev1BQj1eoJ8=
+github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf/go.mod h1:hyb9oH7vZsitZCiBt0ZvifOrB+qc8PS5IiilCIb87rg=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/jarcoal/httpmock v1.4.1 h1:0Ju+VCFuARfFlhVXFc2HxlcQkfB+Xq12/EotHko+x2A=
-github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
-github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+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/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 h1:mFWunSatvkQQDhpdyuFAYwyAan3hzCuma+Pz8sqvOfg=
-github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
+github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc=
+github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/lxzan/gws v1.8.9 h1:VU3SGUeWlQrEwfUSfokcZep8mdg/BrUF+y73YYshdBM=
 github.com/lxzan/gws v1.8.9/go.mod h1:d9yHaR1eDTBHagQC6KY7ycUOaz5KWeqQtP3xu7aMK8Y=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
@@ -79,108 +89,128 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.9.1 h1:SEBhM6P1favzILO0f55CY3P9JwvM9RZ7B1ZMCl+Injs=
-github.com/nicholas-fedor/shoutrrr v0.9.1/go.mod h1:khue5m8LYyMzdPWuJxDTJeT89l9gjwjA+a+r0e8qxxk=
-github.com/onsi/ginkgo/v2 v2.25.3 h1:Ty8+Yi/ayDAGtk4XxmmfUy4GabvM+MegeB4cDLRi6nw=
-github.com/onsi/ginkgo/v2 v2.25.3/go.mod h1:43uiyQC4Ed2tkOzLsEYm7hnrb7UJTWHYNsuy3bG/snE=
-github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
-github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
+github.com/nicholas-fedor/shoutrrr v0.8.8 h1:F/oyoatWK5cbHPPgkjRZrA0262TP7KWuUQz9KskRtR8=
+github.com/nicholas-fedor/shoutrrr v0.8.8/go.mod h1:T30Y+eoZFEjDk4HtOItcHQioZSOe3Z6a6aNfSz6jc5c=
+github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+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.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
+github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pocketbase/dbx v1.11.0 h1:LpZezioMfT3K4tLrqA55wWFw1EtH1pM4tzSVa7kgszU=
 github.com/pocketbase/dbx v1.11.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
-github.com/pocketbase/pocketbase v0.30.1 h1:8lgfhH+HiSw1PyKVMq2sjtC4ZNvda2f/envTAzWMLOA=
-github.com/pocketbase/pocketbase v0.30.1/go.mod h1:sUI+uekXZam5Wa0eh+DClc+HieKMCeqsHA7Ydd9vwyE=
+github.com/pocketbase/pocketbase v0.28.4 h1:RmhWXDcfKrFM9/W0G0Zrlv4eKBM8/s/v4SQKytjgD20=
+github.com/pocketbase/pocketbase v0.28.4/go.mod h1:jSuN93vE/oeJVOz2D2ZxcYyr2bYNmDOMCUkM+JhyJQ0=
 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=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rhysd/go-github-selfupdate v1.2.3 h1:iaa+J202f+Nc+A8zi75uccC8Wg3omaM7HDeimXA22Ag=
+github.com/rhysd/go-github-selfupdate v1.2.3/go.mod h1:mp/N8zj6jFfBQy/XMYoWsmfzxazpPAODuqarmPDe2Rg=
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v4 v4.25.9 h1:JImNpf6gCVhKgZhtaAHJ0serfFGtlfIlSC08eaKdTrU=
-github.com/shirou/gopsutil/v4 v4.25.9/go.mod h1:gxIxoC+7nQRwUl/xNhutXlD8lq+jxTgpIkEf3rADHL8=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
-github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
-github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
+github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
+github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
+github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tcnksm/go-gitconfig v0.1.2 h1:iiDhRitByXAEyjgBqsKi9QU4o2TNtv9kPP3RgPgXBPw=
+github.com/tcnksm/go-gitconfig v0.1.2/go.mod h1:/8EhP4H7oJZdIPyT+/UIsG87kTzrzM4UsLGSItWYCpE=
 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=
 github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
+github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
+github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
 go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
-golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
-golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9 h1:TQwNpfvNkxAVlItJf6Cr5JTsVZoC/Sj7K3OZv2Pc14A=
-golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.31.0 h1:mLChjE2MV6g1S7oqbXC0/UcKijjm5fnJLUYKIYrLESA=
-golang.org/x/image v0.31.0/go.mod h1:R9ec5Lcp96v9FTF+ajwaH3uGxPH4fKfHHAVbUILxghA=
-golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
-golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
+golang.org/x/image v0.28.0 h1:gdem5JW1OLS4FbkWgLO+7ZeFzYtL3xClb97GaUzYMFE=
+golang.org/x/image v0.28.0/go.mod h1:GUJYXtnGKEUgggyzh+Vxt+AviiCcyiwpsl8iQ8MvwGY=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
-golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo=
-golang.org/x/oauth2 v0.31.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+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.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 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-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
-golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
-golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
-golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
-google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-howett.net/plist v1.0.1 h1:37GdZ8tP09Q35o9ych3ehygcsL+HqKSwzctveSlarvM=
-howett.net/plist v1.0.1/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
-modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM=
-modernc.org/cc/v4 v4.26.2/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
+modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
 modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
-modernc.org/fileutil v1.3.8 h1:qtzNm7ED75pd1C7WgAGcK4edm4fvhtBsEiI/0NQ54YM=
-modernc.org/fileutil v1.3.8/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/fileutil v1.3.3 h1:3qaU+7f7xxTUmvU1pJTZiDLAIoJVdUSSauJNHg9yXoA=
+modernc.org/fileutil v1.3.3/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
 modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
-modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
-modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.66.3 h1:cfCbjTUcdsKyyZZfEUKfoHcP3S0Wkvz3jgSzByEWVCQ=
-modernc.org/libc v1.66.3/go.mod h1:XD9zO8kt59cANKvHPXpx7yS2ELPheAey0vjIuZOhOU8=
+modernc.org/libc v1.65.10 h1:ZwEk8+jhW7qBjHIT+wd0d9VjitRyQef9BnzlzGwMODc=
+modernc.org/libc v1.65.10/go.mod h1:StFvYpx7i/mXtBAfVOjaU0PWZOvIRoZSgXhrwXzr8Po=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
@@ -189,8 +219,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
 modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.39.0 h1:6bwu9Ooim0yVYA7IZn9demiQk/Ejp0BtTjBWFLymSeY=
-modernc.org/sqlite v1.39.0/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
+modernc.org/sqlite v1.38.0 h1:+4OrfPQ8pxHKuWG4md1JpR/EYAh3Md7TdejuuzE7EUI=
+modernc.org/sqlite v1.38.0/go.mod h1:1Bj+yES4SVvBZ4cBOpVZ6QgesMCKpJZDq0nxYzOpmNE=
 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=

beszel/internal/agent/agent.go

@@ -0,0 +1,182 @@
+// 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()
+
+	cachedData, ok := a.cache.Get(sessionID)
+	if ok {
+		slog.Debug("Cached stats", "session", sessionID)
+		return cachedData
+	}
+
+	*cachedData = system.CombinedData{
+		Stats: a.getSystemStats(),
+		Info:  a.systemInfo,
+	}
+	slog.Debug("System stats", "data", cachedData)
+
+	if a.dockerManager != nil {
+		if containerStats, err := a.dockerManager.getDockerStats(); err == nil {
+			cachedData.Containers = containerStats
+			slog.Debug("Docker stats", "data", cachedData.Containers)
+		} else {
+			slog.Debug("Docker stats", "err", err)
+		}
+	}
+
+	cachedData.Stats.ExtraFs = make(map[string]*system.FsStats)
+	for name, stats := range a.fsStats {
+		if !stats.Root && stats.DiskTotal > 0 {
+			cachedData.Stats.ExtraFs[name] = stats
+		}
+	}
+	slog.Debug("Extra filesystems", "data", cachedData.Stats.ExtraFs)
+
+	a.cache.Set(sessionID, cachedData)
+	return cachedData
+}
+
+// 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

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

@@ -0,0 +1,88 @@
+//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.Run(func() {
+		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/client.go

@@ -1,6 +1,8 @@
 package agent
 
 import (
+	"beszel"
+	"beszel/internal/common"
 	"crypto/tls"
 	"errors"
 	"fmt"
@@ -8,16 +10,10 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"os"
 	"path"
 	"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"
@@ -57,9 +53,9 @@ func newWebSocketClient(agent *Agent) (client *WebSocketClient, err error) {
 		return nil, errors.New("invalid hub URL")
 	}
 	// get registration token
-	client.token, err = getToken()
-	if err != nil {
-		return nil, err
+	client.token, _ = GetEnv("TOKEN")
+	if client.token == "" {
+		return nil, errors.New("TOKEN environment variable not set")
 	}
 
 	client.agent = agent
@@ -69,27 +65,6 @@ func newWebSocketClient(agent *Agent) (client *WebSocketClient, err error) {
 	return client, nil
 }
 
-// getToken returns the token for the WebSocket client.
-// It first checks the TOKEN environment variable, then the TOKEN_FILE environment variable.
-// If neither is set, it returns an error.
-func getToken() (string, error) {
-	// get token from env var
-	token, _ := GetEnv("TOKEN")
-	if token != "" {
-		return token, nil
-	}
-	// get token from file
-	tokenFile, _ := GetEnv("TOKEN_FILE")
-	if tokenFile == "" {
-		return "", errors.New("must set TOKEN or TOKEN_FILE")
-	}
-	tokenBytes, err := os.ReadFile(tokenFile)
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimSpace(string(tokenBytes)), nil
-}
-
 // getOptions returns the WebSocket client options, creating them if necessary.
 // It configures the connection URL, TLS settings, and authentication headers.
 func (client *WebSocketClient) getOptions() *gws.ClientOption {
@@ -144,9 +119,7 @@ func (client *WebSocketClient) OnOpen(conn *gws.Conn) {
 // OnClose handles WebSocket connection closure.
 // It logs the closure reason and notifies the connection manager.
 func (client *WebSocketClient) OnClose(conn *gws.Conn, err error) {
-	if err != nil {
-		slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
-	}
+	slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
 	client.agent.connectionManager.eventChan <- WebSocketDisconnect
 }
 
@@ -160,15 +133,11 @@ func (client *WebSocketClient) OnMessage(conn *gws.Conn, message *gws.Message) {
 		return
 	}
 
-	var HubRequest common.HubRequest[cbor.RawMessage]
-
-	err := cbor.Unmarshal(message.Data.Bytes(), &HubRequest)
-	if err != nil {
+	if err := cbor.NewDecoder(message.Data).Decode(client.hubRequest); err != nil {
 		slog.Error("Error parsing message", "err", err)
 		return
 	}
-
-	if err := client.handleHubRequest(&HubRequest, HubRequest.Id); err != nil {
+	if err := client.handleHubRequest(client.hubRequest); err != nil {
 		slog.Error("Error handling message", "err", err)
 	}
 }
@@ -181,7 +150,7 @@ func (client *WebSocketClient) OnPing(conn *gws.Conn, message []byte) {
 }
 
 // handleAuthChallenge verifies the authenticity of the hub and returns the system's fingerprint.
-func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) (err error) {
+func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.RawMessage]) (err error) {
 	var authRequest common.FingerprintRequest
 	if err := cbor.Unmarshal(msg.Data, &authRequest); err != nil {
 		return err
@@ -199,13 +168,12 @@ func (client *WebSocketClient) handleAuthChallenge(msg *common.HubRequest[cbor.R
 	}
 
 	if authRequest.NeedSysInfo {
-		response.Name, _ = GetEnv("SYSTEM_NAME")
 		response.Hostname = client.agent.systemInfo.Hostname
 		serverAddr := client.agent.connectionManager.serverOptions.Addr
 		_, response.Port, _ = net.SplitHostPort(serverAddr)
 	}
 
-	return client.sendResponse(response, requestID)
+	return client.sendMessage(response)
 }
 
 // verifySignature verifies the signature of the token using the public keys.
@@ -230,17 +198,25 @@ func (client *WebSocketClient) Close() {
 	}
 }
 
-// handleHubRequest routes the request to the appropriate handler using the handler registry.
-func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage], requestID *uint32) error {
-	ctx := &HandlerContext{
-		Client:       client,
-		Agent:        client.agent,
-		Request:      msg,
-		RequestID:    requestID,
-		HubVerified:  client.hubVerified,
-		SendResponse: client.sendResponse,
+// handleHubRequest routes the request to the appropriate handler.
+// It ensures the hub is verified before processing most requests.
+func (client *WebSocketClient) handleHubRequest(msg *common.HubRequest[cbor.RawMessage]) error {
+	if !client.hubVerified && msg.Action != common.CheckFingerprint {
+		return errors.New("hub not verified")
 	}
-	return client.agent.handlerRegistry.Handle(ctx)
+	switch msg.Action {
+	case common.GetData:
+		return client.sendSystemData()
+	case common.CheckFingerprint:
+		return client.handleAuthChallenge(msg)
+	}
+	return nil
+}
+
+// sendSystemData gathers and sends current system statistics to the hub.
+func (client *WebSocketClient) sendSystemData() error {
+	sysStats := client.agent.gatherStats(client.token)
+	return client.sendMessage(sysStats)
 }
 
 // sendMessage encodes the given data to CBOR and sends it as a binary message over the WebSocket connection to the hub.
@@ -249,47 +225,7 @@ func (client *WebSocketClient) sendMessage(data any) error {
 	if err != nil {
 		return err
 	}
-	err = client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
-	if err != nil {
-		// If writing fails (e.g., broken pipe due to network issues),
-		// close the connection to trigger reconnection logic (#1263)
-		client.Close()
-	}
-	return err
-}
-
-// sendResponse sends a response with optional request ID for the new protocol
-func (client *WebSocketClient) sendResponse(data any, requestID *uint32) error {
-	if requestID != nil {
-		// New format with ID - use typed fields
-		response := common.AgentResponse{
-			Id: requestID,
-		}
-
-		// Set the appropriate typed field based on data type
-		switch v := data.(type) {
-		case *system.CombinedData:
-			response.SystemData = v
-		case *common.FingerprintResponse:
-			response.Fingerprint = v
-		case string:
-			response.String = &v
-		case map[string]smart.SmartData:
-			response.SmartData = v
-		// case []byte:
-		// 	response.RawBytes = v
-		// case string:
-		// 	response.RawBytes = []byte(v)
-		default:
-			// For any other type, convert to error
-			response.Error = fmt.Sprintf("unsupported response type: %T", data)
-		}
-
-		return client.sendMessage(response)
-	} else {
-		// Legacy format - send data directly
-		return client.sendMessage(data)
-	}
+	return client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
 }
 
 // getUserAgent returns one of two User-Agent strings based on current time.

beszel/internal/agent/connection_manager.go

@@ -1,29 +1,26 @@
 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
-	ConnectionType system.ConnectionType
+	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
 }
 
 // ConnectionState represents the current connection state of the agent.
@@ -146,18 +143,15 @@ func (c *ConnectionManager) handleStateChange(newState ConnectionState) {
 	switch newState {
 	case WebSocketConnected:
 		slog.Info("WebSocket connected", "host", c.wsClient.hubURL.Host)
-		c.ConnectionType = system.ConnectionTypeWebSocket
 		c.stopWsTicker()
 		_ = c.agent.StopServer()
 		c.isConnecting = false
 	case SSHConnected:
 		// stop new ws connection attempts
 		slog.Info("SSH connection established")
-		c.ConnectionType = system.ConnectionTypeSSH
 		c.stopWsTicker()
 		c.isConnecting = false
 	case Disconnected:
-		c.ConnectionType = system.ConnectionTypeNone
 		if c.isConnecting {
 			// Already handling reconnection, avoid duplicate attempts
 			return

beszel/internal/agent/data_dir.go

@@ -9,30 +9,35 @@ import (
 )
 
 // getDataDir returns the path to the data directory for the agent and an error
-// if the directory is not valid. Attempts to find the optimal data directory if
-// no data directories are provided.
-func getDataDir(dataDirs ...string) (string, error) {
-	if len(dataDirs) > 0 {
-		return testDataDirs(dataDirs)
+// if the directory is not valid. Pass an empty string to attempt to find the
+// optimal data directory.
+func getDataDir(dataDir string) (string, error) {
+	if dataDir == "" {
+		dataDir, _ = GetEnv("DATA_DIR")
 	}
 
-	dataDir, _ := GetEnv("DATA_DIR")
 	if dataDir != "" {
-		dataDirs = append(dataDirs, dataDir)
+		return testDataDirs([]string{dataDir})
 	}
 
+	var dirsToTry []string
+
 	if runtime.GOOS == "windows" {
-		dataDirs = append(dataDirs,
+		dirsToTry = []string{
 			filepath.Join(os.Getenv("APPDATA"), "beszel-agent"),
 			filepath.Join(os.Getenv("LOCALAPPDATA"), "beszel-agent"),
-		)
+		}
 	} else {
-		dataDirs = append(dataDirs, "/var/lib/beszel-agent")
-		if homeDir, err := os.UserHomeDir(); err == nil {
-			dataDirs = append(dataDirs, filepath.Join(homeDir, ".config", "beszel"))
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		dirsToTry = []string{
+			"/var/lib/beszel-agent",
+			filepath.Join(homeDir, ".config", "beszel"),
 		}
 	}
-	return testDataDirs(dataDirs)
+	return testDataDirs(dirsToTry)
 }
 
 func testDataDirs(paths []string) (string, error) {

beszel/internal/agent/data_dir_test.go

@@ -44,15 +44,15 @@ func TestGetDataDir(t *testing.T) {
 		oldValue := os.Getenv("DATA_DIR")
 		defer func() {
 			if oldValue == "" {
-				os.Unsetenv("BESZEL_AGENT_DATA_DIR")
+				os.Unsetenv("DATA_DIR")
 			} else {
-				os.Setenv("BESZEL_AGENT_DATA_DIR", oldValue)
+				os.Setenv("DATA_DIR", oldValue)
 			}
 		}()
 
-		os.Setenv("BESZEL_AGENT_DATA_DIR", tempDir)
+		os.Setenv("DATA_DIR", tempDir)
 
-		result, err := getDataDir()
+		result, err := getDataDir("")
 		require.NoError(t, err)
 		assert.Equal(t, tempDir, result)
 	})
@@ -79,7 +79,7 @@ func TestGetDataDir(t *testing.T) {
 
 		// This will try platform-specific defaults, which may or may not work
 		// We're mainly testing that it doesn't panic and returns some result
-		result, err := getDataDir()
+		result, err := getDataDir("")
 		// We don't assert success/failure here since it depends on system permissions
 		// Just verify we get a string result if no error
 		if err == nil {

beszel/internal/agent/disk.go

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

beszel/internal/agent/docker.go

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

@@ -1,11 +1,11 @@
 package agent
 
 import (
+	"beszel/internal/entities/system"
 	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"maps"
 	"os/exec"
 	"regexp"
 	"strconv"
@@ -13,8 +13,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/system"
-
 	"golang.org/x/exp/slog"
 )
 
@@ -28,10 +26,13 @@ const (
 	nvidiaSmiInterval  string        = "4"    // in seconds
 	tegraStatsInterval string        = "3700" // in milliseconds
 	rocmSmiInterval    time.Duration = 4300 * time.Millisecond
+
 	// Command retry and timeout constants
 	retryWaitTime     time.Duration = 5 * time.Second
 	maxFailureRetries int           = 5
 
+	cmdBufferSize uint16 = 10 * 1024
+
 	// Unit Conversions
 	mebibytesInAMegabyte float64 = 1.024  // nvidia-smi reports memory in MiB
 	milliwattsInAWatt    float64 = 1000.0 // tegrastats reports power in mW
@@ -40,26 +41,10 @@ const (
 // GPUManager manages data collection for GPUs (either Nvidia or AMD)
 type GPUManager struct {
 	sync.Mutex
-	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
+	nvidiaSmi  bool
+	rocmSmi    bool
+	tegrastats bool
+	GpuDataMap map[string]*system.GPUData
 }
 
 // RocmSmiJson represents the JSON structure of rocm-smi output
@@ -80,7 +65,6 @@ type gpuCollector struct {
 	cmdArgs []string
 	parse   func([]byte) bool // returns true if valid data was found
 	buf     []byte
-	bufSize uint16
 }
 
 var errNoValidData = fmt.Errorf("no valid GPU data found") // Error for missing data
@@ -114,7 +98,7 @@ func (c *gpuCollector) collect() error {
 
 	scanner := bufio.NewScanner(stdout)
 	if c.buf == nil {
-		c.buf = make([]byte, 0, c.bufSize)
+		c.buf = make([]byte, 0, cmdBufferSize)
 	}
 	scanner.Buffer(c.buf, bufio.MaxScanTokenSize)
 
@@ -245,21 +229,36 @@ func (gm *GPUManager) parseAmdData(output []byte) bool {
 	return true
 }
 
-// GetCurrentData returns GPU utilization data averaged since the last call with this cacheKey
-func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData {
+// sums and resets the current GPU utilization data since the last update
+func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
 	gm.Lock()
 	defer gm.Unlock()
 
-	gm.initializeSnapshots(cacheKey)
-	nameCounts := gm.countGPUNames()
+	// check for GPUs with the same name
+	nameCounts := make(map[string]int)
+	for _, gpu := range gm.GpuDataMap {
+		nameCounts[gpu.Name]++
+	}
 
+	// copy / reset the data
 	gpuData := make(map[string]system.GPUData, len(gm.GpuDataMap))
 	for id, gpu := range gm.GpuDataMap {
-		gpuAvg := gm.calculateGPUAverage(id, gpu, cacheKey)
-		gm.updateInstantaneousValues(&gpuAvg, gpu)
-		gm.storeSnapshot(id, gpu, cacheKey)
+		gpuAvg := *gpu
 
-		// Append id to name if there are multiple GPUs with the same name
+		gpuAvg.Temperature = twoDecimals(gpu.Temperature)
+		gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
+		gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
+
+		// avoid division by zero
+		if gpu.Count > 0 {
+			gpuAvg.Usage = twoDecimals(gpu.Usage / gpu.Count)
+			gpuAvg.Power = twoDecimals(gpu.Power / gpu.Count)
+		}
+
+		// reset accumulators in the original
+		gpu.Usage, gpu.Power, gpu.Count = 0, 0, 0
+
+		// append id to the name if there are multiple GPUs with the same name
 		if nameCounts[gpu.Name] > 1 {
 			gpuAvg.Name = fmt.Sprintf("%s %s", gpu.Name, id)
 		}
@@ -269,115 +268,6 @@ func (gm *GPUManager) GetCurrentData(cacheKey uint16) map[string]system.GPUData
 	return gpuData
 }
 
-// initializeSnapshots ensures snapshot maps are initialized for the given cache key
-func (gm *GPUManager) initializeSnapshots(cacheKey uint16) {
-	if gm.lastAvgData == nil {
-		gm.lastAvgData = make(map[string]system.GPUData)
-	}
-	if gm.lastSnapshots == nil {
-		gm.lastSnapshots = make(map[uint16]map[string]*gpuSnapshot)
-	}
-	if gm.lastSnapshots[cacheKey] == nil {
-		gm.lastSnapshots[cacheKey] = make(map[string]*gpuSnapshot)
-	}
-}
-
-// countGPUNames returns a map of GPU names to their occurrence count
-func (gm *GPUManager) countGPUNames() map[string]int {
-	nameCounts := make(map[string]int)
-	for _, gpu := range gm.GpuDataMap {
-		nameCounts[gpu.Name]++
-	}
-	return nameCounts
-}
-
-// calculateGPUAverage computes the average GPU metrics since the last snapshot for this cache key
-func (gm *GPUManager) calculateGPUAverage(id string, gpu *system.GPUData, cacheKey uint16) system.GPUData {
-	lastSnapshot := gm.lastSnapshots[cacheKey][id]
-	currentCount := uint32(gpu.Count)
-	deltaCount := gm.calculateDeltaCount(currentCount, lastSnapshot)
-
-	// If no new data arrived, use last known average
-	if deltaCount == 0 {
-		return gm.lastAvgData[id] // zero value if not found
-	}
-
-	// Calculate new average
-	gpuAvg := *gpu
-	deltaUsage, deltaPower, deltaPowerPkg := gm.calculateDeltas(gpu, lastSnapshot)
-
-	gpuAvg.Power = twoDecimals(deltaPower / float64(deltaCount))
-
-	if gpu.Engines != nil {
-		// make fresh map for averaged engine metrics to avoid mutating
-		// the accumulator map stored in gm.GpuDataMap
-		gpuAvg.Engines = make(map[string]float64, len(gpu.Engines))
-		gpuAvg.Usage = gm.calculateIntelGPUUsage(&gpuAvg, gpu, lastSnapshot, deltaCount)
-		gpuAvg.PowerPkg = twoDecimals(deltaPowerPkg / float64(deltaCount))
-	} else {
-		gpuAvg.Usage = twoDecimals(deltaUsage / float64(deltaCount))
-	}
-
-	gm.lastAvgData[id] = gpuAvg
-	return gpuAvg
-}
-
-// calculateDeltaCount returns the change in count since the last snapshot
-func (gm *GPUManager) calculateDeltaCount(currentCount uint32, lastSnapshot *gpuSnapshot) uint32 {
-	if lastSnapshot != nil {
-		return currentCount - lastSnapshot.count
-	}
-	return currentCount
-}
-
-// calculateDeltas computes the change in usage, power, and powerPkg since the last snapshot
-func (gm *GPUManager) calculateDeltas(gpu *system.GPUData, lastSnapshot *gpuSnapshot) (deltaUsage, deltaPower, deltaPowerPkg float64) {
-	if lastSnapshot != nil {
-		return gpu.Usage - lastSnapshot.usage,
-			gpu.Power - lastSnapshot.power,
-			gpu.PowerPkg - lastSnapshot.powerPkg
-	}
-	return gpu.Usage, gpu.Power, gpu.PowerPkg
-}
-
-// calculateIntelGPUUsage computes Intel GPU usage from engine metrics and returns max engine usage
-func (gm *GPUManager) calculateIntelGPUUsage(gpuAvg, gpu *system.GPUData, lastSnapshot *gpuSnapshot, deltaCount uint32) float64 {
-	maxEngineUsage := 0.0
-	for name, engine := range gpu.Engines {
-		var deltaEngine float64
-		if lastSnapshot != nil && lastSnapshot.engines != nil {
-			deltaEngine = engine - lastSnapshot.engines[name]
-		} else {
-			deltaEngine = engine
-		}
-		gpuAvg.Engines[name] = twoDecimals(deltaEngine / float64(deltaCount))
-		maxEngineUsage = max(maxEngineUsage, deltaEngine/float64(deltaCount))
-	}
-	return twoDecimals(maxEngineUsage)
-}
-
-// updateInstantaneousValues updates values that should reflect current state, not averages
-func (gm *GPUManager) updateInstantaneousValues(gpuAvg *system.GPUData, gpu *system.GPUData) {
-	gpuAvg.Temperature = twoDecimals(gpu.Temperature)
-	gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
-	gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
-}
-
-// storeSnapshot saves the current GPU state for this cache key
-func (gm *GPUManager) storeSnapshot(id string, gpu *system.GPUData, cacheKey uint16) {
-	snapshot := &gpuSnapshot{
-		count:    uint32(gpu.Count),
-		usage:    gpu.Usage,
-		power:    gpu.Power,
-		powerPkg: gpu.PowerPkg,
-	}
-	if gpu.Engines != nil {
-		snapshot.engines = make(map[string]float64, len(gpu.Engines))
-		maps.Copy(snapshot.engines, gpu.Engines)
-	}
-	gm.lastSnapshots[cacheKey][id] = snapshot
-}
-
 // detectGPUs checks for the presence of GPU management tools (nvidia-smi, rocm-smi, tegrastats)
 // in the system path. It sets the corresponding flags in the GPUManager struct if any of these
 // tools are found. If none of the tools are found, it returns an error indicating that no GPU
@@ -393,37 +283,18 @@ func (gm *GPUManager) detectGPUs() error {
 		gm.tegrastats = true
 		gm.nvidiaSmi = false
 	}
-	if _, err := exec.LookPath(intelGpuStatsCmd); err == nil {
-		gm.intelGpuStats = true
-	}
-	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats || gm.intelGpuStats {
+	if gm.nvidiaSmi || gm.rocmSmi || gm.tegrastats {
 		return nil
 	}
-	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, tegrastats, or intel_gpu_top")
+	return fmt.Errorf("no GPU found - install nvidia-smi, rocm-smi, or tegrastats")
 }
 
 // startCollector starts the appropriate GPU data collector based on the command
 func (gm *GPUManager) startCollector(command string) {
 	collector := gpuCollector{
-		name:    command,
-		bufSize: 10 * 1024,
+		name: command,
 	}
 	switch command {
-	case intelGpuStatsCmd:
-		go func() {
-			failures := 0
-			for {
-				if err := gm.collectIntelStats(); err != nil {
-					failures++
-					if failures > maxFailureRetries {
-						break
-					}
-					slog.Warn("Error collecting Intel GPU data; see https://beszel.dev/guide/gpu", "err", err)
-					time.Sleep(retryWaitTime)
-					continue
-				}
-			}
-		}()
 	case nvidiaSmiCmd:
 		collector.cmdArgs = []string{
 			"-l", nvidiaSmiInterval,
@@ -457,9 +328,6 @@ func (gm *GPUManager) startCollector(command string) {
 
 // NewGPUManager creates and initializes a new GPUManager
 func NewGPUManager() (*GPUManager, error) {
-	if skipGPU, _ := GetEnv("SKIP_GPU"); skipGPU == "true" {
-		return nil, nil
-	}
 	var gm GPUManager
 	if err := gm.detectGPUs(); err != nil {
 		return nil, err
@@ -475,9 +343,6 @@ func NewGPUManager() (*GPUManager, error) {
 	if gm.tegrastats {
 		gm.startCollector(tegraStatsCmd)
 	}
-	if gm.intelGpuStats {
-		gm.startCollector(intelGpuStatsCmd)
-	}
 
 	return &gm, nil
 }

beszel/internal/agent/gpu_test.go

@@ -0,0 +1,793 @@
+//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/health/health_test.go

@@ -39,7 +39,7 @@ func TestHealth(t *testing.T) {
 	// This test uses synctest to simulate time passing.
 	// NOTE: This test requires GOEXPERIMENT=synctest to run.
 	t.Run("check with simulated time", func(t *testing.T) {
-		synctest.Test(t, func(t *testing.T) {
+		synctest.Run(func() {
 			// Update the file to set the initial timestamp.
 			require.NoError(t, Update(), "Update() failed inside synctest")
 

beszel/internal/agent/network.go

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

@@ -1,16 +1,13 @@
 package agent
 
 import (
+	"beszel/internal/entities/system"
 	"context"
 	"fmt"
 	"log/slog"
 	"path"
-	"runtime"
 	"strconv"
 	"strings"
-	"unicode/utf8"
-
-	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/shirou/gopsutil/v4/common"
 	"github.com/shirou/gopsutil/v4/sensors"
@@ -85,10 +82,10 @@ func (a *Agent) updateTemperatures(systemStats *system.Stats) {
 	// reset high temp
 	a.systemInfo.DashboardTemp = 0
 
-	temps, err := a.getTempsWithPanicRecovery(getSensorTemps)
+	temps, err := a.getTempsWithPanicRecovery(sensors.TemperaturesWithContext)
 	if err != nil {
 		// retry once on panic (gopsutil/issues/1832)
-		temps, err = a.getTempsWithPanicRecovery(getSensorTemps)
+		temps, err = a.getTempsWithPanicRecovery(sensors.TemperaturesWithContext)
 		if err != nil {
 			slog.Warn("Error updating temperatures", "err", err)
 			if len(systemStats.Temperatures) > 0 {
@@ -106,11 +103,6 @@ func (a *Agent) updateTemperatures(systemStats *system.Stats) {
 
 	systemStats.Temperatures = make(map[string]float64, len(temps))
 	for i, sensor := range temps {
-		// check for malformed strings on darwin (gopsutil/issues/1832)
-		if runtime.GOOS == "darwin" && !utf8.ValidString(sensor.SensorKey) {
-			continue
-		}
-
 		// scale temperature
 		if sensor.Temperature != 0 && sensor.Temperature < 1 {
 			sensor.Temperature = scaleTemperature(sensor.Temperature)

beszel/internal/agent/sensors_test.go

@@ -4,13 +4,12 @@
 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"

beszel/internal/agent/server.go

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

beszel/internal/agent/server_test.go

@@ -1,6 +1,8 @@
 package agent
 
 import (
+	"beszel/internal/entities/container"
+	"beszel/internal/entities/system"
 	"context"
 	"crypto/ed25519"
 	"encoding/json"
@@ -13,9 +15,6 @@ 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"
@@ -474,11 +473,11 @@ func TestWriteToSessionEncoding(t *testing.T) {
 			hubVersion:       "0.12.0-beta0",
 			expectedUsesCbor: false,
 		},
-		// {
-		// 	name:             "matching beta version should use CBOR",
-		// 	hubVersion:       "0.12.0-beta2",
-		// 	expectedUsesCbor: true,
-		// },
+		{
+			name:             "matching beta version should use CBOR",
+			hubVersion:       "0.12.0-beta2",
+			expectedUsesCbor: true,
+		},
 	}
 
 	for _, tt := range tests {

beszel/internal/agent/system.go

@@ -1,6 +1,8 @@
 package agent
 
 import (
+	"beszel"
+	"beszel/internal/entities/system"
 	"bufio"
 	"fmt"
 	"log/slog"
@@ -9,23 +11,14 @@ 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
@@ -37,7 +30,7 @@ func (a *Agent) initializeSystemInfo() {
 		a.systemInfo.KernelVersion = version
 		a.systemInfo.Os = system.Darwin
 	} else if strings.Contains(platform, "indows") {
-		a.systemInfo.KernelVersion = fmt.Sprintf("%s %s", strings.Replace(platform, "Microsoft ", "", 1), version)
+		a.systemInfo.KernelVersion = strings.Replace(platform, "Microsoft ", "", 1) + " " + version
 		a.systemInfo.Os = system.Windows
 	} else if platform == "freebsd" {
 		a.systemInfo.Os = system.Freebsd
@@ -66,37 +59,31 @@ func (a *Agent) initializeSystemInfo() {
 	}
 
 	// zfs
-	if _, err := getARCSize(); err != nil {
-		slog.Debug("Not monitoring ZFS ARC", "err", err)
-	} else {
+	if _, err := getARCSize(); err == nil {
 		a.zfs = true
+	} else {
+		slog.Debug("Not monitoring ZFS ARC", "err", err)
 	}
 }
 
 // Returns current info, stats about the host system
-func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
-	var systemStats system.Stats
-
-	// battery
-	if batteryPercent, batteryState, err := battery.GetBatteryStats(); err == nil {
-		systemStats.Battery[0] = batteryPercent
-		systemStats.Battery[1] = batteryState
-	}
+func (a *Agent) getSystemStats() system.Stats {
+	systemStats := system.Stats{}
 
 	// cpu percent
-	cpuPercent, err := getCpuPercent(cacheTimeMs)
-	if err == nil {
-		systemStats.Cpu = twoDecimals(cpuPercent)
-	} else {
+	cpuPct, err := cpu.Percent(0, false)
+	if err != nil {
 		slog.Error("Error getting cpu percent", "err", err)
+	} else if len(cpuPct) > 0 {
+		systemStats.Cpu = twoDecimals(cpuPct[0])
 	}
 
 	// load average
 	if avgstat, err := load.Avg(); err == nil {
-		systemStats.LoadAvg[0] = avgstat.Load1
-		systemStats.LoadAvg[1] = avgstat.Load5
-		systemStats.LoadAvg[2] = avgstat.Load15
-		slog.Debug("Load average", "5m", avgstat.Load5, "15m", avgstat.Load15)
+		systemStats.LoadAvg1 = twoDecimals(avgstat.Load1)
+		systemStats.LoadAvg5 = twoDecimals(avgstat.Load5)
+		systemStats.LoadAvg15 = twoDecimals(avgstat.Load15)
+		slog.Debug("Load average", "5m", systemStats.LoadAvg5, "15m", systemStats.LoadAvg15)
 	} else {
 		slog.Error("Error getting load average", "err", err)
 	}
@@ -107,22 +94,14 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
 		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
 		// cache + buffers value for default mem calculation
-		// note: gopsutil automatically adds SReclaimable to v.Cached
-		cacheBuff := v.Cached + v.Buffers - v.Shared
-		if cacheBuff <= 0 {
-			cacheBuff = max(v.Total-v.Free-v.Used, 0)
-		}
-		// htop memory calculation overrides (likely outdated as of mid 2025)
+		cacheBuff := v.Total - v.Free - v.Used
+		// htop memory calculation overrides
 		if a.memCalc == "htop" {
-			// cacheBuff = v.Cached + v.Buffers - v.Shared
+			// note: gopsutil automatically adds SReclaimable to v.Cached
+			cacheBuff = v.Cached + v.Buffers - v.Shared
 			v.Used = v.Total - (v.Free + cacheBuff)
 			v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
 		}
-		// if a.memCalc == "legacy" {
-		// 	v.Used = v.Total - v.Free - v.Buffers - v.Cached
-		// 	cacheBuff = v.Total - v.Free - v.Used
-		// 	v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
-		// }
 		// subtract ZFS ARC size from used memory and add as its own category
 		if a.zfs {
 			if arcSize, _ := getARCSize(); arcSize > 0 && arcSize < v.Used {
@@ -138,13 +117,100 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	}
 
 	// disk usage
-	a.updateDiskUsage(&systemStats)
+	for _, stats := range a.fsStats {
+		if d, err := disk.Usage(stats.Mountpoint); err == nil {
+			stats.DiskTotal = bytesToGigabytes(d.Total)
+			stats.DiskUsed = bytesToGigabytes(d.Used)
+			if stats.Root {
+				systemStats.DiskTotal = bytesToGigabytes(d.Total)
+				systemStats.DiskUsed = bytesToGigabytes(d.Used)
+				systemStats.DiskPct = twoDecimals(d.UsedPercent)
+			}
+		} else {
+			// reset stats if error (likely unmounted)
+			slog.Error("Error getting disk stats", "name", stats.Mountpoint, "err", err)
+			stats.DiskTotal = 0
+			stats.DiskUsed = 0
+			stats.TotalRead = 0
+			stats.TotalWrite = 0
+		}
+	}
 
-	// disk i/o (cache-aware per interval)
-	a.updateDiskIo(cacheTimeMs, &systemStats)
+	// disk i/o
+	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
+		for _, d := range ioCounters {
+			stats := a.fsStats[d.Name]
+			if stats == nil {
+				continue
+			}
+			secondsElapsed := time.Since(stats.Time).Seconds()
+			readPerSecond := bytesToMegabytes(float64(d.ReadBytes-stats.TotalRead) / secondsElapsed)
+			writePerSecond := bytesToMegabytes(float64(d.WriteBytes-stats.TotalWrite) / secondsElapsed)
+			// check for invalid values and reset stats if so
+			if readPerSecond < 0 || writePerSecond < 0 || readPerSecond > 50_000 || writePerSecond > 50_000 {
+				slog.Warn("Invalid disk I/O. Resetting.", "name", d.Name, "read", readPerSecond, "write", writePerSecond)
+				a.initializeDiskIoStats(ioCounters)
+				break
+			}
+			stats.Time = time.Now()
+			stats.DiskReadPs = readPerSecond
+			stats.DiskWritePs = writePerSecond
+			stats.TotalRead = d.ReadBytes
+			stats.TotalWrite = d.WriteBytes
+			// if root filesystem, update system stats
+			if stats.Root {
+				systemStats.DiskReadPs = stats.DiskReadPs
+				systemStats.DiskWritePs = stats.DiskWritePs
+			}
+		}
+	}
 
-	// network stats (per cache interval)
-	a.updateNetworkStats(cacheTimeMs, &systemStats)
+	// network stats
+	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 {
+		secondsElapsed := time.Since(a.netIoStats.Time).Seconds()
+		a.netIoStats.Time = time.Now()
+		bytesSent := uint64(0)
+		bytesRecv := 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
+			}
+			bytesSent += v.BytesSent
+			bytesRecv += v.BytesRecv
+		}
+		// add to systemStats
+		sentPerSecond := float64(bytesSent-a.netIoStats.BytesSent) / secondsElapsed
+		recvPerSecond := float64(bytesRecv-a.netIoStats.BytesRecv) / secondsElapsed
+		networkSentPs := bytesToMegabytes(sentPerSecond)
+		networkRecvPs := bytesToMegabytes(recvPerSecond)
+		// 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
+			// update netIoStats
+			a.netIoStats.BytesSent = bytesSent
+			a.netIoStats.BytesRecv = bytesRecv
+		}
+	}
 
 	// temperatures
 	// TODO: maybe refactor to methods on systemStats
@@ -155,7 +221,7 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 		// reset high gpu percent
 		a.systemInfo.GpuPct = 0
 		// get current GPU data
-		if gpuData := a.gpuManager.GetCurrentData(cacheTimeMs); len(gpuData) > 0 {
+		if gpuData := a.gpuManager.GetCurrentData(); len(gpuData) > 0 {
 			systemStats.GPUData = gpuData
 
 			// add temperatures
@@ -184,19 +250,13 @@ func (a *Agent) getSystemStats(cacheTimeMs uint16) system.Stats {
 	}
 
 	// update base system info
-	a.systemInfo.ConnectionType = a.connectionManager.ConnectionType
 	a.systemInfo.Cpu = systemStats.Cpu
-	a.systemInfo.LoadAvg = systemStats.LoadAvg
-	// TODO: remove these in future release in favor of load avg array
-	a.systemInfo.LoadAvg1 = systemStats.LoadAvg[0]
-	a.systemInfo.LoadAvg5 = systemStats.LoadAvg[1]
-	a.systemInfo.LoadAvg15 = systemStats.LoadAvg[2]
+	a.systemInfo.LoadAvg5 = systemStats.LoadAvg5
+	a.systemInfo.LoadAvg15 = systemStats.LoadAvg15
 	a.systemInfo.MemPct = systemStats.MemPct
 	a.systemInfo.DiskPct = systemStats.DiskPct
 	a.systemInfo.Uptime, _ = host.Uptime()
-	// TODO: in future release, remove MB bandwidth values in favor of bytes
 	a.systemInfo.Bandwidth = twoDecimals(systemStats.NetworkSent + systemStats.NetworkRecv)
-	a.systemInfo.BandwidthBytes = systemStats.Bandwidth[0] + systemStats.Bandwidth[1]
 	slog.Debug("sysinfo", "data", a.systemInfo)
 
 	return systemStats

beszel/internal/agent/update.go

@@ -0,0 +1,56 @@
+package agent
+
+import (
+	"beszel"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/rhysd/go-github-selfupdate/selfupdate"
+)
+
+// Update updates beszel-agent to the latest version
+func Update() {
+	var latest *selfupdate.Release
+	var found bool
+	var err error
+	currentVersion := semver.MustParse(beszel.Version)
+	fmt.Println("beszel-agent", currentVersion)
+	fmt.Println("Checking for updates...")
+	updater, _ := selfupdate.NewUpdater(selfupdate.Config{
+		Filters: []string{"beszel-agent"},
+	})
+	latest, found, err = updater.DetectLatest("henrygd/beszel")
+
+	if err != nil {
+		fmt.Println("Error checking for updates:", err)
+		os.Exit(1)
+	}
+
+	if !found {
+		fmt.Println("No updates found")
+		os.Exit(0)
+	}
+
+	fmt.Println("Latest version:", latest.Version)
+
+	if latest.Version.LTE(currentVersion) {
+		fmt.Println("You are up to date")
+		return
+	}
+
+	var binaryPath string
+	fmt.Printf("Updating from %s to %s...\n", currentVersion, latest.Version)
+	binaryPath, err = os.Executable()
+	if err != nil {
+		fmt.Println("Error getting binary path:", err)
+		os.Exit(1)
+	}
+	err = selfupdate.UpdateTo(latest.AssetURL, binaryPath)
+	if err != nil {
+		fmt.Println("Please try rerunning with sudo. Error:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully updated to %s\n\n%s\n", latest.Version, strings.TrimSpace(latest.ReleaseNotes))
+}

beszel/internal/alerts/alerts.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/nicholas-fedor/shoutrrr"
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/mailer"
 )
@@ -46,7 +47,8 @@ type SystemAlertStats struct {
 	NetSent      float64            `json:"ns"`
 	NetRecv      float64            `json:"nr"`
 	Temperatures map[string]float32 `json:"t"`
-	LoadAvg      [3]float64         `json:"la"`
+	LoadAvg5     float64            `json:"l5"`
+	LoadAvg15    float64            `json:"l15"`
 }
 
 type SystemAlertData struct {
@@ -87,21 +89,13 @@ var supportsTitle = map[string]struct{}{
 func NewAlertManager(app hubLike) *AlertManager {
 	am := &AlertManager{
 		hub:        app,
-		alertQueue: make(chan alertTask, 5),
+		alertQueue: make(chan alertTask),
 		stopChan:   make(chan struct{}),
 	}
-	am.bindEvents()
 	go am.startWorker()
 	return am
 }
 
-// Bind events to the alerts collection lifecycle
-func (am *AlertManager) bindEvents() {
-	am.hub.OnRecordAfterUpdateSuccess("alerts").BindFunc(updateHistoryOnAlertUpdate)
-	am.hub.OnRecordAfterDeleteSuccess("alerts").BindFunc(resolveHistoryOnAlertDelete)
-}
-
-// SendAlert sends an alert to the user
 func (am *AlertManager) SendAlert(data AlertMessageData) error {
 	// get user settings
 	record, err := am.hub.FindFirstRecordByFilter(
@@ -205,14 +199,16 @@ func (am *AlertManager) SendShoutrrrAlert(notificationUrl, title, message, link,
 }
 
 func (am *AlertManager) SendTestNotification(e *core.RequestEvent) error {
-	var data struct {
-		URL string `json:"url"`
+	info, _ := e.RequestInfo()
+	if info.Auth == nil {
+		return apis.NewForbiddenError("Forbidden", nil)
 	}
-	err := e.BindBody(&data)
-	if err != nil || data.URL == "" {
-		return e.BadRequestError("URL is required", err)
+	url := e.Request.URL.Query().Get("url")
+	// log.Println("url", url)
+	if url == "" {
+		return e.JSON(200, map[string]string{"err": "URL is required"})
 	}
-	err = am.SendShoutrrrAlert(data.URL, "Test Alert", "This is a notification from Beszel.", am.hub.Settings().Meta.AppURL, "View Beszel")
+	err := am.SendShoutrrrAlert(url, "Test Alert", "This is a notification from Beszel.", am.hub.Settings().Meta.AppURL, "View Beszel")
 	if err != nil {
 		return e.JSON(200, map[string]string{"err": err.Error()})
 	}

beszel/internal/alerts/alerts_status.go

@@ -25,12 +25,7 @@ type alertInfo struct {
 // startWorker is a long-running goroutine that processes alert tasks
 // every x seconds. It must be running to process status alerts.
 func (am *AlertManager) startWorker() {
-	processPendingAlerts := time.Tick(15 * time.Second)
-
-	// 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)
-
+	tick := time.Tick(15 * time.Second)
 	for {
 		select {
 		case <-am.stopChan:
@@ -46,9 +41,7 @@ func (am *AlertManager) startWorker() {
 			case "cancel":
 				am.pendingAlerts.Delete(task.alertRecord.Id)
 			}
-		case <-checkStatusAlerts:
-			resolveStatusAlerts(am.hub)
-		case <-processPendingAlerts:
+		case <-tick:
 			// Check for expired alerts every tick
 			now := time.Now()
 			for key, value := range am.pendingAlerts.Range {
@@ -143,14 +136,6 @@ func (am *AlertManager) handleSystemUp(systemName string, alertRecords []*core.R
 
 // sendStatusAlert sends a status alert ("up" or "down") to the users associated with the alert records.
 func (am *AlertManager) sendStatusAlert(alertStatus string, systemName string, alertRecord *core.Record) error {
-	switch alertStatus {
-	case "up":
-		alertRecord.Set("triggered", false)
-	case "down":
-		alertRecord.Set("triggered", true)
-	}
-	am.hub.Save(alertRecord)
-
 	var emoji string
 	if alertStatus == "up" {
 		emoji = "\u2705" // Green checkmark emoji
@@ -161,51 +146,19 @@ func (am *AlertManager) sendStatusAlert(alertStatus string, systemName string, a
 	title := fmt.Sprintf("Connection to %s is %s %v", systemName, alertStatus, emoji)
 	message := strings.TrimSuffix(title, emoji)
 
-	// if errs := am.hub.ExpandRecord(alertRecord, []string{"user"}, nil); len(errs) > 0 {
-	// 	return errs["user"]
-	// }
-	// user := alertRecord.ExpandedOne("user")
-	// if user == nil {
-	// 	return nil
-	// }
+	if errs := am.hub.ExpandRecord(alertRecord, []string{"user"}, nil); len(errs) > 0 {
+		return errs["user"]
+	}
+	user := alertRecord.ExpandedOne("user")
+	if user == nil {
+		return nil
+	}
 
 	return am.SendAlert(AlertMessageData{
-		UserID:   alertRecord.GetString("user"),
+		UserID:   user.Id,
 		Title:    title,
 		Message:  message,
 		Link:     am.hub.MakeLink("system", systemName),
 		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
-}

beszel/internal/alerts/alerts_system.go

@@ -1,13 +1,12 @@
 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"
@@ -16,7 +15,7 @@ import (
 
 func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *system.CombinedData) error {
 	alertRecords, err := am.hub.FindAllRecords("alerts",
-		dbx.NewExp("system={:system} AND name!='Status'", dbx.Params{"system": systemRecord.Id}),
+		dbx.NewExp("system={:system}", dbx.Params{"system": systemRecord.Id}),
 	)
 	if err != nil || len(alertRecords) == 0 {
 		// log.Println("no alerts found for system")
@@ -55,14 +54,11 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 			}
 			val = data.Info.DashboardTemp
 			unit = "°C"
-		case "LoadAvg1":
-			val = data.Info.LoadAvg[0]
-			unit = ""
 		case "LoadAvg5":
-			val = data.Info.LoadAvg[1]
+			val = data.Info.LoadAvg5
 			unit = ""
 		case "LoadAvg15":
-			val = data.Info.LoadAvg[2]
+			val = data.Info.LoadAvg15
 			unit = ""
 		}
 
@@ -200,12 +196,10 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 					}
 					alert.mapSums[key] += temp
 				}
-			case "LoadAvg1":
-				alert.val += stats.LoadAvg[0]
 			case "LoadAvg5":
-				alert.val += stats.LoadAvg[1]
+				alert.val += stats.LoadAvg5
 			case "LoadAvg15":
-				alert.val += stats.LoadAvg[2]
+				alert.val += stats.LoadAvg15
 			default:
 				continue
 			}
@@ -294,11 +288,18 @@ func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
 		// app.Logger().Error("failed to save alert record", "err", err)
 		return
 	}
-	am.SendAlert(AlertMessageData{
-		UserID:   alert.alertRecord.GetString("user"),
-		Title:    subject,
-		Message:  body,
-		Link:     am.hub.MakeLink("system", systemName),
-		LinkText: "View " + systemName,
-	})
+	// expand the user relation and send the alert
+	if errs := am.hub.ExpandRecord(alert.alertRecord, []string{"user"}, nil); len(errs) > 0 {
+		// app.Logger().Error("failed to expand user relation", "errs", errs)
+		return
+	}
+	if user := alert.alertRecord.ExpandedOne("user"); user != nil {
+		am.SendAlert(AlertMessageData{
+			UserID:   user.Id,
+			Title:    subject,
+			Message:  body,
+			Link:     am.hub.MakeLink("system", systemName),
+			LinkText: "View " + systemName,
+		})
+	}
 }

beszel/internal/common/common-ws.go

@@ -0,0 +1,32 @@
+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/entities/container/container.go

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

beszel/internal/entities/system/system.go

@@ -0,0 +1,104 @@
+package system
+
+// TODO: this is confusing, make common package with common/types common/helpers etc
+
+import (
+	"beszel/internal/entities/container"
+	"time"
+)
+
+type Stats struct {
+	Cpu            float64             `json:"cpu" cbor:"0,keyasint"`
+	MaxCpu         float64             `json:"cpum,omitempty" cbor:"1,keyasint,omitempty"`
+	Mem            float64             `json:"m" cbor:"2,keyasint"`
+	MemUsed        float64             `json:"mu" cbor:"3,keyasint"`
+	MemPct         float64             `json:"mp" cbor:"4,keyasint"`
+	MemBuffCache   float64             `json:"mb" cbor:"5,keyasint"`
+	MemZfsArc      float64             `json:"mz,omitempty" cbor:"6,keyasint,omitempty"` // ZFS ARC memory
+	Swap           float64             `json:"s,omitempty" cbor:"7,keyasint,omitempty"`
+	SwapUsed       float64             `json:"su,omitempty" cbor:"8,keyasint,omitempty"`
+	DiskTotal      float64             `json:"d" cbor:"9,keyasint"`
+	DiskUsed       float64             `json:"du" cbor:"10,keyasint"`
+	DiskPct        float64             `json:"dp" cbor:"11,keyasint"`
+	DiskReadPs     float64             `json:"dr" cbor:"12,keyasint"`
+	DiskWritePs    float64             `json:"dw" cbor:"13,keyasint"`
+	MaxDiskReadPs  float64             `json:"drm,omitempty" cbor:"14,keyasint,omitempty"`
+	MaxDiskWritePs float64             `json:"dwm,omitempty" cbor:"15,keyasint,omitempty"`
+	NetworkSent    float64             `json:"ns" cbor:"16,keyasint"`
+	NetworkRecv    float64             `json:"nr" cbor:"17,keyasint"`
+	MaxNetworkSent float64             `json:"nsm,omitempty" cbor:"18,keyasint,omitempty"`
+	MaxNetworkRecv float64             `json:"nrm,omitempty" cbor:"19,keyasint,omitempty"`
+	Temperatures   map[string]float64  `json:"t,omitempty" cbor:"20,keyasint,omitempty"`
+	ExtraFs        map[string]*FsStats `json:"efs,omitempty" cbor:"21,keyasint,omitempty"`
+	GPUData        map[string]GPUData  `json:"g,omitempty" cbor:"22,keyasint,omitempty"`
+	LoadAvg1       float64             `json:"l1,omitempty" cbor:"23,keyasint,omitempty,omitzero"`
+	LoadAvg5       float64             `json:"l5,omitempty" cbor:"24,keyasint,omitempty,omitzero"`
+	LoadAvg15      float64             `json:"l15,omitempty" cbor:"25,keyasint,omitempty,omitzero"`
+}
+
+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:"-"`
+}
+
+type FsStats struct {
+	Time           time.Time `json:"-"`
+	Root           bool      `json:"-"`
+	Mountpoint     string    `json:"-"`
+	DiskTotal      float64   `json:"d" cbor:"0,keyasint"`
+	DiskUsed       float64   `json:"du" cbor:"1,keyasint"`
+	TotalRead      uint64    `json:"-"`
+	TotalWrite     uint64    `json:"-"`
+	DiskReadPs     float64   `json:"r" cbor:"2,keyasint"`
+	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"`
+}
+
+type NetIoStats struct {
+	BytesRecv uint64
+	BytesSent uint64
+	Time      time.Time
+	Name      string
+}
+
+type Os = uint8
+
+const (
+	Linux Os = iota
+	Darwin
+	Windows
+	Freebsd
+)
+
+type Info struct {
+	Hostname      string  `json:"h" cbor:"0,keyasint"`
+	KernelVersion string  `json:"k,omitempty" cbor:"1,keyasint,omitempty"`
+	Cores         int     `json:"c" cbor:"2,keyasint"`
+	Threads       int     `json:"t,omitempty" cbor:"3,keyasint,omitempty"`
+	CpuModel      string  `json:"m" cbor:"4,keyasint"`
+	Uptime        uint64  `json:"u" cbor:"5,keyasint"`
+	Cpu           float64 `json:"cpu" cbor:"6,keyasint"`
+	MemPct        float64 `json:"mp" cbor:"7,keyasint"`
+	DiskPct       float64 `json:"dp" cbor:"8,keyasint"`
+	Bandwidth     float64 `json:"b" cbor:"9,keyasint"`
+	AgentVersion  string  `json:"v" cbor:"10,keyasint"`
+	Podman        bool    `json:"p,omitempty" cbor:"11,keyasint,omitempty"`
+	GpuPct        float64 `json:"g,omitempty" cbor:"12,keyasint,omitempty"`
+	DashboardTemp float64 `json:"dt,omitempty" cbor:"13,keyasint,omitempty"`
+	Os            Os      `json:"os" cbor:"14,keyasint"`
+	LoadAvg5      float64 `json:"l5,omitempty" cbor:"15,keyasint,omitempty,omitzero"`
+	LoadAvg15     float64 `json:"l15,omitempty" cbor:"16,keyasint,omitempty,omitzero"`
+}
+
+// Final data structure to return to the hub
+type CombinedData struct {
+	Stats      Stats              `json:"stats" cbor:"0,keyasint"`
+	Info       Info               `json:"info" cbor:"1,keyasint"`
+	Containers []*container.Stats `json:"container" cbor:"2,keyasint"`
+}

beszel/internal/hub/agent_connect.go

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

beszel/internal/hub/agent_connect_test.go

@@ -4,6 +4,9 @@
 package hub
 
 import (
+	"beszel/internal/agent"
+	"beszel/internal/common"
+	"beszel/internal/hub/ws"
 	"crypto/ed25519"
 	"fmt"
 	"net/http"
@@ -14,10 +17,6 @@ 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"

beszel/internal/hub/config/config.go

@@ -2,15 +2,15 @@
 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/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/spf13/cast"
 	"gopkg.in/yaml.v3"
@@ -279,8 +279,9 @@ func createFingerprintRecord(app core.App, systemID, token string) error {
 
 // Returns the current config.yml file as a JSON object
 func GetYamlConfig(e *core.RequestEvent) error {
-	if e.Auth.GetString("role") != "admin" {
-		return e.ForbiddenError("Requires admin role", nil)
+	info, _ := e.RequestInfo()
+	if info.Auth == nil || info.Auth.GetString("role") != "admin" {
+		return apis.NewForbiddenError("Forbidden", nil)
 	}
 	configContent, err := generateYAML(e.App)
 	if err != nil {

beszel/internal/hub/config/config_test.go

@@ -4,14 +4,12 @@
 package config_test
 
 import (
+	"beszel/internal/hub/config"
+	"beszel/internal/tests"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/henrygd/beszel/internal/tests"
-
-	"github.com/henrygd/beszel/internal/hub/config"
-
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

beszel/internal/hub/hub.go

@@ -2,23 +2,25 @@
 package hub
 
 import (
+	"beszel"
+	"beszel/internal/alerts"
+	"beszel/internal/hub/config"
+	"beszel/internal/hub/systems"
+	"beszel/internal/records"
+	"beszel/internal/users"
+	"beszel/site"
 	"crypto/ed25519"
 	"encoding/pem"
 	"fmt"
+	"io/fs"
 	"net/http"
+	"net/http/httputil"
 	"net/url"
 	"os"
 	"path"
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel"
-	"github.com/henrygd/beszel/internal/alerts"
-	"github.com/henrygd/beszel/internal/hub/config"
-	"github.com/henrygd/beszel/internal/hub/systems"
-	"github.com/henrygd/beszel/internal/records"
-	"github.com/henrygd/beszel/internal/users"
-
 	"github.com/google/uuid"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
@@ -69,8 +71,6 @@ func (h *Hub) StartHub() error {
 		if err := config.SyncSystems(e); err != nil {
 			return err
 		}
-		// register middlewares
-		h.registerMiddlewares(e)
 		// register api routes
 		if err := h.registerApiRoutes(e); err != nil {
 			return err
@@ -120,19 +120,7 @@ func (h *Hub) initialize(e *core.ServeEvent) error {
 		return err
 	}
 	// set auth settings
-	if err := setCollectionAuthSettings(e.App); err != nil {
-		return err
-	}
-	return nil
-}
-
-// setCollectionAuthSettings sets up default authentication settings for the app
-func setCollectionAuthSettings(app core.App) error {
-	usersCollection, err := app.FindCollectionByNameOrId("users")
-	if err != nil {
-		return err
-	}
-	superusersCollection, err := app.FindCollectionByNameOrId(core.CollectionNameSuperusers)
+	usersCollection, err := e.App.FindCollectionByNameOrId("users")
 	if err != nil {
 		return err
 	}
@@ -140,6 +128,10 @@ func setCollectionAuthSettings(app core.App) error {
 	disablePasswordAuth, _ := GetEnv("DISABLE_PASSWORD_AUTH")
 	usersCollection.PasswordAuth.Enabled = disablePasswordAuth != "true"
 	usersCollection.PasswordAuth.IdentityFields = []string{"email"}
+	// disable oauth if no providers are configured (todo: remove this in post 0.9.0 release)
+	if usersCollection.OAuth2.Enabled {
+		usersCollection.OAuth2.Enabled = len(usersCollection.OAuth2.Providers) > 0
+	}
 	// allow oauth user creation if USER_CREATION is set
 	if userCreation, _ := GetEnv("USER_CREATION"); userCreation == "true" {
 		cr := "@request.context = 'oauth2'"
@@ -147,22 +139,11 @@ func setCollectionAuthSettings(app core.App) error {
 	} else {
 		usersCollection.CreateRule = nil
 	}
-	// enable mfaOtp mfa if MFA_OTP env var is set
-	mfaOtp, _ := GetEnv("MFA_OTP")
-	usersCollection.OTP.Length = 6
-	superusersCollection.OTP.Length = 6
-	usersCollection.OTP.Enabled = mfaOtp == "true"
-	usersCollection.MFA.Enabled = mfaOtp == "true"
-	superusersCollection.OTP.Enabled = mfaOtp == "true" || mfaOtp == "superusers"
-	superusersCollection.MFA.Enabled = mfaOtp == "true" || mfaOtp == "superusers"
-	if err := app.Save(superusersCollection); err != nil {
-		return err
-	}
-	if err := app.Save(usersCollection); err != nil {
+	if err := e.App.Save(usersCollection); err != nil {
 		return err
 	}
 	// allow all users to access systems if SHARE_ALL_SYSTEMS is set
-	systemsCollection, err := app.FindCollectionByNameOrId("systems")
+	systemsCollection, err := e.App.FindCachedCollectionByNameOrId("systems")
 	if err != nil {
 		return err
 	}
@@ -177,98 +158,114 @@ func setCollectionAuthSettings(app core.App) error {
 	systemsCollection.ViewRule = &systemsReadRule
 	systemsCollection.UpdateRule = &updateDeleteRule
 	systemsCollection.DeleteRule = &updateDeleteRule
-	return app.Save(systemsCollection)
+	if err := e.App.Save(systemsCollection); err != nil {
+		return err
+	}
+	return nil
+}
+
+// startServer sets up the server for Beszel
+func (h *Hub) startServer(se *core.ServeEvent) error {
+	// TODO: exclude dev server from production binary
+	switch h.IsDev() {
+	case true:
+		proxy := httputil.NewSingleHostReverseProxy(&url.URL{
+			Scheme: "http",
+			Host:   "localhost:5173",
+		})
+		se.Router.GET("/{path...}", func(e *core.RequestEvent) error {
+			proxy.ServeHTTP(e.Response, e.Request)
+			return nil
+		})
+	default:
+		// parse app url
+		parsedURL, err := url.Parse(h.appURL)
+		if err != nil {
+			return err
+		}
+		// fix base paths in html if using subpath
+		basePath := strings.TrimSuffix(parsedURL.Path, "/") + "/"
+		indexFile, _ := fs.ReadFile(site.DistDirFS, "index.html")
+		indexContent := strings.ReplaceAll(string(indexFile), "./", basePath)
+		indexContent = strings.Replace(indexContent, "{{V}}", beszel.Version, 1)
+		indexContent = strings.Replace(indexContent, "{{HUB_URL}}", h.appURL, 1)
+		// set up static asset serving
+		staticPaths := [2]string{"/static/", "/assets/"}
+		serveStatic := apis.Static(site.DistDirFS, false)
+		// get CSP configuration
+		csp, cspExists := GetEnv("CSP")
+		// add route
+		se.Router.GET("/{path...}", func(e *core.RequestEvent) error {
+			// serve static assets if path is in staticPaths
+			for i := range staticPaths {
+				if strings.Contains(e.Request.URL.Path, staticPaths[i]) {
+					e.Response.Header().Set("Cache-Control", "public, max-age=2592000")
+					return serveStatic(e)
+				}
+			}
+			if cspExists {
+				e.Response.Header().Del("X-Frame-Options")
+				e.Response.Header().Set("Content-Security-Policy", csp)
+			}
+			return e.HTML(http.StatusOK, indexContent)
+		})
+	}
+	return nil
 }
 
 // registerCronJobs sets up scheduled tasks
 func (h *Hub) registerCronJobs(_ *core.ServeEvent) error {
-	// delete old system_stats and alerts_history records once every hour
+	// delete old records once every hour
 	h.Cron().MustAdd("delete old records", "8 * * * *", h.rm.DeleteOldRecords)
 	// create longer records every 10 minutes
 	h.Cron().MustAdd("create longer records", "*/10 * * * *", h.rm.CreateLongerRecords)
 	return nil
 }
 
-// custom middlewares
-func (h *Hub) registerMiddlewares(se *core.ServeEvent) {
-	// authorizes request with user matching the provided email
-	authorizeRequestWithEmail := func(e *core.RequestEvent, email string) (err error) {
-		if e.Auth != nil || email == "" {
-			return e.Next()
-		}
-		isAuthRefresh := e.Request.URL.Path == "/api/collections/users/auth-refresh" && e.Request.Method == http.MethodPost
-		e.Auth, err = e.App.FindFirstRecordByData("users", "email", email)
-		if err != nil || !isAuthRefresh {
-			return e.Next()
-		}
-		// auth refresh endpoint, make sure token is set in header
-		token, _ := e.Auth.NewAuthToken()
-		e.Request.Header.Set("Authorization", token)
-		return e.Next()
-	}
-	// authenticate with trusted header
-	if autoLogin, _ := GetEnv("AUTO_LOGIN"); autoLogin != "" {
-		se.Router.BindFunc(func(e *core.RequestEvent) error {
-			return authorizeRequestWithEmail(e, autoLogin)
-		})
-	}
-	// authenticate with trusted header
-	if trustedHeader, _ := GetEnv("TRUSTED_AUTH_HEADER"); trustedHeader != "" {
-		se.Router.BindFunc(func(e *core.RequestEvent) error {
-			return authorizeRequestWithEmail(e, e.Request.Header.Get(trustedHeader))
-		})
-	}
-}
-
 // custom api routes
 func (h *Hub) registerApiRoutes(se *core.ServeEvent) error {
-	// auth protected routes
-	apiAuth := se.Router.Group("/api/beszel")
-	apiAuth.Bind(apis.RequireAuth())
-	// auth optional routes
-	apiNoAuth := se.Router.Group("/api/beszel")
-
-	// create first user endpoint only needed if no users exist
-	if totalUsers, _ := se.App.CountRecords("users"); totalUsers == 0 {
-		apiNoAuth.POST("/create-user", h.um.CreateFirstUser)
-	}
-	// check if first time setup on login page
-	apiNoAuth.GET("/first-run", func(e *core.RequestEvent) error {
-		total, err := e.App.CountRecords("users")
-		return e.JSON(http.StatusOK, map[string]bool{"firstRun": err == nil && total == 0})
-	})
-	// get public key and version
-	apiAuth.GET("/getkey", func(e *core.RequestEvent) error {
+	// returns public key and version
+	se.Router.GET("/api/beszel/getkey", func(e *core.RequestEvent) error {
+		info, _ := e.RequestInfo()
+		if info.Auth == nil {
+			return apis.NewForbiddenError("Forbidden", nil)
+		}
 		return e.JSON(http.StatusOK, map[string]string{"key": h.pubKey, "v": beszel.Version})
 	})
+	// check if first time setup on login page
+	se.Router.GET("/api/beszel/first-run", func(e *core.RequestEvent) error {
+		total, err := h.CountRecords("users")
+		return e.JSON(http.StatusOK, map[string]bool{"firstRun": err == nil && total == 0})
+	})
 	// send test notification
-	apiAuth.POST("/test-notification", h.SendTestNotification)
-	// get config.yml content
-	apiAuth.GET("/config-yaml", config.GetYamlConfig)
+	se.Router.GET("/api/beszel/send-test-notification", h.SendTestNotification)
+	// API endpoint to get config.yml content
+	se.Router.GET("/api/beszel/config-yaml", config.GetYamlConfig)
 	// handle agent websocket connection
-	apiNoAuth.GET("/agent-connect", h.handleAgentConnect)
+	se.Router.GET("/api/beszel/agent-connect", h.handleAgentConnect)
 	// get or create universal tokens
-	apiAuth.GET("/universal-token", h.getUniversalToken)
-	// update / delete user alerts
-	apiAuth.POST("/user-alerts", alerts.UpsertUserAlerts)
-	apiAuth.DELETE("/user-alerts", alerts.DeleteUserAlerts)
-	// get container logs
-	apiAuth.GET("/containers/logs", h.getContainerLogs)
-	// get container info
-	apiAuth.GET("/containers/info", h.getContainerInfo)
-	// get SMART data
-	apiAuth.GET("/smart", h.getSmartData)
+	se.Router.GET("/api/beszel/universal-token", h.getUniversalToken)
+	// create first user endpoint only needed if no users exist
+	if totalUsers, _ := h.CountRecords("users"); totalUsers == 0 {
+		se.Router.POST("/api/beszel/create-user", h.um.CreateFirstUser)
+	}
 	return nil
 }
 
 // Handler for universal token API endpoint (create, read, delete)
 func (h *Hub) getUniversalToken(e *core.RequestEvent) error {
+	info, err := e.RequestInfo()
+	if err != nil || info.Auth == nil {
+		return apis.NewForbiddenError("Forbidden", nil)
+	}
+
 	tokenMap := universalTokenMap.GetMap()
-	userID := e.Auth.Id
+	userID := info.Auth.Id
 	query := e.Request.URL.Query()
 	token := query.Get("token")
+	tokenSet := token != ""
 
-	if token == "" {
+	if !tokenSet {
 		// return existing token if it exists
 		if token, _, ok := tokenMap.GetByValue(userID); ok {
 			return e.JSON(http.StatusOK, map[string]any{"token": token, "active": true})
@@ -288,59 +285,6 @@ func (h *Hub) getUniversalToken(e *core.RequestEvent) error {
 	return e.JSON(http.StatusOK, response)
 }
 
-// containerRequestHandler handles both container logs and info requests
-func (h *Hub) containerRequestHandler(e *core.RequestEvent, fetchFunc func(*systems.System, string) (string, error), responseKey string) error {
-	systemID := e.Request.URL.Query().Get("system")
-	containerID := e.Request.URL.Query().Get("container")
-
-	if systemID == "" || containerID == "" {
-		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system and container parameters are required"})
-	}
-
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return e.JSON(http.StatusNotFound, map[string]string{"error": "system not found"})
-	}
-
-	data, err := fetchFunc(system, containerID)
-	if err != nil {
-		return e.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
-	}
-
-	return e.JSON(http.StatusOK, map[string]string{responseKey: data})
-}
-
-// getContainerLogs handles GET /api/beszel/containers/logs requests
-func (h *Hub) getContainerLogs(e *core.RequestEvent) error {
-	return h.containerRequestHandler(e, func(system *systems.System, containerID string) (string, error) {
-		return system.FetchContainerLogsFromAgent(containerID)
-	}, "logs")
-}
-
-func (h *Hub) getContainerInfo(e *core.RequestEvent) error {
-	return h.containerRequestHandler(e, func(system *systems.System, containerID string) (string, error) {
-		return system.FetchContainerInfoFromAgent(containerID)
-	}, "info")
-}
-
-// getSmartData handles GET /api/beszel/smart requests
-func (h *Hub) getSmartData(e *core.RequestEvent) error {
-	systemID := e.Request.URL.Query().Get("system")
-	if systemID == "" {
-		return e.JSON(http.StatusBadRequest, map[string]string{"error": "system parameter is required"})
-	}
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return e.JSON(http.StatusNotFound, map[string]string{"error": "system not found"})
-	}
-	data, err := system.FetchSmartDataFromAgent()
-	if err != nil {
-		return e.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
-	}
-	e.Response.Header().Set("Cache-Control", "public, max-age=60")
-	return e.JSON(http.StatusOK, data)
-}
-
 // generates key pair if it doesn't exist and returns signer
 func (h *Hub) GetSSHKey(dataDir string) (ssh.Signer, error) {
 	if h.signer != nil {

beszel/internal/hub/hub_test.go

@@ -0,0 +1,256 @@
+//go:build testing
+// +build testing
+
+package hub_test
+
+import (
+	"beszel/internal/tests"
+	"testing"
+
+	"crypto/ed25519"
+	"encoding/pem"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/crypto/ssh"
+)
+
+func getTestHub(t testing.TB) *tests.TestHub {
+	hub, _ := tests.NewTestHub(t.TempDir())
+	return hub
+}
+
+func TestMakeLink(t *testing.T) {
+	hub := getTestHub(t)
+
+	tests := []struct {
+		name     string
+		appURL   string
+		parts    []string
+		expected string
+	}{
+		{
+			name:     "no parts, no trailing slash in AppURL",
+			appURL:   "http://localhost:8090",
+			parts:    []string{},
+			expected: "http://localhost:8090",
+		},
+		{
+			name:     "no parts, with trailing slash in AppURL",
+			appURL:   "http://localhost:8090/",
+			parts:    []string{},
+			expected: "http://localhost:8090", // TrimSuffix should handle the trailing slash
+		},
+		{
+			name:     "one part",
+			appURL:   "http://example.com",
+			parts:    []string{"one"},
+			expected: "http://example.com/one",
+		},
+		{
+			name:     "multiple parts",
+			appURL:   "http://example.com",
+			parts:    []string{"alpha", "beta", "gamma"},
+			expected: "http://example.com/alpha/beta/gamma",
+		},
+		{
+			name:     "parts with spaces needing escaping",
+			appURL:   "http://example.com",
+			parts:    []string{"path with spaces", "another part"},
+			expected: "http://example.com/path%20with%20spaces/another%20part",
+		},
+		{
+			name:     "parts with slashes needing escaping",
+			appURL:   "http://example.com",
+			parts:    []string{"a/b", "c"},
+			expected: "http://example.com/a%2Fb/c", // url.PathEscape escapes '/'
+		},
+		{
+			name:     "AppURL with subpath, no trailing slash",
+			appURL:   "http://localhost/sub",
+			parts:    []string{"resource"},
+			expected: "http://localhost/sub/resource",
+		},
+		{
+			name:     "AppURL with subpath, with trailing slash",
+			appURL:   "http://localhost/sub/",
+			parts:    []string{"item"},
+			expected: "http://localhost/sub/item",
+		},
+		{
+			name:     "empty parts in the middle",
+			appURL:   "http://localhost",
+			parts:    []string{"first", "", "third"},
+			expected: "http://localhost/first/third",
+		},
+		{
+			name:     "leading and trailing empty parts",
+			appURL:   "http://localhost",
+			parts:    []string{"", "path", ""},
+			expected: "http://localhost/path",
+		},
+		{
+			name:     "parts with various special characters",
+			appURL:   "https://test.dev/",
+			parts:    []string{"p@th?", "key=value&"},
+			expected: "https://test.dev/p@th%3F/key=value&",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Store original app URL and restore it after the test
+			originalAppURL := hub.Settings().Meta.AppURL
+			hub.Settings().Meta.AppURL = tt.appURL
+			defer func() { hub.Settings().Meta.AppURL = originalAppURL }()
+
+			got := hub.MakeLink(tt.parts...)
+			assert.Equal(t, tt.expected, got, "MakeLink generated URL does not match expected")
+		})
+	}
+}
+
+func TestGetSSHKey(t *testing.T) {
+	hub := getTestHub(t)
+
+	// Test Case 1: Key generation (no existing key)
+	t.Run("KeyGeneration", func(t *testing.T) {
+		tempDir := t.TempDir()
+
+		// Ensure pubKey is initially empty or different to ensure GetSSHKey sets it
+		hub.SetPubkey("")
+
+		signer, err := hub.GetSSHKey(tempDir)
+		assert.NoError(t, err, "GetSSHKey should not error when generating a new key")
+		assert.NotNil(t, signer, "GetSSHKey should return a non-nil signer")
+
+		// Check if private key file was created
+		privateKeyPath := filepath.Join(tempDir, "id_ed25519")
+		info, err := os.Stat(privateKeyPath)
+		assert.NoError(t, err, "Private key file should be created")
+		assert.False(t, info.IsDir(), "Private key path should be a file, not a directory")
+
+		// Check if h.pubKey was set
+		assert.NotEmpty(t, hub.GetPubkey(), "h.pubKey should be set after key generation")
+		assert.True(t, strings.HasPrefix(hub.GetPubkey(), "ssh-ed25519 "), "h.pubKey should start with 'ssh-ed25519 '")
+
+		// Verify the generated private key is parsable
+		keyData, err := os.ReadFile(privateKeyPath)
+		require.NoError(t, err)
+		_, err = ssh.ParsePrivateKey(keyData)
+		assert.NoError(t, err, "Generated private key should be parsable by ssh.ParsePrivateKey")
+	})
+
+	// Test Case 2: Existing key
+	t.Run("ExistingKey", func(t *testing.T) {
+		tempDir := t.TempDir()
+
+		// Manually create a valid key pair for the test
+		rawPubKey, rawPrivKey, err := ed25519.GenerateKey(nil)
+		require.NoError(t, err, "Failed to generate raw ed25519 key pair for pre-existing key test")
+
+		// Marshal the private key into OpenSSH PEM format
+		pemBlock, err := ssh.MarshalPrivateKey(rawPrivKey, "")
+		require.NoError(t, err, "Failed to marshal private key to PEM block for pre-existing key test")
+
+		privateKeyBytes := pem.EncodeToMemory(pemBlock)
+		require.NotNil(t, privateKeyBytes, "PEM encoded private key bytes should not be nil")
+
+		privateKeyPath := filepath.Join(tempDir, "id_ed25519")
+		err = os.WriteFile(privateKeyPath, privateKeyBytes, 0600)
+		require.NoError(t, err, "Failed to write pre-existing private key")
+
+		// Determine the expected public key string
+		sshPubKey, err := ssh.NewPublicKey(rawPubKey)
+		require.NoError(t, err)
+		expectedPubKeyStr := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(sshPubKey)))
+
+		// Reset h.pubKey to ensure it's set by GetSSHKey from the file
+		hub.SetPubkey("")
+
+		signer, err := hub.GetSSHKey(tempDir)
+		assert.NoError(t, err, "GetSSHKey should not error when reading an existing key")
+		assert.NotNil(t, signer, "GetSSHKey should return a non-nil signer for an existing key")
+
+		// Check if h.pubKey was set correctly to the public key from the file
+		assert.Equal(t, expectedPubKeyStr, hub.GetPubkey(), "h.pubKey should match the existing public key")
+
+		// Verify the signer's public key matches the original public key
+		signerPubKey := signer.PublicKey()
+		marshaledSignerPubKey := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(signerPubKey)))
+		assert.Equal(t, expectedPubKeyStr, marshaledSignerPubKey, "Signer's public key should match the existing public key")
+	})
+
+	// Test Case 3: Error cases
+	t.Run("ErrorCases", func(t *testing.T) {
+		tests := []struct {
+			name       string
+			setupFunc  func(dir string) error
+			errorCheck func(t *testing.T, err error)
+		}{
+			{
+				name: "CorruptedKey",
+				setupFunc: func(dir string) error {
+					return os.WriteFile(filepath.Join(dir, "id_ed25519"), []byte("this is not a valid SSH key"), 0600)
+				},
+				errorCheck: func(t *testing.T, err error) {
+					assert.Error(t, err)
+					assert.Contains(t, err.Error(), "ssh: no key found")
+				},
+			},
+			{
+				name: "PermissionDenied",
+				setupFunc: func(dir string) error {
+					// Create the key file
+					keyPath := filepath.Join(dir, "id_ed25519")
+					if err := os.WriteFile(keyPath, []byte("dummy content"), 0600); err != nil {
+						return err
+					}
+					// Make it read-only (can't be opened for writing in case a new key needs to be written)
+					return os.Chmod(keyPath, 0400)
+				},
+				errorCheck: func(t *testing.T, err error) {
+					// On read-only key, the parser will attempt to parse it and fail with "ssh: no key found"
+					assert.Error(t, err)
+				},
+			},
+			{
+				name: "EmptyFile",
+				setupFunc: func(dir string) error {
+					// Create an empty file
+					return os.WriteFile(filepath.Join(dir, "id_ed25519"), []byte{}, 0600)
+				},
+				errorCheck: func(t *testing.T, err error) {
+					assert.Error(t, err)
+					// The error from attempting to parse an empty file
+					assert.Contains(t, err.Error(), "ssh: no key found")
+				},
+			},
+		}
+
+		for _, tc := range tests {
+			t.Run(tc.name, func(t *testing.T) {
+				tempDir := t.TempDir()
+
+				// Setup the test case
+				err := tc.setupFunc(tempDir)
+				require.NoError(t, err, "Setup failed")
+
+				// Reset h.pubKey before each test case
+				hub.SetPubkey("")
+
+				// Attempt to get SSH key
+				_, err = hub.GetSSHKey(tempDir)
+
+				// Verify the error
+				tc.errorCheck(t, err)
+
+				// Check that pubKey was not set in error cases
+				assert.Empty(t, hub.GetPubkey(), "h.pubKey should not be set if there was an error")
+			})
+		}
+	})
+}

beszel/internal/hub/hub_test_helpers.go

@@ -3,7 +3,7 @@
 
 package hub
 
-import "github.com/henrygd/beszel/internal/hub/systems"
+import "beszel/internal/hub/systems"
 
 // TESTING ONLY: GetSystemManager returns the system manager
 func (h *Hub) GetSystemManager() *systems.SystemManager {

beszel/internal/hub/systems/system.go

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

beszel/internal/hub/systems/system_manager.go

@@ -1,18 +1,14 @@
 package systems
 
 import (
+	"beszel"
+	"beszel/internal/common"
+	"beszel/internal/entities/system"
+	"beszel/internal/hub/ws"
 	"errors"
 	"fmt"
 	"time"
 
-	"github.com/henrygd/beszel/internal/hub/ws"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-
-	"github.com/henrygd/beszel/internal/common"
-
-	"github.com/henrygd/beszel"
-
 	"github.com/blang/semver"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/store"
@@ -34,8 +30,10 @@ const (
 	sessionTimeout = 4 * time.Second
 )
 
-// errSystemExists is returned when attempting to add a system that already exists
-var errSystemExists = errors.New("system exists")
+var (
+	// errSystemExists is returned when attempting to add a system that already exists
+	errSystemExists = errors.New("system exists")
+)
 
 // SystemManager manages a collection of monitored systems and their connections.
 // It handles system lifecycle, status updates, and maintains both SSH and WebSocket connections.
@@ -63,15 +61,6 @@ func NewSystemManager(hub hubLike) *SystemManager {
 	}
 }
 
-// GetSystem returns a system by ID from the store
-func (sm *SystemManager) GetSystem(systemID string) (*System, error) {
-	sys, ok := sm.systems.GetOk(systemID)
-	if !ok {
-		return nil, fmt.Errorf("system not found")
-	}
-	return sys, nil
-}
-
 // Initialize sets up the system manager by binding event hooks and starting existing systems.
 // It configures SSH client settings and begins monitoring all non-paused systems from the database.
 // Systems are started with staggered delays to prevent overwhelming the hub during startup.
@@ -115,8 +104,6 @@ func (sm *SystemManager) bindEventHooks() {
 	sm.hub.OnRecordAfterUpdateSuccess("systems").BindFunc(sm.onRecordAfterUpdateSuccess)
 	sm.hub.OnRecordAfterDeleteSuccess("systems").BindFunc(sm.onRecordAfterDeleteSuccess)
 	sm.hub.OnRecordAfterUpdateSuccess("fingerprints").BindFunc(sm.onTokenRotated)
-	sm.hub.OnRealtimeSubscribeRequest().BindFunc(sm.onRealtimeSubscribeRequest)
-	sm.hub.OnRealtimeConnectRequest().BindFunc(sm.onRealtimeConnectRequest)
 }
 
 // onTokenRotated handles fingerprint token rotation events.
@@ -172,10 +159,8 @@ func (sm *SystemManager) onRecordUpdate(e *core.RecordEvent) error {
 // - down: Triggers status change alerts
 func (sm *SystemManager) onRecordAfterUpdateSuccess(e *core.RecordEvent) error {
 	newStatus := e.Record.GetString("status")
-	prevStatus := pending
 	system, ok := sm.systems.GetOk(e.Record.Id)
 	if ok {
-		prevStatus = system.Status
 		system.Status = newStatus
 	}
 
@@ -197,7 +182,6 @@ func (sm *SystemManager) onRecordAfterUpdateSuccess(e *core.RecordEvent) error {
 		if err := sm.AddRecord(e.Record, nil); err != nil {
 			e.App.Logger().Error("Error adding record", "err", err)
 		}
-		_ = deactivateAlerts(e.App, e.Record.Id)
 		return e.Next()
 	}
 
@@ -206,6 +190,8 @@ func (sm *SystemManager) onRecordAfterUpdateSuccess(e *core.RecordEvent) error {
 		return sm.AddRecord(e.Record, nil)
 	}
 
+	prevStatus := system.Status
+
 	// Trigger system alerts when system comes online
 	if newStatus == up {
 		if err := sm.hub.HandleSystemAlerts(e.Record, system.data); err != nil {

beszel/internal/hub/systems/systems_test.go

@@ -4,17 +4,16 @@
 package systems_test
 
 import (
+	"beszel/internal/entities/container"
+	"beszel/internal/entities/system"
+	"beszel/internal/hub/systems"
+	"beszel/internal/tests"
 	"fmt"
 	"sync"
 	"testing"
 	"testing/synctest"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/system"
-	"github.com/henrygd/beszel/internal/hub/systems"
-	"github.com/henrygd/beszel/internal/tests"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -30,7 +29,7 @@ func TestSystemManagerNew(t *testing.T) {
 	user, err := tests.CreateUser(hub, "test@test.com", "testtesttest")
 	require.NoError(t, err)
 
-	synctest.Test(t, func(t *testing.T) {
+	synctest.Run(func() {
 		sm.Initialize()
 
 		record, err := tests.CreateRecord(hub, "systems", map[string]any{
@@ -111,11 +110,9 @@ func TestSystemManagerNew(t *testing.T) {
 		err = hub.Delete(record)
 		require.NoError(t, err)
 		assert.False(t, sm.HasSystem(record.Id), "System should not exist in the store after deletion")
-	})
 
-	testOld(t, hub)
+		testOld(t, hub)
 
-	synctest.Test(t, func(t *testing.T) {
 		time.Sleep(time.Second)
 		synctest.Wait()
 

beszel/internal/hub/systems/systems_test_helpers.go

@@ -4,10 +4,9 @@
 package systems
 
 import (
+	entities "beszel/internal/entities/system"
 	"context"
 	"fmt"
-
-	entities "github.com/henrygd/beszel/internal/entities/system"
 )
 
 // TESTING ONLY: GetSystemCount returns the number of systems in the store
@@ -101,10 +100,3 @@ func (sm *SystemManager) SetSystemStatusInDB(systemID string, status string) boo
 
 	return true
 }
-
-// TESTING ONLY: RemoveAllSystems removes all systems from the store
-func (sm *SystemManager) RemoveAllSystems() {
-	for _, system := range sm.systems.GetAll() {
-		sm.RemoveSystem(system.Id)
-	}
-}

beszel/internal/hub/update.go

@@ -0,0 +1,57 @@
+package hub
+
+import (
+	"beszel"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/rhysd/go-github-selfupdate/selfupdate"
+	"github.com/spf13/cobra"
+)
+
+// Update updates beszel to the latest version
+func Update(_ *cobra.Command, _ []string) {
+	var latest *selfupdate.Release
+	var found bool
+	var err error
+	currentVersion := semver.MustParse(beszel.Version)
+	fmt.Println("beszel", currentVersion)
+	fmt.Println("Checking for updates...")
+	updater, _ := selfupdate.NewUpdater(selfupdate.Config{
+		Filters: []string{"beszel_"},
+	})
+	latest, found, err = updater.DetectLatest("henrygd/beszel")
+
+	if err != nil {
+		fmt.Println("Error checking for updates:", err)
+		os.Exit(1)
+	}
+
+	if !found {
+		fmt.Println("No updates found")
+		os.Exit(0)
+	}
+
+	fmt.Println("Latest version:", latest.Version)
+
+	if latest.Version.LTE(currentVersion) {
+		fmt.Println("You are up to date")
+		return
+	}
+
+	var binaryPath string
+	fmt.Printf("Updating from %s to %s...\n", currentVersion, latest.Version)
+	binaryPath, err = os.Executable()
+	if err != nil {
+		fmt.Println("Error getting binary path:", err)
+		os.Exit(1)
+	}
+	err = selfupdate.UpdateTo(latest.AssetURL, binaryPath)
+	if err != nil {
+		fmt.Println("Please try rerunning with sudo. Error:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully updated to %s\n\n%s\n", latest.Version, strings.TrimSpace(latest.ReleaseNotes))
+}

beszel/internal/hub/ws/ws.go

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

beszel/internal/records/records.go

@@ -2,6 +2,8 @@
 package records
 
 import (
+	"beszel/internal/entities/container"
+	"beszel/internal/entities/system"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -9,9 +11,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/system"
-
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 )
@@ -40,14 +39,12 @@ type StatsRecord struct {
 }
 
 // global variables for reusing allocations
-var (
-	statsRecord    StatsRecord
-	containerStats []container.Stats
-	sumStats       system.Stats
-	tempStats      system.Stats
-	queryParams    = make(dbx.Params, 1)
-	containerSums  = make(map[string]*container.Stats)
-)
+var statsRecord StatsRecord
+var containerStats []container.Stats
+var sumStats system.Stats
+var tempStats system.Stats
+var queryParams = make(dbx.Params, 1)
+var containerSums = make(map[string]*container.Stats)
 
 // Create longer records by averaging shorter records
 func (rm *RecordManager) CreateLongerRecords() {
@@ -175,8 +172,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 	tempStats = system.Stats{}
 	sum := &sumStats
 	stats := &tempStats
-	// necessary because uint8 is not big enough for the sum
-	batterySum := 0
 
 	count := float64(len(records))
 	tempCount := float64(0)
@@ -208,39 +203,12 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.DiskWritePs += stats.DiskWritePs
 		sum.NetworkSent += stats.NetworkSent
 		sum.NetworkRecv += stats.NetworkRecv
-		sum.LoadAvg[0] += stats.LoadAvg[0]
-		sum.LoadAvg[1] += stats.LoadAvg[1]
-		sum.LoadAvg[2] += stats.LoadAvg[2]
-		sum.Bandwidth[0] += stats.Bandwidth[0]
-		sum.Bandwidth[1] += stats.Bandwidth[1]
-		sum.DiskIO[0] += stats.DiskIO[0]
-		sum.DiskIO[1] += stats.DiskIO[1]
-		batterySum += int(stats.Battery[0])
-		sum.Battery[1] = stats.Battery[1]
 		// Set peak values
 		sum.MaxCpu = max(sum.MaxCpu, stats.MaxCpu, stats.Cpu)
-		sum.MaxMem = max(sum.MaxMem, stats.MaxMem, stats.MemUsed)
 		sum.MaxNetworkSent = max(sum.MaxNetworkSent, stats.MaxNetworkSent, stats.NetworkSent)
 		sum.MaxNetworkRecv = max(sum.MaxNetworkRecv, stats.MaxNetworkRecv, stats.NetworkRecv)
 		sum.MaxDiskReadPs = max(sum.MaxDiskReadPs, stats.MaxDiskReadPs, stats.DiskReadPs)
 		sum.MaxDiskWritePs = max(sum.MaxDiskWritePs, stats.MaxDiskWritePs, stats.DiskWritePs)
-		sum.MaxBandwidth[0] = max(sum.MaxBandwidth[0], stats.MaxBandwidth[0], stats.Bandwidth[0])
-		sum.MaxBandwidth[1] = max(sum.MaxBandwidth[1], stats.MaxBandwidth[1], stats.Bandwidth[1])
-		sum.MaxDiskIO[0] = max(sum.MaxDiskIO[0], stats.MaxDiskIO[0], stats.DiskIO[0])
-		sum.MaxDiskIO[1] = max(sum.MaxDiskIO[1], stats.MaxDiskIO[1], stats.DiskIO[1])
-
-		// Accumulate network interfaces
-		if sum.NetworkInterfaces == nil {
-			sum.NetworkInterfaces = make(map[string][4]uint64, len(stats.NetworkInterfaces))
-		}
-		for key, value := range stats.NetworkInterfaces {
-			sum.NetworkInterfaces[key] = [4]uint64{
-				sum.NetworkInterfaces[key][0] + value[0],
-				sum.NetworkInterfaces[key][1] + value[1],
-				max(sum.NetworkInterfaces[key][2], value[2]),
-				max(sum.NetworkInterfaces[key][3], value[3]),
-			}
-		}
 
 		// Accumulate temperatures
 		if stats.Temperatures != nil {
@@ -288,16 +256,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 				gpu.Usage += value.Usage
 				gpu.Power += value.Power
 				gpu.Count += value.Count
-
-				if value.Engines != nil {
-					if gpu.Engines == nil {
-						gpu.Engines = make(map[string]float64, len(value.Engines))
-					}
-					for engineKey, engineValue := range value.Engines {
-						gpu.Engines[engineKey] += engineValue
-					}
-				}
-
 				sum.GPUData[id] = gpu
 			}
 		}
@@ -318,28 +276,8 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 		sum.DiskPct = twoDecimals(sum.DiskPct / count)
 		sum.DiskReadPs = twoDecimals(sum.DiskReadPs / count)
 		sum.DiskWritePs = twoDecimals(sum.DiskWritePs / count)
-		sum.DiskIO[0] = sum.DiskIO[0] / uint64(count)
-		sum.DiskIO[1] = sum.DiskIO[1] / uint64(count)
 		sum.NetworkSent = twoDecimals(sum.NetworkSent / count)
 		sum.NetworkRecv = twoDecimals(sum.NetworkRecv / count)
-		sum.LoadAvg[0] = twoDecimals(sum.LoadAvg[0] / count)
-		sum.LoadAvg[1] = twoDecimals(sum.LoadAvg[1] / count)
-		sum.LoadAvg[2] = twoDecimals(sum.LoadAvg[2] / count)
-		sum.Bandwidth[0] = sum.Bandwidth[0] / uint64(count)
-		sum.Bandwidth[1] = sum.Bandwidth[1] / uint64(count)
-		sum.Battery[0] = uint8(batterySum / int(count))
-
-		// Average network interfaces
-		if sum.NetworkInterfaces != nil {
-			for key := range sum.NetworkInterfaces {
-				sum.NetworkInterfaces[key] = [4]uint64{
-					sum.NetworkInterfaces[key][0] / uint64(count),
-					sum.NetworkInterfaces[key][1] / uint64(count),
-					sum.NetworkInterfaces[key][2],
-					sum.NetworkInterfaces[key][3],
-				}
-			}
-		}
 
 		// Average temperatures
 		if sum.Temperatures != nil && tempCount > 0 {
@@ -369,13 +307,6 @@ func (rm *RecordManager) AverageSystemStats(db dbx.Builder, records RecordIds) *
 				gpu.Usage = twoDecimals(gpu.Usage / count)
 				gpu.Power = twoDecimals(gpu.Power / count)
 				gpu.Count = twoDecimals(gpu.Count / count)
-
-				if gpu.Engines != nil {
-					for engineKey := range gpu.Engines {
-						gpu.Engines[engineKey] = twoDecimals(gpu.Engines[engineKey] / count)
-					}
-				}
-
 				sum.GPUData[id] = gpu
 			}
 		}
@@ -430,50 +361,12 @@ func (rm *RecordManager) AverageContainerStats(db dbx.Builder, records RecordIds
 	return result
 }
 
-// Delete old records
+// Deletes records older than what is displayed in the UI
 func (rm *RecordManager) DeleteOldRecords() {
-	rm.app.RunInTransaction(func(txApp core.App) error {
-		err := deleteOldSystemStats(txApp)
-		if err != nil {
-			return err
-		}
-		err = deleteOldContainerRecords(txApp)
-		if err != nil {
-			return err
-		}
-		err = deleteOldAlertsHistory(txApp, 200, 250)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-// Delete old alerts history records
-func deleteOldAlertsHistory(app core.App, countToKeep, countBeforeDeletion int) error {
-	db := app.DB()
-	var users []struct {
-		Id string `db:"user"`
-	}
-	err := db.NewQuery("SELECT user, COUNT(*) as count FROM alerts_history GROUP BY user HAVING count > {:countBeforeDeletion}").Bind(dbx.Params{"countBeforeDeletion": countBeforeDeletion}).All(&users)
-	if err != nil {
-		return err
-	}
-	for _, user := range users {
-		_, err = db.NewQuery("DELETE FROM alerts_history WHERE user = {:user} AND id NOT IN (SELECT id FROM alerts_history WHERE user = {:user} ORDER BY created DESC LIMIT {:countToKeep})").Bind(dbx.Params{"user": user.Id, "countToKeep": countToKeep}).Execute()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Deletes system_stats records older than what is displayed in the UI
-func deleteOldSystemStats(app core.App) error {
-	// Collections to process
+	// Define the collections to process
 	collections := [2]string{"system_stats", "container_stats"}
 
-	// Record types and their retention periods
+	// Define record types and their retention periods
 	type RecordDeletionData struct {
 		recordType string
 		retention  time.Duration
@@ -489,9 +382,10 @@ func deleteOldSystemStats(app core.App) error {
 	now := time.Now().UTC()
 
 	for _, collection := range collections {
-		// Build the WHERE clause
+		// Build the WHERE clause dynamically
 		var conditionParts []string
 		var params dbx.Params = make(map[string]any)
+
 		for i := range recordData {
 			rd := recordData[i]
 			// Create parameterized condition for this record type
@@ -499,29 +393,19 @@ func deleteOldSystemStats(app core.App) error {
 			conditionParts = append(conditionParts, fmt.Sprintf("(type = '%s' AND created < {:%s})", rd.recordType, dateParam))
 			params[dateParam] = now.Add(-rd.retention)
 		}
+
 		// Combine conditions with OR
 		conditionStr := strings.Join(conditionParts, " OR ")
-		// Construct and execute the full raw query
+
+		// Construct the full raw query
 		rawQuery := fmt.Sprintf("DELETE FROM %s WHERE %s", collection, conditionStr)
-		if _, err := app.DB().NewQuery(rawQuery).Bind(params).Execute(); err != nil {
-			return fmt.Errorf("failed to delete from %s: %v", collection, err)
+
+		// Execute the query with parameters
+		if _, err := rm.app.DB().NewQuery(rawQuery).Bind(params).Execute(); err != nil {
+			// return fmt.Errorf("failed to delete from %s: %v", collection, err)
+			rm.app.Logger().Error("failed to delete", "collection", collection, "error", err)
 		}
 	}
-	return nil
-}
-
-// Deletes container records that haven't been updated in the last 10 minutes
-func deleteOldContainerRecords(app core.App) error {
-	now := time.Now().UTC()
-	tenMinutesAgo := now.Add(-10 * time.Minute)
-
-	// Delete container records where updated < tenMinutesAgo
-	_, err := app.DB().NewQuery("DELETE FROM containers WHERE updated < {:updated}").Bind(dbx.Params{"updated": tenMinutesAgo.UnixMilli()}).Execute()
-	if err != nil {
-		return fmt.Errorf("failed to delete old container records: %v", err)
-	}
-
-	return nil
 }
 
 /* Round float to two decimals */

beszel/internal/tests/hub.go

@@ -5,14 +5,10 @@
 package tests
 
 import (
-	"fmt"
-	"testing"
-
-	"github.com/henrygd/beszel/internal/hub"
+	"beszel/internal/hub"
 
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tests"
-	"github.com/stretchr/testify/assert"
 
 	_ "github.com/pocketbase/pocketbase/migrations"
 )
@@ -90,63 +86,3 @@ func CreateRecord(app core.App, collectionName string, fields map[string]any) (*
 
 	return record, app.Save(record)
 }
-
-func ClearCollection(t testing.TB, app core.App, collectionName string) error {
-	_, err := app.DB().NewQuery(fmt.Sprintf("DELETE from %s", collectionName)).Execute()
-	recordCount, err := app.CountRecords(collectionName)
-	assert.EqualValues(t, recordCount, 0, "should have 0 records after clearing")
-	return err
-}
-
-func (h *TestHub) Cleanup() {
-	h.GetAlertManager().StopWorker()
-	h.GetSystemManager().RemoveAllSystems()
-	h.TestApp.Cleanup()
-}
-
-func CreateSystems(app core.App, count int, userId string, status string) ([]*core.Record, error) {
-	systems := make([]*core.Record, 0, count)
-	for i := range count {
-		system, err := CreateRecord(app, "systems", map[string]any{
-			"name":  fmt.Sprintf("test-system-%d", i),
-			"host":  fmt.Sprintf("127.0.0.%d", i),
-			"port":  "33914",
-			"users": []string{userId},
-		})
-		if err != nil {
-			return nil, err
-		}
-		system.Set("status", status)
-		err = app.SaveNoValidate(system)
-		if err != nil {
-			return nil, err
-		}
-		systems = append(systems, system)
-	}
-	return systems, nil
-}
-
-// GetHubWithUser creates a test hub with a test user and user settings
-func GetHubWithUser(t *testing.T) (*TestHub, *core.Record) {
-	hub, err := NewTestHub(t.TempDir())
-	assert.NoError(t, err)
-	hub.StartHub()
-
-	// Manually initialize the system manager to bind event hooks
-	err = hub.GetSystemManager().Initialize()
-	assert.NoError(t, err)
-
-	// Create a test user
-	user, err := CreateUser(hub, "test@example.com", "password")
-	assert.NoError(t, err)
-
-	// Create user settings for the test user (required for alert notifications)
-	userSettingsData := map[string]any{
-		"user":     user.Id,
-		"settings": `{"emails":[test@example.com],"webhooks":[]}`,
-	}
-	_, err = CreateRecord(hub, "user_settings", userSettingsData)
-	assert.NoError(t, err)
-
-	return hub, user
-}

beszel/internal/users/users.go

@@ -2,12 +2,10 @@
 package users
 
 import (
+	"beszel/migrations"
 	"log"
 	"net/http"
 
-	"github.com/henrygd/beszel/internal/migrations"
-
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 )
 
@@ -15,6 +13,15 @@ type UserManager struct {
 	app core.App
 }
 
+type UserSettings struct {
+	ChartTime            string   `json:"chartTime"`
+	NotificationEmails   []string `json:"emails"`
+	NotificationWebhooks []string `json:"webhooks"`
+	// TemperatureUnit      int      `json:"unitTemp"` // 0 for Celsius, 1 for Fahrenheit
+	// NetworkUnit          int      `json:"unitNet"`  // 0 for bytes, 1 for bits
+	// DiskUnit             int      `json:"unitDisk"` // 0 for bytes, 1 for bits
+}
+
 func NewUserManager(app core.App) *UserManager {
 	return &UserManager{
 		app: app,
@@ -32,26 +39,30 @@ func (um *UserManager) InitializeUserRole(e *core.RecordEvent) error {
 // Initialize user settings with defaults if not set
 func (um *UserManager) InitializeUserSettings(e *core.RecordEvent) error {
 	record := e.Record
-	// intialize settings with defaults (zero values can be ignored)
-	settings := struct {
-		ChartTime string   `json:"chartTime"`
-		Emails    []string `json:"emails"`
-	}{
-		ChartTime: "1h",
+	// intialize settings with defaults
+	settings := UserSettings{
+		// Language:             "en",
+		ChartTime:            "1h",
+		NotificationEmails:   []string{},
+		NotificationWebhooks: []string{},
 	}
 	record.UnmarshalJSONField("settings", &settings)
-	// get user email from auth record
-	var user struct {
-		Email string `db:"email"`
+	if len(settings.NotificationEmails) == 0 {
+		// get user email from auth record
+		if errs := um.app.ExpandRecord(record, []string{"user"}, nil); len(errs) == 0 {
+			// app.Logger().Error("failed to expand user relation", "errs", errs)
+			if user := record.ExpandedOne("user"); user != nil {
+				settings.NotificationEmails = []string{user.GetString("email")}
+			} else {
+				log.Println("Failed to get user email from auth record")
+			}
+		} else {
+			log.Println("failed to expand user relation", "errs", errs)
+		}
 	}
-	err := e.App.DB().NewQuery("SELECT email FROM users WHERE id = {:id}").Bind(dbx.Params{
-		"id": record.GetString("user"),
-	}).One(&user)
-	if err != nil {
-		log.Println("failed to get user email", "err", err)
-		return err
-	}
-	settings.Emails = []string{user.Email}
+	// if len(settings.NotificationWebhooks) == 0 {
+	// 	settings.NotificationWebhooks = []string{""}
+	// }
 	record.Set("settings", settings)
 	return e.Next()
 }

beszel/migrations/0_collections_snapshot_0_12_0.go

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

beszel/migrations/initial-settings.go

@@ -0,0 +1,29 @@
+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/index.html

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