summaryrefslogtreecommitdiff
path: root/web/serve.go
diff options
context:
space:
mode:
Diffstat (limited to 'web/serve.go')
-rw-r--r--web/serve.go774
1 files changed, 774 insertions, 0 deletions
diff --git a/web/serve.go b/web/serve.go
new file mode 100644
index 0000000..93b3f05
--- /dev/null
+++ b/web/serve.go
@@ -0,0 +1,774 @@
+// serve.go — notevi web as a live web application.
+//
+// The server owns nothing. Three rules keep it that way, and app_test.go holds
+// each of them:
+//
+// - The log sidecar is the only thing written. Notes typed in the browser are
+// appended to it exactly as notevi appends them; project history and the main
+// working copy are only ever read (see jj.go).
+// - Memory is a cache, never a source. The model, the per-change
+// projections, file lists and rendered pages are all derived from the log
+// and the repo, so a restart changes nothing anyone can see.
+// - What is cached is keyed by what it was derived from: the log's
+// generation, and the commit id — not the change id, which is a pointer
+// that moves whenever the change is edited.
+//
+// What a reader chose lives in the URL (which change, how wide the view) or in
+// their own browser (theme, focus, which folders are open). None of it is here.
+//
+// Pages are rendered per request from the same templates the static export
+// uses; htmx swaps the parts that change on their own — filtered note lists,
+// the activity of agents currently reading, jj queries.
+package web
+
+import (
+ "bytes"
+ "fmt"
+ "html/template"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+)
+
+// liveWindow is how recently a session must have logged something to count as
+// still running.
+const liveWindow = 5 * time.Minute
+
+// renderCacheMax bounds the rendered-file cache; it is dropped wholesale
+// whenever the log changes, since coverage is baked into the HTML.
+const renderCacheMax = 64
+
+type server struct {
+ log logStore
+ repo, title, user, session, base string
+ tpl *template.Template
+ hl *highlighter
+ theme, light *Theme
+ themes *themeSet
+ tx *transcripts
+
+ mu sync.Mutex
+ site *Site
+ entries []Entry
+ state string
+ gen int
+ def string // resolved change the log points at
+ models map[string]*Site // scope key -> the log projected onto it
+ trees map[string][]*File // scope key|change -> file list
+ rendered map[string]*File // gen|scope|change|path -> rendered file
+}
+
+// scopeAll is the key of the unscoped model — the whole log, every change.
+const scopeAll = "*"
+
+func newServer(log logStore, repo, title, user string, theme, light *Theme, themes *themeSet) *server {
+ return newServerAt(log, repo, title, user, "/", theme, light, themes)
+}
+
+func newServerAt(log logStore, repo, title, user, base string, theme, light *Theme, themes *themeSet) *server {
+ if themes == nil {
+ themes = &themeSet{}
+ }
+ base = (&page{Root: base}).liveRoot()
+ hl := newHighlighter(theme, light)
+ sv := &server{log: log, repo: repo, title: title, user: user, base: base,
+ session: "web:" + user, theme: theme, light: light, themes: themes,
+ tpl: newTemplates(hl), models: map[string]*Site{}, trees: map[string][]*File{},
+ rendered: map[string]*File{}, tx: newTranscripts(defaultTranscriptRoots())}
+ sv.hl = hl
+ sv.reload(true)
+ return sv
+}
+
+// reload re-reads the log when the sidecar commit id changes.
+func (sv *server) reload(force bool) {
+ state, err := sv.log.Generation()
+ if err == nil && state == sv.state && !force {
+ return
+ }
+ if err != nil {
+ if sv.site == nil {
+ sv.site = sv.dress(buildModel(sv.title, nil, ""))
+ }
+ return
+ }
+ b, err := sv.log.Read()
+ if err != nil {
+ if sv.site == nil {
+ sv.state = state
+ sv.site = sv.dress(buildModel(sv.title, nil, ""))
+ sv.gen++
+ }
+ return
+ }
+ sv.entries = parseLog(b)
+ sv.state = state
+ sv.site = sv.dress(buildModel(sv.title, sv.entries, ""))
+ sv.gen++
+ sv.def = ""
+ sv.models = map[string]*Site{}
+ sv.trees = map[string][]*File{}
+ sv.rendered = map[string]*File{}
+}
+
+func (sv *server) dress(s *Site) *Site {
+ s.Theme, s.Light, s.Repo = sv.theme, sv.light, sv.repo
+ return s
+}
+
+// snap returns the whole-log model, its generation, and the change the log
+// points at: the most-logged change this repo actually has, since a log can
+// carry entries from several repos, falling back to the working copy.
+func (sv *server) snap() (*Site, int, string) {
+ sv.mu.Lock()
+ defer sv.mu.Unlock()
+ sv.reload(false)
+ if sv.def == "" {
+ for i, c := range sv.site.Ranked {
+ if i == 5 {
+ break // a log with many foreign changes is not worth probing
+ }
+ if id, err := resolveChange(sv.repo, c); err == nil {
+ sv.def = id
+ break
+ }
+ }
+ if sv.def == "" {
+ if id, err := resolveChange(sv.repo, "@"); err == nil {
+ sv.def = id
+ } else {
+ sv.def = sv.site.Change
+ }
+ }
+ }
+ return sv.site, sv.gen, sv.def
+}
+
+// modelFor returns the log projected onto one change, or the whole log when
+// change is "". Built once per generation, since the projection is pure.
+func (sv *server) modelFor(change string) *Site {
+ key := change
+ if key == "" {
+ key = scopeAll
+ }
+ sv.mu.Lock()
+ defer sv.mu.Unlock()
+ if s, ok := sv.models[key]; ok {
+ return s
+ }
+ s := sv.site
+ if change != "" {
+ s = sv.dress(buildModel(sv.title, sv.entries, change))
+ }
+ sv.models[key] = s
+ return s
+}
+
+func scopeKey(site *Site) string {
+ if site.Only == "" {
+ return scopeAll
+ }
+ return site.Only
+}
+
+func (sv *server) filesLocked(site *Site, commit, change string) []*File {
+ key := scopeKey(site) + "|" + commit
+ if f, ok := sv.trees[key]; ok {
+ return f
+ }
+ paths, err := fileList(sv.repo, commit)
+ if err != nil {
+ return nil
+ }
+ f := site.filesAt(paths, change)
+ sv.trees[key] = f
+ return f
+}
+
+func (sv *server) files(site *Site, commit, change string) []*File {
+ sv.mu.Lock()
+ defer sv.mu.Unlock()
+ return sv.filesLocked(site, commit, change)
+}
+
+// forgetDefault drops the chosen change so the next request picks again —
+// the repo moved under us, which is the repo's business, not ours to remember.
+func (sv *server) forgetDefault() {
+ sv.mu.Lock()
+ sv.def = ""
+ sv.mu.Unlock()
+}
+
+// fileAt renders one file: model coverage and notes, source from jj,
+// highlighted. commit is the content it is read at and what the cache is keyed
+// on — change only names it on the page — so an edit under the same change id
+// is a different key, never a stale hit.
+func (sv *server) fileAt(site *Site, gen int, commit, change, path string) *File {
+ key := fmt.Sprintf("%d|%s|%s|%s", gen, scopeKey(site), commit, path)
+ sv.mu.Lock()
+ if f, ok := sv.rendered[key]; ok {
+ sv.mu.Unlock()
+ return f
+ }
+ sv.mu.Unlock()
+
+ var f *File
+ if base, ok := site.Files[path]; ok {
+ f = base.clone()
+ } else {
+ f = &File{Path: path, Change: change, NoteAt: map[int]int{}}
+ }
+ if f.Change == "" {
+ f.Change = change
+ }
+ src, err := fileShow(sv.repo, commit, path)
+ switch {
+ case err != nil:
+ f.Stub = "not present at this change"
+ case bytes.IndexByte(src, 0) >= 0:
+ f.Stub = "binary file — not rendered"
+ case len(src) > 2<<20:
+ f.Stub = fmt.Sprintf("file too large to render (%d KB)", len(src)/1024)
+ default:
+ f.render(src, sv.hl)
+ }
+
+ sv.mu.Lock()
+ if len(sv.rendered) > renderCacheMax {
+ sv.rendered = map[string]*File{}
+ }
+ sv.rendered[key] = f
+ sv.mu.Unlock()
+ return f
+}
+
+// ── request plumbing ──────────────────────────────────────────────────────
+
+// newPage answers the two questions every page starts from: which change am I
+// looking at, and am I seeing only what was recorded there. ?rev= picks the
+// change (default: the one the log points at); ?scope=all widens the view to
+// the whole log, and a change nothing was ever recorded at widens by itself,
+// so the site never looks mysteriously empty.
+func (sv *server) newPage(r *http.Request, kind, title string) (*page, *Site, error) {
+ full, _, def := sv.snap()
+ q := r.URL.Query()
+ path := sv.base + strings.TrimPrefix(r.URL.Path, "/")
+ p := &page{Site: full, Kind: kind, Title: title, Root: sv.base, Live: true,
+ User: sv.user, ChangeID: def, Default: def, Path: path, Scope: "change"}
+ rev := strings.TrimSpace(q.Get("rev"))
+ target := rev
+ if target == "" {
+ target = def
+ }
+ row, err := changeBrief(sv.repo, target)
+ if err != nil {
+ if rev == "" {
+ sv.forgetDefault() // the log's change left the repo; pick again
+ }
+ p.Facets = full.Facets()
+ return p, full, err
+ }
+ p.ChangeID, p.Commit, p.ChangeInfo = row.ID, row.Commit, &row
+ if rev != "" && row.ID != def {
+ p.Rev = rev
+ }
+ if q.Get("scope") == "all" {
+ p.Scope = "all"
+ }
+ return p, sv.rescope(p), nil
+}
+
+// rescope picks the model for the change the page settled on. Handlers that
+// discover their change from the path (a change page) call it again.
+func (sv *server) rescope(p *page) *Site {
+ full, _, _ := sv.snap()
+ site := full
+ p.ScopeEmpty = false
+ if p.Scope == "change" {
+ if full.Votes[p.ChangeID] > 0 {
+ site = sv.modelFor(p.ChangeID)
+ } else {
+ p.ScopeEmpty = true // asked for this change, nothing was recorded here
+ }
+ }
+ p.Site, p.Facets = site, site.Facets()
+ p.Here = full.NotesAt[p.ChangeID]
+ p.Elsewhere = full.NotesTotal - p.Here
+ return site
+}
+
+func (sv *server) render(w http.ResponseWriter, p *page) {
+ var b bytes.Buffer
+ if err := sv.tpl.Execute(&b, p); err != nil {
+ http.Error(w, "render: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ b.WriteTo(w)
+}
+
+func (sv *server) frag(w http.ResponseWriter, name string, data any) {
+ var b bytes.Buffer
+ if err := sv.tpl.ExecuteTemplate(&b, name, data); err != nil {
+ http.Error(w, "render: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ b.WriteTo(w)
+}
+
+func htmxReq(r *http.Request) bool { return r.Header.Get("HX-Request") != "" }
+
+func atoiDefault(s string, def int) int {
+ if n, err := strconv.Atoi(strings.TrimSpace(s)); err == nil {
+ return n
+ }
+ return def
+}
+
+func (sv *server) handler() http.Handler {
+ mux := http.NewServeMux()
+ mux.HandleFunc("GET /{$}", sv.index)
+ mux.HandleFunc("GET /files", sv.filesPage)
+ mux.HandleFunc("GET /tree", sv.treeFrag)
+ mux.HandleFunc("GET /code/{path...}", sv.codePage)
+ mux.HandleFunc("GET /notes", sv.notesPage)
+ mux.HandleFunc("GET /note/{id}", sv.notePage)
+ mux.HandleFunc("GET /notes/list", sv.notesList)
+ mux.HandleFunc("POST /notes", sv.addNote)
+ mux.HandleFunc("GET /activity", sv.activity)
+ mux.HandleFunc("GET /session/{id}", sv.sessionPage)
+ mux.HandleFunc("GET /jj", sv.jjPage)
+ mux.HandleFunc("GET /jj/log", sv.jjLog)
+ mux.HandleFunc("GET /jj/op", sv.jjOp)
+ mux.HandleFunc("GET /change/{id}", sv.changePage)
+ mux.HandleFunc("GET /style.css", sv.styleCSS)
+ mux.HandleFunc("GET /themes.css", sv.themeAsset)
+ mux.HandleFunc("GET /themes.js", sv.themeAsset)
+ mux.HandleFunc("GET /app.js", sv.asset)
+ mux.HandleFunc("GET /htmx.min.js", sv.asset)
+ mux.HandleFunc("GET /bemtevi.svg", sv.asset)
+ return mux
+}
+
+// ── pages ─────────────────────────────────────────────────────────────────
+
+func (sv *server) index(w http.ResponseWriter, r *http.Request) {
+ p, site, err := sv.newPage(r, "index", sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ }
+ p.Notes = site.FilterNotes(NoteFilter{})
+ if len(p.Notes) > 24 {
+ p.Notes = p.Notes[:24]
+ }
+ p.Files = sv.files(site, p.Commit, p.ChangeID)
+ sv.render(w, p)
+}
+
+func (sv *server) filesPage(w http.ResponseWriter, r *http.Request) {
+ p, site, err := sv.newPage(r, "files", "files — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ sv.render(w, p)
+ return
+ }
+ p.Tree = template.HTML(renderTree(sv.files(site, p.Commit, p.ChangeID), p.codeLink()))
+ sv.render(w, p)
+}
+
+func (sv *server) treeFrag(w http.ResponseWriter, r *http.Request) {
+ p, site, err := sv.newPage(r, "files", "")
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ fmt.Fprint(w, renderTree(sv.files(site, p.Commit, p.ChangeID), p.codeLink()))
+}
+
+func (sv *server) codePage(w http.ResponseWriter, r *http.Request) {
+ path := strings.TrimPrefix(r.PathValue("path"), "/")
+ p, site, err := sv.newPage(r, "file", path+" — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ sv.render(w, p)
+ return
+ }
+ _, gen, _ := sv.snap()
+ p.Current = path
+ p.File = sv.fileAt(site, gen, p.Commit, p.ChangeID, path)
+ sv.render(w, p)
+}
+
+func (sv *server) notesPage(w http.ResponseWriter, r *http.Request) {
+ p, site, err := sv.newPage(r, "notes", "notes — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ }
+ p.Filter = filterFrom(r)
+ p.Notes = site.FilterNotes(p.Filter)
+ sv.render(w, p)
+}
+
+// notePage is one note on its own — the permalink. It is looked up in the
+// whole-log model, never the scoped one, so a link handed to someone else
+// opens whatever change they arrive on.
+//
+// The page then reads at the change the note was written at, because that is
+// where its line numbers mean anything; ?rev= still overrides, for a reader
+// asking what those lines say now.
+func (sv *server) notePage(w http.ResponseWriter, r *http.Request) {
+ full, _, _ := sv.snap()
+ n := full.NoteByID(atoiDefault(r.PathValue("id"), 0))
+ if n == nil {
+ http.Error(w, "no note with that id in this log", http.StatusNotFound)
+ return
+ }
+ p, site, err := sv.newPage(r, "note", noteTitle(n)+" — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ sv.render(w, p)
+ return
+ }
+ p.Note, p.Thread, p.Current = n, full.NoteThread(n.ID), n.File
+ if p.Rev == "" && n.Change != "" && n.Change != p.ChangeID {
+ if row, rerr := changeBrief(sv.repo, n.Change); rerr == nil {
+ p.ChangeID, p.Commit, p.ChangeInfo = row.ID, row.Commit, &row
+ if row.ID != p.Default {
+ p.Rev = n.Change
+ }
+ site = sv.rescope(p)
+ } else {
+ p.ExErr = "the change this note was written at is no longer in the repository"
+ }
+ }
+ if n.File != "" && n.Start > 0 && p.ExErr == "" {
+ var cov []uint8
+ if bf, ok := site.Files[n.File]; ok {
+ cov = bf.Cov
+ }
+ src, ferr := fileShow(sv.repo, p.Commit, n.File)
+ switch {
+ case ferr != nil:
+ p.ExErr = "not present at this change"
+ case bytes.IndexByte(src, 0) >= 0:
+ p.ExErr = "binary file — not rendered"
+ default:
+ p.Excerpt, p.ExFrom, p.ExTo = excerptFor(n.File, src, cov, sv.hl, n)
+ }
+ }
+ sv.render(w, p)
+}
+
+// noteTitle names a note the way a browser tab and a link preview should: the
+// lines it is about, or its id when it is pinned to nothing.
+func noteTitle(n *Note) string {
+ if n.File == "" {
+ return "note #" + strconv.Itoa(n.ID)
+ }
+ name := n.File
+ if i := strings.LastIndex(name, "/"); i >= 0 {
+ name = name[i+1:]
+ }
+ if n.Start > 0 {
+ name += ":" + strconv.Itoa(n.Start)
+ if n.End > n.Start {
+ name += "-" + strconv.Itoa(n.End)
+ }
+ }
+ return name
+}
+
+func (sv *server) notesList(w http.ResponseWriter, r *http.Request) {
+ p, site, _ := sv.newPage(r, "notes", "")
+ p.Filter = filterFrom(r)
+ p.Notes = site.FilterNotes(p.Filter)
+ sv.frag(w, "notelist-oob", p)
+}
+
+func filterFrom(r *http.Request) NoteFilter {
+ q := r.URL.Query()
+ return NoteFilter{
+ Text: q.Get("text"), File: q.Get("file"), Agent: q.Get("agent"),
+ Model: q.Get("model"), Session: q.Get("session"), Kind: q.Get("kind"),
+ Change: q.Get("change"), From: q.Get("from"), To: q.Get("to"),
+ }
+}
+
+// addNote appends a comment written in the browser to the log — the only
+// write this program does, and it never touches the repository.
+func (sv *server) addNote(w http.ResponseWriter, r *http.Request) {
+ // the app writes to a file on your disk, so refuse posts a page on
+ // another origin sent here
+ if o := r.Header.Get("Origin"); o != "" {
+ if u, err := url.Parse(o); err != nil || u.Host != r.Host {
+ http.Error(w, "cross-origin post refused", http.StatusForbidden)
+ return
+ }
+ }
+ if err := r.ParseForm(); err != nil {
+ http.Error(w, "bad form", http.StatusBadRequest)
+ return
+ }
+ text := strings.TrimSpace(r.FormValue("text"))
+ if text == "" {
+ http.Error(w, "a note needs text", http.StatusBadRequest)
+ return
+ }
+ // a note belongs to the change its writer was reading, which is the one
+ // the form carries — not the working copy, which may have moved on since
+ full, _, def := sv.snap()
+ replyText := strings.TrimSpace(r.FormValue("reply_to"))
+ replyTo := 0
+ if replyText != "" {
+ var rerr error
+ replyTo, rerr = strconv.Atoi(replyText)
+ if rerr != nil || replyTo < 1 || full.NoteByID(replyTo) == nil {
+ http.Error(w, "reply target is not a note in this log", http.StatusBadRequest)
+ return
+ }
+ }
+ rev := strings.TrimSpace(r.FormValue("rev"))
+ target := strings.TrimSpace(r.FormValue("change"))
+ for _, fallback := range []string{rev, def, "@"} {
+ if target != "" {
+ break
+ }
+ target = fallback
+ }
+ change, commit, err := resolveRevision(sv.repo, target)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+ if rev == "" {
+ rev = target
+ }
+ start := atoiDefault(r.FormValue("start"), 0)
+ end := atoiDefault(r.FormValue("end"), 0)
+ if end < start {
+ end = start
+ }
+ e := Entry{
+ Time: time.Now().Format(time.RFC3339), Op: "note",
+ Session: sv.session, Agent: sv.user, Dir: sv.repo,
+ Rev: rev, Change: change, Commit: commit, File: strings.TrimSpace(r.FormValue("file")),
+ Start: start, End: end, ReplyTo: replyTo,
+ Type: strings.TrimSpace(r.FormValue("kind")), Text: text,
+ }
+
+ sv.mu.Lock()
+ err = appendEntry(sv.log, &e)
+ if err == nil {
+ sv.reload(true)
+ }
+ site := sv.site
+ sv.mu.Unlock()
+ if err != nil {
+ http.Error(w, "write log: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ // answer in the same view the writer is looking at, or the note count
+ // coming back would be the whole log's while their page shows one change
+ scope := r.FormValue("scope")
+ if scope != "all" {
+ site = sv.modelFor(change)
+ }
+
+ if !htmxReq(r) {
+ back := r.FormValue("back")
+ if back == "" {
+ back = sv.base + "notes"
+ }
+ http.Redirect(w, r, back, http.StatusSeeOther)
+ return
+ }
+ p := &page{Site: site, Kind: "file", Root: sv.base, Live: true, User: sv.user, Facets: site.Facets()}
+ if e.File != "" {
+ p.File = site.Files[e.File]
+ }
+ // the note just written is the last one carrying our session and id
+ for i := len(site.Notes) - 1; i >= 0; i-- {
+ if n := site.Notes[i]; n.Session == sv.session && n.NoteID == e.NoteID {
+ p.Notes = []*Note{n}
+ break
+ }
+ }
+ sv.frag(w, "note-added", p)
+}
+
+func (sv *server) activity(w http.ResponseWriter, r *http.Request) {
+ site, _, _ := sv.snap()
+ limit := 6
+ compact := r.URL.Query().Get("compact") != ""
+ if !compact {
+ limit = 20
+ }
+ p := &page{Site: site, Root: sv.base, Live: true, Compact: compact, Window: "5 min",
+ Sessions: site.Sessions(time.Now(), liveWindow, limit)}
+ sv.frag(w, "activity", p)
+}
+
+// sessionPage shows one session's conversation, with ?note=N anchoring the
+// moment a note was written. It renders from the log alone when the harness
+// transcript cannot be found — the reading timeline is still worth having.
+func (sv *server) sessionPage(w http.ResponseWriter, r *http.Request) {
+ id := r.PathValue("id")
+ if err := safeSession(id); err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+ p, site, err := sv.newPage(r, "session", "session "+short(id)+" — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ }
+ q := r.URL.Query()
+ p.Conv = sv.conversation(site, id, atoiDefault(q.Get("note"), 0), q.Get("all") != "")
+ sv.render(w, p)
+}
+
+// ── jj ────────────────────────────────────────────────────────────────────
+
+const defaultLimit = 50
+
+func (sv *server) jjView(r *http.Request) *JJView {
+ q := r.URL.Query()
+ v := &JJView{Root: sv.base, Kind: q.Get("kind"), Revset: strings.TrimSpace(q.Get("revset")),
+ AtOp: strings.TrimSpace(q.Get("at_op")), Limit: atoiDefault(q.Get("limit"), defaultLimit)}
+ if v.Limit < 1 || v.Limit > 1000 {
+ v.Limit = defaultLimit
+ }
+ if v.Kind != "op" {
+ v.Kind = "log"
+ }
+ var err error
+ if v.Kind == "op" {
+ v.Rows, err = OpRows(sv.repo, v.Limit)
+ } else {
+ v.Rows, err = LogRows(sv.repo, v.Revset, v.AtOp, v.Limit)
+ }
+ if err != nil {
+ v.Err = err.Error()
+ }
+ return v
+}
+
+func (sv *server) jjPage(w http.ResponseWriter, r *http.Request) {
+ p, _, err := sv.newPage(r, "jj", "jj — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ }
+ p.JJ = sv.jjView(r)
+ sv.render(w, p)
+}
+
+func (sv *server) jjLog(w http.ResponseWriter, r *http.Request) {
+ v := sv.jjView(r)
+ if !htmxReq(r) {
+ sv.jjPage(w, r)
+ return
+ }
+ sv.frag(w, "jjrows", v)
+}
+
+func (sv *server) jjOp(w http.ResponseWriter, r *http.Request) {
+ q := r.URL.Query()
+ v := &JJView{Root: sv.base, Kind: "op", Limit: atoiDefault(q.Get("limit"), defaultLimit)}
+ if v.Limit < 1 || v.Limit > 1000 {
+ v.Limit = defaultLimit
+ }
+ var err error
+ if v.Rows, err = OpRows(sv.repo, v.Limit); err != nil {
+ v.Err = err.Error()
+ }
+ if !htmxReq(r) {
+ p, _, _ := sv.newPage(r, "jj", "jj op log — "+sv.title)
+ p.JJ = v
+ sv.render(w, p)
+ return
+ }
+ sv.frag(w, "jjrows", v)
+}
+
+func (sv *server) changePage(w http.ResponseWriter, r *http.Request) {
+ id := r.PathValue("id")
+ p, site, _ := sv.newPage(r, "change", id+" — "+sv.title)
+ c, err := LoadChange(sv.repo, id)
+ if err != nil {
+ p.Err = err.Error()
+ sv.render(w, p)
+ return
+ }
+ p.Change = c
+ p.Rev, p.ChangeID, p.Commit = c.Row.ID, c.Row.ID, c.Row.Commit
+ p.ChangeInfo = &c.Row
+ p.Title = c.Row.Short + " — " + sv.title
+ // the page named a change the query string did not, so the view follows it
+ site = sv.rescope(p)
+ p.Notes = site.FilterNotes(NoteFilter{Change: c.Row.ID})
+ sv.render(w, p)
+}
+
+// ── assets ────────────────────────────────────────────────────────────────
+
+func (sv *server) styleCSS(w http.ResponseWriter, r *http.Request) {
+ site, _, _ := sv.snap()
+ var b bytes.Buffer
+ if err := renderCSS(&b, site); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ w.Header().Set("Content-Type", "text/css; charset=utf-8")
+ b.WriteTo(w)
+}
+
+// themeAsset serves the two files the theme picker needs. Both are written
+// once at startup — the machine's themes do not change while we watch a log.
+func (sv *server) themeAsset(w http.ResponseWriter, r *http.Request) {
+ body, ctype := sv.themes.JS, "text/javascript; charset=utf-8"
+ if strings.HasSuffix(r.URL.Path, ".css") {
+ body, ctype = sv.themes.CSS, "text/css; charset=utf-8"
+ }
+ w.Header().Set("Content-Type", ctype)
+ w.Header().Set("Cache-Control", "max-age=300")
+ w.Write(body)
+}
+
+func (sv *server) asset(w http.ResponseWriter, r *http.Request) {
+ name := strings.TrimPrefix(r.URL.Path, "/")
+ b, err := tfs.ReadFile("assets/" + name)
+ if err != nil {
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", assetType(name))
+ w.Header().Set("Cache-Control", "max-age=300")
+ w.Write(b)
+}
+
+// assetType covers what embedded assets/ actually holds: scripts and the mark.
+func assetType(name string) string {
+ if strings.HasSuffix(name, ".svg") {
+ return "image/svg+xml"
+ }
+ return "text/javascript; charset=utf-8"
+}
+
+func serve(addr string, log logStore, repo, title, user string, roots []string, theme, light *Theme, themes *themeSet) {
+ sv := newServer(log, repo, title, user, theme, light, themes)
+ sv.tx = newTranscripts(roots)
+ site, _, def := sv.snap()
+ fmt.Printf("notevi web: http://%s — %d notes, %d agents, repo %s at %s\n",
+ addr, len(site.Notes), len(site.Agents), repo, short(def))
+ fmt.Printf("notevi web: themes — %s dark, %s light, %d more to pick from (%d zed, %d helix)\n",
+ theme.Name, light.Name, len(sv.themes.List), sv.themes.count("zed"), sv.themes.count("helix"))
+ fmt.Printf("notevi web: comments are appended to %s; the project working copy is never written to\n", log)
+ fmt.Printf("notevi web: session transcripts read from %s\n", strings.Join(sv.tx.roots, ", "))
+ if err := http.ListenAndServe(addr, sv.handler()); err != nil {
+ fatal("%v", err)
+ }
+}
generated by cgit v1.3 (git 2.53.0) at 2026-10-03 23:49:13 +0000