New translations en.po (Chinese Traditional, Hong Kong)

.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/ISSUE_TEMPLATE/bug_report.yml

@@ -1,19 +1,8 @@
 name: 🐛 Bug report
 description: Report a new bug or issue.
 title: '[Bug]: '
-labels: ['bug', "needs confirmation"]
+labels: ['bug']
 body:
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of Beszel is this about?
-      options:
-        - Hub
-        - Agent
-        - Hub & Agent
-    validations:
-      required: true
   - type: markdown
     attributes:
       value: |
@@ -54,39 +43,6 @@ body:
         3. Pour it into a cup.
     validations:
       required: true
-  - type: dropdown
-    id: category
-    attributes:
-      label: Category
-      description: Which category does this relate to most?
-      options:
-        - Metrics
-        - Charts & Visualization
-        - Settings & Configuration
-        - Notifications & Alerts
-        - Authentication
-        - Installation
-        - Performance
-        - UI / UX
-        - Other
-    validations:
-      required: true
-  - type: dropdown
-    id: metrics
-    attributes:
-      label: Affected Metrics
-      description: If applicable, which specific metric does this relate to most?
-      options:
-        - CPU
-        - Memory
-        - Storage
-        - Network
-        - Containers
-        - GPU
-        - Sensors
-        - Other
-    validations:
-      required: true
   - type: input
     id: system
     attributes:
@@ -105,6 +61,7 @@ body:
     id: install-method
     attributes:
       label: Installation method
+      default: 0
       options:
         - Docker
         - Binary

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,19 +1,8 @@
 name: 🚀 Feature request
 description: Request a new feature or change.
 title: "[Feature]: "
-labels: ["enhancement", "needs review"]
+labels: ["enhancement"]
 body:
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of Beszel is this about?
-      options:
-        - Hub
-        - Agent
-        - Hub & Agent
-    validations:
-      required: true
   - type: markdown
     attributes:
       value: Before submitting, please search existing [issues](https://github.com/henrygd/beszel/issues) and [discussions](https://github.com/henrygd/beszel/discussions) (including closed).
@@ -22,55 +11,8 @@ body:
       label: Describe the feature you would like to see
     validations:
       required: true
-  - type: textarea
-    id: motivation
-    attributes:
-      label: Motivation / Use Case
-      description: Why do you want this feature? What problem does it solve?
-    validations:
-      required: true
   - type: textarea
     attributes:
       label: Describe how you would like to see this feature implemented
     validations:
       required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Screenshots
-      description: Please attach any relevant screenshots, such as images from your current solution or similar implementations.
-    validations:
-      required: false
-  - type: dropdown
-    id: category
-    attributes:
-      label: Category
-      description: Which category does this relate to most?
-      options:
-        - Metrics
-        - Charts & Visualization
-        - Settings & Configuration
-        - Notifications & Alerts
-        - Authentication
-        - Installation
-        - Performance
-        - UI / UX
-        - Other
-    validations:
-      required: true
-  - type: dropdown
-    id: metrics
-    attributes:
-      label: Affected Metrics
-      description: If applicable, which specific metric does this relate to most?
-      options:
-        - CPU
-        - Memory
-        - Storage
-        - Network
-        - Containers
-        - GPU
-        - Sensors
-        - Other
-    validations:
-      required: true

.github/pull_request_template.md

@@ -1,33 +0,0 @@
-## 📃 Description
-
-A short description of the pull request changes should go here and the sections below should list in detail all changes. You can remove the sections you don't need.
-
-## 📖 Documentation
-
-Add a link to the PR for [documentation](https://github.com/henrygd/beszel-docs) changes.
-
-## 🪵 Changelog
-
-### ➕ Added
-
-- one
-- two
-
-### ✏️ Changed
-
-- one
-- two
-
-### 🔧 Fixed
-
-- one
-- two
-
-### 🗑️ Removed
-
-- one
-- two
-
-## 📷 Screenshots
-
-If this PR has any UI/UX changes it's strongly suggested you add screenshots here.

.github/workflows/docker-images.yml

@@ -3,7 +3,7 @@ name: Make docker images
 on:
   push:
     tags:
-      - "v*"
+      - 'v*'
 
 jobs:
   build:
@@ -13,49 +13,29 @@ jobs:
       matrix:
         include:
           - image: henrygd/beszel
-            context: ./
-            dockerfile: ./internal/dockerfile_hub
+            context: ./beszel
+            dockerfile: ./beszel/dockerfile_Hub
             registry: docker.io
             username_secret: DOCKERHUB_USERNAME
             password_secret: DOCKERHUB_TOKEN
-
           - image: henrygd/beszel-agent
-            context: ./
-            dockerfile: ./internal/dockerfile_agent
+            context: ./beszel
+            dockerfile: ./beszel/dockerfile_Agent
             registry: docker.io
             username_secret: DOCKERHUB_USERNAME
             password_secret: DOCKERHUB_TOKEN
-
-          - image: henrygd/beszel-agent-nvidia
-            context: ./
-            dockerfile: ./internal/dockerfile_agent_nvidia
-            platforms: linux/amd64
-            registry: docker.io
-            username_secret: DOCKERHUB_USERNAME
-            password_secret: DOCKERHUB_TOKEN
-
           - image: ghcr.io/${{ github.repository }}/beszel
-            context: ./
-            dockerfile: ./internal/dockerfile_hub
+            context: ./beszel
+            dockerfile: ./beszel/dockerfile_Hub
             registry: ghcr.io
             username: ${{ github.actor }}
             password_secret: GITHUB_TOKEN
-
           - image: ghcr.io/${{ github.repository }}/beszel-agent
-            context: ./
-            dockerfile: ./internal/dockerfile_agent
+            context: ./beszel
+            dockerfile: ./beszel/dockerfile_Agent
             registry: ghcr.io
             username: ${{ github.actor }}
             password_secret: GITHUB_TOKEN
-
-          - image: ghcr.io/${{ github.repository }}/beszel-agent-nvidia
-            context: ./
-            dockerfile: ./internal/dockerfile_agent_nvidia
-            platforms: linux/amd64
-            registry: ghcr.io
-            username: ${{ github.actor }}
-            password_secret: GITHUB_TOKEN
-
     permissions:
       contents: read
       packages: write
@@ -68,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
@@ -85,7 +65,6 @@ jobs:
         with:
           images: ${{ matrix.image }}
           tags: |
-            type=raw,value=edge
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
@@ -93,9 +72,7 @@ jobs:
 
       # 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] }}
@@ -107,9 +84,9 @@ jobs:
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
-          context: "${{ matrix.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/inactivity-actions.yml

@@ -1,43 +0,0 @@
-name: 'Issue and PR Maintenance'
-
-on:
-  schedule:
-    - cron: '0 0 * * *'   # runs at midnight UTC
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  close-stale:
-    name: Close Stale Issues
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Close Stale Issues
-        uses: actions/stale@v9
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-
-          # Messaging
-          stale-issue-message: >
-            👋 This issue has been automatically marked as stale due to inactivity.
-            If this issue is still relevant, please comment to keep it open.
-            Without activity, it will be closed in 7 days.
-
-          close-issue-message: >
-            🔒 This issue has been automatically closed due to prolonged inactivity.
-            Feel free to open a new issue if you have further questions or concerns.
-
-          # Timing
-          days-before-issue-stale: 14
-          days-before-issue-close: 7
-
-          # Labels
-          stale-issue-label: 'stale'
-          remove-stale-when-updated: true
-          only-issue-labels: 'awaiting-requester'
-
-          # Exemptions
-          exempt-assignees: true
-          exempt-milestones: true

.github/workflows/label-from-dropdown.yml

@@ -1,82 +0,0 @@
-name: Label issues from dropdowns
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  label_from_dropdown:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Apply labels based on dropdown choices
-        uses: actions/github-script@v7
-        with:
-          script: |
-
-            const issueNumber = context.issue.number;
-            const owner = context.repo.owner;
-            const repo = context.repo.repo;
-
-            // Get the issue body
-            const body = context.payload.issue.body;
-
-            // Helper to find dropdown value in the body (assuming markdown format)
-            function extractSectionValue(heading) {
-              const regex = new RegExp(`### ${heading}\\s+([\\s\\S]*?)(?:\\n###|$)`, 'i');
-              const match = body.match(regex);
-              if (match) {
-                // Get the first non-empty line after the heading
-                const lines = match[1].split('\n').map(l => l.trim()).filter(Boolean);
-                return lines[0] || null;
-              }
-              return null;
-            }
-
-            // Extract dropdown selections
-            const category = extractSectionValue('Category');
-            const metrics = extractSectionValue('Affected Metrics');
-            const component = extractSectionValue('Component');
-
-            // Build labels to add
-            let labelsToAdd = [];
-            if (category) labelsToAdd.push(category);
-            if (metrics) labelsToAdd.push(metrics);
-            if (component) labelsToAdd.push(component);
-
-            // Get existing labels in the repo
-            const { data: existingLabels } = await github.rest.issues.listLabelsForRepo({
-              owner,
-              repo,
-              per_page: 100
-            });
-            const existingLabelNames = existingLabels.map(l => l.name);
-
-            // Find labels that need to be created
-            const labelsToCreate = labelsToAdd.filter(label => !existingLabelNames.includes(label));
-
-            // Create missing labels (with a default color)
-            for (const label of labelsToCreate) {
-              try {
-                await github.rest.issues.createLabel({
-                  owner,
-                  repo,
-                  name: label,
-                  color: 'ededed' // light gray, you can pick any hex color
-                });
-              } catch (e) {
-                // Ignore if label already exists (race condition), otherwise rethrow
-                if (!e || e.status !== 422) throw e;
-              }
-            }
-
-            // Now apply all labels (they all exist now)
-            if (labelsToAdd.length > 0) {
-              await github.rest.issues.addLabels({
-                owner,
-                repo,
-                issue_number: issueNumber,
-                labels: labelsToAdd
-              });
-            } 

.github/workflows/release.yml

@@ -3,7 +3,7 @@ name: Make release and binaries
 on:
   push:
     tags:
-      - "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_TOKEN: ${{ secrets.TOKEN }}

.github/workflows/vulncheck.yml

@@ -1,33 +0,0 @@
-# https://github.com/minio/minio/blob/master/.github/workflows/vulncheck.yml
-
-name: VulnCheck
-on:
-  pull_request:
-    branches:
-      - main
-
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  vulncheck:
-    name: VulnCheck
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: 1.25.x
-          # cached: false
-      - name: Get official govulncheck
-        run: go install golang.org/x/vuln/cmd/govulncheck@latest
-        shell: bash
-      - name: Run govulncheck
-        run: govulncheck -show verbose ./...
-        shell: bash

.gitignore

@@ -8,15 +8,11 @@ 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
-*.bak
-__debug_*
-agent/lhm/obj
-agent/lhm/bin
-dockerfile_agent_dev
+beszel/site/src/locales/**/*.ts
+*.bak

.goreleaser.yml

@@ -1,237 +0,0 @@
-version: 2
-
-project_name: beszel
-
-before:
-  hooks:
-    - go mod tidy
-
-builds:
-  - id: beszel
-    binary: beszel
-    main: internal/cmd/hub/hub.go
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-    goarch:
-      - amd64
-      - arm64
-      - arm
-
-  - id: beszel-agent
-    binary: beszel-agent
-    main: internal/cmd/agent/agent.go
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-      - freebsd
-      - openbsd
-      - windows
-    goarch:
-      - amd64
-      - arm64
-      - arm
-      - 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
-        goarch: riscv64
-      - goos: windows
-        goarch: riscv64
-
-archives:
-  - id: beszel-agent
-    formats: [tar.gz]
-    ids:
-      - beszel-agent
-    name_template: >-
-      {{ .Binary }}_
-      {{- .Os }}_
-      {{- .Arch }}
-    format_overrides:
-      - goos: windows
-        formats: [zip]
-
-  - id: beszel
-    formats: [tar.gz]
-    ids:
-      - beszel
-    name_template: >-
-      {{ .Binary }}_
-      {{- .Os }}_
-      {{- .Arch }}
-
-nfpms:
-  - id: beszel-agent
-    package_name: beszel-agent
-    description: |-
-      Agent for Beszel
-      Beszel is a lightweight server monitoring platform that includes Docker
-      statistics, historical data, and alert functions. It has a friendly web
-      interface, simple configuration, and is ready to use out of the box.
-      It supports automatic backup, multi-user, OAuth authentication, and
-      API access.
-    maintainer: henrygd <hank@henrygd.me>
-    section: net
-    ids:
-      - beszel-agent
-    formats:
-      - deb
-    contents:
-      - src: ./supplemental/debian/beszel-agent.service
-        dst: lib/systemd/system/beszel-agent.service
-        packager: deb
-      - src: ./supplemental/debian/copyright
-        dst: usr/share/doc/beszel-agent/copyright
-        packager: deb
-      - 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
-    deb:
-      predepends:
-        - adduser
-        - debconf
-      scripts:
-        templates: ./supplemental/debian/templates
-        # Currently broken due to a bug in goreleaser
-        # https://github.com/goreleaser/goreleaser/issues/5487
-        #config: ./supplemental/debian/config.sh
-
-scoops:
-  - ids: [beszel-agent]
-    name: beszel-agent
-    repository:
-      owner: henrygd
-      name: beszel-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:
-#   - title: Beszel Agent
-#     ids: [beszel-agent]
-#     package_source_url: https://github.com/henrygd/beszel-chocolatey
-#     owners: henrygd
-#     authors: henrygd
-#     summary: 'Agent for Beszel, a lightweight server monitoring platform.'
-#     description: |
-#       Beszel is a lightweight server monitoring platform that includes Docker statistics, historical data, and alert functions.
-
-#       It has a friendly web interface, simple configuration, and is ready to use out of the box. It supports automatic backup, multi-user, OAuth authentication, and API access.
-#     license_url: https://github.com/henrygd/beszel/blob/main/LICENSE
-#     project_url: https://beszel.dev
-#     project_source_url: https://github.com/henrygd/beszel
-#     docs_url: https://beszel.dev/guide/getting-started
-#     icon_url: https://cdn.jsdelivr.net/gh/selfhst/icons/png/beszel.png
-#     bug_tracker_url: https://github.com/henrygd/beszel/issues
-#     copyright: 2025 henrygd
-#     tags: foss cross-platform admin monitoring
-#     require_license_acceptance: false
-#     release_notes: 'https://github.com/henrygd/beszel/releases/tag/v{{ .Version }}'
-
-brews:
-  - ids: [beszel-agent]
-    name: beszel-agent
-    repository:
-      owner: henrygd
-      name: homebrew-beszel
-    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 }}'
-    extra_install: |
-      (bin/"beszel-agent-launcher").write <<~EOS
-        #!/bin/bash
-        set -a
-        if [ -f "$HOME/.config/beszel/beszel-agent.env" ]; then
-          source "$HOME/.config/beszel/beszel-agent.env"
-        fi
-        set +a
-        exec #{bin}/beszel-agent "$@"
-      EOS
-      (bin/"beszel-agent-launcher").chmod 0755
-    service: |
-      run ["#{bin}/beszel-agent-launcher"]
-      log_path "#{Dir.home}/.cache/beszel/beszel-agent.log"
-      error_log_path "#{Dir.home}/.cache/beszel/beszel-agent.log"
-      keep_alive true
-      restart_delay 5
-      process_type :background
-
-winget:
-  - ids: [beszel-agent]
-    name: beszel-agent
-    package_identifier: henrygd.beszel-agent
-    publisher: henrygd
-    license: MIT
-    license_url: "https://github.com/henrygd/beszel/blob/main/LICENSE"
-    copyright: "2025 henrygd"
-    homepage: "https://beszel.dev"
-    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 }}'
-    description: |
-      Beszel is a lightweight server monitoring platform that includes Docker
-      statistics, historical data, and alert functions. It has a friendly web
-      interface, simple configuration, and is ready to use out of the box.
-      It supports automatic backup, multi-user, OAuth authentication, and
-      API access.
-    tags:
-      - homelab
-      - monitoring
-      - self-hosted
-    repository:
-      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
-
-release:
-  draft: true
-
-changelog:
-  disable: true
-  sort: asc
-  filters:
-    exclude:
-      - "^docs:"
-      - "^test:"

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

agent/agent_cache.go

@@ -1,37 +0,0 @@
-package agent
-
-import (
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-// 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()
-}

agent/agent_cache_test.go

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

agent/agent_test_helpers.go

@@ -1,9 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-// TESTING ONLY: GetConnectionManager is a helper function to get the connection manager for testing.
-func (a *Agent) GetConnectionManager() *ConnectionManager {
-	return a.connectionManager
-}

agent/battery/battery.go

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

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.go

@@ -1,266 +0,0 @@
-package agent
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"log/slog"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"path"
-	"strings"
-	"time"
-
-	"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 (
-	wsDeadline = 70 * time.Second
-)
-
-// WebSocketClient manages the WebSocket connection between the agent and hub.
-// It handles authentication, message routing, and connection lifecycle management.
-type WebSocketClient struct {
-	gws.BuiltinEventHandler
-	options            *gws.ClientOption                   // WebSocket client configuration options
-	agent              *Agent                              // Reference to the parent agent
-	Conn               *gws.Conn                           // Active WebSocket connection
-	hubURL             *url.URL                            // Parsed hub URL for connection
-	token              string                              // Authentication token for hub registration
-	fingerprint        string                              // System fingerprint for identification
-	hubRequest         *common.HubRequest[cbor.RawMessage] // Reusable request structure for message parsing
-	lastConnectAttempt time.Time                           // Timestamp of last connection attempt
-	hubVerified        bool                                // Whether the hub has been cryptographically verified
-}
-
-// newWebSocketClient creates a new WebSocket client for the given agent.
-// It reads configuration from environment variables and validates the hub URL.
-func newWebSocketClient(agent *Agent) (client *WebSocketClient, err error) {
-	hubURLStr, exists := GetEnv("HUB_URL")
-	if !exists {
-		return nil, errors.New("HUB_URL environment variable not set")
-	}
-
-	client = &WebSocketClient{}
-
-	client.hubURL, err = url.Parse(hubURLStr)
-	if err != nil {
-		return nil, errors.New("invalid hub URL")
-	}
-	// get registration token
-	client.token, err = getToken()
-	if err != nil {
-		return nil, err
-	}
-
-	client.agent = agent
-	client.hubRequest = &common.HubRequest[cbor.RawMessage]{}
-	client.fingerprint = agent.getFingerprint()
-
-	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 {
-	if client.options != nil {
-		return client.options
-	}
-
-	// update the hub url to use websocket scheme and api path
-	if client.hubURL.Scheme == "https" {
-		client.hubURL.Scheme = "wss"
-	} else {
-		client.hubURL.Scheme = "ws"
-	}
-	client.hubURL.Path = path.Join(client.hubURL.Path, "api/beszel/agent-connect")
-
-	client.options = &gws.ClientOption{
-		Addr:      client.hubURL.String(),
-		TlsConfig: &tls.Config{InsecureSkipVerify: true},
-		RequestHeader: http.Header{
-			"User-Agent": []string{getUserAgent()},
-			"X-Token":    []string{client.token},
-			"X-Beszel":   []string{beszel.Version},
-		},
-	}
-	return client.options
-}
-
-// Connect establishes a WebSocket connection to the hub.
-// It closes any existing connection before attempting to reconnect.
-func (client *WebSocketClient) Connect() (err error) {
-	client.lastConnectAttempt = time.Now()
-
-	// make sure previous connection is closed
-	client.Close()
-
-	client.Conn, _, err = gws.NewClient(client, client.getOptions())
-	if err != nil {
-		return err
-	}
-
-	go client.Conn.ReadLoop()
-
-	return nil
-}
-
-// OnOpen handles WebSocket connection establishment.
-// It sets a deadline for the connection to prevent hanging.
-func (client *WebSocketClient) OnOpen(conn *gws.Conn) {
-	conn.SetDeadline(time.Now().Add(wsDeadline))
-}
-
-// OnClose handles WebSocket connection closure.
-// It logs the closure reason and notifies the connection manager.
-func (client *WebSocketClient) OnClose(conn *gws.Conn, err error) {
-	slog.Warn("Connection closed", "err", strings.TrimPrefix(err.Error(), "gws: "))
-	client.agent.connectionManager.eventChan <- WebSocketDisconnect
-}
-
-// OnMessage handles incoming WebSocket messages from the hub.
-// It decodes CBOR messages and routes them to appropriate handlers.
-func (client *WebSocketClient) OnMessage(conn *gws.Conn, message *gws.Message) {
-	defer message.Close()
-	conn.SetDeadline(time.Now().Add(wsDeadline))
-
-	if message.Opcode != gws.OpcodeBinary {
-		return
-	}
-
-	if err := cbor.NewDecoder(message.Data).Decode(client.hubRequest); err != nil {
-		slog.Error("Error parsing message", "err", err)
-		return
-	}
-	if err := client.handleHubRequest(client.hubRequest); err != nil {
-		slog.Error("Error handling message", "err", err)
-	}
-}
-
-// OnPing handles WebSocket ping frames.
-// It responds with a pong and updates the connection deadline.
-func (client *WebSocketClient) OnPing(conn *gws.Conn, message []byte) {
-	conn.SetDeadline(time.Now().Add(wsDeadline))
-	conn.WritePong(message)
-}
-
-// handleAuthChallenge verifies the authenticity of the hub and returns the system's fingerprint.
-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
-	}
-
-	if err := client.verifySignature(authRequest.Signature); err != nil {
-		return err
-	}
-
-	client.hubVerified = true
-	client.agent.connectionManager.eventChan <- WebSocketConnect
-
-	response := &common.FingerprintResponse{
-		Fingerprint: client.fingerprint,
-	}
-
-	if authRequest.NeedSysInfo {
-		response.Hostname = client.agent.systemInfo.Hostname
-		serverAddr := client.agent.connectionManager.serverOptions.Addr
-		_, response.Port, _ = net.SplitHostPort(serverAddr)
-	}
-
-	return client.sendMessage(response)
-}
-
-// verifySignature verifies the signature of the token using the public keys.
-func (client *WebSocketClient) verifySignature(signature []byte) (err error) {
-	for _, pubKey := range client.agent.keys {
-		sig := ssh.Signature{
-			Format: pubKey.Type(),
-			Blob:   signature,
-		}
-		if err = pubKey.Verify([]byte(client.token), &sig); err == nil {
-			return nil
-		}
-	}
-	return errors.New("invalid signature - check KEY value")
-}
-
-// Close closes the WebSocket connection gracefully.
-// This method is safe to call multiple times.
-func (client *WebSocketClient) Close() {
-	if client.Conn != nil {
-		_ = client.Conn.WriteClose(1000, nil)
-	}
-}
-
-// 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")
-	}
-	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.
-func (client *WebSocketClient) sendMessage(data any) error {
-	bytes, err := cbor.Marshal(data)
-	if err != nil {
-		return err
-	}
-	return client.Conn.WriteMessage(gws.OpcodeBinary, bytes)
-}
-
-// getUserAgent returns one of two User-Agent strings based on current time.
-// This is used to avoid being blocked by Cloudflare or other anti-bot measures.
-func getUserAgent() string {
-	const (
-		uaBase    = "Mozilla/5.0 (%s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
-		uaWindows = "Windows NT 11.0; Win64; x64"
-		uaMac     = "Macintosh; Intel Mac OS X 14_0_0"
-	)
-	if time.Now().UnixNano()%2 == 0 {
-		return fmt.Sprintf(uaBase, uaWindows)
-	}
-	return fmt.Sprintf(uaBase, uaMac)
-}

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)
-
-			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/connection_manager.go

@@ -1,226 +0,0 @@
-package agent
-
-import (
-	"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
-}
-
-// ConnectionState represents the current connection state of the agent.
-type ConnectionState uint8
-
-// ConnectionEvent represents connection-related events that can occur.
-type ConnectionEvent uint8
-
-// Connection states
-const (
-	Disconnected       ConnectionState = iota // No active connection
-	WebSocketConnected                        // Connected via WebSocket
-	SSHConnected                              // Connected via SSH
-)
-
-// Connection events
-const (
-	WebSocketConnect    ConnectionEvent = iota // WebSocket connection established
-	WebSocketDisconnect                        // WebSocket connection lost
-	SSHConnect                                 // SSH connection established
-	SSHDisconnect                              // SSH connection lost
-)
-
-const wsTickerInterval = 10 * time.Second
-
-// newConnectionManager creates a new connection manager for the given agent.
-func newConnectionManager(agent *Agent) *ConnectionManager {
-	cm := &ConnectionManager{
-		agent: agent,
-		State: Disconnected,
-	}
-	return cm
-}
-
-// startWsTicker starts or resets the WebSocket connection attempt ticker.
-func (c *ConnectionManager) startWsTicker() {
-	if c.wsTicker == nil {
-		c.wsTicker = time.NewTicker(wsTickerInterval)
-	} else {
-		c.wsTicker.Reset(wsTickerInterval)
-	}
-}
-
-// stopWsTicker stops the WebSocket connection attempt ticker.
-func (c *ConnectionManager) stopWsTicker() {
-	if c.wsTicker != nil {
-		c.wsTicker.Stop()
-	}
-}
-
-// Start begins connection attempts and enters the main event loop.
-// It handles connection events, periodic health updates, and graceful shutdown.
-func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
-	if c.eventChan != nil {
-		return errors.New("already started")
-	}
-
-	wsClient, err := newWebSocketClient(c.agent)
-	if err != nil {
-		slog.Warn("Error creating WebSocket client", "err", err)
-	}
-	c.wsClient = wsClient
-
-	c.serverOptions = serverOptions
-	c.eventChan = make(chan ConnectionEvent, 1)
-
-	// signal handling for shutdown
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-
-	c.startWsTicker()
-	c.connect()
-
-	// update health status immediately and every 90 seconds
-	_ = health.Update()
-	healthTicker := time.Tick(90 * time.Second)
-
-	for {
-		select {
-		case connectionEvent := <-c.eventChan:
-			c.handleEvent(connectionEvent)
-		case <-c.wsTicker.C:
-			_ = c.startWebSocketConnection()
-		case <-healthTicker:
-			_ = health.Update()
-		case <-sigChan:
-			slog.Info("Shutting down")
-			_ = c.agent.StopServer()
-			c.closeWebSocket()
-			return health.CleanUp()
-		}
-	}
-}
-
-// handleEvent processes connection events and updates the connection state accordingly.
-func (c *ConnectionManager) handleEvent(event ConnectionEvent) {
-	switch event {
-	case WebSocketConnect:
-		c.handleStateChange(WebSocketConnected)
-	case SSHConnect:
-		c.handleStateChange(SSHConnected)
-	case WebSocketDisconnect:
-		if c.State == WebSocketConnected {
-			c.handleStateChange(Disconnected)
-		}
-	case SSHDisconnect:
-		if c.State == SSHConnected {
-			c.handleStateChange(Disconnected)
-		}
-	}
-}
-
-// handleStateChange updates the connection state and performs necessary actions
-// based on the new state, including stopping services and initiating reconnections.
-func (c *ConnectionManager) handleStateChange(newState ConnectionState) {
-	if c.State == newState {
-		return
-	}
-	c.State = newState
-	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
-		}
-		c.isConnecting = true
-		slog.Warn("Disconnected from hub")
-		// make sure old ws connection is closed
-		c.closeWebSocket()
-		// reconnect
-		go c.connect()
-	}
-}
-
-// connect handles the connection logic with proper delays and priority.
-// It attempts WebSocket connection first, falling back to SSH server if needed.
-func (c *ConnectionManager) connect() {
-	c.isConnecting = true
-	defer func() {
-		c.isConnecting = false
-	}()
-
-	if c.wsClient != nil && time.Since(c.wsClient.lastConnectAttempt) < 5*time.Second {
-		time.Sleep(5 * time.Second)
-	}
-
-	// Try WebSocket first, if it fails, start SSH server
-	err := c.startWebSocketConnection()
-	if err != nil && c.State == Disconnected {
-		c.startSSHServer()
-		c.startWsTicker()
-	}
-}
-
-// startWebSocketConnection attempts to establish a WebSocket connection to the hub.
-func (c *ConnectionManager) startWebSocketConnection() error {
-	if c.State != Disconnected {
-		return errors.New("already connected")
-	}
-	if c.wsClient == nil {
-		return errors.New("WebSocket client not initialized")
-	}
-	if time.Since(c.wsClient.lastConnectAttempt) < 5*time.Second {
-		return errors.New("already connecting")
-	}
-
-	err := c.wsClient.Connect()
-	if err != nil {
-		slog.Warn("WebSocket connection failed", "err", err)
-		c.closeWebSocket()
-	}
-	return err
-}
-
-// startSSHServer starts the SSH server if the agent is currently disconnected.
-func (c *ConnectionManager) startSSHServer() {
-	if c.State == Disconnected {
-		go c.agent.StartServer(c.serverOptions)
-	}
-}
-
-// closeWebSocket closes the WebSocket connection if it exists.
-func (c *ConnectionManager) closeWebSocket() {
-	if c.wsClient != nil {
-		c.wsClient.Close()
-	}
-}

agent/connection_manager_test.go

@@ -1,315 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"crypto/ed25519"
-	"fmt"
-	"net"
-	"net/url"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/ssh"
-)
-
-func createTestAgent(t *testing.T) *Agent {
-	dataDir := t.TempDir()
-	agent, err := NewAgent(dataDir)
-	require.NoError(t, err)
-	return agent
-}
-
-func createTestServerOptions(t *testing.T) ServerOptions {
-	// Generate test key pair
-	_, privKey, err := ed25519.GenerateKey(nil)
-	require.NoError(t, err)
-	sshPubKey, err := ssh.NewPublicKey(privKey.Public().(ed25519.PublicKey))
-	require.NoError(t, err)
-
-	// Find available port
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-	port := listener.Addr().(*net.TCPAddr).Port
-	listener.Close()
-
-	return ServerOptions{
-		Network: "tcp",
-		Addr:    fmt.Sprintf("127.0.0.1:%d", port),
-		Keys:    []ssh.PublicKey{sshPubKey},
-	}
-}
-
-// TestConnectionManager_NewConnectionManager tests connection manager creation
-func TestConnectionManager_NewConnectionManager(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := newConnectionManager(agent)
-
-	assert.NotNil(t, cm, "Connection manager should not be nil")
-	assert.Equal(t, agent, cm.agent, "Agent reference should be set")
-	assert.Equal(t, Disconnected, cm.State, "Initial state should be Disconnected")
-	assert.Nil(t, cm.eventChan, "Event channel should be nil initially")
-	assert.Nil(t, cm.wsClient, "WebSocket client should be nil initially")
-	assert.Nil(t, cm.wsTicker, "WebSocket ticker should be nil initially")
-	assert.False(t, cm.isConnecting, "isConnecting should be false initially")
-}
-
-// TestConnectionManager_StateTransitions tests basic state transitions
-func TestConnectionManager_StateTransitions(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-	initialState := cm.State
-	cm.wsClient = &WebSocketClient{
-		hubURL: &url.URL{
-			Host: "localhost:8080",
-		},
-	}
-	assert.NotNil(t, cm, "Connection manager should not be nil")
-	assert.Equal(t, Disconnected, initialState, "Initial state should be Disconnected")
-
-	// Test state transitions
-	cm.handleStateChange(WebSocketConnected)
-	assert.Equal(t, WebSocketConnected, cm.State, "State should change to WebSocketConnected")
-
-	cm.handleStateChange(SSHConnected)
-	assert.Equal(t, SSHConnected, cm.State, "State should change to SSHConnected")
-
-	cm.handleStateChange(Disconnected)
-	assert.Equal(t, Disconnected, cm.State, "State should change to Disconnected")
-
-	// Test that same state doesn't trigger changes
-	cm.State = WebSocketConnected
-	cm.handleStateChange(WebSocketConnected)
-	assert.Equal(t, WebSocketConnected, cm.State, "Same state should not trigger change")
-}
-
-// TestConnectionManager_EventHandling tests event handling logic
-func TestConnectionManager_EventHandling(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-	cm.wsClient = &WebSocketClient{
-		hubURL: &url.URL{
-			Host: "localhost:8080",
-		},
-	}
-
-	testCases := []struct {
-		name          string
-		initialState  ConnectionState
-		event         ConnectionEvent
-		expectedState ConnectionState
-	}{
-		{
-			name:          "WebSocket connect from disconnected",
-			initialState:  Disconnected,
-			event:         WebSocketConnect,
-			expectedState: WebSocketConnected,
-		},
-		{
-			name:          "SSH connect from disconnected",
-			initialState:  Disconnected,
-			event:         SSHConnect,
-			expectedState: SSHConnected,
-		},
-		{
-			name:          "WebSocket disconnect from connected",
-			initialState:  WebSocketConnected,
-			event:         WebSocketDisconnect,
-			expectedState: Disconnected,
-		},
-		{
-			name:          "SSH disconnect from connected",
-			initialState:  SSHConnected,
-			event:         SSHDisconnect,
-			expectedState: Disconnected,
-		},
-		{
-			name:          "WebSocket disconnect from SSH connected (no change)",
-			initialState:  SSHConnected,
-			event:         WebSocketDisconnect,
-			expectedState: SSHConnected,
-		},
-		{
-			name:          "SSH disconnect from WebSocket connected (no change)",
-			initialState:  WebSocketConnected,
-			event:         SSHDisconnect,
-			expectedState: WebSocketConnected,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			cm.State = tc.initialState
-			cm.handleEvent(tc.event)
-			assert.Equal(t, tc.expectedState, cm.State, "State should match expected after event")
-		})
-	}
-}
-
-// TestConnectionManager_TickerManagement tests WebSocket ticker management
-func TestConnectionManager_TickerManagement(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-
-	// Test starting ticker
-	cm.startWsTicker()
-	assert.NotNil(t, cm.wsTicker, "Ticker should be created")
-
-	// Test stopping ticker (should not panic)
-	assert.NotPanics(t, func() {
-		cm.stopWsTicker()
-	}, "Stopping ticker should not panic")
-
-	// Test stopping nil ticker (should not panic)
-	cm.wsTicker = nil
-	assert.NotPanics(t, func() {
-		cm.stopWsTicker()
-	}, "Stopping nil ticker should not panic")
-
-	// Test restarting ticker
-	cm.startWsTicker()
-	assert.NotNil(t, cm.wsTicker, "Ticker should be recreated")
-
-	// Test resetting existing ticker
-	firstTicker := cm.wsTicker
-	cm.startWsTicker()
-	assert.Equal(t, firstTicker, cm.wsTicker, "Same ticker instance should be reused")
-
-	cm.stopWsTicker()
-}
-
-// TestConnectionManager_WebSocketConnectionFlow tests WebSocket connection logic
-func TestConnectionManager_WebSocketConnectionFlow(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping WebSocket connection test in short mode")
-	}
-
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-
-	// Test WebSocket connection without proper environment
-	err := cm.startWebSocketConnection()
-	assert.Error(t, err, "WebSocket connection should fail without proper environment")
-	assert.Equal(t, Disconnected, cm.State, "State should remain Disconnected after failed connection")
-
-	// Test with invalid URL
-	os.Setenv("BESZEL_AGENT_HUB_URL", "invalid-url")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	// Test with missing token
-	os.Setenv("BESZEL_AGENT_HUB_URL", "http://localhost:8080")
-	os.Unsetenv("BESZEL_AGENT_TOKEN")
-
-	_, err2 := newWebSocketClient(agent)
-	assert.Error(t, err2, "WebSocket client creation should fail without token")
-}
-
-// TestConnectionManager_ReconnectionLogic tests reconnection prevention logic
-func TestConnectionManager_ReconnectionLogic(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-	cm.eventChan = make(chan ConnectionEvent, 1)
-
-	// Test that isConnecting flag prevents duplicate reconnection attempts
-	// Start from connected state, then simulate disconnect
-	cm.State = WebSocketConnected
-	cm.isConnecting = false
-
-	// First disconnect should trigger reconnection logic
-	cm.handleStateChange(Disconnected)
-	assert.Equal(t, Disconnected, cm.State, "Should change to disconnected")
-	assert.True(t, cm.isConnecting, "Should set isConnecting flag")
-}
-
-// TestConnectionManager_ConnectWithRateLimit tests connection rate limiting
-func TestConnectionManager_ConnectWithRateLimit(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-
-	// Set up environment for WebSocket client creation
-	os.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	// Create WebSocket client
-	wsClient, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-	cm.wsClient = wsClient
-
-	// Set recent connection attempt
-	cm.wsClient.lastConnectAttempt = time.Now()
-
-	// Test that connection is rate limited
-	err = cm.startWebSocketConnection()
-	assert.Error(t, err, "Should error due to rate limiting")
-	assert.Contains(t, err.Error(), "already connecting", "Error should indicate rate limiting")
-
-	// Test connection after rate limit expires
-	cm.wsClient.lastConnectAttempt = time.Now().Add(-10 * time.Second)
-	err = cm.startWebSocketConnection()
-	// This will fail due to no actual server, but should not be rate limited
-	assert.Error(t, err, "Connection should fail but not due to rate limiting")
-	assert.NotContains(t, err.Error(), "already connecting", "Error should not indicate rate limiting")
-}
-
-// TestConnectionManager_StartWithInvalidConfig tests starting with invalid configuration
-func TestConnectionManager_StartWithInvalidConfig(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-	serverOptions := createTestServerOptions(t)
-
-	// Test starting when already started
-	cm.eventChan = make(chan ConnectionEvent, 5)
-	err := cm.Start(serverOptions)
-	assert.Error(t, err, "Should error when starting already started connection manager")
-}
-
-// TestConnectionManager_CloseWebSocket tests WebSocket closing
-func TestConnectionManager_CloseWebSocket(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-
-	// Test closing when no WebSocket client exists
-	assert.NotPanics(t, func() {
-		cm.closeWebSocket()
-	}, "Should not panic when closing nil WebSocket client")
-
-	// Set up environment and create WebSocket client
-	os.Setenv("BESZEL_AGENT_HUB_URL", "ws://localhost:8080")
-	os.Setenv("BESZEL_AGENT_TOKEN", "test-token")
-	defer func() {
-		os.Unsetenv("BESZEL_AGENT_HUB_URL")
-		os.Unsetenv("BESZEL_AGENT_TOKEN")
-	}()
-
-	wsClient, err := newWebSocketClient(agent)
-	require.NoError(t, err)
-	cm.wsClient = wsClient
-
-	// Test closing when WebSocket client exists
-	assert.NotPanics(t, func() {
-		cm.closeWebSocket()
-	}, "Should not panic when closing WebSocket client")
-}
-
-// TestConnectionManager_ConnectFlow tests the connect method
-func TestConnectionManager_ConnectFlow(t *testing.T) {
-	agent := createTestAgent(t)
-	cm := agent.connectionManager
-
-	// Test connect without WebSocket client
-	assert.NotPanics(t, func() {
-		cm.connect()
-	}, "Connect should not panic without WebSocket client")
-}

agent/data_dir.go

@@ -1,117 +0,0 @@
-package agent
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-)
-
-// 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)
-	}
-
-	dataDir, _ := GetEnv("DATA_DIR")
-	if dataDir != "" {
-		dataDirs = append(dataDirs, dataDir)
-	}
-
-	if runtime.GOOS == "windows" {
-		dataDirs = append(dataDirs,
-			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"))
-		}
-	}
-	return testDataDirs(dataDirs)
-}
-
-func testDataDirs(paths []string) (string, error) {
-	// first check if the directory exists and is writable
-	for _, path := range paths {
-		if valid, _ := isValidDataDir(path, false); valid {
-			return path, nil
-		}
-	}
-	// if the directory doesn't exist, try to create it
-	for _, path := range paths {
-		exists, _ := directoryExists(path)
-		if exists {
-			continue
-		}
-
-		if err := os.MkdirAll(path, 0755); err != nil {
-			continue
-		}
-
-		// Verify the created directory is actually writable
-		writable, _ := directoryIsWritable(path)
-		if !writable {
-			continue
-		}
-
-		return path, nil
-	}
-
-	return "", errors.New("data directory not found")
-}
-
-func isValidDataDir(path string, createIfNotExists bool) (bool, error) {
-	exists, err := directoryExists(path)
-	if err != nil {
-		return false, err
-	}
-
-	if !exists {
-		if !createIfNotExists {
-			return false, nil
-		}
-		if err = os.MkdirAll(path, 0755); err != nil {
-			return false, err
-		}
-	}
-
-	// Always check if the directory is writable
-	writable, err := directoryIsWritable(path)
-	if err != nil {
-		return false, err
-	}
-	return writable, nil
-}
-
-// directoryExists checks if a directory exists
-func directoryExists(path string) (bool, error) {
-	// Check if directory exists
-	stat, err := os.Stat(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, err
-	}
-	if !stat.IsDir() {
-		return false, fmt.Errorf("%s is not a directory", path)
-	}
-	return true, nil
-}
-
-// directoryIsWritable tests if a directory is writable by creating and removing a temporary file
-func directoryIsWritable(path string) (bool, error) {
-	testFile := filepath.Join(path, ".write-test")
-	file, err := os.Create(testFile)
-	if err != nil {
-		return false, err
-	}
-	defer file.Close()
-	defer os.Remove(testFile)
-	return true, nil
-}

agent/data_dir_test.go

@@ -1,263 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGetDataDir(t *testing.T) {
-	// Test with explicit dataDir parameter
-	t.Run("explicit data dir", func(t *testing.T) {
-		tempDir := t.TempDir()
-		result, err := getDataDir(tempDir)
-		require.NoError(t, err)
-		assert.Equal(t, tempDir, result)
-	})
-
-	// Test with explicit non-existent dataDir that can be created
-	t.Run("explicit data dir - create new", func(t *testing.T) {
-		tempDir := t.TempDir()
-		newDir := filepath.Join(tempDir, "new-data-dir")
-		result, err := getDataDir(newDir)
-		require.NoError(t, err)
-		assert.Equal(t, newDir, result)
-
-		// Verify directory was created
-		stat, err := os.Stat(newDir)
-		require.NoError(t, err)
-		assert.True(t, stat.IsDir())
-	})
-
-	// Test with DATA_DIR environment variable
-	t.Run("DATA_DIR environment variable", func(t *testing.T) {
-		tempDir := t.TempDir()
-
-		// Set environment variable
-		oldValue := os.Getenv("DATA_DIR")
-		defer func() {
-			if oldValue == "" {
-				os.Unsetenv("BESZEL_AGENT_DATA_DIR")
-			} else {
-				os.Setenv("BESZEL_AGENT_DATA_DIR", oldValue)
-			}
-		}()
-
-		os.Setenv("BESZEL_AGENT_DATA_DIR", tempDir)
-
-		result, err := getDataDir()
-		require.NoError(t, err)
-		assert.Equal(t, tempDir, result)
-	})
-
-	// Test with invalid explicit dataDir
-	t.Run("invalid explicit data dir", func(t *testing.T) {
-		invalidPath := "/invalid/path/that/cannot/be/created"
-		_, err := getDataDir(invalidPath)
-		assert.Error(t, err)
-	})
-
-	// Test fallback behavior (empty dataDir, no env var)
-	t.Run("fallback to default directories", func(t *testing.T) {
-		// Clear DATA_DIR environment variable
-		oldValue := os.Getenv("DATA_DIR")
-		defer func() {
-			if oldValue == "" {
-				os.Unsetenv("DATA_DIR")
-			} else {
-				os.Setenv("DATA_DIR", oldValue)
-			}
-		}()
-		os.Unsetenv("DATA_DIR")
-
-		// 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()
-		// 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 {
-			assert.NotEmpty(t, result)
-		}
-	})
-}
-
-func TestTestDataDirs(t *testing.T) {
-	// Test with existing valid directory
-	t.Run("existing valid directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		result, err := testDataDirs([]string{tempDir})
-		require.NoError(t, err)
-		assert.Equal(t, tempDir, result)
-	})
-
-	// Test with multiple directories, first one valid
-	t.Run("multiple dirs - first valid", func(t *testing.T) {
-		tempDir := t.TempDir()
-		invalidDir := "/invalid/path"
-		result, err := testDataDirs([]string{tempDir, invalidDir})
-		require.NoError(t, err)
-		assert.Equal(t, tempDir, result)
-	})
-
-	// Test with multiple directories, second one valid
-	t.Run("multiple dirs - second valid", func(t *testing.T) {
-		tempDir := t.TempDir()
-		invalidDir := "/invalid/path"
-		result, err := testDataDirs([]string{invalidDir, tempDir})
-		require.NoError(t, err)
-		assert.Equal(t, tempDir, result)
-	})
-
-	// Test with non-existing directory that can be created
-	t.Run("create new directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		newDir := filepath.Join(tempDir, "new-dir")
-		result, err := testDataDirs([]string{newDir})
-		require.NoError(t, err)
-		assert.Equal(t, newDir, result)
-
-		// Verify directory was created
-		stat, err := os.Stat(newDir)
-		require.NoError(t, err)
-		assert.True(t, stat.IsDir())
-	})
-
-	// Test with no valid directories
-	t.Run("no valid directories", func(t *testing.T) {
-		invalidPaths := []string{"/invalid/path1", "/invalid/path2"}
-		_, err := testDataDirs(invalidPaths)
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "data directory not found")
-	})
-}
-
-func TestIsValidDataDir(t *testing.T) {
-	// Test with existing directory
-	t.Run("existing directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		valid, err := isValidDataDir(tempDir, false)
-		require.NoError(t, err)
-		assert.True(t, valid)
-	})
-
-	// Test with non-existing directory, createIfNotExists=false
-	t.Run("non-existing dir - no create", func(t *testing.T) {
-		tempDir := t.TempDir()
-		nonExistentDir := filepath.Join(tempDir, "does-not-exist")
-		valid, err := isValidDataDir(nonExistentDir, false)
-		require.NoError(t, err)
-		assert.False(t, valid)
-	})
-
-	// Test with non-existing directory, createIfNotExists=true
-	t.Run("non-existing dir - create", func(t *testing.T) {
-		tempDir := t.TempDir()
-		newDir := filepath.Join(tempDir, "new-dir")
-		valid, err := isValidDataDir(newDir, true)
-		require.NoError(t, err)
-		assert.True(t, valid)
-
-		// Verify directory was created
-		stat, err := os.Stat(newDir)
-		require.NoError(t, err)
-		assert.True(t, stat.IsDir())
-	})
-
-	// Test with file instead of directory
-	t.Run("file instead of directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		tempFile := filepath.Join(tempDir, "testfile")
-		err := os.WriteFile(tempFile, []byte("test"), 0644)
-		require.NoError(t, err)
-
-		valid, err := isValidDataDir(tempFile, false)
-		assert.Error(t, err)
-		assert.False(t, valid)
-		assert.Contains(t, err.Error(), "is not a directory")
-	})
-}
-
-func TestDirectoryExists(t *testing.T) {
-	// Test with existing directory
-	t.Run("existing directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		exists, err := directoryExists(tempDir)
-		require.NoError(t, err)
-		assert.True(t, exists)
-	})
-
-	// Test with non-existing directory
-	t.Run("non-existing directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		nonExistentDir := filepath.Join(tempDir, "does-not-exist")
-		exists, err := directoryExists(nonExistentDir)
-		require.NoError(t, err)
-		assert.False(t, exists)
-	})
-
-	// Test with file instead of directory
-	t.Run("file instead of directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		tempFile := filepath.Join(tempDir, "testfile")
-		err := os.WriteFile(tempFile, []byte("test"), 0644)
-		require.NoError(t, err)
-
-		exists, err := directoryExists(tempFile)
-		assert.Error(t, err)
-		assert.False(t, exists)
-		assert.Contains(t, err.Error(), "is not a directory")
-	})
-}
-
-func TestDirectoryIsWritable(t *testing.T) {
-	// Test with writable directory
-	t.Run("writable directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		writable, err := directoryIsWritable(tempDir)
-		require.NoError(t, err)
-		assert.True(t, writable)
-	})
-
-	// Test with non-existing directory
-	t.Run("non-existing directory", func(t *testing.T) {
-		tempDir := t.TempDir()
-		nonExistentDir := filepath.Join(tempDir, "does-not-exist")
-		writable, err := directoryIsWritable(nonExistentDir)
-		assert.Error(t, err)
-		assert.False(t, writable)
-	})
-
-	// Test with non-writable directory (Unix-like systems only)
-	t.Run("non-writable directory", func(t *testing.T) {
-		if runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
-			t.Skip("Skipping non-writable directory test on", runtime.GOOS)
-		}
-
-		tempDir := t.TempDir()
-		readOnlyDir := filepath.Join(tempDir, "readonly")
-
-		// Create the directory
-		err := os.Mkdir(readOnlyDir, 0755)
-		require.NoError(t, err)
-
-		// Make it read-only
-		err = os.Chmod(readOnlyDir, 0444)
-		require.NoError(t, err)
-
-		// Restore permissions after test for cleanup
-		defer func() {
-			os.Chmod(readOnlyDir, 0755)
-		}()
-
-		writable, err := directoryIsWritable(readOnlyDir)
-		assert.Error(t, err)
-		assert.False(t, writable)
-	})
-}

agent/deltatracker/deltatracker.go

@@ -1,81 +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
-}
-
-// 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
-}
-
-// 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/gpu_intel.go

@@ -1,102 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"fmt"
-	"os/exec"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-)
-
-const (
-	intelGpuStatsCmd      string = "intel_gpu_top"
-	intelGpuStatsInterval string = "3300" // in milliseconds
-)
-
-type intelGpuStats struct {
-	Power struct {
-		GPU float64 `json:"GPU"`
-	} `json:"power"`
-	Engines map[string]struct {
-		Busy float64 `json:"busy"`
-	} `json:"engines"`
-}
-
-// updateIntelFromStats updates aggregated GPU data from a single intelGpuStats sample
-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
-	}
-
-	if sample.Power.GPU > 0 {
-		gpuData.Power += sample.Power.GPU
-	}
-
-	if gpuData.Engines == nil {
-		gpuData.Engines = make(map[string]float64, len(sample.Engines))
-	}
-	for name, engine := range sample.Engines {
-		gpuData.Engines[name] += engine.Busy
-	}
-
-	gpuData.Count++
-	return true
-}
-
-// collectIntelStats executes intel_gpu_top in JSON mode and stream-decodes the array of samples
-func (gm *GPUManager) collectIntelStats() error {
-	cmd := exec.Command(intelGpuStatsCmd, "-s", intelGpuStatsInterval, "-J")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	dec := json.NewDecoder(stdout)
-
-	// Expect a JSON array stream: [ { ... }, { ... }, ... ]
-	tok, err := dec.Token()
-	if err != nil {
-		return err
-	}
-	if delim, ok := tok.(json.Delim); !ok || delim != '[' {
-		return fmt.Errorf("unexpected JSON start token: %v", tok)
-	}
-
-	var sample intelGpuStats
-	for {
-		if dec.More() {
-			// Clear the engines map before decoding
-			if sample.Engines != nil {
-				for k := range sample.Engines {
-					delete(sample.Engines, k)
-				}
-			}
-
-			if err := dec.Decode(&sample); err != nil {
-				return fmt.Errorf("decode intel gpu: %w", err)
-			}
-			gm.updateIntelFromStats(&sample)
-			continue
-		}
-		// Attempt to read closing bracket (will only be present when process exits)
-		tok, err = dec.Token()
-		if err != nil {
-			// When the process is still running, decoder will block in More/Decode; any error here is terminal
-			return err
-		}
-		if delim, ok := tok.(json.Delim); ok && delim == ']' {
-			break
-		}
-	}
-
-	return cmd.Wait()
-}

agent/gpu_test.go

@@ -1,887 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/system"
-
-	"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)
-			}
-		})
-	}
-}
-
-func TestIntelUpdateFromStats(t *testing.T) {
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-
-	// First sample with power and two engines
-	sample1 := intelGpuStats{
-		Engines: map[string]struct {
-			Busy float64 `json:"busy"`
-		}{
-			"Render/3D": {Busy: 20.0},
-			"Video":     {Busy: 5.0},
-		},
-	}
-	sample1.Power.GPU = 10.5
-
-	ok := gm.updateIntelFromStats(&sample1)
-	assert.True(t, ok)
-
-	gpu := gm.GpuDataMap["0"]
-	require.NotNil(t, gpu)
-	assert.Equal(t, "GPU", gpu.Name)
-	assert.InDelta(t, 10.5, gpu.Power, 0.001)
-	assert.InDelta(t, 20.0, gpu.Engines["Render/3D"], 0.001)
-	assert.InDelta(t, 5.0, gpu.Engines["Video"], 0.001)
-	assert.Equal(t, float64(1), gpu.Count)
-
-	// Second sample with zero power (should not add) and additional engine busy
-	sample2 := intelGpuStats{
-		Engines: map[string]struct {
-			Busy float64 `json:"busy"`
-		}{
-			"Render/3D": {Busy: 10.0},
-			"Video":     {Busy: 2.5},
-			"Blitter":   {Busy: 1.0},
-		},
-	}
-	// zero power should not increment power accumulator
-	sample2.Power.GPU = 0.0
-
-	ok = gm.updateIntelFromStats(&sample2)
-	assert.True(t, ok)
-
-	gpu = gm.GpuDataMap["0"]
-	require.NotNil(t, gpu)
-	assert.InDelta(t, 10.5, gpu.Power, 0.001)
-	assert.InDelta(t, 30.0, gpu.Engines["Render/3D"], 0.001) // 20 + 10
-	assert.InDelta(t, 7.5, gpu.Engines["Video"], 0.001)      // 5 + 2.5
-	assert.InDelta(t, 1.0, gpu.Engines["Blitter"], 0.001)
-	assert.Equal(t, float64(2), gpu.Count)
-}
-
-func TestIntelCollectorStreaming(t *testing.T) {
-	// Save and override PATH
-	origPath := os.Getenv("PATH")
-	defer os.Setenv("PATH", origPath)
-
-	dir := t.TempDir()
-	os.Setenv("PATH", dir)
-
-	// Create a fake intel_gpu_top that prints a JSON array with two samples and exits
-	scriptPath := filepath.Join(dir, "intel_gpu_top")
-	script := `#!/bin/sh
-# Ignore args -s and -J
-# Emit a JSON array with two objects, separated by a comma, then exit
-(echo '['; \
- echo '{"power":{"GPU":1.5},"engines":{"Render/3D":{"busy":12.34}}},'; \
- echo '{"power":{"GPU":2.0},"engines":{"Video":{"busy":5}}}'; \
- echo ']')`
-	if err := os.WriteFile(scriptPath, []byte(script), 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	gm := &GPUManager{
-		GpuDataMap: make(map[string]*system.GPUData),
-	}
-
-	// Run the collector once; it should read two samples and return
-	if err := gm.collectIntelStats(); err != nil {
-		t.Fatalf("collectIntelStats error: %v", err)
-	}
-
-	gpu := gm.GpuDataMap["0"]
-	require.NotNil(t, gpu)
-	// Power should be sum of non-zero samples: 1.5 + 2.0 = 3.5
-	assert.InDelta(t, 3.5, gpu.Power, 0.001)
-	// Engines aggregated
-	assert.InDelta(t, 12.34, gpu.Engines["Render/3D"], 0.001)
-	assert.InDelta(t, 5.0, gpu.Engines["Video"], 0.001)
-	// Count should be 2 samples
-	assert.Equal(t, float64(2), gpu.Count)
-}

agent/health/health.go

@@ -1,43 +0,0 @@
-// Package health provides functions to check and update the health of the agent.
-// It uses a file in the temp directory to store the timestamp of the last connection attempt.
-// If the timestamp is older than 90 seconds, the agent is considered unhealthy.
-// NB: The agent must be started with the Start() method to be considered healthy.
-package health
-
-import (
-	"errors"
-	"log"
-	"os"
-	"path/filepath"
-	"time"
-)
-
-// healthFile is the path to the health file
-var healthFile = filepath.Join(os.TempDir(), "beszel_health")
-
-// Check checks if the agent is connected by checking the modification time of the health file
-func Check() error {
-	fileInfo, err := os.Stat(healthFile)
-	if err != nil {
-		return err
-	}
-	if time.Since(fileInfo.ModTime()) > 91*time.Second {
-		log.Println("over 90 seconds since last connection")
-		return errors.New("unhealthy")
-	}
-	return nil
-}
-
-// Update updates the modification time of the health file
-func Update() error {
-	file, err := os.Create(healthFile)
-	if err != nil {
-		return err
-	}
-	return file.Close()
-}
-
-// CleanUp removes the health file
-func CleanUp() error {
-	return os.Remove(healthFile)
-}

agent/health/health_test.go

@@ -1,67 +0,0 @@
-//go:build testing
-// +build testing
-
-package health
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"testing/synctest"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestHealth(t *testing.T) {
-	// Override healthFile to use a temporary directory for this test.
-	originalHealthFile := healthFile
-	tmpDir := t.TempDir()
-	healthFile = filepath.Join(tmpDir, "beszel_health_test")
-	defer func() { healthFile = originalHealthFile }()
-
-	t.Run("check with no health file", func(t *testing.T) {
-		err := Check()
-		require.Error(t, err)
-		assert.True(t, os.IsNotExist(err), "expected a file-not-exist error, but got: %v", err)
-	})
-
-	t.Run("update and check", func(t *testing.T) {
-		err := Update()
-		require.NoError(t, err, "Update() failed")
-
-		err = Check()
-		assert.NoError(t, err, "Check() failed immediately after Update()")
-	})
-
-	// 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) {
-			// Update the file to set the initial timestamp.
-			require.NoError(t, Update(), "Update() failed inside synctest")
-
-			// Set the mtime to the current fake time to align the file's timestamp with the simulated clock.
-			now := time.Now()
-			require.NoError(t, os.Chtimes(healthFile, now, now), "Chtimes failed")
-
-			// Wait a duration less than the threshold.
-			time.Sleep(89 * time.Second)
-			synctest.Wait()
-
-			// The check should still pass.
-			assert.NoError(t, Check(), "Check() failed after 89s")
-
-			// Wait for the total duration to exceed the threshold.
-			time.Sleep(5 * time.Second)
-			synctest.Wait()
-
-			// The check should now fail as unhealthy.
-			err := Check()
-			require.Error(t, err, "Check() should have failed after 91s")
-			assert.Equal(t, "unhealthy", err.Error(), "Check() returned wrong error")
-		})
-	})
-}

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,144 +0,0 @@
-package agent
-
-import (
-	"fmt"
-	"log/slog"
-	"strings"
-	"time"
-
-	"github.com/henrygd/beszel/agent/deltatracker"
-	"github.com/henrygd/beszel/internal/entities/system"
-	psutilNet "github.com/shirou/gopsutil/v4/net"
-)
-
-var netInterfaceDeltaTracker = deltatracker.NewDeltaTracker[string, uint64]()
-
-func (a *Agent) updateNetworkStats(systemStats *system.Stats) {
-	// 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 systemStats.NetworkInterfaces == nil {
-		systemStats.NetworkInterfaces = make(map[string][4]uint64, 0)
-	}
-
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		msElapsed := uint64(time.Since(a.netIoStats.Time).Milliseconds())
-		a.netIoStats.Time = time.Now()
-		totalBytesSent := uint64(0)
-		totalBytesRecv := uint64(0)
-		netInterfaceDeltaTracker.Cycle()
-		// sum all bytes sent and received
-		for _, v := range netIO {
-			// skip if not in valid network interfaces list
-			if _, exists := a.netInterfaces[v.Name]; !exists {
-				continue
-			}
-			totalBytesSent += v.BytesSent
-			totalBytesRecv += v.BytesRecv
-
-			// track deltas for each network interface
-			var upDelta, downDelta uint64
-			upKey, downKey := fmt.Sprintf("%sup", v.Name), fmt.Sprintf("%sdown", v.Name)
-			netInterfaceDeltaTracker.Set(upKey, v.BytesSent)
-			netInterfaceDeltaTracker.Set(downKey, v.BytesRecv)
-			if msElapsed > 0 {
-				upDelta = netInterfaceDeltaTracker.Delta(upKey) * 1000 / msElapsed
-				downDelta = netInterfaceDeltaTracker.Delta(downKey) * 1000 / msElapsed
-			}
-			// add interface to systemStats
-			systemStats.NetworkInterfaces[v.Name] = [4]uint64{upDelta, downDelta, v.BytesSent, v.BytesRecv}
-		}
-
-		// add to systemStats
-		var bytesSentPerSecond, bytesRecvPerSecond uint64
-		if msElapsed > 0 {
-			bytesSentPerSecond = (totalBytesSent - a.netIoStats.BytesSent) * 1000 / msElapsed
-			bytesRecvPerSecond = (totalBytesRecv - a.netIoStats.BytesRecv) * 1000 / msElapsed
-		}
-		networkSentPs := bytesToMegabytes(float64(bytesSentPerSecond))
-		networkRecvPs := bytesToMegabytes(float64(bytesRecvPerSecond))
-		// add check for issue (#150) where sent is a massive number
-		if networkSentPs > 10_000 || networkRecvPs > 10_000 {
-			slog.Warn("Invalid net stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
-			for _, v := range netIO {
-				if _, exists := a.netInterfaces[v.Name]; !exists {
-					continue
-				}
-				slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
-			}
-			// reset network I/O stats
-			a.initializeNetIoStats()
-		} else {
-			systemStats.NetworkSent = networkSentPs
-			systemStats.NetworkRecv = networkRecvPs
-			systemStats.Bandwidth[0], systemStats.Bandwidth[1] = bytesSentPerSecond, bytesRecvPerSecond
-			// update netIoStats
-			a.netIoStats.BytesSent = totalBytesSent
-			a.netIoStats.BytesRecv = totalBytesRecv
-		}
-	}
-}
-
-func (a *Agent) initializeNetIoStats() {
-	// reset valid network interfaces
-	a.netInterfaces = make(map[string]struct{}, 0)
-
-	// map of network interface names passed in via NICS env var
-	var nicsMap map[string]struct{}
-	nics, nicsEnvExists := GetEnv("NICS")
-	if nicsEnvExists {
-		nicsMap = make(map[string]struct{}, 0)
-		for nic := range strings.SplitSeq(nics, ",") {
-			nicsMap[nic] = struct{}{}
-		}
-	}
-
-	// 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
-	}
-}

agent/sensors.go

@@ -1,198 +0,0 @@
-package agent
-
-import (
-	"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"
-)
-
-type SensorConfig struct {
-	context        context.Context
-	sensors        map[string]struct{}
-	primarySensor  string
-	isBlacklist    bool
-	hasWildcards   bool
-	skipCollection bool
-}
-
-func (a *Agent) newSensorConfig() *SensorConfig {
-	primarySensor, _ := GetEnv("PRIMARY_SENSOR")
-	sysSensors, _ := GetEnv("SYS_SENSORS")
-	sensorsEnvVal, sensorsSet := GetEnv("SENSORS")
-	skipCollection := sensorsSet && sensorsEnvVal == ""
-
-	return a.newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal, skipCollection)
-}
-
-// Matches sensors.TemperaturesWithContext to allow for panic recovery (gopsutil/issues/1832)
-type getTempsFn func(ctx context.Context) ([]sensors.TemperatureStat, error)
-
-// newSensorConfigWithEnv creates a SensorConfig with the provided environment variables
-// sensorsSet indicates if the SENSORS environment variable was explicitly set (even to empty string)
-func (a *Agent) newSensorConfigWithEnv(primarySensor, sysSensors, sensorsEnvVal string, skipCollection bool) *SensorConfig {
-	config := &SensorConfig{
-		context:        context.Background(),
-		primarySensor:  primarySensor,
-		skipCollection: skipCollection,
-		sensors:        make(map[string]struct{}),
-	}
-
-	// Set sensors context (allows overriding sys location for sensors)
-	if sysSensors != "" {
-		slog.Info("SYS_SENSORS", "path", sysSensors)
-		config.context = context.WithValue(config.context,
-			common.EnvKey, common.EnvMap{common.HostSysEnvKey: sysSensors},
-		)
-	}
-
-	// handle blacklist
-	if strings.HasPrefix(sensorsEnvVal, "-") {
-		config.isBlacklist = true
-		sensorsEnvVal = sensorsEnvVal[1:]
-	}
-
-	for sensor := range strings.SplitSeq(sensorsEnvVal, ",") {
-		sensor = strings.TrimSpace(sensor)
-		if sensor != "" {
-			config.sensors[sensor] = struct{}{}
-			if strings.Contains(sensor, "*") {
-				config.hasWildcards = true
-			}
-		}
-	}
-
-	return config
-}
-
-// updateTemperatures updates the agent with the latest sensor temperatures
-func (a *Agent) updateTemperatures(systemStats *system.Stats) {
-	// skip if sensors whitelist is set to empty string
-	if a.sensorConfig.skipCollection {
-		slog.Debug("Skipping temperature collection")
-		return
-	}
-
-	// reset high temp
-	a.systemInfo.DashboardTemp = 0
-
-	temps, err := a.getTempsWithPanicRecovery(getSensorTemps)
-	if err != nil {
-		// retry once on panic (gopsutil/issues/1832)
-		temps, err = a.getTempsWithPanicRecovery(getSensorTemps)
-		if err != nil {
-			slog.Warn("Error updating temperatures", "err", err)
-			if len(systemStats.Temperatures) > 0 {
-				systemStats.Temperatures = make(map[string]float64)
-			}
-			return
-		}
-	}
-	slog.Debug("Temperature", "sensors", temps)
-
-	// return if no sensors
-	if len(temps) == 0 {
-		return
-	}
-
-	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)
-		}
-		// skip if temperature is unreasonable
-		if sensor.Temperature <= 0 || sensor.Temperature >= 200 {
-			continue
-		}
-		sensorName := sensor.SensorKey
-		if _, ok := systemStats.Temperatures[sensorName]; ok {
-			// if key already exists, append int to key
-			sensorName = sensorName + "_" + strconv.Itoa(i)
-		}
-		// skip if not in whitelist or blacklist
-		if !isValidSensor(sensorName, a.sensorConfig) {
-			continue
-		}
-		// set dashboard temperature
-		switch a.sensorConfig.primarySensor {
-		case "":
-			a.systemInfo.DashboardTemp = max(a.systemInfo.DashboardTemp, sensor.Temperature)
-		case sensorName:
-			a.systemInfo.DashboardTemp = sensor.Temperature
-		}
-		systemStats.Temperatures[sensorName] = twoDecimals(sensor.Temperature)
-	}
-}
-
-// getTempsWithPanicRecovery wraps sensors.TemperaturesWithContext to recover from panics (gopsutil/issues/1832)
-func (a *Agent) getTempsWithPanicRecovery(getTemps getTempsFn) (temps []sensors.TemperatureStat, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			err = fmt.Errorf("panic: %v", r)
-		}
-	}()
-	// get sensor data (error ignored intentionally as it may be only with one sensor)
-	temps, _ = getTemps(a.sensorConfig.context)
-	return
-}
-
-// isValidSensor checks if a sensor is valid based on the sensor name and the sensor config
-func isValidSensor(sensorName string, config *SensorConfig) bool {
-	// if no sensors configured, everything is valid
-	if len(config.sensors) == 0 {
-		return true
-	}
-
-	// Exact match - return true if whitelist, false if blacklist
-	if _, exactMatch := config.sensors[sensorName]; exactMatch {
-		return !config.isBlacklist
-	}
-
-	// If no wildcards, return true if blacklist, false if whitelist
-	if !config.hasWildcards {
-		return config.isBlacklist
-	}
-
-	// Check for wildcard patterns
-	for pattern := range config.sensors {
-		if !strings.Contains(pattern, "*") {
-			continue
-		}
-		if match, _ := path.Match(pattern, sensorName); match {
-			return !config.isBlacklist
-		}
-	}
-
-	return config.isBlacklist
-}
-
-// scaleTemperature scales temperatures in fractional values to reasonable Celsius values
-func scaleTemperature(temp float64) float64 {
-	if temp > 1 {
-		return temp
-	}
-	scaled100 := temp * 100
-	scaled1000 := temp * 1000
-
-	if scaled100 >= 15 && scaled100 <= 95 {
-		return scaled100
-	} else if scaled1000 >= 15 && scaled1000 <= 95 {
-		return scaled1000
-	}
-	return scaled100
-}

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_test.go

@@ -1,554 +0,0 @@
-//go:build testing
-// +build testing
-
-package agent
-
-import (
-	"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"
-	"github.com/stretchr/testify/require"
-)
-
-func TestIsValidSensor(t *testing.T) {
-	tests := []struct {
-		name          string
-		sensorName    string
-		config        *SensorConfig
-		expectedValid bool
-	}{
-		{
-			name:       "Whitelist - sensor in list",
-			sensorName: "cpu_temp",
-			config: &SensorConfig{
-				sensors:     map[string]struct{}{"cpu_temp": {}},
-				isBlacklist: false,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Whitelist - sensor not in list",
-			sensorName: "gpu_temp",
-			config: &SensorConfig{
-				sensors:     map[string]struct{}{"cpu_temp": {}},
-				isBlacklist: false,
-			},
-			expectedValid: false,
-		},
-		{
-			name:       "Blacklist - sensor in list",
-			sensorName: "cpu_temp",
-			config: &SensorConfig{
-				sensors:     map[string]struct{}{"cpu_temp": {}},
-				isBlacklist: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:       "Blacklist - sensor not in list",
-			sensorName: "gpu_temp",
-			config: &SensorConfig{
-				sensors:     map[string]struct{}{"cpu_temp": {}},
-				isBlacklist: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Whitelist with wildcard - matching pattern",
-			sensorName: "core_0_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"core_*_temp": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Whitelist with wildcard - non-matching pattern",
-			sensorName: "gpu_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"core_*_temp": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:       "Blacklist with wildcard - matching pattern",
-			sensorName: "core_0_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"core_*_temp": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:       "Blacklist with wildcard - non-matching pattern",
-			sensorName: "gpu_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"core_*_temp": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "No sensors configured",
-			sensorName: "any_temp",
-			config: &SensorConfig{
-				sensors:        map[string]struct{}{},
-				isBlacklist:    false,
-				hasWildcards:   false,
-				skipCollection: false,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Mixed patterns in whitelist - exact match",
-			sensorName: "cpu_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"cpu_temp": {}, "core_*_temp": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Mixed patterns in whitelist - wildcard match",
-			sensorName: "core_1_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"cpu_temp": {}, "core_*_temp": {}},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-			expectedValid: true,
-		},
-		{
-			name:       "Mixed patterns in blacklist - exact match",
-			sensorName: "cpu_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"cpu_temp": {}, "core_*_temp": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-		{
-			name:       "Mixed patterns in blacklist - wildcard match",
-			sensorName: "core_1_temp",
-			config: &SensorConfig{
-				sensors:      map[string]struct{}{"cpu_temp": {}, "core_*_temp": {}},
-				isBlacklist:  true,
-				hasWildcards: true,
-			},
-			expectedValid: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isValidSensor(tt.sensorName, tt.config)
-			assert.Equal(t, tt.expectedValid, result, "isValidSensor(%q, config) returned unexpected result", tt.sensorName)
-		})
-	}
-}
-
-func TestNewSensorConfigWithEnv(t *testing.T) {
-	agent := &Agent{}
-
-	tests := []struct {
-		name           string
-		primarySensor  string
-		sysSensors     string
-		sensors        string
-		skipCollection bool
-		expectedConfig *SensorConfig
-	}{
-		{
-			name:          "Empty configuration",
-			primarySensor: "",
-			sysSensors:    "",
-			sensors:       "",
-			expectedConfig: &SensorConfig{
-				context:        context.Background(),
-				primarySensor:  "",
-				sensors:        map[string]struct{}{},
-				isBlacklist:    false,
-				hasWildcards:   false,
-				skipCollection: false,
-			},
-		},
-		{
-			name:           "Explicitly set to empty string",
-			primarySensor:  "",
-			sysSensors:     "",
-			sensors:        "",
-			skipCollection: true,
-			expectedConfig: &SensorConfig{
-				context:        context.Background(),
-				primarySensor:  "",
-				sensors:        map[string]struct{}{},
-				isBlacklist:    false,
-				hasWildcards:   false,
-				skipCollection: true,
-			},
-		},
-		{
-			name:          "Primary sensor only - should create sensor map",
-			primarySensor: "cpu_temp",
-			sysSensors:    "",
-			sensors:       "",
-			expectedConfig: &SensorConfig{
-				context:       context.Background(),
-				primarySensor: "cpu_temp",
-				sensors:       map[string]struct{}{},
-				isBlacklist:   false,
-				hasWildcards:  false,
-			},
-		},
-		{
-			name:          "Whitelist sensors",
-			primarySensor: "cpu_temp",
-			sysSensors:    "",
-			sensors:       "cpu_temp,gpu_temp",
-			expectedConfig: &SensorConfig{
-				context:       context.Background(),
-				primarySensor: "cpu_temp",
-				sensors: map[string]struct{}{
-					"cpu_temp": {},
-					"gpu_temp": {},
-				},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:          "Blacklist sensors",
-			primarySensor: "cpu_temp",
-			sysSensors:    "",
-			sensors:       "-cpu_temp,gpu_temp",
-			expectedConfig: &SensorConfig{
-				context:       context.Background(),
-				primarySensor: "cpu_temp",
-				sensors: map[string]struct{}{
-					"cpu_temp": {},
-					"gpu_temp": {},
-				},
-				isBlacklist:  true,
-				hasWildcards: false,
-			},
-		},
-		{
-			name:          "Sensors with wildcard",
-			primarySensor: "cpu_temp",
-			sysSensors:    "",
-			sensors:       "cpu_*,gpu_temp",
-			expectedConfig: &SensorConfig{
-				context:       context.Background(),
-				primarySensor: "cpu_temp",
-				sensors: map[string]struct{}{
-					"cpu_*":    {},
-					"gpu_temp": {},
-				},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-		},
-		{
-			name:          "Sensors with whitespace",
-			primarySensor: "cpu_temp",
-			sysSensors:    "",
-			sensors:       "cpu_*, gpu_temp",
-			expectedConfig: &SensorConfig{
-				context:       context.Background(),
-				primarySensor: "cpu_temp",
-				sensors: map[string]struct{}{
-					"cpu_*":    {},
-					"gpu_temp": {},
-				},
-				isBlacklist:  false,
-				hasWildcards: true,
-			},
-		},
-		{
-			name:          "With SYS_SENSORS path",
-			primarySensor: "cpu_temp",
-			sysSensors:    "/custom/path",
-			sensors:       "cpu_temp",
-			expectedConfig: &SensorConfig{
-				primarySensor: "cpu_temp",
-				sensors: map[string]struct{}{
-					"cpu_temp": {},
-				},
-				isBlacklist:  false,
-				hasWildcards: false,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := agent.newSensorConfigWithEnv(tt.primarySensor, tt.sysSensors, tt.sensors, tt.skipCollection)
-
-			// Check primary sensor
-			assert.Equal(t, tt.expectedConfig.primarySensor, result.primarySensor)
-
-			// Check sensor map
-			if tt.expectedConfig.sensors == nil {
-				assert.Nil(t, result.sensors)
-			} else {
-				assert.Equal(t, len(tt.expectedConfig.sensors), len(result.sensors))
-				for sensor := range tt.expectedConfig.sensors {
-					_, exists := result.sensors[sensor]
-					assert.True(t, exists, "Sensor %s should exist in the result", sensor)
-				}
-			}
-
-			// Check flags
-			assert.Equal(t, tt.expectedConfig.isBlacklist, result.isBlacklist)
-			assert.Equal(t, tt.expectedConfig.hasWildcards, result.hasWildcards)
-
-			// Check context
-			if tt.sysSensors != "" {
-				// Verify context contains correct values
-				envMap, ok := result.context.Value(common.EnvKey).(common.EnvMap)
-				require.True(t, ok, "Context should contain EnvMap")
-				sysPath, ok := envMap[common.HostSysEnvKey]
-				require.True(t, ok, "EnvMap should contain HostSysEnvKey")
-				assert.Equal(t, tt.sysSensors, sysPath)
-			}
-		})
-	}
-}
-
-func TestNewSensorConfig(t *testing.T) {
-	// Save original environment variables
-	originalPrimary, hasPrimary := os.LookupEnv("BESZEL_AGENT_PRIMARY_SENSOR")
-	originalSys, hasSys := os.LookupEnv("BESZEL_AGENT_SYS_SENSORS")
-	originalSensors, hasSensors := os.LookupEnv("BESZEL_AGENT_SENSORS")
-
-	// Restore environment variables after the test
-	defer func() {
-		// Clean up test environment variables
-		os.Unsetenv("BESZEL_AGENT_PRIMARY_SENSOR")
-		os.Unsetenv("BESZEL_AGENT_SYS_SENSORS")
-		os.Unsetenv("BESZEL_AGENT_SENSORS")
-
-		// Restore original values if they existed
-		if hasPrimary {
-			os.Setenv("BESZEL_AGENT_PRIMARY_SENSOR", originalPrimary)
-		}
-		if hasSys {
-			os.Setenv("BESZEL_AGENT_SYS_SENSORS", originalSys)
-		}
-		if hasSensors {
-			os.Setenv("BESZEL_AGENT_SENSORS", originalSensors)
-		}
-	}()
-
-	// Set test environment variables
-	os.Setenv("BESZEL_AGENT_PRIMARY_SENSOR", "test_primary")
-	os.Setenv("BESZEL_AGENT_SYS_SENSORS", "/test/path")
-	os.Setenv("BESZEL_AGENT_SENSORS", "test_sensor1,test_*,test_sensor3")
-
-	agent := &Agent{}
-	result := agent.newSensorConfig()
-
-	// Verify results
-	assert.Equal(t, "test_primary", result.primarySensor)
-	assert.NotNil(t, result.sensors)
-	assert.Equal(t, 3, len(result.sensors))
-	assert.True(t, result.hasWildcards)
-	assert.False(t, result.isBlacklist)
-
-	// Check that sys sensors path is in context
-	envMap, ok := result.context.Value(common.EnvKey).(common.EnvMap)
-	require.True(t, ok, "Context should contain EnvMap")
-	sysPath, ok := envMap[common.HostSysEnvKey]
-	require.True(t, ok, "EnvMap should contain HostSysEnvKey")
-	assert.Equal(t, "/test/path", sysPath)
-}
-
-func TestScaleTemperature(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    float64
-		expected float64
-		desc     string
-	}{
-		// Normal temperatures (no scaling needed)
-		{"normal_cpu_temp", 45.0, 45.0, "Normal CPU temperature"},
-		{"normal_room_temp", 25.0, 25.0, "Normal room temperature"},
-		{"high_cpu_temp", 85.0, 85.0, "High CPU temperature"},
-		// Zero temperature
-		{"zero_temp", 0.0, 0.0, "Zero temperature"},
-		// Fractional values that should use 100x scaling
-		{"fractional_45c", 0.45, 45.0, "0.45 should become 45°C (100x)"},
-		{"fractional_25c", 0.25, 25.0, "0.25 should become 25°C (100x)"},
-		{"fractional_60c", 0.60, 60.0, "0.60 should become 60°C (100x)"},
-		{"fractional_75c", 0.75, 75.0, "0.75 should become 75°C (100x)"},
-		{"fractional_30c", 0.30, 30.0, "0.30 should become 30°C (100x)"},
-		// Fractional values that should use 1000x scaling
-		{"millifractional_45c", 0.045, 45.0, "0.045 should become 45°C (1000x)"},
-		{"millifractional_25c", 0.025, 25.0, "0.025 should become 25°C (1000x)"},
-		{"millifractional_60c", 0.060, 60.0, "0.060 should become 60°C (1000x)"},
-		{"millifractional_75c", 0.075, 75.0, "0.075 should become 75°C (1000x)"},
-		{"millifractional_35c", 0.035, 35.0, "0.035 should become 35°C (1000x)"},
-		// Edge cases - values outside reasonable range
-		{"very_low_fractional", 0.01, 1.0, "0.01 should default to 100x scaling (1°C)"},
-		{"very_high_fractional", 0.99, 99.0, "0.99 should default to 100x scaling (99°C)"},
-		{"extremely_low", 0.001, 0.1, "0.001 should default to 100x scaling (0.1°C)"},
-		// Boundary cases around the reasonable range (15-95°C)
-		{"boundary_low_100x", 0.15, 15.0, "0.15 should use 100x scaling (15°C)"},
-		{"boundary_high_100x", 0.95, 95.0, "0.95 should use 100x scaling (95°C)"},
-		{"boundary_low_1000x", 0.015, 15.0, "0.015 should use 1000x scaling (15°C)"},
-		{"boundary_high_1000x", 0.095, 95.0, "0.095 should use 1000x scaling (95°C)"},
-		// Values just outside reasonable range
-		{"just_below_range_100x", 0.14, 14.0, "0.14 should default to 100x (14°C)"},
-		{"just_above_range_100x", 0.96, 96.0, "0.96 should default to 100x (96°C)"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := scaleTemperature(tt.input)
-			assert.InDelta(t, tt.expected, result, 0.001,
-				"scaleTemperature(%v) = %v, expected %v (%s)",
-				tt.input, result, tt.expected, tt.desc)
-		})
-	}
-}
-
-func TestScaleTemperatureLogic(t *testing.T) {
-	// Test the logic flow for ambiguous cases
-	t.Run("prefers_100x_when_both_valid", func(t *testing.T) {
-		// 0.5 could be 50°C (100x) or 500°C (1000x)
-		// Should prefer 100x since it's tried first and is in range
-		result := scaleTemperature(0.5)
-		expected := 50.0
-		assert.InDelta(t, expected, result, 0.001,
-			"scaleTemperature(0.5) = %v, expected %v (should prefer 100x scaling)",
-			result, expected)
-	})
-
-	t.Run("uses_1000x_when_100x_too_low", func(t *testing.T) {
-		// 0.05 -> 5°C (100x, too low) or 50°C (1000x, in range)
-		// Should use 1000x since 100x is below reasonable range
-		result := scaleTemperature(0.05)
-		expected := 50.0
-		assert.InDelta(t, expected, result, 0.001,
-			"scaleTemperature(0.05) = %v, expected %v (should use 1000x scaling)",
-			result, expected)
-	})
-
-	t.Run("defaults_to_100x_when_both_invalid", func(t *testing.T) {
-		// 0.005 -> 0.5°C (100x, too low) or 5°C (1000x, too low)
-		// Should default to 100x scaling
-		result := scaleTemperature(0.005)
-		expected := 0.5
-		assert.InDelta(t, expected, result, 0.001,
-			"scaleTemperature(0.005) = %v, expected %v (should default to 100x)",
-			result, expected)
-	})
-}
-
-func TestGetTempsWithPanicRecovery(t *testing.T) {
-	agent := &Agent{
-		systemInfo: system.Info{},
-		sensorConfig: &SensorConfig{
-			context: context.Background(),
-		},
-	}
-
-	tests := []struct {
-		name        string
-		getTempsFn  getTempsFn
-		expectError bool
-		errorMsg    string
-	}{
-		{
-			name: "successful_function_call",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				return []sensors.TemperatureStat{
-					{SensorKey: "test_sensor", Temperature: 45.0},
-				}, nil
-			},
-			expectError: false,
-		},
-		{
-			name: "function_returns_error",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				return []sensors.TemperatureStat{
-					{SensorKey: "test_sensor", Temperature: 45.0},
-				}, fmt.Errorf("sensor error")
-			},
-			expectError: false, // getTempsWithPanicRecovery ignores errors from the function
-		},
-		{
-			name: "function_panics_with_string",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				panic("test panic")
-			},
-			expectError: true,
-			errorMsg:    "panic: test panic",
-		},
-		{
-			name: "function_panics_with_error",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				panic(fmt.Errorf("panic error"))
-			},
-			expectError: true,
-			errorMsg:    "panic:",
-		},
-		{
-			name: "function_panics_with_index_out_of_bounds",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				slice := []int{1, 2, 3}
-				_ = slice[10] // out of bounds panic
-				return nil, nil
-			},
-			expectError: true,
-			errorMsg:    "panic:",
-		},
-		{
-			name: "function_panics_with_any_conversion",
-			getTempsFn: func(ctx context.Context) ([]sensors.TemperatureStat, error) {
-				var i any = "string"
-				_ = i.(int) // type assertion panic
-				return nil, nil
-			},
-			expectError: true,
-			errorMsg:    "panic:",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var temps []sensors.TemperatureStat
-			var err error
-
-			// The function should not panic, regardless of what the injected function does
-			assert.NotPanics(t, func() {
-				temps, err = agent.getTempsWithPanicRecovery(tt.getTempsFn)
-			}, "getTempsWithPanicRecovery should not panic")
-
-			if tt.expectError {
-				assert.Error(t, err, "Expected an error to be returned")
-				if tt.errorMsg != "" {
-					assert.Contains(t, err.Error(), tt.errorMsg,
-						"Error message should contain expected text")
-				}
-				assert.Nil(t, temps, "Temps should be nil when panic occurs")
-			} else {
-				assert.NoError(t, err, "Should not return error for successful calls")
-			}
-		})
-	}
-}

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/server.go

@@ -1,224 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log/slog"
-	"net"
-	"os"
-	"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"
-	gossh "golang.org/x/crypto/ssh"
-)
-
-// ServerOptions contains configuration options for starting the SSH server.
-type ServerOptions struct {
-	Addr    string            // Network address to listen on (e.g., ":45876" or "/path/to/socket")
-	Network string            // Network type ("tcp" or "unix")
-	Keys    []gossh.PublicKey // SSH public keys for authentication
-}
-
-// hubVersions caches hub versions by session ID to avoid repeated parsing.
-var hubVersions map[string]semver.Version
-
-// StartServer starts the SSH server with the provided options.
-// It configures the server with secure defaults, sets up authentication,
-// and begins listening for connections. Returns an error if the server
-// is already running or if there's an issue starting the server.
-func (a *Agent) StartServer(opts ServerOptions) error {
-	if a.server != nil {
-		return errors.New("server already started")
-	}
-
-	slog.Info("Starting SSH server", "addr", opts.Addr, "network", opts.Network)
-
-	if opts.Network == "unix" {
-		// remove existing socket file if it exists
-		if err := os.Remove(opts.Addr); err != nil && !os.IsNotExist(err) {
-			return err
-		}
-	}
-
-	// start listening on the address
-	ln, err := net.Listen(opts.Network, opts.Addr)
-	if err != nil {
-		return err
-	}
-	defer ln.Close()
-
-	// base config (limit to allowed algorithms)
-	config := &gossh.ServerConfig{
-		ServerVersion: fmt.Sprintf("SSH-2.0-%s_%s", beszel.AppName, beszel.Version),
-	}
-	config.KeyExchanges = common.DefaultKeyExchanges
-	config.MACs = common.DefaultMACs
-	config.Ciphers = common.DefaultCiphers
-
-	// set default handler
-	ssh.Handle(a.handleSession)
-
-	a.server = &ssh.Server{
-		ServerConfigCallback: func(ctx ssh.Context) *gossh.ServerConfig {
-			return config
-		},
-		// check public key(s)
-		PublicKeyHandler: func(ctx ssh.Context, key ssh.PublicKey) bool {
-			remoteAddr := ctx.RemoteAddr()
-			for _, pubKey := range opts.Keys {
-				if ssh.KeysEqual(key, pubKey) {
-					slog.Info("SSH connected", "addr", remoteAddr)
-					return true
-				}
-			}
-			slog.Warn("Invalid SSH key", "addr", remoteAddr)
-			return false
-		},
-		// disable pty
-		PtyCallback: func(ctx ssh.Context, pty ssh.Pty) bool {
-			return false
-		},
-		// close idle connections after 70 seconds
-		IdleTimeout: 70 * time.Second,
-	}
-
-	// Start SSH server on the listener
-	return a.server.Serve(ln)
-}
-
-// getHubVersion retrieves and caches the hub version for a given session.
-// It extracts the version from the SSH client version string and caches
-// it to avoid repeated parsing. Returns a zero version if parsing fails.
-func (a *Agent) getHubVersion(sessionId string, sessionCtx ssh.Context) semver.Version {
-	if hubVersions == nil {
-		hubVersions = make(map[string]semver.Version, 1)
-	}
-	hubVersion, ok := hubVersions[sessionId]
-	if ok {
-		return hubVersion
-	}
-	// Extract hub version from SSH client version
-	clientVersion := sessionCtx.Value(ssh.ContextKeyClientVersion)
-	if versionStr, ok := clientVersion.(string); ok {
-		hubVersion, _ = extractHubVersion(versionStr)
-	}
-	hubVersions[sessionId] = hubVersion
-	return hubVersion
-}
-
-// handleSession handles an incoming SSH session by gathering system statistics
-// and sending them to the hub. It signals connection events, determines the
-// appropriate encoding format based on hub version, and exits with appropriate
-// status codes.
-func (a *Agent) handleSession(s ssh.Session) {
-	a.connectionManager.eventChan <- SSHConnect
-
-	sessionCtx := s.Context()
-	sessionID := sessionCtx.SessionID()
-
-	hubVersion := a.getHubVersion(sessionID, sessionCtx)
-
-	stats := a.gatherStats(sessionID)
-
-	err := a.writeToSession(s, stats, hubVersion)
-	if err != nil {
-		slog.Error("Error encoding stats", "err", err, "stats", stats)
-		s.Exit(1)
-	} else {
-		s.Exit(0)
-	}
-}
-
-// writeToSession encodes and writes system statistics to the session.
-// It chooses between CBOR and JSON encoding based on the hub version,
-// using CBOR for newer versions and JSON for legacy compatibility.
-func (a *Agent) writeToSession(w io.Writer, stats *system.CombinedData, hubVersion semver.Version) error {
-	if hubVersion.GTE(beszel.MinVersionCbor) {
-		return cbor.NewEncoder(w).Encode(stats)
-	}
-	return json.NewEncoder(w).Encode(stats)
-}
-
-// extractHubVersion extracts the beszel version from SSH client version string.
-// Expected format: "SSH-2.0-beszel_X.Y.Z" or "beszel_X.Y.Z"
-func extractHubVersion(versionString string) (semver.Version, error) {
-	_, after, _ := strings.Cut(versionString, "_")
-	return semver.Parse(after)
-}
-
-// ParseKeys parses a string containing SSH public keys in authorized_keys format.
-// It returns a slice of ssh.PublicKey and an error if any key fails to parse.
-func ParseKeys(input string) ([]gossh.PublicKey, error) {
-	var parsedKeys []gossh.PublicKey
-	for line := range strings.Lines(input) {
-		line = strings.TrimSpace(line)
-		// Skip empty lines or comments
-		if len(line) == 0 || strings.HasPrefix(line, "#") {
-			continue
-		}
-		// Parse the key
-		parsedKey, _, _, _, err := gossh.ParseAuthorizedKey([]byte(line))
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse key: %s, error: %w", line, err)
-		}
-		parsedKeys = append(parsedKeys, parsedKey)
-	}
-	return parsedKeys, nil
-}
-
-// GetAddress determines the network address to listen on from various sources.
-// It checks the provided address, then environment variables (LISTEN, PORT),
-// and finally defaults to ":45876".
-func GetAddress(addr string) string {
-	if addr == "" {
-		addr, _ = GetEnv("LISTEN")
-	}
-	if addr == "" {
-		// Legacy PORT environment variable support
-		addr, _ = GetEnv("PORT")
-	}
-	if addr == "" {
-		return ":45876"
-	}
-	// prefix with : if only port was provided
-	if GetNetwork(addr) != "unix" && !strings.Contains(addr, ":") {
-		addr = ":" + addr
-	}
-	return addr
-}
-
-// GetNetwork determines the network type based on the address format.
-// It checks the NETWORK environment variable first, then infers from
-// the address format: addresses starting with "/" are "unix", others are "tcp".
-func GetNetwork(addr string) string {
-	if network, ok := GetEnv("NETWORK"); ok && network != "" {
-		return network
-	}
-	if strings.HasPrefix(addr, "/") {
-		return "unix"
-	}
-	return "tcp"
-}
-
-// StopServer stops the SSH server if it's running.
-// It returns an error if the server is not running or if there's an error stopping it.
-func (a *Agent) StopServer() error {
-	if a.server == nil {
-		return errors.New("SSH server not running")
-	}
-
-	slog.Info("Stopping SSH server")
-	_ = a.server.Close()
-	a.server = nil
-	a.connectionManager.eventChan <- SSHDisconnect
-	return nil
-}

agent/server_test.go

@@ -1,606 +0,0 @@
-package agent
-
-import (
-	"context"
-	"crypto/ed25519"
-	"encoding/json"
-	"fmt"
-	"net"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"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"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	gossh "golang.org/x/crypto/ssh"
-)
-
-func TestStartServer(t *testing.T) {
-	// Generate a test key pair
-	pubKey, privKey, err := ed25519.GenerateKey(nil)
-	require.NoError(t, err)
-	signer, err := gossh.NewSignerFromKey(privKey)
-	require.NoError(t, err)
-	sshPubKey, err := gossh.NewPublicKey(pubKey)
-	require.NoError(t, err)
-
-	// Generate a different key pair for bad key test
-	badPubKey, badPrivKey, err := ed25519.GenerateKey(nil)
-	require.NoError(t, err)
-	badSigner, err := gossh.NewSignerFromKey(badPrivKey)
-	require.NoError(t, err)
-	sshBadPubKey, err := gossh.NewPublicKey(badPubKey)
-	require.NoError(t, err)
-
-	socketFile := filepath.Join(t.TempDir(), "beszel-test.sock")
-
-	tests := []struct {
-		name        string
-		config      ServerOptions
-		wantErr     bool
-		errContains string
-		setup       func() error
-		cleanup     func() error
-	}{
-		{
-			name: "tcp port only",
-			config: ServerOptions{
-				Network: "tcp",
-				Addr:    ":45987",
-				Keys:    []gossh.PublicKey{sshPubKey},
-			},
-		},
-		{
-			name: "tcp with ipv4",
-			config: ServerOptions{
-				Network: "tcp4",
-				Addr:    "127.0.0.1:45988",
-				Keys:    []gossh.PublicKey{sshPubKey},
-			},
-		},
-		{
-			name: "tcp with ipv6",
-			config: ServerOptions{
-				Network: "tcp6",
-				Addr:    "[::1]:45989",
-				Keys:    []gossh.PublicKey{sshPubKey},
-			},
-		},
-		{
-			name: "unix socket",
-			config: ServerOptions{
-				Network: "unix",
-				Addr:    socketFile,
-				Keys:    []gossh.PublicKey{sshPubKey},
-			},
-			setup: func() error {
-				// Create a socket file that should be removed
-				f, err := os.Create(socketFile)
-				if err != nil {
-					return err
-				}
-				return f.Close()
-			},
-			cleanup: func() error {
-				return os.Remove(socketFile)
-			},
-		},
-		{
-			name: "bad key should fail",
-			config: ServerOptions{
-				Network: "tcp",
-				Addr:    ":45987",
-				Keys:    []gossh.PublicKey{sshBadPubKey},
-			},
-			wantErr:     true,
-			errContains: "ssh: handshake failed",
-		},
-		{
-			name: "good key still good",
-			config: ServerOptions{
-				Network: "tcp",
-				Addr:    ":45987",
-				Keys:    []gossh.PublicKey{sshPubKey},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.setup != nil {
-				err := tt.setup()
-				require.NoError(t, err)
-			}
-
-			if tt.cleanup != nil {
-				defer tt.cleanup()
-			}
-
-			agent, err := NewAgent("")
-			require.NoError(t, err)
-
-			// Start server in a goroutine since it blocks
-			errChan := make(chan error, 1)
-			go func() {
-				errChan <- agent.StartServer(tt.config)
-			}()
-
-			// Add a short delay to allow the server to start
-			time.Sleep(100 * time.Millisecond)
-
-			// Try to connect to verify server is running
-			var client *gossh.Client
-
-			// Choose the appropriate signer based on the test case
-			testSigner := signer
-			if tt.name == "bad key should fail" {
-				testSigner = badSigner
-			}
-
-			sshClientConfig := &gossh.ClientConfig{
-				User: "a",
-				Auth: []gossh.AuthMethod{
-					gossh.PublicKeys(testSigner),
-				},
-				HostKeyCallback: gossh.InsecureIgnoreHostKey(),
-				Timeout:         4 * time.Second,
-			}
-
-			switch tt.config.Network {
-			case "unix":
-				client, err = gossh.Dial("unix", tt.config.Addr, sshClientConfig)
-			default:
-				if !strings.Contains(tt.config.Addr, ":") {
-					tt.config.Addr = ":" + tt.config.Addr
-				}
-				client, err = gossh.Dial("tcp", tt.config.Addr, sshClientConfig)
-			}
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				if tt.errContains != "" {
-					assert.Contains(t, err.Error(), tt.errContains)
-				}
-				return
-			}
-
-			require.NoError(t, err)
-			require.NotNil(t, client)
-			client.Close()
-		})
-	}
-}
-
-/////////////////////////////////////////////////////////////////
-//////////////////// ParseKeys Tests ////////////////////////////
-/////////////////////////////////////////////////////////////////
-
-// Helper function to generate a temporary file with content
-func createTempFile(content string) (string, error) {
-	tmpFile, err := os.CreateTemp("", "ssh_keys_*.txt")
-	if err != nil {
-		return "", fmt.Errorf("failed to create temp file: %w", err)
-	}
-	defer tmpFile.Close()
-
-	if _, err := tmpFile.WriteString(content); err != nil {
-		return "", fmt.Errorf("failed to write to temp file: %w", err)
-	}
-
-	return tmpFile.Name(), nil
-}
-
-// Test case 1: String with a single SSH key
-func TestParseSingleKeyFromString(t *testing.T) {
-	input := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo"
-	keys, err := ParseKeys(input)
-	if err != nil {
-		t.Fatalf("Expected no error, got: %v", err)
-	}
-	if len(keys) != 1 {
-		t.Fatalf("Expected 1 key, got %d keys", len(keys))
-	}
-	if keys[0].Type() != "ssh-ed25519" {
-		t.Fatalf("Expected key type 'ssh-ed25519', got '%s'", keys[0].Type())
-	}
-}
-
-// Test case 2: String with multiple SSH keys
-func TestParseMultipleKeysFromString(t *testing.T) {
-	input := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo\nssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D \n #comment\n ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D"
-	keys, err := ParseKeys(input)
-	if err != nil {
-		t.Fatalf("Expected no error, got: %v", err)
-	}
-	if len(keys) != 3 {
-		t.Fatalf("Expected 3 keys, got %d keys", len(keys))
-	}
-	if keys[0].Type() != "ssh-ed25519" || keys[1].Type() != "ssh-ed25519" || keys[2].Type() != "ssh-ed25519" {
-		t.Fatalf("Unexpected key types: %s, %s, %s", keys[0].Type(), keys[1].Type(), keys[2].Type())
-	}
-}
-
-// Test case 3: File with a single SSH key
-func TestParseSingleKeyFromFile(t *testing.T) {
-	content := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo"
-	filePath, err := createTempFile(content)
-	if err != nil {
-		t.Fatalf("Failed to create temp file: %v", err)
-	}
-	defer os.Remove(filePath) // Clean up the file after the test
-
-	// Read the file content
-	fileContent, err := os.ReadFile(filePath)
-	if err != nil {
-		t.Fatalf("Failed to read temp file: %v", err)
-	}
-
-	// Parse the keys
-	keys, err := ParseKeys(string(fileContent))
-	if err != nil {
-		t.Fatalf("Expected no error, got: %v", err)
-	}
-	if len(keys) != 1 {
-		t.Fatalf("Expected 1 key, got %d keys", len(keys))
-	}
-	if keys[0].Type() != "ssh-ed25519" {
-		t.Fatalf("Expected key type 'ssh-ed25519', got '%s'", keys[0].Type())
-	}
-}
-
-// Test case 4: File with multiple SSH keys
-func TestParseMultipleKeysFromFile(t *testing.T) {
-	content := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo\nssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D \n #comment\n ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D"
-	filePath, err := createTempFile(content)
-	if err != nil {
-		t.Fatalf("Failed to create temp file: %v", err)
-	}
-	// defer os.Remove(filePath) // Clean up the file after the test
-
-	// Read the file content
-	fileContent, err := os.ReadFile(filePath)
-	if err != nil {
-		t.Fatalf("Failed to read temp file: %v", err)
-	}
-
-	// Parse the keys
-	keys, err := ParseKeys(string(fileContent))
-	if err != nil {
-		t.Fatalf("Expected no error, got: %v", err)
-	}
-	if len(keys) != 3 {
-		t.Fatalf("Expected 3 keys, got %d keys", len(keys))
-	}
-	if keys[0].Type() != "ssh-ed25519" || keys[1].Type() != "ssh-ed25519" || keys[2].Type() != "ssh-ed25519" {
-		t.Fatalf("Unexpected key types: %s, %s, %s", keys[0].Type(), keys[1].Type(), keys[2].Type())
-	}
-}
-
-// Test case 5: Invalid SSH key input
-func TestParseInvalidKey(t *testing.T) {
-	input := "invalid-key-data"
-	_, err := ParseKeys(input)
-	if err == nil {
-		t.Fatalf("Expected an error for invalid key, got nil")
-	}
-	expectedErrMsg := "failed to parse key"
-	if !strings.Contains(err.Error(), expectedErrMsg) {
-		t.Fatalf("Expected error message to contain '%s', got: %v", expectedErrMsg, err)
-	}
-}
-
-/////////////////////////////////////////////////////////////////
-//////////////////// Hub Version Tests //////////////////////////
-/////////////////////////////////////////////////////////////////
-
-func TestExtractHubVersion(t *testing.T) {
-	tests := []struct {
-		name            string
-		clientVersion   string
-		expectedVersion string
-		expectError     bool
-	}{
-		{
-			name:            "valid beszel client version with underscore",
-			clientVersion:   "SSH-2.0-beszel_0.11.1",
-			expectedVersion: "0.11.1",
-			expectError:     false,
-		},
-		{
-			name:            "valid beszel client version with beta",
-			clientVersion:   "SSH-2.0-beszel_1.0.0-beta",
-			expectedVersion: "1.0.0-beta",
-			expectError:     false,
-		},
-		{
-			name:            "valid beszel client version with rc",
-			clientVersion:   "SSH-2.0-beszel_0.12.0-rc1",
-			expectedVersion: "0.12.0-rc1",
-			expectError:     false,
-		},
-		{
-			name:            "different SSH client",
-			clientVersion:   "SSH-2.0-OpenSSH_8.0",
-			expectedVersion: "8.0",
-			expectError:     true,
-		},
-		{
-			name:          "malformed version string without underscore",
-			clientVersion: "SSH-2.0-beszel",
-			expectError:   true,
-		},
-		{
-			name:          "empty version string",
-			clientVersion: "",
-			expectError:   true,
-		},
-		{
-			name:            "version string with underscore but no version",
-			clientVersion:   "beszel_",
-			expectedVersion: "",
-			expectError:     true,
-		},
-		{
-			name:            "version with patch and build metadata",
-			clientVersion:   "SSH-2.0-beszel_1.2.3+build.123",
-			expectedVersion: "1.2.3+build.123",
-			expectError:     false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := extractHubVersion(tt.clientVersion)
-
-			if tt.expectError {
-				assert.Error(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tt.expectedVersion, result.String())
-		})
-	}
-}
-
-/////////////////////////////////////////////////////////////////
-/////////////// Hub Version Detection Tests ////////////////////
-/////////////////////////////////////////////////////////////////
-
-func TestGetHubVersion(t *testing.T) {
-	agent, err := NewAgent("")
-	require.NoError(t, err)
-
-	// Mock SSH context that implements the ssh.Context interface
-	mockCtx := &mockSSHContext{
-		sessionID:     "test-session-123",
-		clientVersion: "SSH-2.0-beszel_0.12.0",
-	}
-
-	// Test first call - should extract and cache version
-	version := agent.getHubVersion("test-session-123", mockCtx)
-	assert.Equal(t, "0.12.0", version.String())
-
-	// Test second call - should return cached version
-	mockCtx.clientVersion = "SSH-2.0-beszel_0.11.0" // Change version but should still return cached
-	version = agent.getHubVersion("test-session-123", mockCtx)
-	assert.Equal(t, "0.12.0", version.String()) // Should still be cached version
-
-	// Test different session - should extract new version
-	version = agent.getHubVersion("different-session", mockCtx)
-	assert.Equal(t, "0.11.0", version.String())
-
-	// Test with invalid version string (non-beszel client)
-	mockCtx.clientVersion = "SSH-2.0-OpenSSH_8.0"
-	version = agent.getHubVersion("invalid-session", mockCtx)
-	assert.Equal(t, "0.0.0", version.String()) // Should be empty version for non-beszel clients
-
-	// Test with no client version
-	mockCtx.clientVersion = ""
-	version = agent.getHubVersion("no-version-session", mockCtx)
-	assert.True(t, version.EQ(semver.Version{})) // Should be empty version
-}
-
-// mockSSHContext implements ssh.Context for testing
-type mockSSHContext struct {
-	context.Context
-	sync.Mutex
-	sessionID     string
-	clientVersion string
-}
-
-func (m *mockSSHContext) SessionID() string {
-	return m.sessionID
-}
-
-func (m *mockSSHContext) ClientVersion() string {
-	return m.clientVersion
-}
-
-func (m *mockSSHContext) ServerVersion() string {
-	return "SSH-2.0-beszel_test"
-}
-
-func (m *mockSSHContext) Value(key interface{}) interface{} {
-	if key == ssh.ContextKeyClientVersion {
-		return m.clientVersion
-	}
-	return nil
-}
-
-func (m *mockSSHContext) User() string                    { return "test-user" }
-func (m *mockSSHContext) RemoteAddr() net.Addr            { return nil }
-func (m *mockSSHContext) LocalAddr() net.Addr             { return nil }
-func (m *mockSSHContext) Permissions() *ssh.Permissions   { return nil }
-func (m *mockSSHContext) SetValue(key, value interface{}) {}
-
-/////////////////////////////////////////////////////////////////
-/////////////// CBOR vs JSON Encoding Tests ////////////////////
-/////////////////////////////////////////////////////////////////
-
-// TestWriteToSessionEncoding tests that writeToSession actually encodes data in the correct format
-func TestWriteToSessionEncoding(t *testing.T) {
-	tests := []struct {
-		name             string
-		hubVersion       string
-		expectedUsesCbor bool
-	}{
-		{
-			name:             "old hub version should use JSON",
-			hubVersion:       "0.11.1",
-			expectedUsesCbor: false,
-		},
-		{
-			name:             "non-beta release should use CBOR",
-			hubVersion:       "0.12.0",
-			expectedUsesCbor: true,
-		},
-		{
-			name:             "even newer hub version should use CBOR",
-			hubVersion:       "0.16.4",
-			expectedUsesCbor: true,
-		},
-		{
-			name:             "beta version below release threshold should use JSON",
-			hubVersion:       "0.12.0-beta0",
-			expectedUsesCbor: false,
-		},
-		// {
-		// 	name:             "matching beta version should use CBOR",
-		// 	hubVersion:       "0.12.0-beta2",
-		// 	expectedUsesCbor: true,
-		// },
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Reset the global hubVersions map to ensure clean state for each test
-			hubVersions = nil
-
-			agent, err := NewAgent("")
-			require.NoError(t, err)
-
-			// Parse the test version
-			version, err := semver.Parse(tt.hubVersion)
-			require.NoError(t, err)
-
-			// Create test data to encode
-			testData := createTestCombinedData()
-
-			var buf strings.Builder
-			err = agent.writeToSession(&buf, testData, version)
-			require.NoError(t, err)
-
-			encodedData := buf.String()
-			require.NotEmpty(t, encodedData)
-
-			// Verify the encoding format by attempting to decode
-			if tt.expectedUsesCbor {
-				var decodedCbor system.CombinedData
-				err = cbor.Unmarshal([]byte(encodedData), &decodedCbor)
-				assert.NoError(t, err, "Should be valid CBOR data")
-
-				var decodedJson system.CombinedData
-				err = json.Unmarshal([]byte(encodedData), &decodedJson)
-				assert.Error(t, err, "Should not be valid JSON data")
-
-				assert.Equal(t, testData.Info.Hostname, decodedCbor.Info.Hostname)
-				assert.Equal(t, testData.Stats.Cpu, decodedCbor.Stats.Cpu)
-			} else {
-				// Should be JSON - try to decode as JSON
-				var decodedJson system.CombinedData
-				err = json.Unmarshal([]byte(encodedData), &decodedJson)
-				assert.NoError(t, err, "Should be valid JSON data")
-
-				var decodedCbor system.CombinedData
-				err = cbor.Unmarshal([]byte(encodedData), &decodedCbor)
-				assert.Error(t, err, "Should not be valid CBOR data")
-
-				// Verify the decoded JSON data matches our test data
-				assert.Equal(t, testData.Info.Hostname, decodedJson.Info.Hostname)
-				assert.Equal(t, testData.Stats.Cpu, decodedJson.Stats.Cpu)
-
-				// Verify it looks like JSON (starts with '{' and contains readable field names)
-				assert.True(t, strings.HasPrefix(encodedData, "{"), "JSON should start with '{'")
-				assert.Contains(t, encodedData, `"info"`, "JSON should contain readable field names")
-				assert.Contains(t, encodedData, `"stats"`, "JSON should contain readable field names")
-			}
-		})
-	}
-}
-
-// Helper function to create test data for encoding tests
-func createTestCombinedData() *system.CombinedData {
-	return &system.CombinedData{
-		Stats: system.Stats{
-			Cpu:       25.5,
-			Mem:       8589934592, // 8GB
-			MemUsed:   4294967296, // 4GB
-			MemPct:    50.0,
-			DiskTotal: 1099511627776, // 1TB
-			DiskUsed:  549755813888,  // 512GB
-			DiskPct:   50.0,
-		},
-		Info: system.Info{
-			Hostname:     "test-host",
-			Cores:        8,
-			CpuModel:     "Test CPU Model",
-			Uptime:       3600,
-			AgentVersion: "0.12.0",
-			Os:           system.Linux,
-		},
-		Containers: []*container.Stats{
-			{
-				Name: "test-container",
-				Cpu:  10.5,
-				Mem:  1073741824, // 1GB
-			},
-		},
-	}
-}
-
-func TestHubVersionCaching(t *testing.T) {
-	// Reset the global hubVersions map to ensure clean state
-	hubVersions = nil
-
-	agent, err := NewAgent("")
-	require.NoError(t, err)
-
-	ctx1 := &mockSSHContext{
-		sessionID:     "session1",
-		clientVersion: "SSH-2.0-beszel_0.12.0",
-	}
-	ctx2 := &mockSSHContext{
-		sessionID:     "session2",
-		clientVersion: "SSH-2.0-beszel_0.11.0",
-	}
-
-	// First calls should cache the versions
-	v1 := agent.getHubVersion("session1", ctx1)
-	v2 := agent.getHubVersion("session2", ctx2)
-
-	assert.Equal(t, "0.12.0", v1.String())
-	assert.Equal(t, "0.11.0", v2.String())
-
-	// Verify caching by changing context but keeping same session ID
-	ctx1.clientVersion = "SSH-2.0-beszel_0.10.0"
-	v1Cached := agent.getHubVersion("session1", ctx1)
-	assert.Equal(t, "0.12.0", v1Cached.String()) // Should still be cached version
-
-	// New session should get new version
-	ctx3 := &mockSSHContext{
-		sessionID:     "session3",
-		clientVersion: "SSH-2.0-beszel_0.13.0",
-	}
-	v3 := agent.getHubVersion("session3", ctx3)
-	assert.Equal(t, "0.13.0", v3.String())
-}

agent/update.go

@@ -1,165 +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, "status", "beszel-agent").Run(); err != nil {
-		return nil
-	}
-	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via OpenRC…")
-	return exec.Command(o.cmd, "restart", "beszel-agent").Run()
-}
-
-type openWRTRestarter struct{ cmd string }
-
-func (w *openWRTRestarter) Restart() error {
-	if err := exec.Command(w.cmd, "running", "beszel-agent").Run(); err != nil {
-		return nil
-	}
-	ghupdate.ColorPrint(ghupdate.ColorYellow, "Restarting beszel-agent via procd…")
-	return exec.Command(w.cmd, "restart", "beszel-agent").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("service"); err == nil {
-		if runtime.GOOS == "freebsd" {
-			return &freeBSDRestarter{cmd: path}
-		}
-		return &openWRTRestarter{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,15 +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.12.9"
-	// AppName is the name of the application.
-	AppName = "beszel"
-)
-
-// MinVersionCbor is the minimum supported version for CBOR compatibility.
-var MinVersionCbor = semver.MustParse("0.12.0")

beszel/.goreleaser.yml

@@ -0,0 +1,123 @@
+version: 2
+
+project_name: beszel
+
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+  - id: beszel
+    binary: beszel
+    main: cmd/hub/hub.go
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - darwin
+    goarch:
+      - amd64
+      - arm64
+      - arm
+
+  - id: beszel-agent
+    binary: beszel-agent
+    main: cmd/agent/agent.go
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - darwin
+      - freebsd
+      - windows
+    goarch:
+      - amd64
+      - arm64
+      - arm
+      - mips64
+      - riscv64
+    ignore:
+      - goos: freebsd
+        goarch: arm
+      - goos: windows
+        goarch: arm
+      - goos: darwin
+        goarch: riscv64
+      - goos: windows
+        goarch: riscv64
+
+archives:
+  - id: beszel
+    format: tar.gz
+    builds:
+      - beszel-agent
+    name_template: >-
+      {{ .Binary }}_
+      {{- .Os }}_
+      {{- .Arch }}
+    format_overrides:
+      - goos: windows
+        format: zip
+
+  - id: beszel-agent
+    format: tar.gz
+    builds:
+      - beszel
+    name_template: >-
+      {{ .Binary }}_
+      {{- .Os }}_
+      {{- .Arch }}
+
+nfpms:
+  - id: beszel-agent
+    package_name: beszel-agent
+    description: |-
+      Agent for Beszel
+      Beszel is a lightweight server monitoring platform that includes Docker
+      statistics, historical data, and alert functions. It has a friendly web
+      interface, simple configuration, and is ready to use out of the box.
+      It supports automatic backup, multi-user, OAuth authentication, and
+      API access.
+    maintainer: henrygd <hank@henrygd.me>
+    section: net
+    builds:
+      - beszel-agent
+    formats:
+      - deb
+    # don't think this is needed with CGO_ENABLED=0
+    # dependencies:
+    #   - libc6
+    contents:
+      - src: ../supplemental/debian/beszel-agent.service
+        dst: lib/systemd/system/beszel-agent.service
+        packager: deb
+      - src: ../supplemental/debian/copyright
+        dst: usr/share/doc/beszel-agent/copyright
+        packager: deb
+      - 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
+    deb:
+      predepends:
+        - adduser
+        - debconf
+      scripts:
+        templates: ../supplemental/debian/templates
+        # Currently broken due to a bug in goreleaser
+        # https://github.com/goreleaser/goreleaser/issues/5487
+        #config: ../supplemental/debian/config.sh
+
+release:
+  draft: true
+
+changelog:
+  disable: true
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'

beszel/Makefile

@@ -0,0 +1,68 @@
+# 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
+
+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; \
+	else \
+		cd ./site && npm run dev; \
+	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/*.go ./internal/{alerts,hub,records,users}/*.go | entr -r -s "cd ./cmd/hub && go run . serve"; \
+	else \
+		cd ./cmd/hub && go run . serve; \
+	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,136 @@
+package main
+
+import (
+	"beszel"
+	"beszel/internal/agent"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// cli options
+type cmdOptions struct {
+	key  string // key is the public key(s) for SSH authentication.
+	addr string // addr is the address or port to listen on.
+}
+
+// parseFlags parses the command line flags and populates the config struct.
+func (opts *cmdOptions) parseFlags() {
+	flag.StringVar(&opts.key, "key", "", "Public key(s) for SSH authentication")
+	flag.StringVar(&opts.addr, "addr", "", "Address or port to listen on")
+
+	flag.Usage = func() {
+		fmt.Printf("Usage: %s [options] [subcommand]\n", os.Args[0])
+		fmt.Println("\nOptions:")
+		flag.PrintDefaults()
+		fmt.Println("\nSubcommands:")
+		fmt.Println("  version      Display the version")
+		fmt.Println("  help         Display this help message")
+		fmt.Println("  update       Update the agent to the latest version")
+	}
+}
+
+// handleSubcommand handles subcommands such as version, help, and update.
+// It returns true if a subcommand was handled, false otherwise.
+func handleSubcommand() bool {
+	if len(os.Args) <= 1 {
+		return false
+	}
+	switch os.Args[1] {
+	case "version", "-v":
+		fmt.Println(beszel.AppName+"-agent", beszel.Version)
+		os.Exit(0)
+	case "help":
+		flag.Usage()
+		os.Exit(0)
+	case "update":
+		agent.Update()
+		os.Exit(0)
+	}
+	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))
+}
+
+// getAddress gets the address to listen on from the command line flag, environment variable, or default value.
+func (opts *cmdOptions) getAddress() string {
+	// Try command line flag first
+	if opts.addr != "" {
+		return opts.addr
+	}
+	// Try environment variables
+	if addr, ok := agent.GetEnv("ADDR"); ok && addr != "" {
+		return addr
+	}
+	// Legacy PORT environment variable support
+	if port, ok := agent.GetEnv("PORT"); ok && port != "" {
+		return port
+	}
+	return ":45876"
+}
+
+// getNetwork returns the network type to use for the server.
+func (opts *cmdOptions) getNetwork() string {
+	if network, _ := agent.GetEnv("NETWORK"); network != "" {
+		return network
+	}
+	if strings.HasPrefix(opts.addr, "/") {
+		return "unix"
+	}
+	return "tcp"
+}
+
+func main() {
+	var opts cmdOptions
+	opts.parseFlags()
+
+	if handleSubcommand() {
+		return
+	}
+
+	flag.Parse()
+
+	opts.addr = opts.getAddress()
+
+	var serverConfig agent.ServerOptions
+	var err error
+	serverConfig.Keys, err = opts.loadPublicKeys()
+	if err != nil {
+		log.Fatal("Failed to load public keys:", err)
+	}
+
+	serverConfig.Addr = opts.addr
+	serverConfig.Network = opts.getNetwork()
+
+	agent := agent.NewAgent()
+	if err := agent.StartServer(serverConfig); err != nil {
+		log.Fatal("Failed to start server:", err)
+	}
+}

beszel/cmd/agent/agent_test.go

@@ -2,13 +2,11 @@ package main
 
 import (
 	"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"
@@ -29,22 +27,22 @@ func TestGetAddress(t *testing.T) {
 		{
 			name: "use address from flag",
 			opts: cmdOptions{
-				listen: "8080",
+				addr: "8080",
 			},
-			expected: ":8080",
+			expected: "8080",
 		},
 		{
 			name: "use unix socket from flag",
 			opts: cmdOptions{
-				listen: "/tmp/beszel.sock",
+				addr: "/tmp/beszel.sock",
 			},
 			expected: "/tmp/beszel.sock",
 		},
 		{
-			name: "use LISTEN env var",
+			name: "use ADDR env var",
 			opts: cmdOptions{},
 			envVars: map[string]string{
-				"LISTEN": "1.2.3.4:9090",
+				"ADDR": "1.2.3.4:9090",
 			},
 			expected: "1.2.3.4:9090",
 		},
@@ -54,26 +52,26 @@ func TestGetAddress(t *testing.T) {
 			envVars: map[string]string{
 				"PORT": "7070",
 			},
-			expected: ":7070",
+			expected: "7070",
 		},
 		{
 			name: "use unix socket from env var",
 			opts: cmdOptions{
-				listen: "",
+				addr: "",
 			},
 			envVars: map[string]string{
-				"LISTEN": "/tmp/beszel.sock",
+				"ADDR": "/tmp/beszel.sock",
 			},
 			expected: "/tmp/beszel.sock",
 		},
 		{
 			name: "flag takes precedence over env vars",
 			opts: cmdOptions{
-				listen: ":8080",
+				addr: ":8080",
 			},
 			envVars: map[string]string{
-				"LISTEN": ":9090",
-				"PORT":   "7070",
+				"ADDR": ":9090",
+				"PORT": "7070",
 			},
 			expected: ":8080",
 		},
@@ -203,27 +201,27 @@ func TestGetNetwork(t *testing.T) {
 		},
 		{
 			name:     "only port",
-			opts:     cmdOptions{listen: "8080"},
+			opts:     cmdOptions{addr: "8080"},
 			expected: "tcp",
 		},
 		{
 			name:     "ipv4 address",
-			opts:     cmdOptions{listen: "1.2.3.4:8080"},
+			opts:     cmdOptions{addr: "1.2.3.4:8080"},
 			expected: "tcp",
 		},
 		{
 			name:     "ipv6 address",
-			opts:     cmdOptions{listen: "[2001:db8::1]:8080"},
+			opts:     cmdOptions{addr: "[2001:db8::1]:8080"},
 			expected: "tcp",
 		},
 		{
 			name:     "unix network",
-			opts:     cmdOptions{listen: "/tmp/beszel.sock"},
+			opts:     cmdOptions{addr: "/tmp/beszel.sock"},
 			expected: "unix",
 		},
 		{
 			name:     "env var network",
-			opts:     cmdOptions{listen: ":8080"},
+			opts:     cmdOptions{addr: ":8080"},
 			envVars:  map[string]string{"NETWORK": "tcp4"},
 			expected: "tcp4",
 		},
@@ -235,7 +233,7 @@ func TestGetNetwork(t *testing.T) {
 			for k, v := range tt.envVars {
 				t.Setenv(k, v)
 			}
-			network := agent.GetNetwork(tt.opts.listen)
+			network := tt.opts.getNetwork()
 			assert.Equal(t, tt.expected, network)
 		})
 	}
@@ -246,7 +244,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 {
@@ -258,64 +256,32 @@ func TestParseFlags(t *testing.T) {
 			name: "no flags",
 			args: []string{"cmd"},
 			expected: cmdOptions{
-				key:    "",
-				listen: "",
+				key:  "",
+				addr: "",
 			},
 		},
 		{
 			name: "key flag only",
 			args: []string{"cmd", "-key", "testkey"},
 			expected: cmdOptions{
-				key:    "testkey",
-				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: "",
+				key:  "testkey",
+				addr: "",
 			},
 		},
 		{
 			name: "addr flag only",
-			args: []string{"cmd", "-listen", ":8080"},
+			args: []string{"cmd", "-addr", ":8080"},
 			expected: cmdOptions{
-				key:    "",
-				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",
+				key:  "",
+				addr: ":8080",
 			},
 		},
 		{
 			name: "both flags",
-			args: []string{"cmd", "-key", "testkey", "-listen", ":8080"},
+			args: []string{"cmd", "-key", "testkey", "-addr", ":8080"},
 			expected: cmdOptions{
-				key:    "testkey",
-				listen: ":8080",
+				key:  "testkey",
+				addr: ":8080",
 			},
 		},
 	}
@@ -323,12 +289,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()
+			opts.parseFlags()
+			flag.Parse()
 
 			assert.Equal(t, tt.expected, opts)
 		})

beszel/cmd/hub/hub.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"beszel/internal/hub"
+	_ "beszel/migrations"
+)
+
+func main() {
+	hub.NewHub().Run()
+}

beszel/dockerfile_Agent

@@ -0,0 +1,20 @@
+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
+
+# ? -------------------------
+FROM scratch
+
+COPY --from=builder /agent /agent
+
+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

beszel/go.mod

@@ -0,0 +1,93 @@
+module beszel
+
+go 1.24.0
+
+require (
+	github.com/blang/semver v3.5.1+incompatible
+	github.com/containrrr/shoutrrr v0.8.0
+	github.com/gliderlabs/ssh v0.3.8
+	github.com/goccy/go-json v0.10.5
+	github.com/pocketbase/dbx v1.11.0
+	github.com/pocketbase/pocketbase v0.25.0
+	github.com/rhysd/go-github-selfupdate v1.2.3
+	github.com/shirou/gopsutil/v4 v4.25.1
+	github.com/spf13/cast v1.7.1
+	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.10.0
+	golang.org/x/crypto v0.32.0
+	golang.org/x/exp v0.0.0-20250128182459-e0ece0dbea4c
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect
+	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.36.1 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.8 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.29.6 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.59 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.28 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.59 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.32 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.32 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.2 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.32 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.5.6 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.75.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.24.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.14 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.33.14 // indirect
+	github.com/aws/smithy-go v1.22.2 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/disintegration/imaging v1.6.2 // indirect
+	github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/ebitengine/purego v0.8.2 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+	github.com/ganigeorgiev/fexpr v0.4.1 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/google/go-github/v30 v30.1.0 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/googleapis/gax-go/v2 v2.14.1 // indirect
+	github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // 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.14 // indirect
+	github.com/tklauser/numcpus v0.9.0 // indirect
+	github.com/ulikunitz/xz v0.5.12 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	gocloud.dev v0.40.0 // indirect
+	golang.org/x/image v0.24.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/oauth2 v0.26.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/term v0.29.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
+	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
+	google.golang.org/api v0.220.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 // indirect
+	google.golang.org/grpc v1.70.0 // indirect
+	google.golang.org/protobuf v1.36.4 // indirect
+	modernc.org/libc v1.55.3 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.8.2 // indirect
+	modernc.org/sqlite v1.34.5 // indirect
+)

beszel/go.sum

@@ -0,0 +1,395 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.115.0 h1:CnFSK6Xo3lDYRoBKEcAtia6VSC837/ZkJuRduSFnr14=
+cloud.google.com/go v0.115.0/go.mod h1:8jIM5vVgoAEoiVxQ/O4BFTfHqulPZgs/ufEzMcFMdWU=
+cloud.google.com/go/auth v0.14.1 h1:AwoJbzUdxA/whv1qj3TLKwh3XX5sikny2fc40wUl+h0=
+cloud.google.com/go/auth v0.14.1/go.mod h1:4JHUxlGXisL0AW8kXPtUF6ztuOksyfUQNFjfsOCXkPM=
+cloud.google.com/go/auth/oauth2adapt v0.2.7 h1:/Lc7xODdqcEw8IrZ9SvwnlLX6j9FHQM74z6cBk9Rw6M=
+cloud.google.com/go/auth/oauth2adapt v0.2.7/go.mod h1:NTbTTzfvPl1Y3V1nPpOgl2w6d/FjO7NNUQaWSox6ZMc=
+cloud.google.com/go/compute v1.14.0 h1:hfm2+FfxVmnRlh6LpB7cg1ZNU+5edAHmW679JePztk0=
+cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I=
+cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg=
+cloud.google.com/go/iam v1.1.13 h1:7zWBXG9ERbMLrzQBRhFliAV+kjcRToDTgQT3CTwYyv4=
+cloud.google.com/go/iam v1.1.13/go.mod h1:K8mY0uSXwEXS30KrnVb+j54LB/ntfZu1dr+4zFMNbus=
+cloud.google.com/go/storage v1.43.0 h1:CcxnSohZwizt4LCzQHWvBf1/kvtHUn7gk9QERXPyXFs=
+cloud.google.com/go/storage v1.43.0/go.mod h1:ajvxEa7WmZS1PxvKRq4bq0tFT3vMd502JwstCcYv0Q0=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+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=
+github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
+github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
+github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
+github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/aws/aws-sdk-go-v2 v1.36.1 h1:iTDl5U6oAhkNPba0e1t1hrwAo02ZMqbrGq4k5JBWM5E=
+github.com/aws/aws-sdk-go-v2 v1.36.1/go.mod h1:5PMILGVKiW32oDzjj6RU52yrNrDPUHcbZQYr1sM7qmM=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.8 h1:zAxi9p3wsZMIaVCdoiQp2uZ9k1LsZvmAnoTBeZPXom0=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.8/go.mod h1:3XkePX5dSaxveLAYY7nsbsZZrKxCyEuE5pM4ziFxyGg=
+github.com/aws/aws-sdk-go-v2/config v1.29.6 h1:fqgqEKK5HaZVWLQoLiC9Q+xDlSp+1LYidp6ybGE2OGg=
+github.com/aws/aws-sdk-go-v2/config v1.29.6/go.mod h1:Ft+WLODzDQmCTHDvqAH1JfC2xxbZ0MxpZAcJqmE1LTQ=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.59 h1:9btwmrt//Q6JcSdgJOLI98sdr5p7tssS9yAsGe8aKP4=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.59/go.mod h1:NM8fM6ovI3zak23UISdWidyZuI1ghNe2xjzUZAyT+08=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.28 h1:KwsodFKVQTlI5EyhRSugALzsV6mG/SGrdjlMXSZSdso=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.28/go.mod h1:EY3APf9MzygVhKuPXAc5H+MkGb8k/DOSQjWS0LgkKqI=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.59 h1:5Vsrfdlf9KQP3leGX1dD7VwZq/3HAerEFoXAII4t6zo=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.59/go.mod h1:7XTNs3NYApJjkx6A2Fk9qq23qBuBnIU58k3fKC2Fr1I=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.32 h1:BjUcr3X3K0wZPGFg2bxOWW3VPN8rkE3/61zhP+IHviA=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.32/go.mod h1:80+OGC/bgzzFFTUmcuwD0lb4YutwQeKLFpmt6hoWapU=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.32 h1:m1GeXHVMJsRsUAqG6HjZWx9dj7F5TR+cF1bjyfYyBd4=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.32/go.mod h1:IitoQxGfaKdVLNg0hD8/DXmAqNy0H4K2H2Sf91ti8sI=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.2 h1:Pg9URiobXy85kgFev3og2CuOZ8JZUBENF+dcgWBaYNk=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.2/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.32 h1:OIHj/nAhVzIXGzbAE+4XmZ8FPvro3THr6NlqErJc3wY=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.32/go.mod h1:LiBEsDo34OJXqdDlRGsilhlIiXR7DL+6Cx2f4p1EgzI=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.2 h1:D4oz8/CzT9bAEYtVhSBmFj2dNOtaHOtMKc2vHBwYizA=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.2/go.mod h1:Za3IHqTQ+yNcRHxu1OFucBh0ACZT4j4VQFF0BqpZcLY=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.5.6 h1:cCBJaT7EeEojpJ4s7wTDbhZlHVJOgNHN7iw6qVurGaw=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.5.6/go.mod h1:WYH1ABybY7JK9TITPnk6ZlP7gQB8psI4c9qDmMsnLSA=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.13 h1:SYVGSFQHlchIcy6e7x12bsrxClCXSP5et8cqVhL8cuw=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.13/go.mod h1:kizuDaLX37bG5WZaoxGPQR/LNFXpxp0vsUnqfkWXfNE=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.13 h1:OBsrtam3rk8NfBEq7OLOMm5HtQ9Yyw32X4UQMya/wjw=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.13/go.mod h1:3U4gFA5pmoCOja7aq4nSaIAGbaOHv2Yl2ug018cmC+Q=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.75.4 h1:DJYjOvNgC30JAcDCRmtQHoYK4trc7XetDXRTEAReGKA=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.75.4/go.mod h1:KuLNrwYJFaC2AVZ+CVVc12k9NyqwgWsoNNHjwqF6QNk=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.15 h1:/eE3DogBjYlvlbhd2ssWyeuovWunHLxfgw3s/OJa4GQ=
+github.com/aws/aws-sdk-go-v2/service/sso v1.24.15/go.mod h1:2PCJYpi7EKeA5SkStAmZlF6fi0uUABuhtF8ILHjGc3Y=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.14 h1:M/zwXiL2iXUrHputuXgmO94TVNmcenPHxgLXLutodKE=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.14/go.mod h1:RVwIw3y/IqxC2YEXSIkAzRDdEU1iRabDPaYjpGCbCGQ=
+github.com/aws/aws-sdk-go-v2/service/sts v1.33.14 h1:TzeR06UCMUq+KA3bDkujxK1GVGy+G8qQN/QVYzGLkQE=
+github.com/aws/aws-sdk-go-v2/service/sts v1.33.14/go.mod h1:dspXf/oYWGWo6DEvj98wpaTeqt5+DMidZD0A9BYTizc=
+github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
+github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/containrrr/shoutrrr v0.8.0 h1:mfG2ATzIS7NR2Ec6XL+xyoHzN97H8WPjir8aYzJUSec=
+github.com/containrrr/shoutrrr v0.8.0/go.mod h1:ioyQAyu1LJY6sILuNyKaQaw+9Ttik5QePU8atnAdO2o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+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/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.8.2 h1:jPPGWs2sZ1UgOSgD2bClL0MJIqu58nOmIcBuXr62z1I=
+github.com/ebitengine/purego v0.8.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+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/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+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/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/ganigeorgiev/fexpr v0.4.1 h1:hpUgbUEEWIZhSDBtf4M9aUNfQQ0BZkGRaMePy7Gcx5k=
+github.com/ganigeorgiev/fexpr v0.4.1/go.mod h1:RyGiGqmeXhEQ6+mlGdnUleLHgtzzu/VGO2WtJkF5drE=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+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=
+github.com/go-ozzo/ozzo-validation/v4 v4.3.0 h1:byhDUpfEwjsVQb1vBunvIjh2BHQ9ead57VkAEY4V+Es=
+github.com/go-ozzo/ozzo-validation/v4 v4.3.0/go.mod h1:2NKgrcHl3z6cJs+3Oo940FPRiTzuqKbvfrL2RxCj6Ew=
+github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
+github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
+github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+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/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+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-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k=
+github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo=
+github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
+github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+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/google/wire v0.6.0 h1:HBkoIh4BdSxoyo9PveV8giw7ZsaBOvzWKfcg/6MrVwI=
+github.com/google/wire v0.6.0/go.mod h1:F4QhpQ9EDIdJ1Mbop/NZBRB+5yrR6qg3BnctaoUk6NA=
+github.com/googleapis/enterprise-certificate-proxy v0.3.4 h1:XYIDZApgAnrN1c855gTgghdIA6Stxb52D5RnLI1SLyw=
+github.com/googleapis/enterprise-certificate-proxy v0.3.4/go.mod h1:YKe7cfqYXjKGpGvmSg28/fFvhNzinZQm8DGnaburhGA=
+github.com/googleapis/gax-go/v2 v2.14.1 h1:hb0FFeiPaQskmvakKu5EbCbpntQn48jyHuvrkurSS/Q=
+github.com/googleapis/gax-go/v2 v2.14.1/go.mod h1:Hb/NubMaVM88SrNkvl8X/o8XWwDJEPqouaLeN2IUxoA=
+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.3.0 h1:2RJ8GP0IIaWwcC9Fp2BmVi8Kog3v2Hn7VXM3fTd+nuc=
+github.com/jarcoal/httpmock v1.3.0/go.mod h1:3yb8rc4BI7TCBhFY8ng0gjuLKJNquuDNiPaZjnENuYg=
+github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
+github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
+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-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0=
+github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+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.9.2 h1:BA2GMJOtfGAfagzYtrAlufIP0lq6QERkFmHLMLPwFSU=
+github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts=
+github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
+github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
+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.25.0 h1:/4YQq1hd0muvhzbERyUTVNh88N0BCj5diqK0jtLN6k8=
+github.com/pocketbase/pocketbase v0.25.0/go.mod h1:tOtOv7f3vJhAiyUluIwV9JPuKeknZRQ9F6uJE3W/ntI=
+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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+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.1 h1:QSWkTc+fu9LTAWfkZwZ6j8MSUk4A2LV7rbH0ZqmLjXs=
+github.com/shirou/gopsutil/v4 v4.25.1/go.mod h1:RoUCUpndaJFtT+2zsZzzmhvbfGoDCJ7nFXKJf8GqJbI=
+github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
+github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+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/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+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.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
+github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
+github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo=
+github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI=
+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/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
+go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.58.0 h1:PS8wXpbyaDJQ2VDHHncMe9Vct0Zn1fEjpsjrLxGJoSc=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.58.0/go.mod h1:HDBUsEjOuRC0EzKZ1bSaRGZWUBAzo+MhAcUUORSr4D0=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 h1:yd02MEjBdJkG3uabWP9apV+OuWRIXGDuJEUJbOHmCFU=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0/go.mod h1:umTcuxiv1n/s/S6/c2AT/g2CQ7u5C59sHDNmfSwgz7Q=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
+go.opentelemetry.io/otel/sdk v1.32.0 h1:RNxepc9vK59A8XsgZQouW8ue8Gkb4jpWtJm9ge5lEG4=
+go.opentelemetry.io/otel/sdk v1.32.0/go.mod h1:LqgegDBjKMmb2GC6/PrTnteJG39I8/vJCAP9LlJXEjU=
+go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU=
+go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+gocloud.dev v0.40.0 h1:f8LgP+4WDqOG/RXoUcyLpeIAGOcAbZrZbDQCUee10ng=
+gocloud.dev v0.40.0/go.mod h1:drz+VyYNBvrMTW0KZiBAYEdl8lbNZx+OQ7oQvdrFmSQ=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20250128182459-e0ece0dbea4c h1:KL/ZBHXgKGVmuZBZ01Lt57yE5ws8ZPSkkihmEyq7FXc=
+golang.org/x/exp v0.0.0-20250128182459-e0ece0dbea4c/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.24.0 h1:AN7zRgVsbvmTfNyqIbbOraYL8mSwcKncEj8ofjgzcMQ=
+golang.org/x/image v0.24.0/go.mod h1:4b/ITuLfqYq1hqZcjofwctIhi7sZh2WaCjvsBNjjya8=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
+golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/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-20190213061140-3a22650c66bd/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.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+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.26.0 h1:afQXWNNaeC4nvZ0Ed9XvCCzXM6UHJG7iCg0W4fPqSBE=
+golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+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-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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-20200930185726-fdedc70b468f/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.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+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.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
+golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE=
+golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da h1:noIWHXmPHxILtqtCOPIhSt0ABwskkZKjD3bXGnZGpNY=
+golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+google.golang.org/api v0.220.0 h1:3oMI4gdBgB72WFVwE1nerDD8W3HUOS4kypK6rRLbGns=
+google.golang.org/api v0.220.0/go.mod h1:26ZAlY6aN/8WgpCzjPNy18QpYaz7Zgg1h0qe1GkZEmY=
+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.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20240812133136-8ffd90a71988 h1:CT2Thj5AuPV9phrYMtzX11k+XkzMGfRAet42PmoTATM=
+google.golang.org/genproto v0.0.0-20240812133136-8ffd90a71988/go.mod h1:7uvplUBj4RjHAxIZ//98LzOvrQ04JBkaixRmCMI29hc=
+google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 h1:CkkIfIt50+lT6NHAVoRYEyAvQGFM7xEwXUUywFvEb3Q=
+google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576/go.mod h1:1R3kvZ1dtP3+4p4d3G8uJ8rFk/fWlScl38vanWACI08=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 h1:5bKytslY8ViY0Cj/ewmRtrWHW64bNF03cAatUUFCdFI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489/go.mod h1:8BS3B93F/U1juMFq9+EDk+qOT5CO1R9IzXxG3PTqiRk=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
+google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.36.4 h1:6A3ZDJHn/eNqc1i+IdefRzy/9PokBTPvcqMySR7NNIM=
+google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+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/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.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+modernc.org/cc/v4 v4.21.4 h1:3Be/Rdo1fpr8GrQ7IVw9OHtplU4gWbb+wNgeoBMmGLQ=
+modernc.org/cc/v4 v4.21.4/go.mod h1:HM7VJTZbUCR3rV8EYBi9wxnJ0ZBRiGE5OeGXNA0IsLQ=
+modernc.org/ccgo/v4 v4.19.2 h1:lwQZgvboKD0jBwdaeVCTouxhxAyN6iawF3STraAal8Y=
+modernc.org/ccgo/v4 v4.19.2/go.mod h1:ysS3mxiMV38XGRTTcgo0DQTeTmAO4oCmJl1nX9VFI3s=
+modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE=
+modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ=
+modernc.org/gc/v2 v2.4.1 h1:9cNzOqPyMJBvrUipmynX0ZohMhcxPtMccYgGOJdOiBw=
+modernc.org/gc/v2 v2.4.1/go.mod h1:wzN5dK1AzVGoH6XOzc3YZ+ey/jPgYHLuVckd62P0GYU=
+modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U=
+modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w=
+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.8.2 h1:cL9L4bcoAObu4NkxOlKWBWtNHIsnnACGF/TbqQ6sbcI=
+modernc.org/memory v1.8.2/go.mod h1:ZbjSvMO5NQ1A2i3bWeDiVMxIorXwdClKE/0SZ+BMotU=
+modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4=
+modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
+modernc.org/sortutil v1.2.0 h1:jQiD3PfS2REGJNzNCMMaLSp/wdMNieTbKX920Cqdgqc=
+modernc.org/sortutil v1.2.0/go.mod h1:TKU2s7kJMf1AE84OoiGppNHJwvB753OYfNl2WRb++Ss=
+modernc.org/sqlite v1.34.5 h1:Bb6SR13/fjp15jt70CL4f18JIN7p7dnMExd+UFnF15g=
+modernc.org/sqlite v1.34.5/go.mod h1:YLuNmX9NKs8wRNK2ko1LW1NGYcc9FkBO69JOt1AR9JE=
+modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA=
+modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

beszel/internal/agent/agent.go

@@ -0,0 +1,128 @@
+// Package agent handles the agent's SSH server and system stats collection.
+package agent
+
+import (
+	"beszel"
+	"beszel/internal/entities/system"
+	"context"
+	"log/slog"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/shirou/gopsutil/v4/common"
+)
+
+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
+	sensorsContext   context.Context            // Sensors context to override sys location
+	sensorsWhitelist map[string]struct{}        // List of sensors to monitor
+	systemInfo       system.Info                // Host system info
+	gpuManager       *GPUManager                // Manages GPU data
+}
+
+func NewAgent() *Agent {
+	agent := &Agent{
+		fsStats: make(map[string]*system.FsStats),
+	}
+	agent.memCalc, _ = GetEnv("MEM_CALC")
+
+	// 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)
+
+	// Set sensors context (allows overriding sys location for sensors)
+	if sysSensors, exists := GetEnv("SYS_SENSORS"); exists {
+		slog.Info("SYS_SENSORS", "path", sysSensors)
+		agent.sensorsContext = context.WithValue(agent.sensorsContext,
+			common.EnvKey, common.EnvMap{common.HostSysEnvKey: sysSensors},
+		)
+	} else {
+		agent.sensorsContext = context.Background()
+	}
+
+	// Set sensors whitelist
+	if sensors, exists := GetEnv("SENSORS"); exists {
+		agent.sensorsWhitelist = make(map[string]struct{})
+		for _, sensor := range strings.Split(sensors, ",") {
+			if sensor != "" {
+				agent.sensorsWhitelist[sensor] = struct{}{}
+			}
+		}
+	}
+
+	// initialize system info / docker manager
+	agent.initializeSystemInfo()
+	agent.initializeDiskInfo()
+	agent.initializeNetIoStats()
+	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
+}
+
+// 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() system.CombinedData {
+	a.Lock()
+	defer a.Unlock()
+	slog.Debug("Getting stats")
+	systemData := system.CombinedData{
+		Stats: a.getSystemStats(),
+		Info:  a.systemInfo,
+	}
+	slog.Debug("System stats", "data", systemData)
+	// add docker stats
+	if containerStats, err := a.dockerManager.getDockerStats(); err == nil {
+		systemData.Containers = containerStats
+		slog.Debug("Docker stats", "data", systemData.Containers)
+	} else {
+		slog.Debug("Error getting docker stats", "err", err)
+	}
+	// add extra filesystems
+	systemData.Stats.ExtraFs = make(map[string]*system.FsStats)
+	for name, stats := range a.fsStats {
+		if !stats.Root && stats.DiskTotal > 0 {
+			systemData.Stats.ExtraFs[name] = stats
+		}
+	}
+	slog.Debug("Extra filesystems", "data", systemData.Stats.ExtraFs)
+	return systemData
+}

beszel/internal/agent/disk.go

@@ -1,15 +1,13 @@
 package agent
 
 import (
+	"beszel/internal/entities/system"
 	"log/slog"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/system"
-
 	"github.com/shirou/gopsutil/v4/disk"
 )
 
@@ -38,12 +36,7 @@ func (a *Agent) initializeDiskInfo() {
 
 	// Helper function to add a filesystem to fsStats if it doesn't exist
 	addFsStat := func(device, mountpoint string, root bool) {
-		var key string
-		if runtime.GOOS == "windows" {
-			key = device
-		} else {
-			key = filepath.Base(device)
-		}
+		key := filepath.Base(device)
 		var ioMatch bool
 		if _, exists := a.fsStats[key]; !exists {
 			if root {

beszel/internal/agent/docker.go

@@ -1,7 +1,7 @@
 package agent
 
 import (
-	"bytes"
+	"beszel/internal/entities/container"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -14,8 +14,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/container"
-
 	"github.com/blang/semver"
 )
 
@@ -24,26 +22,10 @@ type dockerManager struct {
 	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)
+	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
-}
-
-// 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
@@ -68,15 +50,13 @@ func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 	if err != nil {
 		return nil, err
 	}
+	defer resp.Body.Close()
 
-	dm.apiContainerList = dm.apiContainerList[:0]
-	if err := dm.decode(resp, &dm.apiContainerList); err != nil {
+	if err := json.NewDecoder(resp.Body).Decode(&dm.apiContainerList); err != nil {
 		return nil, err
 	}
 
-	dm.isWindows = strings.Contains(resp.Header.Get("Server"), "windows")
-
-	containersLength := len(dm.apiContainerList)
+	containersLength := len(*dm.apiContainerList)
 
 	// store valid ids to clean up old container ids from map
 	if dm.validIds == nil {
@@ -85,10 +65,9 @@ func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 		clear(dm.validIds)
 	}
 
-	var failedContainers []*container.ApiInfo
+	var failedContainters []container.ApiInfo
 
-	for i := range dm.apiContainerList {
-		ctr := dm.apiContainerList[i]
+	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)
@@ -105,7 +84,7 @@ func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 			if err != nil {
 				dm.containerStatsMutex.Lock()
 				delete(dm.containerStatsMap, ctr.IdShort)
-				failedContainers = append(failedContainers, ctr)
+				failedContainters = append(failedContainters, ctr)
 				dm.containerStatsMutex.Unlock()
 			}
 		}()
@@ -114,10 +93,9 @@ func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 	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]
+	if len(failedContainters) > 0 {
+		slog.Debug("Retrying failed containers", "count", len(failedContainters))
+		for _, ctr := range failedContainters {
 			dm.queue()
 			go func() {
 				defer dm.dequeue()
@@ -144,7 +122,7 @@ func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
 }
 
 // Updates stats for individual container
-func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
+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")
@@ -170,45 +148,31 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
 	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 {
+	var res container.ApiStats
+	if err := json.NewDecoder(resp.Body).Decode(&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)
+	// 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)
 	}
 
+	// memory (https://docs.docker.com/reference/cli/docker/container/stats/)
+	memCache := res.MemoryStats.Stats.InactiveFile
+	if memCache == 0 {
+		memCache = res.MemoryStats.Stats.Cache
+	}
+	usedMemory := res.MemoryStats.Usage - memCache
+
+	// cpu
+	cpuDelta := res.CPUStats.CPUUsage.TotalUsage - stats.PrevCpu[0]
+	systemDelta := res.CPUStats.SystemUsage - stats.PrevCpu[1]
+	cpuPct := float64(cpuDelta) / float64(systemDelta) * 100
 	if cpuPct > 100 {
 		return fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
 	}
+	stats.PrevCpu = [2]uint64{res.CPUStats.CPUUsage.TotalUsage, res.CPUStats.SystemUsage}
 
 	// network
 	var total_sent, total_recv uint64
@@ -216,25 +180,21 @@ func (dm *dockerManager) updateContainerStats(ctr *container.ApiInfo) error {
 		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
-		}
+	var sent_delta, recv_delta float64
+	// prevent first run from sending all prev sent/recv bytes
+	if initialized {
+		secondsElapsed := time.Since(stats.PrevNet.Time).Seconds()
+		sent_delta = float64(total_sent-stats.PrevNet.Sent) / secondsElapsed
+		recv_delta = float64(total_recv-stats.PrevNet.Recv) / secondsElapsed
 	}
-	stats.PrevNet.Sent, stats.PrevNet.Recv = total_sent, total_recv
+	stats.PrevNet.Sent = total_sent
+	stats.PrevNet.Recv = total_recv
+	stats.PrevNet.Time = time.Now()
 
 	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
+	stats.NetworkSent = bytesToMegabytes(sent_delta)
+	stats.NetworkRecv = bytesToMegabytes(recv_delta)
 
 	return nil
 }
@@ -250,16 +210,14 @@ func (dm *dockerManager) deleteContainerStatsSync(id string) {
 func newDockerManager(a *Agent) *dockerManager {
 	dockerHost, exists := GetEnv("DOCKER_HOST")
 	if exists {
-		// return nil if set to empty string
-		if dockerHost == "" {
-			return nil
-		}
+		slog.Info("DOCKER_HOST", "host", dockerHost)
 	} else {
 		dockerHost = getDockerHost()
 	}
 
 	parsedURL, err := url.Parse(dockerHost)
 	if err != nil {
+		slog.Error("Error parsing DOCKER_HOST", "err", err)
 		os.Exit(1)
 	}
 
@@ -293,28 +251,20 @@ func newDockerManager(a *Agent) *dockerManager {
 		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{
+	dockerClient := &dockerManager{
 		client: &http.Client{
 			Timeout:   timeout,
-			Transport: userAgentTransport,
+			Transport: transport,
 		},
 		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
+		dockerClient.goodDockerVersion = true
+		return dockerClient
 	}
 
 	// Check docker version
@@ -322,39 +272,23 @@ func newDockerManager(a *Agent) *dockerManager {
 	var versionInfo struct {
 		Version string `json:"Version"`
 	}
-	resp, err := manager.client.Get("http://localhost/version")
+	resp, err := dockerClient.client.Get("http://localhost/version")
 	if err != nil {
-		return manager
+		return dockerClient
 	}
 
-	if err := manager.decode(resp, &versionInfo); err != nil {
-		return manager
+	if err := json.NewDecoder(resp.Body).Decode(&versionInfo); err != nil {
+		return dockerClient
 	}
 
 	// 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
+		dockerClient.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)
+	return dockerClient
 }
 
 // Test docker / podman sockets and return if one exists

beszel/internal/agent/gpu.go

@@ -1,8 +1,8 @@
 package agent
 
 import (
+	"beszel/internal/entities/system"
 	"bufio"
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"os/exec"
@@ -12,38 +12,16 @@ import (
 	"sync"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/system"
-
 	"golang.org/x/exp/slog"
 )
 
-const (
-	// Commands
-	nvidiaSmiCmd  string = "nvidia-smi"
-	rocmSmiCmd    string = "rocm-smi"
-	tegraStatsCmd string = "tegrastats"
-
-	// Polling intervals
-	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
-
-	// Unit Conversions
-	mebibytesInAMegabyte float64 = 1.024  // nvidia-smi reports memory in MiB
-	milliwattsInAWatt    float64 = 1000.0 // tegrastats reports power in mW
-)
-
 // 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
+	nvidiaSmi  bool
+	rocmSmi    bool
+	tegrastats bool
+	GpuDataMap map[string]*system.GPUData
 }
 
 // RocmSmiJson represents the JSON structure of rocm-smi output
@@ -64,7 +42,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
@@ -79,7 +56,7 @@ func (c *gpuCollector) start() {
 				break
 			}
 			slog.Warn(c.name+" failed, restarting", "err", err)
-			time.Sleep(retryWaitTime)
+			time.Sleep(time.Second * 5)
 			continue
 		}
 	}
@@ -98,7 +75,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, 4*1024)
 	}
 	scanner.Buffer(c.buf, bufio.MaxScanTokenSize)
 
@@ -125,35 +102,36 @@ func (gm *GPUManager) getJetsonParser() func(output []byte) bool {
 	// TODO: Maybe use VDD_IN for Nano / NX and add a total system power chart
 	powerPattern := regexp.MustCompile(`(GPU_SOC|CPU_GPU_CV) (\d+)mW`)
 
-	// jetson devices have only one gpu so we'll just initialize here
-	gpuData := &system.GPUData{Name: "GPU"}
-	gm.GpuDataMap["0"] = gpuData
-
 	return func(output []byte) bool {
 		gm.Lock()
 		defer gm.Unlock()
+		// we get gpu name from the intitial run of nvidia-smi, so return if it hasn't been initialized
+		gpuData, ok := gm.GpuDataMap["0"]
+		if !ok {
+			return true
+		}
+		data := string(output)
 		// Parse RAM usage
-		ramMatches := ramPattern.FindSubmatch(output)
+		ramMatches := ramPattern.FindStringSubmatch(data)
 		if ramMatches != nil {
-			gpuData.MemoryUsed, _ = strconv.ParseFloat(string(ramMatches[1]), 64)
-			gpuData.MemoryTotal, _ = strconv.ParseFloat(string(ramMatches[2]), 64)
+			gpuData.MemoryUsed, _ = strconv.ParseFloat(ramMatches[1], 64)
+			gpuData.MemoryTotal, _ = strconv.ParseFloat(ramMatches[2], 64)
 		}
 		// Parse GR3D (GPU) usage
-		gr3dMatches := gr3dPattern.FindSubmatch(output)
+		gr3dMatches := gr3dPattern.FindStringSubmatch(data)
 		if gr3dMatches != nil {
-			gr3dUsage, _ := strconv.ParseFloat(string(gr3dMatches[1]), 64)
-			gpuData.Usage += gr3dUsage
+			gpuData.Usage, _ = strconv.ParseFloat(gr3dMatches[1], 64)
 		}
 		// Parse temperature
-		tempMatches := tempPattern.FindSubmatch(output)
+		tempMatches := tempPattern.FindStringSubmatch(data)
 		if tempMatches != nil {
-			gpuData.Temperature, _ = strconv.ParseFloat(string(tempMatches[1]), 64)
+			gpuData.Temperature, _ = strconv.ParseFloat(tempMatches[1], 64)
 		}
 		// Parse power usage
-		powerMatches := powerPattern.FindSubmatch(output)
+		powerMatches := powerPattern.FindStringSubmatch(data)
 		if powerMatches != nil {
-			power, _ := strconv.ParseFloat(string(powerMatches[2]), 64)
-			gpuData.Power += power / milliwattsInAWatt
+			power, _ := strconv.ParseFloat(powerMatches[2], 64)
+			gpuData.Power = power / 1000
 		}
 		gpuData.Count++
 		return true
@@ -164,10 +142,8 @@ func (gm *GPUManager) getJetsonParser() func(output []byte) bool {
 func (gm *GPUManager) parseNvidiaData(output []byte) bool {
 	gm.Lock()
 	defer gm.Unlock()
-	scanner := bufio.NewScanner(bytes.NewReader(output))
 	var valid bool
-	for scanner.Scan() {
-		line := scanner.Text() // Or use scanner.Bytes() for []byte
+	for line := range strings.Lines(string(output)) {
 		fields := strings.Split(strings.TrimSpace(line), ", ")
 		if len(fields) < 7 {
 			continue
@@ -183,12 +159,18 @@ func (gm *GPUManager) parseNvidiaData(output []byte) bool {
 		if _, ok := gm.GpuDataMap[id]; !ok {
 			name := strings.TrimPrefix(fields[1], "NVIDIA ")
 			gm.GpuDataMap[id] = &system.GPUData{Name: strings.TrimSuffix(name, " Laptop GPU")}
+			// check if tegrastats is active - if so we will only use nvidia-smi to get gpu name
+			// - nvidia-smi does not provide metrics for tegra / jetson devices
+			// this will end the nvidia-smi collector
+			if gm.tegrastats {
+				return false
+			}
 		}
 		// update gpu data
 		gpu := gm.GpuDataMap[id]
 		gpu.Temperature = temp
-		gpu.MemoryUsed = memoryUsage / mebibytesInAMegabyte
-		gpu.MemoryTotal = totalMemory / mebibytesInAMegabyte
+		gpu.MemoryUsed = memoryUsage / 1.024
+		gpu.MemoryTotal = totalMemory / 1.024
 		gpu.Usage += usage
 		gpu.Power += power
 		gpu.Count++
@@ -243,39 +225,22 @@ func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
 	// copy / reset the data
 	gpuData := make(map[string]system.GPUData, len(gm.GpuDataMap))
 	for id, gpu := range gm.GpuDataMap {
-		// avoid division by zero
-		count := max(gpu.Count, 1)
-
-		// average the data
-		gpuAvg := *gpu
-		gpuAvg.Temperature = twoDecimals(gpu.Temperature)
-		gpuAvg.Power = twoDecimals(gpu.Power / count)
-
-		// intel gpu stats doesn't provide usage, memory used, or memory total
-		if gm.intelGpuStats {
-			maxEngineUsage := 0.0
-			for name, engine := range gpu.Engines {
-				gpuAvg.Engines[name] = twoDecimals(engine / count)
-				maxEngineUsage = max(maxEngineUsage, engine/count)
-			}
-			gpuAvg.Usage = twoDecimals(maxEngineUsage)
-		} else {
-			gpuAvg.Usage = twoDecimals(gpu.Usage / count)
-			gpuAvg.MemoryUsed = twoDecimals(gpu.MemoryUsed)
-			gpuAvg.MemoryTotal = twoDecimals(gpu.MemoryTotal)
-		}
-
-		// reset accumulators in the original gpu data for next collection
-		gpu.Usage, gpu.Power, gpu.Count = gpuAvg.Usage, gpuAvg.Power, 1
-		gpu.Engines = gpuAvg.Engines
-
+		// sum the data
+		gpu.Temperature = twoDecimals(gpu.Temperature)
+		gpu.MemoryUsed = twoDecimals(gpu.MemoryUsed)
+		gpu.MemoryTotal = twoDecimals(gpu.MemoryTotal)
+		gpu.Usage = twoDecimals(gpu.Usage / gpu.Count)
+		gpu.Power = twoDecimals(gpu.Power / gpu.Count)
+		// reset the count
+		gpu.Count = 1
+		// dereference to avoid overwriting anything else
+		gpuCopy := *gpu
 		// 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)
+			gpuCopy.Name = fmt.Sprintf("%s %s", gpu.Name, id)
 		}
-		gpuData[id] = gpuAvg
+		gpuData[id] = gpuCopy
 	}
-	slog.Debug("GPU", "data", gpuData)
 	return gpuData
 }
 
@@ -284,60 +249,38 @@ func (gm *GPUManager) GetCurrentData() map[string]system.GPUData {
 // tools are found. If none of the tools are found, it returns an error indicating that no GPU
 // management tools are available.
 func (gm *GPUManager) detectGPUs() error {
-	if _, err := exec.LookPath(nvidiaSmiCmd); err == nil {
+	if _, err := exec.LookPath("nvidia-smi"); err == nil {
 		gm.nvidiaSmi = true
 	}
-	if _, err := exec.LookPath(rocmSmiCmd); err == nil {
+	if _, err := exec.LookPath("rocm-smi"); err == nil {
 		gm.rocmSmi = true
 	}
-	if _, err := exec.LookPath(tegraStatsCmd); err == nil {
+	if _, err := exec.LookPath("tegrastats"); err == nil {
 		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,
+	case "nvidia-smi":
+		collector.cmdArgs = []string{"-l", "4",
 			"--query-gpu=index,name,temperature.gpu,memory.used,memory.total,utilization.gpu,power.draw",
-			"--format=csv,noheader,nounits",
-		}
+			"--format=csv,noheader,nounits"}
 		collector.parse = gm.parseNvidiaData
 		go collector.start()
-	case tegraStatsCmd:
-		collector.cmdArgs = []string{"--interval", tegraStatsInterval}
+	case "tegrastats":
+		collector.cmdArgs = []string{"--interval", "3000"}
 		collector.parse = gm.getJetsonParser()
 		go collector.start()
-	case rocmSmiCmd:
+	case "rocm-smi":
 		collector.cmdArgs = []string{"--showid", "--showtemp", "--showuse", "--showpower", "--showproductname", "--showmeminfo", "vram", "--json"}
 		collector.parse = gm.parseAmdData
 		go func() {
@@ -345,12 +288,12 @@ func (gm *GPUManager) startCollector(command string) {
 			for {
 				if err := collector.collect(); err != nil {
 					failures++
-					if failures > maxFailureRetries {
+					if failures > 5 {
 						break
 					}
 					slog.Warn("Error collecting AMD GPU data", "err", err)
 				}
-				time.Sleep(rocmSmiInterval)
+				time.Sleep(4300 * time.Millisecond)
 			}
 		}()
 	}
@@ -365,16 +308,13 @@ func NewGPUManager() (*GPUManager, error) {
 	gm.GpuDataMap = make(map[string]*system.GPUData)
 
 	if gm.nvidiaSmi {
-		gm.startCollector(nvidiaSmiCmd)
+		gm.startCollector("nvidia-smi")
 	}
 	if gm.rocmSmi {
-		gm.startCollector(rocmSmiCmd)
+		gm.startCollector("rocm-smi")
 	}
 	if gm.tegrastats {
-		gm.startCollector(tegraStatsCmd)
-	}
-	if gm.intelGpuStats {
-		gm.startCollector(intelGpuStatsCmd)
+		gm.startCollector("tegrastats")
 	}
 
 	return &gm, nil

beszel/internal/agent/gpu_test.go

@@ -0,0 +1,525 @@
+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:      "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
+		gm          *GPUManager
+		wantMetrics *system.GPUData
+	}{
+		{
+			name:  "valid data",
+			input: "RAM 4300/30698MB GR3D_FREQ 45% tj@52.468C VDD_GPU_SOC 2171mW",
+			wantMetrics: &system.GPUData{
+				Name:        "Jetson",
+				MemoryUsed:  4300.0,
+				MemoryTotal: 30698.0,
+				Usage:       45.0,
+				Temperature: 52.468,
+				Power:       2.171,
+				Count:       1,
+			},
+		},
+		{
+			name:  "missing temperature",
+			input: "RAM 4300/30698MB GR3D_FREQ 45% VDD_GPU_SOC 2171mW",
+			wantMetrics: &system.GPUData{
+				Name:        "Jetson",
+				MemoryUsed:  4300.0,
+				MemoryTotal: 30698.0,
+				Usage:       45.0,
+				Power:       2.171,
+				Count:       1,
+			},
+		},
+		{
+			name:  "no gpu defined by nvidia-smi",
+			input: "RAM 4300/30698MB GR3D_FREQ 45% VDD_GPU_SOC 2171mW",
+			gm: &GPUManager{
+				GpuDataMap: map[string]*system.GPUData{},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.gm != nil {
+				// should return if no gpu set by nvidia-smi
+				assert.Empty(t, tt.gm.GpuDataMap)
+				return
+			}
+			tt.gm = &GPUManager{
+				GpuDataMap: map[string]*system.GPUData{
+					"0": {Name: "Jetson"},
+				},
+			}
+			parser := tt.gm.getJetsonParser()
+			valid := parser([]byte(tt.input))
+			assert.Equal(t, true, valid)
+
+			got := tt.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) {
+	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,
+			},
+		},
+	}
+
+	result := gm.GetCurrentData()
+
+	// Verify name disambiguation
+	assert.Equal(t, "GPU1 0", result["0"].Name)
+	assert.Equal(t, "GPU1 1", result["1"].Name)
+
+	// Check averaged values
+	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 reset counts
+	assert.Equal(t, float64(1), gm.GpuDataMap["0"].Count)
+	assert.Equal(t, float64(1), gm.GpuDataMap["1"].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:  true,
+			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 "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)
+		})
+	}
+}

beszel/internal/agent/network.go

@@ -0,0 +1,66 @@
+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.Split(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"),
+		v.BytesRecv == 0,
+		v.BytesSent == 0:
+		return true
+	default:
+		return false
+	}
+}

beszel/internal/agent/server.go

@@ -0,0 +1,97 @@
+package agent
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net"
+	"os"
+	"strings"
+
+	sshServer "github.com/gliderlabs/ssh"
+	"golang.org/x/crypto/ssh"
+)
+
+type ServerOptions struct {
+	Addr    string
+	Network string
+	Keys    []ssh.PublicKey
+}
+
+func (a *Agent) StartServer(opts ServerOptions) error {
+	sshServer.Handle(a.handleSession)
+
+	slog.Info("Starting SSH server", "addr", opts.Addr, "network", opts.Network)
+
+	switch opts.Network {
+	case "unix":
+		// remove existing socket file if it exists
+		if err := os.Remove(opts.Addr); err != nil && !os.IsNotExist(err) {
+			return err
+		}
+	default:
+		// prefix with : if only port was provided
+		if !strings.Contains(opts.Addr, ":") {
+			opts.Addr = ":" + opts.Addr
+		}
+	}
+
+	// Listen on the address
+	ln, err := net.Listen(opts.Network, opts.Addr)
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+
+	// Start SSH server on the listener
+	err = sshServer.Serve(ln, nil, sshServer.NoPty(),
+		sshServer.PublicKeyAuth(func(ctx sshServer.Context, key sshServer.PublicKey) bool {
+			for _, pubKey := range opts.Keys {
+				if sshServer.KeysEqual(key, pubKey) {
+					return true
+				}
+			}
+			return false
+		}),
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (a *Agent) handleSession(s sshServer.Session) {
+	// slog.Debug("connection", "remoteaddr", s.RemoteAddr(), "user", s.User())
+	stats := a.gatherStats()
+	if err := json.NewEncoder(s).Encode(stats); err != nil {
+		slog.Error("Error encoding stats", "err", err, "stats", stats)
+		s.Exit(1)
+	}
+	s.Exit(0)
+}
+
+// ParseKeys parses a string containing SSH public keys in authorized_keys format.
+// It returns a slice of ssh.PublicKey and an error if any key fails to parse.
+func ParseKeys(input string) ([]ssh.PublicKey, error) {
+	var parsedKeys []ssh.PublicKey
+
+	for line := range strings.Lines(input) {
+		line = strings.TrimSpace(line)
+
+		// Skip empty lines or comments
+		if len(line) == 0 || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Parse the key
+		parsedKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse key: %s, error: %w", line, err)
+		}
+
+		// Append the parsed key to the list
+		parsedKeys = append(parsedKeys, parsedKey)
+	}
+
+	return parsedKeys, nil
+}

beszel/internal/agent/server_test.go

@@ -0,0 +1,289 @@
+package agent
+
+import (
+	"crypto/ed25519"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/crypto/ssh"
+)
+
+func TestStartServer(t *testing.T) {
+	// Generate a test key pair
+	pubKey, privKey, err := ed25519.GenerateKey(nil)
+	require.NoError(t, err)
+	signer, err := ssh.NewSignerFromKey(privKey)
+	require.NoError(t, err)
+	sshPubKey, err := ssh.NewPublicKey(pubKey)
+	require.NoError(t, err)
+
+	// Generate a different key pair for bad key test
+	badPubKey, badPrivKey, err := ed25519.GenerateKey(nil)
+	require.NoError(t, err)
+	badSigner, err := ssh.NewSignerFromKey(badPrivKey)
+	require.NoError(t, err)
+	sshBadPubKey, err := ssh.NewPublicKey(badPubKey)
+	require.NoError(t, err)
+
+	socketFile := filepath.Join(t.TempDir(), "beszel-test.sock")
+
+	tests := []struct {
+		name        string
+		config      ServerOptions
+		wantErr     bool
+		errContains string
+		setup       func() error
+		cleanup     func() error
+	}{
+		{
+			name: "tcp port only",
+			config: ServerOptions{
+				Network: "tcp",
+				Addr:    "45987",
+				Keys:    []ssh.PublicKey{sshPubKey},
+			},
+		},
+		{
+			name: "tcp with ipv4",
+			config: ServerOptions{
+				Network: "tcp4",
+				Addr:    "127.0.0.1:45988",
+				Keys:    []ssh.PublicKey{sshPubKey},
+			},
+		},
+		{
+			name: "tcp with ipv6",
+			config: ServerOptions{
+				Network: "tcp6",
+				Addr:    "[::1]:45989",
+				Keys:    []ssh.PublicKey{sshPubKey},
+			},
+		},
+		{
+			name: "unix socket",
+			config: ServerOptions{
+				Network: "unix",
+				Addr:    socketFile,
+				Keys:    []ssh.PublicKey{sshPubKey},
+			},
+			setup: func() error {
+				// Create a socket file that should be removed
+				f, err := os.Create(socketFile)
+				if err != nil {
+					return err
+				}
+				return f.Close()
+			},
+			cleanup: func() error {
+				return os.Remove(socketFile)
+			},
+		},
+		{
+			name: "bad key should fail",
+			config: ServerOptions{
+				Network: "tcp",
+				Addr:    "45987",
+				Keys:    []ssh.PublicKey{sshBadPubKey},
+			},
+			wantErr:     true,
+			errContains: "ssh: handshake failed",
+		},
+		{
+			name: "good key still good",
+			config: ServerOptions{
+				Network: "tcp",
+				Addr:    "45987",
+				Keys:    []ssh.PublicKey{sshPubKey},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.setup != nil {
+				err := tt.setup()
+				require.NoError(t, err)
+			}
+
+			if tt.cleanup != nil {
+				defer tt.cleanup()
+			}
+
+			agent := NewAgent()
+
+			// Start server in a goroutine since it blocks
+			errChan := make(chan error, 1)
+			go func() {
+				errChan <- agent.StartServer(tt.config)
+			}()
+
+			// Add a short delay to allow the server to start
+			time.Sleep(100 * time.Millisecond)
+
+			// Try to connect to verify server is running
+			var client *ssh.Client
+			var err error
+
+			// Choose the appropriate signer based on the test case
+			testSigner := signer
+			if tt.name == "bad key should fail" {
+				testSigner = badSigner
+			}
+
+			sshClientConfig := &ssh.ClientConfig{
+				User: "a",
+				Auth: []ssh.AuthMethod{
+					ssh.PublicKeys(testSigner),
+				},
+				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+				Timeout:         4 * time.Second,
+			}
+
+			switch tt.config.Network {
+			case "unix":
+				client, err = ssh.Dial("unix", tt.config.Addr, sshClientConfig)
+			default:
+				if !strings.Contains(tt.config.Addr, ":") {
+					tt.config.Addr = ":" + tt.config.Addr
+				}
+				client, err = ssh.Dial("tcp", tt.config.Addr, sshClientConfig)
+			}
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				if tt.errContains != "" {
+					assert.Contains(t, err.Error(), tt.errContains)
+				}
+				return
+			}
+
+			require.NoError(t, err)
+			require.NotNil(t, client)
+			client.Close()
+		})
+	}
+}
+
+/////////////////////////////////////////////////////////////////
+//////////////////// ParseKeys Tests ////////////////////////////
+/////////////////////////////////////////////////////////////////
+
+// Helper function to generate a temporary file with content
+func createTempFile(content string) (string, error) {
+	tmpFile, err := os.CreateTemp("", "ssh_keys_*.txt")
+	if err != nil {
+		return "", fmt.Errorf("failed to create temp file: %w", err)
+	}
+	defer tmpFile.Close()
+
+	if _, err := tmpFile.WriteString(content); err != nil {
+		return "", fmt.Errorf("failed to write to temp file: %w", err)
+	}
+
+	return tmpFile.Name(), nil
+}
+
+// Test case 1: String with a single SSH key
+func TestParseSingleKeyFromString(t *testing.T) {
+	input := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo"
+	keys, err := ParseKeys(input)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+	if len(keys) != 1 {
+		t.Fatalf("Expected 1 key, got %d keys", len(keys))
+	}
+	if keys[0].Type() != "ssh-ed25519" {
+		t.Fatalf("Expected key type 'ssh-ed25519', got '%s'", keys[0].Type())
+	}
+}
+
+// Test case 2: String with multiple SSH keys
+func TestParseMultipleKeysFromString(t *testing.T) {
+	input := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo\nssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D \n #comment\n ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D"
+	keys, err := ParseKeys(input)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+	if len(keys) != 3 {
+		t.Fatalf("Expected 3 keys, got %d keys", len(keys))
+	}
+	if keys[0].Type() != "ssh-ed25519" || keys[1].Type() != "ssh-ed25519" || keys[2].Type() != "ssh-ed25519" {
+		t.Fatalf("Unexpected key types: %s, %s, %s", keys[0].Type(), keys[1].Type(), keys[2].Type())
+	}
+}
+
+// Test case 3: File with a single SSH key
+func TestParseSingleKeyFromFile(t *testing.T) {
+	content := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo"
+	filePath, err := createTempFile(content)
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(filePath) // Clean up the file after the test
+
+	// Read the file content
+	fileContent, err := os.ReadFile(filePath)
+	if err != nil {
+		t.Fatalf("Failed to read temp file: %v", err)
+	}
+
+	// Parse the keys
+	keys, err := ParseKeys(string(fileContent))
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+	if len(keys) != 1 {
+		t.Fatalf("Expected 1 key, got %d keys", len(keys))
+	}
+	if keys[0].Type() != "ssh-ed25519" {
+		t.Fatalf("Expected key type 'ssh-ed25519', got '%s'", keys[0].Type())
+	}
+}
+
+// Test case 4: File with multiple SSH keys
+func TestParseMultipleKeysFromFile(t *testing.T) {
+	content := "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKCBM91kukN7hbvFKtbpEeo2JXjCcNxXcdBH7V7ADMBo\nssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D \n #comment\n ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJDMtAOQfxDlCxe+A5lVbUY/DHxK1LAF2Z3AV0FYv36D"
+	filePath, err := createTempFile(content)
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	// defer os.Remove(filePath) // Clean up the file after the test
+
+	// Read the file content
+	fileContent, err := os.ReadFile(filePath)
+	if err != nil {
+		t.Fatalf("Failed to read temp file: %v", err)
+	}
+
+	// Parse the keys
+	keys, err := ParseKeys(string(fileContent))
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+	if len(keys) != 3 {
+		t.Fatalf("Expected 3 keys, got %d keys", len(keys))
+	}
+	if keys[0].Type() != "ssh-ed25519" || keys[1].Type() != "ssh-ed25519" || keys[2].Type() != "ssh-ed25519" {
+		t.Fatalf("Unexpected key types: %s, %s, %s", keys[0].Type(), keys[1].Type(), keys[2].Type())
+	}
+}
+
+// Test case 5: Invalid SSH key input
+func TestParseInvalidKey(t *testing.T) {
+	input := "invalid-key-data"
+	_, err := ParseKeys(input)
+	if err == nil {
+		t.Fatalf("Expected an error for invalid key, got nil")
+	}
+	expectedErrMsg := "failed to parse key"
+	if !strings.Contains(err.Error(), expectedErrMsg) {
+		t.Fatalf("Expected error message to contain '%s', got: %v", expectedErrMsg, err)
+	}
+}

beszel/internal/agent/system.go

@@ -1,6 +1,8 @@
 package agent
 
 import (
+	"beszel"
+	"beszel/internal/entities/system"
 	"bufio"
 	"fmt"
 	"log/slog"
@@ -9,40 +11,19 @@ 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"
+	"github.com/shirou/gopsutil/v4/sensors"
 )
 
 // Sets initial / non-changing values about the host system
 func (a *Agent) initializeSystemInfo() {
 	a.systemInfo.AgentVersion = beszel.Version
 	a.systemInfo.Hostname, _ = os.Hostname()
-
-	platform, _, version, _ := host.PlatformInformation()
-
-	if platform == "darwin" {
-		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.Os = system.Windows
-	} else if platform == "freebsd" {
-		a.systemInfo.Os = system.Freebsd
-		a.systemInfo.KernelVersion = version
-	} else {
-		a.systemInfo.Os = system.Linux
-	}
-
-	if a.systemInfo.KernelVersion == "" {
-		a.systemInfo.KernelVersion, _ = host.KernelVersion()
-	}
+	a.systemInfo.KernelVersion, _ = host.KernelVersion()
 
 	// cpu model
 	if info, err := cpu.Info(); err == nil && len(info) > 0 {
@@ -60,21 +41,16 @@ 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() system.Stats {
-	var systemStats system.Stats
-
-	// battery
-	if battery.HasReadableBattery() {
-		systemStats.Battery[0], systemStats.Battery[1], _ = battery.GetBatteryStats()
-	}
+	systemStats := system.Stats{}
 
 	// cpu percent
 	cpuPct, err := cpu.Percent(0, false)
@@ -84,16 +60,6 @@ func (a *Agent) getSystemStats() system.Stats {
 		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)
-	} else {
-		slog.Error("Error getting load average", "err", err)
-	}
-
 	// memory
 	if v, err := mem.VirtualMemory(); err == nil {
 		// swap
@@ -172,11 +138,57 @@ func (a *Agent) getSystemStats() system.Stats {
 	}
 
 	// network stats
-	a.updateNetworkStats(&systemStats)
+	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
-	a.updateTemperatures(&systemStats)
+	// temperatures (skip if sensors whitelist is set to empty string)
+	err = a.updateTemperatures(&systemStats)
+	if err != nil {
+		slog.Error("Error getting temperatures", "err", err)
+	}
 
 	// GPU data
 	if a.gpuManager != nil {
@@ -190,46 +202,81 @@ func (a *Agent) getSystemStats() system.Stats {
 			if systemStats.Temperatures == nil {
 				systemStats.Temperatures = make(map[string]float64, len(gpuData))
 			}
-			highestTemp := 0.0
 			for _, gpu := range gpuData {
 				if gpu.Temperature > 0 {
 					systemStats.Temperatures[gpu.Name] = gpu.Temperature
-					if a.sensorConfig.primarySensor == gpu.Name {
-						a.systemInfo.DashboardTemp = gpu.Temperature
-					}
-					if gpu.Temperature > highestTemp {
-						highestTemp = gpu.Temperature
-					}
 				}
 				// update high gpu percent for dashboard
 				a.systemInfo.GpuPct = max(a.systemInfo.GpuPct, gpu.Usage)
 			}
-			// use highest temp for dashboard temp if dashboard temp is unset
-			if a.systemInfo.DashboardTemp == 0 {
-				a.systemInfo.DashboardTemp = highestTemp
-			}
 		}
 	}
 
 	// 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.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
 }
 
+func (a *Agent) updateTemperatures(systemStats *system.Stats) error {
+	// skip if sensors whitelist is set to empty string
+	if a.sensorsWhitelist != nil && len(a.sensorsWhitelist) == 0 {
+		slog.Debug("Skipping temperature collection")
+		return nil
+	}
+
+	primarySensor, primarySensorIsDefined := GetEnv("PRIMARY_SENSOR")
+
+	// reset high temp
+	a.systemInfo.DashboardTemp = 0
+
+	// get sensor data
+	temps, err := sensors.TemperaturesWithContext(a.sensorsContext)
+	if err != nil {
+		return err
+	}
+	slog.Debug("Temperature", "sensors", temps)
+
+	// return if no sensors
+	if len(temps) == 0 {
+		return nil
+	}
+
+	systemStats.Temperatures = make(map[string]float64, len(temps))
+	for i, sensor := range temps {
+		// skip if temperature is unreasonable
+		if sensor.Temperature <= 0 || sensor.Temperature >= 200 {
+			continue
+		}
+		sensorName := sensor.SensorKey
+		if _, ok := systemStats.Temperatures[sensorName]; ok {
+			// if key already exists, append int to key
+			sensorName = sensorName + "_" + strconv.Itoa(i)
+		}
+		// skip if not in whitelist
+		if a.sensorsWhitelist != nil {
+			if _, nameInWhitelist := a.sensorsWhitelist[sensorName]; !nameInWhitelist {
+				continue
+			}
+		}
+		// set dashboard temperature
+		if primarySensorIsDefined {
+			if sensorName == primarySensor {
+				a.systemInfo.DashboardTemp = sensor.Temperature
+			}
+		} else {
+			a.systemInfo.DashboardTemp = max(a.systemInfo.DashboardTemp, sensor.Temperature)
+		}
+		systemStats.Temperatures[sensorName] = twoDecimals(sensor.Temperature)
+	}
+	return nil
+}
+
 // Returns the size of the ZFS ARC memory cache in bytes
 func getARCSize() (uint64, error) {
 	file, err := os.Open("/proc/spl/kstat/zfs/arcstats")

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

@@ -8,19 +8,15 @@ import (
 	"sync"
 	"time"
 
-	"github.com/nicholas-fedor/shoutrrr"
+	"github.com/containrrr/shoutrrr"
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/mailer"
 )
 
-type hubLike interface {
-	core.App
-	MakeLink(parts ...string) string
-}
-
 type AlertManager struct {
-	hub           hubLike
+	app           core.App
 	alertQueue    chan alertTask
 	stopChan      chan struct{}
 	pendingAlerts sync.Map
@@ -46,7 +42,6 @@ type SystemAlertStats struct {
 	NetSent      float64            `json:"ns"`
 	NetRecv      float64            `json:"nr"`
 	Temperatures map[string]float32 `json:"t"`
-	LoadAvg      [3]float64         `json:"la"`
 }
 
 type SystemAlertData struct {
@@ -71,7 +66,6 @@ var supportsTitle = map[string]struct{}{
 	"gotify":     {},
 	"ifttt":      {},
 	"join":       {},
-	"lark":       {},
 	"matrix":     {},
 	"ntfy":       {},
 	"opsgenie":   {},
@@ -84,27 +78,19 @@ var supportsTitle = map[string]struct{}{
 }
 
 // NewAlertManager creates a new AlertManager instance.
-func NewAlertManager(app hubLike) *AlertManager {
+func NewAlertManager(app core.App) *AlertManager {
 	am := &AlertManager{
-		hub:        app,
-		alertQueue: make(chan alertTask, 5),
+		app:        app,
+		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(
+	record, err := am.app.FindFirstRecordByFilter(
 		"user_settings", "user={:user}",
 		dbx.Params{"user": data.UserID},
 	)
@@ -117,12 +103,12 @@ func (am *AlertManager) SendAlert(data AlertMessageData) error {
 		Webhooks: []string{},
 	}
 	if err := record.UnmarshalJSONField("settings", &userAlertSettings); err != nil {
-		am.hub.Logger().Error("Failed to unmarshal user settings", "err", err)
+		am.app.Logger().Error("Failed to unmarshal user settings", "err", err.Error())
 	}
 	// send alerts via webhooks
 	for _, webhook := range userAlertSettings.Webhooks {
 		if err := am.SendShoutrrrAlert(webhook, data.Title, data.Message, data.Link, data.LinkText); err != nil {
-			am.hub.Logger().Error("Failed to send shoutrrr alert", "err", err)
+			am.app.Logger().Error("Failed to send shoutrrr alert", "err", err.Error())
 		}
 	}
 	// send alerts via email
@@ -138,15 +124,15 @@ func (am *AlertManager) SendAlert(data AlertMessageData) error {
 		Subject: data.Title,
 		Text:    data.Message + fmt.Sprintf("\n\n%s", data.Link),
 		From: mail.Address{
-			Address: am.hub.Settings().Meta.SenderAddress,
-			Name:    am.hub.Settings().Meta.SenderName,
+			Address: am.app.Settings().Meta.SenderAddress,
+			Name:    am.app.Settings().Meta.SenderName,
 		},
 	}
-	err = am.hub.NewMailClient().Send(&message)
+	err = am.app.NewMailClient().Send(&message)
 	if err != nil {
 		return err
 	}
-	am.hub.Logger().Info("Sent email alert", "to", message.To, "subj", message.Subject)
+	am.app.Logger().Info("Sent email alert", "to", message.To, "subj", message.Subject)
 	return nil
 }
 
@@ -180,12 +166,10 @@ func (am *AlertManager) SendShoutrrrAlert(notificationUrl, title, message, link,
 
 	// Add link
 	if scheme == "ntfy" {
+		// if ntfy, add link to actions
 		queryParams.Add("Actions", fmt.Sprintf("view, %s, %s", linkText, link))
-	} else if scheme == "lark" {
-		queryParams.Add("link", link)
-	} else if scheme == "bark" {
-		queryParams.Add("url", link)
 	} else {
+		// else add link directly to the message
 		message += "\n\n" + link
 	}
 
@@ -196,23 +180,25 @@ func (am *AlertManager) SendShoutrrrAlert(notificationUrl, title, message, link,
 	err = shoutrrr.Send(parsedURL.String(), message)
 
 	if err == nil {
-		am.hub.Logger().Info("Sent shoutrrr alert", "title", title)
+		am.app.Logger().Info("Sent shoutrrr alert", "title", title)
 	} else {
-		am.hub.Logger().Error("Error sending shoutrrr alert", "err", err)
+		am.app.Logger().Error("Error sending shoutrrr alert", "err", err.Error())
 		return err
 	}
 	return nil
 }
 
 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.app.Settings().Meta.AppURL, "View Beszel")
 	if err != nil {
 		return e.JSON(200, map[string]string{"err": err.Error()})
 	}

beszel/internal/alerts/alerts_status.go

@@ -2,6 +2,7 @@ package alerts
 
 import (
 	"fmt"
+	"net/url"
 	"strings"
 	"time"
 
@@ -25,12 +26,8 @@ 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)
-
+	// no special reason for 13 seconds
+	tick := time.Tick(13 * time.Second)
 	for {
 		select {
 		case <-am.stopChan:
@@ -46,9 +43,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 {
@@ -69,12 +64,21 @@ func (am *AlertManager) StopWorker() {
 }
 
 // HandleStatusAlerts manages the logic when system status changes.
-func (am *AlertManager) HandleStatusAlerts(newStatus string, systemRecord *core.Record) error {
-	if newStatus != "up" && newStatus != "down" {
+func (am *AlertManager) HandleStatusAlerts(newStatus string, oldSystemRecord *core.Record) error {
+	switch newStatus {
+	case "up":
+		if oldSystemRecord.GetString("status") != "down" {
+			return nil
+		}
+	case "down":
+		if oldSystemRecord.GetString("status") != "up" {
+			return nil
+		}
+	default:
 		return nil
 	}
 
-	alertRecords, err := am.getSystemStatusAlerts(systemRecord.Id)
+	alertRecords, err := am.getSystemStatusAlerts(oldSystemRecord.Id)
 	if err != nil {
 		return err
 	}
@@ -82,7 +86,7 @@ func (am *AlertManager) HandleStatusAlerts(newStatus string, systemRecord *core.
 		return nil
 	}
 
-	systemName := systemRecord.GetString("name")
+	systemName := oldSystemRecord.GetString("name")
 	if newStatus == "down" {
 		am.handleSystemDown(systemName, alertRecords)
 	} else {
@@ -93,7 +97,7 @@ func (am *AlertManager) HandleStatusAlerts(newStatus string, systemRecord *core.
 
 // getSystemStatusAlerts retrieves all "Status" alert records for a given system ID.
 func (am *AlertManager) getSystemStatusAlerts(systemID string) ([]*core.Record, error) {
-	alertRecords, err := am.hub.FindAllRecords("alerts", dbx.HashExp{
+	alertRecords, err := am.app.FindAllRecords("alerts", dbx.HashExp{
 		"system": systemID,
 		"name":   "Status",
 	})
@@ -136,21 +140,13 @@ func (am *AlertManager) handleSystemUp(systemName string, alertRecords []*core.R
 		}
 		// No alert scheduled for this record, send "up" alert
 		if err := am.sendStatusAlert("up", systemName, alertRecord); err != nil {
-			am.hub.Logger().Error("Failed to send alert", "err", err)
+			am.app.Logger().Error("Failed to send alert", "err", err.Error())
 		}
 	}
 }
 
 // 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 +157,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.app.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),
+		Link:     am.app.Settings().Meta.AppURL + "/system/" + url.PathEscape(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,22 +1,23 @@
 package alerts
 
 import (
-	"encoding/json"
+	"beszel/internal/entities/system"
 	"fmt"
+	"net/url"
+	"slices"
 	"strings"
 	"time"
 
-	"github.com/henrygd/beszel/internal/entities/system"
-
+	"github.com/goccy/go-json"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/types"
 	"github.com/spf13/cast"
 )
 
-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}),
+func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, systemInfo system.Info, temperatures map[string]float64, extraFs map[string]*system.FsStats) error {
+	alertRecords, err := am.app.FindAllRecords("alerts",
+		dbx.NewExp("system={:system}", dbx.Params{"system": systemRecord.Id}),
 	)
 	if err != nil || len(alertRecords) == 0 {
 		// log.Println("no alerts found for system")
@@ -34,15 +35,15 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 
 		switch name {
 		case "CPU":
-			val = data.Info.Cpu
+			val = systemInfo.Cpu
 		case "Memory":
-			val = data.Info.MemPct
+			val = systemInfo.MemPct
 		case "Bandwidth":
-			val = data.Info.Bandwidth
+			val = systemInfo.Bandwidth
 			unit = " MB/s"
 		case "Disk":
-			maxUsedPct := data.Info.DiskPct
-			for _, fs := range data.Stats.ExtraFs {
+			maxUsedPct := systemInfo.DiskPct
+			for _, fs := range extraFs {
 				usedPct := fs.DiskUsed / fs.DiskTotal * 100
 				if usedPct > maxUsedPct {
 					maxUsedPct = usedPct
@@ -50,20 +51,15 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 			}
 			val = maxUsedPct
 		case "Temperature":
-			if data.Info.DashboardTemp < 1 {
+			if temperatures == nil {
 				continue
 			}
-			val = data.Info.DashboardTemp
+			for _, temp := range temperatures {
+				if temp > val {
+					val = temp
+				}
+			}
 			unit = "°C"
-		case "LoadAvg1":
-			val = data.Info.LoadAvg[0]
-			unit = ""
-		case "LoadAvg5":
-			val = data.Info.LoadAvg[1]
-			unit = ""
-		case "LoadAvg15":
-			val = data.Info.LoadAvg[2]
-			unit = ""
 		}
 
 		triggered := alertRecord.GetBool("triggered")
@@ -78,8 +74,13 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 		}
 
 		min := max(1, cast.ToUint8(alertRecord.Get("min")))
+		// add time to alert time to make sure it's slighty after record creation
+		time := now.Add(-time.Duration(min) * time.Minute)
+		if time.Before(oldestTime) {
+			oldestTime = time
+		}
 
-		alert := SystemAlertData{
+		validAlerts = append(validAlerts, SystemAlertData{
 			systemRecord: systemRecord,
 			alertRecord:  alertRecord,
 			name:         name,
@@ -87,22 +88,9 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 			val:          val,
 			threshold:    threshold,
 			triggered:    triggered,
+			time:         time,
 			min:          min,
-		}
-
-		// send alert immediately if min is 1 - no need to sum up values.
-		if min == 1 {
-			alert.triggered = val > threshold
-			go am.sendSystemAlert(alert)
-			continue
-		}
-
-		alert.time = now.Add(-time.Duration(min) * time.Minute)
-		if alert.time.Before(oldestTime) {
-			oldestTime = alert.time
-		}
-
-		validAlerts = append(validAlerts, alert)
+		})
 	}
 
 	systemStats := []struct {
@@ -110,7 +98,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 		Created types.DateTime `db:"created"`
 	}{}
 
-	err = am.hub.DB().
+	err = am.app.DB().
 		Select("stats", "created").
 		From("system_stats").
 		Where(dbx.NewExp(
@@ -123,7 +111,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 		)).
 		OrderBy("created").
 		All(&systemStats)
-	if err != nil || len(systemStats) == 0 {
+	if err != nil {
 		return err
 	}
 
@@ -131,14 +119,13 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 	oldestRecordTime := systemStats[0].Created.Time()
 	// log.Println("oldestRecordTime", oldestRecordTime.String())
 
-	// Filter validAlerts to keep only those with time newer than oldestRecord
-	filteredAlerts := make([]SystemAlertData, 0, len(validAlerts))
-	for _, alert := range validAlerts {
-		if alert.time.After(oldestRecordTime) {
-			filteredAlerts = append(filteredAlerts, alert)
+	// delete from validAlerts if time is older than oldestRecord
+	for i := range validAlerts {
+		if validAlerts[i].time.Before(oldestRecordTime) {
+			// log.Println("deleting alert - time is older than oldestRecord", validAlerts[i].name, oldestRecordTime, validAlerts[i].time)
+			validAlerts = slices.Delete(validAlerts, i, i+1)
 		}
 	}
-	validAlerts = filteredAlerts
 
 	if len(validAlerts) == 0 {
 		// log.Println("no valid alerts found")
@@ -176,7 +163,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 				alert.val += stats.NetSent + stats.NetRecv
 			case "Disk":
 				if alert.mapSums == nil {
-					alert.mapSums = make(map[string]float32, len(data.Stats.ExtraFs)+1)
+					alert.mapSums = make(map[string]float32, len(extraFs)+1)
 				}
 				// add root disk
 				if _, ok := alert.mapSums["root"]; !ok {
@@ -184,7 +171,7 @@ func (am *AlertManager) HandleSystemAlerts(systemRecord *core.Record, data *syst
 				}
 				alert.mapSums["root"] += float32(stats.Disk)
 				// add extra disks
-				for key, fs := range data.Stats.ExtraFs {
+				for key, fs := range extraFs {
 					if _, ok := alert.mapSums[key]; !ok {
 						alert.mapSums[key] = 0.0
 					}
@@ -200,12 +187,6 @@ 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]
-			case "LoadAvg15":
-				alert.val += stats.LoadAvg[2]
 			default:
 				continue
 			}
@@ -263,10 +244,6 @@ func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
 	if alert.name == "Disk" {
 		alert.name += " usage"
 	}
-	// format LoadAvg5 and LoadAvg15
-	if after, ok := strings.CutPrefix(alert.name, "LoadAvg"); ok {
-		alert.name = after + "m Load"
-	}
 
 	// make title alert name lowercase if not CPU
 	titleAlertName := alert.name
@@ -290,15 +267,22 @@ func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
 	body := fmt.Sprintf("%s averaged %.2f%s for the previous %v %s.", alert.descriptor, alert.val, alert.unit, alert.min, minutesLabel)
 
 	alert.alertRecord.Set("triggered", alert.triggered)
-	if err := am.hub.Save(alert.alertRecord); err != nil {
-		// app.Logger().Error("failed to save alert record", "err", err)
+	if err := am.app.Save(alert.alertRecord); err != nil {
+		// app.Logger().Error("failed to save alert record", "err", err.Error())
 		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.app.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.app.Settings().Meta.AppURL + "/system/" + url.PathEscape(systemName),
+			LinkText: "View " + systemName,
+		})
+	}
 }

beszel/internal/entities/container/container.go

@@ -0,0 +1,134 @@
+package container
+
+import "time"
+
+// Docker container info from /containers/json
+type ApiInfo struct {
+	Id      string
+	IdShort string
+	Names   []string
+	Status  string
+	// Image   string
+	// ImageID string
+	// Command string
+	// Created int64
+	// Ports      []Port
+	// 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"`
+	// }
+	// NetworkSettings *SummaryNetworkSettings
+	// Mounts          []MountPoint
+}
+
+// Docker container resources from /containers/{id}/stats
+type ApiStats struct {
+	// Common stats
+	// Read    time.Time `json:"read"`
+	// PreRead time.Time `json:"preread"`
+
+	// Linux specific stats, not populated on Windows.
+	// PidsStats  PidsStats  `json:"pids_stats,omitempty"`
+	// BlkioStats BlkioStats `json:"blkio_stats,omitempty"`
+
+	// Windows specific stats, not populated on Linux.
+	// NumProcs uint32 `json:"num_procs"`
+	// StorageStats StorageStats `json:"storage_stats,omitempty"`
+	// Networks request version >=1.21
+	Networks map[string]NetworkStats
+
+	// Shared stats
+	CPUStats CPUStats `json:"cpu_stats,omitempty"`
+	// PreCPUStats CPUStats    `json:"precpu_stats,omitempty"` // "Pre"="Previous"
+	MemoryStats MemoryStats `json:"memory_stats,omitempty"`
+}
+
+type CPUStats struct {
+	// CPU Usage. Linux and Windows.
+	CPUUsage CPUUsage `json:"cpu_usage"`
+
+	// System Usage. Linux only.
+	SystemUsage uint64 `json:"system_cpu_usage,omitempty"`
+
+	// Online CPUs. Linux only.
+	// OnlineCPUs uint32 `json:"online_cpus,omitempty"`
+
+	// Throttling Data. Linux only.
+	// ThrottlingData ThrottlingData `json:"throttling_data,omitempty"`
+}
+
+type CPUUsage struct {
+	// Total CPU time consumed.
+	// Units: nanoseconds (Linux)
+	// Units: 100's of nanoseconds (Windows)
+	TotalUsage uint64 `json:"total_usage"`
+
+	// Total CPU time consumed per core (Linux). Not used on Windows.
+	// Units: nanoseconds.
+	// PercpuUsage []uint64 `json:"percpu_usage,omitempty"`
+
+	// Time spent by tasks of the cgroup in kernel mode (Linux).
+	// Time spent by all container processes in kernel mode (Windows).
+	// Units: nanoseconds (Linux).
+	// Units: 100's of nanoseconds (Windows). Not populated for Hyper-V Containers.
+	// UsageInKernelmode uint64 `json:"usage_in_kernelmode"`
+
+	// Time spent by tasks of the cgroup in user mode (Linux).
+	// Time spent by all container processes in user mode (Windows).
+	// Units: nanoseconds (Linux).
+	// Units: 100's of nanoseconds (Windows). Not populated for Hyper-V Containers
+	// UsageInUsermode uint64 `json:"usage_in_usermode"`
+}
+
+type MemoryStats struct {
+	// current res_counter usage for memory
+	Usage uint64 `json:"usage,omitempty"`
+	// all the stats exported via memory.stat.
+	Stats MemoryStatsStats `json:"stats,omitempty"`
+	// maximum usage ever recorded.
+	// MaxUsage uint64 `json:"max_usage,omitempty"`
+	// TODO(vishh): Export these as stronger types.
+	// number of times memory usage hits limits.
+	// Failcnt uint64 `json:"failcnt,omitempty"`
+	// Limit   uint64 `json:"limit,omitempty"`
+
+	// // committed bytes
+	// Commit uint64 `json:"commitbytes,omitempty"`
+	// // peak committed bytes
+	// CommitPeak uint64 `json:"commitpeakbytes,omitempty"`
+	// // private working set
+	// PrivateWorkingSet uint64 `json:"privateworkingset,omitempty"`
+}
+
+type MemoryStatsStats struct {
+	Cache        uint64 `json:"cache,omitempty"`
+	InactiveFile uint64 `json:"inactive_file,omitempty"`
+}
+
+type NetworkStats struct {
+	// Bytes received. Windows and Linux.
+	RxBytes uint64 `json:"rx_bytes"`
+	// Bytes sent. Windows and Linux.
+	TxBytes uint64 `json:"tx_bytes"`
+}
+
+type prevNetStats struct {
+	Sent uint64
+	Recv uint64
+	Time time.Time
+}
+
+// Docker container stats
+type Stats struct {
+	Name        string       `json:"n"`
+	Cpu         float64      `json:"c"`
+	Mem         float64      `json:"m"`
+	NetworkSent float64      `json:"ns"`
+	NetworkRecv float64      `json:"nr"`
+	PrevCpu     [2]uint64    `json:"-"`
+	PrevNet     prevNetStats `json:"-"`
+}

beszel/internal/entities/system/system.go

@@ -0,0 +1,87 @@
+package system
+
+import (
+	"beszel/internal/entities/container"
+	"time"
+)
+
+type Stats struct {
+	Cpu            float64             `json:"cpu"`
+	MaxCpu         float64             `json:"cpum,omitempty"`
+	Mem            float64             `json:"m"`
+	MemUsed        float64             `json:"mu"`
+	MemPct         float64             `json:"mp"`
+	MemBuffCache   float64             `json:"mb"`
+	MemZfsArc      float64             `json:"mz,omitempty"` // ZFS ARC memory
+	Swap           float64             `json:"s,omitempty"`
+	SwapUsed       float64             `json:"su,omitempty"`
+	DiskTotal      float64             `json:"d"`
+	DiskUsed       float64             `json:"du"`
+	DiskPct        float64             `json:"dp"`
+	DiskReadPs     float64             `json:"dr"`
+	DiskWritePs    float64             `json:"dw"`
+	MaxDiskReadPs  float64             `json:"drm,omitempty"`
+	MaxDiskWritePs float64             `json:"dwm,omitempty"`
+	NetworkSent    float64             `json:"ns"`
+	NetworkRecv    float64             `json:"nr"`
+	MaxNetworkSent float64             `json:"nsm,omitempty"`
+	MaxNetworkRecv float64             `json:"nrm,omitempty"`
+	Temperatures   map[string]float64  `json:"t,omitempty"`
+	ExtraFs        map[string]*FsStats `json:"efs,omitempty"`
+	GPUData        map[string]GPUData  `json:"g,omitempty"`
+}
+
+type GPUData struct {
+	Name        string  `json:"n"`
+	Temperature float64 `json:"-"`
+	MemoryUsed  float64 `json:"mu,omitempty"`
+	MemoryTotal float64 `json:"mt,omitempty"`
+	Usage       float64 `json:"u"`
+	Power       float64 `json:"p,omitempty"`
+	Count       float64 `json:"-"`
+}
+
+type FsStats struct {
+	Time           time.Time `json:"-"`
+	Root           bool      `json:"-"`
+	Mountpoint     string    `json:"-"`
+	DiskTotal      float64   `json:"d"`
+	DiskUsed       float64   `json:"du"`
+	TotalRead      uint64    `json:"-"`
+	TotalWrite     uint64    `json:"-"`
+	DiskReadPs     float64   `json:"r"`
+	DiskWritePs    float64   `json:"w"`
+	MaxDiskReadPS  float64   `json:"rm,omitempty"`
+	MaxDiskWritePS float64   `json:"wm,omitempty"`
+}
+
+type NetIoStats struct {
+	BytesRecv uint64
+	BytesSent uint64
+	Time      time.Time
+	Name      string
+}
+
+type Info struct {
+	Hostname      string  `json:"h"`
+	KernelVersion string  `json:"k,omitempty"`
+	Cores         int     `json:"c"`
+	Threads       int     `json:"t,omitempty"`
+	CpuModel      string  `json:"m"`
+	Uptime        uint64  `json:"u"`
+	Cpu           float64 `json:"cpu"`
+	MemPct        float64 `json:"mp"`
+	DiskPct       float64 `json:"dp"`
+	Bandwidth     float64 `json:"b"`
+	AgentVersion  string  `json:"v"`
+	Podman        bool    `json:"p,omitempty"`
+	GpuPct        float64 `json:"g,omitempty"`
+	DashboardTemp float64 `json:"dt,omitempty"`
+}
+
+// Final data structure to return to the hub
+type CombinedData struct {
+	Stats      Stats              `json:"stats"`
+	Info       Info               `json:"info"`
+	Containers []*container.Stats `json:"container"`
+}

beszel/internal/hub/config.go

@@ -1,43 +1,40 @@
-// Package config provides functions for syncing systems with the config.yml file
-package config
+package hub
 
 import (
+	"beszel/internal/entities/system"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
-
-	"github.com/google/uuid"
-	"github.com/henrygd/beszel/internal/entities/system"
+	"strconv"
 
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/spf13/cast"
 	"gopkg.in/yaml.v3"
 )
 
-type config struct {
-	Systems []systemConfig `yaml:"systems"`
+type Config struct {
+	Systems []SystemConfig `yaml:"systems"`
 }
 
-type systemConfig struct {
+type SystemConfig struct {
 	Name  string   `yaml:"name"`
 	Host  string   `yaml:"host"`
-	Port  uint16   `yaml:"port,omitempty"`
-	Token string   `yaml:"token,omitempty"`
+	Port  uint16   `yaml:"port"`
 	Users []string `yaml:"users"`
 }
 
 // Syncs systems with the config.yml file
-func SyncSystems(e *core.ServeEvent) error {
-	h := e.App
+func (h *Hub) syncSystemsWithConfig() error {
 	configPath := filepath.Join(h.DataDir(), "config.yml")
 	configData, err := os.ReadFile(configPath)
 	if err != nil {
 		return nil
 	}
 
-	var config config
+	var config Config
 	err = yaml.Unmarshal(configData, &config)
 	if err != nil {
 		return fmt.Errorf("failed to parse config.yml: %v", err)
@@ -92,16 +89,16 @@ func SyncSystems(e *core.ServeEvent) error {
 		return err
 	}
 
-	// Create a map of existing systems
+	// Create a map of existing systems for easy lookup
 	existingSystemsMap := make(map[string]*core.Record)
 	for _, system := range existingSystems {
-		key := system.GetString("name") + system.GetString("host") + system.GetString("port")
+		key := system.GetString("host") + ":" + system.GetString("port")
 		existingSystemsMap[key] = system
 	}
 
 	// Process systems from config
 	for _, sysConfig := range config.Systems {
-		key := sysConfig.Name + sysConfig.Host + cast.ToString(sysConfig.Port)
+		key := sysConfig.Host + ":" + strconv.Itoa(int(sysConfig.Port))
 		if existingSystem, ok := existingSystemsMap[key]; ok {
 			// Update existing system
 			existingSystem.Set("name", sysConfig.Name)
@@ -110,14 +107,6 @@ func SyncSystems(e *core.ServeEvent) error {
 			if err := h.Save(existingSystem); err != nil {
 				return err
 			}
-
-			// Only update token if one is specified in config, otherwise preserve existing token
-			if sysConfig.Token != "" {
-				if err := updateFingerprintToken(h, existingSystem.Id, sysConfig.Token); err != nil {
-					return err
-				}
-			}
-
 			delete(existingSystemsMap, key)
 		} else {
 			// Create new system
@@ -135,21 +124,10 @@ func SyncSystems(e *core.ServeEvent) error {
 			if err := h.Save(newSystem); err != nil {
 				return fmt.Errorf("failed to create new system: %v", err)
 			}
-
-			// For new systems, generate token if not provided
-			token := sysConfig.Token
-			if token == "" {
-				token = uuid.New().String()
-			}
-
-			// Create fingerprint record for new system
-			if err := createFingerprintRecord(h, newSystem.Id, token); err != nil {
-				return err
-			}
 		}
 	}
 
-	// Delete systems not in config (and their fingerprint records will cascade delete)
+	// Delete systems not in config
 	for _, system := range existingSystemsMap {
 		if err := h.Delete(system); err != nil {
 			return err
@@ -161,7 +139,7 @@ func SyncSystems(e *core.ServeEvent) error {
 }
 
 // Generates content for the config.yml file as a YAML string
-func generateYAML(h core.App) (string, error) {
+func (h *Hub) generateConfigYAML() (string, error) {
 	// Fetch all systems from the database
 	systems, err := h.FindRecordsByFilter("systems", "id != ''", "name", -1, 0)
 	if err != nil {
@@ -169,8 +147,8 @@ func generateYAML(h core.App) (string, error) {
 	}
 
 	// Create a Config struct to hold the data
-	config := config{
-		Systems: make([]systemConfig, 0, len(systems)),
+	config := Config{
+		Systems: make([]SystemConfig, 0, len(systems)),
 	}
 
 	// Fetch all users at once
@@ -178,29 +156,11 @@ func generateYAML(h core.App) (string, error) {
 	for _, system := range systems {
 		allUserIDs = append(allUserIDs, system.GetStringSlice("users")...)
 	}
-	userEmailMap, err := getUserEmailMap(h, allUserIDs)
+	userEmailMap, err := h.getUserEmailMap(allUserIDs)
 	if err != nil {
 		return "", err
 	}
 
-	// Fetch all fingerprint records to get tokens
-	type fingerprintData struct {
-		ID     string `db:"id"`
-		System string `db:"system"`
-		Token  string `db:"token"`
-	}
-	var fingerprints []fingerprintData
-	err = h.DB().NewQuery("SELECT id, system, token FROM fingerprints").All(&fingerprints)
-	if err != nil {
-		return "", err
-	}
-
-	// Create a map of system ID to token
-	systemTokenMap := make(map[string]string)
-	for _, fingerprint := range fingerprints {
-		systemTokenMap[fingerprint.System] = fingerprint.Token
-	}
-
 	// Populate the Config struct with system data
 	for _, system := range systems {
 		userIDs := system.GetStringSlice("users")
@@ -211,12 +171,11 @@ func generateYAML(h core.App) (string, error) {
 			}
 		}
 
-		sysConfig := systemConfig{
+		sysConfig := SystemConfig{
 			Name:  system.GetString("name"),
 			Host:  system.GetString("host"),
 			Port:  cast.ToUint16(system.Get("port")),
 			Users: userEmails,
-			Token: systemTokenMap[system.Id],
 		}
 		config.Systems = append(config.Systems, sysConfig)
 	}
@@ -228,13 +187,13 @@ func generateYAML(h core.App) (string, error) {
 	}
 
 	// Add a header to the YAML
-	yamlData = append([]byte("# Values for port, users, and token are optional.\n# Defaults are port 45876, the first created user, and a generated UUID token.\n\n"), yamlData...)
+	yamlData = append([]byte("# Values for port and users are optional.\n# Defaults are port 45876 and the first created user.\n\n"), yamlData...)
 
 	return string(yamlData), nil
 }
 
 // New helper function to get a map of user IDs to emails
-func getUserEmailMap(h core.App, userIDs []string) (map[string]string, error) {
+func (h *Hub) getUserEmailMap(userIDs []string) (map[string]string, error) {
 	users, err := h.FindRecordsByIds("users", userIDs)
 	if err != nil {
 		return nil, err
@@ -248,41 +207,13 @@ func getUserEmailMap(h core.App, userIDs []string) (map[string]string, error) {
 	return userEmailMap, nil
 }
 
-// Helper function to update or create fingerprint token for an existing system
-func updateFingerprintToken(app core.App, systemID, token string) error {
-	// Try to find existing fingerprint record
-	fingerprint, err := app.FindFirstRecordByFilter("fingerprints", "system = {:system}", dbx.Params{"system": systemID})
-	if err != nil {
-		// If no fingerprint record exists, create one
-		return createFingerprintRecord(app, systemID, token)
-	}
-
-	// Update existing fingerprint record with new token (keep existing fingerprint)
-	fingerprint.Set("token", token)
-	return app.Save(fingerprint)
-}
-
-// Helper function to create a new fingerprint record for a system
-func createFingerprintRecord(app core.App, systemID, token string) error {
-	fingerprintsCollection, err := app.FindCollectionByNameOrId("fingerprints")
-	if err != nil {
-		return fmt.Errorf("failed to find fingerprints collection: %v", err)
-	}
-
-	newFingerprint := core.NewRecord(fingerprintsCollection)
-	newFingerprint.Set("system", systemID)
-	newFingerprint.Set("token", token)
-	newFingerprint.Set("fingerprint", "") // Empty fingerprint, will be set on first connection
-
-	return app.Save(newFingerprint)
-}
-
 // 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)
+func (h *Hub) getYamlConfig(e *core.RequestEvent) error {
+	info, _ := e.RequestInfo()
+	if info.Auth == nil || info.Auth.GetString("role") != "admin" {
+		return apis.NewForbiddenError("Forbidden", nil)
 	}
-	configContent, err := generateYAML(e.App)
+	configContent, err := h.generateConfigYAML()
 	if err != nil {
 		return err
 	}

beszel/internal/hub/hub.go

@@ -0,0 +1,584 @@
+// Package hub handles updating systems and serving the web UI.
+package hub
+
+import (
+	"beszel"
+	"beszel/internal/alerts"
+	"beszel/internal/entities/system"
+	"beszel/internal/records"
+	"beszel/internal/users"
+	"beszel/site"
+	"context"
+	"crypto/ed25519"
+	"encoding/pem"
+	"fmt"
+	"io/fs"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/goccy/go-json"
+	"github.com/pocketbase/pocketbase"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/plugins/migratecmd"
+	"github.com/spf13/cobra"
+	"golang.org/x/crypto/ssh"
+)
+
+type Hub struct {
+	*pocketbase.PocketBase
+	sshClientConfig *ssh.ClientConfig
+	pubKey          string
+	am              *alerts.AlertManager
+	um              *users.UserManager
+	rm              *records.RecordManager
+	systemStats     *core.Collection
+	containerStats  *core.Collection
+	appURL          string
+}
+
+// NewHub creates a new Hub instance with default configuration
+func NewHub() *Hub {
+	var hub Hub
+	hub.PocketBase = pocketbase.NewWithConfig(pocketbase.Config{
+		DefaultDataDir: beszel.AppName + "_data",
+	})
+
+	hub.RootCmd.Version = beszel.Version
+	hub.RootCmd.Use = beszel.AppName
+	hub.RootCmd.Short = ""
+	// add update command
+	hub.RootCmd.AddCommand(&cobra.Command{
+		Use:   "update",
+		Short: "Update " + beszel.AppName + " to the latest version",
+		Run:   Update,
+	})
+
+	hub.am = alerts.NewAlertManager(hub)
+	hub.um = users.NewUserManager(hub)
+	hub.rm = records.NewRecordManager(hub)
+	hub.appURL, _ = GetEnv("APP_URL")
+	return &hub
+}
+
+// GetEnv retrieves an environment variable with a "BESZEL_HUB_" prefix, or falls back to the unprefixed key.
+func GetEnv(key string) (value string, exists bool) {
+	if value, exists = os.LookupEnv("BESZEL_HUB_" + key); exists {
+		return value, exists
+	}
+	// Fallback to the old unprefixed key
+	return os.LookupEnv(key)
+}
+
+func (h *Hub) Run() {
+	isDev := os.Getenv("ENV") == "dev"
+
+	// enable auto creation of migration files when making collection changes in the Admin UI
+	migratecmd.MustRegister(h, h.RootCmd, migratecmd.Config{
+		// (the isDev check is to enable it only during development)
+		Automigrate: isDev,
+		Dir:         "../../migrations",
+	})
+
+	// initial setup
+	h.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		// create ssh client config
+		err := h.createSSHClientConfig()
+		if err != nil {
+			log.Fatal(err)
+		}
+		// set general settings
+		settings := h.Settings()
+		// batch requests (for global alerts)
+		settings.Batch.Enabled = true
+		// set URL if BASE_URL env is set
+		if h.appURL != "" {
+			settings.Meta.AppURL = h.appURL
+		}
+		// set auth settings
+		usersCollection, err := h.FindCollectionByNameOrId("users")
+		if err != nil {
+			return err
+		}
+		// disable email auth if DISABLE_PASSWORD_AUTH env var is set
+		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'"
+			usersCollection.CreateRule = &cr
+		} else {
+			usersCollection.CreateRule = nil
+		}
+		if err := h.Save(usersCollection); err != nil {
+			return err
+		}
+		// sync systems with config
+		h.syncSystemsWithConfig()
+		return se.Next()
+	})
+
+	// serve web ui
+	h.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		switch 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)
+			// 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 se.Next()
+	})
+
+	// set up scheduled jobs / ticker for system updates
+	h.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		// 15 second ticker for system updates
+		go h.startSystemUpdateTicker()
+		// set up cron jobs
+		// 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 * * * *", func() {
+			if systemStats, containerStats, err := h.getCollections(); err == nil {
+				h.rm.CreateLongerRecords([]*core.Collection{systemStats, containerStats})
+			}
+		})
+		return se.Next()
+	})
+
+	// custom api routes
+	h.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		// returns public key
+		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
+		se.Router.GET("/api/beszel/send-test-notification", h.am.SendTestNotification)
+		// API endpoint to get config.yml content
+		se.Router.GET("/api/beszel/config-yaml", h.getYamlConfig)
+		// 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 se.Next()
+	})
+
+	// system creation defaults
+	h.OnRecordCreate("systems").BindFunc(func(e *core.RecordEvent) error {
+		e.Record.Set("info", system.Info{})
+		e.Record.Set("status", "pending")
+		return e.Next()
+	})
+
+	// immediately create connection for new systems
+	h.OnRecordAfterCreateSuccess("systems").BindFunc(func(e *core.RecordEvent) error {
+		go h.updateSystem(e.Record)
+		return e.Next()
+	})
+
+	// handle default values for user / user_settings creation
+	h.OnRecordCreate("users").BindFunc(h.um.InitializeUserRole)
+	h.OnRecordCreate("user_settings").BindFunc(h.um.InitializeUserSettings)
+
+	// empty info for systems that are paused
+	h.OnRecordUpdate("systems").BindFunc(func(e *core.RecordEvent) error {
+		if e.Record.GetString("status") == "paused" {
+			e.Record.Set("info", system.Info{})
+		}
+		return e.Next()
+	})
+
+	// do things after a systems record is updated
+	h.OnRecordAfterUpdateSuccess("systems").BindFunc(func(e *core.RecordEvent) error {
+		newRecord := e.Record.Fresh()
+		oldRecord := newRecord.Original()
+		newStatus := newRecord.GetString("status")
+
+		// if system is not up and connection exists, remove it
+		if newStatus != "up" {
+			h.deleteSystemConnection(newRecord)
+		}
+
+		// if system is set to pending (unpause), try to connect immediately
+		if newStatus == "pending" {
+			go h.updateSystem(newRecord)
+		} else {
+			h.am.HandleStatusAlerts(newStatus, oldRecord)
+		}
+		return e.Next()
+	})
+
+	// if system is deleted, close connection
+	h.OnRecordAfterDeleteSuccess("systems").BindFunc(func(e *core.RecordEvent) error {
+		h.deleteSystemConnection(e.Record)
+		return e.Next()
+	})
+
+	if err := h.Start(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func (h *Hub) startSystemUpdateTicker() {
+	c := time.Tick(15 * time.Second)
+	for range c {
+		h.updateSystems()
+	}
+}
+
+func (h *Hub) updateSystems() {
+	records, err := h.FindRecordsByFilter(
+		"2hz5ncl8tizk5nx",    // systems collection
+		"status != 'paused'", // filter
+		"updated",            // sort
+		-1,                   // limit
+		0,                    // offset
+	)
+	// log.Println("records", len(records))
+	if err != nil || len(records) == 0 {
+		// h.Logger().Error("Failed to query systems")
+		return
+	}
+	fiftySecondsAgo := time.Now().UTC().Add(-50 * time.Second)
+	batchSize := len(records)/4 + 1
+	done := 0
+	for _, record := range records {
+		// break if batch size reached or if the system was updated less than 50 seconds ago
+		if done >= batchSize || record.GetDateTime("updated").Time().After(fiftySecondsAgo) {
+			break
+		}
+		// don't increment for down systems to avoid them jamming the queue
+		// because they're always first when sorted by least recently updated
+		if record.GetString("status") != "down" {
+			done++
+		}
+		go h.updateSystem(record)
+	}
+}
+
+func (h *Hub) updateSystem(record *core.Record) {
+	var client *ssh.Client
+	var err error
+
+	// check if system connection exists
+	if existingClient, ok := h.Store().GetOk(record.Id); ok {
+		client = existingClient.(*ssh.Client)
+	} else {
+		// create system connection
+		client, err = h.createSystemConnection(record)
+		if err != nil {
+			if record.GetString("status") != "down" {
+				h.Logger().Error("Failed to connect:", "err", err.Error(), "system", record.GetString("host"), "port", record.GetString("port"))
+				h.updateSystemStatus(record, "down")
+			}
+			return
+		}
+		h.Store().Set(record.Id, client)
+	}
+	// get system stats from agent
+	var systemData system.CombinedData
+	if err := h.requestJsonFromAgent(client, &systemData); err != nil {
+		if err.Error() == "bad client" {
+			// if previous connection was closed, try again
+			h.Logger().Error("Existing SSH connection closed. Retrying...", "host", record.GetString("host"), "port", record.GetString("port"))
+			h.deleteSystemConnection(record)
+			time.Sleep(time.Millisecond * 100)
+			h.updateSystem(record)
+			return
+		}
+		h.Logger().Error("Failed to get system stats: ", "err", err.Error())
+		h.updateSystemStatus(record, "down")
+		return
+	}
+	// update system record
+	record.Set("status", "up")
+	record.Set("info", systemData.Info)
+	if err := h.SaveNoValidate(record); err != nil {
+		h.Logger().Error("Failed to update record: ", "err", err.Error())
+	}
+	// add system_stats and container_stats records
+	if systemStats, containerStats, err := h.getCollections(); err != nil {
+		h.Logger().Error("Failed to get collections: ", "err", err.Error())
+	} else {
+		// add new system_stats record
+		systemStatsRecord := core.NewRecord(systemStats)
+		systemStatsRecord.Set("system", record.Id)
+		systemStatsRecord.Set("stats", systemData.Stats)
+		systemStatsRecord.Set("type", "1m")
+		if err := h.SaveNoValidate(systemStatsRecord); err != nil {
+			h.Logger().Error("Failed to save record: ", "err", err.Error())
+		}
+		// add new container_stats record
+		if len(systemData.Containers) > 0 {
+			containerStatsRecord := core.NewRecord(containerStats)
+			containerStatsRecord.Set("system", record.Id)
+			containerStatsRecord.Set("stats", systemData.Containers)
+			containerStatsRecord.Set("type", "1m")
+			if err := h.SaveNoValidate(containerStatsRecord); err != nil {
+				h.Logger().Error("Failed to save record: ", "err", err.Error())
+			}
+		}
+	}
+
+	// system info alerts
+	if err := h.am.HandleSystemAlerts(record, systemData.Info, systemData.Stats.Temperatures, systemData.Stats.ExtraFs); err != nil {
+		h.Logger().Error("System alerts error", "err", err.Error())
+	}
+}
+
+// return system_stats and container_stats collections
+func (h *Hub) getCollections() (*core.Collection, *core.Collection, error) {
+	if h.systemStats == nil {
+		systemStats, err := h.FindCollectionByNameOrId("system_stats")
+		if err != nil {
+			return nil, nil, err
+		}
+		h.systemStats = systemStats
+	}
+	if h.containerStats == nil {
+		containerStats, err := h.FindCollectionByNameOrId("container_stats")
+		if err != nil {
+			return nil, nil, err
+		}
+		h.containerStats = containerStats
+	}
+	return h.systemStats, h.containerStats, nil
+}
+
+// set system to specified status and save record
+func (h *Hub) updateSystemStatus(record *core.Record, status string) {
+	if record.Fresh().GetString("status") != status {
+		record.Set("status", status)
+		if err := h.SaveNoValidate(record); err != nil {
+			h.Logger().Error("Failed to update record: ", "err", err.Error())
+		}
+	}
+}
+
+// delete system connection from map and close connection
+func (h *Hub) deleteSystemConnection(record *core.Record) {
+	if client, ok := h.Store().GetOk(record.Id); ok {
+		if sshClient := client.(*ssh.Client); sshClient != nil {
+			sshClient.Close()
+		}
+		h.Store().Remove(record.Id)
+	}
+}
+
+func (h *Hub) createSystemConnection(record *core.Record) (*ssh.Client, error) {
+	network := "tcp"
+	host := record.GetString("host")
+	if strings.HasPrefix(host, "/") {
+		network = "unix"
+	} else {
+		host = net.JoinHostPort(host, record.GetString("port"))
+	}
+	client, err := ssh.Dial(network, host, h.sshClientConfig)
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+func (h *Hub) createSSHClientConfig() error {
+	key, err := h.getSSHKey()
+	if err != nil {
+		h.Logger().Error("Failed to get SSH key: ", "err", err.Error())
+		return err
+	}
+
+	// Create the Signer for this private key.
+	signer, err := ssh.ParsePrivateKey(key)
+	if err != nil {
+		return err
+	}
+
+	h.sshClientConfig = &ssh.ClientConfig{
+		User: "u",
+		Auth: []ssh.AuthMethod{
+			ssh.PublicKeys(signer),
+		},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+		Timeout:         4 * time.Second,
+	}
+	return nil
+}
+
+// Fetches system stats from the agent and decodes the json data into the provided struct
+func (h *Hub) requestJsonFromAgent(client *ssh.Client, systemData *system.CombinedData) error {
+	session, err := newSessionWithTimeout(client, 4*time.Second)
+	if err != nil {
+		return fmt.Errorf("bad client")
+	}
+	defer session.Close()
+
+	stdout, err := session.StdoutPipe()
+	if err != nil {
+		return err
+	}
+
+	if err := session.Shell(); err != nil {
+		return err
+	}
+
+	if err := json.NewDecoder(stdout).Decode(systemData); err != nil {
+		return err
+	}
+
+	// wait for the session to complete
+	if err := session.Wait(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Adds timeout to SSH session creation to avoid hanging in case of network issues
+func newSessionWithTimeout(client *ssh.Client, timeout time.Duration) (*ssh.Session, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	// use goroutine to create the session
+	sessionChan := make(chan *ssh.Session, 1)
+	errChan := make(chan error, 1)
+	go func() {
+		if session, err := client.NewSession(); err != nil {
+			errChan <- err
+		} else {
+			sessionChan <- session
+		}
+	}()
+
+	select {
+	case session := <-sessionChan:
+		return session, nil
+	case err := <-errChan:
+		return nil, err
+	case <-ctx.Done():
+		return nil, fmt.Errorf("session creation timed out")
+	}
+}
+
+func (h *Hub) getSSHKey() ([]byte, error) {
+	dataDir := h.DataDir()
+	// check if the key pair already exists
+	existingKey, err := os.ReadFile(dataDir + "/id_ed25519")
+	if err == nil {
+		if pubKey, err := os.ReadFile(h.DataDir() + "/id_ed25519.pub"); err == nil {
+			h.pubKey = strings.TrimSuffix(string(pubKey), "\n")
+		}
+		// return existing private key
+		return existingKey, nil
+	}
+
+	// Generate the Ed25519 key pair
+	pubKey, privKey, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		// h.Logger().Error("Error generating key pair:", "err", err.Error())
+		return nil, err
+	}
+
+	// Get the private key in OpenSSH format
+	privKeyBytes, err := ssh.MarshalPrivateKey(privKey, "")
+	if err != nil {
+		// h.Logger().Error("Error marshaling private key:", "err", err.Error())
+		return nil, err
+	}
+
+	// Save the private key to a file
+	privateFile, err := os.Create(dataDir + "/id_ed25519")
+	if err != nil {
+		// h.Logger().Error("Error creating private key file:", "err", err.Error())
+		return nil, err
+	}
+	defer privateFile.Close()
+
+	if err := pem.Encode(privateFile, privKeyBytes); err != nil {
+		// h.Logger().Error("Error writing private key to file:", "err", err.Error())
+		return nil, err
+	}
+
+	// Generate the public key in OpenSSH format
+	publicKey, err := ssh.NewPublicKey(pubKey)
+	if err != nil {
+		return nil, err
+	}
+
+	pubKeyBytes := ssh.MarshalAuthorizedKey(publicKey)
+	h.pubKey = strings.TrimSuffix(string(pubKeyBytes), "\n")
+
+	// Save the public key to a file
+	publicFile, err := os.Create(dataDir + "/id_ed25519.pub")
+	if err != nil {
+		return nil, err
+	}
+	defer publicFile.Close()
+
+	if _, err := publicFile.Write(pubKeyBytes); err != nil {
+		return nil, err
+	}
+
+	h.Logger().Info("ed25519 SSH key pair generated successfully.")
+	h.Logger().Info("Private key saved to: " + dataDir + "/id_ed25519")
+	h.Logger().Info("Public key saved to: " + dataDir + "/id_ed25519.pub")
+
+	existingKey, err = os.ReadFile(dataDir + "/id_ed25519")
+	if err == nil {
+		return existingKey, nil
+	}
+	return nil, err
+}

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/records/records.go

@@ -0,0 +1,372 @@
+// Package records handles creating longer records and deleting old records.
+package records
+
+import (
+	"beszel/internal/entities/container"
+	"beszel/internal/entities/system"
+	"log"
+	"math"
+	"time"
+
+	"github.com/goccy/go-json"
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/types"
+)
+
+type RecordManager struct {
+	app core.App
+}
+
+type LongerRecordData struct {
+	shorterType        string
+	longerType         string
+	longerTimeDuration time.Duration
+	minShorterRecords  int
+}
+
+type RecordDeletionData struct {
+	recordType string
+	retention  time.Duration
+}
+
+type RecordStats []struct {
+	Stats []byte `db:"stats"`
+}
+
+func NewRecordManager(app core.App) *RecordManager {
+	return &RecordManager{app}
+}
+
+// Create longer records by averaging shorter records
+func (rm *RecordManager) CreateLongerRecords(collections []*core.Collection) {
+	// start := time.Now()
+	longerRecordData := []LongerRecordData{
+		{
+			shorterType: "1m",
+			// change to 9 from 10 to allow edge case timing or short pauses
+			minShorterRecords:  9,
+			longerType:         "10m",
+			longerTimeDuration: -10 * time.Minute,
+		},
+		{
+			shorterType:        "10m",
+			minShorterRecords:  2,
+			longerType:         "20m",
+			longerTimeDuration: -20 * time.Minute,
+		},
+		{
+			shorterType:        "20m",
+			minShorterRecords:  6,
+			longerType:         "120m",
+			longerTimeDuration: -120 * time.Minute,
+		},
+		{
+			shorterType:        "120m",
+			minShorterRecords:  4,
+			longerType:         "480m",
+			longerTimeDuration: -480 * time.Minute,
+		},
+	}
+	// wrap the operations in a transaction
+	rm.app.RunInTransaction(func(txApp core.App) error {
+		activeSystems, err := txApp.FindAllRecords("systems", dbx.NewExp("status = 'up'"))
+		if err != nil {
+			log.Println("failed to get active systems", "err", err.Error())
+			return err
+		}
+
+		// loop through all active systems, time periods, and collections
+		for _, system := range activeSystems {
+			// log.Println("processing system", system.GetString("name"))
+			for i := range longerRecordData {
+				recordData := longerRecordData[i]
+				// log.Println("processing longer record type", recordData.longerType)
+				// add one minute padding for longer records because they are created slightly later than the job start time
+				longerRecordPeriod := time.Now().UTC().Add(recordData.longerTimeDuration + time.Minute)
+				// shorter records are created independently of longer records, so we shouldn't need to add padding
+				shorterRecordPeriod := time.Now().UTC().Add(recordData.longerTimeDuration)
+				// loop through both collections
+				for _, collection := range collections {
+					// check creation time of last longer record if not 10m, since 10m is created every run
+					if recordData.longerType != "10m" {
+						lastLongerRecord, err := txApp.FindFirstRecordByFilter(
+							collection.Id,
+							"type = {:type} && system = {:system} && created > {:created}",
+							dbx.Params{"type": recordData.longerType, "system": system.Id, "created": longerRecordPeriod},
+						)
+						// continue if longer record exists
+						if err == nil || lastLongerRecord != nil {
+							// log.Println("longer record found. continuing")
+							continue
+						}
+					}
+					// get shorter records from the past x minutes
+					var stats RecordStats
+
+					err := txApp.DB().
+						Select("stats").
+						From(collection.Name).
+						AndWhere(dbx.NewExp(
+							"type={:type} AND system={:system} AND created > {:created}",
+							dbx.Params{
+								"type":    recordData.shorterType,
+								"system":  system.Id,
+								"created": shorterRecordPeriod,
+							},
+						)).
+						All(&stats)
+
+					// continue if not enough shorter records
+					if err != nil || len(stats) < recordData.minShorterRecords {
+						// log.Println("not enough shorter records. continue.", len(allShorterRecords), recordData.expectedShorterRecords)
+						continue
+					}
+					// average the shorter records and create longer record
+					longerRecord := core.NewRecord(collection)
+					longerRecord.Set("system", system.Id)
+					longerRecord.Set("type", recordData.longerType)
+					switch collection.Name {
+					case "system_stats":
+						longerRecord.Set("stats", rm.AverageSystemStats(stats))
+					case "container_stats":
+						longerRecord.Set("stats", rm.AverageContainerStats(stats))
+					}
+					if err := txApp.SaveNoValidate(longerRecord); err != nil {
+						log.Println("failed to save longer record", "err", err.Error())
+					}
+				}
+			}
+		}
+
+		return nil
+	})
+
+	// log.Println("finished creating longer records", "time (ms)", time.Since(start).Milliseconds())
+}
+
+// Calculate the average stats of a list of system_stats records without reflect
+func (rm *RecordManager) AverageSystemStats(records RecordStats) system.Stats {
+	sum := system.Stats{}
+	count := float64(len(records))
+	// use different counter for temps in case some records don't have them
+	tempCount := float64(0)
+
+	var stats system.Stats
+	for i := range records {
+		stats = system.Stats{} // Zero the struct before unmarshalling
+		json.Unmarshal(records[i].Stats, &stats)
+		sum.Cpu += stats.Cpu
+		sum.Mem += stats.Mem
+		sum.MemUsed += stats.MemUsed
+		sum.MemPct += stats.MemPct
+		sum.MemBuffCache += stats.MemBuffCache
+		sum.MemZfsArc += stats.MemZfsArc
+		sum.Swap += stats.Swap
+		sum.SwapUsed += stats.SwapUsed
+		sum.DiskTotal += stats.DiskTotal
+		sum.DiskUsed += stats.DiskUsed
+		sum.DiskPct += stats.DiskPct
+		sum.DiskReadPs += stats.DiskReadPs
+		sum.DiskWritePs += stats.DiskWritePs
+		sum.NetworkSent += stats.NetworkSent
+		sum.NetworkRecv += stats.NetworkRecv
+		// set peak values
+		sum.MaxCpu = max(sum.MaxCpu, stats.MaxCpu, stats.Cpu)
+		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)
+		// add temps to sum
+		if stats.Temperatures != nil {
+			if sum.Temperatures == nil {
+				sum.Temperatures = make(map[string]float64, len(stats.Temperatures))
+			}
+			tempCount++
+			for key, value := range stats.Temperatures {
+				if _, ok := sum.Temperatures[key]; !ok {
+					sum.Temperatures[key] = 0
+				}
+				sum.Temperatures[key] += value
+			}
+		}
+		// add extra fs to sum
+		if stats.ExtraFs != nil {
+			if sum.ExtraFs == nil {
+				sum.ExtraFs = make(map[string]*system.FsStats, len(stats.ExtraFs))
+			}
+			for key, value := range stats.ExtraFs {
+				if _, ok := sum.ExtraFs[key]; !ok {
+					sum.ExtraFs[key] = &system.FsStats{}
+				}
+				sum.ExtraFs[key].DiskTotal += value.DiskTotal
+				sum.ExtraFs[key].DiskUsed += value.DiskUsed
+				sum.ExtraFs[key].DiskWritePs += value.DiskWritePs
+				sum.ExtraFs[key].DiskReadPs += value.DiskReadPs
+				// peak values
+				sum.ExtraFs[key].MaxDiskReadPS = max(sum.ExtraFs[key].MaxDiskReadPS, value.MaxDiskReadPS, value.DiskReadPs)
+				sum.ExtraFs[key].MaxDiskWritePS = max(sum.ExtraFs[key].MaxDiskWritePS, value.MaxDiskWritePS, value.DiskWritePs)
+			}
+		}
+		// add GPU data
+		if stats.GPUData != nil {
+			if sum.GPUData == nil {
+				sum.GPUData = make(map[string]system.GPUData, len(stats.GPUData))
+			}
+			for id, value := range stats.GPUData {
+				if _, ok := sum.GPUData[id]; !ok {
+					sum.GPUData[id] = system.GPUData{Name: value.Name}
+				}
+				gpu := sum.GPUData[id]
+				gpu.Temperature += value.Temperature
+				gpu.MemoryUsed += value.MemoryUsed
+				gpu.MemoryTotal += value.MemoryTotal
+				gpu.Usage += value.Usage
+				gpu.Power += value.Power
+				gpu.Count += value.Count
+				sum.GPUData[id] = gpu
+			}
+		}
+	}
+
+	stats = system.Stats{
+		Cpu:            twoDecimals(sum.Cpu / count),
+		Mem:            twoDecimals(sum.Mem / count),
+		MemUsed:        twoDecimals(sum.MemUsed / count),
+		MemPct:         twoDecimals(sum.MemPct / count),
+		MemBuffCache:   twoDecimals(sum.MemBuffCache / count),
+		MemZfsArc:      twoDecimals(sum.MemZfsArc / count),
+		Swap:           twoDecimals(sum.Swap / count),
+		SwapUsed:       twoDecimals(sum.SwapUsed / count),
+		DiskTotal:      twoDecimals(sum.DiskTotal / count),
+		DiskUsed:       twoDecimals(sum.DiskUsed / count),
+		DiskPct:        twoDecimals(sum.DiskPct / count),
+		DiskReadPs:     twoDecimals(sum.DiskReadPs / count),
+		DiskWritePs:    twoDecimals(sum.DiskWritePs / count),
+		NetworkSent:    twoDecimals(sum.NetworkSent / count),
+		NetworkRecv:    twoDecimals(sum.NetworkRecv / count),
+		MaxCpu:         sum.MaxCpu,
+		MaxDiskReadPs:  sum.MaxDiskReadPs,
+		MaxDiskWritePs: sum.MaxDiskWritePs,
+		MaxNetworkSent: sum.MaxNetworkSent,
+		MaxNetworkRecv: sum.MaxNetworkRecv,
+	}
+
+	if sum.Temperatures != nil {
+		stats.Temperatures = make(map[string]float64, len(sum.Temperatures))
+		for key, value := range sum.Temperatures {
+			stats.Temperatures[key] = twoDecimals(value / tempCount)
+		}
+	}
+
+	if sum.ExtraFs != nil {
+		stats.ExtraFs = make(map[string]*system.FsStats, len(sum.ExtraFs))
+		for key, value := range sum.ExtraFs {
+			stats.ExtraFs[key] = &system.FsStats{
+				DiskTotal:      twoDecimals(value.DiskTotal / count),
+				DiskUsed:       twoDecimals(value.DiskUsed / count),
+				DiskWritePs:    twoDecimals(value.DiskWritePs / count),
+				DiskReadPs:     twoDecimals(value.DiskReadPs / count),
+				MaxDiskReadPS:  value.MaxDiskReadPS,
+				MaxDiskWritePS: value.MaxDiskWritePS,
+			}
+		}
+	}
+
+	if sum.GPUData != nil {
+		stats.GPUData = make(map[string]system.GPUData, len(sum.GPUData))
+		for id, value := range sum.GPUData {
+			stats.GPUData[id] = system.GPUData{
+				Name:        value.Name,
+				Temperature: twoDecimals(value.Temperature / count),
+				MemoryUsed:  twoDecimals(value.MemoryUsed / count),
+				MemoryTotal: twoDecimals(value.MemoryTotal / count),
+				Usage:       twoDecimals(value.Usage / count),
+				Power:       twoDecimals(value.Power / count),
+				Count:       twoDecimals(value.Count / count),
+			}
+		}
+	}
+
+	return stats
+}
+
+// Calculate the average stats of a list of container_stats records
+func (rm *RecordManager) AverageContainerStats(records RecordStats) []container.Stats {
+	sums := make(map[string]*container.Stats)
+	count := float64(len(records))
+
+	var containerStats []container.Stats
+	for i := range records {
+		// Reset the slice length to 0, but keep the capacity
+		containerStats = containerStats[:0]
+		if err := json.Unmarshal(records[i].Stats, &containerStats); err != nil {
+			return []container.Stats{}
+		}
+		for i := range containerStats {
+			stat := containerStats[i]
+			if _, ok := sums[stat.Name]; !ok {
+				sums[stat.Name] = &container.Stats{Name: stat.Name}
+			}
+			sums[stat.Name].Cpu += stat.Cpu
+			sums[stat.Name].Mem += stat.Mem
+			sums[stat.Name].NetworkSent += stat.NetworkSent
+			sums[stat.Name].NetworkRecv += stat.NetworkRecv
+		}
+	}
+
+	result := make([]container.Stats, 0, len(sums))
+	for _, value := range sums {
+		result = append(result, container.Stats{
+			Name:        value.Name,
+			Cpu:         twoDecimals(value.Cpu / count),
+			Mem:         twoDecimals(value.Mem / count),
+			NetworkSent: twoDecimals(value.NetworkSent / count),
+			NetworkRecv: twoDecimals(value.NetworkRecv / count),
+		})
+	}
+	return result
+}
+
+// Deletes records older than what is displayed in the UI
+func (rm *RecordManager) DeleteOldRecords() {
+	collections := []string{"system_stats", "container_stats"}
+	recordData := []RecordDeletionData{
+		{
+			recordType: "1m",
+			retention:  time.Hour,
+		},
+		{
+			recordType: "10m",
+			retention:  12 * time.Hour,
+		},
+		{
+			recordType: "20m",
+			retention:  24 * time.Hour,
+		},
+		{
+			recordType: "120m",
+			retention:  7 * 24 * time.Hour,
+		},
+		{
+			recordType: "480m",
+			retention:  30 * 24 * time.Hour,
+		},
+	}
+	db := rm.app.NonconcurrentDB()
+	for _, recordData := range recordData {
+		for _, collectionSlug := range collections {
+			formattedDate := time.Now().UTC().Add(-recordData.retention).Format(types.DefaultDateLayout)
+			expr := dbx.NewExp("[[created]] < {:date} AND [[type]] = {:type}", dbx.Params{"date": formattedDate, "type": recordData.recordType})
+			_, err := db.Delete(collectionSlug, expr).Execute()
+			if err != nil {
+				rm.app.Logger().Error("Failed to delete records", "err", err.Error())
+			}
+		}
+	}
+}
+
+/* Round float to two decimals */
+func twoDecimals(value float64) float64 {
+	return math.Round(value*100) / 100
+}

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,13 @@ type UserManager struct {
 	app core.App
 }
 
+type UserSettings struct {
+	ChartTime            string   `json:"chartTime"`
+	NotificationEmails   []string `json:"emails"`
+	NotificationWebhooks []string `json:"webhooks"`
+	// Language             string   `json:"lang"`
+}
+
 func NewUserManager(app core.App) *UserManager {
 	return &UserManager{
 		app: app,
@@ -32,26 +37,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/1738624382_updated_users.go

@@ -0,0 +1,98 @@
+package migrations
+
+import (
+	"encoding/json"
+
+	"github.com/pocketbase/pocketbase/core"
+	m "github.com/pocketbase/pocketbase/migrations"
+)
+
+func init() {
+	m.Register(func(app core.App) error {
+		collection, err := app.FindCollectionByNameOrId("_pb_users_auth_")
+		if err != nil {
+			return err
+		}
+
+		// update collection data
+		if err := json.Unmarshal([]byte(`{
+			"indexes": [
+				"CREATE UNIQUE INDEX ` + "`" + `__pb_users_auth__email_idx` + "`" + ` ON ` + "`" + `users` + "`" + ` (` + "`" + `email` + "`" + `) WHERE ` + "`" + `email` + "`" + ` != ''",
+				"CREATE UNIQUE INDEX ` + "`" + `__pb_users_auth__tokenKey_idx` + "`" + ` ON ` + "`" + `users` + "`" + ` (` + "`" + `tokenKey` + "`" + `)"
+			]
+		}`), &collection); err != nil {
+			return err
+		}
+
+		// remove field
+		collection.Fields.RemoveById("text4166911607")
+
+		// update field
+		if err := collection.Fields.AddMarshaledJSONAt(3, []byte(`{
+			"exceptDomains": null,
+			"hidden": false,
+			"id": "email3885137012",
+			"name": "email",
+			"onlyDomains": null,
+			"presentable": false,
+			"required": true,
+			"system": true,
+			"type": "email"
+		}`)); err != nil {
+			return err
+		}
+
+		return app.Save(collection)
+	}, func(app core.App) error {
+		collection, err := app.FindCollectionByNameOrId("_pb_users_auth_")
+		if err != nil {
+			return err
+		}
+
+		// update collection data
+		if err := json.Unmarshal([]byte(`{
+			"indexes": [
+				"CREATE UNIQUE INDEX ` + "`" + `__pb_users_auth__username_idx` + "`" + ` ON ` + "`" + `users` + "`" + ` (username COLLATE NOCASE)",
+				"CREATE UNIQUE INDEX ` + "`" + `__pb_users_auth__email_idx` + "`" + ` ON ` + "`" + `users` + "`" + ` (` + "`" + `email` + "`" + `) WHERE ` + "`" + `email` + "`" + ` != ''",
+				"CREATE UNIQUE INDEX ` + "`" + `__pb_users_auth__tokenKey_idx` + "`" + ` ON ` + "`" + `users` + "`" + ` (` + "`" + `tokenKey` + "`" + `)"
+			]
+		}`), &collection); err != nil {
+			return err
+		}
+
+		// add field
+		if err := collection.Fields.AddMarshaledJSONAt(6, []byte(`{
+			"autogeneratePattern": "users[0-9]{6}",
+			"hidden": false,
+			"id": "text4166911607",
+			"max": 150,
+			"min": 3,
+			"name": "username",
+			"pattern": "^[\\w][\\w\\.\\-]*$",
+			"presentable": false,
+			"primaryKey": false,
+			"required": true,
+			"system": false,
+			"type": "text"
+		}`)); err != nil {
+			return err
+		}
+
+		// update field
+		if err := collection.Fields.AddMarshaledJSONAt(3, []byte(`{
+			"exceptDomains": null,
+			"hidden": false,
+			"id": "email3885137012",
+			"name": "email",
+			"onlyDomains": null,
+			"presentable": false,
+			"required": false,
+			"system": true,
+			"type": "email"
+		}`)); err != nil {
+			return err
+		}
+
+		return app.Save(collection)
+	})
+}

beszel/migrations/initial-settings.go

@@ -0,0 +1,29 @@
+package migrations
+
+import (
+	"github.com/pocketbase/pocketbase/core"
+	m "github.com/pocketbase/pocketbase/migrations"
+)
+
+var (
+	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

@@ -4,15 +4,9 @@
 		<meta charset="UTF-8" />
 		<link rel="manifest" href="./static/manifest.json" />
 		<link rel="icon" type="image/svg+xml" href="./static/favicon.svg" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0,maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<title>Beszel</title>
-		<script>
-			globalThis.BESZEL = {
-				BASE_PATH: "%BASE_URL%",
-				HUB_VERSION: "{{V}}",
-				HUB_URL: "{{HUB_URL}}"
-			}
-		</script>
+		<script>window.BASE_PATH = "%BASE_URL%"</script>
 	</head>
 	<body>
 		<div id="app"></div>

beszel/site/lingui.config.ts

@@ -1,6 +1,6 @@
-import { defineConfig } from "@lingui/cli"
+import type { LinguiConfig } from "@lingui/conf"
 
-export default defineConfig({
+const config: LinguiConfig = {
 	locales: [
 		"en",
 		"ar",
@@ -33,13 +33,12 @@ export default defineConfig({
 	],
 	sourceLocale: "en",
 	compileNamespace: "ts",
-	formatOptions: {
-		lineNumbers: false,
-	},
 	catalogs: [
 		{
 			path: "<rootDir>/src/locales/{locale}/{locale}",
 			include: ["src"],
 		},
 	],
-})
+}
+
+export default config

beszel/site/package.json

@@ -0,0 +1,72 @@
+{
+	"name": "beszel",
+	"private": true,
+	"version": "0.0.0",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "lingui extract --overwrite && lingui compile && vite build",
+		"preview": "vite preview",
+		"sync": "lingui extract --overwrite && lingui compile",
+		"sync_and_purge": "lingui extract --overwrite --clean && lingui compile"
+	},
+	"dependencies": {
+		"@henrygd/queue": "^1.0.7",
+		"@lingui/detect-locale": "^4.14.1",
+		"@lingui/macro": "^4.14.1",
+		"@lingui/react": "^4.14.1",
+		"@nanostores/react": "^0.7.3",
+		"@nanostores/router": "^0.11.0",
+		"@radix-ui/react-alert-dialog": "^1.1.6",
+		"@radix-ui/react-checkbox": "^1.1.4",
+		"@radix-ui/react-dialog": "^1.1.6",
+		"@radix-ui/react-direction": "^1.1.0",
+		"@radix-ui/react-dropdown-menu": "^2.1.6",
+		"@radix-ui/react-label": "^2.1.2",
+		"@radix-ui/react-select": "^2.1.6",
+		"@radix-ui/react-separator": "^1.1.2",
+		"@radix-ui/react-slider": "^1.2.3",
+		"@radix-ui/react-slot": "^1.1.2",
+		"@radix-ui/react-switch": "^1.1.3",
+		"@radix-ui/react-tabs": "^1.1.3",
+		"@radix-ui/react-toast": "^1.2.6",
+		"@radix-ui/react-tooltip": "^1.1.8",
+		"@tanstack/react-table": "^8.20.6",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"cmdk": "^1.0.4",
+		"d3-time": "^3.1.0",
+		"lucide-react": "^0.452.0",
+		"nanostores": "^0.11.3",
+		"pocketbase": "^0.25.1",
+		"react": "^18.3.1",
+		"react-dom": "^18.3.1",
+		"recharts": "^2.15.1",
+		"tailwind-merge": "^2.6.0",
+		"tailwindcss-animate": "^1.0.7",
+		"valibot": "^0.36.0"
+	},
+	"devDependencies": {
+		"@lingui/cli": "^4.14.1",
+		"@lingui/swc-plugin": "^4.1.0",
+		"@lingui/vite-plugin": "^4.14.1",
+		"@types/bun": "^1.2.2",
+		"@types/react": "^18.3.18",
+		"@types/react-dom": "^18.3.5",
+		"@vitejs/plugin-react-swc": "^3.7.2",
+		"autoprefixer": "^10.4.20",
+		"postcss": "^8.5.1",
+		"tailwindcss": "^3.4.17",
+		"tailwindcss-rtl": "^0.9.0",
+		"typescript": "^5.7.3",
+		"vite": "^5.4.14"
+	},
+	"overrides": {
+		"@nanostores/router": {
+			"nanostores": "^0.11.3"
+		}
+	},
+	"optionalDependencies": {
+		"@esbuild/linux-arm64": "^0.21.5"
+	}
+}

beszel/site/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+	plugins: {
+		tailwindcss: {},
+		autoprefixer: {},
+	},
+}

beszel/site/src/components/add-system.tsx

@@ -0,0 +1,273 @@
+import { Button } from "@/components/ui/button"
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog"
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip"
+
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { $publicKey, pb } from "@/lib/stores"
+import { cn, copyToClipboard, isReadOnlyUser } from "@/lib/utils"
+import { i18n } from "@lingui/core"
+import { t, Trans } from "@lingui/macro"
+import { useStore } from "@nanostores/react"
+import { ChevronDownIcon, Copy, PlusIcon } from "lucide-react"
+import { memo, useRef, useState } from "react"
+import { basePath, navigate } from "./router"
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "./ui/dropdown-menu"
+import { SystemRecord } from "@/types"
+
+export function AddSystemButton({ className }: { className?: string }) {
+	const [open, setOpen] = useState(false)
+	let opened = useRef(false)
+	if (open) {
+		opened.current = true
+	}
+
+	return (
+		<Dialog open={open} onOpenChange={setOpen}>
+			<DialogTrigger asChild>
+				<Button
+					variant="outline"
+					className={cn("flex gap-1 max-xs:h-[2.4rem]", className, isReadOnlyUser() && "hidden")}
+				>
+					<PlusIcon className="h-4 w-4 -ms-1" />
+					<Trans>
+						Add <span className="hidden sm:inline">System</span>
+					</Trans>
+				</Button>
+			</DialogTrigger>
+			{opened.current && <SystemDialog setOpen={setOpen} />}
+		</Dialog>
+	)
+}
+
+function copyDockerCompose(port = "45876", publicKey: string) {
+	copyToClipboard(`services:
+  beszel-agent:
+    image: "henrygd/beszel-agent"
+    container_name: "beszel-agent"
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      # monitor other disks / partitions by mounting a folder in /extra-filesystems
+      # - /mnt/disk/.beszel:/extra-filesystems/sda1:ro
+    environment:
+      PORT: ${port}
+      KEY: "${publicKey}"`)
+}
+
+function copyDockerRun(port = "45876", publicKey: string) {
+	copyToClipboard(
+		`docker run -d --name beszel-agent --network host --restart unless-stopped -v /var/run/docker.sock:/var/run/docker.sock:ro -e KEY="${publicKey}" -e PORT=${port} henrygd/beszel-agent:latest`
+	)
+}
+
+function copyInstallCommand(port = "45876", publicKey: string) {
+	let cmd = `curl -sL https://raw.githubusercontent.com/henrygd/beszel/main/supplemental/scripts/install-agent.sh -o install-agent.sh && chmod +x install-agent.sh && ./install-agent.sh -p ${port} -k "${publicKey}"`
+	// add china mirrors flag if zh-CN
+	if ((i18n.locale + navigator.language).includes("zh-CN")) {
+		cmd += ` --china-mirrors`
+	}
+	copyToClipboard(cmd)
+}
+
+/**
+ * SystemDialog component for adding or editing a system.
+ * @param {Object} props - The component props.
+ * @param {function} props.setOpen - Function to set the open state of the dialog.
+ * @param {SystemRecord} [props.system] - Optional system record for editing an existing system.
+ */
+export const SystemDialog = memo(({ setOpen, system }: { setOpen: (open: boolean) => void; system?: SystemRecord }) => {
+	const publicKey = useStore($publicKey)
+	const port = useRef<HTMLInputElement>(null)
+	const [hostValue, setHostValue] = useState(system?.host ?? "")
+	const isUnixSocket = hostValue.startsWith("/")
+
+	async function handleSubmit(e: SubmitEvent) {
+		e.preventDefault()
+		const formData = new FormData(e.target as HTMLFormElement)
+		const data = Object.fromEntries(formData) as Record<string, any>
+		data.users = pb.authStore.record!.id
+		try {
+			setOpen(false)
+			if (system) {
+				await pb.collection("systems").update(system.id, { ...data, status: "pending" })
+			} else {
+				await pb.collection("systems").create(data)
+			}
+			navigate(basePath)
+			// console.log(record)
+		} catch (e) {
+			console.log(e)
+		}
+	}
+
+	return (
+		<DialogContent
+			className="w-[90%] sm:w-auto sm:ns-dialog max-w-full rounded-lg"
+			onCloseAutoFocus={() => {
+				setHostValue(system?.host ?? "")
+			}}
+		>
+			<Tabs defaultValue="docker">
+				<DialogHeader>
+					<DialogTitle className="mb-2">
+						{system ? `${t`Edit`} ${system?.name}` : <Trans>Add New System</Trans>}
+					</DialogTitle>
+					<TabsList className="grid w-full grid-cols-2">
+						<TabsTrigger value="docker">Docker</TabsTrigger>
+						<TabsTrigger value="binary">
+							<Trans>Binary</Trans>
+						</TabsTrigger>
+					</TabsList>
+				</DialogHeader>
+				{/* Docker (set tab index to prevent auto focusing content in edit system dialog) */}
+				<TabsContent value="docker" tabIndex={-1}>
+					<DialogDescription className="mb-4 leading-normal w-0 min-w-full">
+						<Trans>
+							The agent must be running on the system to connect. Copy the
+							<code className="bg-muted px-1 rounded-sm leading-3">docker-compose.yml</code> for the agent below.
+						</Trans>
+					</DialogDescription>
+				</TabsContent>
+				{/* Binary */}
+				<TabsContent value="binary">
+					<DialogDescription className="mb-4 leading-normal w-0 min-w-full">
+						<Trans>
+							The agent must be running on the system to connect. Copy the installation command for the agent below.
+						</Trans>
+					</DialogDescription>
+				</TabsContent>
+				<form onSubmit={handleSubmit as any}>
+					<div className="grid xs:grid-cols-[auto_1fr] gap-y-3 gap-x-4 items-center mt-1 mb-4">
+						<Label htmlFor="name" className="xs:text-end">
+							<Trans>Name</Trans>
+						</Label>
+						<Input id="name" name="name" defaultValue={system?.name} required />
+						<Label htmlFor="host" className="xs:text-end">
+							<Trans>Host / IP</Trans>
+						</Label>
+						<Input
+							id="host"
+							name="host"
+							value={hostValue}
+							required
+							onChange={(e) => {
+								setHostValue(e.target.value)
+							}}
+						/>
+						<Label htmlFor="port" className={cn("xs:text-end", isUnixSocket && "hidden")}>
+							<Trans>Port</Trans>
+						</Label>
+						<Input
+							ref={port}
+							name="port"
+							id="port"
+							defaultValue={system?.port || "45876"}
+							required={!isUnixSocket}
+							className={cn(isUnixSocket && "hidden")}
+						/>
+						<Label htmlFor="pkey" className="xs:text-end whitespace-pre">
+							<Trans comment="Use 'Key' if your language requires many more characters">Public Key</Trans>
+						</Label>
+						<div className="relative">
+							<Input readOnly id="pkey" value={publicKey} required></Input>
+							<div
+								className={
+									"h-6 w-24 bg-gradient-to-r rtl:bg-gradient-to-l from-transparent to-background to-65% absolute top-2 end-1 pointer-events-none"
+								}
+							></div>
+							<TooltipProvider delayDuration={100}>
+								<Tooltip>
+									<TooltipTrigger asChild>
+										<Button
+											type="button"
+											variant={"link"}
+											className="absolute end-0 top-0"
+											onClick={() => copyToClipboard(publicKey)}
+										>
+											<Copy className="h-4 w-4 " />
+										</Button>
+									</TooltipTrigger>
+									<TooltipContent>
+										<p>
+											<Trans>Click to copy</Trans>
+										</p>
+									</TooltipContent>
+								</Tooltip>
+							</TooltipProvider>
+						</div>
+					</div>
+					<DialogFooter className="flex justify-end gap-x-2 gap-y-3 flex-col mt-5">
+						{/* Docker */}
+						<TabsContent value="docker" className="contents">
+							<CopyButton
+								text={t`Copy` + " docker compose"}
+								onClick={() => copyDockerCompose(isUnixSocket ? hostValue : port.current?.value, publicKey)}
+								dropdownText={t`Copy` + " docker run"}
+								dropdownOnClick={() => copyDockerRun(isUnixSocket ? hostValue : port.current?.value, publicKey)}
+							/>
+						</TabsContent>
+						{/* Binary */}
+						<TabsContent value="binary" className="contents">
+							<CopyButton
+								text={t`Copy Linux command`}
+								onClick={() => copyInstallCommand(isUnixSocket ? hostValue : port.current?.value, publicKey)}
+								dropdownText={t`Manual setup instructions`}
+								dropdownUrl="https://beszel.dev/guide/agent-installation#binary"
+							/>
+						</TabsContent>
+						{/* Save */}
+						<Button>{system ? <Trans>Save system</Trans> : <Trans>Add system</Trans>}</Button>
+					</DialogFooter>
+				</form>
+			</Tabs>
+		</DialogContent>
+	)
+})
+
+interface CopyButtonProps {
+	text: string
+	onClick: () => void
+	dropdownText: string
+	dropdownOnClick?: () => void
+	dropdownUrl?: string
+}
+
+const CopyButton = memo((props: CopyButtonProps) => {
+	return (
+		<div className="flex gap-0 rounded-lg">
+			<Button type="button" variant="outline" onClick={props.onClick} className="rounded-e-none dark:border-e-0 grow">
+				{props.text}
+			</Button>
+			<div className="w-px h-full bg-muted"></div>
+			<DropdownMenu>
+				<DropdownMenuTrigger asChild>
+					<Button variant="outline" className={"px-2 rounded-s-none border-s-0"}>
+						<ChevronDownIcon />
+					</Button>
+				</DropdownMenuTrigger>
+				<DropdownMenuContent align="end">
+					{props.dropdownUrl ? (
+						<DropdownMenuItem asChild>
+							<a href={props.dropdownUrl} target="_blank" rel="noopener noreferrer">
+								{props.dropdownText}
+							</a>
+						</DropdownMenuItem>
+					) : (
+						<DropdownMenuItem onClick={props.dropdownOnClick}>{props.dropdownText}</DropdownMenuItem>
+					)}
+				</DropdownMenuContent>
+			</DropdownMenu>
+		</div>
+	)
+})

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

@@ -0,0 +1,120 @@
+import { memo, useState } from "react"
+import { useStore } from "@nanostores/react"
+import { $alerts, $systems } from "@/lib/stores"
+import {
+	Dialog,
+	DialogTrigger,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog"
+import { BellIcon, GlobeIcon, ServerIcon } from "lucide-react"
+import { alertInfo, cn } from "@/lib/utils"
+import { Button } from "@/components/ui/button"
+import { AlertRecord, SystemRecord } from "@/types"
+import { Link } from "../router"
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
+import { Checkbox } from "../ui/checkbox"
+import { SystemAlert, SystemAlertGlobal } from "./alerts-system"
+import { Trans, t } from "@lingui/macro"
+
+export default memo(function AlertsButton({ system }: { system: SystemRecord }) {
+	const alerts = useStore($alerts)
+	const [opened, setOpened] = useState(false)
+
+	const systemAlerts = alerts.filter((alert) => alert.system === system.id) as AlertRecord[]
+	const active = systemAlerts.length > 0
+
+	return (
+		<Dialog>
+			<DialogTrigger asChild>
+				<Button variant="ghost" size="icon" aria-label={t`Alerts`} data-nolink onClick={() => setOpened(true)}>
+					<BellIcon
+						className={cn("h-[1.2em] w-[1.2em] pointer-events-none", {
+							"fill-primary": active,
+						})}
+					/>
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="max-h-full overflow-auto max-w-[35rem]">
+				{opened && <TheContent data={{ system, alerts, systemAlerts }} />}
+			</DialogContent>
+		</Dialog>
+	)
+})
+
+function TheContent({
+	data: { system, alerts, systemAlerts },
+}: {
+	data: { system: SystemRecord; alerts: AlertRecord[]; systemAlerts: AlertRecord[] }
+}) {
+	const [overwriteExisting, setOverwriteExisting] = useState<boolean | "indeterminate">(false)
+	const systems = $systems.get()
+
+	const data = Object.keys(alertInfo).map((key) => {
+		const alert = alertInfo[key as keyof typeof alertInfo]
+		return {
+			key: key as keyof typeof alertInfo,
+			alert,
+			system,
+		}
+	})
+
+	return (
+		<>
+			<DialogHeader>
+				<DialogTitle className="text-xl">
+					<Trans>Alerts</Trans>
+				</DialogTitle>
+				<DialogDescription>
+					<Trans>
+						See{" "}
+						<Link href="/settings/notifications" className="link">
+							notification settings
+						</Link>{" "}
+						to configure how you receive alerts.
+					</Trans>
+				</DialogDescription>
+			</DialogHeader>
+			<Tabs defaultValue="system">
+				<TabsList className="mb-1 -mt-0.5">
+					<TabsTrigger value="system">
+						<ServerIcon className="me-2 h-3.5 w-3.5" />
+						{system.name}
+					</TabsTrigger>
+					<TabsTrigger value="global">
+						<GlobeIcon className="me-1.5 h-3.5 w-3.5" />
+						<Trans>All Systems</Trans>
+					</TabsTrigger>
+				</TabsList>
+				<TabsContent value="system">
+					<div className="grid gap-3">
+						{data.map((d) => (
+							<SystemAlert key={d.key} system={system} data={d} systemAlerts={systemAlerts} />
+						))}
+					</div>
+				</TabsContent>
+				<TabsContent value="global">
+					<label
+						htmlFor="ovw"
+						className="mb-3 flex gap-2 items-center justify-center cursor-pointer border rounded-sm py-3 px-4 border-destructive text-destructive font-semibold text-sm"
+					>
+						<Checkbox
+							id="ovw"
+							className="text-destructive border-destructive data-[state=checked]:bg-destructive"
+							checked={overwriteExisting}
+							onCheckedChange={setOverwriteExisting}
+						/>
+						<Trans>Overwrite existing alerts</Trans>
+					</label>
+					<div className="grid gap-3">
+						{data.map((d) => (
+							<SystemAlertGlobal key={d.key} data={d} overwrite={overwriteExisting} alerts={alerts} systems={systems} />
+						))}
+					</div>
+				</TabsContent>
+			</Tabs>
+		</>
+	)
+}

beszel/site/src/components/alerts/alerts-system.tsx

@@ -0,0 +1,251 @@
+import { pb } from "@/lib/stores"
+import { alertInfo, cn } from "@/lib/utils"
+import { Switch } from "@/components/ui/switch"
+import { AlertInfo, AlertRecord, SystemRecord } from "@/types"
+import { lazy, Suspense, useRef, useState } from "react"
+import { toast } from "../ui/use-toast"
+import { RecordOptions } from "pocketbase"
+import { Trans, t, Plural } from "@lingui/macro"
+
+interface AlertData {
+	checked?: boolean
+	val?: number
+	min?: number
+	updateAlert?: (checked: boolean, value: number, min: number) => void
+	key: keyof typeof alertInfo
+	alert: AlertInfo
+	system: SystemRecord
+}
+
+const Slider = lazy(() => import("@/components/ui/slider"))
+
+const failedUpdateToast = () =>
+	toast({
+		title: t`Failed to update alert`,
+		description: t`Please check logs for more details.`,
+		variant: "destructive",
+	})
+
+export function SystemAlert({
+	system,
+	systemAlerts,
+	data,
+}: {
+	system: SystemRecord
+	systemAlerts: AlertRecord[]
+	data: AlertData
+}) {
+	const alert = systemAlerts.find((alert) => alert.name === data.key)
+
+	data.updateAlert = async (checked: boolean, value: number, min: number) => {
+		try {
+			if (alert && !checked) {
+				await pb.collection("alerts").delete(alert.id)
+			} else if (alert && checked) {
+				await pb.collection("alerts").update(alert.id, { value, min, triggered: false })
+			} else if (checked) {
+				pb.collection("alerts").create({
+					system: system.id,
+					user: pb.authStore.record!.id,
+					name: data.key,
+					value: value,
+					min: min,
+				})
+			}
+		} catch (e) {
+			failedUpdateToast()
+		}
+	}
+
+	if (alert) {
+		data.checked = true
+		data.val = alert.value
+		data.min = alert.min || 1
+	}
+
+	return <AlertContent data={data} />
+}
+
+export function SystemAlertGlobal({
+	data,
+	overwrite,
+	alerts,
+	systems,
+}: {
+	data: AlertData
+	overwrite: boolean | "indeterminate"
+	alerts: AlertRecord[]
+	systems: SystemRecord[]
+}) {
+	const systemsWithExistingAlerts = useRef<{ set: Set<string>; populatedSet: boolean }>({
+		set: new Set(),
+		populatedSet: false,
+	})
+
+	data.checked = false
+	data.val = data.min = 0
+
+	data.updateAlert = async (checked: boolean, value: number, min: number) => {
+		const { set, populatedSet } = systemsWithExistingAlerts.current
+
+		// if overwrite checked, make sure all alerts will be overwritten
+		if (overwrite) {
+			set.clear()
+		}
+
+		const recordData: Partial<AlertRecord> = {
+			value,
+			min,
+			triggered: false,
+		}
+
+		// we can only send 50 in one batch
+		let done = 0
+
+		while (done < systems.length) {
+			const batch = pb.createBatch()
+			let batchSize = 0
+
+			for (let i = done; i < Math.min(done + 50, systems.length); i++) {
+				const system = systems[i]
+				// if overwrite is false and system is in set (alert existed), skip
+				if (!overwrite && set.has(system.id)) {
+					continue
+				}
+				// find matching existing alert
+				const existingAlert = alerts.find((alert) => alert.system === system.id && data.key === alert.name)
+				// if first run, add system to set (alert already existed when global panel was opened)
+				if (existingAlert && !populatedSet && !overwrite) {
+					set.add(system.id)
+					continue
+				}
+				batchSize++
+				const requestOptions: RecordOptions = {
+					requestKey: system.id,
+				}
+
+				// checked - make sure alert is created or updated
+				if (checked) {
+					if (existingAlert) {
+						batch.collection("alerts").update(existingAlert.id, recordData, requestOptions)
+					} else {
+						batch.collection("alerts").create(
+							{
+								system: system.id,
+								user: pb.authStore.record!.id,
+								name: data.key,
+								...recordData,
+							},
+							requestOptions
+						)
+					}
+				} else if (existingAlert) {
+					batch.collection("alerts").delete(existingAlert.id)
+				}
+			}
+			try {
+				batchSize && batch.send()
+			} catch (e) {
+				failedUpdateToast()
+			} finally {
+				done += 50
+			}
+		}
+		systemsWithExistingAlerts.current.populatedSet = true
+	}
+
+	return <AlertContent data={data} />
+}
+
+function AlertContent({ data }: { data: AlertData }) {
+	const { key } = data
+
+	const singleDescription = data.alert.singleDesc?.()
+
+	const [checked, setChecked] = useState(data.checked || false)
+	const [min, setMin] = useState(data.min || 10)
+	const [value, setValue] = useState(data.val || (singleDescription ? 0 : 80))
+
+	const newMin = useRef(min)
+	const newValue = useRef(value)
+
+	const Icon = alertInfo[key].icon
+
+	const updateAlert = (c?: boolean) => data.updateAlert?.(c ?? checked, newValue.current, newMin.current)
+
+	return (
+		<div className="rounded-lg border border-muted-foreground/15 hover:border-muted-foreground/20 transition-colors duration-100 group">
+			<label
+				htmlFor={`s${key}`}
+				className={cn("flex flex-row items-center justify-between gap-4 cursor-pointer p-4", {
+					"pb-0": checked,
+				})}
+			>
+				<div className="grid gap-1 select-none">
+					<p className="font-semibold flex gap-3 items-center">
+						<Icon className="h-4 w-4 opacity-85" /> {data.alert.name()}
+					</p>
+					{!checked && <span className="block text-sm text-muted-foreground">{data.alert.desc()}</span>}
+				</div>
+				<Switch
+					id={`s${key}`}
+					checked={checked}
+					onCheckedChange={(checked) => {
+						setChecked(checked)
+						updateAlert(checked)
+					}}
+				/>
+			</label>
+			{checked && (
+				<div className="grid sm:grid-cols-2 mt-1.5 gap-5 px-4 pb-5 tabular-nums text-muted-foreground">
+					<Suspense fallback={<div className="h-10" />}>
+					{!singleDescription && (
+						<div>
+							<p id={`v${key}`} className="text-sm block h-8">
+								<Trans>
+									Average exceeds{" "}
+									<strong className="text-foreground">
+										{value}
+										{data.alert.unit}
+									</strong>
+								</Trans>
+							</p>
+							<div className="flex gap-3">
+								<Slider
+									aria-labelledby={`v${key}`}
+									defaultValue={[value]}
+									onValueCommit={(val) => (newValue.current = val[0]) && updateAlert()}
+									onValueChange={(val) => setValue(val[0])}
+									min={1}
+									max={alertInfo[key].max ?? 99}
+								/>
+							</div>
+						</div>
+					)}
+						<div className={cn(singleDescription && "col-span-full lowercase")}>
+							<p id={`t${key}`} className="text-sm block h-8 first-letter:uppercase">
+								{singleDescription && (
+									<>{singleDescription}{` `}</>
+								)}
+								<Trans>
+									For <strong className="text-foreground">{min}</strong>{" "}
+									<Plural value={min} one=" minute" other=" minutes" />
+								</Trans>
+							</p>
+							<div className="flex gap-3">
+								<Slider
+									aria-labelledby={`v${key}`}
+									defaultValue={[min]}
+									onValueCommit={(val) => (newMin.current = val[0]) && updateAlert()}
+									onValueChange={(val) => setMin(val[0])}
+									min={1}
+									max={60}
+								/>
+							</div>
+						</div>
+					</Suspense>
+				</div>
+			)}
+		</div>
+	)
+}

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

@@ -0,0 +1,143 @@
+import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+
+import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import {
+	useYAxisWidth,
+	cn,
+	formatShortDate,
+	toFixedWithoutTrailingZeros,
+	decimalString,
+	chartMargin,
+} from "@/lib/utils"
+// import Spinner from '../spinner'
+import { ChartData } from "@/types"
+import { memo, useMemo } from "react"
+import { t } from "@lingui/macro"
+import { useLingui } from "@lingui/react"
+
+/** [label, key, color, opacity] */
+type DataKeys = [string, string, number, number]
+
+const getNestedValue = (path: string, max = false, data: any): number | null => {
+	// fallback value (obj?.stats?.cpum ? 0 : null) should only come into play when viewing
+	// a max value which doesn't exist, or the value was zero and omitted from the stats object.
+	// so we check if cpum is present. if so, return 0 to make sure the zero value is displayed.
+	// if not, return null - there is no max data so do not display anything.
+	return `stats.${path}${max ? "m" : ""}`
+		.split(".")
+		.reduce((acc: any, key: string) => acc?.[key] ?? (data.stats?.cpum ? 0 : null), data)
+}
+
+export default memo(function AreaChartDefault({
+	maxToggled = false,
+	unit = " MB/s",
+	chartName,
+	chartData,
+	max,
+	tickFormatter,
+}: {
+	maxToggled?: boolean
+	unit?: string
+	chartName: string
+	chartData: ChartData
+	max?: number
+	tickFormatter?: (value: number) => string
+}) {
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+	const { i18n } = useLingui()
+
+	const { chartTime } = chartData
+
+	const showMax = chartTime !== "1h" && maxToggled
+
+	const dataKeys: DataKeys[] = useMemo(() => {
+		// [label, key, color, opacity]
+		if (chartName === "CPU Usage") {
+			return [[t`CPU Usage`, "cpu", 1, 0.4]]
+		} else if (chartName === "dio") {
+			return [
+				[t({ message: "Write", comment: "Disk write" }), "dw", 3, 0.3],
+				[t({ message: "Read", comment: "Disk read" }), "dr", 1, 0.3],
+			]
+		} else if (chartName === "bw") {
+			return [
+				[t({ message: "Sent", comment: "Network bytes sent (upload)" }), "ns", 5, 0.2],
+				[t({ message: "Received", comment: "Network bytes received (download)" }), "nr", 2, 0.2],
+			]
+		} else if (chartName.startsWith("efs")) {
+			return [
+				[t`Write`, `${chartName}.w`, 3, 0.3],
+				[t`Read`, `${chartName}.r`, 1, 0.3],
+			]
+		} else if (chartName.startsWith("g.")) {
+			return [chartName.includes("mu") ? [t`Used`, chartName, 2, 0.25] : [t`Usage`, chartName, 1, 0.4]]
+		}
+		return []
+	}, [chartName, i18n.locale])
+
+	// console.log('Rendered at', new Date())
+
+	if (chartData.systemStats.length === 0) {
+		return null
+	}
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn("h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity", {
+					"opacity-100": yAxisWidth,
+				})}
+			>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						direction="ltr"
+						orientation={chartData.orientation}
+						className="tracking-tighter"
+						width={yAxisWidth}
+						domain={[0, max ?? "auto"]}
+						tickFormatter={(value) => {
+							let val: string
+							if (tickFormatter) {
+								val = tickFormatter(value)
+							} else {
+								val = toFixedWithoutTrailingZeros(value, 2) + unit
+							}
+							return updateYAxisWidth(val)
+						}}
+						tickLine={false}
+						axisLine={false}
+					/>
+					{xAxis(chartData)}
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						content={
+							<ChartTooltipContent
+								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
+								contentFormatter={(item) => decimalString(item.value) + unit}
+								// indicator="line"
+							/>
+						}
+					/>
+					{dataKeys.map((key, i) => {
+						const color = `hsl(var(--chart-${key[2]}))`
+						return (
+							<Area
+								key={i}
+								dataKey={getNestedValue.bind(null, key[1], showMax)}
+								name={key[0]}
+								type="monotoneX"
+								fill={color}
+								fillOpacity={key[3]}
+								stroke={color}
+								isAnimationActive={false}
+							/>
+						)
+					})}
+					{/* <ChartLegend content={<ChartLegendContent />} /> */}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})

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

@@ -1,9 +1,9 @@
-import { useStore } from "@nanostores/react"
-import { HistoryIcon } from "lucide-react"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 import { $chartTime } from "@/lib/stores"
 import { chartTimeData, cn } from "@/lib/utils"
-import type { ChartTimes } from "@/types"
+import { ChartTimes } from "@/types"
+import { useStore } from "@nanostores/react"
+import { HistoryIcon } from "lucide-react"
 
 export default function ChartTimeSelect({ className }: { className?: string }) {
 	const chartTime = useStore($chartTime)

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

@@ -1,37 +1,79 @@
+import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+import { ChartConfig, ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import { memo, useMemo } from "react"
+import {
+	useYAxisWidth,
+	cn,
+	formatShortDate,
+	decimalString,
+	chartMargin,
+	toFixedFloat,
+	getSizeAndUnit,
+	toFixedWithoutTrailingZeros,
+} from "@/lib/utils"
 // import Spinner from '../spinner'
 import { useStore } from "@nanostores/react"
-import { memo, useMemo } from "react"
-import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
-import { type ChartConfig, ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-import { ChartType, Unit } from "@/lib/enums"
-import { $containerFilter, $userSettings } from "@/lib/stores"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
+import { $containerFilter } from "@/lib/stores"
+import { ChartData } from "@/types"
 import { Separator } from "../ui/separator"
-import { useYAxisWidth } from "./hooks"
 
 export default memo(function ContainerChart({
 	dataKey,
 	chartData,
-	chartType,
-	chartConfig,
+	chartName,
 	unit = "%",
 }: {
 	dataKey: string
 	chartData: ChartData
-	chartType: ChartType
-	chartConfig: ChartConfig
+	chartName: string
 	unit?: string
 }) {
 	const filter = useStore($containerFilter)
-	const userSettings = useStore($userSettings)
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
 
 	const { containerData } = chartData
 
-	const isNetChart = chartType === ChartType.Network
+	const isNetChart = chartName === "net"
+
+	const chartConfig = useMemo(() => {
+		let config = {} as Record<
+			string,
+			{
+				label: string
+				color: string
+			}
+		>
+		const totalUsage = {} as Record<string, number>
+		for (let stats of containerData) {
+			for (let key in stats) {
+				if (!key || key === "created") {
+					continue
+				}
+				if (!(key in totalUsage)) {
+					totalUsage[key] = 0
+				}
+				if (isNetChart) {
+					totalUsage[key] += (stats[key]?.nr ?? 0) + (stats[key]?.ns ?? 0)
+				} else {
+					// @ts-ignore
+					totalUsage[key] += stats[key]?.[dataKey] ?? 0
+				}
+			}
+		}
+		let keys = Object.keys(totalUsage)
+		keys.sort((a, b) => (totalUsage[a] > totalUsage[b] ? -1 : 1))
+		const length = keys.length
+		for (let i = 0; i < length; i++) {
+			const key = keys[i]
+			const hue = ((i * 360) / length) % 360
+			config[key] = {
+				label: key,
+				color: `hsl(${hue}, 60%, 55%)`,
+			}
+		}
+		return config satisfies ChartConfig
+	}, [chartData])
 
-	// biome-ignore lint/correctness/useExhaustiveDependencies: not necessary
 	const { toolTipFormatter, dataFunction, tickFormatter } = useMemo(() => {
 		const obj = {} as {
 			toolTipFormatter: (item: any, key: string) => React.ReactNode | string
@@ -39,16 +81,15 @@ export default memo(function ContainerChart({
 			tickFormatter: (value: any) => string
 		}
 		// tick formatter
-		if (chartType === ChartType.CPU) {
+		if (chartName === "cpu") {
 			obj.tickFormatter = (value) => {
-				const val = toFixedFloat(value, 2) + unit
+				const val = toFixedWithoutTrailingZeros(value, 2) + unit
 				return updateYAxisWidth(val)
 			}
 		} else {
-			const chartUnit = isNetChart ? userSettings.unitNet : Unit.Bytes
-			obj.tickFormatter = (val) => {
-				const { value, unit } = formatBytes(val, isNetChart, chartUnit, true)
-				return updateYAxisWidth(`${toFixedFloat(value, value >= 10 ? 0 : 1)} ${unit}`)
+			obj.tickFormatter = (value) => {
+				const { v, u } = getSizeAndUnit(value, false)
+				return updateYAxisWidth(`${toFixedFloat(v, 2)}${u}${isNetChart ? "/s" : ""}`)
 			}
 		}
 		// tooltip formatter
@@ -57,14 +98,12 @@ export default memo(function ContainerChart({
 				try {
 					const sent = item?.payload?.[key]?.ns ?? 0
 					const received = item?.payload?.[key]?.nr ?? 0
-					const { value: receivedValue, unit: receivedUnit } = formatBytes(received, true, userSettings.unitNet, true)
-					const { value: sentValue, unit: sentUnit } = formatBytes(sent, true, userSettings.unitNet, true)
 					return (
 						<span className="flex">
-							{decimalString(receivedValue)} {receivedUnit}
+							{decimalString(received)} MB/s
 							<span className="opacity-70 ms-0.5"> rx </span>
 							<Separator orientation="vertical" className="h-3 mx-1.5 bg-primary/40" />
-							{decimalString(sentValue)} {sentUnit}
+							{decimalString(sent)} MB/s
 							<span className="opacity-70 ms-0.5"> tx</span>
 						</span>
 					)
@@ -72,13 +111,8 @@ export default memo(function ContainerChart({
 					return null
 				}
 			}
-		} else if (chartType === ChartType.Memory) {
-			obj.toolTipFormatter = (item: any) => {
-				const { value, unit } = formatBytes(item.value, false, Unit.Bytes, true)
-				return `${decimalString(value)} ${unit}`
-			}
 		} else {
-			obj.toolTipFormatter = (item: any) => `${decimalString(item.value)} ${unit}`
+			obj.toolTipFormatter = (item: any) => decimalString(item.value) + unit
 		}
 		// data function
 		if (isNetChart) {
@@ -89,15 +123,6 @@ export default memo(function ContainerChart({
 		return obj
 	}, [])
 
-	// Filter with set lookup
-	const filteredKeys = useMemo(() => {
-		if (!filter) {
-			return new Set<string>()
-		}
-		const filterLower = filter.toLowerCase()
-		return new Set(Object.keys(chartConfig).filter((key) => !key.toLowerCase().includes(filterLower)))
-	}, [chartConfig, filter])
-
 	// console.log('rendered at', new Date())
 
 	if (containerData.length === 0) {
@@ -132,16 +157,15 @@ export default memo(function ContainerChart({
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
-						truncate={true}
 						labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-						// @ts-expect-error
+						// @ts-ignore
 						itemSorter={(a, b) => b.value - a.value}
 						content={<ChartTooltipContent filter={filter} contentFormatter={toolTipFormatter} />}
 					/>
 					{Object.keys(chartConfig).map((key) => {
-						const filtered = filteredKeys.has(key)
-						const fillOpacity = filtered ? 0.05 : 0.4
-						const strokeOpacity = filtered ? 0.1 : 1
+						const filtered = filter && !key.includes(filter)
+						let fillOpacity = filtered ? 0.05 : 0.4
+						let strokeOpacity = filtered ? 0.1 : 1
 						return (
 							<Area
 								key={key}

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

@@ -1,11 +1,19 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-import { Unit } from "@/lib/enums"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
-import { useYAxisWidth } from "./hooks"
+import {
+	useYAxisWidth,
+	cn,
+	formatShortDate,
+	decimalString,
+	toFixedFloat,
+	chartMargin,
+	getSizeAndUnit,
+} from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo } from "react"
+import { t } from "@lingui/macro"
+import { useLingui } from "@lingui/react"
 
 export default memo(function DiskChart({
 	dataKey,
@@ -17,7 +25,7 @@ export default memo(function DiskChart({
 	chartData: ChartData
 }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-	const { t } = useLingui()
+	const { _ } = useLingui()
 
 	// round to nearest GB
 	if (diskSize >= 100) {
@@ -47,9 +55,9 @@ export default memo(function DiskChart({
 						minTickGap={6}
 						tickLine={false}
 						axisLine={false}
-						tickFormatter={(val) => {
-							const { value, unit } = formatBytes(val * 1024, false, Unit.Bytes, true)
-							return updateYAxisWidth(toFixedFloat(value, value >= 10 ? 0 : 1) + " " + unit)
+						tickFormatter={(value) => {
+							const { v, u } = getSizeAndUnit(value)
+							return updateYAxisWidth(toFixedFloat(v, 2) + u)
 						}}
 					/>
 					{xAxis(chartData)}
@@ -60,19 +68,19 @@ export default memo(function DiskChart({
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
 								contentFormatter={({ value }) => {
-									const { value: convertedValue, unit } = formatBytes(value * 1024, false, Unit.Bytes, true)
-									return decimalString(convertedValue) + " " + unit
+									const { v, u } = getSizeAndUnit(value)
+									return decimalString(v) + u
 								}}
 							/>
 						}
 					/>
 					<Area
 						dataKey={dataKey}
-						name={t`Disk Usage`}
+						name={_(t`Disk Usage`)}
 						type="monotoneX"
-						fill="var(--chart-4)"
+						fill="hsl(var(--chart-4))"
 						fillOpacity={0.4}
-						stroke="var(--chart-4)"
+						stroke="hsl(var(--chart-4))"
 						// animationDuration={1200}
 						isAnimationActive={false}
 					/>

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

@@ -1,5 +1,5 @@
-import { memo, useMemo } from "react"
 import { CartesianGrid, Line, LineChart, YAxis } from "recharts"
+
 import {
 	ChartContainer,
 	ChartLegend,
@@ -8,9 +8,16 @@ import {
 	ChartTooltipContent,
 	xAxis,
 } from "@/components/ui/chart"
-import { chartMargin, cn, decimalString, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
-import { useYAxisWidth } from "./hooks"
+import {
+	useYAxisWidth,
+	cn,
+	formatShortDate,
+	toFixedWithoutTrailingZeros,
+	decimalString,
+	chartMargin,
+} from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo, useMemo } from "react"
 
 export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
@@ -26,10 +33,10 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 			colors: Record<string, string>
 		}
 		const powerSums = {} as Record<string, number>
-		for (const data of chartData.systemStats) {
-			const newData = { created: data.created } as Record<string, number | string>
+		for (let data of chartData.systemStats) {
+			let newData = { created: data.created } as Record<string, number | string>
 
-			for (const gpu of Object.values(data.stats?.g ?? {})) {
+			for (let gpu of Object.values(data.stats?.g ?? {})) {
 				if (gpu.p) {
 					const name = gpu.n
 					newData[name] = gpu.p
@@ -39,7 +46,7 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 			newChartData.data.push(newData)
 		}
 		const keys = Object.keys(powerSums).sort((a, b) => powerSums[b] - powerSums[a])
-		for (const key of keys) {
+		for (let key of keys) {
 			newChartData.colors[key] = `hsl(${((keys.indexOf(key) * 360) / keys.length) % 360}, 60%, 55%)`
 		}
 		return newChartData
@@ -65,8 +72,8 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 						domain={[0, "auto"]}
 						width={yAxisWidth}
 						tickFormatter={(value) => {
-							const val = toFixedFloat(value, 2)
-							return updateYAxisWidth(`${val}W`)
+							const val = toFixedWithoutTrailingZeros(value, 2)
+							return updateYAxisWidth(val + "W")
 						}}
 						tickLine={false}
 						axisLine={false}
@@ -75,12 +82,12 @@ export default memo(function GpuPowerChart({ chartData }: { chartData: ChartData
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
-						// @ts-expect-error
+						// @ts-ignore
 						itemSorter={(a, b) => b.value - a.value}
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => `${decimalString(item.value)}W`}
+								contentFormatter={(item) => decimalString(item.value) + "W"}
 								// indicator="line"
 							/>
 						}

beszel/site/src/components/charts/mem-chart.tsx

@@ -1,15 +1,15 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
-import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-import { Unit } from "@/lib/enums"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
-import { useYAxisWidth } from "./hooks"
 
-export default memo(function MemChart({ chartData, showMax }: { chartData: ChartData; showMax: boolean }) {
+import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
+import { useYAxisWidth, cn, toFixedFloat, decimalString, formatShortDate, chartMargin } from "@/lib/utils"
+import { memo } from "react"
+import { ChartData } from "@/types"
+import { t } from "@lingui/macro"
+import { useLingui } from "@lingui/react"
+
+export default memo(function MemChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-	const { t } = useLingui()
+	const { _ } = useLingui()
 
 	const totalMem = toFixedFloat(chartData.systemStats.at(-1)?.stats.m ?? 0, 1)
 
@@ -41,8 +41,8 @@ export default memo(function MemChart({ chartData, showMax }: { chartData: Chart
 							tickLine={false}
 							axisLine={false}
 							tickFormatter={(value) => {
-								const { value: convertedValue, unit } = formatBytes(value * 1024, false, Unit.Bytes, true)
-								return updateYAxisWidth(toFixedFloat(convertedValue, value >= 10 ? 0 : 1) + " " + unit)
+								const val = toFixedFloat(value, 1)
+								return updateYAxisWidth(val + " GB")
 							}}
 						/>
 					)}
@@ -53,53 +53,50 @@ export default memo(function MemChart({ chartData, showMax }: { chartData: Chart
 						animationDuration={150}
 						content={
 							<ChartTooltipContent
-								// @ts-expect-error
+								// @ts-ignore
 								itemSorter={(a, b) => a.order - b.order}
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={({ value }) => {
-									// mem values are supplied as GB
-									const { value: convertedValue, unit } = formatBytes(value * 1024, false, Unit.Bytes, true)
-									return decimalString(convertedValue, convertedValue >= 100 ? 1 : 2) + " " + unit
-								}}
+								contentFormatter={(item) => decimalString(item.value) + " GB"}
+								// indicator="line"
 							/>
 						}
 					/>
 					<Area
-						name={t`Used`}
+						name={_(t`Used`)}
 						order={3}
-						dataKey={({ stats }) => (showMax ? stats?.mm : stats?.mu)}
+						dataKey="stats.mu"
 						type="monotoneX"
-						fill="var(--chart-2)"
+						fill="hsl(var(--chart-2))"
 						fillOpacity={0.4}
-						stroke="var(--chart-2)"
+						stroke="hsl(var(--chart-2))"
 						stackId="1"
 						isAnimationActive={false}
 					/>
-					{/* {chartData.systemStats.at(-1)?.stats.mz && ( */}
+					{chartData.systemStats.at(-1)?.stats.mz && (
+						<Area
+							name="ZFS ARC"
+							order={2}
+							dataKey="stats.mz"
+							type="monotoneX"
+							fill="hsla(175 60% 45% / 0.8)"
+							fillOpacity={0.5}
+							stroke="hsla(175 60% 45% / 0.8)"
+							stackId="1"
+							isAnimationActive={false}
+						/>
+					)}
 					<Area
-						name="ZFS ARC"
-						order={2}
-						dataKey={({ stats }) => (showMax ? null : stats?.mz)}
-						type="monotoneX"
-						fill="hsla(175 60% 45% / 0.8)"
-						fillOpacity={0.5}
-						stroke="hsla(175 60% 45% / 0.8)"
-						stackId="1"
-						isAnimationActive={false}
-					/>
-					{/* )} */}
-					<Area
-						name={t`Cache / Buffers`}
+						name={_(t`Cache / Buffers`)}
 						order={1}
-						dataKey={({ stats }) => (showMax ? null : stats?.mb)}
+						dataKey="stats.mb"
 						type="monotoneX"
 						fill="hsla(160 60% 45% / 0.5)"
 						fillOpacity={0.4}
+						// strokeOpacity={1}
 						stroke="hsla(160 60% 45% / 0.5)"
 						stackId="1"
 						isAnimationActive={false}
 					/>
-					{/* <ChartLegend content={<ChartLegendContent />} /> */}
 				</AreaChart>
 			</ChartContainer>
 		</div>

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

@@ -1,16 +1,20 @@
-import { t } from "@lingui/core/macro"
-import { useStore } from "@nanostores/react"
-import { memo } from "react"
 import { Area, AreaChart, CartesianGrid, YAxis } from "recharts"
+
 import { ChartContainer, ChartTooltip, ChartTooltipContent, xAxis } from "@/components/ui/chart"
-import { $userSettings } from "@/lib/stores"
-import { chartMargin, cn, decimalString, formatBytes, formatShortDate, toFixedFloat } from "@/lib/utils"
-import type { ChartData } from "@/types"
-import { useYAxisWidth } from "./hooks"
+import {
+	useYAxisWidth,
+	cn,
+	formatShortDate,
+	toFixedWithoutTrailingZeros,
+	decimalString,
+	chartMargin,
+} from "@/lib/utils"
+import { ChartData } from "@/types"
+import { memo } from "react"
+import { t } from "@lingui/macro"
 
 export default memo(function SwapChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-	const userSettings = useStore($userSettings)
 
 	if (chartData.systemStats.length === 0) {
 		return null
@@ -29,14 +33,11 @@ export default memo(function SwapChart({ chartData }: { chartData: ChartData })
 						direction="ltr"
 						orientation={chartData.orientation}
 						className="tracking-tighter"
-						domain={[0, () => toFixedFloat(chartData.systemStats.at(-1)?.stats.s ?? 0.04, 2)]}
+						domain={[0, () => toFixedWithoutTrailingZeros(chartData.systemStats.at(-1)?.stats.s ?? 0.04, 2)]}
 						width={yAxisWidth}
 						tickLine={false}
 						axisLine={false}
-						tickFormatter={(value) => {
-							const { value: convertedValue, unit } = formatBytes(value * 1024, false, userSettings.unitDisk, true)
-							return updateYAxisWidth(toFixedFloat(convertedValue, value >= 10 ? 0 : 1) + " " + unit)
-						}}
+						tickFormatter={(value) => updateYAxisWidth(value + " GB")}
 					/>
 					{xAxis(chartData)}
 					<ChartTooltip
@@ -45,11 +46,7 @@ export default memo(function SwapChart({ chartData }: { chartData: ChartData })
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={({ value }) => {
-									// mem values are supplied as GB
-									const { value: convertedValue, unit } = formatBytes(value * 1024, false, userSettings.unitDisk, true)
-									return decimalString(convertedValue, convertedValue >= 100 ? 1 : 2) + " " + unit
-								}}
+								contentFormatter={(item) => decimalString(item.value) + " GB"}
 								// indicator="line"
 							/>
 						}
@@ -58,9 +55,9 @@ export default memo(function SwapChart({ chartData }: { chartData: ChartData })
 						dataKey="stats.su"
 						name={t`Used`}
 						type="monotoneX"
-						fill="var(--chart-2)"
+						fill="hsl(var(--chart-2))"
 						fillOpacity={0.4}
-						stroke="var(--chart-2)"
+						stroke="hsl(var(--chart-2))"
 						isAnimationActive={false}
 					/>
 				</AreaChart>