Andy Dixon
777e8f50b5
Phase 8, completing milestone M1. A user message is stored and appended as an observation event carrying trust, actor, channel and reference. The perceive process analyses it deterministically (intent, introspection kind, entities, claims, urgency) and, within the per-cycle model allowance, enriches it through the perceive prompt. Its handler writes a perception event, an episodic memory with participants, turns claims into beliefs whose evidence is the message, and builds a response intent from state: beliefs and memories for the topic, evidence rows for why-questions, the uncertain band, contested beliefs and their links, recent learning, status changes, and honest declines for subsystems that do not exist yet or for requests with no capabilities. The respond prompt phrases the intent when a model is assigned; otherwise the reply is a direct rendering of the intent. response_generated cites the message, the perception, every belief and memory used, the episode and the model call. API: conversations, messages with optional wait, one-shot ask; chat UI with live refresh and a per-reply intent view. Sample mind Dani as a strictly decoded seed document with an import endpoint and noemactl mind import. tests/m1 drives all fourteen milestone steps including restart.
359 lines
12 KiB
Go
359 lines
12 KiB
Go
// Package ui serves the server-rendered administration interface. Every page
|
||
// is a Go handler plus an html/template; live updates reuse the same templates
|
||
// through SSE fragments (ADR-0007).
|
||
package ui
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/base64"
|
||
"encoding/json"
|
||
"fmt"
|
||
"html/template"
|
||
"io/fs"
|
||
"net/http"
|
||
"net/url"
|
||
"os"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/andydixon/noema/internal/api"
|
||
"github.com/andydixon/noema/internal/app"
|
||
"github.com/andydixon/noema/internal/attention"
|
||
"github.com/andydixon/noema/internal/auth"
|
||
"github.com/andydixon/noema/internal/beliefs"
|
||
"github.com/andydixon/noema/internal/conversation"
|
||
"github.com/andydixon/noema/internal/llm"
|
||
"github.com/andydixon/noema/internal/minds"
|
||
"github.com/andydixon/noema/internal/version"
|
||
"github.com/andydixon/noema/pkg/concepts"
|
||
"github.com/andydixon/noema/pkg/ids"
|
||
"github.com/andydixon/noema/web"
|
||
)
|
||
|
||
// UI holds handlers and the parsed template set.
|
||
type UI struct {
|
||
deps app.Deps
|
||
pages map[string]*template.Template
|
||
static fs.FS
|
||
statusF func(r *http.Request) any // system status provider injected by api
|
||
ctxF func(r *http.Request, id ids.ID) (api.EventContext, error) // event forensic context, shared with api
|
||
wsF func(r *http.Request, m minds.Mind) (api.WorkspaceView, error)
|
||
memF func(r *http.Request, mind, id ids.ID) (api.MemoryDetail, error)
|
||
belF func(r *http.Request, mind, id ids.ID) (api.BeliefDetail, error)
|
||
emitF func() beliefs.Emitter
|
||
postF func(r *http.Request, mind ids.ID, conv conversation.Conversation, text, who string) (conversation.Message, error)
|
||
}
|
||
|
||
// View is the data passed to every template.
|
||
type View struct {
|
||
Title string
|
||
Path string
|
||
Principal *auth.Principal
|
||
CSRF string
|
||
Flash *Flash
|
||
Version string
|
||
Data any
|
||
}
|
||
|
||
// Flash is a one-shot message shown on the next page load.
|
||
type Flash struct{ Kind, Message string }
|
||
|
||
const flashCookie = "noema_flash"
|
||
|
||
// New parses templates. In development, when ./web exists on disk, templates
|
||
// and static files are read from disk so edits show without a rebuild.
|
||
func New(deps app.Deps, statusF func(r *http.Request) any, ctxF func(r *http.Request, id ids.ID) (api.EventContext, error), wsF func(r *http.Request, m minds.Mind) (api.WorkspaceView, error), memF func(r *http.Request, mind, id ids.ID) (api.MemoryDetail, error), belF func(r *http.Request, mind, id ids.ID) (api.BeliefDetail, error), emitF func() beliefs.Emitter, postF func(r *http.Request, mind ids.ID, conv conversation.Conversation, text, who string) (conversation.Message, error)) (*UI, error) {
|
||
tmplFS, staticFS := web.Templates(), web.Static()
|
||
if !deps.Config.Production() {
|
||
if st, err := os.Stat("web/templates"); err == nil && st.IsDir() {
|
||
tmplFS, staticFS = os.DirFS("web/templates"), os.DirFS("web/static")
|
||
deps.Log.Info("ui: serving templates and static files from ./web (development)")
|
||
}
|
||
}
|
||
u := &UI{deps: deps, static: staticFS, statusF: statusF, ctxF: ctxF, wsF: wsF, memF: memF, belF: belF, emitF: emitF, postF: postF}
|
||
if err := u.parse(tmplFS); err != nil {
|
||
return nil, err
|
||
}
|
||
return u, nil
|
||
}
|
||
|
||
func (u *UI) parse(fsys fs.FS) error {
|
||
funcs := template.FuncMap{
|
||
"hasPrefix": strings.HasPrefix,
|
||
"roles": auth.AllRoles,
|
||
"date": func(t time.Time) string { return t.Local().Format("2006-01-02 15:04") },
|
||
"ago": ago,
|
||
"duration": func(s int64) string { return (time.Duration(s) * time.Second).Truncate(time.Second).String() },
|
||
"bytes": humanBytes,
|
||
"pct": func(f float64) string { return fmt.Sprintf("%.0f%%", f*100) },
|
||
"conf": func(v any) string {
|
||
switch x := v.(type) {
|
||
case float64:
|
||
return fmt.Sprintf("%.2f", x)
|
||
case float32:
|
||
return fmt.Sprintf("%.2f", x)
|
||
case *float64:
|
||
if x != nil {
|
||
return fmt.Sprintf("%.2f", *x)
|
||
}
|
||
}
|
||
return "–"
|
||
},
|
||
"inc": func(i int) int { return i + 1 },
|
||
"deref": func(v any) any {
|
||
switch x := v.(type) {
|
||
case *float64:
|
||
if x == nil {
|
||
return 0.0
|
||
}
|
||
return *x
|
||
case *bool:
|
||
if x == nil {
|
||
return false
|
||
}
|
||
return *x
|
||
}
|
||
return v
|
||
},
|
||
"title": func(s string) string { s = strings.ReplaceAll(s, "_", " "); return strings.ToUpper(s[:1]) + s[1:] },
|
||
"valueKeys": func() []string { return minds.ValueKeys },
|
||
"features": func() []string { return minds.AttentionFeatures },
|
||
"memoryKinds": func() []concepts.MemoryKind { return concepts.AllMemoryKinds },
|
||
"epistemicKinds": func() []concepts.Epistemic { return concepts.AllEpistemic },
|
||
"relations": func() []concepts.Relation { return concepts.AllRelations },
|
||
"llmRoles": func() []llm.RoleInfo { return llm.Roles },
|
||
"pretty": prettyRaw,
|
||
"deref_id": func(id *ids.ID) ids.ID {
|
||
if id == nil {
|
||
return ids.Nil
|
||
}
|
||
return *id
|
||
},
|
||
"deref_int": func(i *int) int {
|
||
if i == nil {
|
||
return 0
|
||
}
|
||
return *i
|
||
},
|
||
"has_id": func(list []ids.ID, id ids.ID) bool {
|
||
for _, x := range list {
|
||
if x == id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
},
|
||
"beliefStatuses": func() []beliefs.Status {
|
||
return []beliefs.Status{beliefs.StatusHypothesis, beliefs.StatusTentative, beliefs.StatusLikely, beliefs.StatusAccepted, beliefs.StatusContested, beliefs.StatusRejected, beliefs.StatusSuperseded}
|
||
},
|
||
"trunc": func(s string, n int) string {
|
||
if len(s) > n {
|
||
return s[:n] + "…"
|
||
}
|
||
return s
|
||
},
|
||
"candSummary": func(s string) string {
|
||
if i := strings.Index(s, "] "); i > 0 && strings.HasPrefix(s, "[") {
|
||
return s[i+2:]
|
||
}
|
||
return s
|
||
},
|
||
"payloadField": func(raw json.RawMessage, field string) string {
|
||
var m map[string]any
|
||
if json.Unmarshal(raw, &m) != nil {
|
||
return ""
|
||
}
|
||
return fmt.Sprint(m[field])
|
||
},
|
||
"breakdownOf": func(raw json.RawMessage) *attention.Breakdown {
|
||
var p struct {
|
||
Breakdown attention.Breakdown `json:"breakdown"`
|
||
}
|
||
if json.Unmarshal(raw, &p) != nil || len(p.Breakdown.Terms) == 0 {
|
||
return nil
|
||
}
|
||
return &p.Breakdown
|
||
},
|
||
"traitKeys": func() []string { return minds.TraitKeys },
|
||
"dict": func(kv ...any) map[string]any {
|
||
m := map[string]any{}
|
||
for i := 0; i+1 < len(kv); i += 2 {
|
||
m[fmt.Sprint(kv[i])] = kv[i+1]
|
||
}
|
||
return m
|
||
},
|
||
}
|
||
base, err := template.New("base").Funcs(funcs).ParseFS(fsys, "layout.html")
|
||
if err != nil {
|
||
return fmt.Errorf("ui: parse layout: %w", err)
|
||
}
|
||
if partials, _ := fs.Glob(fsys, "partials/*.html"); len(partials) > 0 {
|
||
if _, err := base.ParseFS(fsys, partials...); err != nil {
|
||
return fmt.Errorf("ui: parse partials: %w", err)
|
||
}
|
||
}
|
||
pages, err := fs.Glob(fsys, "pages/*.html")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
u.pages = map[string]*template.Template{}
|
||
for _, p := range pages {
|
||
t, err := base.Clone()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if _, err := t.ParseFS(fsys, p); err != nil {
|
||
return fmt.Errorf("ui: parse %s: %w", p, err)
|
||
}
|
||
u.pages[strings.TrimPrefix(strings.TrimSuffix(p, ".html"), "pages/")] = t
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// render executes a page template. Rendering into a buffer first means a
|
||
// template error yields a proper 500 instead of a half-written page.
|
||
func (u *UI) render(w http.ResponseWriter, r *http.Request, page, title string, data any) {
|
||
t, ok := u.pages[page]
|
||
if !ok {
|
||
http.Error(w, "template not found: "+page, http.StatusInternalServerError)
|
||
return
|
||
}
|
||
v := View{Title: title, Path: r.URL.Path, Version: version.Version, Data: data}
|
||
if p, ok := auth.PrincipalFrom(r.Context()); ok {
|
||
v.Principal = &p
|
||
if tok, err := u.deps.Auth.CSRFToken(r.Context(), p.SessionID); err == nil {
|
||
v.CSRF = tok
|
||
}
|
||
}
|
||
if c, err := r.Cookie(flashCookie); err == nil && c.Value != "" {
|
||
if raw, err := base64.RawURLEncoding.DecodeString(c.Value); err == nil {
|
||
if kind, msg, ok := strings.Cut(string(raw), "|"); ok {
|
||
v.Flash = &Flash{Kind: kind, Message: msg}
|
||
}
|
||
}
|
||
http.SetCookie(w, &http.Cookie{Name: flashCookie, Path: "/", MaxAge: -1, HttpOnly: true, SameSite: http.SameSiteLaxMode})
|
||
}
|
||
var buf bytes.Buffer
|
||
if err := t.ExecuteTemplate(&buf, "layout", v); err != nil {
|
||
u.deps.Log.Error("template execution failed", "page", page, "err", err)
|
||
http.Error(w, "template error", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
buf.WriteTo(w) //nolint:errcheck
|
||
}
|
||
|
||
// flash stores a one-shot message and redirects.
|
||
func (u *UI) flash(w http.ResponseWriter, r *http.Request, kind, msg, to string) {
|
||
val := base64.RawURLEncoding.EncodeToString([]byte(kind + "|" + msg))
|
||
http.SetCookie(w, &http.Cookie{Name: flashCookie, Value: val, Path: "/", MaxAge: 60, HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: u.deps.Config.Production()})
|
||
http.Redirect(w, r, to, http.StatusSeeOther)
|
||
}
|
||
|
||
func (u *UI) errorPage(w http.ResponseWriter, r *http.Request, status int, msg string) {
|
||
w.WriteHeader(status)
|
||
u.render(w, r, "error", http.StatusText(status), map[string]any{"Status": status, "Message": msg})
|
||
}
|
||
|
||
// uiAuthFail redirects anonymous users to login and shows 403 to others.
|
||
func (u *UI) uiAuthFail(w http.ResponseWriter, r *http.Request, authenticated bool) {
|
||
if authenticated {
|
||
u.errorPage(w, r, http.StatusForbidden, "Your role does not permit this page.")
|
||
return
|
||
}
|
||
next := ""
|
||
if r.Method == http.MethodGet && r.URL.Path != "/" {
|
||
next = "?next=" + url.QueryEscape(r.URL.RequestURI())
|
||
}
|
||
http.Redirect(w, r, "/login"+next, http.StatusSeeOther)
|
||
}
|
||
|
||
func (u *UI) require(min auth.Role, h http.HandlerFunc) http.Handler {
|
||
return auth.RequireRole(min, u.uiAuthFail)(h)
|
||
}
|
||
|
||
// Register mounts all UI routes.
|
||
func (u *UI) Register(m *http.ServeMux) {
|
||
m.Handle("GET /static/", http.StripPrefix("/static/", cacheStatic(http.FileServerFS(u.static))))
|
||
m.HandleFunc("GET /login", u.loginForm)
|
||
m.HandleFunc("POST /login", u.loginSubmit)
|
||
m.HandleFunc("POST /logout", u.logout)
|
||
m.HandleFunc("GET /setup", u.setupForm)
|
||
m.HandleFunc("POST /setup", u.setupSubmit)
|
||
m.HandleFunc("GET /about", func(w http.ResponseWriter, r *http.Request) { u.render(w, r, "about", "Interpretation boundary", nil) })
|
||
|
||
m.Handle("GET /{$}", u.require(auth.RoleObserver, u.dashboard))
|
||
m.Handle("GET /system", u.require(auth.RoleObserver, u.system))
|
||
m.Handle("GET /audit", u.require(auth.RoleOperator, u.audit))
|
||
m.Handle("GET /account", u.require(auth.RoleObserver, u.account))
|
||
m.Handle("POST /account/password", u.require(auth.RoleObserver, u.accountPassword))
|
||
m.Handle("POST /account/sessions/{id}/revoke", u.require(auth.RoleObserver, u.accountSessionRevoke))
|
||
m.Handle("POST /account/tokens", u.require(auth.RoleObserver, u.accountTokenCreate))
|
||
m.Handle("POST /account/tokens/{id}/revoke", u.require(auth.RoleObserver, u.accountTokenRevoke))
|
||
m.Handle("GET /admin/users", u.require(auth.RoleAdministrator, u.users))
|
||
m.Handle("POST /admin/users", u.require(auth.RoleAdministrator, u.usersCreate))
|
||
m.Handle("POST /admin/users/{id}", u.require(auth.RoleAdministrator, u.usersUpdate))
|
||
|
||
u.mindRoutes(m)
|
||
u.eventRoutes(m)
|
||
u.memoryRoutes(m)
|
||
u.beliefRoutes(m)
|
||
u.llmRoutes(m)
|
||
u.conversationRoutes(m)
|
||
|
||
for _, p := range []struct{ path, title, note string }{
|
||
{"/approvals", "Approvals", "The approval centre arrives with the capability system."},
|
||
{"/integrations", "Integrations", "Integrations arrive in phase 13."},
|
||
{"/policies", "Policies", "The policy matrix arrives in phase 12."},
|
||
} {
|
||
m.Handle("GET "+p.path, u.require(auth.RoleObserver, func(w http.ResponseWriter, r *http.Request) { u.render(w, r, "placeholder", p.title, p.note) }))
|
||
}
|
||
}
|
||
|
||
func cacheStatic(h http.Handler) http.Handler {
|
||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
w.Header().Set("Cache-Control", "public, max-age=300")
|
||
h.ServeHTTP(w, r)
|
||
})
|
||
}
|
||
|
||
func ago(t any) string {
|
||
var tm time.Time
|
||
switch v := t.(type) {
|
||
case time.Time:
|
||
tm = v
|
||
case *time.Time:
|
||
if v == nil {
|
||
return "never"
|
||
}
|
||
tm = *v
|
||
default:
|
||
return ""
|
||
}
|
||
d := time.Since(tm)
|
||
switch {
|
||
case d < time.Minute:
|
||
return "just now"
|
||
case d < time.Hour:
|
||
return fmt.Sprintf("%dm ago", int(d.Minutes()))
|
||
case d < 48*time.Hour:
|
||
return fmt.Sprintf("%dh ago", int(d.Hours()))
|
||
default:
|
||
return fmt.Sprintf("%dd ago", int(d.Hours()/24))
|
||
}
|
||
}
|
||
|
||
func humanBytes(n uint64) string {
|
||
const unit = 1024
|
||
if n < unit {
|
||
return fmt.Sprintf("%d B", n)
|
||
}
|
||
div, exp := uint64(unit), 0
|
||
for m := n / unit; m >= unit; m /= unit {
|
||
div *= unit
|
||
exp++
|
||
}
|
||
return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
|
||
}
|