131 lines
3.2 KiB
Go
131 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// A SpunCrow is a crow the Boss created: its own name, the persona whose
|
|
// habits it runs on, and the trust it started at ("stranger" or "regular").
|
|
// Once created it is an ordinary crow: the same ledger and guardrails apply.
|
|
type SpunCrow struct {
|
|
Name string `json:"name"`
|
|
Persona string `json:"persona"`
|
|
Trust string `json:"trust"`
|
|
}
|
|
|
|
// CrowStore is the spun-crow registry. It follows the atomic-save style of
|
|
// NestStore: one JSON file, written to a temp path and renamed.
|
|
type CrowStore struct {
|
|
path string
|
|
mu sync.Mutex
|
|
spun []SpunCrow
|
|
}
|
|
|
|
func LoadCrowStore(path string) (*CrowStore, error) {
|
|
s := &CrowStore{path: path}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return nil, err
|
|
}
|
|
if err == nil {
|
|
if err := json.Unmarshal(data, &s.spun); err != nil {
|
|
return nil, fmt.Errorf("crows file is unreadable: %w", err)
|
|
}
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// All returns every spun crow, sorted by name.
|
|
func (s *CrowStore) All() []SpunCrow {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
out := make([]SpunCrow, len(s.spun))
|
|
copy(out, s.spun)
|
|
slices.SortFunc(out, func(a, b SpunCrow) int { return strings.Compare(a.Name, b.Name) })
|
|
return out
|
|
}
|
|
|
|
// Get finds a spun crow by name.
|
|
func (s *CrowStore) Get(name string) (SpunCrow, bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
for _, c := range s.spun {
|
|
if c.Name == name {
|
|
return c, true
|
|
}
|
|
}
|
|
return SpunCrow{}, false
|
|
}
|
|
|
|
// Add registers a new spun crow and saves. A name already in the registry is
|
|
// refused; any other error means the save failed.
|
|
func (s *CrowStore) Add(c SpunCrow) error {
|
|
c.Name = strings.TrimSpace(c.Name)
|
|
if c.Name == "" {
|
|
return fmt.Errorf("a spun crow needs a name")
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
for _, e := range s.spun {
|
|
if strings.EqualFold(e.Name, c.Name) {
|
|
return fmt.Errorf("%s is already in the registry", c.Name)
|
|
}
|
|
}
|
|
s.spun = append(s.spun, c)
|
|
if err := s.save(); err != nil {
|
|
s.spun = s.spun[:len(s.spun)-1]
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Has reports whether a crow with that name is in the registry.
|
|
func (s *CrowStore) Has(name string) bool {
|
|
_, ok := s.Get(name)
|
|
return ok
|
|
}
|
|
|
|
// Len is how many crows the registry holds.
|
|
func (s *CrowStore) Len() int {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return len(s.spun)
|
|
}
|
|
|
|
// save writes atomically. The caller holds s.mu.
|
|
func (s *CrowStore) save() error {
|
|
data, err := json.MarshalIndent(s.spun, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(s.path), 0o755); err != nil {
|
|
return err
|
|
}
|
|
tmp := s.path + ".tmp"
|
|
if err := os.WriteFile(tmp, data, 0o644); err != nil {
|
|
return err
|
|
}
|
|
return os.Rename(tmp, s.path)
|
|
}
|
|
|
|
// getCrowRegistry lists the spun crows (EVENTS.md: the registry lives here,
|
|
// never the persona crows). A server with no registry reads as empty.
|
|
func (s *Server) getCrowRegistry(w http.ResponseWriter, r *http.Request) {
|
|
var spun []SpunCrow
|
|
if s.crows != nil {
|
|
spun = s.crows.All()
|
|
}
|
|
out := make([]map[string]string, 0, len(spun))
|
|
for _, c := range spun {
|
|
out = append(out, map[string]string{"name": c.Name, "persona": c.Persona, "trust": c.Trust})
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{"crows": out})
|
|
}
|