fix(bx): invalidate monitor snapshot on box config changes (#146)

* fix(bx): invalidate monitor snapshot on box config changes

The Bx status monitor polls every 30 seconds and caches each box's full
status (level, latency, last_checked, ConsoleEnabled, etc.) in an
in-memory snapshot. /bx renders from that snapshot.

Side effect: toggling a per-box setting (Remote console, Enabled, …)
in /settings/boxes did not show on /bx until the next 30s tick. User
report described this as "I had it enabled but it was disabled when we
relaunched" (no shell icon visible) plus "I went back to the box and
confirmed the console feature was checked, it was, but I hit save
again anyway and then back to the Bx dashboard and after a couple
more refreshes, it showed up."

Wiring:

- Add EventTypeBoxConfigChanged ("box.config_changed") + Hub.PublishBoxConfigChanged helper.
- HAProxyBoxUpdatePost and HAProxyBoxTogglePost publish the event
  immediately after UpdateBox / SetBoxEnabled returns.
- Bx Gear.Start subscribes to "box.config_changed" via deps.EventHub
  and calls monitor.PokeBox(serverID) for the affected box.
- New statusMonitor.PokeBox(ctx, boxID) fetches the row, runs a single
  probe, and writes the result via m.set — which also broadcasts to
  SSE subscribers, so any open /bx tab updates in place without a refresh.
- PokeBox handles the "box was deleted" case by dropping the stale
  snapshot entry instead of leaving last-known-good values for a
  now-missing box.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* address Copilot review findings on PR #146

- Add statusMonitor.setAndBroadcast that always broadcasts to SSE
  subscribers; PokeBox now uses it so a config edit that flips only a
  non-level field (ConsoleEnabled, Enabled, Name, …) still pushes to
  open /bx tabs. The chatter-suppression in set() is desirable for
  the steady-state poll loop but defeats the purpose of an
  out-of-band config-change refresh.
- PokeBox now distinguishes transient DB errors from "not found":
  on err != nil we log and keep the last-known-good snapshot; only
  box == nil drops the cached entry. Avoids poisoning the UI when
  SQLite hiccups.
- Gear.Start stores the unsubscribe func returned by Subscribe and
  Gear.Stop now calls it before shutting the monitor down. Closes
  the events-adapter forwarder goroutine cleanly and stops new
  PokeBox calls from reaching a winding-down monitor.
- Subscribe call now references events.EventTypeBoxConfigChanged
  (cast to string for the gear.EventPublisher API) instead of a raw
  "box.config_changed" literal — keeps publisher and subscriber on
  the same constant.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sarg3nt

gearbox/internal/framework/events/hub.go

@@ -36,6 +36,13 @@ const (
 	// EventTypeMetadataRefreshed indicates metadata was refreshed.
 	EventTypeMetadataRefreshed EventType = "metadata.refreshed"
 
+	// EventTypeBoxConfigChanged indicates a box's persisted settings have
+	// changed (enabled flag, console toggle, agent URL, etc.). Consumers
+	// that cache box state (e.g. the Bx status monitor) should invalidate
+	// their cache for ServerID and re-probe so user-visible toggles
+	// propagate without waiting on the next periodic poll.
+	EventTypeBoxConfigChanged EventType = "box.config_changed"
+
 	// EventTypeStatsUpdated indicates HAProxy stats have been updated.
 	EventTypeStatsUpdated EventType = "stats.updated"
 
@@ -343,6 +350,17 @@ func (h *Hub) PublishMetadataRefreshed(serverID string) {
 	})
 }
 
+// PublishBoxConfigChanged publishes a box-config-changed event. Caches
+// keyed on the box's settings (Bx status monitor, capabilities cache,
+// etc.) should treat this as a signal to invalidate and re-probe.
+func (h *Hub) PublishBoxConfigChanged(serverID string) {
+	h.Publish(Event{
+		Type:      EventTypeBoxConfigChanged,
+		ServerID:  serverID,
+		Timestamp: time.Now(),
+	})
+}
+
 // SubscriberCount returns the number of active subscribers.
 func (h *Hub) SubscriberCount() int {
 	h.mu.RLock()

gearbox/internal/framework/handler/haproxy_config.go

@@ -258,6 +258,15 @@ func (h *Handler) HAProxyBoxUpdatePost(w http.ResponseWriter, r *http.Request) {
 	// TTL expires.
 	h.invalidateBoxCapabilities(server.BoxID)
 
+	// Notify caches keyed on per-box settings (Bx status monitor's
+	// ConsoleEnabled mirror, etc.) so toggles propagate immediately
+	// instead of waiting on the next 30s poll. Without this, a user
+	// flipping console_enabled on/off in this form would not see the
+	// shell icon appear/disappear on /bx until the next periodic poll.
+	if h.eventHub != nil {
+		h.eventHub.PublishBoxConfigChanged(server.BoxID)
+	}
+
 	// Log audit
 	h.logAudit(r, user.ID, "haproxy_box_update", fmt.Sprintf("Updated HAProxy box: %s (%s)", server.Name, server.BoxID))
 
@@ -365,6 +374,13 @@ func (h *Handler) HAProxyBoxTogglePost(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Notify caches keyed on per-box settings — same reasoning as the
+	// update-form path. Toggling enabled on/off should reflect on /bx
+	// immediately, not after the next 30s monitor tick.
+	if h.eventHub != nil {
+		h.eventHub.PublishBoxConfigChanged(server.BoxID)
+	}
+
 	// Log audit
 	action := "disabled"
 	if newEnabled {

gearbox/internal/gears/bx/gear.go

@@ -16,6 +16,7 @@ import (
 	"github.com/a-h/templ"
 	"github.com/go-chi/chi/v5"
 
+	"github.com/sarg3nt/gearbox/internal/framework/events"
 	"github.com/sarg3nt/gearbox/internal/framework/gear"
 )
 
@@ -26,8 +27,9 @@ func init() {
 // Gear implements the Bx fleet-view gear.
 type Gear struct {
 	gear.BaseGear
-	handlers *Handlers
-	monitor  *statusMonitor
+	handlers           *Handlers
+	monitor            *statusMonitor
+	configChangeUnsub  func() // returned by EventHub.Subscribe; called in Stop
 }
 
 // Info returns gear metadata.
@@ -54,16 +56,38 @@ func (g *Gear) Initialize(ctx context.Context, deps gear.Dependencies) error {
 	return nil
 }
 
-// Start launches the per-box status poller.
+// Start launches the per-box status poller and subscribes to
+// box-config-changed events so toggle/edit operations refresh the
+// monitor's snapshot for the affected box immediately, instead of
+// waiting on the next 30s poll. Without this subscription, /bx would
+// keep rendering stale ConsoleEnabled / Enabled values for up to 30s
+// after the user clicked save.
 func (g *Gear) Start(ctx context.Context) error {
 	if g.monitor != nil {
 		g.monitor.Start(ctx)
 	}
+	if g.monitor != nil {
+		if hub := g.GetEventHub(); hub != nil {
+			g.configChangeUnsub = hub.Subscribe(string(events.EventTypeBoxConfigChanged), func(e gear.Event) {
+				if e.ServerID == "" {
+					return
+				}
+				g.monitor.PokeBox(ctx, e.ServerID)
+			})
+		}
+	}
 	return nil
 }
 
-// Stop signals the background poller to wind down.
+// Stop signals the background poller to wind down and releases the
+// event subscription so the forwarder goroutine inside the events
+// adapter exits cleanly and no further PokeBox calls reach a
+// shutting-down monitor.
 func (g *Gear) Stop(ctx context.Context) error {
+	if g.configChangeUnsub != nil {
+		g.configChangeUnsub()
+		g.configChangeUnsub = nil
+	}
 	if g.monitor != nil {
 		g.monitor.Stop()
 	}

gearbox/internal/gears/bx/status.go

@@ -116,6 +116,48 @@ func (m *statusMonitor) run(ctx context.Context) {
 	}
 }
 
+// PokeBox triggers an immediate out-of-band probe of a single box,
+// updates the snapshot, and broadcasts to SSE subscribers. Used by the
+// box-config-changed event subscriber so settings edits (enable toggle,
+// console-enabled toggle, agent URL change, …) reflect on /bx without
+// waiting on the next 30s tick. Safe to call concurrently with the
+// regular poll loop — set/setAndBroadcast are mutex-guarded.
+func (m *statusMonitor) PokeBox(ctx context.Context, boxID string) {
+	if m.db == nil {
+		return
+	}
+	box, err := m.db.GetBoxByBoxID(boxID)
+	if err != nil {
+		// Transient DB error — don't poison the snapshot by dropping
+		// last-known-good values. Log and bail; the next 30s poll
+		// will reconcile.
+		if m.deps.Logger != nil {
+			m.deps.Logger.Warn("bx PokeBox: db lookup failed; preserving last-known status", "box_id", boxID, "error", err)
+		}
+		return
+	}
+	if box == nil {
+		// Box was deleted — drop the stale snapshot so /bx doesn't
+		// keep rendering last-known-good values for a now-missing box.
+		m.mu.Lock()
+		delete(m.statuses, boxID)
+		m.mu.Unlock()
+		return
+	}
+	apiKey := ""
+	if enc := m.encryptor(); enc != nil && len(box.APIKeyEncrypted) > 0 {
+		if dec, err := enc.DecryptString(box.APIKeyEncrypted); err == nil {
+			apiKey = dec
+		}
+	}
+	status := m.probe(ctx, box, apiKey)
+	// Force-broadcast: a config edit may have flipped only a non-level
+	// field (e.g. ConsoleEnabled). The default set() suppresses chatter
+	// on equal-level updates, which is exactly the case we need to NOT
+	// suppress here.
+	m.setAndBroadcast(status)
+}
+
 // pollAll fans out a reachability check per configured box. The check is
 // the unauthenticated `/health` endpoint of each agent — same probe as the
 // HAProxy backend health check, with the same 5s budget.
@@ -241,6 +283,19 @@ func (m *statusMonitor) set(s BoxStatus) {
 	}
 }
 
+// setAndBroadcast stores a status and ALWAYS broadcasts to subscribers,
+// even when level/reachable haven't changed. Used by PokeBox so a flip
+// of a non-level field (ConsoleEnabled, Enabled, Name, …) reaches open
+// /bx tabs immediately — the chatter-suppression in set() is desirable
+// for the steady-state poll loop but defeats the purpose of an
+// out-of-band config-change refresh.
+func (m *statusMonitor) setAndBroadcast(s BoxStatus) {
+	m.mu.Lock()
+	m.statuses[s.BoxID] = s
+	m.mu.Unlock()
+	m.broadcast(s)
+}
+
 // Subscribe returns a channel of status events and an unsubscribe func.
 // Events are best-effort: a slow consumer that doesn't drain its channel
 // will simply miss events (we never block the publisher).