feat(demo): reset the demo instance every 20 minutes with a countdown

DEMO_RESET_MINUTES (default 20, 0 = off) resets the database to the
sample data. Demo accounts get fixed IDs so sessions survive; requests
hold a read lock so the reset never runs under a half-finished request
(streams excluded). DEMO_RESET goes to every connection, /auth/status
announces the next reset. The app shows "✨ Demo · Reset in MM:SS" in
place of the version, then clears cached answers, remounts the views,
reloads in the background and shows a short notice; if no event
arrives (long polling) it asks the server after the countdown.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/api/demo.go

@@ -0,0 +1,77 @@
+package api
+
+import (
+	"log/slog"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// In demo mode the database is reset to the sample data every DEMO_RESET_MINUTES. Requests hold a read
+// lock while they run and the reset takes the write lock, so no request sees half-dropped tables.
+// Long-lived streams (WebSocket, SSE, long polling) are left out, otherwise the reset would wait for
+// them forever; they reconnect or retry on their own. The demo accounts keep their IDs, so sessions
+// stay valid; clients get DEMO_RESET and reload their data.
+
+type demoState struct {
+	gate sync.RWMutex // read: a running request, write: the reset
+
+	mu        sync.Mutex
+	nextReset time.Time
+}
+
+func isLongLivedRequest(r *http.Request) bool {
+	p := r.URL.Path
+	return strings.HasPrefix(p, "/api/v1/ws") || p == "/api/v1/events" ||
+		(strings.HasPrefix(p, "/api/v1/docs/") && strings.HasSuffix(p, "/changes"))
+}
+
+func (s *Server) demoResetGate(next http.Handler) http.Handler {
+	if !s.cfg.DemoMode {
+		return next
+	}
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isLongLivedRequest(r) || !strings.HasPrefix(r.URL.Path, "/api/") {
+			next.ServeHTTP(w, r)
+			return
+		}
+		s.demo.gate.RLock()
+		defer s.demo.gate.RUnlock()
+		next.ServeHTTP(w, r)
+	})
+}
+
+// demoNextReset is zero when no periodic reset runs.
+func (s *Server) demoNextReset() time.Time {
+	s.demo.mu.Lock()
+	defer s.demo.mu.Unlock()
+	return s.demo.nextReset
+}
+
+func (s *Server) setDemoNextReset(t time.Time) {
+	s.demo.mu.Lock()
+	s.demo.nextReset = t
+	s.demo.mu.Unlock()
+}
+
+func (s *Server) resetDemo() {
+	s.demo.gate.Lock()
+	err := s.store.ResetAndSeedDemo()
+	s.demo.gate.Unlock()
+	if err != nil {
+		slog.Error("Demo-Reset fehlgeschlagen", "error", err)
+		return
+	}
+	s.wsHub.BroadcastSystem("DEMO_RESET")
+}
+
+func (s *Server) startDemoResetTicker() {
+	interval := time.Duration(s.cfg.DemoResetMinutes) * time.Minute
+	for {
+		next := time.Now().Add(interval)
+		s.setDemoNextReset(next)
+		time.Sleep(time.Until(next))
+		s.resetDemo()
+	}
+}

internal/api/demo_test.go

@@ -0,0 +1,90 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/sandrodach/mindsift/internal/config"
+	"github.com/sandrodach/mindsift/internal/storage"
+	"github.com/sandrodach/mindsift/internal/ws"
+)
+
+func TestDemoResetKeepsSessionsAndRestoresSampleData(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "demo_reset.db")
+	store, err := storage.NewStore(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+	if err := store.ResetAndSeedDemo(); err != nil {
+		t.Fatal(err)
+	}
+	srv := NewServer(&config.Config{DatabasePath: dbPath, JWTSecret: "demo-secret", DemoMode: true}, store, ws.NewHub(), nil)
+	router := srv.Router()
+	call := func(method, path, token, body string) *httptest.ResponseRecorder {
+		req := httptest.NewRequest(method, path, strings.NewReader(body))
+		req.Header.Set("Content-Type", "application/json")
+		if token != "" {
+			req.Header.Set("Authorization", "Bearer "+token)
+		}
+		rec := httptest.NewRecorder()
+		router.ServeHTTP(rec, req)
+		return rec
+	}
+	var login struct{ Token string }
+	_ = json.Unmarshal(call("POST", "/api/v1/auth/login", "", `{"login":"admin","password":"admin"}`).Body.Bytes(), &login)
+	countDocs := func() int {
+		var docs []json.RawMessage
+		_ = json.Unmarshal(call("GET", "/api/v1/documents", login.Token, "").Body.Bytes(), &docs)
+		return len(docs)
+	}
+	seeded := countDocs()
+	if seeded == 0 {
+		t.Fatal("expected sample notes")
+	}
+	if rec := call("POST", "/api/v1/documents", login.Token, `{"title":"Testnotiz"}`); rec.Code >= 300 {
+		t.Fatalf("create note: %d %s", rec.Code, rec.Body.String())
+	}
+
+	// Requests running during the reset must neither fail half-way nor see missing tables
+	var wg sync.WaitGroup
+	failures := make(chan int, 50)
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if rec := call("GET", "/api/v1/documents", login.Token, ""); rec.Code != http.StatusOK {
+				failures <- rec.Code
+			}
+		}()
+	}
+	srv.resetDemo()
+	wg.Wait()
+	close(failures)
+	for code := range failures {
+		t.Errorf("request during reset failed with %d", code)
+	}
+
+	if rec := call("GET", "/api/v1/auth/me", login.Token, ""); rec.Code != http.StatusOK {
+		t.Fatalf("session must survive the reset, got %d", rec.Code)
+	}
+	if n := countDocs(); n != seeded {
+		t.Errorf("reset should restore the %d sample notes, got %d", seeded, n)
+	}
+
+	srv.setDemoNextReset(time.Now().Add(90 * time.Second))
+	var st struct {
+		DemoNextReset      string `json:"demoNextReset"`
+		DemoResetInSeconds int    `json:"demoResetInSeconds"`
+	}
+	_ = json.Unmarshal(call("GET", "/api/v1/auth/status", "", "").Body.Bytes(), &st)
+	if st.DemoNextReset == "" || st.DemoResetInSeconds < 85 || st.DemoResetInSeconds > 90 {
+		t.Errorf("status should announce the next reset: %+v", st)
+	}
+}

internal/api/handlers_auth.go

@@ -37,7 +37,7 @@ func (s *Server) handleAuthStatus(w http.ResponseWriter, r *http.Request) {
 			instanceName = sys.InstanceName
 		}
 	}
-	writeJSON(w, http.StatusOK, map[string]interface{}{
+	status := map[string]interface{}{
 		"needsSetup":        count == 0,
 		"allowRegistration": allowReg,
 		"instanceName":      instanceName,
@@ -51,7 +51,14 @@ func (s *Server) handleAuthStatus(w http.ResponseWriter, r *http.Request) {
 			"privacyUrl":        s.cfg.Legal.PrivacyURL,
 			"hasPrivacyContent": s.cfg.Legal.PrivacyContent != "",
 		},
-	})
+	}
+	// Countdown to the next demo reset; seconds as well, so client clocks do not matter
+	if next := s.demoNextReset(); !next.IsZero() {
+		status["demoNextReset"] = next.UTC().Format(time.RFC3339)
+		status["demoResetInSeconds"] = int(time.Until(next).Seconds())
+		status["demoResetMinutes"] = s.cfg.DemoResetMinutes
+	}
+	writeJSON(w, http.StatusOK, status)
 }
 
 // handleLegalText serves the configured Markdown of the imprint or privacy notice (public, no login).

internal/api/server.go

@@ -28,6 +28,8 @@ type Server struct {
 
 	leases   *collab.LeaseManager // block leases and open sessions of notes
 	notifier *collab.Notifier     // wakes long-poll requests on note changes
+
+	demo demoState // periodic reset in demo mode (demo.go)
 }
 
 func NewServer(cfg *config.Config, store *storage.Store, wsHub *ws.Hub, staticFS fs.FS) *Server {
@@ -46,6 +48,9 @@ func NewServer(cfg *config.Config, store *storage.Store, wsHub *ws.Hub, staticFS
 	}
 	go srv.startAlarmTicker()
 	go srv.startCompaction()
+	if cfg.DemoMode && cfg.DemoResetMinutes > 0 {
+		go srv.startDemoResetTicker()
+	}
 	return srv
 }
 
@@ -70,6 +75,7 @@ func (s *Server) Router() http.Handler {
 	r := chi.NewRouter()
 
 	r.Use(middleware.RealIP)
+	r.Use(s.demoResetGate)
 	r.Use(middleware.Recoverer)
 	r.Use(s.apiLoggingMiddleware)
 	r.Use(cors.Handler(cors.Options{

internal/config/config.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"crypto/rand"
+	"strconv"
 	"encoding/hex"
 	"log/slog"
 	"os"
@@ -22,6 +23,8 @@ type Config struct {
 	LogLevel          string
 	Debug             bool
 	DemoMode          bool
+	// DemoResetMinutes: in demo mode the database is reset to the sample data this often (0 = never)
+	DemoResetMinutes int
 
 	// Optional SMTP environment variables (can also be overridden/configured in DB system_settings)
 	SMTPHost string
@@ -161,6 +164,7 @@ func Load() *Config {
 		LogLevel:          logLevel,
 		Debug:             debug,
 		DemoMode:          demoMode,
+		DemoResetMinutes:  demoResetMinutes(),
 		SMTPHost:          smtpHost,
 		SMTPPort:          smtpPort,
 		SMTPUser:          smtpUser,
@@ -197,3 +201,11 @@ func getEnv(key, fallback string) string {
 	}
 	return fallback
 }
+
+func demoResetMinutes() int {
+	n, err := strconv.Atoi(strings.TrimSpace(getEnv("DEMO_RESET_MINUTES", "20")))
+	if err != nil || n < 0 {
+		return 20
+	}
+	return n
+}

internal/storage/users.go

@@ -67,6 +67,10 @@ func (s *Store) CreateUser(email, passwordHash, displayName, role string) (*doma
 }
 
 func (s *Store) CreateUserWithUsername(email, username, passwordHash, displayName, role string) (*domain.User, error) {
+	return s.createUserWithID(domain.NewID("usr"), email, username, passwordHash, displayName, role)
+}
+
+func (s *Store) createUserWithID(id, email, username, passwordHash, displayName, role string) (*domain.User, error) {
 	if role != "admin" && role != "member" {
 		role = "member"
 	}
@@ -76,7 +80,7 @@ func (s *Store) CreateUserWithUsername(email, username, passwordHash, displayNam
 		cleanUsername = strings.Split(cleanEmail, "@")[0]
 	}
 	u := &domain.User{
-		ID:                  domain.NewID("usr"),
+		ID:                  id,
 		Email:               cleanEmail,
 		Username:            cleanUsername,
 		PasswordHash:        passwordHash,
@@ -125,6 +129,13 @@ func (s *Store) GetUserByLogin(login string) (*domain.User, error) {
 }
 
 // EnsureDemoAccounts seeds admin/admin and user/user accounts for demo evaluation
+// Demo accounts keep the same IDs across resets, so the sessions of people trying the demo stay valid
+// when the database is reset underneath them.
+const (
+	DemoAdminID = "usr_demo_admin"
+	DemoUserID  = "usr_demo_user"
+)
+
 func (s *Store) EnsureDemoAccounts() error {
 	s.initMu.Lock()
 	defer s.initMu.Unlock()
@@ -142,7 +153,7 @@ func (s *Store) EnsureDemoAccounts() error {
 	adminCreated := false
 	adminUser, err := s.GetUserByLogin("admin")
 	if err != nil || adminUser == nil {
-		adminUser, err = s.CreateUserWithUsername("admin@mindsift.local", "admin", adminHash, "Admin", "admin")
+		adminUser, err = s.createUserWithID(DemoAdminID, "admin@mindsift.local", "admin", adminHash, "Admin", "admin")
 		if err != nil {
 			return fmt.Errorf("failed to create demo admin: %w", err)
 		}
@@ -155,7 +166,7 @@ func (s *Store) EnsureDemoAccounts() error {
 	// 2. Regular user (user / user)
 	normalUser, err := s.GetUserByLogin("user")
 	if err != nil || normalUser == nil {
-		normalUser, err = s.CreateUserWithUsername("user@mindsift.local", "user", userHash, "User", "member")
+		normalUser, err = s.createUserWithID(DemoUserID, "user@mindsift.local", "user", userHash, "User", "member")
 		if err != nil {
 			return fmt.Errorf("failed to create demo user: %w", err)
 		}

internal/ws/hub.go

@@ -371,6 +371,26 @@ func (h *Hub) BroadcastToUser(userID, event string, payload interface{}) {
 	}
 }
 
+// BroadcastSystem sends an event to every connection. Only for events without user data (e.g. the
+// demo reset notice).
+func (h *Hub) BroadcastSystem(event string) {
+	data, err := json.Marshal(domain.WSMessage{Event: event, Timestamp: domain.NowISO()})
+	if err != nil {
+		return
+	}
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	if h.closed {
+		return
+	}
+	for client := range h.allClients {
+		client.trySend(data)
+	}
+	for sseClient := range h.sseClients {
+		sseClient.trySend(data)
+	}
+}
+
 // BroadcastToUsers sends one event to every connection of the given users (duplicates are ignored).
 func (h *Hub) BroadcastToUsers(userIDs []string, event string, payload interface{}) {
 	seen := make(map[string]bool, len(userIDs))