Fix: Configuration auto-refresh in-memory sync and SSE event integration

This PR fixes critical bugs in the configuration auto-refresh feature that prevented real-time updates in the Web UI Configuration page.

## Changes

### Backend (internal/runtime/)
- **lifecycle.go**: Fixed in-memory config sync bug where configSvc path didn't update r.cfg.Servers
  - Moved mutex-protected update outside if/else to apply to both configSvc and legacy paths
  - Added comprehensive debug logging (before/after disk save, old vs new server counts)
  - Added emitConfigSaved() call to broadcast config.saved events
- **event_bus.go**: Added emitConfigSaved() method for SSE integration
- **events.go**: Added EventTypeConfigSaved constant
- **event_bus_test.go**: Unit tests for event bus subscription and emission

### Frontend (frontend/src/)
- **stores/system.ts**: Added SSE listener for config.saved events
  - Dispatches CustomEvent 'mcpproxy:config-saved' to notify Settings view
- **views/Settings.vue**: Added event listener and cleanup
  - Calls loadConfig() when config.saved event received
  - Proper onMounted/onUnmounted lifecycle hooks

### Testing (internal/)
- **testutil/binary.go**: Added GetConfigPath() helper for E2E tests
- **server/e2e_config_auto_refresh_test.go**: Integration test structure for config auto-refresh

## Bug Fix Details

**Problem**: When adding servers via Web UI, the configuration file was updated but the /api/v1/config endpoint returned stale data, causing Monaco editor to not show new servers.

**Root Cause**: In SaveConfiguration(), the in-memory config update only happened in the legacy else branch, not in the configSvc path.

**Solution**: Moved the in-memory update outside the conditional to ensure both paths update r.cfg.Servers.

## Verification

Tested with Playwright E2E:
- ✅ Server added via Web UI appears in config file
- ✅ config.saved SSE event received in browser console
- ✅ Monaco editor automatically reloads and displays new server
- ✅ API endpoint returns fresh data immediately

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Dumbris

frontend/src/stores/system.ts

@@ -140,6 +140,19 @@ export const useSystemStore = defineStore('system', () => {
       }
     })
 
+    // Listen for config.saved events to notify Configuration page
+    es.addEventListener('config.saved', (event) => {
+      try {
+        const data = JSON.parse(event.data)
+        console.log('SSE config.saved event received:', data)
+
+        // Dispatch event for Configuration page to refresh
+        window.dispatchEvent(new CustomEvent('mcpproxy:config-saved', { detail: data }))
+      } catch (error) {
+        console.error('Failed to parse SSE config.saved event:', error)
+      }
+    })
+
     es.onerror = (event) => {
       connected.value = false
       console.error('EventSource error occurred:', event)

frontend/src/views/Settings.vue

@@ -112,7 +112,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue'
+import { ref, computed, onMounted, onUnmounted } from 'vue'
 import { VueMonacoEditor } from '@guolao/vue-monaco-editor'
 import { useServersStore } from '@/stores/servers'
 import CollapsibleHintsPanel from '@/components/CollapsibleHintsPanel.vue'
@@ -330,8 +330,25 @@ const settingsHints = computed<Hint[]>(() => {
   ]
 })
 
+// Configuration reload event listener
+function handleConfigSaved(event: Event) {
+  const customEvent = event as CustomEvent
+  console.log('Configuration saved event received, reloading config:', customEvent.detail)
+
+  // Reload configuration to show updated servers
+  loadConfig()
+}
+
 // Initialize component
 onMounted(() => {
   loadConfig() // Load configuration when component mounts
+
+  // Listen for config.saved events from SSE
+  window.addEventListener('mcpproxy:config-saved', handleConfigSaved)
+})
+
+onUnmounted(() => {
+  // Clean up event listener
+  window.removeEventListener('mcpproxy:config-saved', handleConfigSaved)
 })
 </script>

internal/runtime/event_bus.go

@@ -46,3 +46,8 @@ func (r *Runtime) emitConfigReloaded(path string) {
 	payload := map[string]any{"path": path}
 	r.publishEvent(newEvent(EventTypeConfigReloaded, payload))
 }
+
+func (r *Runtime) emitConfigSaved(path string) {
+	payload := map[string]any{"path": path}
+	r.publishEvent(newEvent(EventTypeConfigSaved, payload))
+}

internal/runtime/event_bus_test.go

@@ -0,0 +1,283 @@
+package runtime
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+func TestEventBus_ConfigSavedEvent(t *testing.T) {
+	// Create logger
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+	defer logger.Sync()
+
+	// Create minimal runtime for testing event bus
+	rt := &Runtime{
+		logger:    logger,
+		eventSubs: make(map[chan Event]struct{}),
+	}
+
+	// Subscribe to events
+	eventChan := rt.SubscribeEvents()
+	defer rt.UnsubscribeEvents(eventChan)
+
+	// Create a done channel to signal when we receive the event
+	done := make(chan Event, 1)
+
+	// Listen for config.saved event in background
+	go func() {
+		select {
+		case evt := <-eventChan:
+			if evt.Type == EventTypeConfigSaved {
+				done <- evt
+			}
+		case <-time.After(2 * time.Second):
+			t.Log("Timeout waiting for config.saved event")
+		}
+	}()
+
+	// Trigger emitConfigSaved
+	testPath := "/test/config.json"
+	rt.emitConfigSaved(testPath)
+
+	// Wait for event
+	select {
+	case evt := <-done:
+		assert.Equal(t, EventTypeConfigSaved, evt.Type, "Event type should be config.saved")
+		assert.NotNil(t, evt.Payload, "Event payload should not be nil")
+		assert.Equal(t, testPath, evt.Payload["path"], "Event payload should contain config path")
+		assert.NotZero(t, evt.Timestamp, "Event should have a timestamp")
+	case <-time.After(2 * time.Second):
+		t.Fatal("Did not receive config.saved event within timeout")
+	}
+}
+
+func TestEventBus_ConfigReloadedEvent(t *testing.T) {
+	// Create logger
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+	defer logger.Sync()
+
+	rt := &Runtime{
+		logger:    logger,
+		eventSubs: make(map[chan Event]struct{}),
+	}
+
+	// Subscribe to events
+	eventChan := rt.SubscribeEvents()
+	defer rt.UnsubscribeEvents(eventChan)
+
+	done := make(chan Event, 1)
+
+	// Listen for config.reloaded event
+	go func() {
+		select {
+		case evt := <-eventChan:
+			if evt.Type == EventTypeConfigReloaded {
+				done <- evt
+			}
+		case <-time.After(2 * time.Second):
+			t.Log("Timeout waiting for config.reloaded event")
+		}
+	}()
+
+	// Trigger emitConfigReloaded
+	testPath := "/test/config.json"
+	rt.emitConfigReloaded(testPath)
+
+	// Wait for event
+	select {
+	case evt := <-done:
+		assert.Equal(t, EventTypeConfigReloaded, evt.Type, "Event type should be config.reloaded")
+		assert.NotNil(t, evt.Payload, "Event payload should not be nil")
+		assert.Equal(t, testPath, evt.Payload["path"], "Event payload should contain config path")
+		assert.NotZero(t, evt.Timestamp, "Event should have a timestamp")
+	case <-time.After(2 * time.Second):
+		t.Fatal("Did not receive config.reloaded event within timeout")
+	}
+}
+
+func TestEventBus_ServersChangedEvent(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+	defer logger.Sync()
+
+	rt := &Runtime{
+		logger:    logger,
+		eventSubs: make(map[chan Event]struct{}),
+	}
+
+	// Subscribe to events
+	eventChan := rt.SubscribeEvents()
+	defer rt.UnsubscribeEvents(eventChan)
+
+	done := make(chan Event, 1)
+
+	// Listen for servers.changed event
+	go func() {
+		select {
+		case evt := <-eventChan:
+			if evt.Type == EventTypeServersChanged {
+				done <- evt
+			}
+		case <-time.After(2 * time.Second):
+			t.Log("Timeout waiting for servers.changed event")
+		}
+	}()
+
+	// Trigger emitServersChanged with custom payload
+	extra := map[string]any{
+		"server":  "test-server",
+		"enabled": true,
+	}
+	rt.emitServersChanged("test_reason", extra)
+
+	// Wait for event
+	select {
+	case evt := <-done:
+		assert.Equal(t, EventTypeServersChanged, evt.Type, "Event type should be servers.changed")
+		assert.NotNil(t, evt.Payload, "Event payload should not be nil")
+		assert.Equal(t, "test_reason", evt.Payload["reason"], "Event should contain reason")
+		assert.Equal(t, "test-server", evt.Payload["server"], "Event should contain server name")
+		assert.Equal(t, true, evt.Payload["enabled"], "Event should contain enabled flag")
+		assert.NotZero(t, evt.Timestamp, "Event should have a timestamp")
+	case <-time.After(2 * time.Second):
+		t.Fatal("Did not receive servers.changed event within timeout")
+	}
+}
+
+func TestEventBus_MultipleSubscribers(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+	defer logger.Sync()
+
+	rt := &Runtime{
+		logger:    logger,
+		eventSubs: make(map[chan Event]struct{}),
+	}
+
+	// Create multiple subscribers
+	sub1 := rt.SubscribeEvents()
+	sub2 := rt.SubscribeEvents()
+	sub3 := rt.SubscribeEvents()
+
+	defer rt.UnsubscribeEvents(sub1)
+	defer rt.UnsubscribeEvents(sub2)
+	defer rt.UnsubscribeEvents(sub3)
+
+	// Create done channels for each subscriber
+	done1 := make(chan Event, 1)
+	done2 := make(chan Event, 1)
+	done3 := make(chan Event, 1)
+
+	// Listen on all subscribers
+	go func() {
+		select {
+		case evt := <-sub1:
+			done1 <- evt
+		case <-time.After(2 * time.Second):
+			t.Log("Subscriber 1 timeout")
+		}
+	}()
+
+	go func() {
+		select {
+		case evt := <-sub2:
+			done2 <- evt
+		case <-time.After(2 * time.Second):
+			t.Log("Subscriber 2 timeout")
+		}
+	}()
+
+	go func() {
+		select {
+		case evt := <-sub3:
+			done3 <- evt
+		case <-time.After(2 * time.Second):
+			t.Log("Subscriber 3 timeout")
+		}
+	}()
+
+	// Emit single event
+	rt.emitConfigSaved("/test/path")
+
+	// All subscribers should receive the event
+	timeout := time.After(2 * time.Second)
+	receivedCount := 0
+
+	for i := 0; i < 3; i++ {
+		select {
+		case evt := <-done1:
+			assert.Equal(t, EventTypeConfigSaved, evt.Type)
+			receivedCount++
+		case evt := <-done2:
+			assert.Equal(t, EventTypeConfigSaved, evt.Type)
+			receivedCount++
+		case evt := <-done3:
+			assert.Equal(t, EventTypeConfigSaved, evt.Type)
+			receivedCount++
+		case <-timeout:
+			t.Fatalf("Only %d of 3 subscribers received the event", receivedCount)
+		}
+	}
+
+	assert.Equal(t, 3, receivedCount, "All 3 subscribers should have received the event")
+}
+
+func TestEventBus_ConcurrentPublish(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)
+	defer logger.Sync()
+
+	rt := &Runtime{
+		logger:    logger,
+		eventSubs: make(map[chan Event]struct{}),
+	}
+
+	// Create subscriber
+	eventChan := rt.SubscribeEvents()
+	defer rt.UnsubscribeEvents(eventChan)
+
+	// Count received events
+	receivedCount := 0
+	done := make(chan struct{})
+
+	go func() {
+		for evt := range eventChan {
+			if evt.Type == EventTypeConfigSaved {
+				receivedCount++
+				if receivedCount == 10 {
+					close(done)
+					return
+				}
+			}
+		}
+	}()
+
+	// Emit 10 events concurrently
+	var wg sync.WaitGroup
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			time.Sleep(time.Millisecond * time.Duration(idx*10))
+			rt.emitConfigSaved("/test/path")
+		}(i)
+	}
+
+	wg.Wait()
+
+	// Wait for all events to be received
+	select {
+	case <-done:
+		assert.Equal(t, 10, receivedCount, "Should receive all 10 events")
+	case <-time.After(3 * time.Second):
+		t.Fatalf("Only received %d of 10 events", receivedCount)
+	}
+}
+

internal/runtime/events.go

@@ -10,6 +10,8 @@ const (
 	EventTypeServersChanged EventType = "servers.changed"
 	// EventTypeConfigReloaded is emitted after configuration reload completes.
 	EventTypeConfigReloaded EventType = "config.reloaded"
+	// EventTypeConfigSaved is emitted after configuration is successfully saved to disk.
+	EventTypeConfigSaved EventType = "config.saved"
 )
 
 // Event is a typed notification published by the runtime event bus.