🎉 live server seems to be working now

internal/live/preset.go

@@ -0,0 +1,168 @@
+package live
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"sync"
+)
+
+// Preset maps one PipeWire capture source to a set of Sendspin clients.
+// Members are sendspin `client_id` values, not friendly names.
+type Preset struct {
+	ID      string   `json:"id"`
+	Name    string   `json:"name"`
+	Source  string   `json:"source"`
+	Members []string `json:"members"`
+}
+
+var idRe = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
+
+func (p *Preset) validate() error {
+	if p.ID == "" {
+		return fmt.Errorf("id is required")
+	}
+	if !idRe.MatchString(p.ID) {
+		return fmt.Errorf("id must be lowercase kebab-case")
+	}
+	if p.Name == "" {
+		return fmt.Errorf("name is required")
+	}
+	if p.Source == "" {
+		return fmt.Errorf("source is required")
+	}
+	return nil
+}
+
+// Store is an in-memory, file-backed preset collection. Writes are
+// serialized; the file is rewritten atomically on every change.
+type Store struct {
+	mu      sync.RWMutex
+	path    string
+	presets map[string]Preset
+	onWrite func()
+}
+
+func NewStore(path string) (*Store, error) {
+	s := &Store{
+		path:    path,
+		presets: make(map[string]Preset),
+	}
+	if err := s.load(); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// OnWrite registers a callback that runs after every successful write.
+// Used by the manager to refresh active state when the active preset
+// changes underneath it.
+func (s *Store) OnWrite(fn func()) {
+	s.mu.Lock()
+	s.onWrite = fn
+	s.mu.Unlock()
+}
+
+func (s *Store) load() error {
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	if len(data) == 0 {
+		return nil
+	}
+	var list []Preset
+	if err := json.Unmarshal(data, &list); err != nil {
+		return fmt.Errorf("parse %s: %w", s.path, err)
+	}
+	for _, p := range list {
+		s.presets[p.ID] = p
+	}
+	return nil
+}
+
+func (s *Store) writeLocked() error {
+	if err := os.MkdirAll(filepath.Dir(s.path), 0o755); err != nil {
+		return err
+	}
+	list := make([]Preset, 0, len(s.presets))
+	for _, p := range s.presets {
+		list = append(list, p)
+	}
+	sort.Slice(list, func(i, j int) bool { return list[i].ID < list[j].ID })
+
+	data, err := json.MarshalIndent(list, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	tmp := s.path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0o644); err != nil {
+		return err
+	}
+	if err := os.Rename(tmp, s.path); err != nil {
+		return err
+	}
+	if s.onWrite != nil {
+		go s.onWrite()
+	}
+	return nil
+}
+
+func (s *Store) List() []Preset {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]Preset, 0, len(s.presets))
+	for _, p := range s.presets {
+		out = append(out, p)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
+	return out
+}
+
+func (s *Store) Get(id string) (Preset, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	p, ok := s.presets[id]
+	return p, ok
+}
+
+func (s *Store) Put(p Preset) error {
+	if err := p.validate(); err != nil {
+		return err
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.presets[p.ID] = p
+	return s.writeLocked()
+}
+
+// Create adds a preset, failing if the ID already exists.
+func (s *Store) Create(p Preset) error {
+	if err := p.validate(); err != nil {
+		return err
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, exists := s.presets[p.ID]; exists {
+		return fmt.Errorf("preset %q already exists", p.ID)
+	}
+	s.presets[p.ID] = p
+	return s.writeLocked()
+}
+
+func (s *Store) Delete(id string) (bool, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, ok := s.presets[id]; !ok {
+		return false, nil
+	}
+	delete(s.presets, id)
+	return true, s.writeLocked()
+}