update go version for vulcheck action

alerts tests and small refactoring
bump go version and add keyword
2026-03-24 06:26:17 +01:00 · 2025-09-04 19:17:44 -04:00 · 2025-09-04 19:13:10 -04:00 · 2025-09-04 19:13:10 -04:00 · 2025-09-04 19:13:10 -04:00 · 2025-09-04 11:26:53 -04:00
19 changed files with 385 additions and 155 deletions
--- a/.github/workflows/vulncheck.yml
+++ b/.github/workflows/vulncheck.yml
@@ -15,7 +15,7 @@ permissions:

 jobs:
  vulncheck:
-    name: Analysis
+    name: VulnCheck
    runs-on: ubuntu-latest
    steps:
      - name: Check out code into the Go module directory
@@ -23,8 +23,8 @@ jobs:
      - name: Set up Go
        uses: actions/setup-go@v5
        with:
-          go-version: 1.24.x
-          cached: false
+          go-version: 1.25.x
+          # cached: false
      - name: Get official govulncheck
        run: go install golang.org/x/vuln/cmd/govulncheck@latest
        shell: bash
--- a/beszel/go.mod
+++ b/beszel/go.mod
@@ -1,6 +1,6 @@
 module beszel

-go 1.24.4
+go 1.25.1

 // lock shoutrrr to specific version to allow review before updating
 replace github.com/nicholas-fedor/shoutrrr => github.com/nicholas-fedor/shoutrrr v0.8.8
--- a/beszel/internal/alerts/alerts.go
+++ b/beszel/internal/alerts/alerts.go
@@ -87,7 +87,7 @@ var supportsTitle = map[string]struct{}{
 func NewAlertManager(app hubLike) *AlertManager {
 	am := &AlertManager{
 		hub:        app,
-		alertQueue: make(chan alertTask),
+		alertQueue: make(chan alertTask, 5),
 		stopChan:   make(chan struct{}),
 	}
 	am.bindEvents()
--- a/beszel/internal/alerts/alerts_history.go
+++ b/beszel/internal/alerts/alerts_history.go
@@ -42,21 +42,10 @@ func updateHistoryOnAlertUpdate(e *core.RecordEvent) error {

 // resolveAlertHistoryRecord sets the resolved field to the current time
 func resolveAlertHistoryRecord(app core.App, alertRecordID string) error {
-	alertHistoryRecords, err := app.FindRecordsByFilter(
-		"alerts_history",
-		"alert_id={:alert_id} && resolved=null",
-		"-created",
-		1,
-		0,
-		dbx.Params{"alert_id": alertRecordID},
-	)
-	if err != nil {
+	alertHistoryRecord, err := app.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id} && resolved=null", dbx.Params{"alert_id": alertRecordID})
+	if err != nil || alertHistoryRecord == nil {
 		return err
 	}
-	if len(alertHistoryRecords) == 0 {
-		return nil
-	}
-	alertHistoryRecord := alertHistoryRecords[0] // there should be only one record
 	alertHistoryRecord.Set("resolved", time.Now().UTC())
 	err = app.Save(alertHistoryRecord)
 	if err != nil {
--- a/beszel/internal/alerts/alerts_test.go
+++ b/beszel/internal/alerts/alerts_test.go
@@ -10,6 +10,8 @@ import (
 	"net/http"
 	"strings"
 	"testing"
+	"testing/synctest"
+	"time"

 	beszelTests "beszel/internal/tests"

@@ -63,14 +65,14 @@ func TestUserAlertsApi(t *testing.T) {
 	}

 	scenarios := []beszelTests.ApiScenario{
-		{
-			Name:            "GET not implemented - returns index",
-			Method:          http.MethodGet,
-			URL:             "/api/beszel/user-alerts",
-			ExpectedStatus:  200,
-			ExpectedContent: []string{"<html ", "globalThis.BESZEL"},
-			TestAppFactory:  testAppFactory,
-		},
+		// {
+		// 	Name:            "GET not implemented - returns index",
+		// 	Method:          http.MethodGet,
+		// 	URL:             "/api/beszel/user-alerts",
+		// 	ExpectedStatus:  200,
+		// 	ExpectedContent: []string{"<html ", "globalThis.BESZEL"},
+		// 	TestAppFactory:  testAppFactory,
+		// },
 		{
 			Name:            "POST no auth",
 			Method:          http.MethodPost,
@@ -366,3 +368,237 @@ func TestUserAlertsApi(t *testing.T) {
 		scenario.Test(t)
 	}
 }
+
+func getHubWithUser(t *testing.T) (*beszelTests.TestHub, *core.Record) {
+	hub, err := beszelTests.NewTestHub(t.TempDir())
+	assert.NoError(t, err)
+	hub.StartHub()
+
+	// Manually initialize the system manager to bind event hooks
+	err = hub.GetSystemManager().Initialize()
+	assert.NoError(t, err)
+
+	// Create a test user
+	user, err := beszelTests.CreateUser(hub, "test@example.com", "password")
+	assert.NoError(t, err)
+
+	// Create user settings for the test user (required for alert notifications)
+	userSettingsData := map[string]any{
+		"user":     user.Id,
+		"settings": `{"emails":[test@example.com],"webhooks":[]}`,
+	}
+	_, err = beszelTests.CreateRecord(hub, "user_settings", userSettingsData)
+	assert.NoError(t, err)
+
+	return hub, user
+}
+
+func TestStatusAlerts(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		hub, user := getHubWithUser(t)
+		defer hub.Cleanup()
+
+		systems, err := beszelTests.CreateSystems(hub, 4, user.Id, "paused")
+		assert.NoError(t, err)
+
+		var alerts []*core.Record
+		for i, system := range systems {
+			alert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+				"name":   "Status",
+				"system": system.Id,
+				"user":   user.Id,
+				"min":    i + 1,
+			})
+			assert.NoError(t, err)
+			alerts = append(alerts, alert)
+		}
+
+		time.Sleep(10 * time.Millisecond)
+
+		for _, alert := range alerts {
+			assert.False(t, alert.GetBool("triggered"), "Alert should not be triggered immediately")
+		}
+		if hub.TestMailer.TotalSend() != 0 {
+			assert.Zero(t, hub.TestMailer.TotalSend(), "Expected 0 messages, got %d", hub.TestMailer.TotalSend())
+		}
+		for _, system := range systems {
+			assert.EqualValues(t, "paused", system.GetString("status"), "System should be paused")
+		}
+		for _, system := range systems {
+			system.Set("status", "up")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		time.Sleep(time.Second)
+		assert.EqualValues(t, 0, hub.GetPendingAlertsCount(), "should have 0 alerts in the pendingAlerts map")
+		for _, system := range systems {
+			system.Set("status", "down")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		// after 30 seconds, should have 4 alerts in the pendingAlerts map, no triggered alerts
+		time.Sleep(time.Second * 30)
+		assert.EqualValues(t, 4, hub.GetPendingAlertsCount(), "should have 4 alerts in the pendingAlerts map")
+		triggeredCount, err := hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 0, triggeredCount, "should have 0 alert triggered")
+		assert.EqualValues(t, 0, hub.TestMailer.TotalSend(), "should have 0 messages sent")
+		// after 1:30 seconds, should have 1 triggered alert and 3 pending alerts
+		time.Sleep(time.Second * 60)
+		assert.EqualValues(t, 3, hub.GetPendingAlertsCount(), "should have 3 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "should have 1 alert triggered")
+		assert.EqualValues(t, 1, hub.TestMailer.TotalSend(), "should have 1 messages sent")
+		// after 2:30 seconds, should have 2 triggered alerts and 2 pending alerts
+		time.Sleep(time.Second * 60)
+		assert.EqualValues(t, 2, hub.GetPendingAlertsCount(), "should have 2 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 2, triggeredCount, "should have 2 alert triggered")
+		assert.EqualValues(t, 2, hub.TestMailer.TotalSend(), "should have 2 messages sent")
+		// now we will bring the remaning systems back up
+		for _, system := range systems {
+			system.Set("status", "up")
+			err = hub.SaveNoValidate(system)
+			assert.NoError(t, err)
+		}
+		time.Sleep(time.Second)
+		// should have 0 alerts in the pendingAlerts map and 0 alerts triggered
+		assert.EqualValues(t, 0, hub.GetPendingAlertsCount(), "should have 0 alerts in the pendingAlerts map")
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true})
+		assert.NoError(t, err)
+		assert.Zero(t, triggeredCount, "should have 0 alert triggered")
+		// 4 messages sent, 2 down alerts and 2 up alerts for first 2 systems
+		assert.EqualValues(t, 4, hub.TestMailer.TotalSend(), "should have 4 messages sent")
+	})
+}
+
+func TestAlertsHistory(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		hub, user := getHubWithUser(t)
+		defer hub.Cleanup()
+
+		// Create systems and alerts
+		systems, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
+		assert.NoError(t, err)
+		system := systems[0]
+
+		alert, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+			"name":   "Status",
+			"system": system.Id,
+			"user":   user.Id,
+			"min":    1,
+		})
+		assert.NoError(t, err)
+
+		// Initially, no alert history records should exist
+		initialHistoryCount, err := hub.CountRecords("alerts_history", nil)
+		assert.NoError(t, err)
+		assert.Zero(t, initialHistoryCount, "Should have 0 alert history records initially")
+
+		// Set system to up initially
+		system.Set("status", "up")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+		time.Sleep(10 * time.Millisecond)
+
+		// Set system to down to trigger alert
+		system.Set("status", "down")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+
+		// Wait for alert to trigger (after the downtime delay)
+		// With 1 minute delay, we need to wait at least 1 minute + some buffer
+		time.Sleep(time.Second * 75)
+
+		// Check that alert is triggered
+		triggeredCount, err := hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "Alert should be triggered")
+
+		// Check that alert history record was created
+		historyCount, err := hub.CountRecords("alerts_history", dbx.HashExp{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, historyCount, "Should have 1 alert history record for triggered alert")
+
+		// Get the alert history record and verify it's not resolved immediately
+		historyRecord, err := hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord, "Alert history record should exist")
+		assert.Equal(t, alert.Id, historyRecord.GetString("alert_id"), "Alert history should reference correct alert")
+		assert.Equal(t, system.Id, historyRecord.GetString("system"), "Alert history should reference correct system")
+		assert.Equal(t, "Status", historyRecord.GetString("name"), "Alert history should have correct name")
+
+		// The alert history might be resolved immediately in some cases, so let's check the alert's triggered status
+		alertRecord, err := hub.FindFirstRecordByFilter("alerts", "id={:id}", dbx.Params{"id": alert.Id})
+		assert.NoError(t, err)
+		assert.True(t, alertRecord.GetBool("triggered"), "Alert should still be triggered when checking history")
+
+		// Now resolve the alert by setting system back to up
+		system.Set("status", "up")
+		err = hub.SaveNoValidate(system)
+		assert.NoError(t, err)
+		time.Sleep(200 * time.Millisecond)
+
+		// Check that alert is no longer triggered
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert.Id})
+		assert.NoError(t, err)
+		assert.Zero(t, triggeredCount, "Alert should not be triggered after system is back up")
+
+		// Check that alert history record is now resolved
+		historyRecord, err = hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord, "Alert history record should still exist")
+		assert.NotNil(t, historyRecord.Get("resolved"), "Alert history should be resolved")
+
+		// Test deleting a triggered alert resolves its history
+		// Create another system and alert
+		systems2, err := beszelTests.CreateSystems(hub, 1, user.Id, "up")
+		assert.NoError(t, err)
+		system2 := systems2[0]
+		system2.Set("name", "test-system-2") // Rename for clarity
+		err = hub.SaveNoValidate(system2)
+		assert.NoError(t, err)
+
+		alert2, err := beszelTests.CreateRecord(hub, "alerts", map[string]any{
+			"name":   "Status",
+			"system": system2.Id,
+			"user":   user.Id,
+			"min":    1,
+		})
+		assert.NoError(t, err)
+
+		// Set system2 to down to trigger alert
+		system2.Set("status", "down")
+		err = hub.SaveNoValidate(system2)
+		assert.NoError(t, err)
+
+		// Wait for alert to trigger
+		time.Sleep(time.Second * 75)
+
+		// Verify alert is triggered and history record exists
+		triggeredCount, err = hub.CountRecords("alerts", dbx.HashExp{"triggered": true, "id": alert2.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, triggeredCount, "Second alert should be triggered")
+
+		historyCount, err = hub.CountRecords("alerts_history", dbx.HashExp{"alert_id": alert2.Id})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, historyCount, "Should have 1 alert history record for second alert")
+
+		// Delete the triggered alert
+		err = hub.Delete(alert2)
+		assert.NoError(t, err)
+
+		// Check that alert history record is resolved after deletion
+		historyRecord2, err := hub.FindFirstRecordByFilter("alerts_history", "alert_id={:alert_id}", dbx.Params{"alert_id": alert2.Id})
+		assert.NoError(t, err)
+		assert.NotNil(t, historyRecord2, "Alert history record should still exist after alert deletion")
+		assert.NotNil(t, historyRecord2.Get("resolved"), "Alert history should be resolved after alert deletion")
+
+		// Verify total history count is correct (2 records total)
+		totalHistoryCount, err := hub.CountRecords("alerts_history", nil)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 2, totalHistoryCount, "Should have 2 total alert history records")
+	})
+}
--- a/beszel/internal/alerts/alerts_test_helpers.go
+++ b/beszel/internal/alerts/alerts_test_helpers.go
@@ -0,0 +1,55 @@
+package alerts
+
+import (
+	"sync"
+	"time"
+
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func (am *AlertManager) GetAlertManager() *AlertManager {
+	return am
+}
+
+func (am *AlertManager) GetPendingAlerts() *sync.Map {
+	return &am.pendingAlerts
+}
+
+func (am *AlertManager) GetPendingAlertsCount() int {
+	count := 0
+	am.pendingAlerts.Range(func(key, value any) bool {
+		count++
+		return true
+	})
+	return count
+}
+
+// ProcessPendingAlerts manually processes all expired alerts (for testing)
+func (am *AlertManager) ProcessPendingAlerts() ([]*core.Record, error) {
+	now := time.Now()
+	var lastErr error
+	var processedAlerts []*core.Record
+	am.pendingAlerts.Range(func(key, value any) bool {
+		info := value.(*alertInfo)
+		if now.After(info.expireTime) {
+			// Downtime delay has passed, process alert
+			if err := am.sendStatusAlert("down", info.systemName, info.alertRecord); err != nil {
+				lastErr = err
+			}
+			processedAlerts = append(processedAlerts, info.alertRecord)
+			am.pendingAlerts.Delete(key)
+		}
+		return true
+	})
+	return processedAlerts, lastErr
+}
+
+// ForceExpirePendingAlerts sets all pending alerts to expire immediately (for testing)
+func (am *AlertManager) ForceExpirePendingAlerts() {
+	now := time.Now()
+	am.pendingAlerts.Range(func(key, value any) bool {
+		info := value.(*alertInfo)
+		info.expireTime = now.Add(-time.Second) // Set to 1 second ago
+		return true
+	})
+}
--- a/beszel/internal/hub/hub.go
+++ b/beszel/internal/hub/hub.go
@@ -19,7 +19,6 @@ import (
 	"time"

 	"github.com/google/uuid"
-	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
@@ -300,30 +299,3 @@ func (h *Hub) MakeLink(parts ...string) string {
 	}
 	return base
 }
-
-type SystemInfo struct {
-	Name   string `json:"name"`
-	Id     string `json:"id"`
-	Status string `json:"status"`
-	Port   uint16 `json:"port"`
-	Host   string `json:"host"`
-	Info   string `json:"info"`
-}
-
-func (h *Hub) getUserSystemsFromRequest(req *http.Request) ([]SystemInfo, error) {
-	systems := []SystemInfo{}
-	token, err := req.Cookie("beszauth")
-	if err != nil {
-		return systems, err
-	}
-	if token.Value != "" {
-		user, err := h.FindAuthRecordByToken(token.Value)
-		if err != nil {
-			return systems, err
-		}
-		h.DB().NewQuery("SELECT s.id, s.info, s.status, s.name, s.port, s.host FROM systems s JOIN json_each(s.users) AS je WHERE je.value = {:user_id}").Bind(dbx.Params{
-			"user_id": user.Id,
-		}).All(&systems)
-	}
-	return systems, err
-}
--- a/beszel/internal/hub/server_development.go
+++ b/beszel/internal/hub/server_development.go
@@ -4,7 +4,6 @@ package hub

 import (
 	"beszel"
-	"encoding/json"
 	"fmt"
 	"io"
 	"log/slog"
@@ -16,36 +15,29 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

-// responseModifier wraps an http.RoundTripper to modify HTML responses
+// Wraps http.RoundTripper to modify dev proxy HTML responses
 type responseModifier struct {
 	transport http.RoundTripper
 	hub       *Hub
 }

-// RoundTrip implements http.RoundTripper interface with response modification
 func (rm *responseModifier) RoundTrip(req *http.Request) (*http.Response, error) {
 	resp, err := rm.transport.RoundTrip(req)
 	if err != nil {
 		return resp, err
 	}
-
 	// Only modify HTML responses
 	contentType := resp.Header.Get("Content-Type")
 	if !strings.Contains(contentType, "text/html") {
 		return resp, nil
 	}
-
-	// Read the response body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return resp, err
 	}
 	resp.Body.Close()
-
-	// Modify the HTML content here
-	modifiedBody := rm.modifyHTML(string(body), req)
-
 	// Create a new response with the modified body
+	modifiedBody := rm.modifyHTML(string(body))
 	resp.Body = io.NopCloser(strings.NewReader(modifiedBody))
 	resp.ContentLength = int64(len(modifiedBody))
 	resp.Header.Set("Content-Length", fmt.Sprintf("%d", len(modifiedBody)))
@@ -53,8 +45,7 @@ func (rm *responseModifier) RoundTrip(req *http.Request) (*http.Response, error)
 	return resp, nil
 }

-// modifyHTML applies modifications to HTML content
-func (rm *responseModifier) modifyHTML(html string, req *http.Request) string {
+func (rm *responseModifier) modifyHTML(html string) string {
 	parsedURL, err := url.Parse(rm.hub.appURL)
 	if err != nil {
 		return html
@@ -63,19 +54,7 @@ func (rm *responseModifier) modifyHTML(html string, req *http.Request) string {
 	basePath := strings.TrimSuffix(parsedURL.Path, "/") + "/"
 	html = strings.ReplaceAll(html, "./", basePath)
 	html = strings.Replace(html, "{{V}}", beszel.Version, 1)
-	slog.Info("modifying HTML", "appURL", rm.hub.appURL)
 	html = strings.Replace(html, "{{HUB_URL}}", rm.hub.appURL, 1)
-
-	systems, err := rm.hub.getUserSystemsFromRequest(req)
-	if err != nil {
-		return html
-	}
-	systemsJson, err := json.Marshal(systems)
-	if err != nil {
-		return html
-	}
-	html = strings.Replace(html, "'{SYSTEMS}'", string(systemsJson), 1)
-
 	return html
 }

@@ -87,7 +66,6 @@ func (h *Hub) startServer(se *core.ServeEvent) error {
 		Host:   "localhost:5173",
 	})

-	// Set up custom transport with response modification
 	proxy.Transport = &responseModifier{
 		transport: http.DefaultTransport,
 		hub:       h,
--- a/beszel/internal/hub/server_production.go
+++ b/beszel/internal/hub/server_production.go
@@ -5,9 +5,7 @@ package hub
 import (
 	"beszel"
 	"beszel/site"
-	"encoding/json"
 	"io/fs"
-	"log/slog"
 	"net/http"
 	"net/url"
 	"strings"
@@ -47,15 +45,6 @@ func (h *Hub) startServer(se *core.ServeEvent) error {
 			e.Response.Header().Del("X-Frame-Options")
 			e.Response.Header().Set("Content-Security-Policy", csp)
 		}
-		systems, err := h.getUserSystemsFromRequest(e.Request)
-		if err != nil {
-			slog.Error("error getting user systems", "error", err)
-		}
-		systemsJson, err := json.Marshal(systems)
-		if err != nil {
-			slog.Error("error marshalling user systems", "error", err)
-		}
-		html = strings.Replace(html, "'{SYSTEMS}'", string(systemsJson), 1)
 		return e.HTML(http.StatusOK, html)
 	})
 	return nil
--- a/beszel/internal/hub/systems/systems_test_helpers.go
+++ b/beszel/internal/hub/systems/systems_test_helpers.go
@@ -100,3 +100,10 @@ func (sm *SystemManager) SetSystemStatusInDB(systemID string, status string) boo

 	return true
 }
+
+// TESTING ONLY: RemoveAllSystems removes all systems from the store
+func (sm *SystemManager) RemoveAllSystems() {
+	for _, system := range sm.systems.GetAll() {
+		sm.RemoveSystem(system.Id)
+	}
+}
--- a/beszel/internal/tests/hub.go
+++ b/beszel/internal/tests/hub.go
@@ -96,3 +96,31 @@ func ClearCollection(t testing.TB, app core.App, collectionName string) error {
 	assert.EqualValues(t, recordCount, 0, "should have 0 records after clearing")
 	return err
 }
+
+func (h *TestHub) Cleanup() {
+	h.GetAlertManager().StopWorker()
+	h.GetSystemManager().RemoveAllSystems()
+	h.TestApp.Cleanup()
+}
+
+func CreateSystems(app core.App, count int, userId string, status string) ([]*core.Record, error) {
+	systems := make([]*core.Record, 0, count)
+	for i := range count {
+		system, err := CreateRecord(app, "systems", map[string]any{
+			"name":  fmt.Sprintf("test-system-%d", i),
+			"host":  fmt.Sprintf("127.0.0.%d", i),
+			"port":  "33914",
+			"users": []string{userId},
+		})
+		if err != nil {
+			return nil, err
+		}
+		system.Set("status", status)
+		err = app.SaveNoValidate(system)
+		if err != nil {
+			return nil, err
+		}
+		systems = append(systems, system)
+	}
+	return systems, nil
+}
--- a/beszel/site/index.html
+++ b/beszel/site/index.html
@@ -10,8 +10,7 @@
 			globalThis.BESZEL = {
 				BASE_PATH: "%BASE_URL%",
 				HUB_VERSION: "{{V}}",
-				HUB_URL: "{{HUB_URL}}",
-				SYSTEMS: '{SYSTEMS}'
+				HUB_URL: "{{HUB_URL}}"
 			}
 		</script>
 	</head>
--- a/beszel/site/src/components/command-palette.tsx
+++ b/beszel/site/src/components/command-palette.tsx
@@ -121,6 +121,7 @@ export default memo(function CommandPalette({ open, setOpen }: { open: boolean;
 							{SettingsShortcut}
 						</CommandItem>
 						<CommandItem
+							keywords={[t`Universal token`]}
 							onSelect={() => {
 								navigate(getPagePath($router, "settings", { name: "tokens" }))
 								setOpen(false)
--- a/beszel/site/src/lib/api.ts
+++ b/beszel/site/src/lib/api.ts
@@ -12,13 +12,6 @@ export const pb = new PocketBase(basePath)
 export const isAdmin = () => pb.authStore.record?.role === "admin"
 export const isReadOnlyUser = () => pb.authStore.record?.role === "readonly"

-export const updateCookieToken = () => {
-	console.log("setting token", pb.authStore.token)
-	document.cookie = `beszauth=${pb.authStore.token}; path=/; expires=${new Date(
-		Date.now() + 7 * 24 * 60 * 60 * 1000
-	).toString()}`
-}
-
 export const verifyAuth = () => {
 	pb.collection("users")
 		.authRefresh()
--- a/beszel/site/src/lib/stores.ts
+++ b/beszel/site/src/lib/stores.ts
@@ -17,7 +17,7 @@ export const $downSystems = map<Record<string, SystemRecord>>({})
 /** Map of paused systems by id */
 export const $pausedSystems = map<Record<string, SystemRecord>>({})
 /** List of all system records */
-export const $systems: ReadableAtom<SystemRecord[]> = computed($allSystemsByName, Object.values)
+export const $systems: ReadableAtom<SystemRecord[]> = computed($allSystemsById, Object.values)

 /** Map of alert records by system id and alert name */
 export const $alerts = map<AlertMap>({})
--- a/beszel/site/src/lib/systemsManager.ts
+++ b/beszel/site/src/lib/systemsManager.ts
@@ -29,7 +29,7 @@ export function init() {
 	initialized = true

 	// sync system stores on change
-	$allSystemsByName.listen((newSystems, oldSystems, changedKey) => {
+	$allSystemsById.listen((newSystems, oldSystems, changedKey) => {
 		const oldSystem = oldSystems[changedKey]
 		const newSystem = newSystems[changedKey]

@@ -59,6 +59,10 @@ export function init() {
 			$pausedSystems.setKey(newSystem.id, newSystem)
 			removeFromStore(newSystem, $upSystems)
 			removeFromStore(newSystem, $downSystems)
+		} else if (newStatus === SystemStatus.Pending) {
+			removeFromStore(newSystem, $upSystems)
+			removeFromStore(newSystem, $downSystems)
+			removeFromStore(newSystem, $pausedSystems)
 		}

 		// run things that need to be done when systems change
@@ -100,13 +104,22 @@ async function fetchSystems(): Promise<SystemRecord[]> {
 	}
 }

-// Store management functions
 /** Add system to both name and ID stores */
 export function add(system: SystemRecord) {
 	$allSystemsByName.setKey(system.name, system)
 	$allSystemsById.setKey(system.id, system)
 }

+/** Update system in stores */
+export function update(system: SystemRecord) {
+	// if name changed, make sure old name is removed from the name store
+	const oldName = $allSystemsById.get()[system.id]?.name
+	if (oldName !== system.name) {
+		$allSystemsByName.setKey(oldName, undefined as any)
+	}
+	add(system)
+}
+
 /** Remove system from stores */
 export function remove(system: SystemRecord) {
 	removeFromStore(system, $allSystemsByName)
@@ -125,7 +138,7 @@ function removeFromStore(system: SystemRecord, store: PreinitializedMapStore<Rec
 /** Action functions for subscription */
 const actionFns: Record<string, (system: SystemRecord) => void> = {
 	create: add,
-	update: add,
+	update: update,
 	delete: remove,
 }

@@ -141,13 +154,7 @@ export async function subscribe() {
 }

 /** Refresh all systems with latest data from the hub */
-export async function refresh(records: SystemRecord[] = []) {
-	if (records.length) {
-		for (const record of records) {
-			add(record)
-		}
-		return
-	}
+export async function refresh() {
 	try {
 		const records = await fetchSystems()
 		if (!records.length) {
--- a/beszel/site/src/main.tsx
+++ b/beszel/site/src/main.tsx
@@ -5,7 +5,7 @@ import ReactDOM from "react-dom/client"
 import { ThemeProvider } from "./components/theme-provider.tsx"
 import { DirectionProvider } from "@radix-ui/react-direction"
 import { $authenticated, $publicKey, $copyContent, $direction } from "./lib/stores.ts"
-import { pb, updateUserSettings, updateCookieToken } from "./lib/api.ts"
+import { pb, updateUserSettings } from "./lib/api.ts"
 import * as systemsManager from "./lib/systemsManager.ts"
 import { useStore } from "@nanostores/react"
 import { Toaster } from "./components/ui/toaster.tsx"
@@ -27,10 +27,8 @@ const App = memo(() => {

 	useEffect(() => {
 		// change auth store on auth change
-		updateCookieToken()
 		pb.authStore.onChange(() => {
 			$authenticated.set(pb.authStore.isValid)
-			updateCookieToken()
 		})
 		// get version / public key
 		pb.send("/api/beszel/getkey", {}).then((data) => {
@@ -38,17 +36,11 @@ const App = memo(() => {
 		})
 		// get user settings
 		updateUserSettings()
-		const startingSystems = globalThis.BESZEL.SYSTEMS
-		for (const system of startingSystems) {
-			// if (typeof system.info === "string") {
-			system.info = JSON.parse(system.info as unknown as string)
-			// }
-		}
 		// need to get system list before alerts
 		systemsManager.init()
 		systemsManager
 			// get current systems list
-			.refresh(startingSystems)
+			.refresh()
 			// subscribe to new system updates
 			.then(systemsManager.subscribe)
 			// get current alerts
@@ -59,7 +51,6 @@ const App = memo(() => {
 			// updateFavicon("favicon.svg")
 			alertManager.unsubscribe()
 			systemsManager.unsubscribe()
-			globalThis.BESZEL.SYSTEMS = []
 		}
 	}, [])

--- a/beszel/site/src/types.d.ts
+++ b/beszel/site/src/types.d.ts
@@ -7,8 +7,6 @@ declare global {
 		BASE_PATH: string
 		HUB_VERSION: string
 		HUB_URL: string
-		/** initial list of systems */
-		SYSTEMS: SystemRecord[]
 	}
 }

--- a/supplemental/scripts/install-agent.sh
+++ b/supplemental/scripts/install-agent.sh
@@ -216,11 +216,11 @@ if [ "$UNINSTALL" = true ]; then
    echo "Removing the OpenRC service files..."
    rm -f /etc/init.d/beszel-agent

-    # Remove the update service if it exists
-    echo "Removing the daily update service..."
-    rc-service beszel-agent-update stop 2>/dev/null
-    rc-update del beszel-agent-update default 2>/dev/null
-    rm -f /etc/init.d/beszel-agent-update
+    # Remove the daily update cron job if it exists
+    echo "Removing the daily update cron job..."
+    if crontab -u root -l 2>/dev/null | grep -q "beszel-agent.*update"; then
+      crontab -u root -l 2>/dev/null | grep -v "beszel-agent.*update" | crontab -u root -
+    fi

    # Remove log files
    echo "Removing log files..."
@@ -321,6 +321,9 @@ if [ -z "$KEY" ]; then
  read KEY
 fi

+# Remove newlines from KEY
+KEY=$(echo "$KEY" | tr -d '\n')
+
 # TOKEN and HUB_URL are optional for backwards compatibility - no interactive prompts
 # They will be set as empty environment variables if not provided

@@ -523,35 +526,19 @@ EOF
  elif [ "$AUTO_UPDATE_FLAG" = "false" ]; then
    AUTO_UPDATE="n"
  else
-    printf "\nWould you like to enable automatic daily updates for beszel-agent? (y/n): "
+    printf "\nEnable automatic daily updates for beszel-agent? (y/n): "
    read AUTO_UPDATE
  fi
  case "$AUTO_UPDATE" in
  [Yy]*)
    echo "Setting up daily automatic updates for beszel-agent..."

-    cat >/etc/init.d/beszel-agent-update <<EOF
-#!/sbin/openrc-run
+    # Create cron job to run beszel-agent update command daily at midnight
+    if ! crontab -u root -l 2>/dev/null | grep -q "beszel-agent.*update"; then
+      (crontab -u root -l 2>/dev/null; echo "12 0 * * * /opt/beszel-agent/beszel-agent update >/dev/null 2>&1") | crontab -u root -
+    fi

-name="beszel-agent-update"
-description="Update beszel-agent if needed"
-
-depend() {
-    need beszel-agent
-}
-
-start() {
-    ebegin "Checking for beszel-agent updates"
-    /opt/beszel-agent/beszel-agent update
-    eend $?
-}
-EOF
-
-    chmod +x /etc/init.d/beszel-agent-update
-    rc-update add beszel-agent-update default
-    rc-service beszel-agent-update start
-
-    printf "\nAutomatic daily updates have been enabled.\n"
+    printf "\nDaily updates have been enabled via cron job.\n"
    ;;
  esac

@@ -612,7 +599,7 @@ EOF
    AUTO_UPDATE="n"
    sleep 1 # give time for the service to start
  else
-    printf "\nWould you like to enable automatic daily updates for beszel-agent? (y/n): "
+    printf "\nEnable automatic daily updates for beszel-agent? (y/n): "
    read AUTO_UPDATE
  fi
  case "$AUTO_UPDATE" in
@@ -620,12 +607,12 @@ EOF
    echo "Setting up daily automatic updates for beszel-agent..."

    cat >/etc/crontabs/beszel <<EOF
-0 0 * * * /etc/init.d/beszel-agent update
+12 0 * * * /etc/init.d/beszel-agent update
 EOF

    /etc/init.d/cron restart

-    printf "\nAutomatic daily updates have been enabled.\n"
+    printf "\nDaily updates have been enabled.\n"
    ;;
  esac

@@ -695,7 +682,7 @@ EOF
    AUTO_UPDATE="n"
    sleep 1 # give time for the service to start
  else
-    printf "\nWould you like to enable automatic daily updates for beszel-agent? (y/n): "
+    printf "\nEnable automatic daily updates for beszel-agent? (y/n): "
    read AUTO_UPDATE
  fi
  case "$AUTO_UPDATE" in
@@ -730,7 +717,7 @@ EOF
    systemctl daemon-reload
    systemctl enable --now beszel-agent-update.timer

-    printf "\nAutomatic daily updates have been enabled.\n"
+    printf "\nDaily updates have been enabled.\n"
    ;;
  esac
Author	SHA1	Message	Date
henrygd	f7618ed6b0	update go version for vulcheck action	2025-09-04 19:17:44 -04:00
henrygd	d1295b7c50	alerts tests and small refactoring	2025-09-04 19:13:10 -04:00
henrygd	a162a54a58	bump go version and add keyword	2025-09-04 19:13:10 -04:00
henrygd	794db0ac6a	make sure old names are removed in systemsbyname store	2025-09-04 19:13:10 -04:00
henrygd	e9fb9b856f	install script: remove newlines from KEY (#1139 )	2025-09-04 11:26:53 -04:00
Sven van Ginkel	66bca11d36	[Bug] Update install script to use crontab on Alpine (#1136 ) * add cron * update the install script	2025-09-03 23:10:38 -04:00
henrygd	86e87f0d47	refactor hub dev server - moved html replacement functionality from vite to go	2025-09-01 22:16:57 -04:00