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>

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

@@ -54,11 +54,26 @@ 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 {
+			hub.Subscribe("box.config_changed", func(e gear.Event) {
+				if e.ServerID == "" {
+					return
+				}
+				g.monitor.PokeBox(ctx, e.ServerID)
+			})
+		}
+	}
 	return nil
 }
 

gearbox/internal/gears/bx/status.go

@@ -116,6 +116,36 @@ 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 — m.set is 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 || box == nil {
+		// Box was deleted, or the DB call failed — drop any stale
+		// snapshot for that ID so /bx renders default-state rather
+		// than the 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)
+	m.set(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.