chore(deps): bump github.com/ebitengine/purego from 0.10.0 to 0.10.2 (#2191)

Bumps [github.com/ebitengine/purego](https://github.com/ebitengine/purego) from 0.10.0 to 0.10.2.
- [Release notes](https://github.com/ebitengine/purego/releases)
- [Commits](https://github.com/ebitengine/purego/compare/v0.10.0...v0.10.2)

---
updated-dependencies:
- dependency-name: github.com/ebitengine/purego
  dependency-version: 0.10.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: weekly
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+

.github/workflows/docker-images.yml

@@ -164,7 +164,7 @@ jobs:
         run: bun run --cwd ./internal/site build
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v4
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
@@ -190,7 +190,7 @@ jobs:
       # Build and push Docker image with Buildx (don't push on PR)
       # https://github.com/docker/build-push-action
       - name: Build and push Docker image
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v7
         with:
           context: ./
           file: ${{ matrix.dockerfile }}

.github/workflows/inactivity-actions.yml

@@ -15,7 +15,7 @@ jobs:
     name: Lock Inactive Issues
     runs-on: ubuntu-24.04
     steps:
-      - uses: klaasnicolaas/action-inactivity-lock@v1.1.3
+      - uses: klaasnicolaas/action-inactivity-lock@v2.0.1
         id: lock
         with:
           days-inactive-issues: 14

.github/workflows/release.yml

@@ -27,7 +27,7 @@ jobs:
         run: bun run --cwd ./internal/site build
 
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v7
         with:
           go-version: "^1.22.1"
 
@@ -42,7 +42,7 @@ jobs:
         shell: bash
 
       - name: GoReleaser beszel
-        uses: goreleaser/goreleaser-action@v6
+        uses: goreleaser/goreleaser-action@v7
         with:
           workdir: ./
           distribution: goreleaser

.github/workflows/vulncheck.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Check out code into the Go module directory
         uses: actions/checkout@v6
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v7
         with:
           go-version: 1.26.x
           # cached: false

agent/agent.go

@@ -48,7 +48,6 @@ type Agent struct {
 	keys                      []gossh.PublicKey                                     // SSH public keys
 	smartManager              *SmartManager                                         // Manages SMART data
 	systemdManager            *systemdManager                                       // Manages systemd services
-	probeManager              *ProbeManager                                         // Manages network probes
 }
 
 // NewAgent creates a new agent with the given data directory for persisting data.
@@ -122,9 +121,6 @@ func NewAgent(dataDir ...string) (agent *Agent, err error) {
 	// initialize handler registry
 	agent.handlerRegistry = NewHandlerRegistry()
 
-	// initialize probe manager
-	agent.probeManager = newProbeManager()
-
 	// initialize disk info
 	agent.initializeDiskInfo()
 
@@ -182,11 +178,6 @@ func (a *Agent) gatherStats(options common.DataRequestOptions) *system.CombinedD
 		}
 	}
 
-	if a.probeManager != nil {
-		data.Probes = a.probeManager.GetResults(cacheTimeMs)
-		slog.Debug("Probes", "data", data.Probes)
-	}
-
 	// skip updating systemd services if cache time is not the default 60sec interval
 	if a.systemdManager != nil && cacheTimeMs == defaultDataCacheTimeMs {
 		totalCount := uint16(a.systemdManager.getServiceStatsCount())

agent/connection_manager.go

@@ -141,7 +141,6 @@ func (c *ConnectionManager) Start(serverOptions ServerOptions) error {
 //	}
 func (c *ConnectionManager) stop() error {
 	_ = c.agent.StopServer()
-	c.agent.probeManager.Stop()
 	c.closeWebSocket()
 	return health.CleanUp()
 }

agent/handlers.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/fxamacker/cbor/v2"
 	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/entities/smart"
 
 	"log/slog"
@@ -52,7 +51,6 @@ func NewHandlerRegistry() *HandlerRegistry {
 	registry.Register(common.GetContainerInfo, &GetContainerInfoHandler{})
 	registry.Register(common.GetSmartData, &GetSmartDataHandler{})
 	registry.Register(common.GetSystemdInfo, &GetSystemdInfoHandler{})
-	registry.Register(common.SyncNetworkProbes, &SyncNetworkProbesHandler{})
 
 	return registry
 }
@@ -205,22 +203,3 @@ func (h *GetSystemdInfoHandler) Handle(hctx *HandlerContext) error {
 
 	return hctx.SendResponse(details, hctx.RequestID)
 }
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-// SyncNetworkProbesHandler handles probe configuration sync from hub
-type SyncNetworkProbesHandler struct{}
-
-func (h *SyncNetworkProbesHandler) Handle(hctx *HandlerContext) error {
-	var req probe.SyncRequest
-	if err := cbor.Unmarshal(hctx.Request.Data, &req); err != nil {
-		return err
-	}
-	resp, err := hctx.Agent.probeManager.HandleSyncRequest(req)
-	if err != nil {
-		return err
-	}
-	slog.Info("network probes synced", "action", req.Action)
-	return hctx.SendResponse(resp, hctx.RequestID)
-}

agent/probe.go

@@ -1,547 +0,0 @@
-package agent
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"math/rand"
-	"net"
-	"net/http"
-
-	// "strconv"
-	"sync"
-	"time"
-
-	"log/slog"
-
-	"github.com/henrygd/beszel/internal/entities/probe"
-)
-
-// Probe functionality overview:
-// Probes run at user-defined intervals (e.g., every 10s).
-// To keep memory usage low and constant, data is stored in two layers:
-// 1. Raw samples: The most recent individual results (kept for probeRawRetention).
-// 2. Minute buckets: A fixed-size ring buffer of 61 buckets, each representing one
-//    wall-clock minute. Samples collected within the same minute are aggregated
-//    (sum, min, max, count) into a single bucket.
-//
-// Short-term requests (<= 2m) use raw samples for perfect accuracy.
-// Long-term requests (up to 1h) use the minute buckets to avoid storing thousands
-// of individual data points.
-
-const (
-	// probeRawRetention is the duration to keep individual samples for high-precision short-term requests
-	probeRawRetention = 70 * time.Second
-	// probeMinuteBucketLen is the number of 1-minute buckets to keep (1 hour + 1 for partials)
-	probeMinuteBucketLen int32 = 61
-)
-
-// ProbeManager manages network probe tasks.
-type ProbeManager struct {
-	mu         sync.RWMutex
-	probes     map[string]*probeTask // key = probe.Config.Key()
-	httpClient *http.Client
-}
-
-// probeTask owns retention buffers and cancellation for a single probe config.
-type probeTask struct {
-	config  probe.Config
-	cancel  chan struct{}
-	mu      sync.Mutex
-	samples []probeSample
-	buckets [probeMinuteBucketLen]probeBucket
-}
-
-// probeSample stores one probe attempt and its collection time.
-type probeSample struct {
-	responseUs int64 // -1 means loss
-	timestamp  time.Time
-}
-
-// probeBucket stores one minute of aggregated probe data.
-type probeBucket struct {
-	minute int32
-	filled bool
-	stats  probeAggregate
-}
-
-// probeAggregate accumulates successful response stats and total sample counts.
-type probeAggregate struct {
-	sumUs        int64
-	minUs        int64
-	maxUs        int64
-	totalCount   int64
-	successCount int64
-}
-
-func newProbeManager() *ProbeManager {
-	return &ProbeManager{
-		probes:     make(map[string]*probeTask),
-		httpClient: &http.Client{Timeout: 10 * time.Second},
-	}
-}
-
-func newProbeTask(config probe.Config) *probeTask {
-	return &probeTask{
-		config:  config,
-		cancel:  make(chan struct{}),
-		samples: make([]probeSample, 0, 64),
-	}
-}
-
-func newProbeTaskFromExisting(config probe.Config, existing *probeTask) *probeTask {
-	task := newProbeTask(config)
-	if existing == nil {
-		return task
-	}
-
-	existing.mu.Lock()
-	defer existing.mu.Unlock()
-	task.samples = append(task.samples, existing.samples...)
-	task.buckets = existing.buckets
-	return task
-}
-
-// newProbeAggregate initializes an aggregate with an unset minimum value.
-func newProbeAggregate() probeAggregate {
-	return probeAggregate{minUs: math.MaxInt64}
-}
-
-// addResponse folds a single probe sample into the aggregate.
-func (agg *probeAggregate) addResponse(responseUs int64) {
-	agg.totalCount++
-	if responseUs < 0 {
-		return
-	}
-	agg.successCount++
-	agg.sumUs += responseUs
-	if responseUs < agg.minUs {
-		agg.minUs = responseUs
-	}
-	if responseUs > agg.maxUs {
-		agg.maxUs = responseUs
-	}
-}
-
-// addAggregate merges another aggregate into this one.
-func (agg *probeAggregate) addAggregate(other probeAggregate) {
-	if other.totalCount == 0 {
-		return
-	}
-	agg.totalCount += other.totalCount
-	agg.successCount += other.successCount
-	agg.sumUs += other.sumUs
-	if other.successCount == 0 {
-		return
-	}
-	if agg.minUs == math.MaxInt64 || other.minUs < agg.minUs {
-		agg.minUs = other.minUs
-	}
-	if other.maxUs > agg.maxUs {
-		agg.maxUs = other.maxUs
-	}
-}
-
-// hasData reports whether the aggregate contains any samples.
-func (agg probeAggregate) hasData() bool {
-	return agg.totalCount > 0
-}
-
-// result converts the aggregate into the probe result slice format.
-func (agg probeAggregate) result() probe.Result {
-	avg := agg.avgResponse()
-	minUs := 0.0
-	if agg.successCount > 0 {
-		minUs = float64(agg.minUs)
-	}
-	return probe.Result{
-		avg,
-		minUs,
-		float64(agg.maxUs),
-		agg.lossPercentage(),
-	}
-}
-
-// avgResponse returns the rounded average of successful samples.
-func (agg probeAggregate) avgResponse() float64 {
-	if agg.successCount == 0 {
-		return 0
-	}
-	return float64(agg.sumUs / agg.successCount)
-
-}
-
-// lossPercentage returns the rounded failure rate for the aggregate.
-func (agg probeAggregate) lossPercentage() float64 {
-	if agg.totalCount == 0 {
-		return 0
-	}
-	return math.Round(float64(agg.totalCount-agg.successCount)/float64(agg.totalCount)*10000) / 100
-}
-
-// SyncProbes replaces all probe tasks with the given configs.
-func (pm *ProbeManager) SyncProbes(configs []probe.Config) {
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-
-	// Build set of new keys
-	newKeys := make(map[string]probe.Config, len(configs))
-	for _, cfg := range configs {
-		if cfg.ID == "" {
-			continue
-		}
-		newKeys[cfg.ID] = cfg
-	}
-
-	// Stop removed probes
-	for key, task := range pm.probes {
-		if _, exists := newKeys[key]; !exists {
-			close(task.cancel)
-			delete(pm.probes, key)
-		}
-	}
-
-	// Start new probes and restart tasks whose config changed.
-	for key, cfg := range newKeys {
-		task, exists := pm.probes[key]
-		if exists && task.config == cfg {
-			continue
-		}
-		if exists {
-			close(task.cancel)
-		}
-		task = newProbeTaskFromExisting(cfg, task)
-		pm.probes[key] = task
-		go pm.runProbe(task, false)
-	}
-}
-
-// HandleSyncRequest applies a full or incremental probe sync request.
-func (pm *ProbeManager) HandleSyncRequest(req probe.SyncRequest) (probe.SyncResponse, error) {
-	switch req.Action {
-	case probe.SyncActionReplace:
-		pm.SyncProbes(req.Configs)
-		return probe.SyncResponse{}, nil
-	case probe.SyncActionUpsert:
-		result, err := pm.UpsertProbe(req.Config, req.RunNow)
-		if err != nil {
-			return probe.SyncResponse{}, err
-		}
-		if result == nil {
-			return probe.SyncResponse{}, nil
-		}
-		return probe.SyncResponse{Result: *result}, nil
-	case probe.SyncActionDelete:
-		if req.Config.ID == "" {
-			return probe.SyncResponse{}, errors.New("missing probe ID for delete")
-		}
-		pm.DeleteProbe(req.Config.ID)
-		return probe.SyncResponse{}, nil
-	default:
-		return probe.SyncResponse{}, fmt.Errorf("unknown probe sync action: %d", req.Action)
-	}
-}
-
-// UpsertProbe creates or replaces a single probe task.
-func (pm *ProbeManager) UpsertProbe(config probe.Config, runNow bool) (*probe.Result, error) {
-	if config.ID == "" {
-		return nil, errors.New("missing probe ID")
-	}
-
-	pm.mu.Lock()
-	task, exists := pm.probes[config.ID]
-	startTask := false
-	if exists && task.config == config {
-		pm.mu.Unlock()
-		if !runNow {
-			return nil, nil
-		}
-		return pm.runProbeNow(task), nil
-	}
-	if exists {
-		close(task.cancel)
-	}
-	task = newProbeTaskFromExisting(config, task)
-	pm.probes[config.ID] = task
-	startTask = true
-	pm.mu.Unlock()
-
-	if runNow {
-		result := pm.runProbeNow(task)
-		if startTask {
-			go pm.runProbe(task, false)
-		}
-		return result, nil
-	}
-	if startTask {
-		go pm.runProbe(task, false)
-	}
-	return nil, nil
-}
-
-// DeleteProbe stops and removes a single probe task.
-func (pm *ProbeManager) DeleteProbe(id string) {
-	if id == "" {
-		return
-	}
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-	if task, exists := pm.probes[id]; exists {
-		close(task.cancel)
-		delete(pm.probes, id)
-	}
-}
-
-// GetResults returns aggregated results for all probes over the last supplied duration in ms.
-func (pm *ProbeManager) GetResults(durationMs uint16) map[string]probe.Result {
-	pm.mu.RLock()
-	defer pm.mu.RUnlock()
-
-	results := make(map[string]probe.Result, len(pm.probes))
-	now := time.Now()
-	duration := time.Duration(durationMs) * time.Millisecond
-
-	for _, task := range pm.probes {
-		task.mu.Lock()
-		result, ok := task.resultLocked(duration, now)
-		task.mu.Unlock()
-
-		if !ok {
-			continue
-		}
-		results[task.config.ID] = result
-	}
-
-	return results
-}
-
-// Stop stops all probe tasks.
-func (pm *ProbeManager) Stop() {
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-	for key, task := range pm.probes {
-		close(task.cancel)
-		delete(pm.probes, key)
-	}
-}
-
-// runProbe executes a single probe task in a loop.
-func (pm *ProbeManager) runProbe(task *probeTask, runNow bool) {
-	interval := time.Duration(task.config.Interval) * time.Second
-	if interval < time.Second {
-		interval = 30 * time.Second
-	}
-
-	stagger := getStagger(interval.Milliseconds())
-	slog.Info("starting probe task", "id", task.config.ID, "initial_delay", stagger.String(), "interval", interval.String())
-
-	if runNow {
-		pm.executeProbe(task)
-	}
-
-	select {
-	case <-task.cancel:
-		slog.Info("removed probe", "id", task.config.ID)
-		return
-	case <-time.After(stagger):
-		slog.Info("initial probe execution", "id", task.config.ID)
-		pm.executeProbe(task)
-	}
-
-	ticker := time.Tick(interval)
-
-	for {
-		select {
-		case <-task.cancel:
-			slog.Info("removed probe", "id", task.config.ID)
-			return
-		case <-ticker:
-			slog.Info("running probe in main loop", "id", task.config.ID, "interval", interval.String())
-			pm.executeProbe(task)
-		}
-	}
-}
-
-// getStagger returns a random duration between intervalSeconds/2 and intervalSeconds to stagger probe executions
-func getStagger(intervalMilli int64) time.Duration {
-	intervalMilliInt := int(intervalMilli)
-	randomDelayInt := rand.Intn(intervalMilliInt)
-	if randomDelayInt < intervalMilliInt/2 {
-		randomDelayInt += intervalMilliInt / 2
-	}
-	return time.Duration(randomDelayInt) * time.Millisecond
-}
-
-func (pm *ProbeManager) runProbeNow(task *probeTask) *probe.Result {
-	pm.executeProbe(task)
-	task.mu.Lock()
-	defer task.mu.Unlock()
-	result, ok := task.resultLocked(time.Minute, time.Now())
-	if !ok {
-		return nil
-	}
-	return &result
-}
-
-// aggregateLocked collects probe data for the requested time window.
-func (task *probeTask) aggregateLocked(duration time.Duration, now time.Time) probeAggregate {
-	cutoff := now.Add(-duration)
-	// Keep short windows exact; longer windows read from minute buckets to avoid raw-sample retention.
-	if duration <= probeRawRetention {
-		return aggregateSamplesSince(task.samples, cutoff)
-	}
-	return aggregateBucketsSince(task.buckets[:], cutoff, now)
-}
-
-// resultLocked returns the aggregated probe result for the requested duration along with a bool indicating whether any data was available.
-func (task *probeTask) resultLocked(duration time.Duration, now time.Time) (probe.Result, bool) {
-	agg := task.aggregateLocked(duration, now)
-	hourAgg := task.aggregateLocked(time.Hour, now)
-	if !agg.hasData() {
-		return nil, false
-	}
-
-	result := agg.result()
-
-	res := result[0]
-	res1h := hourAgg.avgResponse()
-	resMin := result[1]
-	resMin1h := float64(hourAgg.minUs)
-	resMax := result[2]
-	resMax1h := float64(hourAgg.maxUs)
-	loss := result[3]
-	loss1h := hourAgg.lossPercentage()
-
-	if hourAgg.successCount == 0 {
-		resMin1h, resMax1h = 0, 0
-	}
-	return probe.Result{
-		res,
-		res1h,
-		resMin,
-		resMin1h,
-		resMax,
-		resMax1h,
-		loss,
-		loss1h,
-	}, true
-}
-
-// aggregateSamplesSince aggregates raw samples newer than the cutoff.
-func aggregateSamplesSince(samples []probeSample, cutoff time.Time) probeAggregate {
-	agg := newProbeAggregate()
-	for _, sample := range samples {
-		if sample.timestamp.Before(cutoff) {
-			continue
-		}
-		agg.addResponse(sample.responseUs)
-	}
-	return agg
-}
-
-// aggregateBucketsSince aggregates minute buckets overlapping the requested window.
-func aggregateBucketsSince(buckets []probeBucket, cutoff, now time.Time) probeAggregate {
-	agg := newProbeAggregate()
-	startMinute := int32(cutoff.Unix() / 60)
-	endMinute := int32(now.Unix() / 60)
-	for _, bucket := range buckets {
-		if !bucket.filled || bucket.minute < startMinute || bucket.minute > endMinute {
-			continue
-		}
-		agg.addAggregate(bucket.stats)
-	}
-	return agg
-}
-
-// addSampleLocked stores a fresh sample in both raw and per-minute retention buffers.
-func (task *probeTask) addSampleLocked(sample probeSample) {
-	cutoff := sample.timestamp.Add(-probeRawRetention)
-	start := 0
-	for i := range task.samples {
-		if !task.samples[i].timestamp.Before(cutoff) {
-			start = i
-			break
-		}
-		if i == len(task.samples)-1 {
-			start = len(task.samples)
-		}
-	}
-	if start > 0 {
-		size := copy(task.samples, task.samples[start:])
-		task.samples = task.samples[:size]
-	}
-	task.samples = append(task.samples, sample)
-
-	minute := int32(sample.timestamp.Unix() / 60)
-	// Each slot stores one wall-clock minute, so the ring stays fixed-size at ~1h per probe.
-	bucket := &task.buckets[minute%probeMinuteBucketLen]
-	if !bucket.filled || bucket.minute != minute {
-		bucket.minute = minute
-		bucket.filled = true
-		bucket.stats = newProbeAggregate()
-	}
-	bucket.stats.addResponse(sample.responseUs)
-}
-
-// executeProbe runs the configured probe and records the sample.
-func (pm *ProbeManager) executeProbe(task *probeTask) {
-	var responseUs int64
-
-	switch task.config.Protocol {
-	case "icmp":
-		responseUs = probeICMP(task.config.Target)
-	case "tcp":
-		responseUs = probeTCP(task.config.Target, task.config.Port)
-	case "http":
-		responseUs = probeHTTP(pm.httpClient, task.config.Target)
-	default:
-		slog.Warn("unknown probe protocol", "protocol", task.config.Protocol)
-		return
-	}
-
-	sample := probeSample{
-		responseUs: responseUs,
-		timestamp:  time.Now(),
-	}
-
-	task.mu.Lock()
-	task.addSampleLocked(sample)
-	task.mu.Unlock()
-}
-
-// probeTCP measures pure TCP handshake response (excluding DNS resolution).
-// Returns -1 on failure.
-func probeTCP(target string, port uint16) int64 {
-	// Resolve DNS first, outside the timing window
-	ips, err := net.LookupHost(target)
-	if err != nil || len(ips) == 0 {
-		return -1
-	}
-	addr := net.JoinHostPort(ips[0], fmt.Sprintf("%d", port))
-
-	// Measure only the TCP handshake
-	start := time.Now()
-	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
-	if err != nil {
-		return -1
-	}
-	conn.Close()
-	return time.Since(start).Microseconds()
-}
-
-// probeHTTP measures HTTP GET request response in microseconds. Returns -1 on failure.
-func probeHTTP(client *http.Client, url string) int64 {
-	if client == nil {
-		client = http.DefaultClient
-	}
-	start := time.Now()
-	resp, err := client.Get(url)
-	if err != nil {
-		return -1
-	}
-	resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return -1
-	}
-	return time.Since(start).Microseconds()
-}

agent/probe_ping.go

@@ -1,243 +0,0 @@
-package agent
-
-import (
-	"math"
-	"net"
-	"os"
-	"os/exec"
-	"regexp"
-	"runtime"
-	"strconv"
-	"sync"
-	"time"
-
-	"golang.org/x/net/icmp"
-	"golang.org/x/net/ipv4"
-	"golang.org/x/net/ipv6"
-
-	"log/slog"
-)
-
-var pingTimeRegex = regexp.MustCompile(`time[=<]([\d.]+)\s*ms`)
-
-type icmpPacketConn interface {
-	Close() error
-}
-
-// icmpMethod tracks which ICMP approach to use. Once a method succeeds or
-// all native methods fail, the choice is cached so subsequent probes skip
-// the trial-and-error overhead.
-type icmpMethod int
-
-const (
-	icmpUntried      icmpMethod = iota // haven't tried yet
-	icmpRaw                            // privileged raw socket
-	icmpDatagram                       // unprivileged datagram socket
-	icmpExecFallback                   // shell out to system ping command
-)
-
-// icmpFamily holds the network parameters and cached detection result for one address family.
-type icmpFamily struct {
-	rawNetwork   string    // e.g. "ip4:icmp" or "ip6:ipv6-icmp"
-	dgramNetwork string    // e.g. "udp4" or "udp6"
-	listenAddr   string    // "0.0.0.0" or "::"
-	echoType     icmp.Type // outgoing echo request type
-	replyType    icmp.Type // expected echo reply type
-	proto        int       // IANA protocol number for parsing replies
-	isIPv6       bool
-	mode         icmpMethod // cached detection result (guarded by icmpModeMu)
-}
-
-var (
-	icmpV4 = icmpFamily{
-		rawNetwork:   "ip4:icmp",
-		dgramNetwork: "udp4",
-		listenAddr:   "0.0.0.0",
-		echoType:     ipv4.ICMPTypeEcho,
-		replyType:    ipv4.ICMPTypeEchoReply,
-		proto:        1,
-	}
-	icmpV6 = icmpFamily{
-		rawNetwork:   "ip6:ipv6-icmp",
-		dgramNetwork: "udp6",
-		listenAddr:   "::",
-		echoType:     ipv6.ICMPTypeEchoRequest,
-		replyType:    ipv6.ICMPTypeEchoReply,
-		proto:        58,
-		isIPv6:       true,
-	}
-	icmpModeMu sync.Mutex
-	icmpListen = func(network, listenAddr string) (icmpPacketConn, error) {
-		return icmp.ListenPacket(network, listenAddr)
-	}
-)
-
-// probeICMP sends an ICMP echo request and measures round-trip response.
-// Supports both IPv4 and IPv6 targets. The ICMP method (raw socket,
-// unprivileged datagram, or exec fallback) is detected once per address
-// family and cached for subsequent probes.
-// Returns response in microseconds, or -1 on failure.
-func probeICMP(target string) int64 {
-	family, ip := resolveICMPTarget(target)
-	if family == nil {
-		return -1
-	}
-
-	icmpModeMu.Lock()
-	if family.mode == icmpUntried {
-		family.mode = detectICMPMode(family, icmpListen)
-	}
-	mode := family.mode
-	icmpModeMu.Unlock()
-
-	switch mode {
-	case icmpRaw:
-		return probeICMPNative(family.rawNetwork, family, &net.IPAddr{IP: ip})
-	case icmpDatagram:
-		return probeICMPNative(family.dgramNetwork, family, &net.UDPAddr{IP: ip})
-	case icmpExecFallback:
-		return probeICMPExec(target, family.isIPv6)
-	default:
-		return -1
-	}
-}
-
-// resolveICMPTarget resolves a target hostname or IP to determine the address
-// family and concrete IP address. Prefers IPv4 for dual-stack hostnames.
-func resolveICMPTarget(target string) (*icmpFamily, net.IP) {
-	if ip := net.ParseIP(target); ip != nil {
-		if ip.To4() != nil {
-			return &icmpV4, ip.To4()
-		}
-		return &icmpV6, ip
-	}
-
-	ips, err := net.LookupIP(target)
-	if err != nil || len(ips) == 0 {
-		return nil, nil
-	}
-	for _, ip := range ips {
-		if v4 := ip.To4(); v4 != nil {
-			return &icmpV4, v4
-		}
-	}
-	return &icmpV6, ips[0]
-}
-
-func detectICMPMode(family *icmpFamily, listen func(network, listenAddr string) (icmpPacketConn, error)) icmpMethod {
-	label := "IPv4"
-	if family.isIPv6 {
-		label = "IPv6"
-	}
-
-	if conn, err := listen(family.rawNetwork, family.listenAddr); err == nil {
-		conn.Close()
-		slog.Info("ICMP probe using raw socket", "family", label)
-		return icmpRaw
-	} else {
-		slog.Debug("ICMP raw socket unavailable", "family", label, "err", err)
-	}
-
-	if conn, err := listen(family.dgramNetwork, family.listenAddr); err == nil {
-		conn.Close()
-		slog.Info("ICMP probe using unprivileged datagram socket", "family", label)
-		return icmpDatagram
-	} else {
-		slog.Debug("ICMP datagram socket unavailable", "family", label, "err", err)
-	}
-
-	slog.Info("ICMP probe falling back to system ping command", "family", label)
-	return icmpExecFallback
-}
-
-// probeICMPNative sends an ICMP echo request using Go's x/net/icmp package.
-func probeICMPNative(network string, family *icmpFamily, dst net.Addr) int64 {
-	conn, err := icmp.ListenPacket(network, family.listenAddr)
-	if err != nil {
-		return -1
-	}
-	defer conn.Close()
-
-	// Build ICMP echo request
-	msg := &icmp.Message{
-		Type: family.echoType,
-		Code: 0,
-		Body: &icmp.Echo{
-			ID:   os.Getpid() & 0xffff,
-			Seq:  1,
-			Data: []byte("beszel-probe"),
-		},
-	}
-	msgBytes, err := msg.Marshal(nil)
-	if err != nil {
-		return -1
-	}
-
-	// Set deadline before sending
-	conn.SetDeadline(time.Now().Add(3 * time.Second))
-
-	start := time.Now()
-	if _, err := conn.WriteTo(msgBytes, dst); err != nil {
-		return -1
-	}
-
-	// Read reply
-	buf := make([]byte, 1500)
-	for {
-		n, _, err := conn.ReadFrom(buf)
-		if err != nil {
-			return -1
-		}
-
-		reply, err := icmp.ParseMessage(family.proto, buf[:n])
-		if err != nil {
-			return -1
-		}
-
-		if reply.Type == family.replyType {
-			return time.Since(start).Microseconds()
-		}
-		// Ignore non-echo-reply messages (e.g. destination unreachable) and keep reading
-	}
-}
-
-// probeICMPExec falls back to the system ping command. Returns -1 on failure.
-func probeICMPExec(target string, isIPv6 bool) int64 {
-	var cmd *exec.Cmd
-	switch runtime.GOOS {
-	case "windows":
-		if isIPv6 {
-			cmd = exec.Command("ping", "-6", "-n", "1", "-w", "3000", target)
-		} else {
-			cmd = exec.Command("ping", "-n", "1", "-w", "3000", target)
-		}
-	default: // linux, darwin, freebsd
-		if isIPv6 {
-			cmd = exec.Command("ping", "-6", "-c", "1", "-W", "3", target)
-		} else {
-			cmd = exec.Command("ping", "-c", "1", "-W", "3", target)
-		}
-	}
-
-	start := time.Now()
-	output, err := cmd.Output()
-	if err != nil {
-		// If ping fails but we got output, still try to parse
-		if len(output) == 0 {
-			return -1
-		}
-	}
-
-	matches := pingTimeRegex.FindSubmatch(output)
-	if len(matches) >= 2 {
-		if ms, err := strconv.ParseFloat(string(matches[1]), 64); err == nil {
-			return int64(math.Round(ms * 1000))
-		}
-	}
-
-	// Fallback: use wall clock time if ping succeeded but parsing failed
-	if err == nil {
-		return time.Since(start).Microseconds()
-	}
-	return -1
-}

agent/probe_ping_test.go

@@ -1,118 +0,0 @@
-//go:build testing
-
-package agent
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-type testICMPPacketConn struct{}
-
-func (testICMPPacketConn) Close() error { return nil }
-
-func TestDetectICMPMode(t *testing.T) {
-	tests := []struct {
-		name         string
-		family       *icmpFamily
-		rawErr       error
-		udpErr       error
-		want         icmpMethod
-		wantNetworks []string
-	}{
-		{
-			name:         "IPv4 prefers raw socket when available",
-			family:       &icmpV4,
-			want:         icmpRaw,
-			wantNetworks: []string{"ip4:icmp"},
-		},
-		{
-			name:         "IPv4 uses datagram when raw unavailable",
-			family:       &icmpV4,
-			rawErr:       errors.New("operation not permitted"),
-			want:         icmpDatagram,
-			wantNetworks: []string{"ip4:icmp", "udp4"},
-		},
-		{
-			name:         "IPv4 falls back to exec when both unavailable",
-			family:       &icmpV4,
-			rawErr:       errors.New("operation not permitted"),
-			udpErr:       errors.New("protocol not supported"),
-			want:         icmpExecFallback,
-			wantNetworks: []string{"ip4:icmp", "udp4"},
-		},
-		{
-			name:         "IPv6 prefers raw socket when available",
-			family:       &icmpV6,
-			want:         icmpRaw,
-			wantNetworks: []string{"ip6:ipv6-icmp"},
-		},
-		{
-			name:         "IPv6 uses datagram when raw unavailable",
-			family:       &icmpV6,
-			rawErr:       errors.New("operation not permitted"),
-			want:         icmpDatagram,
-			wantNetworks: []string{"ip6:ipv6-icmp", "udp6"},
-		},
-		{
-			name:         "IPv6 falls back to exec when both unavailable",
-			family:       &icmpV6,
-			rawErr:       errors.New("operation not permitted"),
-			udpErr:       errors.New("protocol not supported"),
-			want:         icmpExecFallback,
-			wantNetworks: []string{"ip6:ipv6-icmp", "udp6"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			calls := make([]string, 0, 2)
-			listen := func(network, listenAddr string) (icmpPacketConn, error) {
-				require.Equal(t, tt.family.listenAddr, listenAddr)
-				calls = append(calls, network)
-				switch network {
-				case tt.family.rawNetwork:
-					if tt.rawErr != nil {
-						return nil, tt.rawErr
-					}
-				case tt.family.dgramNetwork:
-					if tt.udpErr != nil {
-						return nil, tt.udpErr
-					}
-				default:
-					t.Fatalf("unexpected network %q", network)
-				}
-				return testICMPPacketConn{}, nil
-			}
-
-			assert.Equal(t, tt.want, detectICMPMode(tt.family, listen))
-			assert.Equal(t, tt.wantNetworks, calls)
-		})
-	}
-}
-
-func TestResolveICMPTarget(t *testing.T) {
-	t.Run("IPv4 literal", func(t *testing.T) {
-		family, ip := resolveICMPTarget("127.0.0.1")
-		require.NotNil(t, family)
-		assert.False(t, family.isIPv6)
-		assert.Equal(t, "127.0.0.1", ip.String())
-	})
-
-	t.Run("IPv6 literal", func(t *testing.T) {
-		family, ip := resolveICMPTarget("::1")
-		require.NotNil(t, family)
-		assert.True(t, family.isIPv6)
-		assert.Equal(t, "::1", ip.String())
-	})
-
-	t.Run("IPv4-mapped IPv6 resolves as IPv4", func(t *testing.T) {
-		family, ip := resolveICMPTarget("::ffff:127.0.0.1")
-		require.NotNil(t, family)
-		assert.False(t, family.isIPv6)
-		assert.Equal(t, "127.0.0.1", ip.String())
-	})
-}

agent/probe_test.go

@@ -1,346 +0,0 @@
-package agent
-
-import (
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/probe"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestProbeTaskAggregateLockedUsesRawSamplesForShortWindows(t *testing.T) {
-	now := time.Date(2026, time.April, 21, 12, 0, 0, 0, time.UTC)
-	task := &probeTask{}
-
-	task.addSampleLocked(probeSample{responseUs: 10, timestamp: now.Add(-90 * time.Second)})
-	task.addSampleLocked(probeSample{responseUs: 20, timestamp: now.Add(-30 * time.Second)})
-	task.addSampleLocked(probeSample{responseUs: -1, timestamp: now.Add(-10 * time.Second)})
-
-	agg := task.aggregateLocked(time.Minute, now)
-	require.True(t, agg.hasData())
-	assert.Equal(t, int64(2), agg.totalCount)
-	assert.Equal(t, int64(1), agg.successCount)
-	assert.Equal(t, 20.0, agg.result()[0])
-	assert.Equal(t, 20.0, agg.result()[1])
-	assert.Equal(t, 20.0, agg.result()[2])
-	assert.Equal(t, 50.0, agg.result()[3])
-}
-
-func TestProbeTaskAggregateLockedUsesMinuteBucketsForLongWindows(t *testing.T) {
-	now := time.Date(2026, time.April, 21, 12, 0, 30, 0, time.UTC)
-	task := &probeTask{}
-
-	task.addSampleLocked(probeSample{responseUs: 10, timestamp: now.Add(-11 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 20, timestamp: now.Add(-9 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 40, timestamp: now.Add(-5 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: -1, timestamp: now.Add(-90 * time.Second)})
-	task.addSampleLocked(probeSample{responseUs: 30, timestamp: now.Add(-30 * time.Second)})
-
-	agg := task.aggregateLocked(10*time.Minute, now)
-	require.True(t, agg.hasData())
-	assert.Equal(t, int64(4), agg.totalCount)
-	assert.Equal(t, int64(3), agg.successCount)
-	assert.Equal(t, 30.0, agg.result()[0])
-	assert.Equal(t, 20.0, agg.result()[1])
-	assert.Equal(t, 40.0, agg.result()[2])
-	assert.Equal(t, 25.0, agg.result()[3])
-}
-
-func TestProbeTaskAddSampleLockedTrimsRawSamplesButKeepsBucketHistory(t *testing.T) {
-	now := time.Date(2026, time.April, 21, 12, 0, 0, 0, time.UTC)
-	task := &probeTask{}
-
-	task.addSampleLocked(probeSample{responseUs: 10, timestamp: now.Add(-10 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 20, timestamp: now})
-
-	require.Len(t, task.samples, 1)
-	assert.Equal(t, int64(20), task.samples[0].responseUs)
-
-	agg := task.aggregateLocked(10*time.Minute, now)
-	require.True(t, agg.hasData())
-	assert.Equal(t, int64(2), agg.totalCount)
-	assert.Equal(t, int64(2), agg.successCount)
-	assert.Equal(t, 15.0, agg.result()[0])
-	assert.Equal(t, 10.0, agg.result()[1])
-	assert.Equal(t, 20.0, agg.result()[2])
-	assert.Equal(t, 0.0, agg.result()[3])
-}
-
-func TestProbeManagerGetResultsIncludesHourResponseRange(t *testing.T) {
-	now := time.Now().UTC()
-	task := &probeTask{config: probe.Config{ID: "probe-1"}}
-	task.addSampleLocked(probeSample{responseUs: 10, timestamp: now.Add(-30 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 20, timestamp: now.Add(-9 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 40, timestamp: now.Add(-5 * time.Minute)})
-	task.addSampleLocked(probeSample{responseUs: 30, timestamp: now.Add(-50 * time.Second)})
-	task.addSampleLocked(probeSample{responseUs: -1, timestamp: now.Add(-30 * time.Second)})
-
-	pm := &ProbeManager{probes: map[string]*probeTask{"icmp:example.com": task}}
-
-	results := pm.GetResults(uint16(time.Minute / time.Millisecond))
-	result, ok := results["probe-1"]
-	require.True(t, ok)
-	require.Len(t, result, 6)
-	assert.Equal(t, 30.0, result[0])
-	assert.Equal(t, 25.0, result[1])
-	assert.Equal(t, 10.0, result[2])
-	assert.Equal(t, 40.0, result[3])
-	assert.Equal(t, 50.0, result[4])
-	assert.Equal(t, 20.0, result[5])
-}
-
-func TestProbeManagerGetResultsIncludesLossOnlyHourData(t *testing.T) {
-	now := time.Now().UTC()
-	task := &probeTask{config: probe.Config{ID: "probe-1"}}
-	task.addSampleLocked(probeSample{responseUs: -1, timestamp: now.Add(-30 * time.Second)})
-	task.addSampleLocked(probeSample{responseUs: -1, timestamp: now.Add(-10 * time.Second)})
-
-	pm := &ProbeManager{probes: map[string]*probeTask{"icmp:example.com": task}}
-
-	results := pm.GetResults(uint16(time.Minute / time.Millisecond))
-	result, ok := results["probe-1"]
-	require.True(t, ok)
-	require.Len(t, result, 6)
-	assert.Equal(t, 0.0, result[0])
-	assert.Equal(t, 0.0, result[1])
-	assert.Equal(t, 0.0, result[2])
-	assert.Equal(t, 0.0, result[3])
-	assert.Equal(t, 100.0, result[4])
-	assert.Equal(t, 100.0, result[5])
-}
-
-func TestProbeConfigResultKeyUsesSyncedID(t *testing.T) {
-	cfg := probe.Config{ID: "probe-1", Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
-	assert.Equal(t, "probe-1", cfg.ID)
-}
-
-func TestProbeManagerSyncProbesSkipsConfigsWithoutStableID(t *testing.T) {
-	validCfg := probe.Config{ID: "probe-1", Target: "ignored", Protocol: "noop", Interval: 10}
-	invalidCfg := probe.Config{Target: "ignored", Protocol: "noop", Interval: 10}
-
-	pm := newProbeManager()
-	pm.SyncProbes([]probe.Config{validCfg, invalidCfg})
-	defer pm.Stop()
-
-	_, validExists := pm.probes[validCfg.ID]
-	_, invalidExists := pm.probes[invalidCfg.ID]
-	assert.True(t, validExists)
-	assert.False(t, invalidExists)
-}
-
-func TestProbeManagerSyncProbesStopsRemovedTasksButKeepsExisting(t *testing.T) {
-	keepCfg := probe.Config{ID: "probe-1", Target: "ignored", Protocol: "noop", Interval: 10}
-	removeCfg := probe.Config{ID: "probe-2", Target: "ignored", Protocol: "noop", Interval: 10}
-
-	keptTask := &probeTask{config: keepCfg, cancel: make(chan struct{})}
-	removedTask := &probeTask{config: removeCfg, cancel: make(chan struct{})}
-	pm := &ProbeManager{
-		probes: map[string]*probeTask{
-			keepCfg.ID:   keptTask,
-			removeCfg.ID: removedTask,
-		},
-	}
-
-	pm.SyncProbes([]probe.Config{keepCfg})
-
-	assert.Same(t, keptTask, pm.probes[keepCfg.ID])
-	_, exists := pm.probes[removeCfg.ID]
-	assert.False(t, exists)
-
-	select {
-	case <-removedTask.cancel:
-	default:
-		t.Fatal("expected removed probe task to be cancelled")
-	}
-
-	select {
-	case <-keptTask.cancel:
-		t.Fatal("expected existing probe task to remain active")
-	default:
-	}
-}
-
-func TestProbeManagerSyncProbesRestartsChangedConfig(t *testing.T) {
-	originalCfg := probe.Config{ID: "probe-1", Target: "ignored-a", Protocol: "noop", Interval: 10}
-	updatedCfg := probe.Config{ID: "probe-1", Target: "ignored-b", Protocol: "noop", Interval: 10}
-	originalTask := &probeTask{config: originalCfg, cancel: make(chan struct{})}
-	pm := &ProbeManager{
-		probes: map[string]*probeTask{
-			originalCfg.ID: originalTask,
-		},
-	}
-
-	pm.SyncProbes([]probe.Config{updatedCfg})
-	defer pm.Stop()
-
-	restartedTask := pm.probes[updatedCfg.ID]
-	assert.NotSame(t, originalTask, restartedTask)
-	assert.Equal(t, updatedCfg, restartedTask.config)
-
-	select {
-	case <-originalTask.cancel:
-	default:
-		t.Fatal("expected changed probe task to be cancelled")
-	}
-}
-
-func TestProbeManagerApplySyncUpsertRunsImmediatelyAndReturnsResult(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusNoContent)
-	}))
-	defer server.Close()
-
-	pm := &ProbeManager{
-		probes:     make(map[string]*probeTask),
-		httpClient: server.Client(),
-	}
-
-	resp, err := pm.HandleSyncRequest(probe.SyncRequest{
-		Action: probe.SyncActionUpsert,
-		Config: probe.Config{ID: "probe-1", Target: server.URL, Protocol: "http", Interval: 10},
-		RunNow: true,
-	})
-	defer pm.Stop()
-
-	require.NoError(t, err)
-	require.Len(t, resp.Result, 6)
-	assert.GreaterOrEqual(t, resp.Result[0], 0.0)
-	assert.Equal(t, 0.0, resp.Result[4])
-	assert.Equal(t, 0.0, resp.Result[5])
-
-	task := pm.probes["probe-1"]
-	require.NotNil(t, task)
-	task.mu.Lock()
-	defer task.mu.Unlock()
-	require.Len(t, task.samples, 1)
-}
-
-func TestProbeManagerUpsertProbeKeepsHistoryWhenOnlyIntervalChanges(t *testing.T) {
-	originalCfg := probe.Config{ID: "probe-1", Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
-	updatedCfg := probe.Config{ID: "probe-1", Target: "1.1.1.1", Protocol: "icmp", Interval: 30}
-	now := time.Now().UTC()
-
-	existingTask := &probeTask{config: originalCfg, cancel: make(chan struct{})}
-	existingTask.addSampleLocked(probeSample{responseUs: 12, timestamp: now.Add(-50 * time.Minute)})
-	existingTask.addSampleLocked(probeSample{responseUs: 24, timestamp: now.Add(-30 * time.Second)})
-
-	pm := &ProbeManager{
-		probes: map[string]*probeTask{originalCfg.ID: existingTask},
-	}
-
-	result, err := pm.UpsertProbe(updatedCfg, false)
-	defer pm.Stop()
-
-	require.NoError(t, err)
-	assert.Nil(t, result)
-
-	updatedTask := pm.probes[updatedCfg.ID]
-	require.NotNil(t, updatedTask)
-	assert.NotSame(t, existingTask, updatedTask)
-	assert.Equal(t, updatedCfg, updatedTask.config)
-
-	updatedTask.mu.Lock()
-	defer updatedTask.mu.Unlock()
-	require.Len(t, updatedTask.samples, 1)
-	assert.Equal(t, int64(24), updatedTask.samples[0].responseUs)
-
-	agg := updatedTask.aggregateLocked(time.Hour, now)
-	require.True(t, agg.hasData())
-	assert.Equal(t, int64(2), agg.totalCount)
-	assert.Equal(t, int64(2), agg.successCount)
-	assert.Equal(t, 18.0, agg.avgResponse())
-
-	select {
-	case <-existingTask.cancel:
-	default:
-		t.Fatal("expected original probe task to be cancelled")
-	}
-}
-
-func TestProbeManagerApplySyncDeleteRemovesTask(t *testing.T) {
-	config := probe.Config{ID: "probe-1", Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
-	task := &probeTask{config: config, cancel: make(chan struct{})}
-	pm := &ProbeManager{
-		probes: map[string]*probeTask{config.ID: task},
-	}
-
-	_, err := pm.HandleSyncRequest(probe.SyncRequest{
-		Action: probe.SyncActionDelete,
-		Config: probe.Config{ID: config.ID},
-	})
-
-	require.NoError(t, err)
-	_, exists := pm.probes[config.ID]
-	assert.False(t, exists)
-
-	select {
-	case <-task.cancel:
-	default:
-		t.Fatal("expected deleted probe task to be cancelled")
-	}
-}
-
-func TestProbeManagerGetRandomDelay(t *testing.T) {
-	for i := 1000; i < 360_000; i += 1000 {
-		delay := getStagger(int64(i))
-		assert.GreaterOrEqual(t, delay, time.Duration(i/2)*time.Millisecond)
-		assert.LessOrEqual(t, delay, time.Duration(i)*time.Millisecond)
-	}
-}
-
-func TestProbeHTTP(t *testing.T) {
-	t.Run("success", func(t *testing.T) {
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.WriteHeader(http.StatusNoContent)
-		}))
-		defer server.Close()
-
-		responseUs := probeHTTP(server.Client(), server.URL)
-		assert.GreaterOrEqual(t, responseUs, int64(0))
-	})
-
-	t.Run("server error", func(t *testing.T) {
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			http.Error(w, "boom", http.StatusInternalServerError)
-		}))
-		defer server.Close()
-
-		assert.Equal(t, int64(-1), probeHTTP(server.Client(), server.URL))
-	})
-}
-
-func TestProbeTCP(t *testing.T) {
-	t.Run("success", func(t *testing.T) {
-		listener, err := net.Listen("tcp", "127.0.0.1:0")
-		require.NoError(t, err)
-		defer listener.Close()
-
-		accepted := make(chan struct{})
-		go func() {
-			defer close(accepted)
-			conn, err := listener.Accept()
-			if err == nil {
-				_ = conn.Close()
-			}
-		}()
-
-		port := uint16(listener.Addr().(*net.TCPAddr).Port)
-		responseUs := probeTCP("127.0.0.1", port)
-		assert.GreaterOrEqual(t, responseUs, int64(0))
-		<-accepted
-	})
-
-	t.Run("connection failure", func(t *testing.T) {
-		listener, err := net.Listen("tcp", "127.0.0.1:0")
-		require.NoError(t, err)
-
-		port := uint16(listener.Addr().(*net.TCPAddr).Port)
-		require.NoError(t, listener.Close())
-
-		assert.Equal(t, int64(-1), probeTCP("127.0.0.1", port))
-	})
-}

go.mod

@@ -1,27 +1,27 @@
 module github.com/henrygd/beszel
 
-go 1.26.1
+go 1.26.3
 
 require (
 	github.com/blang/semver v3.5.1+incompatible
 	github.com/coreos/go-systemd/v22 v22.7.0
-	github.com/ebitengine/purego v0.10.0
-	github.com/fxamacker/cbor/v2 v2.9.0
+	github.com/ebitengine/purego v0.10.2
+	github.com/fxamacker/cbor/v2 v2.9.2
 	github.com/gliderlabs/ssh v0.3.8
 	github.com/google/uuid v1.6.0
-	github.com/lxzan/gws v1.9.1
-	github.com/nicholas-fedor/shoutrrr v0.14.3
+	github.com/lxzan/gws v1.10.1
+	github.com/nicholas-fedor/shoutrrr v0.17.0
 	github.com/pocketbase/dbx v1.12.0
 	github.com/pocketbase/pocketbase v0.36.8
-	github.com/shirou/gopsutil/v4 v4.26.3
+	github.com/shirou/gopsutil/v4 v4.26.7
 	github.com/spf13/cast v1.10.0
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/pflag v1.0.10
 	github.com/stretchr/testify v1.11.1
-	golang.org/x/crypto v0.49.0
+	golang.org/x/crypto v0.54.0
 	golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90
-	golang.org/x/net v0.52.0
-	golang.org/x/sys v0.42.0
+	golang.org/x/net v0.57.0
+	golang.org/x/sys v0.47.0
 	gopkg.in/yaml.v3 v3.0.1
 	howett.net/plist v1.0.1
 )
@@ -46,8 +46,8 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/klauspost/compress v1.18.5 // indirect
 	github.com/lufia/plan9stats v0.0.0-20260324052639-156f7da3f749 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-colorable v0.1.15 // indirect
+	github.com/mattn/go-isatty v0.0.24 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
@@ -56,11 +56,11 @@ require (
 	github.com/tklauser/numcpus v0.11.0 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/image v0.38.0 // indirect
+	golang.org/x/image v0.41.0 // indirect
 	golang.org/x/oauth2 v0.36.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/term v0.41.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
+	golang.org/x/term v0.45.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
 	modernc.org/libc v1.70.0 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -1,7 +1,7 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
-github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=
+github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg=
@@ -21,24 +21,24 @@ github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCO
 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU=
-github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitengine/purego v0.10.2 h1:W809HbnvzAxgdm+aOvlSekrM16wGCdT/e76+9tS7gzE=
+github.com/ebitengine/purego v0.10.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/eclipse/paho.golang v0.23.0 h1:KHgl2wz6EJo7cMBmkuhpt7C576vP+kpPv7jjvSyR6Mk=
 github.com/eclipse/paho.golang v0.23.0/go.mod h1:nQRhTkoZv8EAiNs5UU0/WdQIx2NrnWUpL9nsGJTQN04=
 github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
 github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
-github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
+github.com/fxamacker/cbor/v2 v2.9.2 h1:X4Ksno9+x3cz0TZv69ec1hxP/+tymuR8PXQJyDwfh78=
+github.com/fxamacker/cbor/v2 v2.9.2/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
 github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM=
 github.com/gabriel-vasile/mimetype v1.4.13/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
 github.com/ganigeorgiev/fexpr v0.5.0 h1:XA9JxtTE/Xm+g/JFI6RfZEHSiQlk+1glLvRK1Lpv/Tk=
 github.com/ganigeorgiev/fexpr v0.5.0/go.mod h1:RyGiGqmeXhEQ6+mlGdnUleLHgtzzu/VGO2WtJkF5drE=
 github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
+github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -56,8 +56,8 @@ github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArs
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw=
-github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo=
+github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk=
 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/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
@@ -66,8 +66,8 @@ github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/jarcoal/httpmock v1.4.1 h1:0Ju+VCFuARfFlhVXFc2HxlcQkfB+Xq12/EotHko+x2A=
-github.com/jarcoal/httpmock v1.4.1/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
+github.com/jarcoal/httpmock v1.4.2 h1:dKwiP/9zITCPfBLsDn3kchbSOu16JrnxtVEmL0fPRcI=
+github.com/jarcoal/httpmock v1.4.2/go.mod h1:ftW1xULwo+j0R0JJkJIIi7UKigZUXCLLanykgjwBXL0=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
 github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
@@ -77,20 +77,20 @@ 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-20260324052639-156f7da3f749 h1:Qj3hTcdWH8uMZDI41HNuTuJN525C7NBrbtH5kSO6fPk=
 github.com/lufia/plan9stats v0.0.0-20260324052639-156f7da3f749/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
-github.com/lxzan/gws v1.9.1 h1:4lbIp4cW0hOLP3ejFHR/uWRy741AURx7oKkNNi2OT9o=
-github.com/lxzan/gws v1.9.1/go.mod h1:gXHSCPmTGryWJ4icuqy8Yho32E4YIMHH0fkDRYJRbdc=
-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/lxzan/gws v1.10.1 h1:1xG+tDOV0lgDeVPf0wNT74u3cn0K3LpcavRrTPTrMwQ=
+github.com/lxzan/gws v1.10.1/go.mod h1:gXHSCPmTGryWJ4icuqy8Yho32E4YIMHH0fkDRYJRbdc=
+github.com/mattn/go-colorable v0.1.15 h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY=
+github.com/mattn/go-colorable v0.1.15/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
+github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/nicholas-fedor/shoutrrr v0.14.3 h1:aBX2iw9a7jl5wfHd3bi9LnS5ucoYIy6KcLH9XVF+gig=
-github.com/nicholas-fedor/shoutrrr v0.14.3/go.mod h1:U7IywBkLpBV7rgn8iLbQ9/LklJG1gm24bFv5cXXsDKs=
-github.com/onsi/ginkgo/v2 v2.28.1 h1:S4hj+HbZp40fNKuLUQOYLDgZLwNUVn19N3Atb98NCyI=
-github.com/onsi/ginkgo/v2 v2.28.1/go.mod h1:CLtbVInNckU3/+gC8LzkGUb9oF+e8W8TdUsxPwvdOgE=
-github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28=
-github.com/onsi/gomega v1.39.1/go.mod h1:hL6yVALoTOxeWudERyfppUcZXjMwIMLnuSfruD2lcfg=
+github.com/nicholas-fedor/shoutrrr v0.17.0 h1:xfp3z5QbE8jXvUhUEwWDk47SJ/b912VoB8MJJDU+q4E=
+github.com/nicholas-fedor/shoutrrr v0.17.0/go.mod h1:s4ldyLs6uwBy9lIjYrY+8lyTqJtPvZSrILw0CyMLock=
+github.com/onsi/ginkgo/v2 v2.32.0 h1:Hw7s2pVrQo/8Yz5N77qdnpHaoc+c6cC9WIV1Jce+J6E=
+github.com/onsi/ginkgo/v2 v2.32.0/go.mod h1:+aXOY+vzZ5mu2iI2HpTZUPmM//oQfsNFX6gU9kNcA44=
+github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I=
+github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg=
 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=
@@ -105,8 +105,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v4 v4.26.3 h1:2ESdQt90yU3oXF/CdOlRCJxrP+Am1aBYubTMTfxJ1qc=
-github.com/shirou/gopsutil/v4 v4.26.3/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ=
+github.com/shirou/gopsutil/v4 v4.26.7 h1:IXzpHz/dkMRYAhKkOXr1HB6SuzWU3eoyyeWe7g3bNZc=
+github.com/shirou/gopsutil/v4 v4.26.7/go.mod h1:5O9FjBiXoTDFatIWjZZosqj4pV0DRtLx598xGbBehzM=
 github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
 github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
@@ -130,41 +130,41 @@ github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
 golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA=
 golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.38.0 h1:5l+q+Y9JDC7mBOMjo4/aPhMDcxEptsX+Tt3GgRQRPuE=
-golang.org/x/image v0.38.0/go.mod h1:/3f6vaXC+6CEanU4KJxbcUZyEePbyKbaLoDOe4ehFYY=
-golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
-golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
+golang.org/x/image v0.41.0 h1:8wS72eGJMJaBxK6okTzd4WaXumUlTVlb753MlsSvTCo=
+golang.org/x/image v0.41.0/go.mod h1:uIc348UZMSvS5Z65CVZ7iDPaNobNFEPeJ4kbqTOszmA=
+golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk=
+golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
-golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
+golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
+golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
 golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
 golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
-golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
+golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
 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.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
-golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
+golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
+golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

internal/common/common-ws.go

@@ -22,8 +22,6 @@ const (
 	GetSmartData
 	// Request detailed systemd service info from agent
 	GetSystemdInfo
-	// Sync network probe configuration to agent
-	SyncNetworkProbes
 	// Add new actions here...
 )
 

internal/entities/probe/probe.go

@@ -1,82 +0,0 @@
-package probe
-
-type SyncAction uint8
-
-const (
-	// SyncActionReplace indicates a full sync where the provided configs should replace all existing probes for the system.
-	SyncActionReplace SyncAction = iota
-	// SyncActionUpsert indicates an incremental sync where the provided config should be added or updated.
-	SyncActionUpsert
-	// SyncActionDelete indicates an incremental sync where the provided config should be removed.
-	SyncActionDelete
-)
-
-// Config defines a network probe task sent from hub to agent.
-type Config struct {
-	// ID is the stable network_probes record ID generated by the hub.
-	ID       string `cbor:"0,keyasint"`
-	Target   string `cbor:"1,keyasint"`
-	Protocol string `cbor:"2,keyasint"` // "icmp", "tcp", or "http"
-	Port     uint16 `cbor:"3,keyasint,omitempty"`
-	Interval uint16 `cbor:"4,keyasint"` // seconds
-}
-
-// SyncRequest defines an incremental or full probe sync request sent to the agent.
-type SyncRequest struct {
-	Action  SyncAction `cbor:"0,keyasint"`
-	Config  Config     `cbor:"1,keyasint,omitempty"`
-	Configs []Config   `cbor:"2,keyasint,omitempty"`
-	RunNow  bool       `cbor:"3,keyasint,omitempty"`
-}
-
-// SyncResponse returns the immediate result for an upsert when requested.
-type SyncResponse struct {
-	Result Result `cbor:"0,keyasint,omitempty"`
-}
-
-// Result holds aggregated probe results for a single target.
-//
-// 0: avg response in microseconds
-//
-// 1: 1h average response in microseconds
-//
-// 2: min response in microseconds
-//
-// 3: 1h min response in microseconds
-//
-// 4: max response in microseconds
-//
-// 5: 1h max response in microseconds
-//
-// 6: packet loss percentage (0-100)
-//
-// 7: 1h packet loss percentage (0-100)
-type Result []float64
-
-// Get returns the value at the specified index or 0 if the index is out of range.
-func (r Result) Get(index int) float64 {
-	if index < len(r) {
-		return r[index]
-	}
-	return 0
-}
-
-// Stats holds only 1m values for a single target, which are used for charts.
-//
-// 0: avg response in microseconds
-//
-// 1: min response in microseconds
-//
-// 2: max response in microseconds
-//
-// 3: packet loss percentage (0-100)
-type Stats []float64
-
-func (s Stats) FromResult(result Result) Stats {
-	return Stats{
-		result.Get(0), // avg response
-		result.Get(2), // min response
-		result.Get(4), // max response
-		result.Get(6), // packet loss
-	}
-}

internal/entities/system/system.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/entities/systemd"
 )
 
@@ -175,10 +174,9 @@ type Details struct {
 
 // Final data structure to return to the hub
 type CombinedData struct {
-	Stats           Stats                   `json:"stats" cbor:"0,keyasint"`
-	Info            Info                    `json:"info" cbor:"1,keyasint"`
-	Containers      []*container.Stats      `json:"container" cbor:"2,keyasint"`
-	SystemdServices []*systemd.Service      `json:"systemd,omitempty" cbor:"3,keyasint,omitempty"`
-	Details         *Details                `cbor:"4,keyasint,omitempty"`
-	Probes          map[string]probe.Result `cbor:"5,keyasint,omitempty"`
+	Stats           Stats              `json:"stats" cbor:"0,keyasint"`
+	Info            Info               `json:"info" cbor:"1,keyasint"`
+	Containers      []*container.Stats `json:"container" cbor:"2,keyasint"`
+	SystemdServices []*systemd.Service `json:"systemd,omitempty" cbor:"3,keyasint,omitempty"`
+	Details         *Details           `cbor:"4,keyasint,omitempty"`
 }

internal/hub/collections.go

@@ -78,7 +78,7 @@ func setCollectionAuthSettings(app core.App) error {
 		return err
 	}
 
-	if err := applyCollectionRules(app, []string{"containers", "container_stats", "system_stats", "systemd_services", "network_probe_stats"}, collectionRules{
+	if err := applyCollectionRules(app, []string{"containers", "container_stats", "system_stats", "systemd_services"}, collectionRules{
 		list: &systemScopedReadRule,
 	}); err != nil {
 		return err
@@ -92,7 +92,7 @@ func setCollectionAuthSettings(app core.App) error {
 		return err
 	}
 
-	if err := applyCollectionRules(app, []string{"fingerprints", "network_probes"}, collectionRules{
+	if err := applyCollectionRules(app, []string{"fingerprints"}, collectionRules{
 		list:   &systemScopedReadRule,
 		view:   &systemScopedReadRule,
 		create: &systemScopedWriteRule,

internal/hub/hub.go

@@ -81,7 +81,6 @@ func (h *Hub) StartHub() error {
 		}
 		// register middlewares
 		h.registerMiddlewares(e)
-		// bind events that aren't set up in different
 		// register api routes
 		if err := h.registerApiRoutes(e); err != nil {
 			return err
@@ -110,8 +109,6 @@ func (h *Hub) StartHub() error {
 	h.App.OnRecordCreate("users").BindFunc(h.um.InitializeUserRole)
 	h.App.OnRecordCreate("user_settings").BindFunc(h.um.InitializeUserSettings)
 
-	bindNetworkProbesEvents(h)
-
 	pb, ok := h.App.(*pocketbase.PocketBase)
 	if !ok {
 		return errors.New("not a pocketbase app")

internal/hub/probes.go

@@ -1,145 +0,0 @@
-package hub
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/henrygd/beszel/internal/entities/probe"
-	"github.com/henrygd/beszel/internal/hub/systems"
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/types"
-)
-
-// generateProbeID creates a stable hash ID for a probe based on its configuration and the system it belongs to.
-func generateProbeID(systemId string, config probe.Config) string {
-	return systems.MakeStableHashId(systemId, config.Target, config.Protocol, strconv.FormatUint(uint64(config.Port), 10))
-}
-
-// bindNetworkProbesEvents keeps probe records and agent probe state in sync.
-func bindNetworkProbesEvents(hub *Hub) {
-	// on create, make sure the id is set to a stable hash
-	hub.OnRecordCreate("network_probes").BindFunc(func(e *core.RecordEvent) error {
-		systemID := e.Record.GetString("system")
-		config := probeConfigFromRecord(e.Record)
-		id := generateProbeID(systemID, *config)
-		e.Record.Set("id", id)
-		return e.Next()
-	})
-
-	// sync probe to agent on creation and persist the first result immediately when available
-	hub.OnRecordAfterCreateSuccess("network_probes").BindFunc(func(e *core.RecordEvent) error {
-		err := e.Next()
-		if err != nil {
-			return err
-		}
-		if !e.Record.GetBool("enabled") {
-			return nil
-		}
-		// if system connected, run the probe immediately
-		// if not, return and wait for the system to connect and sync probes on reg schedule
-		system, err := hub.sm.GetSystem(e.Record.GetString("system"))
-		if err == nil && system.Status == "up" {
-			go hub.upsertNetworkProbe(e.Record, true)
-		}
-		return err
-	})
-
-	// On API update requests, if the probe config changed in a way that requires a new ID, create a new
-	// record with the new ID and delete the old one. Otherwise, just update the existing probe on the agent.
-	hub.OnRecordUpdateRequest("network_probes").BindFunc(func(e *core.RecordRequestEvent) error {
-		systemID := e.Record.GetString("system")
-		ID := generateProbeID(systemID, *probeConfigFromRecord(e.Record))
-		if ID != e.Record.Id {
-			newRecord := copyProbeToNewRecord(e.Record, ID)
-			if err := e.App.Save(newRecord); err != nil {
-				return err
-			}
-			if err := e.App.Delete(e.Record); err != nil {
-				return err
-			}
-			return nil
-		}
-		err := e.Next()
-		if e.Record.GetBool("enabled") {
-			// if the probe is enabled, sync the updated config to the agent now
-			runNow := !e.Record.Original().GetBool("enabled")
-			err = hub.upsertNetworkProbe(e.Record, runNow)
-		} else {
-			// if the probe is paused, remove it from the agent
-			err = hub.deleteNetworkProbe(e.Record)
-		}
-		if err != nil {
-			hub.Logger().Warn("failed to sync updated probe", "system", systemID, "probe", e.Record.Id, "err", err)
-		}
-		return nil
-	})
-
-	// sync probe to agent on delete
-	hub.OnRecordAfterDeleteSuccess("network_probes").BindFunc(func(e *core.RecordEvent) error {
-		if err := hub.deleteNetworkProbe(e.Record); err != nil {
-			hub.Logger().Warn("failed to delete probe on agent", "system", e.Record.GetString("system"), "probe", e.Record.Id, "err", err)
-		}
-		return e.Next()
-	})
-}
-
-// probeConfigFromRecord builds a probe config from a network_probes record.
-func probeConfigFromRecord(record *core.Record) *probe.Config {
-	return &probe.Config{
-		ID:       record.Id,
-		Target:   record.GetString("target"),
-		Protocol: record.GetString("protocol"),
-		Port:     uint16(record.GetInt("port")),
-		Interval: uint16(record.GetInt("interval")),
-	}
-}
-
-// setProbeResultFields stores the latest probe result values on the record.
-func setProbeResultFields(record *core.Record, result probe.Result) {
-	now := time.Now().UTC()
-	nowString := now.Format(types.DefaultDateLayout)
-	record.Set("res", result.Get(0))
-	record.Set("resAvg1h", result.Get(1))
-	record.Set("resMin1h", result.Get(3))
-	record.Set("resMax1h", result.Get(5))
-	// record.Set("loss", result.Get(4))
-	record.Set("loss1h", result.Get(7))
-	record.Set("updated", nowString)
-}
-
-// copyProbeToNewRecord creates a new record with the same field values as the old one.
-// This is used when the probe config changes in a way that requires a new ID, so we need
-// to create a new record with the new ID and delete the old one.
-func copyProbeToNewRecord(oldRecord *core.Record, newID string) *core.Record {
-	collection := oldRecord.Collection()
-	newRecord := core.NewRecord(collection)
-	newRecord.Load(oldRecord.FieldsData())
-	newRecord.Set("id", newID)
-	return newRecord
-}
-
-// upsertNetworkProbe creates or updates the record's probe on the target system. If runNow
-// is true, it will also trigger an immediate probe run and update the record with the result.
-func (h *Hub) upsertNetworkProbe(record *core.Record, runNow bool) error {
-	systemID := record.GetString("system")
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return err
-	}
-	result, err := system.UpsertNetworkProbe(*probeConfigFromRecord(record), runNow)
-	if err != nil || result == nil {
-		return err
-	}
-	setProbeResultFields(record, *result)
-	return h.App.SaveNoValidate(record)
-}
-
-// deleteNetworkProbe removes the record's probe from the target system.
-func (h *Hub) deleteNetworkProbe(record *core.Record) error {
-	systemID := record.GetString("system")
-	system, err := h.sm.GetSystem(systemID)
-	if err != nil {
-		return err
-	}
-	return system.DeleteNetworkProbe(record.Id)
-}

internal/hub/probes_test.go

@@ -1,101 +0,0 @@
-package hub
-
-import (
-	"testing"
-
-	"github.com/henrygd/beszel/internal/entities/probe"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGenerateProbeID(t *testing.T) {
-	tests := []struct {
-		name     string
-		systemID string
-		config   probe.Config
-		expected string
-	}{
-		{
-			name:     "HTTP probe on example.com",
-			systemID: "sys123",
-			config: probe.Config{
-				Protocol: "http",
-				Target:   "example.com",
-				Port:     80,
-				Interval: 60,
-			},
-			expected: "de7b3647",
-		},
-		{
-			name:     "HTTP probe on example.com with different system ID",
-			systemID: "sys1234",
-			config: probe.Config{
-				Protocol: "http",
-				Target:   "example.com",
-				Port:     80,
-				Interval: 60,
-			},
-			expected: "be9e2707",
-		},
-		{
-			name:     "Same probe, different interval",
-			systemID: "sys1234",
-			config: probe.Config{
-				Protocol: "http",
-				Target:   "example.com",
-				Port:     80,
-				Interval: 120,
-			},
-			expected: "be9e2707",
-		},
-		{
-			name:     "ICMP probe on 1.1.1.1",
-			systemID: "sys456",
-			config: probe.Config{
-				Protocol: "icmp",
-				Target:   "1.1.1.1",
-				Port:     0,
-				Interval: 10,
-			},
-			expected: "49ec14fc",
-		}, {
-			name:     "ICMP probe on 1.1.1.1 with different system ID",
-			systemID: "sys4567",
-			config: probe.Config{
-				Protocol: "icmp",
-				Target:   "1.1.1.1",
-				Port:     0,
-				Interval: 10,
-			},
-			expected: "84921aa3",
-		},
-		{
-			name:     "TCP probe on example.com with port 443",
-			systemID: "sys789",
-			config: probe.Config{
-				Protocol: "tcp",
-				Target:   "example.com",
-				Port:     443,
-				Interval: 30,
-			},
-			expected: "677b991",
-		},
-		{
-			name:     "TCP probe on example.com with port 8443",
-			systemID: "sys789",
-			config: probe.Config{
-				Protocol: "tcp",
-				Target:   "example.com",
-				Port:     8443,
-				Interval: 30,
-			},
-			expected: "84167969",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := generateProbeID(tt.systemID, tt.config)
-			assert.Equal(t, tt.expected, got, "generateProbeID() = %v, want %v", got, tt.expected)
-		})
-	}
-}

internal/hub/systems/system.go

@@ -18,7 +18,6 @@ import (
 	"github.com/henrygd/beszel/internal/hub/ws"
 
 	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/entities/smart"
 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/henrygd/beszel/internal/entities/systemd"
@@ -30,8 +29,6 @@ import (
 	"github.com/lxzan/gws"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/security"
-	"github.com/pocketbase/pocketbase/tools/types"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -241,12 +238,6 @@ func (sys *System) createRecords(data *system.CombinedData) (*core.Record, error
 			}
 		}
 
-		if data.Probes != nil {
-			if err := updateNetworkProbesRecords(txApp, data.Probes, sys.Id); err != nil {
-				return err
-			}
-		}
-
 		// update system record (do this last because it triggers alerts and we need above records to be inserted first)
 		systemRecord.Set("status", up)
 		systemRecord.Set("info", data.Info)
@@ -298,7 +289,7 @@ func createSystemdStatsRecords(app core.App, data []*systemd.Service, systemId s
 	for i, service := range data {
 		suffix := fmt.Sprintf("%d", i)
 		valueStrings = append(valueStrings, fmt.Sprintf("({:id%[1]s}, {:system}, {:name%[1]s}, {:state%[1]s}, {:sub%[1]s}, {:cpu%[1]s}, {:cpuPeak%[1]s}, {:memory%[1]s}, {:memPeak%[1]s}, {:updated})", suffix))
-		params["id"+suffix] = MakeStableHashId(systemId, service.Name)
+		params["id"+suffix] = makeStableHashId(systemId, service.Name)
 		params["name"+suffix] = service.Name
 		params["state"+suffix] = service.State
 		params["sub"+suffix] = service.Sub
@@ -315,97 +306,6 @@ func createSystemdStatsRecords(app core.App, data []*systemd.Service, systemId s
 	return err
 }
 
-func updateNetworkProbesRecords(app core.App, probeResults map[string]probe.Result, systemId string) error {
-	if len(probeResults) == 0 {
-		return nil
-	}
-	var err error
-	probeCollectionName := "network_probes"
-
-	// If realtime updates are active, we save via PocketBase records to trigger realtime events.
-	// Otherwise we can do a more efficient direct update via SQL
-	realtimeActive := utils.RealtimeActiveForCollection(app, probeCollectionName, func(filterQuery string) bool {
-		return !strings.Contains(filterQuery, "system") || strings.Contains(filterQuery, systemId)
-	})
-
-	now := time.Now().UTC()
-	nowMilli := now.UnixMilli()
-	nowString := now.Format(types.DefaultDateLayout)
-	var db dbx.Builder
-	var updateQuery *dbx.Query
-	if !realtimeActive {
-		db = app.DB()
-		probeFields := []string{"res", "resMin1h", "resMax1h", "resAvg1h", "loss1h", "updated"}
-		setClauses := make([]string, len(probeFields))
-		for i, f := range probeFields {
-			setClauses[i] = fmt.Sprintf("%s={:%s}", f, f)
-		}
-		queryString := fmt.Sprintf("UPDATE %s SET %s WHERE id={:id}", probeCollectionName, strings.Join(setClauses, ", "))
-		updateQuery = db.NewQuery(queryString)
-	}
-
-	// update network_probes records
-	for id, values := range probeResults {
-		probeData := map[string]any{
-			"id":       id,
-			"res":      values.Get(0),
-			"resAvg1h": values.Get(1),
-			"resMin1h": values.Get(3),
-			"resMax1h": values.Get(5),
-			"loss1h":   values.Get(7),
-			"updated":  nowString,
-		}
-		switch realtimeActive {
-		case true:
-			var record *core.Record
-			record, err = app.FindRecordById(probeCollectionName, id)
-			if err == nil {
-				record.Load(probeData)
-				err = app.SaveNoValidate(record)
-			}
-		default:
-			_, err = updateQuery.Bind(dbx.Params(probeData)).Execute()
-		}
-		if err != nil {
-			app.Logger().Warn("Failed to update probe", "system", systemId, "probe", id, "err", err)
-		}
-	}
-
-	// handle stats collection as well
-	statsCollectionName := "network_probe_stats"
-
-	// we don't need the hour values for the stats collection
-	stats := make(map[string]probe.Stats, len(probeResults))
-	for key, values := range probeResults {
-		stats[key] = probe.Stats{}.FromResult(values)
-	}
-
-	statsRecordData := map[string]any{
-		"system":  systemId,
-		"type":    "1m",
-		"created": nowMilli,
-	}
-	var statsJson types.JSONRaw
-	if err = statsJson.Scan(stats); err == nil {
-		statsRecordData["stats"] = statsJson
-		switch realtimeActive {
-		case true:
-			collection, _ := app.FindCachedCollectionByNameOrId(statsCollectionName)
-			record := core.NewRecord(collection)
-			record.Load(statsRecordData)
-			err = app.SaveNoValidate(record)
-		default:
-			statsRecordData["id"] = security.PseudorandomStringWithAlphabet(10, core.DefaultIdAlphabet)
-			_, err = db.Insert(statsCollectionName, dbx.Params(statsRecordData)).Execute()
-		}
-	}
-	if err != nil {
-		app.Logger().Error("Failed to update probe stats", "system", systemId, "err", err)
-	}
-
-	return nil
-}
-
 // createContainerRecords creates container records
 func createContainerRecords(app core.App, data []*container.Stats, systemId string) error {
 	if len(data) == 0 {
@@ -640,7 +540,7 @@ func (sys *System) FetchSmartDataFromAgent() (map[string]smart.SmartData, error)
 	return result, err
 }
 
-func MakeStableHashId(strings ...string) string {
+func makeStableHashId(strings ...string) string {
 	hash := fnv.New32a()
 	for _, str := range strings {
 		hash.Write([]byte(str))

internal/hub/systems/system_manager.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/henrygd/beszel/internal/hub/ws"
 
-	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/entities/system"
 	"github.com/henrygd/beszel/internal/hub/expirymap"
 
@@ -16,7 +15,6 @@ import (
 	"github.com/henrygd/beszel"
 
 	"github.com/blang/semver"
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/store"
 	"golang.org/x/crypto/ssh"
@@ -319,17 +317,6 @@ func (sm *SystemManager) AddWebSocketSystem(systemId string, agentVersion semver
 	if err := sm.AddRecord(systemRecord, system); err != nil {
 		return err
 	}
-
-	// Sync network probes to the newly connected agent
-	go func() {
-		configs := sm.GetProbeConfigsForSystem(systemId)
-		if len(configs) > 0 {
-			if err := system.SyncNetworkProbes(configs); err != nil {
-				sm.hub.Logger().Warn("failed to sync probes to agent", "system", systemId, "err", err)
-			}
-		}
-	}()
-
 	return nil
 }
 
@@ -342,16 +329,6 @@ func (sm *SystemManager) resetFailedSmartFetchState(systemID string) {
 	}
 }
 
-// GetProbeConfigsForSystem returns all enabled probe configs for a system.
-func (sm *SystemManager) GetProbeConfigsForSystem(systemID string) []probe.Config {
-	var configs []probe.Config
-	_ = sm.hub.DB().
-		NewQuery("SELECT id, target, protocol, port, interval FROM network_probes WHERE system = {:system} AND enabled = true").
-		Bind(dbx.Params{"system": systemID}).
-		All(&configs)
-	return configs
-}
-
 // createSSHClientConfig initializes the SSH client configuration for connecting to an agent's server
 func (sm *SystemManager) createSSHClientConfig() error {
 	privateKey, err := sm.hub.GetSSHKey("")

internal/hub/systems/system_probes.go

@@ -1,48 +0,0 @@
-package systems
-
-import (
-	"context"
-	"time"
-
-	"github.com/henrygd/beszel/internal/common"
-	"github.com/henrygd/beszel/internal/entities/probe"
-)
-
-// SyncNetworkProbes sends probe configurations to the agent.
-func (sys *System) SyncNetworkProbes(configs []probe.Config) error {
-	_, err := sys.syncNetworkProbes(probe.SyncRequest{Action: probe.SyncActionReplace, Configs: configs})
-	return err
-}
-
-// UpsertNetworkProbe sends a single probe configuration change to the agent.
-func (sys *System) UpsertNetworkProbe(config probe.Config, runNow bool) (*probe.Result, error) {
-	resp, err := sys.syncNetworkProbes(probe.SyncRequest{
-		Action: probe.SyncActionUpsert,
-		Config: config,
-		RunNow: runNow,
-	})
-	if err != nil {
-		return nil, err
-	}
-	if len(resp.Result) == 0 {
-		return nil, nil
-	}
-	result := resp.Result
-	return &result, nil
-}
-
-// DeleteNetworkProbe removes a single probe task from the agent.
-func (sys *System) DeleteNetworkProbe(id string) error {
-	_, err := sys.syncNetworkProbes(probe.SyncRequest{
-		Action: probe.SyncActionDelete,
-		Config: probe.Config{ID: id},
-	})
-	return err
-}
-
-func (sys *System) syncNetworkProbes(req probe.SyncRequest) (probe.SyncResponse, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	var result probe.SyncResponse
-	return result, sys.request(ctx, common.SyncNetworkProbes, req, &result)
-}

internal/hub/systems/system_smart.go

@@ -84,7 +84,7 @@ func (sys *System) saveSmartDevices(smartData map[string]smart.SmartData) error
 
 func (sys *System) upsertSmartDeviceRecord(collection *core.Collection, deviceKey string, device smart.SmartData) error {
 	hub := sys.manager.hub
-	recordID := MakeStableHashId(sys.Id, deviceKey)
+	recordID := makeStableHashId(sys.Id, deviceKey)
 
 	record, err := hub.FindRecordById(collection, recordID)
 	if err != nil {

internal/hub/systems/system_systemd_test.go

@@ -14,9 +14,9 @@ func TestGetSystemdServiceId(t *testing.T) {
 		serviceName := "nginx.service"
 
 		// Call multiple times and ensure same result
-		id1 := MakeStableHashId(systemId, serviceName)
-		id2 := MakeStableHashId(systemId, serviceName)
-		id3 := MakeStableHashId(systemId, serviceName)
+		id1 := makeStableHashId(systemId, serviceName)
+		id2 := makeStableHashId(systemId, serviceName)
+		id3 := makeStableHashId(systemId, serviceName)
 
 		assert.Equal(t, id1, id2)
 		assert.Equal(t, id2, id3)
@@ -29,10 +29,10 @@ func TestGetSystemdServiceId(t *testing.T) {
 		serviceName1 := "nginx.service"
 		serviceName2 := "apache.service"
 
-		id1 := MakeStableHashId(systemId1, serviceName1)
-		id2 := MakeStableHashId(systemId2, serviceName1)
-		id3 := MakeStableHashId(systemId1, serviceName2)
-		id4 := MakeStableHashId(systemId2, serviceName2)
+		id1 := makeStableHashId(systemId1, serviceName1)
+		id2 := makeStableHashId(systemId2, serviceName1)
+		id3 := makeStableHashId(systemId1, serviceName2)
+		id4 := makeStableHashId(systemId2, serviceName2)
 
 		// All IDs should be different
 		assert.NotEqual(t, id1, id2)
@@ -56,14 +56,14 @@ func TestGetSystemdServiceId(t *testing.T) {
 		}
 
 		for _, tc := range testCases {
-			id := MakeStableHashId(tc.systemId, tc.serviceName)
+			id := makeStableHashId(tc.systemId, tc.serviceName)
 			// FNV-32 produces 8 hex characters
 			assert.Len(t, id, 8, "ID should be 8 characters for systemId='%s', serviceName='%s'", tc.systemId, tc.serviceName)
 		}
 	})
 
 	t.Run("hexadecimal output", func(t *testing.T) {
-		id := MakeStableHashId("test-system", "test-service")
+		id := makeStableHashId("test-system", "test-service")
 		assert.NotEmpty(t, id)
 
 		// Should only contain hexadecimal characters

internal/hub/utils/utils.go

@@ -1,11 +1,7 @@
 // Package utils provides utility functions for the hub.
 package utils
 
-import (
-	"os"
-
-	"github.com/pocketbase/pocketbase/core"
-)
+import "os"
 
 // 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) {
@@ -14,26 +10,3 @@ func GetEnv(key string) (value string, exists bool) {
 	}
 	return os.LookupEnv(key)
 }
-
-// realtimeActiveForCollection checks if there are active WebSocket subscriptions for the given collection.
-func RealtimeActiveForCollection(app core.App, collectionName string, validateFn func(filterQuery string) bool) bool {
-	broker := app.SubscriptionsBroker()
-	if broker.TotalClients() == 0 {
-		return false
-	}
-	for _, client := range broker.Clients() {
-		subs := client.Subscriptions(collectionName)
-		if len(subs) > 0 {
-			if validateFn == nil {
-				return true
-			}
-			for k := range subs {
-				filter := subs[k].Query["filter"]
-				if validateFn(filter) {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}

internal/migrations/0_collections_snapshot_0_19_0_dev_1.go

@@ -1699,288 +1699,6 @@ func init() {
 		"type": "base",
 		"updateRule": null,
 		"viewRule": null
-	},
-	{
-		"createRule": null,
-		"deleteRule": null,
-		"fields": [
-			{
-				"autogeneratePattern": "[a-z0-9]{10}",
-				"hidden": false,
-				"id": "text3208210256",
-				"max": 10,
-				"min": 6,
-				"name": "id",
-				"pattern": "^[a-z0-9]+$",
-				"presentable": false,
-				"primaryKey": true,
-				"required": true,
-				"system": true,
-				"type": "text"
-			},
-			{
-				"cascadeDelete": true,
-				"collectionId": "2hz5ncl8tizk5nx",
-				"hidden": false,
-				"id": "np_system",
-				"maxSelect": 1,
-				"minSelect": 0,
-				"name": "system",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "relation"
-			},
-			{
-				"autogeneratePattern": "",
-				"hidden": false,
-				"id": "np_name",
-				"max": 200,
-				"min": 0,
-				"name": "name",
-				"pattern": "",
-				"presentable": false,
-				"primaryKey": false,
-				"required": false,
-				"system": false,
-				"type": "text"
-			},
-			{
-				"autogeneratePattern": "",
-				"hidden": false,
-				"id": "np_target",
-				"max": 500,
-				"min": 1,
-				"name": "target",
-				"pattern": "",
-				"presentable": false,
-				"primaryKey": false,
-				"required": true,
-				"system": false,
-				"type": "text"
-			},
-			{
-				"hidden": false,
-				"id": "np_protocol",
-				"maxSelect": 1,
-				"name": "protocol",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "select",
-				"values": [
-					"icmp",
-					"tcp",
-					"http"
-				]
-			},
-			{
-				"hidden": false,
-				"id": "np_port",
-				"max": 65535,
-				"min": 0,
-				"name": "port",
-				"onlyInt": true,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "np_interval",
-				"max": 3600,
-				"min": 1,
-				"name": "interval",
-				"onlyInt": true,
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "number926446584",
-				"max": null,
-				"min": null,
-				"name": "res",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "number1006954605",
-				"max": null,
-				"min": null,
-				"name": "resAvg1h",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "number4267669802",
-				"max": null,
-				"min": null,
-				"name": "resMin1h",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "number591433223",
-				"max": null,
-				"min": null,
-				"name": "resMax1h",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "number3726709001",
-				"max": null,
-				"min": null,
-				"name": "loss1h",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "np_enabled",
-				"name": "enabled",
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "bool"
-			},
-			{
-				"hidden": false,
-				"id": "autodate2990389176",
-				"name": "created",
-				"onCreate": true,
-				"onUpdate": false,
-				"presentable": false,
-				"system": false,
-				"type": "autodate"
-			},
-			{
-				"hidden": false,
-				"id": "date3332085495",
-				"max": "",
-				"min": "",
-				"name": "updated",
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "date"
-			}
-		],
-		"id": "np_probes_001",
-		"indexes": [
-			"CREATE INDEX ` + "`" + `idx_np_system_enabled` + "`" + ` ON ` + "`" + `network_probes` + "`" + ` (` + "`" + `system` + "`" + `)"
-		],
-		"listRule": null,
-		"name": "network_probes",
-		"system": false,
-		"type": "base",
-		"updateRule": null,
-		"viewRule": null
-	},
-	{
-		"createRule": null,
-		"deleteRule": null,
-		"fields": [
-			{
-				"autogeneratePattern": "[a-z0-9]{10}",
-				"hidden": false,
-				"id": "text3208210256",
-				"max": 10,
-				"min": 10,
-				"name": "id",
-				"pattern": "^[a-z0-9]+$",
-				"presentable": false,
-				"primaryKey": true,
-				"required": true,
-				"system": true,
-				"type": "text"
-			},
-			{
-				"cascadeDelete": true,
-				"collectionId": "2hz5ncl8tizk5nx",
-				"hidden": false,
-				"id": "nps_system",
-				"maxSelect": 1,
-				"minSelect": 0,
-				"name": "system",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "relation"
-			},
-			{
-				"hidden": false,
-				"id": "nps_stats",
-				"maxSize": 2000000,
-				"name": "stats",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "json"
-			},
-			{
-				"hidden": false,
-				"id": "nps_type",
-				"maxSelect": 1,
-				"name": "type",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "select",
-				"values": [
-					"1m",
-					"10m",
-					"20m",
-					"120m",
-					"480m"
-				]
-			},
-			{
-				"hidden": false,
-				"id": "number2990389176",
-				"max": null,
-				"min": null,
-				"name": "created",
-				"onlyInt": false,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			}
-		],
-		"id": "np_stats_001",
-		"indexes": [
-			"CREATE INDEX ` + "`" + `idx_nps_system_type_created` + "`" + ` ON ` + "`" + `network_probe_stats` + "`" + ` (\n  ` + "`" + `system` + "`" + `,\n  ` + "`" + `type` + "`" + `,\n  ` + "`" + `created` + "`" + `\n)"
-		],
-		"listRule": null,
-		"name": "network_probe_stats",
-		"system": false,
-		"type": "base",
-		"updateRule": null,
-		"viewRule": null
 	}
 ]`
 

internal/records/probe_averaging_test.go

@@ -1,58 +0,0 @@
-//go:build testing
-
-package records_test
-
-import (
-	"testing"
-
-	"github.com/henrygd/beszel/internal/records"
-	"github.com/henrygd/beszel/internal/tests"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestAverageProbeStats(t *testing.T) {
-	hub, err := tests.NewTestHub(t.TempDir())
-	require.NoError(t, err)
-	defer hub.Cleanup()
-
-	rm := records.NewRecordManager(hub)
-	user, err := tests.CreateUser(hub, "probe-avg@example.com", "testtesttest")
-	require.NoError(t, err)
-	system, err := tests.CreateRecord(hub, "systems", map[string]any{
-		"name":   "probe-avg-system",
-		"host":   "localhost",
-		"port":   "45876",
-		"status": "up",
-		"users":  []string{user.Id},
-	})
-	require.NoError(t, err)
-
-	recordA, err := tests.CreateRecord(hub, "network_probe_stats", map[string]any{
-		"system": system.Id,
-		"type":   "1m",
-		"stats":  `{"icmp:1.1.1.1":[10,80,8,14,1]}`,
-	})
-	require.NoError(t, err)
-	recordB, err := tests.CreateRecord(hub, "network_probe_stats", map[string]any{
-		"system": system.Id,
-		"type":   "1m",
-		"stats":  `{"icmp:1.1.1.1":[40,100,9,50,5]}`,
-	})
-	require.NoError(t, err)
-
-	result := rm.AverageProbeStats(hub.DB(), records.RecordIds{
-		{Id: recordA.Id},
-		{Id: recordB.Id},
-	})
-
-	stats, ok := result["icmp:1.1.1.1"]
-	require.True(t, ok)
-	require.Len(t, stats, 5)
-	assert.Equal(t, 25.0, stats[0])
-	assert.Equal(t, 90.0, stats[1])
-	assert.Equal(t, 8.0, stats[2])
-	assert.Equal(t, 50.0, stats[3])
-	assert.Equal(t, 3.0, stats[4])
-}

internal/records/records.go

@@ -8,12 +8,10 @@ import (
 	"time"
 
 	"github.com/henrygd/beszel/internal/entities/container"
-	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/entities/system"
 
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/types"
 )
 
 type RecordManager struct {
@@ -41,7 +39,7 @@ type StatsRecord struct {
 
 // Create longer records by averaging shorter records
 func (rm *RecordManager) CreateLongerRecords() {
-	now := time.Now().UTC()
+	// start := time.Now()
 	longerRecordData := []LongerRecordData{
 		{
 			shorterType: "1m",
@@ -72,8 +70,7 @@ func (rm *RecordManager) CreateLongerRecords() {
 	// wrap the operations in a transaction
 	rm.app.RunInTransaction(func(txApp core.App) error {
 		var err error
-
-		collections := [3]*core.Collection{}
+		collections := [2]*core.Collection{}
 		collections[0], err = txApp.FindCachedCollectionByNameOrId("system_stats")
 		if err != nil {
 			return err
@@ -82,10 +79,6 @@ func (rm *RecordManager) CreateLongerRecords() {
 		if err != nil {
 			return err
 		}
-		collections[2], err = txApp.FindCachedCollectionByNameOrId("network_probe_stats")
-		if err != nil {
-			return err
-		}
 		var systems RecordIds
 		db := txApp.DB()
 
@@ -98,71 +91,55 @@ func (rm *RecordManager) CreateLongerRecords() {
 				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 := now.Add(recordData.longerTimeDuration + time.Minute)
+				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 := now.Add(recordData.longerTimeDuration)
+				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" {
-						var existingRecord struct {
-							Id string
-						}
-
-						params := dbx.Params{
-							"type":    recordData.longerType,
-							"system":  system.Id,
-							"created": getCreatedTimeField(collection.Name, longerRecordPeriod),
-						}
-
-						_ = db.Select("id").
-							From(collection.Name).
-							Where(dbx.NewExp("system = {:system} AND type = {:type} AND created > {:created}", params)).
-							Limit(1).
-							One(&existingRecord)
-
+						count, err := txApp.CountRecords(
+							collection.Id,
+							dbx.NewExp(
+								"system = {:system} AND type = {:type} AND created > {:created}",
+								dbx.Params{"type": recordData.longerType, "system": system.Id, "created": longerRecordPeriod},
+							),
+						)
 						// continue if longer record exists
-						if existingRecord.Id != "" {
+						if err != nil || count > 0 {
 							continue
 						}
 					}
 					// get shorter records from the past x minutes
 					var recordIds RecordIds
 
-					params := dbx.Params{
-						"type":    recordData.shorterType,
-						"system":  system.Id,
-						"created": getCreatedTimeField(collection.Name, shorterRecordPeriod),
-					}
-
-					_ = txApp.DB().
+					err := txApp.DB().
 						Select("id").
 						From(collection.Name).
-						Where(dbx.NewExp(
+						AndWhere(dbx.NewExp(
 							"system={:system} AND type={:type} AND created > {:created}",
-							params,
+							dbx.Params{
+								"type":    recordData.shorterType,
+								"system":  system.Id,
+								"created": shorterRecordPeriod,
+							},
 						)).
 						All(&recordIds)
 
 					// continue if not enough shorter records
-					if len(recordIds) < recordData.minShorterRecords {
+					if err != nil || len(recordIds) < recordData.minShorterRecords {
 						continue
 					}
 					// average the shorter records and create longer record
 					longerRecord := core.NewRecord(collection)
 					longerRecord.Set("system", system.Id)
 					longerRecord.Set("type", recordData.longerType)
-					// network_probe_stats uses created as unix timestamp in milliseconds, so we need to set it manually here instead of relying on the default created field
-					if collection.Name == "network_probe_stats" {
-						longerRecord.Set("created", now.UnixMilli())
-					}
 					switch collection.Name {
 					case "system_stats":
 						longerRecord.Set("stats", rm.AverageSystemStats(db, recordIds))
 					case "container_stats":
+
 						longerRecord.Set("stats", rm.AverageContainerStats(db, recordIds))
-					case "network_probe_stats":
-						longerRecord.Set("stats", rm.AverageProbeStats(db, recordIds))
 					}
 					if err := txApp.SaveNoValidate(longerRecord); err != nil {
 						log.Println("failed to save longer record", "err", err)
@@ -174,14 +151,7 @@ func (rm *RecordManager) CreateLongerRecords() {
 		return nil
 	})
 
-	// slog.Info("finished creating longer records", "time (ms)", time.Since(now).Milliseconds())
-}
-
-func getCreatedTimeField(collectionName string, period time.Time) any {
-	if collectionName == "network_probe_stats" {
-		return period.UnixMilli()
-	}
-	return period.Format(types.DefaultDateLayout)
+	// 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
@@ -530,80 +500,6 @@ func AverageContainerStatsSlice(records [][]container.Stats) []container.Stats {
 	return result
 }
 
-// AverageProbeStats averages probe stats across multiple records.
-// For each probe key: avg of average fields, min of mins, and max of maxes.
-func (rm *RecordManager) AverageProbeStats(db dbx.Builder, records RecordIds) map[string]probe.Result {
-	type probeValues struct {
-		sums   probe.Result
-		counts []int
-	}
-
-	query := db.NewQuery("SELECT stats FROM network_probe_stats WHERE id = {:id}")
-
-	// accumulate sums for each probe key across records
-	sums := make(map[string]*probeValues)
-	var row StatsRecord
-	for _, rec := range records {
-		row.Stats = row.Stats[:0]
-		query.Bind(dbx.Params{"id": rec.Id}).One(&row)
-		var rawStats map[string]probe.Result
-		if err := json.Unmarshal(row.Stats, &rawStats); err != nil {
-			continue
-		}
-		for key, vals := range rawStats {
-			s, ok := sums[key]
-			if !ok {
-				s = &probeValues{sums: make(probe.Result, len(vals)), counts: make([]int, len(vals))}
-				sums[key] = s
-			}
-			if len(vals) > len(s.sums) {
-				expandedSums := make(probe.Result, len(vals))
-				copy(expandedSums, s.sums)
-				s.sums = expandedSums
-
-				expandedCounts := make([]int, len(vals))
-				copy(expandedCounts, s.counts)
-				s.counts = expandedCounts
-			}
-			for i := range vals {
-				switch i {
-				case 1: // min fields
-					if s.counts[i] == 0 || vals[i] < s.sums[i] {
-						s.sums[i] = vals[i]
-					}
-				case 2: // max fields
-					if s.counts[i] == 0 || vals[i] > s.sums[i] {
-						s.sums[i] = vals[i]
-					}
-				default: // average fields
-					s.sums[i] += vals[i]
-				}
-				s.counts[i]++
-			}
-		}
-	}
-
-	// compute final averages
-	result := make(map[string]probe.Result, len(sums))
-	for key, s := range sums {
-		if len(s.counts) == 0 {
-			continue
-		}
-		for i := range s.sums {
-			switch i {
-			case 1, 2: // min and max fields should not be averaged
-				continue
-			default:
-				if s.counts[i] > 0 {
-					s.sums[i] = twoDecimals(s.sums[i] / float64(s.counts[i]))
-				}
-			}
-		}
-		result[key] = s.sums
-	}
-	return result
-}
-
 /* Round float to two decimals */
 func twoDecimals(value float64) float64 {
 	return math.Round(value*100) / 100

internal/records/records_deletion.go

@@ -3,6 +3,7 @@ package records
 import (
 	"fmt"
 	"log/slog"
+	"strings"
 	"time"
 
 	"github.com/pocketbase/dbx"
@@ -58,7 +59,7 @@ func deleteOldAlertsHistory(app core.App, countToKeep, countBeforeDeletion int)
 // Deletes system_stats records older than what is displayed in the UI
 func deleteOldSystemStats(app core.App) error {
 	// Collections to process
-	collections := [3]string{"system_stats", "container_stats", "network_probe_stats"}
+	collections := [2]string{"system_stats", "container_stats"}
 
 	// Record types and their retention periods
 	type RecordDeletionData struct {
@@ -74,17 +75,24 @@ func deleteOldSystemStats(app core.App) error {
 	}
 
 	now := time.Now().UTC()
-	db := app.DB()
 
 	for _, collection := range collections {
-		query := db.Delete(collection, dbx.NewExp("type={:type} AND created<{:created}"))
-		for _, rd := range recordData {
-			if _, err := query.Bind(dbx.Params{
-				"type":    rd.recordType,
-				"created": getCreatedTimeField(collection, now.Add(-rd.retention)),
-			}).Execute(); err != nil {
-				return fmt.Errorf("failed to delete from %s: %v", collection, err)
-			}
+		// Build the WHERE clause
+		var conditionParts []string
+		var params dbx.Params = make(map[string]any)
+		for i := range recordData {
+			rd := recordData[i]
+			// Create parameterized condition for this record type
+			dateParam := fmt.Sprintf("date%d", i)
+			conditionParts = append(conditionParts, fmt.Sprintf("(type = '%s' AND created < {:%s})", rd.recordType, dateParam))
+			params[dateParam] = now.Add(-rd.retention)
+		}
+		// Combine conditions with OR
+		conditionStr := strings.Join(conditionParts, " OR ")
+		// Construct and execute the full raw query
+		rawQuery := fmt.Sprintf("DELETE FROM %s WHERE %s", collection, conditionStr)
+		if _, err := app.DB().NewQuery(rawQuery).Bind(params).Execute(); err != nil {
+			return fmt.Errorf("failed to delete from %s: %v", collection, err)
 		}
 	}
 	return nil

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

@@ -66,7 +66,7 @@ export default function AreaChartDefault({
 }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
 	const { isIntersecting, ref } = useIntersectionObserver({ freeze: false })
-	const sourceData = customData ?? chartData.systemStats ?? []
+	const sourceData = customData ?? chartData.systemStats
 	const [displayData, setDisplayData] = useState(sourceData)
 	const [displayMaxToggled, setDisplayMaxToggled] = useState(maxToggled)
 
@@ -111,8 +111,6 @@ export default function AreaChartDefault({
 		})
 	}, [areasKey, displayMaxToggled])
 
-	const XAxis = xAxis(chartData.chartTime, displayData.at(-1)?.created)
-
 	return useMemo(() => {
 		if (displayData.length === 0) {
 			return null
@@ -148,7 +146,7 @@ export default function AreaChartDefault({
 							axisLine={false}
 						/>
 					)}
-					{XAxis}
+					{xAxis(chartData)}
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
@@ -169,5 +167,5 @@ export default function AreaChartDefault({
 				</AreaChart>
 			</ChartContainer>
 		)
-	}, [displayData, yAxisWidth, filter, Areas, XAxis])
+	}, [displayData, yAxisWidth, filter, Areas])
 }

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

@@ -22,7 +22,6 @@ export type DataPoint<T = SystemStatsRecord> = {
 	order?: number
 	strokeOpacity?: number
 	activeDot?: boolean
-	dot?: boolean
 }
 
 export default function LineChartDefault({
@@ -42,7 +41,6 @@ export default function LineChartDefault({
 	filter,
 	truncate = false,
 	chartProps,
-	connectNulls,
 }: {
 	chartData: ChartData
 	// biome-ignore lint/suspicious/noExplicitAny: accepts different data source types (systemStats or containerData)
@@ -64,11 +62,10 @@ export default function LineChartDefault({
 	filter?: string
 	truncate?: boolean
 	chartProps?: Omit<React.ComponentProps<typeof LineChart>, "data" | "margin">
-	connectNulls?: boolean
 }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
 	const { isIntersecting, ref } = useIntersectionObserver({ freeze: false })
-	const sourceData = customData ?? chartData.systemStats ?? []
+	const sourceData = customData ?? chartData.systemStats
 	const [displayData, setDisplayData] = useState(sourceData)
 	const [displayMaxToggled, setDisplayMaxToggled] = useState(maxToggled)
 
@@ -86,9 +83,7 @@ export default function LineChartDefault({
 	}, [displayData, displayMaxToggled, isIntersecting, maxToggled, sourceData])
 
 	// Use a stable key derived from data point identities and visual properties
-	const linesKey = dataPoints?.map((d) => `${d.label}:${d.strokeOpacity}${d.dot}`).join("\0")
-
-	const XAxis = xAxis(chartData.chartTime, displayData.at(-1)?.created)
+	const linesKey = dataPoints?.map((d) => `${d.label}:${d.strokeOpacity ?? ""}`).join("\0")
 
 	const Lines = useMemo(() => {
 		return dataPoints?.map((dataPoint, i) => {
@@ -102,7 +97,7 @@ export default function LineChartDefault({
 					dataKey={dataPoint.dataKey}
 					name={dataPoint.label}
 					type="monotoneX"
-					dot={dataPoint.dot || false}
+					dot={false}
 					strokeWidth={1.5}
 					stroke={color}
 					strokeOpacity={dataPoint.strokeOpacity}
@@ -110,7 +105,6 @@ export default function LineChartDefault({
 					// stackId={dataPoint.stackId}
 					order={dataPoint.order || i}
 					activeDot={dataPoint.activeDot ?? true}
-					connectNulls={connectNulls}
 				/>
 			)
 		})
@@ -151,7 +145,7 @@ export default function LineChartDefault({
 							axisLine={false}
 						/>
 					)}
-					{XAxis}
+					{xAxis(chartData)}
 					<ChartTooltip
 						animationEasing="ease-out"
 						animationDuration={150}
@@ -172,5 +166,5 @@ export default function LineChartDefault({
 				</LineChart>
 			</ChartContainer>
 		)
-	}, [displayData, yAxisWidth, filter, Lines, XAxis])
+	}, [displayData, yAxisWidth, filter, Lines])
 }

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

@@ -15,7 +15,7 @@ import {
 import { EthernetIcon, HourglassIcon, SquareArrowRightEnterIcon } from "../ui/icons"
 import { Badge } from "../ui/badge"
 import { t } from "@lingui/core/macro"
-import { $allSystemsById, $longestSystemName } from "@/lib/stores"
+import { $allSystemsById, $longestSystemNameLen } from "@/lib/stores"
 import { useStore } from "@nanostores/react"
 import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip"
 
@@ -63,13 +63,10 @@ export const containerChartCols: ColumnDef<ContainerRecord>[] = [
 		header: ({ column }) => <HeaderButton column={column} name={t`System`} Icon={ServerIcon} />,
 		cell: ({ getValue }) => {
 			const allSystems = useStore($allSystemsById)
-			const longestName = useStore($longestSystemName)
+			const longestName = useStore($longestSystemNameLen)
 			return (
-				<div className="ms-1 relative w-fit max-w-40">
-					<span className="invisible block whitespace-nowrap" aria-hidden="true">
-						{longestName}
-					</span>
-					<span className="absolute inset-0 truncate">{allSystems[getValue() as string]?.name ?? ""}</span>
+				<div className="ms-1 max-w-40 truncate" style={{ width: `${longestName / 1.05}ch` }}>
+					{allSystems[getValue() as string]?.name ?? ""}
 				</div>
 			)
 		},

internal/site/src/components/login/auth-form.tsx

@@ -17,7 +17,7 @@ import { toast } from "../ui/use-toast"
 import { OtpInputForm } from "./otp-forms"
 
 const honeypot = v.literal("")
-const emailSchema = v.pipe(v.string(), v.email(t`Invalid email address.`))
+const emailSchema = v.pipe(v.string(), v.rfcEmail(t`Invalid email address.`))
 const passwordSchema = v.pipe(
 	v.string(),
 	v.minLength(8, t`Password must be at least 8 characters.`),

internal/site/src/components/navbar.tsx

@@ -8,7 +8,6 @@ import {
 	LogOutIcon,
 	LogsIcon,
 	MenuIcon,
-	NetworkIcon,
 	PlusIcon,
 	SearchIcon,
 	ServerIcon,
@@ -110,10 +109,6 @@ export default function Navbar() {
 								<HardDriveIcon className="h-4 w-4 me-2.5" strokeWidth={1.5} />
 								<span>S.M.A.R.T.</span>
 							</DropdownMenuItem>
-							<DropdownMenuItem onClick={() => navigate(getPagePath($router, "probes"))} className="flex items-center">
-								<NetworkIcon className="h-4 w-4 me-2.5" strokeWidth={1.5} />
-								<Trans>Network Probes</Trans>
-							</DropdownMenuItem>
 							<DropdownMenuItem
 								onClick={() => navigate(getPagePath($router, "settings", { name: "general" }))}
 								className="flex items-center"
@@ -185,21 +180,6 @@ export default function Navbar() {
 					</TooltipTrigger>
 					<TooltipContent>S.M.A.R.T.</TooltipContent>
 				</Tooltip>
-				<Tooltip>
-					<TooltipTrigger asChild>
-						<Link
-							href={getPagePath($router, "probes")}
-							className={cn("hidden md:grid", buttonVariants({ variant: "ghost", size: "icon" }))}
-							aria-label="Network Probes"
-							onMouseEnter={() => import("@/components/routes/probes")}
-						>
-							<NetworkIcon className="h-[1.2rem] w-[1.2rem]" strokeWidth={1.5} />
-						</Link>
-					</TooltipTrigger>
-					<TooltipContent>
-						<Trans>Network Probes</Trans>
-					</TooltipContent>
-				</Tooltip>
 				<LangToggle />
 				<ModeToggle />
 				<Tooltip>

internal/site/src/components/network-probes-table/network-probes-columns.tsx

@@ -1,381 +0,0 @@
-import type { CellContext, Column, ColumnDef } from "@tanstack/react-table"
-import { Button } from "@/components/ui/button"
-import { cn, copyToClipboard, formatMicroseconds, hourWithSeconds } from "@/lib/utils"
-import {
-	GlobeIcon,
-	TimerIcon,
-	WifiOffIcon,
-	Trash2Icon,
-	ArrowLeftRightIcon,
-	MoreHorizontalIcon,
-	ServerIcon,
-	ClockIcon,
-	NetworkIcon,
-	RefreshCwIcon,
-	PenBoxIcon,
-	PauseCircleIcon,
-	PlayCircleIcon,
-	CopyIcon,
-} from "lucide-react"
-import { t } from "@lingui/core/macro"
-import type { NetworkProbeRecord, SystemRecord } from "@/types"
-import {
-	DropdownMenu,
-	DropdownMenuContent,
-	DropdownMenuItem,
-	DropdownMenuSeparator,
-	DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu"
-import { Trans } from "@lingui/react/macro"
-import { $allSystemsById, $longestSystemName } from "@/lib/stores"
-import { useStore } from "@nanostores/react"
-import { SystemStatus } from "@/lib/enums"
-import { Checkbox } from "@/components/ui/checkbox"
-import { useMemo } from "react"
-import { formatBulkProbeLine } from "@/components/network-probes-table/probe-dialog"
-
-const protocolColors: Record<string, string> = {
-	icmp: "bg-blue-500/15 text-blue-400",
-	tcp: "bg-purple-500/15 text-purple-400",
-	http: "bg-green-500/15 text-green-400",
-}
-
-const SYSTEM_STATUS_COLORS = {
-	[SystemStatus.Up]: "bg-green-500",
-	[SystemStatus.Down]: "bg-red-500",
-	[SystemStatus.Paused]: "bg-primary/40",
-	[SystemStatus.Pending]: "bg-yellow-500",
-} as const
-
-/**
- * A probe is considered muted if it's disabled or if its associated system is not up.
- */
-const isMuted = (record: NetworkProbeRecord, systemRecord: SystemRecord | undefined) =>
-	!record.enabled || systemRecord?.status !== SystemStatus.Up
-
-export function getProbeColumns(
-	longestName = "",
-	longestTarget = "",
-	{
-		onEdit,
-		onDelete,
-		onSetEnabled,
-	}: {
-		onEdit?: (probe: NetworkProbeRecord) => void
-		onDelete?: (probes: NetworkProbeRecord[]) => void | Promise<void>
-		onSetEnabled?: (probes: NetworkProbeRecord[], enabled: boolean) => void | Promise<void>
-	} = {}
-): ColumnDef<NetworkProbeRecord>[] {
-	return [
-		{
-			id: "select",
-			header: ({ table }) => (
-				<Checkbox
-					className="ms-2"
-					checked={table.getIsAllRowsSelected() || (table.getIsSomeRowsSelected() && "indeterminate")}
-					onClick={(event) => event.stopPropagation()}
-					onCheckedChange={(value) => table.toggleAllRowsSelected(!!value)}
-					aria-label={t`Select all`}
-				/>
-			),
-			cell: ({ row }) => (
-				<Checkbox
-					checked={row.getIsSelected()}
-					onClick={(event) => event.stopPropagation()}
-					onCheckedChange={(value) => row.toggleSelected(!!value)}
-					aria-label={t`Select row`}
-				/>
-			),
-			enableSorting: false,
-			enableHiding: false,
-			size: 44,
-		},
-		{
-			id: "name",
-			sortingFn: (a, b) => (a.original.name || a.original.target).localeCompare(b.original.name || b.original.target),
-			accessorFn: (record) => record.name || record.target,
-			header: ({ column }) => <HeaderButton column={column} name={t`Name`} Icon={NetworkIcon} />,
-			cell: ({ row, getValue }) => {
-				const probe = row.original
-				return (
-					<div className="ms-1.5 max-w-40 flex gap-2 items-center tabular-nums">
-						<span className={cn("shrink-0 size-2 rounded-full", probe.enabled ? "bg-green-500" : "bg-primary/40")} />
-						<div className="relative w-fit min-w-0 max-w-full">
-							<span className="invisible block overflow-hidden whitespace-nowrap" aria-hidden="true">
-								{longestName}
-							</span>
-							<span className="absolute inset-0 truncate">{getValue() as string}</span>
-						</div>
-					</div>
-				)
-			},
-		},
-		{
-			id: "system",
-			accessorFn: (record) => record.system,
-			sortingFn: (a, b) => {
-				const allSystems = $allSystemsById.get()
-				const systemNameA = allSystems[a.original.system]?.name ?? ""
-				const systemNameB = allSystems[b.original.system]?.name ?? ""
-				return systemNameA.localeCompare(systemNameB)
-			},
-			header: ({ column }) => <HeaderButton column={column} name={t`System`} Icon={ServerIcon} />,
-			cell: ({ getValue }) => {
-				const system = useStore($allSystemsById)[getValue() as string] as SystemRecord | undefined
-				const longestSystemName = useStore($longestSystemName)
-				const name = system?.name
-				const status = system?.status as SystemStatus // undefined val is fine but makes lsp mad
-
-				return useMemo(
-					() => (
-						<div className="ms-1.5 max-w-44 flex gap-2 items-center tabular-nums">
-							<span className={cn("shrink-0 size-2 rounded-full", SYSTEM_STATUS_COLORS[status])} />
-							<div className="relative w-fit min-w-0 max-w-full">
-								<span className="invisible block whitespace-nowrap" aria-hidden="true">
-									{longestSystemName}
-								</span>
-								<span className="absolute inset-0 truncate">{name}</span>
-							</div>
-						</div>
-					),
-					[status, name]
-				)
-			},
-		},
-		{
-			id: "target",
-			sortingFn: (a, b) => a.original.target.localeCompare(b.original.target),
-			accessorFn: (record) => record.target,
-			header: ({ column }) => <HeaderButton column={column} name={t`Target`} Icon={GlobeIcon} />,
-			cell: ({ getValue }) => (
-				<div className="ms-1.5 relative w-fit max-w-44 tabular-nums">
-					<span className="invisible block whitespace-nowrap" aria-hidden="true">
-						{longestTarget}
-					</span>
-					<span className="absolute inset-0 truncate">{getValue() as string}</span>
-				</div>
-			),
-		},
-		{
-			id: "protocol",
-			accessorFn: (record) => record.protocol,
-			header: ({ column }) => <HeaderButton column={column} name={t`Protocol`} Icon={ArrowLeftRightIcon} />,
-			cell: ({ getValue }) => {
-				const protocol = getValue() as string
-				return (
-					<span className={cn("ms-1.5 px-2 py-0.5 rounded text-xs font-medium uppercase", protocolColors[protocol])}>
-						{protocol}
-					</span>
-				)
-			},
-		},
-		{
-			id: "interval",
-			accessorFn: (record) => record.interval,
-			header: ({ column }) => <HeaderButton column={column} name={t`Interval`} Icon={RefreshCwIcon} />,
-			cell: ({ getValue }) => <span className="ms-1.5 tabular-nums">{getValue() as number}s</span>,
-		},
-		{
-			id: "res",
-			accessorFn: (record) => record.res,
-			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Response`} Icon={TimerIcon} />,
-			cell: responseTimeCell,
-		},
-		{
-			id: "res1h",
-			accessorFn: (record) => record.resAvg1h,
-			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Avg 1h`} Icon={TimerIcon} />,
-			cell: responseTimeCell,
-		},
-		{
-			id: "max1h",
-			accessorFn: (record) => record.resMax1h,
-			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Max 1h`} Icon={TimerIcon} />,
-			cell: responseTimeCell,
-		},
-		{
-			id: "min1h",
-			accessorFn: (record) => record.resMin1h,
-			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Min 1h`} Icon={TimerIcon} />,
-			cell: responseTimeCell,
-		},
-		{
-			id: "loss",
-			accessorFn: (record) => record.loss1h,
-			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Loss 1h`} Icon={WifiOffIcon} />,
-			cell: ({ row }) => {
-				const { loss1h, res, system } = row.original
-				const systemRecord = useStore($allSystemsById)[system]
-
-				if (loss1h === undefined || (!res && !loss1h)) {
-					return <span className="ms-1.5 text-muted-foreground">-</span>
-				}
-
-				const muted = isMuted(row.original, systemRecord)
-				let color = "bg-green-500"
-				if (muted) {
-					color = "bg-muted-foreground/50"
-				} else if (loss1h) {
-					color = loss1h > 20 ? "bg-red-500" : "bg-yellow-500"
-				}
-				return (
-					<span className="ms-1.5 tabular-nums flex gap-2 items-center">
-						<span className={cn("shrink-0 size-2 rounded-full", color)} />
-						{loss1h}%
-					</span>
-				)
-			},
-		},
-		{
-			id: "updated",
-			invertSorting: true,
-			accessorFn: (record) => record.updated,
-			header: ({ column }) => <HeaderButton column={column} name={t`Updated`} Icon={ClockIcon} />,
-			cell: ({ getValue }) => {
-				const timestamp = getValue() as number
-				if (!timestamp) {
-					return <span className="ms-1.5 text-muted-foreground">-</span>
-				}
-				return <span className="ms-1.5 tabular-nums">{hourWithSeconds(timestamp)}</span>
-			},
-		},
-		{
-			id: "actions",
-			enableSorting: false,
-			enableHiding: false,
-			header: () => null,
-			size: 40,
-			cell: ({ row, table }) => {
-				const selectedRows = table.getSelectedRowModel().rows
-				const actionRows =
-					row.getIsSelected() && selectedRows.length > 1
-						? selectedRows.map((selectedRow) => selectedRow.original)
-						: [row.original]
-				const isBulkAction = actionRows.length > 1
-				const shouldPause = actionRows.some((probe) => probe.enabled)
-				const bulkCopyContent = actionRows.map((probe) => formatBulkProbeLine(probe)).join("\n")
-				return (
-					<DropdownMenu>
-						<DropdownMenuTrigger asChild>
-							<Button variant="ghost" size="icon" className="size-10">
-								<span className="sr-only">
-									<Trans>Open menu</Trans>
-								</span>
-								<MoreHorizontalIcon className="w-5" />
-							</Button>
-						</DropdownMenuTrigger>
-						<DropdownMenuContent align="end" onClick={(event) => event.stopPropagation()}>
-							{!isBulkAction && (
-								<DropdownMenuItem
-									onClick={() => {
-										onEdit?.(row.original)
-									}}
-								>
-									<PenBoxIcon className="me-2.5 size-4" />
-									<Trans>Edit</Trans>
-								</DropdownMenuItem>
-							)}
-							<DropdownMenuItem
-								onClick={() => {
-									onSetEnabled?.(actionRows, !shouldPause)
-								}}
-							>
-								{shouldPause ? (
-									<>
-										<PauseCircleIcon className="me-2.5 size-4" />
-										<Trans>Pause</Trans>
-									</>
-								) : (
-									<>
-										<PlayCircleIcon className="me-2.5 size-4" />
-										<Trans>Resume</Trans>
-									</>
-								)}
-							</DropdownMenuItem>
-							<DropdownMenuItem
-								onClick={() => {
-									copyToClipboard(bulkCopyContent)
-								}}
-							>
-								<CopyIcon className="me-2.5 size-4" />
-								<Trans>Bulk copy</Trans>
-							</DropdownMenuItem>
-							<DropdownMenuSeparator />
-							<DropdownMenuItem
-								onClick={() => {
-									onDelete?.(actionRows)
-								}}
-							>
-								<Trash2Icon className="me-2.5 size-4" />
-								<Trans>Delete</Trans>
-							</DropdownMenuItem>
-						</DropdownMenuContent>
-					</DropdownMenu>
-				)
-			},
-		},
-	]
-}
-
-const responseTimeThresholds = {
-	http: { warning: 800_000, critical: 3_000_000 },
-	tcp: { warning: 500_000, critical: 2_000_000 },
-	icmp: { warning: 100_000, critical: 500_000 },
-}
-
-function responseTimeCell(cell: CellContext<NetworkProbeRecord, unknown>) {
-	const probe = cell.row.original
-	const systemRecord = useStore($allSystemsById)[probe.system]
-	const responseTime = cell.getValue() as number | undefined
-
-	if (!responseTime) {
-		return <span className="ms-1.5 text-muted-foreground">-</span>
-	}
-
-	const muted = isMuted(probe, systemRecord)
-	let color = "bg-green-500"
-	if (muted) {
-		color = "bg-muted-foreground/50"
-	} else if (responseTime > responseTimeThresholds[probe.protocol].warning) {
-		color = "bg-yellow-500"
-	}
-	if (!muted && responseTime > responseTimeThresholds[probe.protocol].critical) {
-		color = "bg-red-500"
-	}
-	return (
-		<span className="ms-1.5 tabular-nums flex gap-2 items-center">
-			<span className={cn("shrink-0 size-2 rounded-full", color)} />
-			{formatMicroseconds(responseTime)}
-		</span>
-	)
-}
-
-function HeaderButton({
-	column,
-	name,
-	Icon,
-}: {
-	column: Column<NetworkProbeRecord>
-	name: string
-	Icon: React.ElementType
-}) {
-	const isSorted = column.getIsSorted()
-	return (
-		<Button
-			className={cn(
-				"h-9 px-3 flex items-center gap-2 duration-50",
-				isSorted && "bg-accent/70 light:bg-accent text-accent-foreground/90"
-			)}
-			variant="ghost"
-			onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
-		>
-			{Icon && <Icon className="size-4" />}
-			{name}
-		</Button>
-	)
-}

internal/site/src/components/network-probes-table/network-probes-table.tsx

@@ -1,534 +0,0 @@
-import { t } from "@lingui/core/macro"
-import { Trans } from "@lingui/react/macro"
-import {
-	type ColumnFiltersState,
-	flexRender,
-	getCoreRowModel,
-	getFilteredRowModel,
-	getSortedRowModel,
-	type Row,
-	type RowSelectionState,
-	type SortingState,
-	type Table as TableType,
-	useReactTable,
-	type VisibilityState,
-} from "@tanstack/react-table"
-import { useVirtualizer, type VirtualItem } from "@tanstack/react-virtual"
-import {
-	AlertDialog,
-	AlertDialogAction,
-	AlertDialogCancel,
-	AlertDialogContent,
-	AlertDialogDescription,
-	AlertDialogFooter,
-	AlertDialogHeader,
-	AlertDialogTitle,
-} from "@/components/ui/alert-dialog"
-import { Button, buttonVariants } from "@/components/ui/button"
-import { memo, useCallback, useMemo, useRef, useState } from "react"
-import { getProbeColumns } from "@/components/network-probes-table/network-probes-columns"
-import { Card, CardHeader, CardTitle } from "@/components/ui/card"
-import { Input } from "@/components/ui/input"
-import { TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
-import { useToast } from "@/components/ui/use-toast"
-import { isReadOnlyUser } from "@/lib/api"
-import { pb } from "@/lib/api"
-import { $allSystemsById, $chartTime, $direction } from "@/lib/stores"
-import { cn, isVisuallyLonger, useBrowserStorage } from "@/lib/utils"
-import type { NetworkProbeRecord } from "@/types"
-import { AddProbeDialog, EditProbeDialog } from "./probe-dialog"
-import { XIcon } from "lucide-react"
-import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "@/components/ui/sheet"
-import ChartTimeSelect from "@/components/charts/chart-time-select"
-import { LossChart, AvgMinMaxResponseChart } from "@/components/routes/system/charts/probes-charts"
-import { useNetworkProbeStats } from "@/lib/use-network-probes"
-import { useStore } from "@nanostores/react"
-import type { ChartData } from "@/types"
-import { parseSemVer } from "@/lib/utils"
-import { Separator } from "../ui/separator"
-import { $router, Link } from "../router"
-import { getPagePath } from "@nanostores/router"
-
-export default function NetworkProbesTableNew({
-	systemId,
-	probes,
-}: {
-	systemId?: string
-	probes: NetworkProbeRecord[]
-}) {
-	const [sorting, setSorting] = useBrowserStorage<SortingState>(
-		`sort-np-${systemId ? 1 : 0}`,
-		[{ id: systemId ? "name" : "system", desc: false }],
-		sessionStorage
-	)
-	const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([])
-	const [columnVisibility, setColumnVisibility] = useState<VisibilityState>({})
-	const [rowSelection, setRowSelection] = useState<RowSelectionState>({})
-	const [globalFilter, setGlobalFilter] = useState("")
-	const [deleteOpen, setDeleteOpen] = useState(false)
-	const [pendingDeleteIds, setPendingDeleteIds] = useState<string[]>([])
-	const [editingProbe, setEditingProbe] = useState<NetworkProbeRecord>()
-	const { toast } = useToast()
-	const canManageProbes = !isReadOnlyUser()
-
-	const [longestName, longestTarget] = useMemo(() => {
-		let longestName = ""
-		let longestTarget = ""
-		for (const p of probes) {
-			const name = p.name || p.target
-			if (isVisuallyLonger(name, longestName)) {
-				longestName = name
-			}
-			if (isVisuallyLonger(p.target, longestTarget)) {
-				longestTarget = p.target
-			}
-		}
-		return [longestName, longestTarget]
-	}, [probes])
-
-	const runProbeBatch = useCallback(
-		async (ids: string[], enqueue: (batch: ReturnType<typeof pb.createBatch>, id: string) => void) => {
-			let batch = pb.createBatch()
-			let inBatch = 0
-			for (const id of ids) {
-				enqueue(batch, id)
-				if (++inBatch >= 20) {
-					await batch.send()
-					batch = pb.createBatch()
-					inBatch = 0
-				}
-			}
-			if (inBatch) {
-				await batch.send()
-			}
-		},
-		[]
-	)
-
-	const handleDeleteRequest = useCallback(
-		async (probesToDelete: NetworkProbeRecord[]) => {
-			if (!probesToDelete.length) {
-				return
-			}
-
-			const ids = probesToDelete.map((probe) => probe.id)
-			if (ids.length === 1) {
-				try {
-					await pb.collection("network_probes").delete(ids[0])
-				} catch (err: unknown) {
-					toast({
-						variant: "destructive",
-						title: t`Error`,
-						description: (err as Error)?.message || t`Failed to delete probes.`,
-					})
-				}
-				return
-			}
-
-			setPendingDeleteIds(ids)
-			setDeleteOpen(true)
-		},
-		[toast]
-	)
-
-	const handleBulkDelete = async () => {
-		setDeleteOpen(false)
-		if (!pendingDeleteIds.length) {
-			return
-		}
-
-		try {
-			await runProbeBatch(pendingDeleteIds, (batch, id) => batch.collection("network_probes").delete(id))
-			setPendingDeleteIds([])
-			setRowSelection({})
-		} catch (err: unknown) {
-			toast({
-				variant: "destructive",
-				title: t`Error`,
-				description: (err as Error)?.message || t`Failed to delete probes.`,
-			})
-		}
-	}
-
-	const handleSetEnabled = useCallback(
-		async (probesToUpdate: NetworkProbeRecord[], enabled: boolean) => {
-			if (!probesToUpdate.length) {
-				return
-			}
-
-			const pendingUpdates = probesToUpdate.filter((probe) => probe.enabled !== enabled)
-			if (!pendingUpdates.length) {
-				return
-			}
-
-			try {
-				if (pendingUpdates.length === 1) {
-					await pb.collection("network_probes").update(pendingUpdates[0].id, { enabled })
-					return
-				}
-				await runProbeBatch(
-					pendingUpdates.map((probe) => probe.id),
-					(batch, id) => batch.collection("network_probes").update(id, { enabled })
-				)
-				if (probesToUpdate.length > 1) {
-					setRowSelection({})
-				}
-			} catch (err: unknown) {
-				toast({
-					variant: "destructive",
-					title: t`Error`,
-					description: (err as Error)?.message || t`Failed to update probes.`,
-				})
-			}
-		},
-		[runProbeBatch, toast]
-	)
-
-	const columns = useMemo(() => {
-		let columns = getProbeColumns(longestName, longestTarget, {
-			onEdit: setEditingProbe,
-			onDelete: handleDeleteRequest,
-			onSetEnabled: handleSetEnabled,
-		})
-		columns = systemId ? columns.filter((col) => col.id !== "system") : columns
-		columns = canManageProbes ? columns : columns.filter((col) => col.id !== "actions")
-		return columns
-	}, [canManageProbes, handleDeleteRequest, handleSetEnabled, longestName, systemId, longestTarget])
-
-	const table = useReactTable({
-		data: probes,
-		columns,
-		getRowId: (row) => row.id,
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getFilteredRowModel: getFilteredRowModel(),
-		onSortingChange: setSorting,
-		onColumnFiltersChange: setColumnFilters,
-		onColumnVisibilityChange: setColumnVisibility,
-		onRowSelectionChange: setRowSelection,
-		defaultColumn: {
-			sortUndefined: "last",
-			size: 900,
-			minSize: 0,
-		},
-		state: {
-			sorting,
-			columnFilters,
-			columnVisibility,
-			rowSelection,
-			globalFilter,
-		},
-		onGlobalFilterChange: setGlobalFilter,
-		globalFilterFn: (row, _columnId, filterValue) => {
-			const probe = row.original
-			const systemName = $allSystemsById.get()[probe.system]?.name ?? ""
-			const searchString = `${probe.name}${probe.target}${probe.protocol}${systemName}`.toLocaleLowerCase()
-			return (filterValue as string)
-				.toLowerCase()
-				.split(" ")
-				.every((term) => searchString.includes(term))
-		},
-	})
-
-	const rows = table.getRowModel().rows
-	const visibleColumns = table.getVisibleLeafColumns()
-
-	return (
-		<Card className="@container w-full px-3 py-5 sm:py-6 sm:px-6">
-			<CardHeader className="p-0 mb-3 sm:mb-4">
-				<div className="grid md:flex gap-x-5 gap-y-3 w-full items-end">
-					<div className="px-2 sm:px-1">
-						<CardTitle className="mb-2">
-							<Trans>Network Probes</Trans>
-						</CardTitle>
-						<div className="text-sm text-muted-foreground flex items-center flex-wrap">
-							<Trans>Response time monitoring from agents.</Trans>
-						</div>
-					</div>
-					<div className="md:ms-auto flex items-center gap-2">
-						{probes.length > 0 && (
-							<div className="relative">
-								<Input
-									placeholder={t`Filter...`}
-									value={globalFilter}
-									onChange={(e) => setGlobalFilter(e.target.value)}
-									className="ms-auto px-4 w-full max-w-full md:w-50"
-								/>
-								{globalFilter && (
-									<Button
-										type="button"
-										variant="ghost"
-										size="icon"
-										aria-label={t`Clear`}
-										className="absolute right-1 top-1/2 -translate-y-1/2 h-7 w-7 text-muted-foreground"
-										onClick={() => setGlobalFilter("")}
-									>
-										<XIcon className="h-4 w-4" />
-									</Button>
-								)}
-							</div>
-						)}
-						{canManageProbes ? <AddProbeDialog systemId={systemId} probes={probes} /> : null}
-						{canManageProbes ? (
-							<EditProbeDialog
-								systemId={systemId}
-								probe={editingProbe}
-								open={!!editingProbe}
-								setOpen={(open) => {
-									if (!open) {
-										setEditingProbe(undefined)
-									}
-								}}
-							/>
-						) : null}
-						<AlertDialog
-							open={deleteOpen}
-							onOpenChange={(open) => {
-								setDeleteOpen(open)
-								if (!open) {
-									setPendingDeleteIds([])
-								}
-							}}
-						>
-							<AlertDialogContent>
-								<AlertDialogHeader>
-									<AlertDialogTitle>
-										<Trans>Are you sure?</Trans>
-									</AlertDialogTitle>
-									<AlertDialogDescription>
-										<Trans>This will permanently delete all selected records from the database.</Trans>
-									</AlertDialogDescription>
-								</AlertDialogHeader>
-								<AlertDialogFooter>
-									<AlertDialogCancel>
-										<Trans>Cancel</Trans>
-									</AlertDialogCancel>
-									<AlertDialogAction
-										className={cn(buttonVariants({ variant: "destructive" }))}
-										onClick={handleBulkDelete}
-									>
-										<Trans>Continue</Trans>
-									</AlertDialogAction>
-								</AlertDialogFooter>
-							</AlertDialogContent>
-						</AlertDialog>
-					</div>
-				</div>
-			</CardHeader>
-			<div className="rounded-md">
-				<NetworkProbesTable table={table} rows={rows} colLength={visibleColumns.length} rowSelection={rowSelection} />
-			</div>
-		</Card>
-	)
-}
-
-const NetworkProbesTable = memo(function NetworkProbeTable({
-	table,
-	rows,
-	colLength,
-	rowSelection: _rowSelection,
-}: {
-	table: TableType<NetworkProbeRecord>
-	rows: Row<NetworkProbeRecord>[]
-	colLength: number
-	rowSelection: RowSelectionState
-}) {
-	// The virtualizer will need a reference to the scrollable container element
-	const scrollRef = useRef<HTMLDivElement>(null)
-	const [sheetOpen, setSheetOpen] = useState(false)
-	const [activeProbeId, setActiveProbeId] = useState<string | null>(null)
-	const activeProbe = activeProbeId ? table.options.data.find((probe) => probe.id === activeProbeId) : undefined
-	const openSheet = useCallback((probe: NetworkProbeRecord) => {
-		setActiveProbeId(probe.id)
-		setSheetOpen(true)
-	}, [])
-
-	const virtualizer = useVirtualizer<HTMLDivElement, HTMLTableRowElement>({
-		count: rows.length,
-		estimateSize: () => 54,
-		getScrollElement: () => scrollRef.current,
-		overscan: 5,
-	})
-	const virtualRows = virtualizer.getVirtualItems()
-
-	const paddingTop = Math.max(0, virtualRows[0]?.start ?? 0 - virtualizer.options.scrollMargin)
-	const paddingBottom = Math.max(0, virtualizer.getTotalSize() - (virtualRows[virtualRows.length - 1]?.end ?? 0))
-
-	return (
-		<div
-			className={cn(
-				"h-min max-h-[calc(100dvh-17rem)] max-w-full relative overflow-auto border rounded-md",
-				// don't set min height if there are less than 2 rows, do set if we need to display the empty state
-				(!rows.length || rows.length > 2) && "min-h-50"
-			)}
-			ref={scrollRef}
-		>
-			{/* add header height to table size */}
-			<div style={{ height: `${virtualizer.getTotalSize() + 48}px`, paddingTop, paddingBottom }}>
-				<table className="text-sm w-full h-full text-nowrap">
-					<NetworkProbeTableHead table={table} />
-					<TableBody>
-						{rows.length ? (
-							virtualRows.map((virtualRow) => {
-								const row = rows[virtualRow.index]
-								return (
-									<NetworkProbeTableRow
-										key={row.id}
-										row={row}
-										virtualRow={virtualRow}
-										isSelected={row.getIsSelected()}
-										openSheet={openSheet}
-									/>
-								)
-							})
-						) : (
-							<TableRow>
-								<TableCell colSpan={colLength} className="h-37 text-center pointer-events-none">
-									<Trans>No results.</Trans>
-								</TableCell>
-							</TableRow>
-						)}
-					</TableBody>
-				</table>
-			</div>
-			<NetworkProbeSheet
-				open={sheetOpen}
-				onOpenChange={(nextOpen) => {
-					setSheetOpen(nextOpen)
-				}}
-				probe={activeProbe}
-			/>
-		</div>
-	)
-})
-
-function NetworkProbeTableHead({ table }: { table: TableType<NetworkProbeRecord> }) {
-	return (
-		<TableHeader className="sticky top-0 z-50 w-full border-b-2">
-			{table.getHeaderGroups().map((headerGroup) => (
-				<tr key={headerGroup.id}>
-					{headerGroup.headers.map((header) => {
-						return (
-							<TableHead className="px-2" key={header.id}>
-								{header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())}
-							</TableHead>
-						)
-					})}
-				</tr>
-			))}
-		</TableHeader>
-	)
-}
-
-const NetworkProbeTableRow = memo(function NetworkProbeTableRow({
-	row,
-	virtualRow,
-	isSelected,
-	openSheet,
-}: {
-	row: Row<NetworkProbeRecord>
-	virtualRow: VirtualItem
-	isSelected: boolean
-	openSheet: (probe: NetworkProbeRecord) => void
-}) {
-	return (
-		<TableRow
-			data-state={isSelected && "selected"}
-			className="cursor-pointer transition-opacity"
-			onClick={() => openSheet(row.original)}
-		>
-			{row.getVisibleCells().map((cell) => (
-				<TableCell
-					key={cell.id}
-					className="py-0"
-					style={{
-						width: `${cell.column.getSize()}px`,
-						height: virtualRow.size,
-					}}
-				>
-					{flexRender(cell.column.columnDef.cell, cell.getContext())}
-				</TableCell>
-			))}
-		</TableRow>
-	)
-})
-
-function NetworkProbeSheet({
-	open,
-	onOpenChange,
-	probe,
-}: {
-	open: boolean
-	onOpenChange: (open: boolean) => void
-	probe?: NetworkProbeRecord
-}) {
-	if (!probe) {
-		return null
-	}
-
-	return <NetworkProbeSheetContent key={probe.system} open={open} onOpenChange={onOpenChange} probe={probe} />
-}
-
-function NetworkProbeSheetContent({
-	open,
-	onOpenChange,
-	probe,
-}: {
-	open: boolean
-	onOpenChange: (open: boolean) => void
-	probe: NetworkProbeRecord
-}) {
-	const chartTime = useStore($chartTime)
-	const direction = useStore($direction)
-	const system = useStore($allSystemsById)[probe.system]
-
-	const probeStats = useNetworkProbeStats({ systemId: probe.system, chartTime })
-
-	const chartData = useMemo<ChartData>(
-		() => ({
-			agentVersion: parseSemVer(system?.info?.v),
-			orientation: direction === "rtl" ? "right" : "left",
-			chartTime,
-		}),
-		[probeStats]
-	)
-	const hasProbeStats = probeStats.some((record) => record.stats?.[probe.id] != null)
-	const probeLabel = probe.name || probe.target
-
-	return (
-		<Sheet open={open} onOpenChange={onOpenChange}>
-			<SheetContent className="w-full sm:max-w-220 overflow-auto p-4 sm:p-6">
-				<SheetHeader className="mb-0 border-b p-0 pb-4">
-					<SheetTitle>{probeLabel}</SheetTitle>
-					<SheetDescription className="flex flex-wrap items-center gap-x-2 gap-y-1">
-						<Link className="hover:underline" href={getPagePath($router, "system", { id: system?.id ?? "" })}>
-							{system?.name ?? ""}
-						</Link>
-						<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-						{probe.protocol.toUpperCase()}
-						<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-						{probe.target}
-						{probe.port > 0 && (
-							<>
-								<Separator orientation="vertical" className="h-2.5 bg-muted-foreground opacity-70" />
-								<span>{probe.port}</span>
-							</>
-						)}
-					</SheetDescription>
-				</SheetHeader>
-				<div className="grid gap-4">
-					<ChartTimeSelect className="bg-card" agentVersion={chartData.agentVersion} />
-					<AvgMinMaxResponseChart probeStats={probeStats} probe={probe} chartData={chartData} empty={!hasProbeStats} />
-					<LossChart
-						probeStats={probeStats}
-						grid={false}
-						probes={[probe]}
-						chartData={chartData}
-						empty={!hasProbeStats}
-						showFilter={false}
-					/>
-				</div>
-			</SheetContent>
-		</Sheet>
-	)
-}

internal/site/src/components/network-probes-table/probe-dialog.tsx

@@ -1,591 +0,0 @@
-import { useEffect, useRef, useState } from "react"
-import { Trans, useLingui } from "@lingui/react/macro"
-import { useStore } from "@nanostores/react"
-import { pb } from "@/lib/api"
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-} from "@/components/ui/dialog"
-import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu"
-import { Sheet, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle } from "@/components/ui/sheet"
-import { Button } from "@/components/ui/button"
-import { Input } from "@/components/ui/input"
-import { Label } from "@/components/ui/label"
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
-import { Textarea } from "@/components/ui/textarea"
-import { ChevronDownIcon, ListIcon, ServerIcon } from "lucide-react"
-import { useToast } from "@/components/ui/use-toast"
-import { $systems } from "@/lib/stores"
-import type { NetworkProbeRecord } from "@/types"
-import * as v from "valibot"
-
-type ProbeProtocol = "icmp" | "tcp" | "http"
-
-type ProbeValues = {
-	system: string
-	target: string
-	protocol: ProbeProtocol
-	port: number
-	interval: string
-	name?: string
-}
-
-type NormalizedProbeValues = Omit<ProbeValues, "system" | "interval"> & {
-	interval: number
-}
-
-type BulkProbeLineSource = Pick<NetworkProbeRecord, "target" | "protocol" | "port" | "interval" | "name">
-
-const defaultInterval = 20
-
-const ProbeProtocolSchema = v.picklist(["icmp", "tcp", "http"])
-
-const ProbeIntervalSchema = v.pipe(v.string(), v.toNumber(), v.minValue(1), v.maxValue(3600))
-
-// Both the single-probe form and the bulk importer flow through this schema so
-// defaults and HTTP target normalization stay in one place.
-const NormalizedProbeValuesSchema = v.pipe(
-	v.object({
-		target: v.pipe(v.string(), v.trim(), v.nonEmpty("target is required")),
-		protocol: ProbeProtocolSchema,
-		port: v.number(),
-		interval: ProbeIntervalSchema,
-		name: v.optional(v.pipe(v.string(), v.trim())),
-	}),
-	v.transform((input): NormalizedProbeValues => {
-		let { protocol, port } = input
-		if (protocol === "icmp") {
-			port = 0
-		} else if ((protocol === "tcp" || protocol === "http") && !port) {
-			port = 443
-		}
-		return {
-			// HTTP probes may be entered as bare hostnames, so normalize them to a
-			// scheme-bearing URL before the payload is sent to PocketBase.
-			target: protocol === "http" ? normalizeHttpTarget(input.target, port) : input.target,
-			protocol,
-			port,
-			interval: input.interval,
-			name: input.name || undefined,
-		}
-	}),
-	v.forward(
-		v.check((input) => {
-			if (input.protocol === "icmp") {
-				return input.port === 0
-			}
-
-			return Number.isInteger(input.port) && input.port >= 1 && input.port <= 65535
-		}, "Port must be between 1 and 65535"),
-		["port"]
-	)
-)
-
-// Bulk parsing only trims raw CSV fields. Inference, defaults, and protocol-
-// specific validation still go through the shared normalization schema above.
-const BulkProbeSchema = v.object({
-	target: v.pipe(v.string(), v.trim(), v.nonEmpty("target is required")),
-	protocol: v.optional(v.pipe(v.string(), v.trim())),
-	port: v.optional(v.pipe(v.string(), v.trim())),
-	interval: v.optional(v.pipe(v.string(), v.trim())),
-	name: v.optional(v.pipe(v.string(), v.trim())),
-})
-
-function normalizeHttpTarget(target: string, port: number) {
-	if (/^https?:\/\//i.test(target)) {
-		return target
-	}
-
-	return `${port === 443 ? "https" : "http"}://${target}`
-}
-
-function trimTrailingEmptyFields(fields: string[]) {
-	let lastValueIndex = fields.length - 1
-	while (lastValueIndex > 0 && !fields[lastValueIndex]) {
-		lastValueIndex--
-	}
-	return fields.slice(0, lastValueIndex + 1)
-}
-
-function buildProbePayload(values: ProbeValues, enabled = true) {
-	const normalizedValues = v.safeParse(NormalizedProbeValuesSchema, values)
-	if (!normalizedValues.success) {
-		throw new Error(normalizedValues.issues[0]?.message || "Invalid probe")
-	}
-
-	const payload = {
-		system: values.system,
-		enabled,
-		...normalizedValues.output,
-	}
-
-	const trimmedName = normalizedValues.output.name?.trim()
-	const targetName = normalizedValues.output.target.replace(/^https?:\/\//i, "")
-	if (trimmedName) {
-		payload.name = trimmedName
-	} else if (targetName !== normalizedValues.output.target) {
-		payload.name = targetName
-	} else {
-		payload.name = ""
-	}
-	return payload
-}
-
-type ProbeIdentity = Pick<ProbeValues, "system" | "target" | "protocol" | "port">
-function getProbeIdentityKey({ system, target, protocol, port }: ProbeIdentity) {
-	return `${system}${target}${protocol}${port}`
-}
-
-function parseBulkProbeLine(line: string, lineNumber: number, system: string) {
-	const [rawTarget = "", rawProtocol = "", rawPort = "", rawInterval = "", ...rawName] = line.split(",")
-	const parsed = v.safeParse(BulkProbeSchema, {
-		target: rawTarget,
-		protocol: rawProtocol,
-		port: rawPort,
-		interval: rawInterval,
-		name: rawName.join(","),
-	})
-	if (!parsed.success) {
-		throw new Error(`Line ${lineNumber}: ${parsed.issues[0]?.message || "invalid probe entry"}`)
-	}
-
-	return buildProbePayload({
-		system,
-		target: parsed.output.target,
-		protocol: (parsed.output.protocol?.toLowerCase() ||
-			(/^https?:\/\//i.test(parsed.output.target) ? "http" : "icmp")) as ProbeProtocol,
-		port: parsed.output.port ? Number(parsed.output.port) : 0,
-		interval: parsed.output.interval || `${defaultInterval}`,
-		name: parsed.output.name || undefined,
-	})
-}
-
-export function formatBulkProbeLine(probe: BulkProbeLineSource) {
-	const port = probe.protocol === "icmp" || probe.port === 443 ? "" : `${probe.port}`
-	const interval = probe.interval === defaultInterval ? "" : `${probe.interval}`
-	return trimTrailingEmptyFields([probe.target, probe.protocol, port, interval, probe.name?.trim() || ""]).join(",")
-}
-
-export function AddProbeDialog({ systemId, probes }: { systemId?: string; probes: NetworkProbeRecord[] }) {
-	const [open, setOpen] = useState(false)
-	const [bulkOpen, setBulkOpen] = useState(false)
-	const [bulkInput, setBulkInput] = useState("")
-	const [bulkLoading, setBulkLoading] = useState(false)
-	const [bulkSelectedSystemId, setBulkSelectedSystemId] = useState("")
-	const bulkFormRef = useRef<HTMLFormElement>(null)
-	const { toast } = useToast()
-	const { t } = useLingui()
-	const systems = useStore($systems)
-
-	const resetBulkForm = () => {
-		setBulkInput("")
-		// setBulkSelectedSystemId("")
-	}
-
-	const openBulkAdd = (selectedSystemId?: string) => {
-		if (!systemId && selectedSystemId) {
-			setBulkSelectedSystemId(selectedSystemId)
-		}
-		setOpen(false)
-		setBulkOpen(true)
-	}
-
-	const openAdd = () => {
-		setBulkOpen(false)
-		setOpen(true)
-	}
-
-	async function handleBulkSubmit(e: React.FormEvent) {
-		e.preventDefault()
-		setBulkLoading(true)
-		let closedForSubmit = false
-
-		try {
-			const system = systemId ?? bulkSelectedSystemId
-			if (!system) {
-				throw new Error("Select a system.")
-			}
-			const rawLines = bulkInput.split(/\r?\n/).filter((line) => line.trim())
-			if (!rawLines.length) {
-				throw new Error("Enter at least one probe.")
-			}
-
-			const payloads = rawLines.map((line, index) => parseBulkProbeLine(line, index + 1, system))
-			const existingProbeKeys = new Set(
-				probes.filter((probe) => probe.system === system).map((probe) => getProbeIdentityKey(probe))
-			)
-			const newPayloads = [] as typeof payloads
-
-			for (const payload of payloads) {
-				const probeKey = getProbeIdentityKey(payload)
-				if (existingProbeKeys.has(probeKey)) {
-					continue
-				}
-
-				existingProbeKeys.add(probeKey)
-				newPayloads.push(payload)
-			}
-
-			if (!newPayloads.length) {
-				throw new Error("No new probes. All entries exist.")
-			}
-
-			closedForSubmit = true
-			let batch = pb.createBatch()
-			let inBatch = 0
-			for (const payload of newPayloads) {
-				batch.collection("network_probes").create(payload)
-				inBatch++
-				if (inBatch > 20) {
-					await batch.send()
-					batch = pb.createBatch()
-					inBatch = 0
-				}
-			}
-			if (inBatch) {
-				await batch.send()
-			}
-
-			resetBulkForm()
-			toast({ title: t`Probes created`, description: `${newPayloads.length} probe(s) added.` })
-		} catch (err: unknown) {
-			if (closedForSubmit) {
-				setBulkOpen(true)
-			}
-			toast({ variant: "destructive", title: t`Error`, description: (err as Error)?.message })
-		} finally {
-			setBulkLoading(false)
-		}
-	}
-
-	return (
-		<>
-			<div className="flex gap-0 rounded-lg">
-				<Button variant="outline" onClick={openAdd} className="rounded-e-none grow">
-					{/* <PlusIcon className="size-4 me-1" /> */}
-					<Trans>Add {{ foo: t`Probe` }}</Trans>
-				</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" aria-label={t`More probe actions`}>
-							<ChevronDownIcon className="size-4" />
-						</Button>
-					</DropdownMenuTrigger>
-					<DropdownMenuContent align="end">
-						<DropdownMenuItem onClick={() => openBulkAdd(systemId)}>
-							<ListIcon className="size-4 me-2" />
-							<Trans>Bulk Add</Trans>
-						</DropdownMenuItem>
-					</DropdownMenuContent>
-				</DropdownMenu>
-			</div>
-			<Dialog
-				open={open}
-				onOpenChange={(nextOpen) => {
-					setOpen(nextOpen)
-				}}
-			>
-				<ProbeDialogContent open={open} setOpen={setOpen} systemId={systemId} onOpenBulkAdd={openBulkAdd} />
-			</Dialog>
-
-			<Sheet
-				open={bulkOpen}
-				onOpenChange={(nextOpen) => {
-					setBulkOpen(nextOpen)
-					if (!nextOpen) {
-						resetBulkForm()
-					}
-				}}
-			>
-				<SheetContent className="w-full sm:max-w-xl gap-0">
-					<SheetHeader className="border-b">
-						<SheetTitle>
-							<Trans>Bulk Add {{ foo: t`Network Probes` }}</Trans>
-						</SheetTitle>
-						<SheetDescription>target[,protocol[,port[,interval[,name]]]]</SheetDescription>
-					</SheetHeader>
-					<form ref={bulkFormRef} onSubmit={handleBulkSubmit} className="flex h-full flex-col overflow-hidden">
-						<div className="flex-1 flex flex-col space-y-4 overflow-auto p-4">
-							{!systemId && (
-								<div className="grid gap-2">
-									<Label className="sr-only">
-										<Trans>System</Trans>
-									</Label>
-									<Select value={bulkSelectedSystemId} onValueChange={setBulkSelectedSystemId} required>
-										<SelectTrigger className="relative ps-10 pe-5 bg-card">
-											<ServerIcon className="size-3.5 absolute start-4 top-1/2 -translate-y-1/2 opacity-85" />
-											<SelectValue placeholder={t`Select a system`} />
-										</SelectTrigger>
-										<SelectContent>
-											{systems.map((sys) => (
-												<SelectItem key={sys.id} value={sys.id}>
-													{sys.name}
-												</SelectItem>
-											))}
-										</SelectContent>
-									</Select>
-								</div>
-							)}
-							<div className="grow flex flex-col gap-2">
-								<Label htmlFor="bulk-probes" className="sr-only">
-									Entries
-								</Label>
-								<Textarea
-									id="bulk-probes"
-									value={bulkInput}
-									onChange={(e) => setBulkInput(e.target.value)}
-									onKeyDown={(e) => {
-										if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
-											e.preventDefault()
-											bulkFormRef.current?.requestSubmit()
-										}
-									}}
-									className="font-mono grow text-sm bg-card"
-									placeholder={["1.1.1.1", "example.com,tcp", "https://example.com,http,,60,Example"].join("\n")}
-									required
-								/>
-								<p className="text-xs text-muted-foreground">target[,protocol[,port[,interval[,name]]]]</p>
-							</div>
-						</div>
-						<SheetFooter className="border-t">
-							<Button type="submit" disabled={bulkLoading || (!systemId && !bulkSelectedSystemId)}>
-								<Trans>Add {{ foo: t`Network Probes` }}</Trans>
-							</Button>
-						</SheetFooter>
-					</form>
-				</SheetContent>
-			</Sheet>
-		</>
-	)
-}
-
-export function EditProbeDialog({
-	open,
-	setOpen,
-	systemId,
-	probe,
-}: {
-	open: boolean
-	setOpen: (open: boolean) => void
-	systemId?: string
-	probe?: NetworkProbeRecord
-}) {
-	const hasOpened = useRef(false)
-	if (!probe && !hasOpened.current) {
-		return null
-	}
-	hasOpened.current = true
-	return (
-		<Dialog open={open} onOpenChange={setOpen}>
-			<ProbeDialogContent open={open} setOpen={setOpen} systemId={systemId} probe={probe} />
-		</Dialog>
-	)
-}
-
-function ProbeDialogContent({
-	open,
-	setOpen,
-	systemId,
-	probe,
-	onOpenBulkAdd,
-}: {
-	open: boolean
-	setOpen: (open: boolean) => void
-	systemId?: string
-	probe?: NetworkProbeRecord
-	onOpenBulkAdd?: (selectedSystemId?: string) => void
-}) {
-	const [protocol, setProtocol] = useState<ProbeProtocol>(probe?.protocol ?? "icmp")
-	const [target, setTarget] = useState(probe?.target ?? "")
-	const [port, setPort] = useState(
-		(probe?.protocol === "tcp" || probe?.protocol === "http") && probe.port ? String(probe.port) : ""
-	)
-	const [probeInterval, setProbeInterval] = useState(String(probe?.interval ?? defaultInterval))
-	const [name, setName] = useState(probe?.name ?? "")
-	const [loading, setLoading] = useState(false)
-	const [selectedSystemId, setSelectedSystemId] = useState(probe?.system ?? "")
-	const systems = useStore($systems)
-	const { toast } = useToast()
-	const { t } = useLingui()
-	const isEditing = !!probe
-	const targetName = target.replace(/^https?:\/\//, "")
-
-	// When the dialog is opened, initialize form fields with probe values (if editing) or defaults (if adding).
-	useEffect(() => {
-		if (!open) {
-			return
-		}
-
-		setProtocol(probe?.protocol ?? "icmp")
-		setTarget(probe?.target ?? "")
-		setPort((probe?.protocol === "tcp" || probe?.protocol === "http") && probe.port ? String(probe.port) : "")
-		setProbeInterval(String(probe?.interval ?? defaultInterval))
-		setName(probe?.name ?? "")
-		setSelectedSystemId(probe?.system ?? "")
-		setLoading(false)
-	}, [open, probe])
-
-	async function handleSubmit(e: React.FormEvent) {
-		e.preventDefault()
-		setLoading(true)
-
-		try {
-			const selectedSystem = systemId ?? selectedSystemId
-			if (!selectedSystem) {
-				throw new Error("Select a system.")
-			}
-			const payload = buildProbePayload(
-				{
-					system: selectedSystem,
-					target,
-					protocol,
-					port: protocol === "tcp" || protocol === "http" ? Number(port) : 0,
-					interval: probeInterval,
-					name,
-				},
-				probe ? probe.enabled : true
-			)
-			if (probe) {
-				await pb.collection("network_probes").update(probe.id, payload)
-			} else {
-				await pb.collection("network_probes").create(payload)
-			}
-			setOpen(false)
-		} catch (err: unknown) {
-			toast({ variant: "destructive", title: t`Error`, description: (err as Error)?.message })
-		} finally {
-			setLoading(false)
-		}
-	}
-
-	return (
-		<DialogContent className="max-w-md">
-			<DialogHeader>
-				<DialogTitle>
-					{isEditing ? <Trans>Edit {{ foo: t`Network Probe` }}</Trans> : <Trans>Add {{ foo: t`Network Probe` }}</Trans>}
-				</DialogTitle>
-				<DialogDescription>
-					<Trans>Configure response monitoring from this agent.</Trans>
-				</DialogDescription>
-			</DialogHeader>
-			<form onSubmit={handleSubmit} className="grid gap-4 tabular-nums">
-				{!systemId && (
-					<div className="grid gap-2">
-						<Label>
-							<Trans>System</Trans>
-						</Label>
-						<Select value={selectedSystemId} onValueChange={setSelectedSystemId} required>
-							<SelectTrigger>
-								<SelectValue placeholder={t`Select a system`} />
-							</SelectTrigger>
-							<SelectContent>
-								{systems.map((sys) => (
-									<SelectItem key={sys.id} value={sys.id}>
-										{sys.name}
-									</SelectItem>
-								))}
-							</SelectContent>
-						</Select>
-					</div>
-				)}
-				<div className="grid gap-2">
-					<Label>
-						<Trans>Target</Trans>
-					</Label>
-					<Input
-						value={target}
-						onChange={(e) => setTarget(e.target.value)}
-						placeholder={protocol === "http" ? "https://example.com" : "1.1.1.1"}
-						required
-					/>
-				</div>
-				<div className="grid gap-2">
-					<Label>
-						<Trans>Protocol</Trans>
-					</Label>
-
-					<Select value={protocol} onValueChange={(value) => setProtocol(value as ProbeProtocol)}>
-						<SelectTrigger>
-							<SelectValue />
-						</SelectTrigger>
-						<SelectContent>
-							<SelectItem value="icmp">ICMP</SelectItem>
-							<SelectItem value="tcp">TCP</SelectItem>
-							<SelectItem value="http">HTTP</SelectItem>
-						</SelectContent>
-					</Select>
-				</div>
-				{(protocol === "tcp" || protocol === "http") && (
-					<div className="grid gap-2">
-						<Label>
-							<Trans>Port</Trans>
-						</Label>
-						<Input
-							type="number"
-							value={port}
-							onChange={(e) => setPort(e.target.value)}
-							placeholder="443"
-							min={1}
-							max={65535}
-						/>
-					</div>
-				)}
-				<div className="grid gap-2">
-					<Label>
-						<Trans>Interval (seconds)</Trans>
-					</Label>
-					<Input
-						type="number"
-						value={probeInterval}
-						onChange={(e) => setProbeInterval(e.target.value)}
-						min={1}
-						max={3600}
-						required
-					/>
-				</div>
-				<div className="grid gap-2">
-					<Label>
-						<Trans>Name (optional)</Trans>
-					</Label>
-					<Input
-						value={name}
-						onChange={(e) => setName(e.target.value)}
-						placeholder={targetName || t`e.g. Cloudflare DNS`}
-					/>
-				</div>
-				<DialogFooter>
-					{!isEditing && onOpenBulkAdd && (
-						<Button
-							type="button"
-							variant="outline"
-							onClick={() => onOpenBulkAdd(selectedSystemId)}
-							disabled={loading}
-							className="me-auto"
-						>
-							<ListIcon className="size-4 me-2" />
-							<Trans>Bulk Add</Trans>
-						</Button>
-					)}
-					<Button type="submit" disabled={loading || (!systemId && !selectedSystemId)}>
-						{loading ? (
-							isEditing ? (
-								<Trans>Saving...</Trans>
-							) : (
-								<Trans>Creating...</Trans>
-							)
-						) : isEditing ? (
-							<Trans>Save {{ foo: t`Probe` }}</Trans>
-						) : (
-							<Trans>Add {{ foo: t`Probe` }}</Trans>
-						)}
-					</Button>
-				</DialogFooter>
-			</form>
-		</DialogContent>
-	)
-}

internal/site/src/components/router.tsx

@@ -4,7 +4,6 @@ const routes = {
 	home: "/",
 	containers: "/containers",
 	smart: "/smart",
-	probes: "/probes",
 	system: `/system/:id`,
 	settings: `/settings/:name?`,
 	forgot_password: `/forgot-password`,

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

@@ -1,25 +0,0 @@
-import { useLingui } from "@lingui/react/macro"
-import { memo, useEffect } from "react"
-import NetworkProbesTableNew from "@/components/network-probes-table/network-probes-table"
-import { ActiveAlerts } from "@/components/active-alerts"
-import { FooterRepoLink } from "@/components/footer-repo-link"
-import { useNetworkProbes } from "@/lib/use-network-probes"
-
-export default memo(() => {
-	const { t } = useLingui()
-	const probes = useNetworkProbes({})
-
-	useEffect(() => {
-		document.title = `${t`Network Probes`} / Beszel`
-	}, [t])
-
-	return (
-		<>
-			<div className="grid gap-4">
-				<ActiveAlerts />
-				<NetworkProbesTableNew probes={probes} />
-			</div>
-			<FooterRepoLink />
-		</>
-	)
-})

internal/site/src/components/routes/settings/notifications.tsx

@@ -24,7 +24,7 @@ interface ShoutrrrUrlCardProps {
 }
 
 const NotificationSchema = v.object({
-	emails: v.array(v.pipe(v.string(), v.email())),
+	emails: v.array(v.pipe(v.string(), v.rfcEmail())),
 	webhooks: v.array(v.pipe(v.string(), v.url())),
 })
 

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

@@ -11,9 +11,9 @@ import { RootDiskCharts, ExtraFsCharts } from "./system/charts/disk-charts"
 import { BandwidthChart, ContainerNetworkChart } from "./system/charts/network-charts"
 import { TemperatureChart, BatteryChart } from "./system/charts/sensor-charts"
 import { GpuPowerChart, GpuDetailCharts } from "./system/charts/gpu-charts"
-import { LazyContainersTable, LazySmartTable, LazySystemdTable, LazyNetworkProbesTable } from "./system/lazy-tables"
+import { LazyContainersTable, LazySmartTable, LazySystemdTable } from "./system/lazy-tables"
 import { LoadAverageChart } from "./system/charts/load-average-chart"
-import { ContainerIcon, CpuIcon, HardDriveIcon, NetworkIcon, TerminalSquareIcon } from "lucide-react"
+import { ContainerIcon, CpuIcon, HardDriveIcon, TerminalSquareIcon } from "lucide-react"
 import { GpuIcon } from "../ui/icons"
 import SystemdTable from "../systemd-table/systemd-table"
 import ContainersTable from "../containers-table/containers-table"
@@ -65,7 +65,7 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 	const hasGpu = hasGpuData || hasGpuPowerData
 
 	// keep tabsRef in sync for keyboard navigation
-	const tabs = ["core", "network", "disk"]
+	const tabs = ["core", "disk"]
 	if (hasGpu) tabs.push("gpu")
 	if (hasContainers) tabs.push("containers")
 	if (hasSystemd) tabs.push("services")
@@ -145,8 +145,6 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 				{hasContainersTable && <LazyContainersTable systemId={system.id} />}
 
 				{hasSystemd && <LazySystemdTable systemId={system.id} />}
-
-				<LazyNetworkProbesTable systemId={system.id} systemData={systemData} />
 			</>
 		)
 	}
@@ -159,10 +157,6 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 						<CpuIcon className="size-3.5" />
 						<Trans context="Core system metrics">Core</Trans>
 					</TabsTrigger>
-					<TabsTrigger value="network" className="w-full flex items-center gap-1.5">
-						<NetworkIcon className="size-3.5" />
-						<Trans>Network</Trans>
-					</TabsTrigger>
 					<TabsTrigger value="disk" className="w-full flex items-center gap-1.5">
 						<HardDriveIcon className="size-3.5" />
 						<Trans>Disk</Trans>
@@ -190,26 +184,16 @@ export default memo(function SystemDetail({ id }: { id: string }) {
 				<TabsContent value="core" forceMount className={activeTab === "core" ? "contents" : "hidden"}>
 					<div className="grid xl:grid-cols-2 gap-4">
 						<CpuChart {...coreProps} />
-						<LoadAverageChart chartData={chartData} grid={grid} dataEmpty={dataEmpty} />
 						<MemoryChart {...coreProps} />
-						<SwapChart chartData={chartData} grid={grid} dataEmpty={dataEmpty} systemStats={systemStats} />
+						<LoadAverageChart chartData={chartData} grid={grid} dataEmpty={dataEmpty} />
+						<BandwidthChart {...coreProps} systemStats={systemStats} />
 						<TemperatureChart {...coreProps} setPageBottomExtraMargin={setPageBottomExtraMargin} />
 						<BatteryChart {...coreProps} />
+						<SwapChart chartData={chartData} grid={grid} dataEmpty={dataEmpty} systemStats={systemStats} />
 						{pageBottomExtraMargin > 0 && <div style={{ marginBottom: pageBottomExtraMargin }}></div>}
 					</div>
 				</TabsContent>
 
-				<TabsContent value="network" forceMount className={activeTab === "network" ? "contents" : "hidden"}>
-					{mountedTabs.has("network") && (
-						<>
-							<div className="grid xl:grid-cols-2 gap-4">
-								<BandwidthChart {...coreProps} systemStats={systemStats} />
-							</div>
-							<LazyNetworkProbesTable systemId={system.id} systemData={systemData} />
-						</>
-					)}
-				</TabsContent>
-
 				<TabsContent value="disk" forceMount className={activeTab === "disk" ? "contents" : "hidden"}>
 					{mountedTabs.has("disk") && (
 						<>

internal/site/src/components/routes/system/chart-data.ts

@@ -1,13 +1,7 @@
+import { timeTicks } from "d3-time"
 import { getPbTimestamp, pb } from "@/lib/api"
 import { chartTimeData } from "@/lib/utils"
-import type {
-	ChartData,
-	ChartDataContainer,
-	ChartTimes,
-	ContainerStatsRecord,
-	NetworkProbeStatsRecord,
-	SystemStatsRecord,
-} from "@/types"
+import type { ChartData, ChartTimes, ContainerStatsRecord, SystemStatsRecord } from "@/types"
 
 type ChartTimeData = {
 	time: number
@@ -23,10 +17,31 @@ export const cache = new Map<
 	ChartTimeData | SystemStatsRecord[] | ContainerStatsRecord[] | ChartData["containerData"]
 >()
 
+// create ticks and domain for charts
+export function getTimeData(chartTime: ChartTimes, lastCreated: number) {
+	const cached = cache.get("td") as ChartTimeData | undefined
+	if (cached && cached.chartTime === chartTime) {
+		if (!lastCreated || cached.time >= lastCreated) {
+			return cached.data
+		}
+	}
+
+	// const buffer = chartTime === "1m" ? 400 : 20_000
+	const now = new Date(Date.now())
+	const startTime = chartTimeData[chartTime].getOffset(now)
+	const ticks = timeTicks(startTime, now, chartTimeData[chartTime].ticks ?? 12).map((date) => date.getTime())
+	const data = {
+		ticks,
+		domain: [chartTimeData[chartTime].getOffset(now).getTime(), now.getTime()],
+	}
+	cache.set("td", { time: now.getTime(), data, chartTime })
+	return data
+}
+
 /** Append new records onto prev with gap detection. Converts string `created` values to ms timestamps in place.
  * Pass `maxLen` to cap the result length in one copy instead of slicing again after the call. */
 export function appendData<T extends { created: string | number | null }>(
-	prev: T[] = [],
+	prev: T[],
 	newRecords: T[],
 	expectedInterval: number,
 	maxLen?: number
@@ -51,18 +66,17 @@ export function appendData<T extends { created: string | number | null }>(
 	return result
 }
 
-export async function getStats<T extends SystemStatsRecord | ContainerStatsRecord | NetworkProbeStatsRecord>(
+export async function getStats<T extends SystemStatsRecord | ContainerStatsRecord>(
 	collection: string,
 	systemId: string,
-	chartTime: ChartTimes,
-	cachedStats?: { created: string | number | null }[],
-	createdIsNumber?: boolean
+	chartTime: ChartTimes
 ): Promise<T[]> {
+	const cachedStats = cache.get(`${systemId}_${chartTime}_${collection}`) as T[] | undefined
 	const lastCached = cachedStats?.at(-1)?.created as number
 	return await pb.collection<T>(collection).getFullList({
 		filter: pb.filter("system={:id} && created > {:created} && type={:type}", {
 			id: systemId,
-			created: getPbTimestamp(chartTime, lastCached ? new Date(lastCached + 1000) : undefined, createdIsNumber),
+			created: getPbTimestamp(chartTime, lastCached ? new Date(lastCached + 1000) : undefined),
 			type: chartTimeData[chartTime].type,
 		}),
 		fields: "created,stats",
@@ -70,11 +84,11 @@ export async function getStats<T extends SystemStatsRecord | ContainerStatsRecor
 	})
 }
 
-export function makeContainerData(containers: ContainerStatsRecord[]): ChartDataContainer[] {
-	const result = [] as ChartDataContainer[]
+export function makeContainerData(containers: ContainerStatsRecord[]): ChartData["containerData"] {
+	const result = [] as ChartData["containerData"]
 	for (const { created, stats } of containers) {
 		if (!created) {
-			result.push({ created: null } as ChartDataContainer)
+			result.push({ created: null } as ChartData["containerData"][0])
 			continue
 		}
 		result.push(makeContainerPoint(new Date(created).getTime(), stats))
@@ -83,8 +97,11 @@ export function makeContainerData(containers: ContainerStatsRecord[]): ChartData
 }
 
 /** Transform a single realtime container stats message into a ChartDataContainer point. */
-export function makeContainerPoint(created: number, stats: ContainerStatsRecord["stats"]): ChartDataContainer {
-	const point: ChartDataContainer = { created } as ChartDataContainer
+export function makeContainerPoint(
+	created: number,
+	stats: ContainerStatsRecord["stats"]
+): ChartData["containerData"][0] {
+	const point: ChartData["containerData"][0] = { created } as ChartData["containerData"][0]
 	for (const container of stats) {
 		;(point as Record<string, unknown>)[container.n] = container
 	}

internal/site/src/components/routes/system/charts/probes-charts.tsx

@@ -1,237 +0,0 @@
-import LineChartDefault from "@/components/charts/line-chart"
-import type { DataPoint } from "@/components/charts/line-chart"
-import { decimalString, formatMicroseconds, toFixedFloat } from "@/lib/utils"
-import { useLingui } from "@lingui/react/macro"
-import { ChartCard, FilterBar } from "../chart-card"
-import type { ChartData, NetworkProbeRecord, NetworkProbeStatsRecord } from "@/types"
-import { useMemo } from "react"
-import { atom } from "nanostores"
-import { useStore } from "@nanostores/react"
-
-const $filter = atom("")
-
-type ProbeChartProps = {
-	probeStats: NetworkProbeStatsRecord[]
-	grid?: boolean
-	probes: NetworkProbeRecord[]
-	chartData: ChartData
-	empty: boolean
-	showFilter?: boolean
-}
-
-type ProbeChartBaseProps = ProbeChartProps & {
-	valueIndex: number
-	title: string
-	description: string
-	tickFormatter: (value: number) => string
-	contentFormatter: ({ value }: { value: number | string }) => string | number
-	domain?: [number | "auto", number | "auto"]
-}
-
-function ProbeChart({
-	probeStats,
-	grid,
-	probes,
-	chartData,
-	empty,
-	valueIndex,
-	title,
-	description,
-	tickFormatter,
-	contentFormatter,
-	domain,
-	showFilter = probes.length > 1,
-}: ProbeChartBaseProps) {
-	const storedFilter = useStore($filter)
-	const filter = showFilter ? storedFilter : ""
-
-	const { dataPoints, visibleKeys } = useMemo(() => {
-		const sortedProbes = [...probes].sort((a, b) => b.resAvg1h - a.resAvg1h)
-		const count = sortedProbes.length
-		const points: DataPoint<NetworkProbeStatsRecord>[] = []
-		const visibleIDs: string[] = []
-		const filterTerms = filter
-			? filter
-					.toLowerCase()
-					.split(" ")
-					.filter((term) => term.length > 0)
-			: []
-		const dot = chartData.chartTime === "1m"
-		for (let i = 0; i < count; i++) {
-			const p = sortedProbes[i]
-			const label = p.name || p.target
-			const filtered = filterTerms.length > 0 && !filterTerms.some((term) => label.toLowerCase().includes(term))
-			if (filtered) {
-				continue
-			}
-			visibleIDs.push(p.id)
-			points.push({
-				order: i,
-				label,
-				dataKey: (record: NetworkProbeStatsRecord) => record.stats?.[p.id]?.[valueIndex] ?? "-",
-				dot,
-				color: count <= 5 ? i + 1 : `hsl(${(i * 360) / count}, var(--chart-saturation), var(--chart-lightness))`,
-			})
-		}
-		return { dataPoints: points, visibleKeys: visibleIDs }
-	}, [probes, filter, valueIndex, chartData.chartTime])
-
-	const filteredProbeStats = useMemo(() => {
-		if (!visibleKeys.length) return probeStats
-		return probeStats.filter((record) => visibleKeys.some((id) => record.stats?.[id] != null))
-	}, [probeStats, visibleKeys])
-
-	const legend = dataPoints.length < 10 && dataPoints.length > 1
-
-	return (
-		<ChartCard
-			legend={legend || !showFilter}
-			cornerEl={showFilter ? <FilterBar store={$filter} /> : undefined}
-			empty={empty}
-			title={title}
-			description={description}
-			grid={grid}
-		>
-			<LineChartDefault
-				truncate
-				chartData={chartData}
-				customData={filteredProbeStats}
-				dataPoints={dataPoints}
-				domain={domain ?? ["auto", "auto"]}
-				connectNulls
-				tickFormatter={tickFormatter}
-				contentFormatter={contentFormatter}
-				legend={legend}
-				filter={filter}
-			/>
-		</ChartCard>
-	)
-}
-
-export function ResponseChart({ probeStats, grid, probes, chartData, empty }: ProbeChartProps) {
-	const { t } = useLingui()
-
-	return (
-		<ProbeChart
-			probeStats={probeStats}
-			grid={grid}
-			probes={probes}
-			chartData={chartData}
-			empty={empty}
-			valueIndex={0}
-			title={t`Response`}
-			description={t`Average response time`}
-			tickFormatter={(value) => formatMicroseconds(value, false)}
-			contentFormatter={({ value }) => {
-				if (typeof value !== "number") {
-					return value
-				}
-				return formatMicroseconds(value)
-			}}
-		/>
-	)
-}
-
-interface AvgMinMaxResponseChartProps {
-	probeStats: NetworkProbeStatsRecord[]
-	probe: NetworkProbeRecord | null
-	chartData: ChartData
-	empty: boolean
-}
-
-export function AvgMinMaxResponseChart({ probeStats, probe, chartData, empty }: AvgMinMaxResponseChartProps) {
-	const { t } = useLingui()
-
-	const { chartTime } = chartData
-	const hasLongInterval = (probe?.interval ?? 61) > 60
-
-	// only one probe is relevant for this chart
-	const dataPoints: DataPoint<NetworkProbeStatsRecord>[] = useMemo(() => {
-		const dataFn = (index: number) => (record: NetworkProbeStatsRecord) =>
-			record.stats?.[probe?.id ?? ""]?.[index] ?? "-"
-		const avgPoint = {
-			label: "Avg",
-			dataKey: dataFn(0),
-			color: 1,
-			order: 0,
-		}
-		if (chartTime === "1m" || (hasLongInterval && chartTime === "1h")) {
-			// avg, min, max are all the same for 1m interval, so just show avg
-			return [avgPoint]
-		}
-		return [
-			{
-				label: "Max",
-				dataKey: dataFn(2),
-				color: 3,
-				order: 0,
-			},
-			avgPoint,
-			{
-				label: "Min",
-				dataKey: dataFn(1),
-				color: 2,
-				order: 2,
-			},
-		]
-	}, [chartTime, hasLongInterval])
-
-	const data = useMemo(() => {
-		if (!probe) return []
-		return probeStats.filter((record) => record.stats && probe.id in record.stats)
-	}, [probe, probeStats])
-
-	const legend = dataPoints.length > 1
-
-	return (
-		<ChartCard
-			legend={true}
-			empty={empty}
-			title={t`Response`}
-			description={t`Average, minimum, and maximum response time`}
-			grid={false}
-		>
-			<LineChartDefault
-				truncate
-				chartData={chartData}
-				customData={data}
-				dataPoints={dataPoints}
-				domain={["auto", "auto"]}
-				connectNulls
-				legend={legend}
-				tickFormatter={(value) => formatMicroseconds(value, false)}
-				contentFormatter={({ value }) => {
-					if (typeof value !== "number") {
-						return value
-					}
-					return formatMicroseconds(value)
-				}}
-			/>
-		</ChartCard>
-	)
-}
-
-export function LossChart({ probeStats, grid, probes, chartData, empty }: ProbeChartProps) {
-	const { t } = useLingui()
-
-	return (
-		<ProbeChart
-			probeStats={probeStats}
-			grid={grid}
-			probes={probes}
-			chartData={chartData}
-			empty={empty}
-			valueIndex={3}
-			title={t`Loss`}
-			description={t`Packet loss (%)`}
-			domain={[0, 100]}
-			tickFormatter={(value) => `${toFixedFloat(value, value >= 10 ? 0 : 1)}%`}
-			contentFormatter={({ value }) => {
-				if (typeof value !== "number") {
-					return value
-				}
-				return `${decimalString(value, 2)}%`
-			}}
-		/>
-	)
-}

internal/site/src/components/routes/system/charts/sensor-charts.tsx

@@ -120,7 +120,8 @@ export function TemperatureChart({
 				label: key,
 				dataKey: dataKeys[key],
 				color: colorMap[key],
-				opacity: strokeOpacity,
+				strokeOpacity,
+				activeDot: !filtered,
 			}
 		})
 	}, [sortedKeys, filter, dataKeys, colorMap])
@@ -134,7 +135,7 @@ export function TemperatureChart({
 	// 			label: `Test ${++i}`,
 	// 			dataKey: () => 0,
 	// 			color: "red",
-	// 			opacity: 1,
+	// 			strokeOpacity: 1,
 	// 		})
 	// 	}
 	// }
@@ -202,6 +203,7 @@ export function TemperatureChart({
 						return `${decimalString(value)} ${unit}`
 					}}
 					dataPoints={dataPoints}
+					filter={filter}
 				></LineChartDefault>
 			</ChartCard>
 		</div>

internal/site/src/components/routes/system/lazy-tables.tsx

@@ -1,11 +1,6 @@
 import { lazy } from "react"
 import { useIntersectionObserver } from "@/lib/use-intersection-observer"
 import { cn } from "@/lib/utils"
-import { ResponseChart, LossChart } from "./charts/probes-charts"
-import type { SystemData } from "./use-system-data"
-import { $chartTime } from "@/lib/stores"
-import { useStore } from "@nanostores/react"
-import { useNetworkProbes, useNetworkProbeStats } from "@/lib/use-network-probes"
 
 const ContainersTable = lazy(() => import("../../containers-table/containers-table"))
 
@@ -39,47 +34,3 @@ export function LazySystemdTable({ systemId }: { systemId: string }) {
 		</div>
 	)
 }
-
-const NetworkProbesTable = lazy(() => import("@/components/network-probes-table/network-probes-table"))
-
-export function LazyNetworkProbesTable({ systemId, systemData }: { systemId: string; systemData: SystemData }) {
-	const { isIntersecting, ref } = useIntersectionObserver()
-
-	return (
-		<div ref={ref} className={cn(isIntersecting && "contents")}>
-			{isIntersecting && <ProbesTable systemId={systemId} systemData={systemData} />}
-		</div>
-	)
-}
-
-function ProbesTable({ systemId, systemData }: { systemId: string; systemData: SystemData }) {
-	const { grid, chartData } = systemData ?? {}
-	const chartTime = useStore($chartTime)
-
-	const probes = useNetworkProbes({ systemId })
-	const probeStats = useNetworkProbeStats({ systemId, chartTime })
-
-	return (
-		<>
-			<NetworkProbesTable systemId={systemId} probes={probes} />
-			{!!chartData && !!probes.length && (
-				<div className="grid xl:grid-cols-2 gap-4">
-					<ResponseChart
-						probeStats={probeStats}
-						grid={grid}
-						probes={probes}
-						chartData={chartData}
-						empty={!probeStats.length}
-					/>
-					<LossChart
-						probeStats={probeStats}
-						grid={grid}
-						probes={probes}
-						chartData={chartData}
-						empty={!probeStats.length}
-					/>
-				</div>
-			)}
-		</>
-	)
-}

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

@@ -43,6 +43,7 @@ import {
 	toFixedFloat,
 	formatTemperature,
 	cn,
+	getVisualStringWidth,
 	secondsToString,
 	hourWithSeconds,
 	formatShortDate,
@@ -105,9 +106,9 @@ function formatCapacity(bytes: number): string {
 const SMART_DEVICE_FIELDS = "id,system,name,model,state,capacity,temp,type,hours,cycles,updated"
 
 export const createColumns = (
-	longestName: string,
-	longestModel: string,
-	longestDevice: string
+	longestName: number,
+	longestModel: number,
+	longestDevice: number
 ): ColumnDef<SmartDeviceRecord>[] => [
 	{
 		id: "system",
@@ -122,11 +123,8 @@ export const createColumns = (
 		cell: ({ getValue }) => {
 			const allSystems = useStore($allSystemsById)
 			return (
-				<div className="ms-1.5 relative w-fit max-w-44">
-					<span className="invisible block whitespace-nowrap" aria-hidden="true">
-						{longestName}
-					</span>
-					<span className="absolute inset-0 truncate">{allSystems[getValue() as string]?.name ?? ""}</span>
+				<div className="ms-1.5 max-w-40 block truncate" style={{ width: `${longestName / 1.05}ch` }}>
+					{allSystems[getValue() as string]?.name ?? ""}
 				</div>
 			)
 		},
@@ -136,11 +134,12 @@ export const createColumns = (
 		sortingFn: (a, b) => a.original.name.localeCompare(b.original.name),
 		header: ({ column }) => <HeaderButton column={column} name={t`Device`} Icon={HardDrive} />,
 		cell: ({ getValue }) => (
-			<div className="font-medium ms-1 relative w-fit max-w-44" title={getValue() as string}>
-				<span className="invisible block whitespace-nowrap" aria-hidden="true">
-					{longestDevice}
-				</span>
-				<span className="absolute inset-0 truncate">{getValue() as string}</span>
+			<div
+				className="font-medium max-w-40 truncate ms-1"
+				title={getValue() as string}
+				style={{ width: `${longestDevice / 1.05}ch` }}
+			>
+				{getValue() as string}
 			</div>
 		),
 	},
@@ -151,11 +150,12 @@ export const createColumns = (
 			<HeaderButton column={column} name={t({ message: "Model", comment: "Device model" })} Icon={Box} />
 		),
 		cell: ({ getValue }) => (
-			<div className="ms-1 relative w-fit max-w-44" title={getValue() as string}>
-				<span className="invisible block whitespace-nowrap" aria-hidden="true">
-					{longestModel}
-				</span>
-				<span className="absolute inset-0 truncate">{getValue() as string}</span>
+			<div
+				className="max-w-48 truncate ms-1"
+				title={getValue() as string}
+				style={{ width: `${longestModel / 1.05}ch` }}
+			>
+				{getValue() as string}
 			</div>
 		),
 	},
@@ -309,7 +309,7 @@ export default function DisksTable({ systemId }: { systemId?: string }) {
 
 	// Calculate the right width for the columns based on the longest strings among the displayed devices
 	const { longestName, longestModel, longestDevice } = useMemo(() => {
-		const result = { longestName: "", longestModel: "", longestDevice: "" }
+		const result = { longestName: 0, longestModel: 0, longestDevice: 0 }
 		if (!smartDevices || Object.keys(allSystems).length === 0) {
 			return result
 		}
@@ -318,16 +318,10 @@ export default function DisksTable({ systemId }: { systemId?: string }) {
 			if (!systemId && !seenSystems.has(device.system)) {
 				seenSystems.add(device.system)
 				const name = allSystems[device.system]?.name ?? ""
-				if (name.length > result.longestName.length) {
-					result.longestName = name
-				}
-			}
-			if ((device.model ?? "").length > result.longestModel.length) {
-				result.longestModel = device.model ?? ""
-			}
-			if ((device.name ?? "").length > result.longestDevice.length) {
-				result.longestDevice = device.name ?? ""
+				result.longestName = Math.max(result.longestName, getVisualStringWidth(name))
 			}
+			result.longestModel = Math.max(result.longestModel, getVisualStringWidth(device.model ?? ""))
+			result.longestDevice = Math.max(result.longestDevice, getVisualStringWidth(device.name ?? ""))
 		}
 		return result
 	}, [smartDevices, systemId, allSystems])

internal/site/src/components/routes/system/use-system-data.ts

@@ -26,7 +26,7 @@ import type {
 	SystemStatsRecord,
 } from "@/types"
 import { $router, navigate } from "../../router"
-import { appendData, cache, getStats, makeContainerData, makeContainerPoint } from "./chart-data"
+import { appendData, cache, getStats, getTimeData, makeContainerData, makeContainerPoint } from "./chart-data"
 
 export type SystemData = ReturnType<typeof useSystemData>
 
@@ -151,11 +151,16 @@ export function useSystemData(id: string) {
 	const agentVersion = useMemo(() => parseSemVer(system?.info?.v), [system?.info?.v])
 
 	const chartData: ChartData = useMemo(() => {
+		const lastCreated = Math.max(
+			(systemStats.at(-1)?.created as number) ?? 0,
+			(containerData.at(-1)?.created as number) ?? 0
+		)
 		return {
 			systemStats,
 			containerData,
 			chartTime,
 			orientation: direction === "rtl" ? "right" : "left",
+			...getTimeData(chartTime, lastCreated),
 			agentVersion,
 		}
 	}, [systemStats, containerData, direction])
@@ -195,8 +200,8 @@ export function useSystemData(id: string) {
 		}
 
 		Promise.allSettled([
-			getStats<SystemStatsRecord>("system_stats", systemId, chartTime, cachedSystemStats),
-			getStats<ContainerStatsRecord>("container_stats", systemId, chartTime, cachedContainerData),
+			getStats<SystemStatsRecord>("system_stats", systemId, chartTime),
+			getStats<ContainerStatsRecord>("container_stats", systemId, chartTime),
 		]).then(([systemStats, containerStats]) => {
 			// If another request has been made since this one, ignore the results
 			if (requestId !== statsRequestId.current) {
@@ -288,7 +293,7 @@ export function useSystemData(id: string) {
 	// derived values
 	const isLongerChart = !["1m", "1h"].includes(chartTime)
 	const showMax = maxValues && isLongerChart
-	const dataEmpty = !chartLoading && chartData.systemStats?.length === 0
+	const dataEmpty = !chartLoading && chartData.systemStats.length === 0
 	const lastGpus = systemStats.at(-1)?.stats?.g
 	const isPodman = details?.podman ?? system.info?.p ?? false
 

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

@@ -26,7 +26,7 @@ import { memo, useMemo, useRef, useState } from "react"
 import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip"
 import { isReadOnlyUser, pb } from "@/lib/api"
 import { BatteryState, ConnectionType, connectionTypeLabels, MeterState, SystemStatus } from "@/lib/enums"
-import { $longestSystemName, $userSettings } from "@/lib/stores"
+import { $longestSystemNameLen, $userSettings } from "@/lib/stores"
 import {
 	cn,
 	copyToClipboard,
@@ -135,7 +135,7 @@ export function SystemsTableColumns(viewMode: "table" | "grid"): ColumnDef<Syste
 			Icon: ServerIcon,
 			cell: (info) => {
 				const { name, id } = info.row.original
-				const longestName = useStore($longestSystemName)
+				const longestName = useStore($longestSystemNameLen)
 				const linkUrl = getPagePath($router, "system", { id })
 
 				return (
@@ -145,7 +145,8 @@ export function SystemsTableColumns(viewMode: "table" | "grid"): ColumnDef<Syste
 							<Link
 								href={linkUrl}
 								tabIndex={-1}
-								className="relative w-fit max-w-48 z-10"
+								className="truncate z-10 relative"
+								style={{ width: `${longestName / 1.05}ch` }}
 								onMouseEnter={(e) => {
 									// set title on hover if text is truncated to show full name
 									const a = e.currentTarget
@@ -156,10 +157,7 @@ export function SystemsTableColumns(viewMode: "table" | "grid"): ColumnDef<Syste
 									}
 								}}
 							>
-								<span className="invisible block" aria-hidden="true">
-									{longestName}
-								</span>
-								<span className="absolute inset-0 truncate">{name}</span>
+								{name}
 							</Link>
 						</span>
 						<Link href={linkUrl} className="inset-0 absolute size-full" aria-label={name}></Link>

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

@@ -1,11 +1,11 @@
+import type { JSX } from "react"
 import { useLingui } from "@lingui/react/macro"
 import * as React from "react"
 import * as RechartsPrimitive from "recharts"
 import { chartTimeData, cn } from "@/lib/utils"
-import type { ChartTimes } from "@/types"
+import type { ChartData } from "@/types"
 import { Separator } from "./separator"
-import type { AxisDomain } from "recharts/types/util/types"
-import { timeTicks } from "d3-time"
+import { AxisDomain } from "recharts/types/util/types"
 
 // Format: { THEME_NAME: CSS_SELECTOR }
 const THEMES = { light: "", dark: ".dark" } as const
@@ -101,7 +101,7 @@ const ChartTooltipContent = React.forwardRef<
 			labelKey?: string
 			unit?: string
 			filter?: string
-			contentFormatter?: (item: unknown, key: string) => React.ReactNode | string
+			contentFormatter?: (item: any, key: string) => React.ReactNode | string
 			truncate?: boolean
 			showTotal?: boolean
 			totalLabel?: React.ReactNode
@@ -175,13 +175,7 @@ const ChartTooltipContent = React.forwardRef<
 			}
 
 			const totalKey = "__total__"
-			const totalItem: {
-				value: number
-				name: string
-				dataKey: string
-				color: string | undefined
-				payload?: unknown
-			} = {
+			const totalItem: any = {
 				value: totalValue,
 				name: totalName,
 				dataKey: totalKey,
@@ -406,57 +400,26 @@ function getPayloadConfigFromPayload(config: ChartConfig, payload: unknown, key:
 	return configLabelKey in config ? config[configLabelKey] : config[key as keyof typeof config]
 }
 
-interface XAxisData {
-	el: React.ReactElement
-	domain: [number, number]
-}
-
-const xAxisCache = new Map<ChartTimes, XAxisData>()
-
-function createXAxisData(chartTime: ChartTimes): XAxisData {
-	// console.log("Creating XAxis for", chartTime, new Date())
-	const axisEndTime = Date.now() + 500
-	const axisEndDate = new Date(axisEndTime)
-	const startTime = chartTimeData[chartTime].getOffset(axisEndDate)
-	const ticks = timeTicks(startTime, axisEndDate, chartTimeData[chartTime].ticks ?? 12).map((date) => date.getTime())
-	const domain: [number, number] = [startTime.getTime(), axisEndTime]
-
-	return {
-		domain,
-		el: (
-			<RechartsPrimitive.XAxis
-				dataKey="created"
-				domain={domain}
-				ticks={ticks}
-				allowDataOverflow
-				type="number"
-				scale="time"
-				minTickGap={12}
-				tickMargin={8}
-				axisLine={false}
-				tickFormatter={chartTimeData[chartTime].format}
-			/>
-		),
+let cachedAxis: JSX.Element
+const xAxis = ({ domain, ticks, chartTime }: ChartData) => {
+	if (cachedAxis && domain[0] === cachedAxis.props.domain[0]) {
+		return cachedAxis
 	}
-}
-
-function xAxis(chartTime: ChartTimes, lastCreated: number) {
-	if (!lastCreated) {
-		return null
-	}
-	const cachedAxis = xAxisCache.get(chartTime)
-
-	const expectedInterval = chartTimeData[chartTime].expectedInterval
-	const conservativeEndTime = Date.now() - expectedInterval / 2
-	const axisEndTime = Math.max(lastCreated, conservativeEndTime)
-
-	if (cachedAxis && axisEndTime < cachedAxis.domain[1]) {
-		return cachedAxis.el
-	}
-
-	const axisData = createXAxisData(chartTime)
-	xAxisCache.set(chartTime, axisData)
-	return axisData.el
+	cachedAxis = (
+		<RechartsPrimitive.XAxis
+			dataKey="created"
+			domain={domain}
+			ticks={ticks}
+			allowDataOverflow
+			type="number"
+			scale="time"
+			minTickGap={12}
+			tickMargin={8}
+			axisLine={false}
+			tickFormatter={chartTimeData[chartTime].format}
+		/>
+	)
+	return cachedAxis
 }
 
 export {

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

@@ -41,7 +41,7 @@ const TableRow = React.forwardRef<HTMLTableRowElement, React.HTMLAttributes<HTML
 		<tr
 			ref={ref}
 			className={cn(
-				"border-b border-border/60 hover:bg-muted/40 dark:hover:bg-muted/20 data-[state=selected]:bg-muted/40!",
+				"border-b border-border/60 hover:bg-muted/40 dark:hover:bg-muted/20 data-[state=selected]:bg-muted!",
 				className
 			)}
 			{...props}

internal/site/src/lib/api.ts

@@ -54,11 +54,8 @@ export async function updateUserSettings() {
 	}
 }
 
-export function getPbTimestamp(timeString: ChartTimes, d?: Date, createdIsNumber?: boolean) {
+export function getPbTimestamp(timeString: ChartTimes, d?: Date) {
 	d ||= chartTimeData[timeString].getOffset(new Date())
-	if (createdIsNumber) {
-		return d.getTime()
-	}
 	const year = d.getUTCFullYear()
 	const month = String(d.getUTCMonth() + 1).padStart(2, "0")
 	const day = String(d.getUTCDate()).padStart(2, "0")

internal/site/src/lib/stores.ts

@@ -70,5 +70,7 @@ export const $copyContent = atom("")
 /** Direction for localization */
 export const $direction = atom<"ltr" | "rtl">("ltr")
 
-/** Longest system name string. Used to reserve width in virtualized tables. */
-export const $longestSystemName = atom("")
+/** Longest system name length. Used to set table column width. I know this
+ *  is stupid but the table is virtualized and I know this will work.
+ */
+export const $longestSystemNameLen = atom(8)

internal/site/src/lib/systemsManager.ts

@@ -5,17 +5,20 @@ import {
 	$allSystemsById,
 	$allSystemsByName,
 	$downSystems,
-	$longestSystemName,
+	$longestSystemNameLen,
 	$pausedSystems,
 	$upSystems,
 } from "@/lib/stores"
-import { isVisuallyLonger, updateFavicon } from "@/lib/utils"
+import { getVisualStringWidth, updateFavicon } from "@/lib/utils"
 import type { SystemRecord } from "@/types"
 import { SystemStatus } from "./enums"
 
 const COLLECTION = pb.collection<SystemRecord>("systems")
 const FIELDS_DEFAULT = "id,name,host,port,info,status"
 
+/** Maximum system name length for display purposes */
+const MAX_SYSTEM_NAME_LENGTH = 22
+
 let initialized = false
 // biome-ignore lint/suspicious/noConfusingVoidType: typescript rocks
 let unsub: (() => void) | undefined | void
@@ -41,7 +44,7 @@ export function init() {
 		}
 
 		if (!newSystem) {
-			onSystemsChanged(newSystems, newSystem, oldSystem)
+			onSystemsChanged(newSystems, undefined)
 			return
 		}
 
@@ -65,28 +68,20 @@ export function init() {
 		}
 
 		// run things that need to be done when systems change
-		onSystemsChanged(newSystems, newSystem, oldSystem)
+		onSystemsChanged(newSystems, newSystem)
 	})
 }
 
-/** Update the longest system name string and favicon based on system status */
-function onSystemsChanged(systems: Record<string, SystemRecord>, newSystem?: SystemRecord, oldSystem?: SystemRecord) {
+/** Update the longest system name length and favicon based on system status */
+function onSystemsChanged(_: Record<string, SystemRecord>, changedSystem: SystemRecord | undefined) {
 	const downSystemsStore = $downSystems.get()
 	const downSystems = Object.values(downSystemsStore)
 
-	// if the old system's old name was the longest, we need to find the new longest name
-	// otherwise, if the changed system's new name is longer than the current longest, update it
-	const longestName = $longestSystemName.get()
-	if (oldSystem?.name === longestName && oldSystem.name !== newSystem?.name) {
-		let newLongest = ""
-		for (const id in systems) {
-			if (isVisuallyLonger(systems[id].name, newLongest)) {
-				newLongest = systems[id].name
-			}
-		}
-		$longestSystemName.set(newLongest)
-	} else if (newSystem && newSystem.name !== longestName && isVisuallyLonger(newSystem.name, longestName)) {
-		$longestSystemName.set(newSystem.name)
+	// Update longest system name length
+	const longestName = $longestSystemNameLen.get()
+	const nameLen = Math.min(MAX_SYSTEM_NAME_LENGTH, getVisualStringWidth(changedSystem?.name || ""))
+	if (nameLen > longestName) {
+		$longestSystemNameLen.set(nameLen)
 	}
 
 	updateFavicon(downSystems.length)

internal/site/src/lib/use-network-probes.ts

@@ -1,286 +0,0 @@
-import { chartTimeData } from "@/lib/utils"
-import type { ChartTimes, NetworkProbeRecord, NetworkProbeStatsRecord } from "@/types"
-import { useEffect, useRef, useState } from "react"
-import { getStats, appendData } from "@/components/routes/system/chart-data"
-import { pb } from "@/lib/api"
-import { toast } from "@/components/ui/use-toast"
-import type { RecordListOptions, RecordSubscription } from "pocketbase"
-
-const cache = new Map<string, NetworkProbeStatsRecord[]>()
-
-function getCacheValue(systemId: string, chartTime: ChartTimes | "rt") {
-	return cache.get(`${systemId}${chartTime}`) || []
-}
-
-function appendCacheValue(
-	systemId: string,
-	chartTime: ChartTimes | "rt",
-	newStats: NetworkProbeStatsRecord[],
-	maxPoints = 100
-) {
-	const cache_key = `${systemId}${chartTime}`
-	const existingStats = getCacheValue(systemId, chartTime)
-	if (existingStats) {
-		const { expectedInterval } = chartTimeData[chartTime]
-		const updatedStats = appendData(existingStats, newStats, expectedInterval, maxPoints)
-		cache.set(cache_key, updatedStats)
-		return updatedStats
-	} else {
-		cache.set(cache_key, newStats)
-		return newStats
-	}
-}
-
-const NETWORK_PROBE_FIELDS =
-	"id,name,system,target,protocol,port,interval,res,resMin1h,resMax1h,resAvg1h,loss1h,enabled,updated"
-
-interface UseNetworkProbesProps {
-	systemId?: string
-}
-
-export function useNetworkProbes(props: UseNetworkProbesProps) {
-	const { systemId } = props
-
-	const [probes, setProbes] = useState<NetworkProbeRecord[]>([])
-	const pendingProbeEvents = useRef(new Map<string, RecordSubscription<NetworkProbeRecord>>())
-	const probeBatchTimeout = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-	// clear old data when systemId changes
-	// useEffect(() => {
-	// 	return setProbes([])
-	// }, [systemId])
-
-	// initial load - fetch probes if not provided by caller
-	useEffect(() => {
-		fetchProbes(systemId).then((probes) => setProbes(probes))
-	}, [systemId])
-
-	// Subscribe to updates if probes not provided by caller
-	useEffect(() => {
-		let unsubscribe: (() => void) | undefined
-
-		function flushPendingProbeEvents() {
-			probeBatchTimeout.current = null
-			if (!pendingProbeEvents.current.size) {
-				return
-			}
-			const events = pendingProbeEvents.current
-			pendingProbeEvents.current = new Map()
-			setProbes((currentProbes) => {
-				return applyProbeEvents(currentProbes ?? [], events.values(), systemId)
-			})
-		}
-
-		const pbOptions: RecordListOptions = { fields: NETWORK_PROBE_FIELDS }
-		if (systemId) {
-			pbOptions.filter = pb.filter("system = {:system}", { system: systemId })
-		}
-
-		;(async () => {
-			try {
-				unsubscribe = await pb.collection<NetworkProbeRecord>("network_probes").subscribe(
-					"*",
-					(event) => {
-						pendingProbeEvents.current.set(event.record.id, event)
-						if (!probeBatchTimeout.current) {
-							probeBatchTimeout.current = setTimeout(flushPendingProbeEvents, 50)
-						}
-					},
-					pbOptions
-				)
-			} catch (error) {
-				console.error("Failed to subscribe to probes", error)
-			}
-		})()
-
-		return () => {
-			if (probeBatchTimeout.current !== null) {
-				clearTimeout(probeBatchTimeout.current)
-				probeBatchTimeout.current = null
-			}
-			pendingProbeEvents.current.clear()
-			unsubscribe?.()
-		}
-	}, [systemId])
-
-	return probes
-}
-
-interface UseNetworkProbeStatsProps {
-	systemId?: string
-	chartTime: ChartTimes
-}
-
-export function useNetworkProbeStats(props: UseNetworkProbeStatsProps) {
-	const { systemId, chartTime } = props
-	const [probeStats, setProbeStats] = useState<NetworkProbeStatsRecord[]>([])
-	const requestID = useRef(0)
-
-	// fetch missing probe stats on load and when chart time changes
-	useEffect(() => {
-		if (!systemId || !chartTime || chartTime === "1m") {
-			return
-		}
-
-		const { expectedInterval } = chartTimeData[chartTime]
-		const requestId = ++requestID.current
-
-		const cachedProbeStats = getCacheValue(systemId, chartTime)
-
-		// Render from cache immediately if available
-		if (cachedProbeStats.length) {
-			setProbeStats(cachedProbeStats)
-
-			// Skip the fetch if the latest cached point is recent enough that no new point is expected yet
-			const lastCreated = cachedProbeStats.at(-1)?.created
-			if (lastCreated && Date.now() - lastCreated < expectedInterval * 0.9) {
-				return
-			}
-		}
-
-		getStats<NetworkProbeStatsRecord>("network_probe_stats", systemId, chartTime, cachedProbeStats, true).then(
-			(probeStats) => {
-				// If another request has been made since this one, ignore the results
-				if (requestId !== requestID.current) {
-					return
-				}
-				const newStats = appendCacheValue(systemId, chartTime, probeStats)
-				setProbeStats(newStats)
-			}
-		)
-	}, [chartTime])
-
-	// Subscribe to new probe stats on non-1m chart times (1h, 12h, etc)
-	useEffect(() => {
-		if (!systemId || !chartTime || chartTime === "1m") {
-			return
-		}
-		let unsubscribe: (() => void) | undefined
-		const pbOptions = {
-			fields: "stats,created,type",
-			filter: pb.filter("system={:system} && type={:type}", { system: systemId, type: chartTimeData[chartTime].type }),
-		}
-
-		;(async () => {
-			try {
-				unsubscribe = await pb.collection<NetworkProbeStatsRecord>("network_probe_stats").subscribe(
-					"*",
-					(event) => {
-						if (event.action !== "create") {
-							return
-						}
-						// console.log("Appending new probe stats to chart:", event.record)
-						const newStats = appendCacheValue(systemId, chartTime, [event.record])
-						setProbeStats(newStats)
-					},
-					pbOptions
-				)
-			} catch (error) {
-				console.error("Failed to subscribe to probe stats:", error)
-			}
-		})()
-
-		return () => unsubscribe?.()
-	}, [systemId, chartTime])
-
-	// subscribe to realtime metrics if chart time is 1m
-	useEffect(() => {
-		if (!systemId || chartTime !== "1m") {
-			return
-		}
-		let unsubscribe: (() => void) | undefined
-		const cache_key = `${systemId}rt`
-		pb.realtime
-			.subscribe(
-				`rt_metrics`,
-				(data: { Probes: NetworkProbeStatsRecord["stats"] }) => {
-					const prev = getCacheValue(systemId, "rt")
-					const now = Date.now()
-					// if no previous data or the last data point is older than 1min,
-					// create a new data set starting with a point 1 second ago to seed the chart data
-					// if (!prev || (prev.at(-1)?.created ?? 0) < now - 60_000) {
-					// 	prev = [{ created: now - 30_000, stats: probesToStats(probes) }]
-					// }
-					const stats = { created: now, stats: data.Probes } as NetworkProbeStatsRecord
-					const newStats = appendData(prev, [stats], 1000, 120)
-					setProbeStats(() => newStats)
-					cache.set(cache_key, newStats)
-				},
-				{ query: { system: systemId } }
-			)
-			.then((us) => {
-				unsubscribe = us
-			})
-		return () => unsubscribe?.()
-	}, [chartTime, systemId])
-
-	return probeStats
-}
-// function probesToStats(probes: NetworkProbeRecord[]): NetworkProbeStatsRecord["stats"] {
-// 	const stats: NetworkProbeStatsRecord["stats"] = {}
-// 	for (const probe of probes) {
-// 		// TODO: include only if probe.updated < charttime
-// 		stats[probe.id] = [probe.res, probe.resAvg1h, probe.resMin1h, probe.resMax1h, probe.loss, probe.loss1h]
-// 	}
-// 	return stats
-// }
-
-async function fetchProbes(systemId?: string) {
-	try {
-		const res = await pb.collection<NetworkProbeRecord>("network_probes").getList(0, 2000, {
-			fields: NETWORK_PROBE_FIELDS,
-			filter: systemId ? pb.filter("system={:system}", { system: systemId }) : undefined,
-		})
-		return res.items
-	} catch (error) {
-		toast({
-			title: "Error",
-			description: (error as Error)?.message,
-			variant: "destructive",
-		})
-		return []
-	}
-}
-
-function applyProbeEvents(
-	probes: NetworkProbeRecord[],
-	events: Iterable<RecordSubscription<NetworkProbeRecord>>,
-	systemId?: string
-) {
-	// Use a map to handle updates/deletes in constant time
-	const probeById = new Map(probes.map((probe) => [probe.id, probe]))
-	const createdProbes: NetworkProbeRecord[] = []
-
-	for (const { action, record } of events) {
-		const matchesSystemScope = !systemId || record.system === systemId
-
-		if (action === "delete" || !matchesSystemScope) {
-			probeById.delete(record.id)
-			continue
-		}
-
-		if (!probeById.has(record.id)) {
-			createdProbes.push(record)
-		}
-
-		probeById.set(record.id, record)
-	}
-
-	const nextProbes: NetworkProbeRecord[] = []
-	// Prepend brand new probes (matching previous behavior)
-	for (let index = createdProbes.length - 1; index >= 0; index -= 1) {
-		nextProbes.push(createdProbes[index])
-	}
-
-	// Rebuild the final list while preserving original order for existing probes
-	for (const probe of probes) {
-		const nextProbe = probeById.get(probe.id)
-		if (!nextProbe) {
-			continue
-		}
-		nextProbes.push(nextProbe)
-		probeById.delete(probe.id)
-	}
-
-	return nextProbes
-}

internal/site/src/lib/utils.ts

@@ -72,7 +72,7 @@ export const formatShortDate = (timestamp: string) => {
 	return shortDateFormatter.format(new Date(timestamp))
 }
 
-export const hourWithSeconds = (timestamp: string | number) => {
+export const hourWithSeconds = (timestamp: string) => {
 	return hourWithSecondsFormatter.format(new Date(timestamp))
 }
 
@@ -111,18 +111,17 @@ export const updateFavicon = (() => {
     </linearGradient>
   </defs>
   <path fill="url(#gradient)" d="M35 70H0V0h35q4.4 0 8.2 1.7a21.4 21.4 0 0 1 6.6 4.5q2.9 2.8 4.5 6.6Q56 16.7 56 21a15.4 15.4 0 0 1-.3 3.2 17.6 17.6 0 0 1-.2.8 19.4 19.4 0 0 1-1.5 4 17 17 0 0 1-2.4 3.4 13.5 13.5 0 0 1-2.6 2.3 12.5 12.5 0 0 1-.4.3q1.7 1 3 2.5Q53 39.1 54 41a18.3 18.3 0 0 1 1.5 4 17.4 17.4 0 0 1 .5 3 15.3 15.3 0 0 1 0 1q0 4.4-1.7 8.2a21.4 21.4 0 0 1-4.5 6.6q-2.8 2.9-6.6 4.6Q39.4 70 35 70ZM14 14v14h21a7 7 0 0 0 2.3-.3 6.6 6.6 0 0 0 .4-.2Q39 27 40 26a6.9 6.9 0 0 0 1.5-2.2q.5-1.3.5-2.8a7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 17 40 16a7 7 0 0 0-2.3-1.4 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Zm0 28v14h21a7 7 0 0 0 2.3-.4 6.6 6.6 0 0 0 .4-.1Q39 54.9 40 54a7 7 0 0 0 1.5-2.2 6.9 6.9 0 0 0 .5-2.6 7.9 7.9 0 0 0 0-.2 7 7 0 0 0-.4-2.3 6.6 6.6 0 0 0-.1-.4Q40.9 45 40 44a7 7 0 0 0-2.3-1.5 6.9 6.9 0 0 0-2.5-.6 7.9 7.9 0 0 0-.2 0H14Z"/>
-  ${
-		downCount > 0 &&
-		`
+  ${downCount > 0 &&
+			`
 		<circle cx="40" cy="50" r="22" fill="#f00"/>
   	<text x="40" y="60" font-size="34" text-anchor="middle" fill="#fff" font-family="Arial" font-weight="bold">${downCount}</text>
 	`
-	}
+			}
 </svg>
 	`
 		const blob = new Blob([svg], { type: "image/svg+xml" })
 		const url = URL.createObjectURL(blob)
-		;(document.querySelector("link[rel='icon']") as HTMLLinkElement).href = url
+			; (document.querySelector("link[rel='icon']") as HTMLLinkElement).href = url
 	}
 })()
 
@@ -199,26 +198,6 @@ export function decimalString(num: number, digits = 2) {
 	return formatter.format(num)
 }
 
-export function formatMicroseconds(microseconds: number, showDigits = true): string {
-	if (!Number.isFinite(microseconds)) {
-		return "-"
-	}
-
-	if (microseconds < 1000) {
-		return `${microseconds}μs`
-	}
-
-	if (microseconds < 1_000_000) {
-		const milliseconds = microseconds / 1000
-		const digits = milliseconds >= 10 ? 1 : 2
-		return `${decimalString(milliseconds, showDigits ? digits : 0)}ms`
-	}
-
-	const seconds = microseconds / 1_000_000
-	const digits = seconds >= 10 ? 1 : 2
-	return `${decimalString(seconds, showDigits ? digits : 0)}s`
-}
-
 /** Get value from local or session storage */
 function getStorageValue(key: string, defaultValue: unknown, storageInterface: Storage = localStorage) {
 	const saved = storageInterface?.getItem(key)
@@ -386,12 +365,12 @@ export function formatDuration(
 		.join(" ")
 }
 
-/** Parse semver string into major, minor, and patch numbers
+/** Parse semver string into major, minor, and patch numbers 
  * @example
  * const semVer = "1.2.3"
  * const { major, minor, patch } = parseSemVer(semVer)
  * console.log(major, minor, patch) // 1, 2, 3
- */
+*/
 export const parseSemVer = (semVer = ""): SemVer => {
 	// if (semVer.startsWith("v")) {
 	// 	semVer = semVer.slice(1)
@@ -443,52 +422,10 @@ export function runOnce<T extends (...args: any[]) => any>(fn: T): T {
 	}) as T
 }
 
-/** Format seconds to hours, minutes, or seconds */
-export function secondsToString(seconds: number, unit: "hour" | "minute" | "day"): string {
-	const count = Math.floor(seconds / (unit === "hour" ? 3600 : unit === "minute" ? 60 : 86400))
-	const countString = count.toLocaleString()
-	switch (unit) {
-		case "minute":
-			return plural(count, {
-				one: `${countString} minute`,
-				few: `${countString} minutes`,
-				many: `${countString} minutes`,
-				other: `${countString} minutes`,
-			})
-		case "hour":
-			return plural(count, { one: `${countString} hour`, other: `${countString} hours` })
-		case "day":
-			return plural(count, { one: `${countString} day`, other: `${countString} days` })
-	}
-}
-
-/** Format seconds to uptime string - "X minutes", "X hours", "X days" */
-export function secondsToUptimeString(seconds: number): string {
-	if (seconds < 3600) {
-		return secondsToString(seconds, "minute")
-	} else if (seconds < 360000) {
-		return secondsToString(seconds, "hour")
-	} else {
-		return secondsToString(seconds, "day")
-	}
-}
-
-const visualWidthCache = new Map<string, number>()
-
-/** Get the visual width of a string, accounting for full-width and narrow punctuation characters.
- *  Don't use for monospaced fonts, use .length instead
- */
+/** Get the visual width of a string, accounting for full-width characters */
 export function getVisualStringWidth(str: string): number {
-	const cached = visualWidthCache.get(str)
-	if (cached !== undefined) {
-		return cached
-	}
 	let width = 0
 	for (const char of str) {
-		if (char === ".") {
-			width += 0.7
-			continue
-		}
 		const code = char.codePointAt(0) || 0
 		// Hangul Jamo and Syllables are often slightly thinner than Hanzi/Kanji
 		if ((code >= 0x1100 && code <= 0x115f) || (code >= 0xac00 && code <= 0xd7af)) {
@@ -506,11 +443,30 @@ export function getVisualStringWidth(str: string): number {
 			code > 0xffff // Emojis and other supplementary plane characters
 		width += isFullWidth ? 2 : 1
 	}
-	visualWidthCache.set(str, width)
-
 	return width
 }
 
-export function isVisuallyLonger(str1: string, str2: string): boolean {
-	return getVisualStringWidth(str1) > getVisualStringWidth(str2)
+/** Format seconds to hours, minutes, or seconds */
+export function secondsToString(seconds: number, unit: "hour" | "minute" | "day"): string {
+	const count = Math.floor(seconds / (unit === "hour" ? 3600 : unit === "minute" ? 60 : 86400))
+	const countString = count.toLocaleString()
+	switch (unit) {
+		case "minute":
+			return plural(count, { one: `${countString} minute`, few: `${countString} minutes`, many: `${countString} minutes`, other: `${countString} minutes` })
+		case "hour":
+			return plural(count, { one: `${countString} hour`, other: `${countString} hours` })
+		case "day":
+			return plural(count, { one: `${countString} day`, other: `${countString} days` })
+	}
 }
+
+/** Format seconds to uptime string - "X minutes", "X hours", "X days" */
+export function secondsToUptimeString(seconds: number): string {
+	if (seconds < 3600) {
+		return secondsToString(seconds, "minute")
+	} else if (seconds < 360000) {
+		return secondsToString(seconds, "hour")
+	} else {
+		return secondsToString(seconds, "day")
+	}
+}

internal/site/src/main.tsx

@@ -30,7 +30,6 @@ const LoginPage = lazy(() => import("@/components/login/login.tsx"))
 const Home = lazy(() => import("@/components/routes/home.tsx"))
 const Containers = lazy(() => import("@/components/routes/containers.tsx"))
 const Smart = lazy(() => import("@/components/routes/smart.tsx"))
-const Probes = lazy(() => import("@/components/routes/probes.tsx"))
 const SystemDetail = lazy(() => import("@/components/routes/system.tsx"))
 const CopyToClipboardDialog = lazy(() => import("@/components/copy-to-clipboard.tsx"))
 
@@ -80,8 +79,6 @@ const App = memo(() => {
 		return <Containers />
 	} else if (page.route === "smart") {
 		return <Smart />
-	} else if (page.route === "probes") {
-		return <Probes />
 	} else if (page.route === "settings") {
 		return <Settings />
 	}

internal/site/src/types.d.ts

@@ -313,9 +313,11 @@ export interface SemVer {
 
 export interface ChartData {
 	agentVersion: SemVer
-	systemStats?: SystemStatsRecord[]
-	containerData?: ChartDataContainer[]
+	systemStats: SystemStatsRecord[]
+	containerData: ChartDataContainer[]
 	orientation: "right" | "left"
+	ticks: number[]
+	domain: number[]
 	chartTime: ChartTimes
 }
 
@@ -544,41 +546,3 @@ export interface UpdateInfo {
 	v: string // new version
 	url: string // url to new version
 }
-
-export interface NetworkProbeRecord {
-	id: string
-	system: string
-	name: string
-	target: string
-	protocol: "icmp" | "tcp" | "http"
-	port: number
-	res: number
-	resMin1h: number
-	resMax1h: number
-	resAvg1h: number
-	loss: number
-	loss1h: number
-	interval: number
-	enabled: boolean
-	updated: string
-}
-
-/**
- * Stats holds only 1m values for a single target, which are used for charts.
- *
- * 0: avg response in microseconds
- *
- * 1: min response in microseconds
- *
- * 2: max response in microseconds
- *
- * 3: packet loss percentage (0-100)
- */
-type ProbeStats = number[]
-
-export interface NetworkProbeStatsRecord {
-	id?: string
-	type?: string
-	stats: Record<string, ProbeStats>
-	created: number // unix timestamp (ms) for Recharts xAxis
-}

supplemental/docker/agent/docker-compose.yml

@@ -1,18 +1,24 @@
+# Specialized images available for Nvidia / Intel GPUs
+#
+# Docs: https://beszel.dev/guide/agent-installation
+# Env vars: https://beszel.dev/guide/environment-variables
+
 services:
   beszel-agent:
-    image: 'henrygd/beszel-agent' #Or henrygd/beszel-agent-nvidia
-    container_name: 'beszel-agent'
+    image: henrygd/beszel-agent
+    container_name: beszel-agent
     restart: unless-stopped
     network_mode: host
-    # Only when using henrygd/beszel-agent-nvidia
-    # runtime: nvidia
     volumes:
+      - ./beszel_agent_data:/var/lib/beszel-agent
       - /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
+      # - /mnt/disk1/.beszel:/extra-filesystems/disk1:ro
     environment:
-      PORT: 45876
-      KEY: 'ssh-ed25519 YOUR_PUBLIC_KEY'
-      # Only when using henrygd/beszel-agent-nvidia
-      # NVIDIA_VISIBLE_DEVICES: all 
-      # NVIDIA_DRIVER_CAPABILITIES: compute,video,utility
+      LISTEN: 45876
+      KEY: "<public key>"
+      HUB_URL: "<hub url>"
+      TOKEN: "<token>"
+    # healthcheck:
+    #   test: ['CMD', '/agent', 'health']
+    #   interval: 120s

supplemental/docker/hub/docker-compose.yml

@@ -1,9 +1,17 @@
+# Docs: https://beszel.dev/guide/hub-installation
+# Env vars: https://beszel.dev/guide/environment-variables
+
 services:
   beszel:
-    image: 'henrygd/beszel'
-    container_name: 'beszel'
+    image: "henrygd/beszel"
+    container_name: "beszel"
     restart: unless-stopped
     ports:
-      - '8090:8090'
+      - "8090:8090"
     volumes:
       - ./beszel_data:/beszel_data
+    # healthcheck:
+    #   test: ['CMD', '/beszel', 'health', '--url', 'http://localhost:8090']
+    #   interval: 120s
+    #   start_period: 10s
+    #   timeout: 5s

supplemental/docker/same-system/docker-compose.yml

@@ -1,26 +1,38 @@
+# Docs: https://beszel.dev/guide/getting-started
+# Env vars: https://beszel.dev/guide/environment-variables
+
 services:
   beszel:
-    image: 'henrygd/beszel'
-    container_name: 'beszel'
+    image: henrygd/beszel:latest
+    container_name: beszel
     restart: unless-stopped
+    environment:
+      APP_URL: http://localhost:8090
     ports:
-      - '8090:8090'
+      - 8090:8090
     volumes:
       - ./beszel_data:/beszel_data
-    extra_hosts:
-      - 'host.docker.internal:host-gateway'
+      - ./beszel_socket:/beszel_socket
+    # healthcheck:
+    #   test: ['CMD', '/beszel', 'health', '--url', 'http://localhost:8090']
+    #   interval: 120s
+    #   start_period: 10s
+    #   timeout: 5s
 
   beszel-agent:
-    image: 'henrygd/beszel-agent' #Add -nvidia for nvidia gpus
-    container_name: 'beszel-agent'
+    image: henrygd/beszel-agent:latest
+    container_name: beszel-agent
     restart: unless-stopped
     network_mode: host
-    # runtime: nvidia # when using beszel-agent-nvidia
     volumes:
+      - ./beszel_agent_data:/var/lib/beszel-agent
+      - ./beszel_socket:/beszel_socket
       - /var/run/docker.sock:/var/run/docker.sock:ro
     environment:
-      PORT: 45876
-      KEY: '...'
-      # FILESYSTEM: /dev/sda1 # set to the correct filesystem for disk I/O stats
-      # NVIDIA_VISIBLE_DEVICES: all # when using beszel-agent-nvidia
-      # NVIDIA_DRIVER_CAPABILITIES: utility # when using beszel-agent-nvidia
+      LISTEN: /beszel_socket/beszel.sock
+      HUB_URL: http://localhost:8090
+      TOKEN: <token>
+      KEY: "<key>"
+    # healthcheck:
+    #   test: ['CMD', '/agent', 'health']
+    #   interval: 120s