implement support for watching /_bull/browse (live reload)

Author: stapelberg

internal/bull/fswatch.go

@@ -111,7 +111,7 @@ func (b *bullServer) watchContentLoop(ctx context.Context, w *fsnotify.Watcher)
 }
 
 // handleContentEvent processes a single fsnotify event.
-// It returns true if the index was updated (caller should notify).
+// It returns true if a content file was affected (caller should notify).
 func (b *bullServer) handleContentEvent(w *fsnotify.Watcher, event fsnotify.Event) bool {
 	name := event.Name
 
@@ -162,10 +162,9 @@ func (b *bullServer) handleContentEvent(w *fsnotify.Watcher, event fsnotify.Even
 	case event.Has(fsnotify.Remove) || event.Has(fsnotify.Rename):
 		// Reading idx outside the lock is a benign TOCTOU: worst case we call
 		// removeFromIndex redundantly (it rechecks under the lock).
-		if old := b.idx.Load().links[pageName]; old == nil {
-			return false // already absent from the index
+		if old := b.idx.Load().links[pageName]; old != nil {
+			b.removeFromIndex(pageName)
 		}
-		b.removeFromIndex(pageName)
 		return true
 
 	case event.Has(fsnotify.Create) || event.Has(fsnotify.Write):
@@ -181,10 +180,9 @@ func (b *bullServer) handleContentEvent(w *fsnotify.Watcher, event fsnotify.Even
 		}
 		// Reading idx outside the lock is a benign TOCTOU: worst case we call
 		// updateIndex redundantly (it rechecks and stores an identical snapshot).
-		if slices.Equal(b.idx.Load().links[pageName], targets) {
-			return false // index already up to date (e.g. save already applied)
+		if !slices.Equal(b.idx.Load().links[pageName], targets) {
+			b.updateIndex(pageName, targets)
 		}
-		b.updateIndex(pageName, targets)
 		return true
 	}
 	return false

internal/bull/fswatch_test.go

@@ -134,8 +134,15 @@ func TestHandleContentEventDedup(t *testing.T) {
 		Name: filepath.Join(b.contentDir, "alpha.md"),
 		Op:   fsnotify.Write,
 	})
-	if updated {
-		t.Fatal("unchanged targets should not trigger index update")
+	// handleContentEvent returns true for any markdown file change
+	// (so watchers like the browse page can reload), but the link
+	// index itself should not be updated when targets are unchanged.
+	if !updated {
+		t.Fatal("markdown write should report content changed")
+	}
+	cur := b.idx.Load()
+	if diff := cmp.Diff(idx.links["alpha"], cur.links["alpha"]); diff != "" {
+		t.Fatalf("index should not change for unchanged targets (-want +got):\n%s", diff)
 	}
 }
 

internal/bull/watch.go

@@ -65,6 +65,22 @@ func maybeNotify(ctx context.Context, notify chan<- struct{}, fileName string) {
 	}
 }
 
+func (b *bullServer) handleWatchBrowse(w http.ResponseWriter, flusher http.Flusher, ctx context.Context) error {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	initEventStream(w)
+	for {
+		contentChanged := b.contentChangedCh()
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-contentChanged:
+			w.Write([]byte("data: {\"changed\":true}\n\n"))
+			flusher.Flush()
+			return nil // client reloads and reconnects
+		}
+	}
+}
+
 func (b *bullServer) handleWatch(w http.ResponseWriter, r *http.Request) error {
 	flusher, ok := w.(http.Flusher)
 	if !ok {
@@ -73,6 +89,11 @@ func (b *bullServer) handleWatch(w http.ResponseWriter, r *http.Request) error {
 
 	ctx := r.Context()
 
+	pageName := pageFromURL(r)
+	if pageName == bullPrefix+"browse" {
+		return b.handleWatchBrowse(w, flusher, ctx)
+	}
+
 	possibilities := filesFromURL(r)
 	lastb, err := b.readFirst(possibilities)
 	if err != nil {