Implement dynamic Bose proxy with detailed origin logging and Soundcork fallback

This commit fixes a JS error in showSummary and migrate functions where they were still trying to access the UI element by its old ID 'proxy-domain' instead of the new 'soundcork-url'.

.github/workflows/docs.yml

@@ -20,16 +20,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: Setup Pages
-        uses: actions/configure-pages@v4
+        uses: actions/configure-pages@v5
       - name: Build with Jekyll
         uses: actions/jekyll-build-pages@v1
         with:
           source: 'docs/'
           destination: '_site'
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v4
         with:
           path: '_site'
       - name: Deploy to GitHub Pages

.github/workflows/release.yml

@@ -133,10 +133,13 @@ jobs:
             local CMD_PATH=$2
             local OUTPUT_NAME
 
+            # Ensure build directory exists
+            mkdir -p build
+
             if [[ "${{ matrix.goos }}" == "windows" ]]; then
-              OUTPUT_NAME="${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}.exe"
+              OUTPUT_NAME="build/${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}.exe"
             else
-              OUTPUT_NAME="${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}"
+              OUTPUT_NAME="build/${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}"
             fi
 
             echo "Building $BINARY_NAME: $OUTPUT_NAME"
@@ -193,8 +196,8 @@ jobs:
         with:
           name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.goarm }}
           path: |
-            soundtouch-cli-v*
-            soundtouch-service-v*
+            build/soundtouch-cli-v*
+            build/soundtouch-service-v*
           retention-days: 1
 
   checksums:

.gitignore

@@ -19,6 +19,7 @@ dist/
 /example-unified
 /mdns-scanner
 /websocket-demo
+/main
 
 # Environment configuration
 .env
@@ -28,6 +29,7 @@ docker-compose.override.yml
 
 # Test coverage reports
 coverage.out
+coverage*.out
 coverage.html
 *.prof
 

README.md

@@ -23,6 +23,7 @@ A comprehensive solution for controlling and preserving Bose SoundTouch devices,
 - 🔧 **Service Migration**: Migrate devices to use local services instead of Bose cloud
 - 📊 **Traffic Analysis**: Proxy and log device communications
 - 📝 **HTTP Recording**: Persist interactions as re-playable `.http` files
+- 🧹 **Session Management**: Manage and cleanup recorded interaction sessions
 - 🔒 **Production Ready**: Extensive testing with real SoundTouch hardware
 - 🌐 **Cross-Platform**: Windows, macOS, Linux support
 
@@ -61,7 +62,7 @@ soundtouch-cli --host 192.168.1.100 volume set --level 50
 soundtouch-cli --host 192.168.1.100 preset list
 ```
 
-For full CLI documentation, see the [CLI Reference](https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.md).
+For full CLI documentation, see the [CLI Reference](https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.html).
 
 ### SoundTouch Service (Cloud Shutdown Protection)
 
@@ -74,6 +75,7 @@ The `soundtouch-service` is a local server that emulates Bose's cloud services.
 - **🌐 Web Management UI**: Easy browser-based setup and management
 - **💾 Persistent Data**: Store presets, recents, and sources locally
 - **📝 HTTP Recording**: Persist all interactions as re-playable `.http` files
+- **🧹 Session Management**: Manage and cleanup recorded interaction sessions
 
 #### Quick Start:
 ```bash
@@ -82,11 +84,11 @@ soundtouch-service
 ```
 Open `http://localhost:8000` in your browser to manage your devices. Documentation is also available directly through the web interface.
 
-For a comprehensive guide on transitioning your system, see the [Bose Cloud Shutdown: Survival Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SURVIVAL-GUIDE.md).
+For a comprehensive guide on transitioning your system, see the [Bose Cloud Shutdown: Survival Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SURVIVAL-GUIDE.html).
 
-Detailed service configuration and Docker instructions can be found in [SoundTouch Service Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SOUNDTOUCH-SERVICE.md).
+Detailed service configuration and Docker instructions can be found in [SoundTouch Service Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SOUNDTOUCH-SERVICE.html).
 
-For professional migration tips and safety measures, see the [Migration & Safety Guide](https://gesellix.github.io/Bose-SoundTouch/guides/MIGRATION-SAFETY.md).
+For professional migration tips and safety measures, see the [Migration & Safety Guide](https://gesellix.github.io/Bose-SoundTouch/guides/MIGRATION-SAFETY.html).
 
 ### Library Usage
 
@@ -379,19 +381,19 @@ This library supports all Bose SoundTouch-compatible devices, including:
 ## Documentation
 
 - 📖 [Contributing Guide](CONTRIBUTING.md) - How to contribute to the project
-- 📚 [API Reference](https://gesellix.github.io/Bose-SoundTouch/reference/API-ENDPOINTS.md) - Complete endpoint documentation
-- 🔧 [CLI Reference](https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.md) - Command-line tool guide
-- 🌐 [SoundTouch Service Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SOUNDTOUCH-SERVICE.md) - Local service setup and migration
-- 🎯 [Getting Started](https://gesellix.github.io/Bose-SoundTouch/guides/GETTING-STARTED.md) - Detailed setup and usage
+ - 📚 [API Reference](https://gesellix.github.io/Bose-SoundTouch/reference/API-ENDPOINTS.html) - Complete endpoint documentation
+- 🔧 [CLI Reference](https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.html) - Command-line tool guide
+- 🌐 [SoundTouch Service Guide](https://gesellix.github.io/Bose-SoundTouch/guides/SOUNDTOUCH-SERVICE.html) - Local service setup and migration
+- 🎯 [Getting Started](https://gesellix.github.io/Bose-SoundTouch/guides/GETTING-STARTED.html) - Detailed setup and usage
 - 📻 [Preset Quick Start](https://gesellix.github.io/Bose-SoundTouch/PRESET-QUICKSTART.md) - Favorite content management
 - 🧭 [Navigation Guide](https://gesellix.github.io/Bose-SoundTouch/NAVIGATION-GUIDE.md) - Content browsing and station management
 - 📋 [Navigation API Reference](https://gesellix.github.io/Bose-SoundTouch/API-NAVIGATION-REFERENCE.md) - Navigation API documentation
-- ⚙️ [Advanced Features](https://gesellix.github.io/Bose-SoundTouch/reference/SYSTEM-ENDPOINTS.md) - Advanced functionality
-- 🏠 [Multiroom Setup](https://gesellix.github.io/Bose-SoundTouch/reference/ZONE-MANAGEMENT.md) - Zone configuration guide
-- ⚡ [WebSocket Events](https://gesellix.github.io/Bose-SoundTouch/reference/WEBSOCKET-EVENTS.md) - Real-time event handling
-- 🔔 [Speaker Notifications](https://gesellix.github.io/Bose-SoundTouch/reference/SPEAKER-ENDPOINT.md) - TTS and audio notifications guide
-- 🔍 [Device Discovery](https://gesellix.github.io/Bose-SoundTouch/reference/DISCOVERY.md) - Discovery configuration
-- 🛠️ [Troubleshooting](https://gesellix.github.io/Bose-SoundTouch/guides/TROUBLESHOOTING.md) - Common issues and solutions
+- ⚙️ [Advanced Features](https://gesellix.github.io/Bose-SoundTouch/reference/SYSTEM-ENDPOINTS.html) - Advanced functionality
+- 🏠 [Multiroom Setup](https://gesellix.github.io/Bose-SoundTouch/reference/ZONE-MANAGEMENT.html) - Zone configuration guide
+- ⚡ [WebSocket Events](https://gesellix.github.io/Bose-SoundTouch/reference/WEBSOCKET-EVENTS.html) - Real-time event handling
+- 🔔 [Speaker Notifications](https://gesellix.github.io/Bose-SoundTouch/reference/SPEAKER-ENDPOINT.html) - TTS and audio notifications guide
+- 🔍 [Device Discovery](https://gesellix.github.io/Bose-SoundTouch/reference/DISCOVERY.html) - Discovery configuration
+- 🛠️ [Troubleshooting](https://gesellix.github.io/Bose-SoundTouch/guides/TROUBLESHOOTING.html) - Common issues and solutions
 
 ## Development
 
@@ -479,7 +481,7 @@ This project builds upon the excellent work of several community projects:
 ### SoundCork 🍾
 - **Project**: [SoundCork - SoundTouch API Intercept](https://github.com/deborahgu/soundcork)
 - **Authors**: Deborah Kaplan and contributors
-- **Our Implementation**: The `soundtouch-service` in this project is heavily inspired by and based on SoundCork's Python implementation. SoundCork pioneered the approach of intercepting and emulating Bose's cloud services, providing the foundation for offline SoundTouch operation.
+- **Our Implementation**: The `soundtouch-service` in this project is heavily inspired by SoundCork's Python implementation. SoundCork pioneered the approach of intercepting and emulating Bose's cloud services, providing the foundation for offline SoundTouch operation.
 - **Key Contributions**: Service emulation architecture, BMX/Marge endpoint discovery, device migration strategies
 - **License**: MIT License
 
@@ -528,11 +530,11 @@ If you discover new endpoints, features, or improvements through this library, p
 - ❓ **Questions**: Check [existing discussions](https://github.com/gesellix/bose-soundtouch/discussions)
 - 📖 **Documentation**: [Online Documentation](https://gesellix.github.io/Bose-SoundTouch/)
 - 🔍 **New Discoveries**: [Undocumented Community Features](https://gesellix.github.io/Bose-SoundTouch/UNDOCUMENTED-COMMUNITY-FEATURES.md)
-- 🌐 **Upstream Analysis**: [Upstream URLs & Domains](https://gesellix.github.io/Bose-SoundTouch/analysis/UPSTREAM-URLS.md)
-- 🔧 **Redirection Guide**: [Device Redirect Methods](https://gesellix.github.io/Bose-SoundTouch/analysis/DEVICE-REDIRECT-METHODS.md)
-- 🐣 **Initial Setup**: [Device Initial Setup Variants](https://gesellix.github.io/Bose-SoundTouch/guides/DEVICE-INITIAL-SETUP.md)
+- 🌐 **Upstream Analysis**: [Upstream URLs & Domains](https://gesellix.github.io/Bose-SoundTouch/analysis/UPSTREAM-URLS.html)
+- 🔧 **Redirection Guide**: [Device Redirect Methods](https://gesellix.github.io/Bose-SoundTouch/analysis/DEVICE-REDIRECT-METHODS.html)
+- 🐣 **Initial Setup**: [Device Initial Setup Variants](https://gesellix.github.io/Bose-SoundTouch/guides/DEVICE-INITIAL-SETUP.html)
 - 📜 **Logging & Debugging**: [Device Logging Guide](https://gesellix.github.io/Bose-SoundTouch/DEVICE-LOGGING.md)
-- 🔒 **HTTPS & CA Setup**: [HTTPS & Custom CA Guide](https://gesellix.github.io/Bose-SoundTouch/guides/HTTPS-SETUP.md)
+- 🔒 **HTTPS & CA Setup**: [HTTPS & Custom CA Guide](https://gesellix.github.io/Bose-SoundTouch/guides/HTTPS-SETUP.html)
 
 ---
 

cmd/soundtouch-service/main.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-	"net/http/httputil"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -81,10 +80,15 @@ func main() {
 				EnvVars: []string{"BIND_ADDR"},
 			},
 			&cli.StringFlag{
-				Name:    "target-url",
-				Usage:   "URL for Python-based service components (legacy)",
+				Name:    "soundcork-url",
+				Usage:   "URL for Soundcork-based service components (legacy)",
 				Value:   "http://localhost:8001",
-				EnvVars: []string{"PYTHON_BACKEND_URL", "TARGET_URL"},
+				EnvVars: []string{"SOUNDCORK_BACKEND_URL", "TARGET_URL"},
+			},
+			&cli.BoolFlag{
+				Name:    "enable-soundcork-proxy",
+				Usage:   "Enable proxying unknown requests to the Soundcork backend",
+				EnvVars: []string{"ENABLE_SOUNDCORK_PROXY"},
 			},
 			&cli.StringFlag{
 				Name:    "data-dir",
@@ -138,47 +142,11 @@ func main() {
 			config := loadConfig(c)
 			ds := initDataStore(config.dataDir)
 
-			// Load settings from datastore
-			persisted, err := ds.GetSettings()
+			persisted := applyPersistedSettings(ds, &config)
 
-			settingsExist := err == nil && persisted.ServerURL != ""
-			if persisted.ServerURL != "" {
-				config.serverURL = persisted.ServerURL
-			}
-
-			if persisted.ProxyURL != "" {
-				config.targetURL = persisted.ProxyURL
-			}
-
-			if persisted.HTTPServerURL != "" {
-				config.httpsServerURL = persisted.HTTPServerURL
-			}
-
-			if persisted.DiscoveryInterval != "" {
-				if d, durErr := time.ParseDuration(persisted.DiscoveryInterval); durErr == nil {
-					config.discoveryInterval = d
-				}
-			}
-
-			config.redact = persisted.RedactLogs || config.redact
-			config.logBody = persisted.LogBodies || config.logBody
-			config.record = persisted.RecordInteractions || config.record
-
-			if !settingsExist {
+			if persisted.ServerURL == "" {
 				log.Printf("Creating default settings.json in %s", config.dataDir)
-				persisted.ServerURL = config.serverURL
-				persisted.ProxyURL = config.targetURL
-				persisted.HTTPServerURL = config.httpsServerURL
-				persisted.RedactLogs = config.redact
-				persisted.LogBodies = config.logBody
-				persisted.RecordInteractions = config.record
-				persisted.DiscoveryInterval = config.discoveryInterval.String()
-				persisted.DiscoveryDisabled = false
-				persisted.Shortcuts = map[string]int{
-					"/.well-known/appspecific/com.chrome.devtools.json": http.StatusNotFound,
-					"/sw.js": http.StatusNotFound,
-				}
-				_ = ds.SaveSettings(persisted)
+				persisted = createDefaultSettings(ds, config)
 			}
 
 			// Recalculate domains if settings changed
@@ -191,10 +159,11 @@ func main() {
 
 			cm := initCertificateManager(config.dataDir)
 			sm := setup.NewManager(config.serverURL, ds, cm)
-			server := handlers.NewServer(ds, sm, config.serverURL, config.redact, config.logBody, config.record)
+			server := handlers.NewServer(ds, sm, config.serverURL, config.redact, config.logBody, config.record, config.enableSoundcorkProxy)
+			server.SetSoundcorkURL(config.soundcorkURL)
 			server.SetHTTPServerURL(config.httpsServerURL)
 			server.SetVersionInfo(version, commit, date)
-			server.SetDiscoverySettings(config.discoveryInterval, persisted.DiscoveryDisabled)
+			server.SetDiscoverySettings(config.discoveryInterval, persisted.DiscoveryEnabled)
 			server.SetShortcuts(persisted.Shortcuts)
 
 			for path, status := range persisted.Shortcuts {
@@ -234,13 +203,11 @@ func main() {
 				log.Printf("Warning: Failed to setup TLS: %v", err)
 			}
 
-			pyProxy := setupPythonProxy(config.targetURL, config.redact, config.logBody, recorder, server)
-
 			startDeviceDiscovery(server)
 
-			r := setupRouter(server, pyProxy)
+			r := setupRouter(server)
 
-			log.Printf("Go service starting on %s, proxying to %s", config.serverURL, config.targetURL)
+			log.Printf("Go service starting on %s, proxying to %s", config.serverURL, config.soundcorkURL)
 
 			if tlsConfig != nil {
 				startHTTPSServer(config.httpsAddr, r, tlsConfig, config.httpsServerURL)
@@ -274,19 +241,20 @@ func showVersionInfo(_ *cli.Context) error {
 }
 
 type serviceConfig struct {
-	port              string
-	bindAddr          string
-	addr              string
-	targetURL         string
-	dataDir           string
-	serverURL         string
-	httpsServerURL    string
-	httpsAddr         string
-	redact            bool
-	logBody           bool
-	record            bool
-	discoveryInterval time.Duration
-	domains           []string
+	port                 string
+	bindAddr             string
+	addr                 string
+	soundcorkURL         string
+	dataDir              string
+	serverURL            string
+	httpsServerURL       string
+	httpsAddr            string
+	redact               bool
+	logBody              bool
+	record               bool
+	enableSoundcorkProxy bool
+	discoveryInterval    time.Duration
+	domains              []string
 }
 
 func loadConfig(c *cli.Context) serviceConfig {
@@ -298,7 +266,7 @@ func loadConfig(c *cli.Context) serviceConfig {
 		addr = ":" + port
 	}
 
-	targetURL := c.String("target-url")
+	soundcorkURL := c.String("soundcork-url")
 	dataDir := c.String("data-dir")
 
 	hostname, _ := os.Hostname()
@@ -330,6 +298,7 @@ func loadConfig(c *cli.Context) serviceConfig {
 	redact := c.Bool("redact-logs")
 	logBody := c.Bool("log-bodies")
 	record := c.Bool("record-interactions")
+	enableSoundcorkProxy := c.Bool("enable-soundcork-proxy")
 
 	discoveryIntervalStr := c.String("discovery-interval")
 
@@ -341,19 +310,20 @@ func loadConfig(c *cli.Context) serviceConfig {
 	}
 
 	return serviceConfig{
-		port:              port,
-		bindAddr:          bindAddr,
-		addr:              addr,
-		targetURL:         targetURL,
-		dataDir:           dataDir,
-		serverURL:         serverURL,
-		httpsServerURL:    httpsServerURL,
-		httpsAddr:         httpsAddr,
-		redact:            redact,
-		logBody:           logBody,
-		record:            record,
-		discoveryInterval: discoveryInterval,
-		domains:           domains,
+		port:                 port,
+		bindAddr:             bindAddr,
+		addr:                 addr,
+		soundcorkURL:         soundcorkURL,
+		dataDir:              dataDir,
+		serverURL:            serverURL,
+		httpsServerURL:       httpsServerURL,
+		httpsAddr:            httpsAddr,
+		redact:               redact,
+		logBody:              logBody,
+		record:               record,
+		enableSoundcorkProxy: enableSoundcorkProxy,
+		discoveryInterval:    discoveryInterval,
+		domains:              domains,
 	}
 }
 
@@ -386,6 +356,59 @@ func getDomains(serverURL, httpsServerURL, hostname string) []string {
 	return domains
 }
 
+func applyPersistedSettings(ds *datastore.DataStore, config *serviceConfig) datastore.Settings {
+	persisted, err := ds.GetSettings()
+	if err != nil {
+		return datastore.Settings{}
+	}
+
+	if persisted.ServerURL != "" {
+		config.serverURL = persisted.ServerURL
+	}
+
+	if persisted.SoundcorkURL != "" {
+		config.soundcorkURL = persisted.SoundcorkURL
+	}
+
+	if persisted.HTTPServerURL != "" {
+		config.httpsServerURL = persisted.HTTPServerURL
+	}
+
+	if persisted.DiscoveryInterval != "" {
+		if d, durErr := time.ParseDuration(persisted.DiscoveryInterval); durErr == nil {
+			config.discoveryInterval = d
+		}
+	}
+
+	config.redact = persisted.RedactLogs || config.redact
+	config.logBody = persisted.LogBodies || config.logBody
+	config.record = persisted.RecordInteractions || config.record
+	config.enableSoundcorkProxy = persisted.EnableSoundcorkProxy || config.enableSoundcorkProxy
+
+	return persisted
+}
+
+func createDefaultSettings(ds *datastore.DataStore, config serviceConfig) datastore.Settings {
+	settings := datastore.Settings{
+		ServerURL:            config.serverURL,
+		SoundcorkURL:         config.soundcorkURL,
+		HTTPServerURL:        config.httpsServerURL,
+		RedactLogs:           config.redact,
+		LogBodies:            config.logBody,
+		RecordInteractions:   config.record,
+		DiscoveryInterval:    config.discoveryInterval.String(),
+		DiscoveryEnabled:     true,
+		EnableSoundcorkProxy: config.enableSoundcorkProxy,
+		Shortcuts: map[string]int{
+			"/.well-known/appspecific/com.chrome.devtools.json": http.StatusNotFound,
+			"/sw.js": http.StatusNotFound,
+		},
+	}
+	_ = ds.SaveSettings(settings)
+
+	return settings
+}
+
 func initDataStore(dataDir string) *datastore.DataStore {
 	ds := datastore.NewDataStore(dataDir)
 	if err := ds.Initialize(); err != nil {
@@ -404,47 +427,11 @@ func initCertificateManager(dataDir string) *certmanager.CertificateManager {
 	return cm
 }
 
-func setupPythonProxy(targetURL string, redact, logBody bool, recorder *proxy.Recorder, server *handlers.Server) *httputil.ReverseProxy {
-	target, err := url.Parse(targetURL)
-	if err != nil {
-		log.Fatalf("Failed to parse target URL: %v", err)
-	}
-
-	pyProxy := httputil.NewSingleHostReverseProxy(target)
-	pyProxy.ModifyResponse = func(res *http.Response) error {
-		if etags, ok := res.Header["Etag"]; ok {
-			delete(res.Header, "Etag")
-			res.Header["ETag"] = etags
-		}
-
-		currentLp := proxy.NewLoggingProxy(target.String(), redact)
-		currentLp.LogBody = logBody
-		currentLp.RecordEnabled = server.GetRecordEnabled()
-		currentLp.SetRecorder(recorder)
-		currentLp.LogResponse(res)
-
-		return nil
-	}
-
-	originalPyDirector := pyProxy.Director
-	pyProxy.Director = func(req *http.Request) {
-		originalPyDirector(req)
-
-		currentLp := proxy.NewLoggingProxy(target.String(), redact)
-		currentLp.LogBody = logBody
-		currentLp.RecordEnabled = server.GetRecordEnabled()
-		currentLp.SetRecorder(recorder)
-		currentLp.LogRequest(req)
-	}
-
-	return pyProxy
-}
-
 func startDeviceDiscovery(server *handlers.Server) {
 	go func() {
 		for {
-			currentInterval, disabled := server.GetDiscoverySettings()
-			if !disabled {
+			currentInterval, enabled := server.GetDiscoverySettings()
+			if enabled {
 				server.DiscoverDevices(context.Background())
 			}
 
@@ -453,9 +440,9 @@ func startDeviceDiscovery(server *handlers.Server) {
 	}()
 }
 
-func setupRouter(server *handlers.Server, pyProxy *httputil.ReverseProxy) *chi.Mux {
+func setupRouter(server *handlers.Server) *chi.Mux {
 	r := chi.NewRouter()
-	r.Use(middleware.Logger)
+	r.Use(server.OriginMiddleware)
 	r.Use(middleware.Recoverer)
 	r.Use(server.ShortcutMiddleware)
 	r.Use(server.RecordMiddleware)
@@ -479,6 +466,13 @@ func setupRouter(server *handlers.Server, pyProxy *httputil.ReverseProxy) *chi.M
 		r.Post("/orion/v1/playback/station/{data}", server.HandleOrionPlayback)
 	})
 
+	// Legacy or direct domain calls without /bmx prefix
+	r.Get("/registry/v1/services", server.HandleBMXRegistry)
+	r.Get("/tunein/v1/playback/station/{stationID}", server.HandleTuneInPlayback)
+	r.Get("/tunein/v1/playback/episodes/{podcastID}", server.HandleTuneInPodcastInfo)
+	r.Get("/tunein/v1/playback/episode/{podcastID}", server.HandleTuneInPlaybackPodcast)
+	r.Post("/orion/v1/playback/station/{data}", server.HandleOrionPlayback)
+
 	r.Route("/marge", func(r chi.Router) {
 		r.Get("/streaming/sourceproviders", server.HandleMargeSourceProviders)
 		r.Get("/accounts/{account}/full", server.HandleMargeAccountFull)
@@ -492,6 +486,37 @@ func setupRouter(server *handlers.Server, pyProxy *httputil.ReverseProxy) *chi.M
 		r.Get("/streaming/account/{account}/provider_settings", server.HandleMargeProviderSettings)
 		r.Get("/streaming/device/{device}/streaming_token", server.HandleMargeStreamingToken)
 		r.Post("/streaming/support/customersupport", server.HandleMargeCustomerSupport)
+		r.Get("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeGetDeviceSettings)
+		r.Post("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeUpdateDeviceSettings)
+		r.Get("/streaming/account/{account}/emailaddress", server.HandleMargeGetEmailAddress)
+	})
+
+	// Legacy or direct domain calls without /marge prefix
+	r.Get("/streaming/sourceproviders", server.HandleMargeSourceProviders)
+	r.Get("/accounts/{account}/full", server.HandleMargeAccountFull)
+	r.Post("/streaming/support/power_on", server.HandleMargePowerOn)
+	r.Get("/updates/soundtouch", server.HandleMargeSoftwareUpdate)
+	r.Get("/accounts/{account}/devices/{device}/presets", server.HandleMargePresets)
+	r.Post("/accounts/{account}/devices/{device}/presets/{presetNumber}", server.HandleMargeUpdatePreset)
+	r.Post("/accounts/{account}/devices/{device}/recents", server.HandleMargeAddRecent)
+	r.Post("/accounts/{account}/devices", server.HandleMargeAddDevice)
+	r.Delete("/accounts/{account}/devices/{device}", server.HandleMargeRemoveDevice)
+	r.Get("/streaming/account/{account}/provider_settings", server.HandleMargeProviderSettings)
+	r.Get("/streaming/device/{device}/streaming_token", server.HandleMargeStreamingToken)
+	r.Post("/streaming/support/customersupport", server.HandleMargeCustomerSupport)
+	r.Get("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeGetDeviceSettings)
+	r.Post("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeUpdateDeviceSettings)
+	r.Get("/streaming/account/{account}/emailaddress", server.HandleMargeGetEmailAddress)
+
+	r.Route("/customer", func(r chi.Router) {
+		r.Get("/account/{account}", server.HandleMargeAccountProfile)
+		r.Post("/account/{account}", server.HandleMargeUpdateAccountProfile)
+		r.Post("/account/{account}/password", server.HandleMargeChangePassword)
+	})
+
+	r.Route("/v1", func(r chi.Router) {
+		r.Post("/stapp/{deviceId}", server.HandleAppEvents)
+		r.Post("/scmudc/{deviceId}", server.HandleAppEvents)
 	})
 
 	r.Route("/streaming/stats", func(r chi.Router) {
@@ -525,12 +550,16 @@ func setupRouter(server *handlers.Server, pyProxy *httputil.ReverseProxy) *chi.M
 		r.Get("/proxy-settings", server.HandleGetProxySettings)
 		r.Post("/proxy-settings", server.HandleUpdateProxySettings)
 		r.Get("/version", server.HandleGetVersionInfo)
+		r.Get("/interaction-stats", server.HandleGetInteractionStats)
+		r.Get("/interactions", server.HandleListInteractions)
+		r.Get("/interaction-content", server.HandleGetInteractionContent)
+		r.Get("/interactions/sessions/{session}/download", server.HandleDownloadSession)
+		r.Delete("/interactions/sessions/{session}", server.HandleDeleteSession)
+		r.Delete("/interactions/sessions", server.HandleCleanupSessions)
 		r.Get("/devices/{deviceId}/events", server.HandleGetDeviceEvents)
 	})
 
-	r.NotFound(func(w http.ResponseWriter, r *http.Request) {
-		pyProxy.ServeHTTP(w, r)
-	})
+	r.NotFound(server.HandleNotFound)
 
 	return r
 }

data/.gitignore

@@ -1,4 +1,6 @@
+accounts/
 certs/
 default/
 interactions/
+patterns.json
 settings.json

data/patterns.json

@@ -1,17 +0,0 @@
-[
-  {
-    "name": "IPv4",
-    "regexp": "^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$",
-    "replacement": "{ip}"
-  },
-  {
-    "name": "DeviceID",
-    "regexp": "^[A-F0-9]{12}$",
-    "replacement": "{deviceId}"
-  },
-  {
-    "name": "AccountID",
-    "regexp": "^\\d{1,10}$",
-    "replacement": "{accountId}"
-  }
-]

docs/SUMMARY.md

@@ -24,6 +24,7 @@
 ## Technical Reference
 * [API Cookbook](reference/API-COOKBOOK.md)
 * [API Endpoints](reference/API-ENDPOINTS.md)
+* [Cloud API Emulation](reference/CLOUD-API.md)
 * [System Endpoints](reference/SYSTEM-ENDPOINTS.md)
 * [Speaker Endpoint](reference/SPEAKER-ENDPOINT.md)
 * [WebSocket Events](reference/WEBSOCKET-EVENTS.md)

docs/analysis/DEVICE-REDIRECT-METHODS.md

@@ -9,6 +9,9 @@ SoundTouch devices primarily communicate with the following domains:
 - `updates.bose.com`: Software updates
 - `stats.bose.com`: Telemetry and analytics
 - `bmx.bose.com`: Bose Media eXchange registry
+- `events.api.bosecm.com`: Stockholm app analytics
+- `bose-prod.apigee.net`: Apigee gateway (used by some services)
+- `worldwide.bose.com`: Software update metadata and secondary services
 
 ---
 
@@ -153,7 +156,7 @@ For developers creating a completely isolated "dark" environment (no internet at
 1.  **XML**: Point all URLs to local services.
 2.  **Binary Patch**: Neutralize `IsItBose` to allow non-Bose domains/IPs.
 3.  **`/etc/hosts`**: Redirect hardcoded domains that aren't exposed in the XML (like analytics or NTP) to prevent leakage to the real Bose cloud.
-4.  **Process Instrumentation**: Use [SoundTouch Hook](https://github.com/CodeFinder2/bose-soundtouch-hook) to monitor and override internal behavior in real-time.
+4.  **Process Instrumentation**: Use [SoundTouch Hook](https://github.com/CodeFinder2/bose-soundtouch-hook) to monitor and override internal behavior in real-time. This is particularly useful for handling unknown hostnames or deep-hooking into service discovery logic that might bypass standard DNS lookups.
 
 ---
 

docs/guides/HTTPS-SETUP.md

@@ -1,6 +1,6 @@
 # HTTPS Setup & Custom CA Certificate
 
-To use the `/etc/hosts` redirection method safely, SoundTouch devices must communicate over HTTPS. This requires the device to trust the Root CA certificate used by the local `soundtouch-service`.
+To use the `/etc/hosts` redirection method safely, SoundTouch devices must communicate over HTTPS. This requires the device to trust the AfterTouch Root CA certificate used by the local service.
 
 ## 1. Automated Migration (Hosts Method)
 
@@ -13,12 +13,12 @@ curl -X POST "http://localhost:8000/setup/migrate/{deviceIP}?method=hosts"
 This command will:
 1.  Connect to the device via SSH.
 2.  Update `/etc/hosts` to point Bose domains to the service IP.
-3.  Inject the auto-generated Root CA into the device's trust store (`/etc/pki/tls/certs/ca-bundle.crt`).
+3.  Inject the auto-generated AfterTouch Root CA into the device's trust store (`/etc/pki/tls/certs/ca-bundle.crt`).
 4.  Reboot the device.
 
 ## 2. Managing the Root CA
 
-The `soundtouch-service` automatically generates a Root CA when it first starts.
+The AfterTouch service automatically generates a Root CA when it first starts.
 
 - **CA Certificate**: `data/certs/ca.crt`
 - **CA Private Key**: `data/certs/ca.key`
@@ -34,7 +34,7 @@ The `soundtouch-service` now includes a built-in HTTPS listener. This simplifies
 - **HTTPS Port**: Configurable via `HTTPS_PORT` environment variable (defaults to `8443`).
 - **HTTPS Server URL**: Configurable via `HTTPS_SERVER_URL` (e.g., `https://mysoundtouch.local:8443`). If not set, the service attempts to guess it using the system hostname.
 - **Domain Coverage**: Automatically presents a certificate for `streaming.bose.com`, `updates.bose.com`, `stats.bose.com`, `bmx.bose.com`, and `content.api.bose.io`.
-- **Automatic Setup**: On first start, it generates a server certificate signed by your local Root CA.
+- **Automatic Setup**: On first start, it generates a server certificate signed by your AfterTouch local Root CA.
 
 #### TLS Security
 

docs/guides/SOUNDTOUCH-SERVICE.md

@@ -375,6 +375,13 @@ The web management interface provides a comprehensive dashboard for managing you
 - **Statistics Dashboard**: Usage and error analytics
 - **Debug Tools**: Device communication testing utilities
 
+#### Interactions & Traffic Analysis
+- **Traffic Overview**: View aggregate request counts for self-handled and proxied traffic.
+- **Session Browsing**: Browse recorded interactions grouped by session.
+- **Advanced Filtering**: Filter interactions by session, category (Self/Upstream), and timestamp.
+- **Interaction Viewer**: View raw `.http` recording content directly in the browser.
+- **Session Management**: Delete individual sessions or perform bulk cleanup to keep only recent sessions.
+
 ### Usage Tips
 
 1. **First Time Setup**: The interface will guide you through initial device discovery
@@ -393,6 +400,7 @@ The service automatically records all HTTP interactions (both those handled loca
 - **Path-Based Structure**: Recordings are organized into subdirectories based on their URL path for better discoverability.
 - **Automatic Sanitization**: Variable path segments like IP addresses, Device IDs, and Account IDs are automatically identified and replaced with placeholders (e.g., `{{ip}}`, `{{deviceId}}`). The original values are preserved as comments at the top of the recorded `.http` files for easy identification.
 - **Re-playability**: An `http-client.env.json` file is generated for each session, allowing you to re-play the recorded requests immediately in IntelliJ IDEA.
+- **Management UI**: The **5. Interactions** tab provides a built-in viewer and management tools for all recorded data.
 
 ### Configuration
 
@@ -531,6 +539,26 @@ find data/stats/ -name "*.json" -mtime +90 -delete
 - `POST /setup/migrate/{deviceIP}`: Migrate a device using the specified method (XML/Hosts).
 - `GET /setup/ca.crt`: Download the Root CA certificate for manual installation.
 
+#### `GET /setup/interactions`
+Lists recorded interactions with optional filtering.
+
+**Query Parameters:**
+- `session`: Filter by session ID (optional)
+- `category`: Filter by category (`self` or `upstream`) (optional)
+- `since`: Filter by timestamp (e.g., `2026-02-15 15:00:00`) (optional)
+
+#### `GET /setup/interaction-stats`
+Returns aggregate statistics about recorded interactions across all sessions.
+
+#### `GET /setup/interaction-content?file={path}`
+Returns the raw content of a specific recorded `.http` file.
+
+#### `DELETE /setup/interactions/sessions/{sessionID}`
+Deletes all recordings associated with a specific session.
+
+#### `DELETE /setup/interactions/sessions?keep={N}`
+Bulk cleanup: deletes all but the most recent `N` sessions.
+
 ### Emulated Services
 - `/bmx/registry/v1/services`: BMX service registry.
 - `/bmx/tunein/v1/*`: TuneIn radio emulation.

docs/reference/CLOUD-API.md

@@ -0,0 +1,73 @@
+# Bose SoundTouch Cloud API Emulation (Marge/BMX/Stats)
+
+This document describes the cloud-emulation APIs provided by the SoundTouch service. These APIs mimic the Bose cloud services (Marge, BMX, Stats) that SoundTouch devices and the SoundTouch controller application (Stockholm) interact with.
+
+## Marge API (Account & Configuration)
+
+Base path: `/marge`
+
+### GET /streaming/sourceproviders
+Retrieves a list of available streaming source providers.
+
+### GET /accounts/{accountId}/full
+Retrieves the full account configuration including sources, presets, and devices.
+
+### GET /streaming/account/{accountId}/emailaddress
+Retrieves the email address associated with the account.
+
+### GET /streaming/device_setting/account/{accountId}/device/{deviceId}/device_settings
+Retrieves settings for a specific device (e.g., clock format).
+
+### POST /streaming/device_setting/account/{accountId}/device/{deviceId}/device_settings
+Updates settings for a specific device.
+
+### POST /accounts/{accountId}/devices/{deviceId}/presets/{presetNumber}
+Updates a preset for a device.
+
+### POST /accounts/{accountId}/devices/{deviceId}/recents
+Adds an item to the device's recently played history.
+
+### POST /accounts/{accountId}/devices
+Adds a device to the account.
+
+### DELETE /accounts/{accountId}/devices/{deviceId}
+Removes a device from the account.
+
+## Customer API (Profile & Password)
+
+Base path: `/customer`
+
+### GET /account/{accountId}
+Retrieves the customer account profile.
+
+### POST /account/{accountId}
+Updates the customer account profile.
+
+### POST /account/{accountId}/password
+Changes the account password.
+
+## Analytics & Stats API
+
+Base path: `/v1` (App Events) or `/streaming/stats` (Device Stats)
+
+### POST /v1/stapp/{deviceId}
+Endpoint called by Bose SoundTouch mobile and web applications (Stockholm) to submit event data.
+
+### POST /v1/scmudc/{deviceId}
+Endpoint equivalent to `/v1/stapp/{deviceId}` sometimes used by apps or devices.
+
+### POST /streaming/stats/usage
+Endpoint used by physical devices to report usage statistics.
+
+### POST /streaming/stats/error
+Endpoint used by physical devices to report error statistics.
+
+## BMX API (Streaming & Registry)
+
+Base path: `/bmx`
+
+### GET /registry/v1/services
+Retrieves the registry of available streaming services.
+
+### GET /tunein/v1/playback/station/{stationID}
+Retrieves playback information for a TuneIn station.

go.mod

@@ -8,16 +8,16 @@ require (
 	github.com/hashicorp/mdns v1.0.6
 	github.com/russross/blackfriday/v2 v2.1.0
 	github.com/urfave/cli/v2 v2.27.7
-	golang.org/x/crypto v0.47.0
+	golang.org/x/crypto v0.48.0
 )
 
 require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
 	github.com/miekg/dns v1.1.72 // indirect
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
-	golang.org/x/mod v0.32.0 // indirect
-	golang.org/x/net v0.49.0 // indirect
+	golang.org/x/mod v0.33.0 // indirect
+	golang.org/x/net v0.50.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect
-	golang.org/x/tools v0.41.0 // indirect
+	golang.org/x/tools v0.42.0 // indirect
 )

go.sum

@@ -24,16 +24,16 @@ golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliY
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
-golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
+golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
-golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
+golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -44,8 +44,8 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
-golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
-golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
+golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -79,8 +79,8 @@ golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
-golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
-golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
+golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
+golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
@@ -98,6 +98,6 @@ golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
-golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
+golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

pkg/models/models.go

@@ -240,3 +240,70 @@ type DeviceEvent struct {
 	MonoTime int64                  `json:"monoTime"`
 	Data     map[string]interface{} `json:"data"`
 }
+
+// DeviceEventsRequest represents a request containing multiple device events (stapp/scmudc).
+type DeviceEventsRequest struct {
+	Envelope struct {
+		MonoTime               int64  `json:"monoTime"`
+		PayloadProtocolVersion string `json:"payloadProtocolVersion"`
+		PayloadType            string `json:"payloadType"`
+		ProtocolVersion        string `json:"protocolVersion"`
+		Time                   string `json:"time"`
+		UniqueID               string `json:"uniqueId"`
+	} `json:"envelope"`
+	Payload struct {
+		DeviceInfo struct {
+			BoseID          string `json:"boseID"`
+			DeviceID        string `json:"deviceID"`
+			DeviceType      string `json:"deviceType"`
+			SoftwareVersion string `json:"softwareVersion"`
+		} `json:"deviceInfo"`
+		Events []struct {
+			Data map[string]interface{} `json:"data"`
+			Time string                 `json:"time"`
+			Type string                 `json:"type"`
+		} `json:"events"`
+	} `json:"payload"`
+}
+
+// DeviceSettingsResponse represents device settings.
+type DeviceSettingsResponse struct {
+	XMLName  xml.Name        `xml:"deviceSettings"`
+	Settings []DeviceSetting `xml:"deviceSetting"`
+}
+
+// DeviceSetting represents a single device setting.
+type DeviceSetting struct {
+	Name  string `xml:"name"`
+	Value string `xml:"value"`
+}
+
+// AccountProfileResponse represents a customer account profile.
+type AccountProfileResponse struct {
+	XMLName        xml.Name `xml:"customer"`
+	AccountID      string   `xml:"accountID"`
+	Email          string   `xml:"email"`
+	FirstName      string   `xml:"firstName"`
+	LastName       string   `xml:"lastName"`
+	CountryCode    string   `xml:"countryCode"`
+	LanguageCode   string   `xml:"languageCode"`
+	Street         string   `xml:"street"`
+	City           string   `xml:"city"`
+	PostalCode     string   `xml:"postalCode"`
+	State          string   `xml:"state"`
+	Phone          string   `xml:"phone"`
+	MarketingOptIn bool     `xml:"marketingOptIn"`
+}
+
+// ChangePasswordRequest represents a request to change the account password.
+type ChangePasswordRequest struct {
+	XMLName     xml.Name `xml:"passwordChange"`
+	OldPassword string   `xml:"oldPassword"`
+	NewPassword string   `xml:"newPassword"`
+}
+
+// EmailAddressResponse represents the account email address.
+type EmailAddressResponse struct {
+	XMLName xml.Name `xml:"emailAddress"`
+	Email   string   `xml:",chardata"`
+}

pkg/service/certmanager/certmanager.go

@@ -148,8 +148,8 @@ func (cm *CertificateManager) GenerateCA() error {
 	template := x509.Certificate{
 		SerialNumber: serialNumber,
 		Subject: pkix.Name{
-			Organization: []string{"SoundTouch Local Service"},
-			CommonName:   "SoundTouch Local Root CA",
+			Organization: []string{"AfterTouch"},
+			CommonName:   "AfterTouch Local Root CA",
 		},
 		NotBefore:             notBefore,
 		NotAfter:              notAfter,
@@ -240,7 +240,7 @@ func (cm *CertificateManager) GenerateCertificate(domains []string) ([]byte, []b
 	template := x509.Certificate{
 		SerialNumber: serialNumber,
 		Subject: pkix.Name{
-			Organization: []string{"SoundTouch Local Service"},
+			Organization: []string{"AfterTouch"},
 			CommonName:   domains[0],
 		},
 		NotBefore:   notBefore,

pkg/service/datastore/datastore.go

@@ -42,12 +42,12 @@ func NewDataStore(dataDir string) *DataStore {
 
 // AccountDir returns the directory path for a specific account.
 func (ds *DataStore) AccountDir(account string) string {
-	return filepath.Join(ds.DataDir, account)
+	return filepath.Join(ds.DataDir, "accounts", account)
 }
 
 // AccountDevicesDir returns the devices directory path for a specific account.
 func (ds *DataStore) AccountDevicesDir(account string) string {
-	return filepath.Join(ds.DataDir, account, constants.DevicesDir)
+	return filepath.Join(ds.AccountDir(account), constants.DevicesDir)
 }
 
 // AccountDeviceDir returns the directory path for a specific device within an account.
@@ -154,13 +154,13 @@ func (ds *DataStore) ListAllDevices() ([]models.ServiceDeviceInfo, error) {
 
 func (ds *DataStore) getPossibleDataDirs() []string {
 	dirs := []string{}
-	if exists(ds.DataDir) {
-		dirs = append(dirs, ds.DataDir)
+	if exists(filepath.Join(ds.DataDir, "accounts")) {
+		dirs = append(dirs, filepath.Join(ds.DataDir, "accounts"))
 	}
 
-	// Also check soundcork-go/data if it's different and exists
-	altDir := "soundcork-go/data"
-	if ds.DataDir != altDir && exists(altDir) {
+	// Also check st-go/data/accounts if it's different and exists
+	altDir := "st-go/data/accounts"
+	if filepath.Join(ds.DataDir, "accounts") != altDir && exists(altDir) {
 		dirs = append(dirs, altDir)
 	}
 
@@ -639,17 +639,6 @@ func (ds *DataStore) Initialize() error {
 		return fmt.Errorf("failed to create data directory: %w", err)
 	}
 
-	// Ensure default account exists
-	defaultDir := ds.AccountDir("default")
-	if err := os.MkdirAll(defaultDir, 0755); err != nil {
-		return fmt.Errorf("failed to create default account directory: %w", err)
-	}
-
-	// Ensure devices subdirectory for default account
-	if err := os.MkdirAll(ds.AccountDevicesDir("default"), 0755); err != nil {
-		return fmt.Errorf("failed to create default devices directory: %w", err)
-	}
-
 	return nil
 }
 
@@ -709,15 +698,16 @@ func (ds *DataStore) GetETagForAccount(account, device string) int64 {
 
 // Settings represents the global service settings.
 type Settings struct {
-	ServerURL          string         `json:"server_url"`
-	ProxyURL           string         `json:"proxy_url"`
-	HTTPServerURL      string         `json:"https_server_url,omitempty"`
-	RedactLogs         bool           `json:"redact_logs"`
-	LogBodies          bool           `json:"log_bodies"`
-	RecordInteractions bool           `json:"record_interactions"`
-	DiscoveryInterval  string         `json:"discovery_interval,omitempty"`
-	DiscoveryDisabled  bool           `json:"discovery_disabled"`
-	Shortcuts          map[string]int `json:"shortcuts,omitempty"`
+	ServerURL            string         `json:"server_url"`
+	SoundcorkURL         string         `json:"soundcork_url"`
+	HTTPServerURL        string         `json:"https_server_url,omitempty"`
+	RedactLogs           bool           `json:"redact_logs"`
+	LogBodies            bool           `json:"log_bodies"`
+	RecordInteractions   bool           `json:"record_interactions"`
+	DiscoveryInterval    string         `json:"discovery_interval,omitempty"`
+	DiscoveryEnabled     bool           `json:"discovery_enabled"`
+	EnableSoundcorkProxy bool           `json:"enable_soundcork_proxy"`
+	Shortcuts            map[string]int `json:"shortcuts,omitempty"`
 }
 
 // GetSettings retrieves the global service settings.

pkg/service/datastore/datastore_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestDataStore(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -22,8 +22,9 @@ func TestDataStore(t *testing.T) {
 
 	// Test Save/Get DeviceInfo
 	info := &models.ServiceDeviceInfo{
-		DeviceID: device,
-		Name:     "Test Speaker",
+		DeviceID:  device,
+		Name:      "Test Speaker",
+		AccountID: account,
 	}
 
 	err = ds.SaveDeviceInfo(account, device, info)
@@ -87,14 +88,14 @@ func TestDataStore(t *testing.T) {
 	}
 
 	// Test path helpers
-	expectedAccountDir := filepath.Join(tempDir, account)
+	expectedAccountDir := filepath.Join(tempDir, "accounts", account)
 	if ds.AccountDir(account) != expectedAccountDir {
 		t.Errorf("Expected account dir %s, got %s", expectedAccountDir, ds.AccountDir(account))
 	}
 }
 
 func TestListAllDevices_Empty(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-empty-test-*")
+	tempDir, err := os.MkdirTemp("", "st-empty-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -133,7 +134,7 @@ func TestListAllDevices_Empty(t *testing.T) {
 }
 
 func TestListAllDevices(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-list-test-*")
+	tempDir, err := os.MkdirTemp("", "st-list-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -151,6 +152,7 @@ func TestListAllDevices(t *testing.T) {
 		DeviceSerialNumber: deviceID,
 		ProductCode:        "SoundTouch 10",
 		FirmwareVersion:    "1.2.3",
+		AccountID:          account,
 	}
 
 	err = ds.SaveDeviceInfo(account, deviceID, info)
@@ -173,7 +175,7 @@ func TestListAllDevices(t *testing.T) {
 }
 
 func TestListAllDevices_EmptyDeviceID(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-empty-id-test-*")
+	tempDir, err := os.MkdirTemp("", "st-empty-id-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -185,8 +187,9 @@ func TestListAllDevices_EmptyDeviceID(t *testing.T) {
 	deviceID := ""
 
 	info := &models.ServiceDeviceInfo{
-		DeviceID: deviceID,
-		Name:     "Empty ID Speaker",
+		DeviceID:  deviceID,
+		Name:      "Empty ID Speaker",
+		AccountID: account,
 	}
 
 	// Use IP as fallback for device ID if it is empty
@@ -215,7 +218,7 @@ func TestListAllDevices_EmptyDeviceID(t *testing.T) {
 }
 
 func TestListAllDevices_MultipleEmptyIDs(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-multi-empty-test-*")
+	tempDir, err := os.MkdirTemp("", "st-multi-empty-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -230,11 +233,13 @@ func TestListAllDevices_MultipleEmptyIDs(t *testing.T) {
 		DeviceID:  "",
 		Name:      "Speaker 1",
 		IPAddress: "192.168.1.1",
+		AccountID: account,
 	}
 	info2 := &models.ServiceDeviceInfo{
 		DeviceID:  "",
 		Name:      "Speaker 2",
 		IPAddress: "192.168.1.2",
+		AccountID: account,
 	}
 
 	// We use the same logic as in main.go: use IP as fallback for directory name
@@ -259,7 +264,7 @@ func TestListAllDevices_MultipleEmptyIDs(t *testing.T) {
 }
 
 func TestListAllDevices_MalformedXML(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-malformed-test-*")
+	tempDir, err := os.MkdirTemp("", "st-malformed-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -377,10 +382,10 @@ func TestSettingsPersistence(t *testing.T) {
 
 	settings := Settings{
 		ServerURL:         "http://myserver:8000",
-		ProxyURL:          "http://myproxy:8001",
+		SoundcorkURL:      "http://myproxy:8001",
 		LogBodies:         true,
 		DiscoveryInterval: "10m",
-		DiscoveryDisabled: true,
+		DiscoveryEnabled:  true,
 	}
 
 	err = ds.SaveSettings(settings)
@@ -402,7 +407,7 @@ func TestSettingsPersistence(t *testing.T) {
 	if loaded.DiscoveryInterval != settings.DiscoveryInterval {
 		t.Errorf("Expected DiscoveryInterval %s, got %s", settings.DiscoveryInterval, loaded.DiscoveryInterval)
 	}
-	if loaded.DiscoveryDisabled != settings.DiscoveryDisabled {
-		t.Errorf("Expected DiscoveryDisabled %v, got %v", settings.DiscoveryDisabled, loaded.DiscoveryDisabled)
+	if loaded.DiscoveryEnabled != settings.DiscoveryEnabled {
+		t.Errorf("Expected DiscoveryEnabled %v, got %v", settings.DiscoveryEnabled, loaded.DiscoveryEnabled)
 	}
 }

pkg/service/handlers/handlers_etag_test.go

@@ -16,7 +16,7 @@ const normalizedEtag = "Etag"
 const caseSensitiveETag = "ETag"
 
 func TestMargeETags(t *testing.T) {
-	tempDir, _ := os.MkdirTemp("", "soundcork-etag-test-*")
+	tempDir, _ := os.MkdirTemp("", "st-etag-test-*")
 
 	defer func() { _ = os.RemoveAll(tempDir) }()
 
@@ -24,7 +24,7 @@ func TestMargeETags(t *testing.T) {
 
 	account := "12345"
 	deviceID := "DEV1"
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 	deviceDir := filepath.Join(accountDir, "devices", deviceID)
 	_ = os.MkdirAll(deviceDir, 0755)
 

pkg/service/handlers/handlers_marge.go

@@ -60,6 +60,85 @@ func (s *Server) HandleMargePowerOn(w http.ResponseWriter, _ *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
+// HandleMargeAccountProfile returns the account profile.
+func (s *Server) HandleMargeAccountProfile(w http.ResponseWriter, r *http.Request) {
+	accountID := chi.URLParam(r, "account")
+
+	// Mock profile data
+	profile := models.AccountProfileResponse{
+		AccountID:    accountID,
+		Email:        "user@example.com",
+		FirstName:    "SoundTouch",
+		LastName:     "User",
+		CountryCode:  "US",
+		LanguageCode: "en",
+	}
+
+	data, err := xml.MarshalIndent(profile, "", "  ")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/xml")
+	_, _ = w.Write([]byte(xml.Header))
+	_, _ = w.Write(data)
+}
+
+// HandleMargeUpdateAccountProfile updates the account profile.
+func (s *Server) HandleMargeUpdateAccountProfile(w http.ResponseWriter, _ *http.Request) {
+	// Stub implementation
+	w.WriteHeader(http.StatusOK)
+}
+
+// HandleMargeChangePassword changes the account password.
+func (s *Server) HandleMargeChangePassword(w http.ResponseWriter, _ *http.Request) {
+	// Stub implementation
+	w.WriteHeader(http.StatusOK)
+}
+
+// HandleMargeGetEmailAddress returns the account email address.
+func (s *Server) HandleMargeGetEmailAddress(w http.ResponseWriter, _ *http.Request) {
+	resp := models.EmailAddressResponse{
+		Email: "user@example.com",
+	}
+
+	data, err := xml.MarshalIndent(resp, "", "  ")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/xml")
+	_, _ = w.Write([]byte(xml.Header))
+	_, _ = w.Write(data)
+}
+
+// HandleMargeGetDeviceSettings returns device settings.
+func (s *Server) HandleMargeGetDeviceSettings(w http.ResponseWriter, _ *http.Request) {
+	resp := models.DeviceSettingsResponse{
+		Settings: []models.DeviceSetting{
+			{Name: "CLOCK_FORMAT", Value: "24HR"},
+		},
+	}
+
+	data, err := xml.MarshalIndent(resp, "", "  ")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/xml")
+	_, _ = w.Write([]byte(xml.Header))
+	_, _ = w.Write(data)
+}
+
+// HandleMargeUpdateDeviceSettings updates device settings.
+func (s *Server) HandleMargeUpdateDeviceSettings(w http.ResponseWriter, _ *http.Request) {
+	// Stub implementation
+	w.WriteHeader(http.StatusOK)
+}
+
 // HandleMargeSoftwareUpdate returns the Marge software update information.
 func (s *Server) HandleMargeSoftwareUpdate(w http.ResponseWriter, r *http.Request) {
 	etag := "default-embedded"
@@ -202,11 +281,22 @@ func (s *Server) HandleMargeProviderSettings(w http.ResponseWriter, r *http.Requ
 func (s *Server) HandleMargeStreamingToken(w http.ResponseWriter, _ *http.Request) {
 	// Simple mock token for offline use.
 	// In a real production environment, this would be a JWT or similar signed token.
-	// Some speakers might expect a specific format; soundcork uses a distinctive prefix
+	// Some speakers might expect a specific format; we use a distinctive prefix
 	// to indicate it's a locally generated token.
-	token := "soundcork-local-token-" + strconv.FormatInt(time.Now().Unix(), 10)
-	w.Header().Set("Authorization", "Bearer "+token)
+	tokenValue := "st-local-token-" + strconv.FormatInt(time.Now().Unix(), 10)
+	bearerToken := models.NewBearerToken(tokenValue)
+
+	data, err := xml.Marshal(bearerToken)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/vnd.bose.streaming-v1.2+xml")
+	w.Header().Set("Authorization", bearerToken.GetAuthHeader())
 	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write([]byte(xml.Header))
+	_, _ = w.Write(data)
 }
 
 // HandleMargeCustomerSupport handles Marge customer support uploads.

pkg/service/handlers/handlers_marge_stockholm_test.go

@@ -0,0 +1,102 @@
+package handlers
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestMargeStockholmHandlers(t *testing.T) {
+	r, _ := setupRouter("http://localhost:8001", nil)
+	ts := httptest.NewServer(r)
+	defer ts.Close()
+
+	t.Run("HandleMargeAccountProfile GET", func(t *testing.T) {
+		res, err := http.Get(ts.URL + "/customer/account/12345")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+
+		body, _ := io.ReadAll(res.Body)
+		if !strings.Contains(string(body), "<accountID>12345</accountID>") {
+			t.Errorf("Response missing account ID: %s", string(body))
+		}
+	})
+
+	t.Run("HandleMargeUpdateAccountProfile POST", func(t *testing.T) {
+		res, err := http.Post(ts.URL+"/customer/account/12345", "application/xml", strings.NewReader("<profile/>"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+	})
+
+	t.Run("HandleMargeChangePassword POST", func(t *testing.T) {
+		res, err := http.Post(ts.URL+"/customer/account/12345/password", "application/xml", strings.NewReader("<password/>"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+	})
+
+	t.Run("HandleMargeGetEmailAddress GET", func(t *testing.T) {
+		res, err := http.Get(ts.URL + "/marge/streaming/account/12345/emailaddress")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+
+		body, _ := io.ReadAll(res.Body)
+		if !strings.Contains(string(body), "user@example.com") {
+			t.Errorf("Response missing email: %s", string(body))
+		}
+	})
+
+	t.Run("HandleMargeGetDeviceSettings GET", func(t *testing.T) {
+		res, err := http.Get(ts.URL + "/marge/streaming/device_setting/account/123/device/DEV1/device_settings")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+
+		body, _ := io.ReadAll(res.Body)
+		if !strings.Contains(string(body), "CLOCK_FORMAT") {
+			t.Errorf("Response missing settings: %s", string(body))
+		}
+	})
+
+	t.Run("HandleMargeUpdateDeviceSettings POST", func(t *testing.T) {
+		res, err := http.Post(ts.URL+"/marge/streaming/device_setting/account/123/device/DEV1/device_settings", "application/xml", strings.NewReader("<settings/>"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			t.Errorf("Expected status OK, got %v", res.Status)
+		}
+	})
+}

pkg/service/handlers/handlers_marge_test.go

@@ -61,7 +61,7 @@ func TestMargeSoftwareUpdate(t *testing.T) {
 }
 
 func TestMargeAccountFull(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -72,7 +72,7 @@ func TestMargeAccountFull(t *testing.T) {
 
 	account := "12345"
 	deviceID := "ABCDE"
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 
 	deviceDir := filepath.Join(accountDir, "devices", deviceID)
 	err = os.MkdirAll(deviceDir, 0755)
@@ -125,7 +125,7 @@ func TestMargeAccountFull(t *testing.T) {
 }
 
 func TestMargePresets(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -137,7 +137,7 @@ func TestMargePresets(t *testing.T) {
 	account := "12345"
 	deviceID := "any"
 
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 	deviceDir := filepath.Join(accountDir, "devices", deviceID)
 	err = os.MkdirAll(deviceDir, 0755)
 
@@ -196,7 +196,7 @@ func TestMargePresets(t *testing.T) {
 }
 
 func TestMargeUpdatePreset(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -208,7 +208,7 @@ func TestMargeUpdatePreset(t *testing.T) {
 	account := "12345"
 	deviceID := "DEV1"
 
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 	deviceDir := filepath.Join(accountDir, "devices", deviceID)
 	err = os.MkdirAll(deviceDir, 0755)
 
@@ -265,7 +265,7 @@ func TestMargeUpdatePreset(t *testing.T) {
 }
 
 func TestMargeDeviceInfo(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -277,7 +277,7 @@ func TestMargeDeviceInfo(t *testing.T) {
 	account := "12345"
 	deviceID := "DEV1"
 
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 	deviceDir := filepath.Join(accountDir, "devices", deviceID)
 	err = os.MkdirAll(deviceDir, 0755)
 
@@ -332,7 +332,7 @@ func TestMargeDeviceInfo(t *testing.T) {
 }
 
 func TestMargeAddRemoveDevice(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -343,7 +343,7 @@ func TestMargeAddRemoveDevice(t *testing.T) {
 
 	account := "12345"
 
-	accountDir := filepath.Join(tempDir, account)
+	accountDir := filepath.Join(tempDir, "accounts", account)
 	err = os.MkdirAll(accountDir, 0755)
 
 	if err != nil {
@@ -427,7 +427,7 @@ func TestMargePowerOn(t *testing.T) {
 }
 
 func TestMargeAdvancedFeatures(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -471,10 +471,23 @@ func TestMargeAdvancedFeatures(t *testing.T) {
 			t.Errorf("Expected status OK, got %v", res.Status)
 		}
 
+		contentType := res.Header.Get("Content-Type")
+		if contentType != "application/vnd.bose.streaming-v1.2+xml" {
+			t.Errorf("Invalid content type: %s", contentType)
+		}
+
 		token := res.Header.Get("Authorization")
-		if !strings.HasPrefix(token, "Bearer soundcork-local-token-") {
+		if !strings.HasPrefix(token, "Bearer st-local-token-") {
 			t.Errorf("Invalid token header: %s", token)
 		}
+
+		body, _ := io.ReadAll(res.Body)
+		if !strings.Contains(string(body), "<bearertoken") {
+			t.Errorf("Response body missing <bearertoken: %s", body)
+		}
+		if !strings.Contains(string(body), token) {
+			t.Errorf("Response body missing token value: %s", body)
+		}
 	})
 
 	t.Run("CustomerSupport", func(t *testing.T) {

pkg/service/handlers/handlers_media.go

@@ -14,13 +14,13 @@ var indexHTML []byte
 //go:embed web/css/* web/js/*
 var webFS embed.FS
 
-//go:embed soundcork/media/*
+//go:embed static/media/*
 var mediaFS embed.FS
 
-//go:embed soundcork/bmx_services.json
+//go:embed static/bmx_services.json
 var bmxServicesJSON []byte
 
-//go:embed soundcork/swupdate.xml
+//go:embed static/swupdate.xml
 var swUpdateXML []byte
 
 // HandleRoot returns the root endpoint response.
@@ -47,7 +47,7 @@ func (s *Server) HandleWeb() http.HandlerFunc {
 
 // HandleMedia returns a handler for serving media files.
 func (s *Server) HandleMedia() http.HandlerFunc {
-	subFS, _ := fs.Sub(mediaFS, "soundcork/media")
+	subFS, _ := fs.Sub(mediaFS, "static/media")
 
 	return func(w http.ResponseWriter, r *http.Request) {
 		fs := http.StripPrefix("/media/", http.FileServer(http.FS(subFS)))

pkg/service/handlers/handlers_media_test.go

@@ -35,8 +35,8 @@ func TestRootEndpoint(t *testing.T) {
 	}
 
 	body, _ := io.ReadAll(res.Body)
-	if !strings.Contains(string(body), "Bose SoundTouch Toolkit") {
-		t.Errorf("Expected body to contain 'Bose SoundTouch Toolkit', got %s", string(body))
+	if !strings.Contains(string(body), "AfterTouch") {
+		t.Errorf("Expected body to contain 'AfterTouch', got %s", string(body))
 	}
 }
 
@@ -80,7 +80,7 @@ func TestStaticMedia(t *testing.T) {
 	ts := httptest.NewServer(r)
 	defer ts.Close()
 
-	// Use a known file from soundcork/media
+	// Use a known file from static/media
 	res, err := http.Get(ts.URL + "/media/SiriusXM_Logo_Color.svg")
 	if err != nil {
 		t.Fatal(err)

pkg/service/handlers/handlers_proxy.go

@@ -1,6 +1,10 @@
 package handlers
 
 import (
+	"bytes"
+	"crypto/tls"
+	"io"
+	"log"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
@@ -33,33 +37,155 @@ func (s *Server) HandleProxyRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	lp := proxy.NewLoggingProxy(target.String(), s.proxyRedact)
-	lp.LogBody = s.proxyLogBody
-	lp.RecordEnabled = s.recordEnabled
-	lp.SetRecorder(s.recorder)
+	s.ServeProxy(target)(w, r)
+}
 
-	proxy := httputil.NewSingleHostReverseProxy(target)
-	// Update director to set the correct host and path
-	originalDirector := proxy.Director
-	proxy.Director = func(req *http.Request) {
-		originalDirector(req)
-		req.Host = target.Host
-		req.URL.Path = target.Path
-		req.URL.RawQuery = r.URL.RawQuery
-		lp.LogRequest(req)
-	}
+// ServeProxy returns a handler that proxies to the given target.
+func (s *Server) ServeProxy(target *url.URL) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		lp := proxy.NewLoggingProxy(target.String(), s.proxyRedact)
+		lp.LogBody = s.proxyLogBody
+		lp.RecordEnabled = s.recordEnabled
+		lp.SetRecorder(s.recorder)
 
-	proxy.ModifyResponse = func(res *http.Response) error {
-		// Generic Header Preservation
-		if etags, ok := res.Header["Etag"]; ok {
-			delete(res.Header, "Etag")
-			res.Header["ETag"] = etags
+		rp := httputil.NewSingleHostReverseProxy(target)
+		rp.Transport = &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
 		}
 
-		lp.LogResponse(res)
+		// Update director to set the correct host and path
+		originalDirector := rp.Director
+		rp.Director = func(req *http.Request) {
+			originalDirector(req)
+			req.Host = target.Host
+			// If target has a path, we should probably append or replace.
+			// For Bose upstream, it's usually just the domain.
+			if target.Path != "" && target.Path != "/" {
+				req.URL.Path = target.Path
+			}
 
-		return nil
+			lp.LogRequest(req)
+		}
+
+		rp.ModifyResponse = func(res *http.Response) error {
+			res.Header.Set("X-Proxy-Origin", "upstream")
+			// Generic Header Preservation
+			if etags, ok := res.Header["Etag"]; ok {
+				delete(res.Header, "Etag")
+				res.Header["ETag"] = etags
+			}
+
+			lp.LogResponse(res)
+
+			return nil
+		}
+
+		rp.ServeHTTP(w, r)
+	}
+}
+
+// HandleNotFound handles requests that don't match any route.
+func (s *Server) HandleNotFound(w http.ResponseWriter, r *http.Request) {
+	if s.enableSoundcorkProxy {
+		s.HandleSoundcorkWithFallback(w, r)
+		return
 	}
 
-	proxy.ServeHTTP(w, r)
+	s.HandleBoseProxy(w, r)
+}
+
+// HandleSoundcorkWithFallback tries Soundcork first, then Bose if Soundcork returns 404 or fails.
+func (s *Server) HandleSoundcorkWithFallback(w http.ResponseWriter, r *http.Request) {
+	target, _ := url.Parse(s.soundcorkURL)
+
+	// Buffer request body if any, to allow multiple proxy attempts
+	var bodyBytes []byte
+	if r.Body != nil {
+		bodyBytes, _ = io.ReadAll(r.Body)
+		_ = r.Body.Close()
+	}
+
+	// We use a custom response writer to catch 404s
+	rw := &fallbackResponseWriter{
+		ResponseWriter: w,
+		statusCode:     http.StatusOK,
+		buffer:         &bytes.Buffer{},
+	}
+
+	// Create a shallow copy of the request to avoid side effects between attempts
+	r2 := r.Clone(r.Context())
+	if bodyBytes != nil {
+		r2.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	} else {
+		r2.Body = nil
+	}
+
+	// Remove RequestURI as it's not allowed in client requests
+	r2.RequestURI = ""
+
+	s.ServeProxy(target)(rw, r2)
+
+	if rw.statusCode == http.StatusNotFound || rw.statusCode == http.StatusBadGateway || rw.statusCode == http.StatusServiceUnavailable {
+		log.Printf("[PROXY] Soundcork returned %d for %s, falling back to Bose", rw.statusCode, r.URL.Path)
+
+		if !rw.wroteHeader {
+			// Restore original body if any
+			if bodyBytes != nil {
+				r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+			}
+
+			s.HandleBoseProxy(w, r)
+		}
+	}
+}
+
+type fallbackResponseWriter struct {
+	http.ResponseWriter
+	statusCode  int
+	wroteHeader bool
+	buffer      *bytes.Buffer
+}
+
+func (rw *fallbackResponseWriter) WriteHeader(code int) {
+	rw.statusCode = code
+	if code != http.StatusNotFound && code != http.StatusBadGateway && code != http.StatusServiceUnavailable {
+		rw.wroteHeader = true
+		rw.ResponseWriter.WriteHeader(code)
+	}
+}
+
+func (rw *fallbackResponseWriter) Write(b []byte) (int, error) {
+	if rw.statusCode == http.StatusNotFound || rw.statusCode == http.StatusBadGateway || rw.statusCode == http.StatusServiceUnavailable {
+		return len(b), nil // Drop the body
+	}
+
+	rw.wroteHeader = true
+
+	return rw.ResponseWriter.Write(b)
+}
+
+// HandleBoseProxy proxies the request to the Bose upstream.
+func (s *Server) HandleBoseProxy(w http.ResponseWriter, r *http.Request) {
+	host := r.Host
+	if host == "" {
+		host = "streaming.bose.com"
+	}
+
+	// Default to HTTPS for Bose services
+	scheme := "https"
+	if strings.HasPrefix(host, "localhost") || strings.HasPrefix(host, "127.0.0.1") || strings.HasPrefix(host, "::1") {
+		scheme = "http"
+	}
+
+	targetURL := scheme + "://" + host
+
+	target, err := url.Parse(targetURL)
+	if err != nil {
+		log.Printf("[PROXY_ERR] Failed to parse target URL %s: %v", targetURL, err)
+		http.Error(w, "Invalid upstream host", http.StatusBadGateway)
+
+		return
+	}
+
+	s.ServeProxy(target)(w, r)
 }

pkg/service/handlers/handlers_setup.go

@@ -6,8 +6,11 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"strconv"
 	"time"
 
+	"fmt"
+
 	"github.com/gesellix/bose-soundtouch/pkg/models"
 	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
 	"github.com/gesellix/bose-soundtouch/pkg/service/setup"
@@ -101,10 +104,7 @@ func (s *Server) HandleRemoveDevice(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// For now we assume a default account if not specified,
-	// or we might need to find which account this device belongs to.
-	// Looking at DataStore.ListAllDevices, it returns models.ServiceDeviceInfo which has DeviceID.
-
+	// Find which account this device belongs to.
 	devices, err := s.ds.ListAllDevices()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -145,17 +145,25 @@ func (s *Server) HandleGetSettings(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	s.mu.RLock()
-	serverURL, proxyURL, httpsServerURL := s.serverURL, s.proxyURL, s.httpsServerURL
+	serverURL, soundcorkURL, httpsServerURL := s.serverURL, s.soundcorkURL, s.httpsServerURL
 	discoveryInterval := s.discoveryInterval.String()
-	discoveryDisabled := s.discoveryDisabled
+	discoveryEnabled := s.discoveryEnabled
+	enableSoundcorkProxy := s.enableSoundcorkProxy
+	redact, logBody, record := s.proxyRedact, s.proxyLogBody, s.recordEnabled
+	shortcuts := s.shortcuts
 	s.mu.RUnlock()
 
 	if err := json.NewEncoder(w).Encode(map[string]interface{}{
-		"server_url":         serverURL,
-		"proxy_url":          proxyURL,
-		"https_server_url":   httpsServerURL,
-		"discovery_interval": discoveryInterval,
-		"discovery_disabled": discoveryDisabled,
+		"server_url":             serverURL,
+		"soundcork_url":          soundcorkURL,
+		"https_server_url":       httpsServerURL,
+		"discovery_interval":     discoveryInterval,
+		"discovery_enabled":      discoveryEnabled,
+		"enable_soundcork_proxy": enableSoundcorkProxy,
+		"redact_logs":            redact,
+		"log_bodies":             logBody,
+		"record_interactions":    record,
+		"shortcuts":              shortcuts,
 	}); err != nil {
 		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
 		return
@@ -165,10 +173,12 @@ func (s *Server) HandleGetSettings(w http.ResponseWriter, _ *http.Request) {
 // HandleUpdateSettings updates the service settings.
 func (s *Server) HandleUpdateSettings(w http.ResponseWriter, r *http.Request) {
 	var settings struct {
-		ServerURL         string `json:"server_url"`
-		ProxyURL          string `json:"proxy_url"`
-		DiscoveryInterval string `json:"discovery_interval"`
-		DiscoveryDisabled bool   `json:"discovery_disabled"`
+		ServerURL            string         `json:"server_url"`
+		SoundcorkURL         string         `json:"soundcork_url"`
+		DiscoveryInterval    string         `json:"discovery_interval"`
+		DiscoveryEnabled     bool           `json:"discovery_enabled"`
+		EnableSoundcorkProxy bool           `json:"enable_soundcork_proxy"`
+		Shortcuts            map[string]int `json:"shortcuts"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&settings); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
@@ -184,12 +194,17 @@ func (s *Server) HandleUpdateSettings(w http.ResponseWriter, r *http.Request) {
 	s.mu.Lock()
 	s.serverURL = settings.ServerURL
 
-	s.proxyURL = settings.ProxyURL
+	s.soundcorkURL = settings.SoundcorkURL
 	if settings.DiscoveryInterval != "" {
 		s.discoveryInterval = interval
 	}
 
-	s.discoveryDisabled = settings.DiscoveryDisabled
+	s.discoveryEnabled = settings.DiscoveryEnabled
+
+	s.enableSoundcorkProxy = settings.EnableSoundcorkProxy
+	if settings.Shortcuts != nil {
+		s.shortcuts = settings.Shortcuts
+	}
 
 	if s.sm != nil {
 		s.sm.ServerURL = settings.ServerURL
@@ -204,14 +219,16 @@ func (s *Server) HandleUpdateSettings(w http.ResponseWriter, r *http.Request) {
 
 	log.Printf("Saving updated settings to %s/settings.json", s.ds.DataDir)
 	err = s.ds.SaveSettings(datastore.Settings{
-		ServerURL:          s.serverURL,
-		ProxyURL:           s.proxyURL,
-		HTTPServerURL:      currentHTTPS,
-		RedactLogs:         currentRedact,
-		LogBodies:          currentLogBody,
-		RecordInteractions: currentRecord,
-		DiscoveryInterval:  s.discoveryInterval.String(),
-		DiscoveryDisabled:  s.discoveryDisabled,
+		ServerURL:            s.serverURL,
+		SoundcorkURL:         s.soundcorkURL,
+		HTTPServerURL:        currentHTTPS,
+		RedactLogs:           currentRedact,
+		LogBodies:            currentLogBody,
+		RecordInteractions:   currentRecord,
+		DiscoveryInterval:    s.discoveryInterval.String(),
+		DiscoveryEnabled:     s.discoveryEnabled,
+		EnableSoundcorkProxy: s.enableSoundcorkProxy,
+		Shortcuts:            s.shortcuts,
 	})
 	s.mu.Unlock()
 
@@ -515,12 +532,13 @@ func (s *Server) HandleBackupConfig(w http.ResponseWriter, r *http.Request) {
 func (s *Server) HandleGetProxySettings(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
-	redact, logBody, record := s.GetProxySettings()
+	redact, logBody, record, enableSoundcorkProxy := s.GetProxySettings()
 
-	if err := json.NewEncoder(w).Encode(map[string]bool{
-		"redact":   redact,
-		"log_body": logBody,
-		"record":   record,
+	if err := json.NewEncoder(w).Encode(map[string]interface{}{
+		"redact":                 redact,
+		"log_body":               logBody,
+		"record":                 record,
+		"enable_soundcork_proxy": enableSoundcorkProxy,
 	}); err != nil {
 		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
 		return
@@ -545,9 +563,10 @@ func (s *Server) HandleGetCACert(w http.ResponseWriter, _ *http.Request) {
 // HandleUpdateProxySettings updates the proxy settings.
 func (s *Server) HandleUpdateProxySettings(w http.ResponseWriter, r *http.Request) {
 	var settings struct {
-		Redact  bool `json:"redact"`
-		LogBody bool `json:"log_body"`
-		Record  bool `json:"record"`
+		Redact               bool `json:"redact"`
+		LogBody              bool `json:"log_body"`
+		Record               bool `json:"record"`
+		EnableSoundcorkProxy bool `json:"enable_soundcork_proxy"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&settings); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
@@ -558,23 +577,26 @@ func (s *Server) HandleUpdateProxySettings(w http.ResponseWriter, r *http.Reques
 	s.proxyRedact = settings.Redact
 	s.proxyLogBody = settings.LogBody
 	s.recordEnabled = settings.Record
+	s.enableSoundcorkProxy = settings.EnableSoundcorkProxy
 
 	// Persist to datastore
 	// Access fields directly since we already hold the lock
-	serverURL, proxyURL, httpsServerURL := s.serverURL, s.proxyURL, s.httpsServerURL
+	serverURL, soundcorkURL, httpsServerURL := s.serverURL, s.soundcorkURL, s.httpsServerURL
 	discoveryInterval := s.discoveryInterval.String()
-	discoveryDisabled := s.discoveryDisabled
+	discoveryEnabled := s.discoveryEnabled
 
 	log.Printf("Saving updated proxy settings to %s/settings.json", s.ds.DataDir)
 	err := s.ds.SaveSettings(datastore.Settings{
-		ServerURL:          serverURL,
-		ProxyURL:           proxyURL,
-		HTTPServerURL:      httpsServerURL,
-		RedactLogs:         s.proxyRedact,
-		LogBodies:          s.proxyLogBody,
-		RecordInteractions: s.recordEnabled,
-		DiscoveryInterval:  discoveryInterval,
-		DiscoveryDisabled:  discoveryDisabled,
+		ServerURL:            serverURL,
+		SoundcorkURL:         soundcorkURL,
+		HTTPServerURL:        httpsServerURL,
+		RedactLogs:           s.proxyRedact,
+		LogBodies:            s.proxyLogBody,
+		RecordInteractions:   s.recordEnabled,
+		DiscoveryInterval:    discoveryInterval,
+		DiscoveryEnabled:     discoveryEnabled,
+		EnableSoundcorkProxy: s.enableSoundcorkProxy,
+		Shortcuts:            s.shortcuts,
 	})
 	s.mu.Unlock()
 
@@ -743,3 +765,143 @@ func (s *Server) HandleGetVersionInfo(w http.ResponseWriter, _ *http.Request) {
 		return
 	}
 }
+
+// HandleGetInteractionStats returns statistics about recorded interactions.
+func (s *Server) HandleGetInteractionStats(w http.ResponseWriter, _ *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	stats, err := s.recorder.GetInteractionStats()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(stats); err != nil {
+		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
+		return
+	}
+}
+
+// HandleListInteractions returns a list of recorded interactions.
+func (s *Server) HandleListInteractions(w http.ResponseWriter, r *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	session := r.URL.Query().Get("session")
+	category := r.URL.Query().Get("category")
+	since := r.URL.Query().Get("since")
+
+	interactions, err := s.recorder.ListInteractions(session, category, since)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	if err := json.NewEncoder(w).Encode(interactions); err != nil {
+		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
+		return
+	}
+}
+
+// HandleGetInteractionContent returns the raw content of a recorded interaction.
+func (s *Server) HandleGetInteractionContent(w http.ResponseWriter, r *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	file := r.URL.Query().Get("file")
+	if file == "" {
+		http.Error(w, "File parameter is required", http.StatusBadRequest)
+		return
+	}
+
+	content, err := s.recorder.GetInteractionContent(file)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/plain")
+	_, _ = w.Write(content)
+}
+
+// HandleDeleteSession deletes a recorded interaction session.
+func (s *Server) HandleDeleteSession(w http.ResponseWriter, r *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	session := chi.URLParam(r, "session")
+	if session == "" {
+		http.Error(w, "Session ID is required", http.StatusBadRequest)
+		return
+	}
+
+	if err := s.recorder.DeleteSession(session); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write([]byte(`{"ok": true}`))
+}
+
+// HandleCleanupSessions deletes all but the most recent N sessions.
+func (s *Server) HandleCleanupSessions(w http.ResponseWriter, r *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	keep := 10
+
+	keepStr := r.URL.Query().Get("keep")
+	if keepStr != "" {
+		if k, err := strconv.Atoi(keepStr); err == nil {
+			keep = k
+		}
+	}
+
+	if err := s.recorder.CleanupSessions(keep); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write([]byte(`{"ok": true}`))
+}
+
+// HandleDownloadSession returns a .tar.gz archive of a recorded interaction session.
+func (s *Server) HandleDownloadSession(w http.ResponseWriter, r *http.Request) {
+	if s.recorder == nil {
+		http.Error(w, "Recorder not initialized", http.StatusServiceUnavailable)
+		return
+	}
+
+	session := chi.URLParam(r, "session")
+	if session == "" {
+		http.Error(w, "Session ID is required", http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.tar.gz\"", session))
+
+	if err := s.recorder.ArchiveSession(session, w); err != nil {
+		log.Printf("Error archiving session %s: %v", session, err)
+		// Since we already set headers, if we have an error here it might be partially written.
+		// But for now, simple error handling.
+		return
+	}
+}

pkg/service/handlers/handlers_setup_test.go

@@ -98,8 +98,8 @@ func TestProxySettingsAPI(t *testing.T) {
 
 	// 3. Test System Settings POST
 	sysUpdate := map[string]string{
-		"server_url": "http://new-server:8000",
-		"proxy_url":  "http://new-proxy:8001",
+		"server_url":    "http://new-server:8000",
+		"soundcork_url": "http://new-proxy:8001",
 	}
 
 	sysBody, err := json.Marshal(sysUpdate)
@@ -121,7 +121,7 @@ func TestProxySettingsAPI(t *testing.T) {
 	// Verify server state
 	sURL, pURL, _ := server.GetSettings()
 	if sURL != "http://new-server:8000" || pURL != "http://new-proxy:8001" {
-		t.Errorf("POST /setup/settings: Server state did not update: serverURL=%s, proxyURL=%s", sURL, pURL)
+		t.Errorf("POST /setup/settings: Server state did not update: serverURL=%s, soundcorkURL=%s", sURL, pURL)
 	}
 }
 
@@ -262,7 +262,7 @@ func TestRemoveDevice(t *testing.T) {
 	// Setup a dummy device in the datastore
 	account := "test-account"
 	deviceID := "TEST-DEVICE-ID"
-	deviceDir := filepath.Join(tempDir, account, "devices", deviceID)
+	deviceDir := filepath.Join(tempDir, "accounts", account, "devices", deviceID)
 	if err := os.MkdirAll(deviceDir, 0755); err != nil {
 		t.Fatalf("Failed to create device dir: %v", err)
 	}

pkg/service/handlers/handlers_stats.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/go-chi/chi/v5"
 )
 
 // HandleUsageStats handles Marge usage stats uploads.
@@ -49,6 +50,42 @@ func (s *Server) HandleUsageStats(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
+// HandleAppEvents handles events from the Bose SoundTouch app (stapp/scmudc).
+func (s *Server) HandleAppEvents(w http.ResponseWriter, r *http.Request) {
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, "Failed to read body", http.StatusBadRequest)
+		return
+	}
+
+	var req models.DeviceEventsRequest
+	if err := json.Unmarshal(body, &req); err != nil {
+		http.Error(w, "Invalid app events format", http.StatusBadRequest)
+		return
+	}
+
+	deviceID := req.Envelope.UniqueID
+	if deviceID == "" {
+		deviceID = chi.URLParam(r, "deviceId")
+	}
+
+	for _, e := range req.Payload.Events {
+		event := models.DeviceEvent{
+			Type:     e.Type,
+			Time:     e.Time,
+			MonoTime: req.Envelope.MonoTime,
+			Data:     e.Data,
+		}
+		if event.Time == "" {
+			event.Time = time.Now().Format(time.RFC3339)
+		}
+
+		s.ds.AddDeviceEvent(deviceID, event)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
 // HandleErrorStats handles Marge error stats uploads.
 func (s *Server) HandleErrorStats(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)

pkg/service/handlers/handlers_stats_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestStatsHandlers(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "soundcork-test-*")
+	tempDir, err := os.MkdirTemp("", "st-test-*")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -63,4 +63,44 @@ func TestStatsHandlers(t *testing.T) {
 			t.Error("Error stats file was not created")
 		}
 	})
+
+	t.Run("HandleAppEvents", func(t *testing.T) {
+		jsonData := `{
+			"envelope": {
+				"monoTime": 12345,
+				"payloadProtocolVersion": "3.1",
+				"payloadType": "stapp",
+				"protocolVersion": "1.0",
+				"time": "2023-10-27T10:00:00Z",
+				"uniqueId": "device789"
+			},
+			"payload": {
+				"deviceInfo": {
+					"deviceID": "device789"
+				},
+				"events": [
+					{
+						"type": "APP_OPEN",
+						"time": "2023-10-27T10:00:01Z",
+						"data": {"foo": "bar"}
+					}
+				]
+			}
+		}`
+		req := httptest.NewRequest("POST", "/v1/stapp/device789", bytes.NewBufferString(jsonData))
+		w := httptest.NewRecorder()
+
+		s.HandleAppEvents(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("Expected status OK, got %d", w.Code)
+		}
+
+		events := ds.GetDeviceEvents("device789")
+		if len(events) == 0 {
+			t.Error("App events were not recorded")
+		} else if events[0].Type != "APP_OPEN" {
+			t.Errorf("Expected event type APP_OPEN, got %s", events[0].Type)
+		}
+	})
 }

pkg/service/handlers/interactions_test.go

@@ -0,0 +1,161 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
+	"github.com/gesellix/bose-soundtouch/pkg/service/proxy"
+	"github.com/go-chi/chi/v5"
+)
+
+func TestInteractionHandlers(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "interaction-handlers-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	ds := datastore.NewDataStore(filepath.Join(tmpDir, "test.db"))
+	server := &Server{ds: ds}
+
+	t.Run("HandleGetInteractionStats_NoRecorder", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/setup/interaction-stats", nil)
+		w := httptest.NewRecorder()
+		server.HandleGetInteractionStats(w, req)
+		if w.Code != http.StatusServiceUnavailable {
+			t.Errorf("Expected status 503, got %d", w.Code)
+		}
+	})
+
+	recorder := proxy.NewRecorder(tmpDir)
+	server.SetRecorder(recorder)
+
+	// Create a dummy interaction file
+	sessionID := recorder.SessionID
+	relPath := filepath.Join(sessionID, "self", "test", "0001-12-00-00.000-GET.http")
+	fullPath := filepath.Join(tmpDir, "interactions", relPath)
+	os.MkdirAll(filepath.Dir(fullPath), 0755)
+	os.WriteFile(fullPath, []byte("### GET /test\n\n> {% \n    // Response: 200 OK\n%}\n"), 0644)
+
+	r := chi.NewRouter()
+	r.Route("/setup", func(r chi.Router) {
+		r.Get("/interaction-stats", server.HandleGetInteractionStats)
+		r.Get("/interactions", server.HandleListInteractions)
+		r.Get("/interaction-content", server.HandleGetInteractionContent)
+	})
+
+	t.Run("HandleGetInteractionStats", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/setup/interaction-stats", nil)
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("Expected status 200, got %d", w.Code)
+		}
+
+		var stats proxy.InteractionStats
+		if err := json.NewDecoder(w.Body).Decode(&stats); err != nil {
+			t.Fatalf("Failed to decode stats: %v", err)
+		}
+
+		if stats.TotalRequests != 1 {
+			t.Errorf("Expected 1 total request, got %d", stats.TotalRequests)
+		}
+	})
+
+	t.Run("HandleListInteractions", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/setup/interactions?category=self", nil)
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("Expected status 200, got %d", w.Code)
+		}
+
+		var interactions []proxy.Interaction
+		if err := json.NewDecoder(w.Body).Decode(&interactions); err != nil {
+			t.Fatalf("Failed to decode interactions: %v", err)
+		}
+
+		if len(interactions) != 1 {
+			t.Errorf("Expected 1 interaction, got %d", len(interactions))
+		}
+	})
+
+	t.Run("HandleGetInteractionContent", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/setup/interaction-content?file="+relPath, nil)
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+
+		if w.Code != http.StatusOK {
+			t.Errorf("Expected status 200, got %d", w.Code)
+		}
+
+		if !strings.Contains(w.Body.String(), "### GET /test") {
+			t.Errorf("Unexpected content: %s", w.Body.String())
+		}
+	})
+
+	t.Run("HandleGetInteractionContent_MissingFile", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/setup/interaction-content", nil)
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+		if w.Code != http.StatusBadRequest {
+			t.Errorf("Expected status 400, got %d", w.Code)
+		}
+	})
+}
+
+func TestRecordMiddleware(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "record-middleware-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	ds := datastore.NewDataStore(filepath.Join(tmpDir, "test.db"))
+	server := &Server{
+		ds:            ds,
+		recordEnabled: true,
+	}
+	recorder := proxy.NewRecorder(tmpDir)
+	server.SetRecorder(recorder)
+
+	r := chi.NewRouter()
+	r.Use(server.RecordMiddleware)
+	r.Get("/test-middleware", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("X-Test", "Value")
+		w.WriteHeader(http.StatusCreated)
+		w.Write([]byte("created"))
+
+		if f, ok := w.(http.Flusher); ok {
+			f.Flush()
+		}
+	})
+
+	req := httptest.NewRequest("GET", "/test-middleware", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusCreated {
+		t.Errorf("Expected status 201, got %d", w.Code)
+	}
+
+	t.Run("HandleRecordMiddleware_Disabled", func(t *testing.T) {
+		server.recordEnabled = false
+		req := httptest.NewRequest("GET", "/test-middleware", nil)
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+		if w.Code != http.StatusCreated {
+			t.Errorf("Expected status 201, got %d", w.Code)
+		}
+	})
+}

pkg/service/handlers/main_test.go

@@ -1,19 +1,19 @@
 package handlers
 
 import (
-	"net/http"
-	"net/url"
-
 	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
 	"github.com/go-chi/chi/v5"
 )
 
 func setupRouter(targetURL string, ds *datastore.DataStore) (*chi.Mux, *Server) {
-	target, _ := url.Parse(targetURL)
-	proxy := &reverseProxy{target: target}
-	server := &Server{ds: ds}
+	server := NewServer(ds, nil, "http://localhost:8000", false, false, false, false)
+	server.SetSoundcorkURL(targetURL)
 
 	r := chi.NewRouter()
+	r.Use(server.OriginMiddleware)
+	r.Use(server.ShortcutMiddleware)
+	r.Use(server.RecordMiddleware)
+
 	r.Get("/", server.HandleRoot)
 
 	// Setup media and web directories for tests
@@ -29,6 +29,13 @@ func setupRouter(targetURL string, ds *datastore.DataStore) (*chi.Mux, *Server)
 		r.Post("/orion/v1/playback/station/{data}", server.HandleOrionPlayback)
 	})
 
+	// Legacy or direct domain calls without /bmx prefix
+	r.Get("/registry/v1/services", server.HandleBMXRegistry)
+	r.Get("/tunein/v1/playback/station/{stationID}", server.HandleTuneInPlayback)
+	r.Get("/tunein/v1/playback/episodes/{podcastID}", server.HandleTuneInPodcastInfo)
+	r.Get("/tunein/v1/playback/episode/{podcastID}", server.HandleTuneInPlaybackPodcast)
+	r.Post("/orion/v1/playback/station/{data}", server.HandleOrionPlayback)
+
 	// Setup Marge for tests
 	r.Route("/marge", func(r chi.Router) {
 		r.Get("/streaming/sourceproviders", server.HandleMargeSourceProviders)
@@ -43,6 +50,33 @@ func setupRouter(targetURL string, ds *datastore.DataStore) (*chi.Mux, *Server)
 		r.Get("/streaming/account/{account}/provider_settings", server.HandleMargeProviderSettings)
 		r.Get("/streaming/device/{device}/streaming_token", server.HandleMargeStreamingToken)
 		r.Post("/streaming/support/customersupport", server.HandleMargeCustomerSupport)
+		r.Get("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeGetDeviceSettings)
+		r.Post("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeUpdateDeviceSettings)
+		r.Get("/streaming/account/{account}/emailaddress", server.HandleMargeGetEmailAddress)
+	})
+
+	// Legacy or direct domain calls without /marge prefix
+	r.Get("/streaming/sourceproviders", server.HandleMargeSourceProviders)
+	r.Get("/accounts/{account}/full", server.HandleMargeAccountFull)
+	r.Post("/streaming/support/power_on", server.HandleMargePowerOn)
+	r.Get("/updates/soundtouch", server.HandleMargeSoftwareUpdate)
+	r.Get("/accounts/{account}/devices/{device}/presets", server.HandleMargePresets)
+	r.Post("/accounts/{account}/devices/{device}/presets/{presetNumber}", server.HandleMargeUpdatePreset)
+	r.Post("/accounts/{account}/devices/{device}/recents", server.HandleMargeAddRecent)
+	r.Post("/accounts/{account}/devices", server.HandleMargeAddDevice)
+	r.Delete("/accounts/{account}/devices/{device}", server.HandleMargeRemoveDevice)
+	r.Get("/streaming/account/{account}/provider_settings", server.HandleMargeProviderSettings)
+	r.Get("/streaming/device/{device}/streaming_token", server.HandleMargeStreamingToken)
+	r.Post("/streaming/support/customersupport", server.HandleMargeCustomerSupport)
+	r.Get("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeGetDeviceSettings)
+	r.Post("/streaming/device_setting/account/{account}/device/{device}/device_settings", server.HandleMargeUpdateDeviceSettings)
+	r.Get("/streaming/account/{account}/emailaddress", server.HandleMargeGetEmailAddress)
+
+	// Setup Customer for tests
+	r.Route("/customer", func(r chi.Router) {
+		r.Get("/account/{account}", server.HandleMargeAccountProfile)
+		r.Post("/account/{account}", server.HandleMargeUpdateAccountProfile)
+		r.Post("/account/{account}/password", server.HandleMargeChangePassword)
 	})
 
 	// Setup Setup for tests
@@ -64,19 +98,12 @@ func setupRouter(targetURL string, ds *datastore.DataStore) (*chi.Mux, *Server)
 		r.Get("/ca.crt", server.HandleGetCACert)
 	})
 
-	r.NotFound(func(w http.ResponseWriter, r *http.Request) {
-		proxy.ServeHTTP(w, r)
-	})
+	r.NotFound(server.HandleNotFound)
 
 	return r, server
 }
 
-type reverseProxy struct {
-	target *url.URL
-}
-
-func (p *reverseProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Simplified proxy for testing
-	w.WriteHeader(http.StatusAccepted) // Custom status to identify proxy hit in tests
-	_, _ = w.Write([]byte("Proxied to " + p.target.String()))
+func init() {
+	// Silence logger for tests
+	// log.SetOutput(io.Discard)
 }

pkg/service/handlers/origin_middleware.go

@@ -0,0 +1,27 @@
+package handlers
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+// OriginMiddleware returns a middleware that logs whether the request was handled "self" or "upstream".
+func (s *Server) OriginMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+
+		ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+
+		next.ServeHTTP(ww, r)
+
+		origin := "self"
+		if ww.Header().Get("X-Proxy-Origin") != "" {
+			origin = "upstream"
+		}
+
+		log.Printf("[LOG] %s %s | %d | %s | %v", r.Method, r.URL.Path, ww.Status(), origin, time.Since(start))
+	})
+}

pkg/service/handlers/server.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"context"
 	"log"
+	"net/http"
 	"sync"
 	"time"
 
@@ -15,36 +16,39 @@ import (
 
 // Server handles HTTP requests for the SoundTouch service.
 type Server struct {
-	ds                *datastore.DataStore
-	sm                *setup.Manager
-	mu                sync.RWMutex
-	serverURL         string
-	proxyURL          string
-	httpsServerURL    string
-	discovering       bool
-	proxyRedact       bool
-	proxyLogBody      bool
-	recordEnabled     bool
-	discoveryInterval time.Duration
-	discoveryDisabled bool
-	shortcuts         map[string]int
-	recorder          *proxy.Recorder
-	Version           string
-	Commit            string
-	Date              string
+	ds                   *datastore.DataStore
+	sm                   *setup.Manager
+	mu                   sync.RWMutex
+	serverURL            string
+	soundcorkURL         string
+	httpsServerURL       string
+	discovering          bool
+	proxyRedact          bool
+	proxyLogBody         bool
+	recordEnabled        bool
+	discoveryInterval    time.Duration
+	discoveryEnabled     bool
+	enableSoundcorkProxy bool
+	shortcuts            map[string]int
+	recorder             *proxy.Recorder
+	UpstreamProxy        http.Handler
+	Version              string
+	Commit               string
+	Date                 string
 }
 
 // NewServer creates a new SoundTouch service server.
-func NewServer(ds *datastore.DataStore, sm *setup.Manager, serverURL string, proxyRedact, proxyLogBody, recordEnabled bool) *Server {
+func NewServer(ds *datastore.DataStore, sm *setup.Manager, serverURL string, proxyRedact, proxyLogBody, recordEnabled, enableSoundcorkProxy bool) *Server {
 	return &Server{
-		ds:                ds,
-		sm:                sm,
-		serverURL:         serverURL,
-		proxyURL:          serverURL,
-		proxyRedact:       proxyRedact,
-		proxyLogBody:      proxyLogBody,
-		recordEnabled:     recordEnabled,
-		discoveryInterval: 5 * time.Minute,
+		ds:                   ds,
+		sm:                   sm,
+		serverURL:            serverURL,
+		soundcorkURL:         "http://localhost:8001",
+		proxyRedact:          proxyRedact,
+		proxyLogBody:         proxyLogBody,
+		recordEnabled:        recordEnabled,
+		enableSoundcorkProxy: enableSoundcorkProxy,
+		discoveryInterval:    5 * time.Minute,
 	}
 }
 
@@ -59,12 +63,12 @@ func (s *Server) SetVersionInfo(version, commit, date string) {
 }
 
 // SetDiscoverySettings sets the discovery settings for the server.
-func (s *Server) SetDiscoverySettings(interval time.Duration, disabled bool) {
+func (s *Server) SetDiscoverySettings(interval time.Duration, enabled bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	s.discoveryInterval = interval
-	s.discoveryDisabled = disabled
+	s.discoveryEnabled = enabled
 }
 
 // SetShortcuts sets the request shortcuts for the server.
@@ -88,7 +92,7 @@ func (s *Server) GetDiscoverySettings() (time.Duration, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	return s.discoveryInterval, s.discoveryDisabled
+	return s.discoveryInterval, s.discoveryEnabled
 }
 
 // SetHTTPServerURL sets the external HTTPS URL of the service.
@@ -99,6 +103,14 @@ func (s *Server) SetHTTPServerURL(url string) {
 	s.httpsServerURL = url
 }
 
+// SetSoundcorkURL sets the URL for the Soundcork backend.
+func (s *Server) SetSoundcorkURL(url string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.soundcorkURL = url
+}
+
 // SetRecorder sets the recorder for the server.
 func (s *Server) SetRecorder(r *proxy.Recorder) {
 	s.recorder = r
@@ -117,15 +129,15 @@ func (s *Server) GetSettings() (string, string, string) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	return s.serverURL, s.proxyURL, s.httpsServerURL
+	return s.serverURL, s.soundcorkURL, s.httpsServerURL
 }
 
 // GetProxySettings returns the current proxy settings.
-func (s *Server) GetProxySettings() (bool, bool, bool) {
+func (s *Server) GetProxySettings() (bool, bool, bool, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
-	return s.proxyRedact, s.proxyLogBody, s.recordEnabled
+	return s.proxyRedact, s.proxyLogBody, s.recordEnabled, s.enableSoundcorkProxy
 }
 
 // DiscoverDevices starts a background device discovery process.
@@ -186,8 +198,33 @@ func (s *Server) handleDiscoveredDevice(d models.DiscoveredDevice) {
 		deviceID = d.Host
 	}
 
+	accountID := ""
+
+	if liveInfo, err := s.sm.GetLiveDeviceInfo(d.Host); err == nil {
+		if liveInfo.MargeAccountUUID != "" {
+			accountID = liveInfo.MargeAccountUUID
+		}
+
+		if liveInfo.SerialNumber != "" {
+			d.SerialNo = liveInfo.SerialNumber
+			deviceID = d.SerialNo
+		}
+	}
+
+	if accountID == "" {
+		// Try to find account ID from existing device entries if live info failed
+		if existing := s.findExistingDeviceInfo(d); existing != nil {
+			accountID = existing.AccountID
+		}
+	}
+
+	if accountID == "" {
+		accountID = "default"
+	}
+
 	info := &models.ServiceDeviceInfo{
-		DeviceID:           d.SerialNo,
+		DeviceID:           deviceID,
+		AccountID:          accountID,
 		Name:               d.Name,
 		IPAddress:          d.Host,
 		DeviceSerialNumber: d.SerialNo,
@@ -199,10 +236,10 @@ func (s *Server) handleDiscoveredDevice(d models.DiscoveredDevice) {
 	// If we had an IP-based entry and now have a Serial, clean up the IP-based entry
 	if d.SerialNo != "" && existingID != "" && existingID != d.SerialNo {
 		log.Printf("Device %s previously known as %s, migrating to serial-based ID %s", d.Name, existingID, d.SerialNo)
-		_ = s.ds.RemoveDevice("default", existingID)
+		_ = s.ds.RemoveDevice(accountID, existingID)
 	}
 
-	if err := s.ds.SaveDeviceInfo("default", deviceID, info); err != nil {
+	if err := s.ds.SaveDeviceInfo(accountID, deviceID, info); err != nil {
 		log.Printf("Failed to save device info: %v", err)
 	}
 }
@@ -233,15 +270,24 @@ func (s *Server) mergeOverlappingDevices() {
 		var master *models.ServiceDeviceInfo
 
 		for i := range devices {
-			if devices[i].DeviceSerialNumber != "" || devices[i].DeviceID != "" {
+			if devices[i].DeviceSerialNumber != "" {
 				master = &devices[i]
 				break
 			}
 		}
 
 		if master == nil {
-			// None have serials, just keep the first one (already handled by ListAllDevices unique check usually,
-			// but ListAllDevices might see different AccountIDs or directories)
+			// Fallback: look for one with DeviceID that isn't the IP
+			for i := range devices {
+				if devices[i].DeviceID != "" && devices[i].DeviceID != devices[i].IPAddress {
+					master = &devices[i]
+					break
+				}
+			}
+		}
+
+		if master == nil {
+			// None have serials, just keep the first one
 			continue
 		}
 
@@ -267,26 +313,27 @@ func (s *Server) mergeOverlappingDevices() {
 }
 
 func (s *Server) findExistingDeviceID(d models.DiscoveredDevice) string {
+	info := s.findExistingDeviceInfo(d)
+	if info != nil {
+		return info.DeviceID
+	}
+
+	return ""
+}
+
+func (s *Server) findExistingDeviceInfo(d models.DiscoveredDevice) *models.ServiceDeviceInfo {
 	allDevices, _ := s.ds.ListAllDevices()
 	for i := range allDevices {
 		known := allDevices[i]
 		// Match by Serial
 		if d.SerialNo != "" && (known.DeviceID == d.SerialNo || known.DeviceSerialNumber == d.SerialNo) {
-			if known.DeviceID != "" {
-				return known.DeviceID
-			}
-
-			return known.IPAddress
+			return &known
 		}
 		// Match by IP
 		if d.Host != "" && known.IPAddress == d.Host {
-			if known.DeviceID != "" {
-				return known.DeviceID
-			}
-
-			return known.IPAddress
+			return &known
 		}
 	}
 
-	return ""
+	return nil
 }

pkg/service/handlers/server_merge_test.go

@@ -24,8 +24,11 @@ func TestMergeOverlappingDevices(t *testing.T) {
 
 	// 1. Save IP-based entry
 	infoIP := &models.ServiceDeviceInfo{
-		Name:      "Speaker IP",
-		IPAddress: ip,
+		DeviceID:    ip,
+		Name:        "Speaker IP",
+		IPAddress:   ip,
+		AccountID:   "default",
+		ProductCode: "ST10",
 	}
 	err = ds.SaveDeviceInfo("default", ip, infoIP)
 	if err != nil {
@@ -38,6 +41,8 @@ func TestMergeOverlappingDevices(t *testing.T) {
 		DeviceSerialNumber: serial,
 		Name:               "Speaker Serial",
 		IPAddress:          ip,
+		AccountID:          "default",
+		ProductCode:        "ST10",
 	}
 	err = ds.SaveDeviceInfo("default", serial, infoSerial)
 	if err != nil {
@@ -76,8 +81,11 @@ func TestFindExistingDeviceID(t *testing.T) {
 
 	// Save IP-based
 	ds.SaveDeviceInfo("default", ip, &models.ServiceDeviceInfo{
-		IPAddress: ip,
-		Name:      "IP Speaker",
+		DeviceID:    ip,
+		IPAddress:   ip,
+		Name:        "IP Speaker",
+		AccountID:   "default",
+		ProductCode: "ST10",
 	})
 
 	// Test finding by IP
@@ -94,6 +102,8 @@ func TestFindExistingDeviceID(t *testing.T) {
 		DeviceSerialNumber: serial,
 		IPAddress:          ip,
 		Name:               "Serial Speaker",
+		AccountID:          "default",
+		ProductCode:        "ST10",
 	})
 
 	// Test finding by IP should now return Serial (if Serial is known)

pkg/service/handlers/static/media/favicon.md

@@ -1,6 +1,6 @@
 # Favicon Meanings
 
-This directory contains favicons for the Soundcork project in various formats (SVG, PNG, ICO). The icons use Morse code and Braille to represent the initials **S** (Sound) and **T** (Touch).
+This directory contains favicons for the service in various formats (SVG, PNG, ICO). The icons use Morse code and Braille to represent the initials **S** (Sound) and **T** (Touch).
 
 ## Morse Variant (`favicon-morse.*`)
 The icon represents the letters **S** and **T** in international Morse code:

pkg/service/handlers/web/css/style.css

@@ -4,7 +4,7 @@ th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
 th { background-color: #f2f2f2; }
 button { padding: 5px 10px; cursor: pointer; }
 .status { margin-top: 10px; padding: 10px; border: 1px solid #ccc; display: none; }
-.summary-box { margin-top: 20px; padding: 15px; border: 1px solid #aaa; background-color: #f9f9f9; display: none; }
+.summary-box { margin-top: 20px; padding: 15px; border: 1px solid #aaa; background-color: #f9f9f9; }
 pre { background-color: #eee; padding: 10px; overflow-x: auto; font-size: 12px; }
 .diff-container { display: flex; gap: 10px; }
 .diff-pane { flex: 1; min-width: 0; }
@@ -76,3 +76,36 @@ pre { background-color: #eee; padding: 10px; overflow-x: auto; font-size: 12px;
 .btn-danger:hover {
     background-color: #d32f2f;
 }
+
+.badge {
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-size: 0.85em;
+    font-weight: bold;
+}
+.stats-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+.stats-list li {
+    padding: 5px 0;
+    border-bottom: 1px solid #f0f0f0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+.stats-list li:last-child {
+    border-bottom: none;
+}
+.category-self { background-color: #e3f2fd; color: #0d47a1; }
+.category-upstream { background-color: #f3e5f5; color: #7b1fa2; }
+.status-success { background-color: #e8f5e9; color: #2e7d32; }
+.status-error { background-color: #ffebee; color: #c62828; }
+
+.badge {
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 0.8em;
+    font-weight: bold;
+}

pkg/service/handlers/web/index.html

@@ -2,12 +2,13 @@
 <html>
 <head>
     <meta charset="UTF-8">
-    <title>Bose SoundTouch Toolkit</title>
+    <title>AfterTouch (SoundTouch Toolkit)</title>
     <link rel="icon" href="/media/favicon-braille.svg" type="image/svg+xml">
     <link rel="stylesheet" href="/web/css/style.css">
 </head>
 <body>
-    <h1>Bose SoundTouch Toolkit</h1>
+    <h1>AfterTouch</h1>
+    <p style="margin-top: -10px; font-style: italic; color: #666;">Bose SoundTouch Toolkit</p>
 
     <div class="tabs">
         <div class="tab-buttons">
@@ -16,11 +17,12 @@
             <button class="tab-btn" onclick="openTab(event, 'tab-devices')">2. Devices</button>
             <button class="tab-btn" onclick="openTab(event, 'tab-sync')">3. Data Sync</button>
             <button class="tab-btn" onclick="openTab(event, 'tab-migration')">4. Migration</button>
+            <button class="tab-btn" onclick="openTab(event, 'tab-interactions')">5. Interactions & Events</button>
         </div>
 
         <!-- Tab 0: Overview -->
         <div id="tab-overview" class="tab-content active">
-            <h2>Welcome to Bose SoundTouch Toolkit</h2>
+            <h2>Welcome to AfterTouch</h2>
             <p>This toolkit helps you keep your Bose SoundTouch speakers functional even after the Bose Cloud shutdown in May 2026. It emulates the necessary cloud services locally on your network.</p>
 
             <h3>Migration Process at a Glance</h3>
@@ -60,14 +62,14 @@
 
             <div class="info-box safety-box">
                 <strong>⚠️ Safety First:</strong> Before starting any migration, please read our
-                <a href="https://gesellix.github.io/Bose-SoundTouch/guides/MIGRATION-SAFETY.md" target="_blank">Professional Migration & Safety Guide</a>.
+                <a href="https://gesellix.github.io/Bose-SoundTouch/guides/MIGRATION-SAFETY.html" target="_blank">Professional Migration & Safety Guide</a>.
                 The toolkit automatically creates backups, but understanding the process is key to a smooth transition.
             </div>
 
             <h3>Useful Links</h3>
             <ul>
-                <li><a href="https://gesellix.github.io/Bose-SoundTouch/guides/SURVIVAL-GUIDE.md" target="_blank">Cloud Shutdown Survival Guide</a></li>
-                <li><a href="https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.md" target="_blank">CLI Reference</a></li>
+                <li><a href="https://gesellix.github.io/Bose-SoundTouch/guides/SURVIVAL-GUIDE.html" target="_blank">Cloud Shutdown Survival Guide</a></li>
+                <li><a href="https://gesellix.github.io/Bose-SoundTouch/guides/CLI-REFERENCE.html" target="_blank">CLI Reference</a></li>
             </ul>
         </div>
 
@@ -85,24 +87,30 @@
                 <span style="font-size: 0.8em; color: #666;">(Standard services URL)</span>
             </div>
             <div style="margin-bottom: 20px;">
-                <label for="proxy-domain">Proxy Domain:</label>
-                <input type="text" id="proxy-domain" placeholder="http://192.168.x.x:8000" style="width: 300px;">
-                <span style="font-size: 0.8em; color: #666;">(Upstream proxy URL)</span>
+                <label for="soundcork-url">Soundcork URL:</label>
+                <input type="text" id="soundcork-url" placeholder="http://192.168.x.x:8001" style="width: 300px;">
+                <span style="font-size: 0.8em; color: #666;">(Soundcork services URL)</span>
             </div>
             <div style="margin-bottom: 20px;">
                 <label for="discovery-interval">Discovery Interval:</label>
                 <input type="text" id="discovery-interval" placeholder="5m" style="width: 100px;">
-                <label style="margin-left: 15px;"><input type="checkbox" id="discovery-disabled"> Disable Automated Discovery</label>
+                <label style="margin-left: 15px;"><input type="checkbox" id="discovery-enabled"> Enable Automated Discovery</label>
             </div>
             <div style="margin-bottom: 20px;">
                 <button onclick="updateSettings()">Save Settings</button>
                 <span id="settings-status" style="margin-left: 10px; font-size: 0.9em;"></span>
             </div>
             <div style="margin-bottom: 20px;">
-                Proxy Logging:
-                <label><input type="checkbox" id="proxy-redact" onchange="updateProxySettings()"> Redact Sensitive Headers</label>
-                <label style="margin-left: 15px;"><input type="checkbox" id="proxy-log-body" onchange="updateProxySettings()"> Log Bodies</label>
-                <label style="margin-left: 15px;"><input type="checkbox" id="proxy-record" onchange="updateProxySettings()"> Record Interactions</label>
+                <strong>Proxy Logging:</strong>
+                <div style="margin-top: 5px;">
+                    <label style="display: block; margin-bottom: 5px;"><input type="checkbox" id="proxy-redact" onchange="updateProxySettings()"> Redact Sensitive Headers</label>
+                    <label style="display: block; margin-bottom: 5px;"><input type="checkbox" id="proxy-log-body" onchange="updateProxySettings()"> Log Bodies</label>
+                    <label style="display: block; margin-bottom: 5px;"><input type="checkbox" id="enable-soundcork-proxy" onchange="updateProxySettings()"> Enable Soundcork Proxy (Legacy)</label>
+                    <label style="display: block; margin-bottom: 5px;">
+                        <input type="checkbox" id="proxy-record" onchange="updateProxySettings()"> Record Interactions
+                        <span style="font-size: 0.85em; color: #666; margin-left: 5px;">(View in <strong>5. Interactions</strong> tab)</span>
+                    </label>
+                </div>
             </div>
         </div>
 
@@ -154,11 +162,12 @@
 
             <div id="migration-summary" class="summary-box" style="display: none;">
                 <h3>Migration Summary for <span id="summary-ip"></span></h3>
+                <p>Migration Status: <span id="migration-status"></span></p>
                 <p>SSH Connection: <span id="ssh-status"></span></p>
                 <p id="original-config-status" style="display: none;">Backup: ✅ Found .original config at <code>/opt/Bose/etc/SoundTouchSdkPrivateCfg.xml.original</code> <button onclick="toggleOriginalConfig()">Show Original Config</button></p>
                 <p id="no-original-config-status" style="display: none;">Backup: ❌ Not found <button id="backup-config-btn">Backup Config Now</button></p>
                 <p>Remote Services Enabled: <span id="remote-services-status"></span> <span id="remote-services-found" style="font-size: 0.8em; color: #666;"></span></p>
-                <p>Local Root CA Trusted: <span id="ca-trust-status"></span> <button id="trust-ca-btn" style="display: none; background-color: #607D8B; color: white; border: none; padding: 2px 8px; font-size: 0.8em; margin-left: 10px;">Trust CA Now</button></p>
+                <p>AfterTouch Local Root CA Trusted: <span id="ca-trust-status"></span> <button id="trust-ca-btn" style="display: none; background-color: #607D8B; color: white; border: none; padding: 2px 8px; font-size: 0.8em; margin-left: 10px;">Trust CA Now</button></p>
 
                 <div id="connection-test" style="margin: 15px 0; padding: 10px; border: 1px solid #ddd; background-color: #eefbff;">
                     <strong>HTTPS Connection Test:</strong><br>
@@ -207,8 +216,8 @@
                             <td id="orig-marge">loading...</td>
                             <td>
                                 <select id="opt-marge" onchange="refreshSummary()">
-                                    <option value="soundcork">Soundcork (Go/Python)</option>
-                                    <option value="original">Original (Proxy via soundcork-go)</option>
+                                    <option value="self">AfterTouch (Local Service)</option>
+                                    <option value="upstream">Upstream (Proxy via local service)</option>
                                 </select>
                             </td>
                         </tr>
@@ -217,8 +226,8 @@
                             <td id="orig-stats">loading...</td>
                             <td>
                                 <select id="opt-stats" onchange="refreshSummary()">
-                                    <option value="soundcork">Soundcork (Go/Python)</option>
-                                    <option value="original">Original (Proxy via soundcork-go)</option>
+                                    <option value="self">AfterTouch (Local Service)</option>
+                                    <option value="upstream">Upstream (Proxy via local service)</option>
                                 </select>
                             </td>
                         </tr>
@@ -227,8 +236,8 @@
                             <td id="orig-sw_update">loading...</td>
                             <td>
                                 <select id="opt-sw_update" onchange="refreshSummary()">
-                                    <option value="soundcork">Soundcork (Go/Python)</option>
-                                    <option value="original">Original (Proxy via soundcork-go)</option>
+                                    <option value="self">AfterTouch (Local Service)</option>
+                                    <option value="upstream">Upstream (Proxy via local service)</option>
                                 </select>
                             </td>
                         </tr>
@@ -237,8 +246,8 @@
                             <td id="orig-bmx">loading...</td>
                             <td>
                                 <select id="opt-bmx" onchange="refreshSummary()">
-                                    <option value="soundcork">Soundcork (Go/Python)</option>
-                                    <option value="original">Original (Proxy via soundcork-go)</option>
+                                    <option value="self">AfterTouch (Local Service)</option>
+                                    <option value="upstream">Upstream (Proxy via local service)</option>
                                 </select>
                             </td>
                         </tr>
@@ -251,14 +260,14 @@
                         <pre id="current-config"></pre>
                     </div>
                     <div id="planned-xml-pane" class="diff-pane">
-                        <span class="config-header">Planned Config (Soundcork)</span>
+                        <span class="config-header">Planned Config (AfterTouch)</span>
                         <pre id="planned-config"></pre>
                     </div>
                     <div id="planned-hosts-pane" class="diff-pane" style="display: none;">
                         <span class="config-header">Planned /etc/hosts Entries</span>
                         <pre id="planned-hosts"></pre>
                         <div style="margin-top: 10px; font-size: 0.9em; color: #666;">
-                            <strong>Note:</strong> This method also injects the local Root CA into <code>/etc/pki/tls/certs/ca-bundle.crt</code> to enable secure HTTPS communication.
+                            <strong>Note:</strong> This method also injects the AfterTouch Local Root CA into <code>/etc/pki/tls/certs/ca-bundle.crt</code> to enable secure HTTPS communication.
                         </div>
                     </div>
                 </div>
@@ -272,11 +281,122 @@
                 </div>
             </div>
         </div>
+
+        <!-- Tab 5: Interactions & Events -->
+        <div id="tab-interactions" class="tab-content">
+            <h2>Recorded Interactions & Device Events</h2>
+            <p>Analysis of traffic handled by this service (self), proxied to Bose (upstream), and internal device events (telemetry).</p>
+
+            <div id="interaction-stats-container" class="summary-box">
+                <div style="display: flex; gap: 20px; align-items: center; margin-bottom: 15px;">
+                    <p style="margin: 0;">Total Requests: <strong id="total-requests">0</strong></p>
+                    <button onclick="fetchInteractionStats()">Refresh Stats</button>
+                    <div style="margin-left: 10px;">
+                        <button onclick="showDeviceEvents()">View App/Device Events</button>
+                    </div>
+                    <div style="margin-left: auto; text-align: right;">
+                        <button onclick="cleanupSessions()" class="btn-danger">Cleanup old sessions</button>
+                        <div style="font-size: 0.75em; color: #666; margin-top: 3px;">Keeps only the 10 most recent sessions</div>
+                    </div>
+                </div>
+                <div style="display: flex; gap: 20px;">
+                    <div style="flex: 1; border-right: 1px solid #eee; padding-right: 20px;">
+                        <h3>By Service</h3>
+                        <ul id="stats-by-service" class="stats-list"></ul>
+                    </div>
+                    <div style="flex: 2;">
+                        <h3>Sessions</h3>
+                        <div id="stats-by-session-container" style="max-height: 200px; overflow-y: auto; border: 1px solid #eee; padding: 5px; border-radius: 4px;">
+                            <ul id="stats-by-session" class="stats-list"></ul>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div id="browse-recordings" class="summary-box" style="margin-top: 20px;">
+                <h3>Browse Recordings</h3>
+                <div style="margin-bottom: 15px; display: flex; gap: 15px; align-items: center; background: #f9f9f9; padding: 10px; border-radius: 4px;">
+                    <div>
+                        <label for="filter-session">Session:</label>
+                        <select id="filter-session" onchange="fetchInteractions()">
+                            <option value="">All Sessions</option>
+                        </select>
+                    </div>
+                    <div>
+                        <label for="filter-category">Category:</label>
+                        <select id="filter-category" onchange="fetchInteractions()">
+                            <option value="">All Categories</option>
+                            <option value="self">Self (Emulated)</option>
+                            <option value="upstream">Upstream (Bose)</option>
+                        </select>
+                    </div>
+                    <div>
+                        <label for="filter-since">Since (YYYY-MM-DD HH:mm:ss):</label>
+                        <input type="text" id="filter-since" placeholder="e.g. 2026-02-15 15:00:00" size="25" onchange="fetchInteractions()">
+                    </div>
+                    <button onclick="fetchInteractions()">Apply Filters</button>
+                </div>
+
+                <div id="interactions-list-container" style="max-height: 400px; overflow-y: auto;">
+                    <table style="width: 100%; border-collapse: collapse;">
+                        <thead>
+                            <tr style="text-align: left; border-bottom: 2px solid #eee;">
+                                <th style="padding: 8px;">#</th>
+                                <th style="padding: 8px;">Time</th>
+                                <th style="padding: 8px;">Method</th>
+                                <th style="padding: 8px;">Path</th>
+                                <th style="padding: 8px;">Status</th>
+                                <th style="padding: 8px;">Category</th>
+                                <th style="padding: 8px;">Action</th>
+                            </tr>
+                        </thead>
+                        <tbody id="interactions-list">
+                            <tr><td colspan="7" style="padding: 20px; text-align: center; color: #666;">No interactions found.</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+
+            <div id="interaction-viewer" class="summary-box" style="margin-top: 20px; display: none; background: #2b2b2b; color: #a9b7c6;">
+                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+                    <h3 style="margin: 0; color: #fff;">Recording Viewer: <span id="viewer-filename" style="font-weight: normal; font-size: 0.8em;"></span></h3>
+                    <button onclick="document.getElementById('interaction-viewer').style.display='none'" style="background: #444; color: #fff; border: 1px solid #666;">Close</button>
+                </div>
+                <pre id="interaction-content" style="white-space: pre-wrap; font-family: 'Courier New', Courier, monospace; font-size: 0.9em; margin: 0; padding: 10px; overflow-x: auto; max-height: 600px;"></pre>
+            </div>
+
+            <!-- Device Events Overlay -->
+            <div id="device-events-overlay" class="summary-box" style="margin-top: 20px; display: none; background: #fdfdfd; border: 1px solid #ddd;">
+                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+                    <h3 style="margin: 0;">App & Device Events</h3>
+                    <div>
+                        <select id="event-device-selector" onchange="fetchDeviceEvents(this.value)">
+                            <option value="">-- Select Device --</option>
+                        </select>
+                        <button onclick="document.getElementById('device-events-overlay').style.display='none'" style="margin-left: 10px;">Close</button>
+                    </div>
+                </div>
+                <div id="events-list-container" style="max-height: 400px; overflow-y: auto;">
+                    <table style="width: 100%; border-collapse: collapse;">
+                        <thead>
+                            <tr style="text-align: left; border-bottom: 2px solid #eee;">
+                                <th style="padding: 8px;">Time</th>
+                                <th style="padding: 8px;">Type</th>
+                                <th style="padding: 8px;">Data</th>
+                            </tr>
+                        </thead>
+                        <tbody id="events-list">
+                            <tr><td colspan="3" style="padding: 20px; text-align: center; color: #666;">Select a device to view events.</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
     </div>
 
     <script src="/web/js/script.js"></script>
     <footer style="margin-top: 50px; padding: 20px; border-top: 1px solid #eee; font-size: 0.8em; color: #888; text-align: center;">
-        <span id="version-info">SoundTouch Toolkit</span>
+        <span id="version-info">AfterTouch</span>
     </footer>
 </body>
 </html>

pkg/service/handlers/web/js/script.js

@@ -6,13 +6,16 @@ async function fetchSettings() {
             document.getElementById('target-domain').value = settings.server_url;
         }
         if (settings.proxy_url) {
-            document.getElementById('proxy-domain').value = settings.proxy_url;
+            document.getElementById('soundcork-url').value = settings.proxy_url;
         }
         if (settings.discovery_interval) {
             document.getElementById('discovery-interval').value = settings.discovery_interval;
         }
-        if (settings.discovery_disabled !== undefined) {
-            document.getElementById('discovery-disabled').checked = settings.discovery_disabled;
+        if (settings.discovery_enabled !== undefined) {
+            document.getElementById('discovery-enabled').checked = settings.discovery_enabled;
+        }
+        if (settings.enable_soundcork_proxy !== undefined) {
+            document.getElementById('enable-soundcork-proxy').checked = settings.enable_soundcork_proxy;
         }
         fetchProxySettings();
     } catch (error) {
@@ -27,6 +30,9 @@ async function fetchProxySettings() {
         document.getElementById('proxy-redact').checked = settings.redact;
         document.getElementById('proxy-log-body').checked = settings.log_body;
         document.getElementById('proxy-record').checked = settings.record;
+        if (settings.enable_soundcork_proxy !== undefined) {
+            document.getElementById('enable-soundcork-proxy').checked = settings.enable_soundcork_proxy;
+        }
     } catch (error) {
         console.error('Failed to fetch proxy settings', error);
     }
@@ -36,7 +42,8 @@ async function updateProxySettings() {
     const settings = {
         redact: document.getElementById('proxy-redact').checked,
         log_body: document.getElementById('proxy-log-body').checked,
-        record: document.getElementById('proxy-record').checked
+        record: document.getElementById('proxy-record').checked,
+        enable_soundcork_proxy: document.getElementById('enable-soundcork-proxy').checked
     };
     try {
         await fetch('/setup/proxy-settings', {
@@ -52,9 +59,10 @@ async function updateProxySettings() {
 async function updateSettings() {
     const settings = {
         server_url: document.getElementById('target-domain').value,
-        proxy_url: document.getElementById('proxy-domain').value,
+        proxy_url: document.getElementById('soundcork-url').value,
         discovery_interval: document.getElementById('discovery-interval').value,
-        discovery_disabled: document.getElementById('discovery-disabled').checked
+        discovery_enabled: document.getElementById('discovery-enabled').checked,
+        enable_soundcork_proxy: document.getElementById('enable-soundcork-proxy').checked
     };
     const status = document.getElementById('settings-status');
     status.innerText = 'Saving...';
@@ -92,23 +100,26 @@ async function fetchDevices() {
         if (devices.length === 0) {
             container.innerHTML = 'No devices known yet.';
         } else {
-            let html = '<table><tr><th>Name</th><th>IP Address</th><th>Model</th><th>Serial Number</th><th>Firmware</th><th>Method</th><th>Action</th></tr>';
+            let html = '<table><tr><th>Name & Model</th><th>IP Address</th><th>Device & Account ID</th><th>Firmware & Serial</th><th>Method</th><th>Action</th></tr>';
 
             // Clear and repopulate selectors
             const currentSyncVal = syncSelector.value;
             const currentMigrationVal = migrationSelector.value;
+            const eventSelector = document.getElementById('event-device-selector');
+            const currentEventVal = eventSelector ? eventSelector.value : "";
+
             syncSelector.innerHTML = '<option value="">-- Select a device --</option>';
             migrationSelector.innerHTML = '<option value="">-- Select a device --</option>';
+            if (eventSelector) eventSelector.innerHTML = '<option value="">-- Select a device --</option>';
 
             devices.forEach(d => {
                 const methodLabel = d.discovery_method === 'manual' ? '👤 Manual' : '🔍 Auto';
                 html += `
                     <tr id="device-row-${d.ip_address.replace(/\./g, '-')}">
-                        <td class="col-name">${d.name}</td>
+                        <td class="col-name-model"><div class="col-name">${d.name}</div><div class="col-model" style="font-size: 0.8em; color: #666;">${d.product_code}</div></td>
                         <td class="col-ip">${d.ip_address}</td>
-                        <td class="col-model">${d.product_code}</td>
-                        <td class="col-serial">${d.device_serial_number}</td>
-                        <td class="col-firmware">${d.firmware_version || '0.0.0'}</td>
+                        <td class="col-ids"><div class="col-deviceid">${d.device_id}</div><div class="col-accountid" style="font-size: 0.8em; color: #666;">${d.account_id || 'default'}</div></td>
+                        <td class="col-fw-serial"><div class="col-firmware">${d.firmware_version || '0.0.0'}</div><div class="col-serial" style="font-size: 0.8em; color: #666;">${d.device_serial_number}</div></td>
                         <td class="col-method">${methodLabel}</td>
                         <td>
                             <button onclick="prepareSync('${d.ip_address}')">Sync Data</button>
@@ -127,12 +138,20 @@ async function fetchDevices() {
                 optMigrate.value = d.ip_address;
                 optMigrate.textContent = `${d.name} (${d.ip_address})`;
                 migrationSelector.appendChild(optMigrate);
+
+                if (eventSelector) {
+                    const optEvent = document.createElement('option');
+                    optEvent.value = d.device_id || d.ip_address;
+                    optEvent.textContent = `${d.name} (${d.ip_address})`;
+                    eventSelector.appendChild(optEvent);
+                }
             });
             html += '</table>';
             container.innerHTML = html;
 
             if (currentSyncVal) syncSelector.value = currentSyncVal;
             if (currentMigrationVal) migrationSelector.value = currentMigrationVal;
+            if (eventSelector && currentEventVal) eventSelector.value = currentEventVal;
 
             // Asynchronously fetch live info for each device
             devices.forEach(d => updateDeviceInfo(d.ip_address));
@@ -169,6 +188,11 @@ function openTab(evt, tabId) {
         content.className += " active";
     }
 
+    if (tabId === 'tab-interactions') {
+        fetchInteractionStats();
+        fetchInteractions();
+    }
+
     if (evt) {
         evt.currentTarget.className += " active";
     } else {
@@ -223,20 +247,324 @@ async function fetchVersion() {
         const data = await response.json();
         const info = document.getElementById('version-info');
         if (info && data.version) {
-            info.innerText = `SoundTouch Toolkit ${data.version} (${data.commit}) - ${data.date}`;
+            info.innerText = `AfterTouch ${data.version} (${data.commit}) - ${data.date}`;
         }
     } catch (error) {
         console.error('Failed to fetch version info', error);
     }
 }
 
+async function fetchInteractionStats() {
+    console.log('Fetching interaction stats...');
+    try {
+        const response = await fetch('/setup/interaction-stats');
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const stats = await response.json();
+        console.log('Fetched interaction stats:', stats);
+
+        document.getElementById('total-requests').innerText = stats.total_requests || stats.TotalRequests || 0;
+
+        const statsContainer = document.getElementById('interaction-stats-container');
+        if (statsContainer) {
+            statsContainer.style.display = 'block';
+        }
+
+        const serviceList = document.getElementById('stats-by-service');
+        serviceList.innerHTML = '';
+        const byService = stats.by_service || stats.ByService;
+        if (byService) {
+            Object.entries(byService).forEach(([service, count]) => {
+                const li = document.createElement('li');
+                li.innerHTML = `<strong>${service || "unknown"}:</strong> ${count || 0} requests`;
+                serviceList.appendChild(li);
+            });
+        }
+
+        const sessionList = document.getElementById('stats-by-session');
+        const sessionFilter = document.getElementById('filter-session');
+        const currentFilter = sessionFilter.value;
+
+        sessionList.innerHTML = '';
+        sessionFilter.innerHTML = '<option value="">All Sessions</option>';
+
+        const bySession = stats.by_session || stats.BySession;
+        if (bySession) {
+            // Sort by session ID (timestamp) descending
+            const sortedSessions = Object.entries(bySession)
+                .sort((a, b) => {
+                    const sessionA = a[0] || "";
+                    const sessionB = b[0] || "";
+                    return sessionB.localeCompare(sessionA);
+                });
+
+            sortedSessions.forEach(([session, count]) => {
+                // Session format is like 20260215-160705-99213
+                // Try to make it more readable: 2026-02-15 16:07:05 (PID 99213)
+                let sessionDisplay = session || "unknown";
+                if (session && session.includes('-')) {
+                    const parts = session.split('-');
+                    if (parts.length >= 2) {
+                        const date = parts[0]; // 20260215
+                        const time = parts[1]; // 160705
+                        if (date.length === 8 && time.length === 6) {
+                            sessionDisplay = `${date.substring(0, 4)}-${date.substring(4, 6)}-${date.substring(6, 8)} ${time.substring(0, 2)}:${time.substring(2, 4)}:${time.substring(4, 6)}`;
+                            if (parts.length >= 3) {
+                                sessionDisplay += ` (PID ${parts[2]})`;
+                            }
+                        }
+                    }
+                }
+
+                const li = document.createElement('li');
+                li.innerHTML = `
+                    <span class="session-info"><strong>${sessionDisplay}:</strong> ${count || 0} requests</span>
+                    <div style="display: flex; gap: 5px;">
+                        <button onclick="downloadSession('${session || ""}')" class="btn-info" style="font-size: 0.8em; padding: 2px 5px;">Download</button>
+                        <button onclick="filterBySession('${session || ""}')" style="font-size: 0.8em; padding: 2px 5px;">Filter</button>
+                        <button onclick="deleteSession('${session || ""}')" class="btn-danger" style="font-size: 0.8em; padding: 2px 5px;">Delete</button>
+                    </div>
+                `;
+                sessionList.appendChild(li);
+
+                const opt = document.createElement('option');
+                opt.value = session || "";
+                opt.innerText = sessionDisplay;
+                sessionFilter.appendChild(opt);
+            });
+
+            sessionFilter.value = currentFilter;
+        }
+    } catch (error) {
+        console.error('Failed to fetch interaction stats', error);
+    }
+}
+
+function downloadSession(sessionId) {
+    if (!sessionId) return;
+    window.location.href = `/setup/interactions/sessions/${sessionId}/download`;
+}
+
+async function filterBySession(sessionId) {
+    document.getElementById('filter-session').value = sessionId;
+    fetchInteractions();
+    const browseContainer = document.getElementById('browse-recordings');
+    if (browseContainer) {
+        browseContainer.scrollIntoView({ behavior: 'smooth' });
+    }
+}
+
+async function deleteSession(sessionId) {
+    if (!sessionId) return;
+    if (!confirm(`Are you sure you want to delete session ${sessionId}?`)) {
+        return;
+    }
+
+    try {
+        const response = await fetch(`/setup/interactions/sessions/${sessionId}`, {
+            method: 'DELETE'
+        });
+        if (response.ok) {
+            // If the deleted session was selected in the filter, clear the filter
+            const sessionFilter = document.getElementById('filter-session');
+            if (sessionFilter.value === sessionId) {
+                sessionFilter.value = "";
+                fetchInteractions();
+            }
+            fetchInteractionStats();
+        } else {
+            const err = await response.text();
+            alert('Failed to delete session: ' + err);
+        }
+    } catch (error) {
+        alert('Error deleting session: ' + error.message);
+    }
+}
+
+async function cleanupSessions() {
+    if (!confirm('Are you sure you want to cleanup old sessions? Only the 10 most recent ones will be kept.')) {
+        return;
+    }
+
+    try {
+        const response = await fetch('/setup/interactions/sessions?keep=10', {
+            method: 'DELETE'
+        });
+        if (response.ok) {
+            // Refresh everything
+            document.getElementById('filter-session').value = "";
+            fetchInteractionStats();
+            fetchInteractions();
+        } else {
+            const err = await response.text();
+            alert('Failed to cleanup sessions: ' + err);
+        }
+    } catch (error) {
+        alert('Error cleaning up sessions: ' + error.message);
+    }
+}
+
+async function fetchInteractions() {
+    console.log('Fetching interactions...');
+    const session = document.getElementById('filter-session').value;
+    const category = document.getElementById('filter-category').value;
+    const since = document.getElementById('filter-since').value;
+
+    let url = '/setup/interactions';
+    const params = [];
+    if (session) params.push(`session=${encodeURIComponent(session)}`);
+    if (category) params.push(`category=${encodeURIComponent(category)}`);
+    if (since) params.push(`since=${encodeURIComponent(since)}`);
+    if (params.length > 0) url += '?' + params.join('&');
+
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const interactions = await response.json();
+        console.log('Fetched interactions:', interactions);
+        const list = document.getElementById('interactions-list');
+        if (!list) {
+            console.error('Could not find interactions-list element');
+            return;
+        }
+
+        // Show the parent summary box if it was hidden
+        const browseContainer = list.closest('.summary-box');
+        if (browseContainer) {
+            browseContainer.style.display = 'block';
+        }
+
+        list.innerHTML = '';
+
+        if (!interactions || interactions.length === 0) {
+            list.innerHTML = '<tr><td colspan="7" style="padding: 20px; text-align: center; color: #666;">No interactions found for current filters.</td></tr>';
+            return;
+        }
+
+        // Default sort: Session desc, then Counter asc
+        // If a specific session is selected, sort primarily by counter asc
+        interactions.sort((a, b) => {
+            const sessionA = a.session || a.Session || "";
+            const sessionB = b.session || b.Session || "";
+            if (sessionA !== sessionB) {
+                return sessionB.localeCompare(sessionA);
+            }
+            const counterA = a.counter || a.Counter || 0;
+            const counterB = b.counter || b.Counter || 0;
+            return counterA - counterB;
+        });
+
+        interactions.forEach(i => {
+            const tr = document.createElement('tr');
+            tr.style.borderBottom = '1px solid #eee';
+
+            const counter = i.counter || i.Counter || 0;
+            const timestamp = i.timestamp || i.Timestamp || "";
+            const method = i.method || i.Method || "";
+            const path = i.path || i.Path || "";
+            const status = i.status || i.Status || "";
+            const category = i.category || i.Category || "";
+            const session = i.session || i.Session || "";
+            const file = i.file || i.File || "";
+
+            let statusClass = '';
+            if (status >= 200 && status < 300) statusClass = 'status-success';
+            else if (status >= 400) statusClass = 'status-error';
+
+            tr.innerHTML = `
+                <td style="padding: 8px; color: #888;">${counter}</td>
+                <td style="padding: 8px; font-size: 0.8em; white-space: nowrap;">${timestamp}</td>
+                <td style="padding: 8px; font-family: monospace;">${method}</td>
+                <td style="padding: 8px; font-size: 0.9em;">${path}</td>
+                <td style="padding: 8px;"><span class="badge ${statusClass}">${status || '???'}</span></td>
+                <td style="padding: 8px;"><span class="badge category-${category}">${category}</span></td>
+                <td style="padding: 8px;"><button onclick="viewInteraction('${file}')">View</button></td>
+            `;
+            list.appendChild(tr);
+        });
+    } catch (error) {
+        console.error('Failed to fetch interactions', error);
+    }
+}
+
+async function viewInteraction(file) {
+    try {
+        const response = await fetch(`/setup/interaction-content?file=${encodeURIComponent(file)}`);
+        const content = await response.text();
+
+        document.getElementById('viewer-filename').innerText = file;
+        document.getElementById('interaction-content').innerText = content;
+        document.getElementById('interaction-viewer').style.display = 'block';
+        document.getElementById('interaction-viewer').scrollIntoView({ behavior: 'smooth' });
+    } catch (error) {
+        alert('Failed to load interaction content: ' + error);
+    }
+}
+
+async function showDeviceEvents() {
+    const overlay = document.getElementById('device-events-overlay');
+    overlay.style.display = 'block';
+    overlay.scrollIntoView({ behavior: 'smooth' });
+
+    // Ensure device selector is populated (handled by fetchDevices)
+    // but if it's still empty, we can try to trigger a fetch
+    const selector = document.getElementById('event-device-selector');
+    if (selector.options.length <= 1) {
+        fetchDevices();
+    }
+}
+
+async function fetchDeviceEvents(deviceId) {
+    if (!deviceId) return;
+
+    const list = document.getElementById('events-list');
+    list.innerHTML = '<tr><td colspan="3" style="padding: 20px; text-align: center; color: #666;">Loading events...</td></tr>';
+
+    try {
+        const response = await fetch(`/setup/devices/${deviceId}/events`);
+        const data = await response.json();
+        const events = data.events;
+
+        list.innerHTML = '';
+        if (!events || events.length === 0) {
+            list.innerHTML = '<tr><td colspan="3" style="padding: 20px; text-align: center; color: #666;">No events found for this device.</td></tr>';
+            return;
+        }
+
+        // Sort events by time descending
+        events.sort((a, b) => (b.time || "").localeCompare(a.time || ""));
+
+        events.forEach(e => {
+            const tr = document.createElement('tr');
+            tr.style.borderBottom = '1px solid #eee';
+
+            const time = e.time || "";
+            const type = e.type || "";
+            const data = JSON.stringify(e.data || {});
+
+            tr.innerHTML = `
+                <td style="padding: 8px; font-size: 0.8em; white-space: nowrap;">${time}</td>
+                <td style="padding: 8px;"><span class="badge category-self">${type}</span></td>
+                <td style="padding: 8px; font-size: 0.85em; font-family: monospace; max-width: 400px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;" title='${data}'>${data}</td>
+            `;
+            list.appendChild(tr);
+        });
+    } catch (error) {
+        list.innerHTML = `<tr><td colspan="3" style="padding: 20px; text-align: center; color: #f44336;">Error loading events: ${error.message}</td></tr>`;
+    }
+}
+
 document.addEventListener('DOMContentLoaded', () => {
     fetchSettings();
     fetchDevices();
     triggerDiscovery();
     fetchVersion();
 
-    document.getElementById('sync-now-btn').onclick = startSync;
+    const syncBtn = document.getElementById('sync-now-btn');
+    if (syncBtn) syncBtn.onclick = startSync;
 });
 
 
@@ -336,6 +664,12 @@ async function updateDeviceInfo(ip) {
 
             const firmwareEl = row.querySelector('.col-firmware');
             if (firmwareEl && info.softwareVersion) firmwareEl.innerText = info.softwareVersion;
+
+            const deviceIdEl = row.querySelector('.col-deviceid');
+            if (deviceIdEl && info.deviceID) deviceIdEl.innerText = info.deviceID;
+
+            const accountIdEl = row.querySelector('.col-accountid');
+            if (accountIdEl && info.margeAccountUUID) accountIdEl.innerText = info.margeAccountUUID;
         }
     } catch (error) {
         console.warn('Failed to fetch live info for ' + ip, error);
@@ -348,7 +682,7 @@ async function showSummary(ip) {
         return;
     }
     const targetUrl = document.getElementById('target-domain').value;
-    const proxyUrl = document.getElementById('proxy-domain').value;
+    const proxyUrl = document.getElementById('soundcork-url').value;
 
     const opts = {
         marge: document.getElementById('opt-marge').value,
@@ -396,11 +730,22 @@ async function showSummary(ip) {
 
             const firmwareEl = row.querySelector('.col-firmware');
             if (firmwareEl && summary.firmware_version) firmwareEl.innerText = summary.firmware_version;
+
+            const deviceIdEl = row.querySelector('.col-deviceid');
+            if (deviceIdEl && summary.device_id) deviceIdEl.innerText = summary.device_id;
+
+            const accountIdEl = row.querySelector('.col-accountid');
+            if (accountIdEl && summary.account_id) accountIdEl.innerText = summary.account_id;
         }
 
         document.getElementById('ssh-status').innerText = summary.ssh_success ? '✅ Success' : '❌ Failed';
         document.getElementById('ssh-status').style.color = summary.ssh_success ? 'green' : 'red';
 
+        const migrationStatus = document.getElementById('migration-status');
+        migrationStatus.innerText = summary.is_migrated ? '✅ Migrated to AfterTouch' : '❌ Not Migrated';
+        migrationStatus.style.color = summary.is_migrated ? 'green' : 'red';
+        migrationStatus.style.fontWeight = 'bold';
+
         document.getElementById('original-config-status').style.display = summary.original_config ? 'block' : 'none';
         document.getElementById('no-original-config-status').style.display = summary.original_config ? 'none' : 'block';
         document.getElementById('original-config-content').innerText = summary.original_config || '';
@@ -476,6 +821,7 @@ async function showSummary(ip) {
         const rebootBtn = document.getElementById('reboot-speaker-btn');
         rebootBtn.onclick = () => reboot(ip);
         rebootBtn.disabled = !summary.ssh_success;
+        rebootBtn.style.border = 'none'; // Reset border if it was set during migration
 
         const remoteBtn = document.getElementById('ensure-remote-btn');
         remoteBtn.onclick = () => ensureRemoteServices(ip);
@@ -586,7 +932,7 @@ async function migrate(ip) {
         return;
     }
     const targetUrl = document.getElementById('target-domain').value;
-    const proxyUrl = document.getElementById('proxy-domain').value;
+    const proxyUrl = document.getElementById('soundcork-url').value;
     const method = document.getElementById('migration-method').value;
 
     const opts = {
@@ -615,7 +961,16 @@ async function migrate(ip) {
         showCommandOutput(result);
         if (result.ok) {
             statusDiv.style.backgroundColor = '#ccffcc';
-            statusDiv.innerHTML = 'Successfully started migration for ' + ip + '.';
+            statusDiv.innerHTML = 'Successfully started migration for ' + ip + '. <strong>Please reboot the device to activate the changes.</strong>';
+
+            // Make reboot button available and prominent
+            const rebootBtn = document.getElementById('reboot-speaker-btn');
+            rebootBtn.style.display = 'inline-block';
+            rebootBtn.disabled = false;
+            rebootBtn.style.border = '2px solid #000';
+
+            // Re-show summary but with prominence on reboot
+            summaryDiv.style.display = 'block';
         } else {
             statusDiv.style.backgroundColor = '#ffcccc';
             statusDiv.innerHTML = 'Migration failed for ' + ip + ': ' + (result.message || 'Unknown error');

pkg/service/proxy/patterns.go

@@ -59,13 +59,26 @@ func (pp PathPatterns) Sanitize(segment string) (string, string) {
 
 // DefaultPatterns returns the default set of path patterns.
 func DefaultPatterns() PathPatterns {
-	p := PathPattern{
-		Name:        "IPv4",
-		Regexp:      `^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$`,
-		Replacement: "{ip}",
+	return PathPatterns{
+		{
+			Name:        "IPv4",
+			Regexp:      `^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$`,
+			Replacement: "{ip}",
+		},
+		{
+			Name:        "UUID",
+			Regexp:      `^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`,
+			Replacement: "{uuid}",
+		},
+		{
+			Name:        "AccountID",
+			Regexp:      `^\d{5,10}$`,
+			Replacement: "{accountId}",
+		},
+		{
+			Name:        "DeviceID",
+			Regexp:      `^[0-9a-fA-F]{12}$`,
+			Replacement: "{device_id}",
+		},
 	}
-	re, _ := regexp.Compile(p.Regexp)
-	p.compiled = re
-
-	return PathPatterns{p}
 }

pkg/service/proxy/patterns_test.go

@@ -0,0 +1,61 @@
+package proxy
+
+import (
+	"regexp"
+	"testing"
+)
+
+func TestDefaultPatterns(t *testing.T) {
+	patterns := DefaultPatterns()
+	if len(patterns) != 4 {
+		t.Errorf("Expected 4 default patterns, got %d", len(patterns))
+	}
+
+	expectedNames := []string{"IPv4", "UUID", "AccountID", "DeviceID"}
+	for i, name := range expectedNames {
+		if patterns[i].Name != name {
+			t.Errorf("Expected pattern %d name %s, got %s", i, name, patterns[i].Name)
+		}
+	}
+}
+
+func TestPathPatterns_Sanitize(t *testing.T) {
+	patterns := DefaultPatterns()
+	// Need to compile them as DefaultPatterns() in its new form doesn't compile them (main.go or LoadPatterns does it)
+	// Wait, actually the new DefaultPatterns() I wrote doesn't compile them.
+	// But PathPatterns.Sanitize checks for compiled != nil.
+
+	// Let's manually compile for the test
+	for i := range patterns {
+		patterns[i].compiled = mustCompile(patterns[i].Regexp)
+	}
+
+	tests := []struct {
+		segment  string
+		wantRepl string
+	}{
+		{"192.168.1.100", "{ip}"},
+		{"1234567", "{accountId}"},
+		{"12345", "{accountId}"},
+		{"12345678-1234-5678-9012-123456789012", "{uuid}"},
+		{"D05FB8A848E5", "{device_id}"},
+		{"some-other-segment", ""},
+	}
+
+	for _, tt := range tests {
+		repl, _ := patterns.Sanitize(tt.segment)
+		if tt.wantRepl == "" {
+			if repl != tt.segment {
+				t.Errorf("Sanitize(%q) = %q, want %q (no change)", tt.segment, repl, tt.segment)
+			}
+		} else {
+			if repl != tt.wantRepl {
+				t.Errorf("Sanitize(%q) = %q, want %q", tt.segment, repl, tt.wantRepl)
+			}
+		}
+	}
+}
+
+func mustCompile(re string) *regexp.Regexp {
+	return regexp.MustCompile(re)
+}

pkg/service/proxy/proxy_test.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"net/http/httptest"
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 )
@@ -64,6 +65,7 @@ func TestLoggingProxy_LogRequest(t *testing.T) {
 	defer func() { _ = os.Unsetenv("LOG_PROXY_BODY") }()
 
 	lp := NewLoggingProxy("http://example.com", true)
+	lp.LogBody = true
 
 	body := "test body content"
 	req := httptest.NewRequest("POST", "http://example.com/api", strings.NewReader(body))
@@ -77,4 +79,48 @@ func TestLoggingProxy_LogRequest(t *testing.T) {
 	if string(readBody) != body {
 		t.Errorf("Request body was consumed or changed, got %q, want %q", string(readBody), body)
 	}
+
+	// Test truncation
+	lp.MaxBodySize = 4
+	req2 := httptest.NewRequest("POST", "http://example.com/api", strings.NewReader("1234567890"))
+	req2.Header.Set("Content-Type", "text/plain")
+	lp.LogRequest(req2)
+}
+
+func TestLoggingProxy_LogResponse(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	lp := NewLoggingProxy("http://example.com", true)
+	lp.LogBody = true
+
+	body := "response content"
+	req := httptest.NewRequest("GET", "http://example.com/api", nil)
+	w := httptest.NewRecorder()
+	w.Header().Set("Content-Type", "text/plain")
+	_, _ = w.WriteString(body)
+	res := w.Result()
+	res.Request = req
+
+	lp.LogResponse(res)
+
+	// Check if body is still readable
+	readBody, _ := io.ReadAll(res.Body)
+	if string(readBody) != body {
+		t.Errorf("Response body was consumed or changed, got %q, want %q", string(readBody), body)
+	}
+
+	// Test with recorder
+	tmpDir, _ := os.MkdirTemp("", "proxy-recorder-test")
+	defer os.RemoveAll(tmpDir)
+	recorder := NewRecorder(tmpDir)
+	lp.SetRecorder(recorder)
+	lp.RecordEnabled = true
+
+	lp.LogResponse(res)
+
+	// Verify recording exists
+	interactionsDir := filepath.Join(tmpDir, "interactions", recorder.SessionID, "upstream", "api")
+	files, _ := os.ReadDir(interactionsDir)
+	if len(files) == 0 {
+		t.Error("LogResponse did not record the interaction")
+	}
 }

pkg/service/proxy/recorder.go

@@ -1,13 +1,17 @@
 package proxy
 
 import (
+	"archive/tar"
 	"bytes"
+	"compress/gzip"
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -24,21 +28,70 @@ type Recorder struct {
 	counter    uint64
 	variables  map[string]string
 	mu         sync.Mutex
+	queue      chan recordingTask
+}
+
+type recordingTask struct {
+	category     string
+	req          *http.Request
+	res          *http.Response
+	replacements map[string]string
+	dir          string
+	path         string
+}
+
+// InteractionStats represents statistics for recorded interactions.
+type InteractionStats struct {
+	TotalRequests int            `json:"total_requests"`
+	ByService     map[string]int `json:"by_service"`
+	BySession     map[string]int `json:"by_session"`
+}
+
+// Interaction represents a single recorded HTTP interaction.
+type Interaction struct {
+	ID        string `json:"id"`
+	Session   string `json:"session"`
+	Category  string `json:"category"`
+	Method    string `json:"method"`
+	Path      string `json:"path"`
+	File      string `json:"file"`
+	Counter   int    `json:"counter"`
+	Status    int    `json:"status"`
+	Timestamp string `json:"timestamp"`
 }
 
 // NewRecorder creates a new HTTP interaction recorder.
 func NewRecorder(baseDir string) *Recorder {
 	sessionID := time.Now().Format("20060102-150405") + "-" + fmt.Sprintf("%d", os.Getpid())
 
-	return &Recorder{
+	r := &Recorder{
 		BaseDir:   baseDir,
 		SessionID: sessionID,
 		Patterns:  DefaultPatterns(),
 		variables: make(map[string]string),
 	}
+
+	// Use environment variable to control async recording, default to true for production
+	// but allow disabling it for tests if needed.
+	if os.Getenv("RECORDER_ASYNC") != "false" {
+		r.queue = make(chan recordingTask, 100)
+		go r.worker()
+	} else {
+		log.Println("[DEBUG_LOG] Recorder starting in synchronous mode")
+	}
+
+	return r
 }
 
-// Record persists a request and response to a .http file in the specified category (e.g., "self" or "upstream").
+// Close stops the recorder and waits for pending tasks to finish.
+func (r *Recorder) Close() {
+	if r.queue != nil {
+		close(r.queue)
+		// We might want to wait here, but for now just closing is a start
+	}
+}
+
+// Record logs an interaction to the configured category.
 func (r *Recorder) Record(category string, req *http.Request, res *http.Response) error {
 	if r.BaseDir == "" {
 		return nil
@@ -53,19 +106,82 @@ func (r *Recorder) Record(category string, req *http.Request, res *http.Response
 
 	path := r.getRecordingPath(dir, req.Method)
 
+	// If we are in async mode, we MUST copy the bodies now because the caller
+	// might close them as soon as Record() returns.
+	var (
+		clonedReq *http.Request
+		clonedRes *http.Response
+	)
+
+	if r.queue != nil {
+		// Clone request
+		clonedReq = req.Clone(req.Context())
+		if req.Body != nil {
+			bodyBytes, _ := io.ReadAll(req.Body)
+			req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+			clonedReq.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+		}
+
+		// Clone response if present
+		if res != nil {
+			clonedRes = &http.Response{
+				StatusCode: res.StatusCode,
+				Header:     res.Header.Clone(),
+				Request:    clonedReq,
+			}
+			if res.Body != nil {
+				bodyBytes, _ := io.ReadAll(res.Body)
+				res.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+				clonedRes.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+			}
+		}
+	} else {
+		clonedReq = req
+		clonedRes = res
+	}
+
+	task := recordingTask{
+		category:     category,
+		req:          clonedReq,
+		res:          clonedRes,
+		replacements: replacements,
+		dir:          dir,
+		path:         path,
+	}
+
+	// For testing purposes or if queue is nil, fallback to synchronous
+	if r.queue == nil {
+		r.save(task)
+		return nil
+	}
+
+	select {
+	case r.queue <- task:
+		return nil
+	default:
+		return fmt.Errorf("recording queue full, dropping interaction for %s", req.URL.Path)
+	}
+}
+
+func (r *Recorder) save(task recordingTask) {
 	var buf bytes.Buffer
+	r.writeRequest(&buf, task.req, task.replacements)
 
-	r.writeRequest(&buf, req, replacements)
-
-	if res != nil {
-		r.writeResponse(&buf, res)
+	if task.res != nil {
+		r.writeResponse(&buf, task.res)
 	}
 
-	if err := os.WriteFile(path, buf.Bytes(), 0644); err != nil {
-		return err
+	if err := os.WriteFile(task.path, buf.Bytes(), 0644); err != nil {
+		log.Printf("failed to write recording to %s: %v", task.path, err)
 	}
 
-	return r.updateEnvFile(replacements)
+	_ = r.updateEnvFile(task.replacements)
+}
+
+func (r *Recorder) worker() {
+	for task := range r.queue {
+		r.save(task)
+	}
 }
 
 func (r *Recorder) getSanitizedSegments(path string) ([]string, map[string]string) {
@@ -120,6 +236,7 @@ func (r *Recorder) writeRequest(buf *bytes.Buffer, req *http.Request, replacemen
 	}
 
 	fmt.Fprintf(buf, "%s %s\n", req.Method, displayURL)
+	fmt.Fprintf(buf, "Host: %s\n", req.Host)
 
 	for k, vv := range req.Header {
 		if r.Redact && isSensitive(k) {
@@ -221,3 +338,312 @@ func (r *Recorder) updateEnvFile(newVars map[string]string) error {
 
 	return os.WriteFile(envFile, data, 0644)
 }
+
+// GetInteractionStats returns statistics about recorded interactions.
+func (r *Recorder) GetInteractionStats() (*InteractionStats, error) {
+	stats := &InteractionStats{
+		ByService: make(map[string]int),
+		BySession: make(map[string]int),
+	}
+
+	interactionsDir := filepath.Join(r.BaseDir, "interactions")
+	if _, err := os.Stat(interactionsDir); os.IsNotExist(err) {
+		return stats, nil
+	}
+
+	err := filepath.Walk(interactionsDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && strings.HasSuffix(info.Name(), ".http") {
+			stats.TotalRequests++
+
+			// Extract category (self/upstream) and session from path
+			// Path is like: .../interactions/<session>/<category>/...
+			rel, err := filepath.Rel(interactionsDir, path)
+			if err != nil {
+				return err
+			}
+
+			parts := strings.Split(rel, string(filepath.Separator))
+			if len(parts) >= 2 {
+				sessionID := parts[0]
+				category := parts[1]
+				stats.BySession[sessionID]++
+				stats.ByService[category]++
+			}
+		}
+
+		return nil
+	})
+
+	return stats, err
+}
+
+// ListInteractions returns a list of recorded interactions.
+func (r *Recorder) ListInteractions(sessionFilter, categoryFilter, sinceFilter string) ([]Interaction, error) {
+	interactions := make([]Interaction, 0)
+	interactionsDir := filepath.Join(r.BaseDir, "interactions")
+
+	if _, err := os.Stat(interactionsDir); os.IsNotExist(err) {
+		return interactions, nil
+	}
+
+	err := filepath.Walk(interactionsDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() || !strings.HasSuffix(info.Name(), ".http") {
+			return nil
+		}
+
+		rel, err := filepath.Rel(interactionsDir, path)
+		if err != nil {
+			return err
+		}
+
+		parts := strings.Split(rel, string(filepath.Separator))
+		if len(parts) < 3 {
+			return nil
+		}
+
+		sessionID, category := parts[0], parts[1]
+		if (sessionFilter != "" && sessionID != sessionFilter) || (categoryFilter != "" && category != categoryFilter) {
+			return nil
+		}
+
+		interaction, ok := r.parseInteractionFile(rel, path, parts)
+		if !ok {
+			return nil
+		}
+
+		if sinceFilter != "" && interaction.Timestamp != "" {
+			fullTS := r.getFullTimestamp(sessionID, interaction.ID)
+
+			normalizedSince := strings.ReplaceAll(strings.ReplaceAll(sinceFilter, ":", "-"), " ", "-")
+			if fullTS != "" && fullTS < normalizedSince {
+				return nil
+			}
+		}
+
+		interactions = append(interactions, interaction)
+
+		return nil
+	})
+
+	return interactions, err
+}
+
+func (r *Recorder) parseInteractionFile(rel, path string, parts []string) (Interaction, bool) {
+	sessionID, category := parts[0], parts[1]
+	filename := parts[len(parts)-1]
+	fnParts := strings.Split(strings.TrimSuffix(filename, ".http"), "-")
+
+	date := ""
+	if len(sessionID) >= 8 {
+		date = sessionID[0:4] + "-" + sessionID[4:6] + "-" + sessionID[6:8]
+	}
+
+	timestamp := ""
+
+	if len(fnParts) >= 4 {
+		timeStr := fnParts[1] + ":" + fnParts[2] + ":" + fnParts[3]
+		timestamp = timeStr
+
+		if date != "" {
+			timestamp = date + " " + timeStr
+		}
+	}
+
+	requestPath := "/" + strings.Join(parts[2:len(parts)-1], "/")
+	if requestPath == "/root" {
+		requestPath = "/"
+	}
+
+	method, counter := "UNKNOWN", 0
+	if len(fnParts) >= 1 {
+		_, _ = fmt.Sscanf(fnParts[0], "%d", &counter)
+	}
+
+	if len(fnParts) >= 5 {
+		method = fnParts[4]
+	}
+
+	return Interaction{
+		ID:        filename,
+		Session:   sessionID,
+		Category:  category,
+		Method:    method,
+		Path:      requestPath,
+		File:      rel,
+		Counter:   counter,
+		Status:    r.peekStatus(path),
+		Timestamp: timestamp,
+	}, true
+}
+
+func (r *Recorder) getFullTimestamp(sessionID, filename string) string {
+	if len(sessionID) < 8 {
+		return ""
+	}
+
+	date := sessionID[0:4] + "-" + sessionID[4:6] + "-" + sessionID[6:8]
+	fnParts := strings.Split(strings.TrimSuffix(filename, ".http"), "-")
+
+	if len(fnParts) < 4 {
+		return ""
+	}
+
+	return date + "-" + fnParts[1] + "-" + fnParts[2] + "-" + fnParts[3]
+}
+
+func (r *Recorder) peekStatus(path string) int {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return 0
+	}
+
+	lines := strings.Split(string(content), "\n")
+	for _, line := range lines {
+		if !strings.Contains(line, "// Response:") {
+			continue
+		}
+
+		trimmedLine := strings.TrimPrefix(strings.TrimSpace(line), "//")
+		trimmedLine = strings.TrimPrefix(strings.TrimSpace(trimmedLine), "Response:")
+		trimmedLine = strings.TrimSpace(trimmedLine)
+
+		status := 0
+		_, _ = fmt.Sscanf(trimmedLine, "%d", &status)
+
+		return status
+	}
+
+	return 0
+}
+
+// DeleteSession deletes a specific recording session.
+func (r *Recorder) DeleteSession(sessionID string) error {
+	if sessionID == "" {
+		return fmt.Errorf("session ID is required")
+	}
+
+	sessionDir := filepath.Join(r.BaseDir, "interactions", sessionID)
+
+	return os.RemoveAll(sessionDir)
+}
+
+// CleanupSessions deletes all but the most recent keepCount sessions.
+func (r *Recorder) CleanupSessions(keepCount int) error {
+	interactionsDir := filepath.Join(r.BaseDir, "interactions")
+
+	entries, err := os.ReadDir(interactionsDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+
+		return err
+	}
+
+	var sessions []os.DirEntry
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			sessions = append(sessions, entry)
+		}
+	}
+
+	if len(sessions) <= keepCount {
+		return nil
+	}
+
+	// Sort sessions by name (timestamp) descending to keep the newest ones
+	// Session ID format: 20260102-150405-PID
+	sort.Slice(sessions, func(i, j int) bool {
+		return sessions[i].Name() > sessions[j].Name()
+	})
+
+	for i := keepCount; i < len(sessions); i++ {
+		sessionDir := filepath.Join(interactionsDir, sessions[i].Name())
+		if err := os.RemoveAll(sessionDir); err != nil {
+			return fmt.Errorf("failed to delete session %s: %w", sessions[i].Name(), err)
+		}
+	}
+
+	return nil
+}
+
+// GetInteractionContent returns the raw content of a recorded interaction.
+func (r *Recorder) GetInteractionContent(relPath string) ([]byte, error) {
+	fullPath := filepath.Join(r.BaseDir, "interactions", relPath)
+	return os.ReadFile(fullPath)
+}
+
+// ArchiveSession creates a .tar.gz archive of the specified session and writes it to w.
+func (r *Recorder) ArchiveSession(sessionID string, w io.Writer) (err error) {
+	sessionDir := filepath.Join(r.BaseDir, "interactions", sessionID)
+
+	info, statErr := os.Stat(sessionDir)
+	if statErr != nil {
+		return statErr
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("%s is not a directory", sessionID)
+	}
+
+	gw := gzip.NewWriter(w)
+
+	defer func() {
+		if closeErr := gw.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	tw := tar.NewWriter(gw)
+
+	defer func() {
+		if closeErr := tw.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	return filepath.Walk(sessionDir, func(path string, info os.FileInfo, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+
+		header, hErr := tar.FileInfoHeader(info, info.Name())
+		if hErr != nil {
+			return hErr
+		}
+
+		rel, rErr := filepath.Rel(sessionDir, path)
+		if rErr != nil {
+			return rErr
+		}
+
+		header.Name = rel
+
+		if whErr := tw.WriteHeader(header); whErr != nil {
+			return whErr
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		f, oErr := os.Open(path)
+		if oErr != nil {
+			return oErr
+		}
+		defer f.Close()
+
+		_, cErr := io.Copy(tw, f)
+
+		return cErr
+	})
+}

pkg/service/proxy/recorder_test.go

@@ -1,7 +1,12 @@
 package proxy
 
 import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
 	"encoding/json"
+	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -12,6 +17,7 @@ import (
 )
 
 func TestRecorder_Record_Structure(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -19,6 +25,11 @@ func TestRecorder_Record_Structure(t *testing.T) {
 	defer os.RemoveAll(tmpDir)
 
 	r := NewRecorder(tmpDir)
+	// Compile default patterns
+	for i := range r.Patterns {
+		re, _ := regexp.Compile(r.Patterns[i].Regexp)
+		r.Patterns[i].compiled = re
+	}
 
 	tests := []struct {
 		name     string
@@ -85,12 +96,19 @@ func TestRecorder_Record_Structure(t *testing.T) {
 				if len(f.Name()) < 5 || !isDigit(f.Name()[0]) || !isDigit(f.Name()[1]) || !isDigit(f.Name()[2]) || !isDigit(f.Name()[3]) || f.Name()[4] != '-' {
 					t.Errorf("Filename %s does not have correct 0000- prefix", f.Name())
 				}
+
+				// Verify Host header is present
+				content, _ := os.ReadFile(filepath.Join(expectedDir, f.Name()))
+				if !strings.Contains(string(content), "Host: ") {
+					t.Errorf("Recorded file does not contain Host header:\n%s", string(content))
+				}
 			}
 		})
 	}
 }
 
 func TestRecorder_Record_Sanitization(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-sanitization-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -100,11 +118,11 @@ func TestRecorder_Record_Sanitization(t *testing.T) {
 	r := NewRecorder(tmpDir)
 	// Add a custom pattern
 	r.Patterns = append(r.Patterns, PathPattern{
-		Name:        "DeviceID",
+		Name:        "CustomDeviceID",
 		Regexp:      `^A81B\w{8}$`,
 		Replacement: "{deviceId}",
 	})
-	// Re-compile
+	// Compile all patterns
 	for i := range r.Patterns {
 		re, _ := regexp.Compile(r.Patterns[i].Regexp)
 		r.Patterns[i].compiled = re
@@ -124,7 +142,7 @@ func TestRecorder_Record_Sanitization(t *testing.T) {
 		t.Fatalf("Record failed: %v", err)
 	}
 
-	expectedDir := filepath.Join(tmpDir, "interactions", r.SessionID, "self", "info", "{ip}", "{deviceId}")
+	expectedDir := filepath.Join(tmpDir, "interactions", r.SessionID, "self", "info", "{ip}", "{device_id}")
 	if _, err := os.Stat(expectedDir); os.IsNotExist(err) {
 		t.Errorf("Expected directory %s does not exist", expectedDir)
 	}
@@ -137,18 +155,19 @@ func TestRecorder_Record_Sanitization(t *testing.T) {
 	content, _ := os.ReadFile(filepath.Join(expectedDir, files[0].Name()))
 	contentStr := string(content)
 
-	if !strings.Contains(contentStr, "### GET /info/{{ip}}/{{deviceId}}") {
+	if !strings.Contains(contentStr, "### GET /info/{{ip}}/{{device_id}}") {
 		t.Errorf("Expected sanitized comment in .http file, got:\n%s", contentStr)
 	}
-	if !strings.Contains(contentStr, "GET /info/{{ip}}/{{deviceId}}") {
+	if !strings.Contains(contentStr, "GET /info/{{ip}}/{{device_id}}") {
 		t.Errorf("Expected sanitized URL in .http file, got:\n%s", contentStr)
 	}
-	if !strings.Contains(contentStr, "X-Device: {{deviceId}}") {
+	if !strings.Contains(contentStr, "X-Device: {{device_id}}") {
 		t.Errorf("Expected sanitized Header in .http file, got:\n%s", contentStr)
 	}
 }
 
 func TestRecorder_Record_Sanitization_Account(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-sanitization-account-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -156,22 +175,19 @@ func TestRecorder_Record_Sanitization_Account(t *testing.T) {
 	defer os.RemoveAll(tmpDir)
 
 	r := NewRecorder(tmpDir)
-	// Add AccountID pattern
-	r.Patterns = append(r.Patterns, PathPattern{
-		Name:        "AccountID",
-		Regexp:      `^\d{1,10}$`,
-		Replacement: "{accountId}",
-	})
-	// Re-compile
+	// Use default patterns which now include AccountID
+	r.Patterns = DefaultPatterns()
+	// Compile all patterns
 	for i := range r.Patterns {
 		re, _ := regexp.Compile(r.Patterns[i].Regexp)
 		r.Patterns[i].compiled = re
 	}
 
+	accountID := "1234567"
 	req := &http.Request{
 		Method: "GET",
 		URL: &url.URL{
-			Path: "/marge/accounts/12345/full",
+			Path: "/marge/accounts/" + accountID + "/full",
 		},
 		Header: make(http.Header),
 	}
@@ -200,12 +216,13 @@ func TestRecorder_Record_Sanitization_Account(t *testing.T) {
 	if !strings.Contains(contentStr, "GET /marge/accounts/{{accountId}}/full") {
 		t.Errorf("Expected sanitized URL in .http file, got:\n%s", contentStr)
 	}
-	if !strings.Contains(contentStr, "// accountId: 12345") {
+	if !strings.Contains(contentStr, "// accountId: "+accountID) {
 		t.Errorf("Expected accountId comment in .http file, got:\n%s", contentStr)
 	}
 }
 
 func TestRecorder_Record_Redaction(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-redaction-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -255,6 +272,7 @@ func isDigit(c byte) bool {
 }
 
 func TestRecorder_IncreasingPrefix(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-prefix-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -262,6 +280,11 @@ func TestRecorder_IncreasingPrefix(t *testing.T) {
 	defer os.RemoveAll(tmpDir)
 
 	r := NewRecorder(tmpDir)
+	// Compile default patterns
+	for i := range r.Patterns {
+		re, _ := regexp.Compile(r.Patterns[i].Regexp)
+		r.Patterns[i].compiled = re
+	}
 	req := &http.Request{
 		Method: "GET",
 		URL: &url.URL{
@@ -292,6 +315,7 @@ func TestRecorder_IncreasingPrefix(t *testing.T) {
 }
 
 func TestRecorder_EnvFile(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
 	tmpDir, err := os.MkdirTemp("", "recorder-env-test")
 	if err != nil {
 		t.Fatalf("failed to create temp dir: %v", err)
@@ -299,6 +323,11 @@ func TestRecorder_EnvFile(t *testing.T) {
 	defer os.RemoveAll(tmpDir)
 
 	r := NewRecorder(tmpDir)
+	// Compile default patterns
+	for i := range r.Patterns {
+		re, _ := regexp.Compile(r.Patterns[i].Regexp)
+		r.Patterns[i].compiled = re
+	}
 	req := &http.Request{
 		Method: "GET",
 		URL: &url.URL{
@@ -327,3 +356,494 @@ func TestRecorder_EnvFile(t *testing.T) {
 		t.Errorf("Expected ip to be 192.168.178.35, got %s", content["session"]["ip"])
 	}
 }
+
+func TestRecorder_GetInteractionStats(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "recorder-stats-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+	r.SessionID = "20260215-120000-12345"
+
+	// Create some dummy interactions
+	files := []string{
+		"interactions/20260215-120000-12345/self/setup/0001-12-00-01.000-GET.http",
+		"interactions/20260215-120000-12345/upstream/marge/0002-12-00-02.000-POST.http",
+		"interactions/20260215-130000-67890/self/setup/0001-13-00-01.000-GET.http",
+	}
+
+	for _, f := range files {
+		path := filepath.Join(tmpDir, f)
+		os.MkdirAll(filepath.Dir(path), 0755)
+		os.WriteFile(path, []byte("test"), 0644)
+	}
+
+	stats, err := r.GetInteractionStats()
+	if err != nil {
+		t.Fatalf("GetInteractionStats failed: %v", err)
+	}
+
+	if stats.TotalRequests != 3 {
+		t.Errorf("Expected 3 total requests, got %d", stats.TotalRequests)
+	}
+
+	if stats.ByService["self"] != 2 {
+		t.Errorf("Expected 2 self requests, got %d", stats.ByService["self"])
+	}
+
+	if stats.ByService["upstream"] != 1 {
+		t.Errorf("Expected 1 upstream request, got %d", stats.ByService["upstream"])
+	}
+
+	if stats.BySession["20260215-120000-12345"] != 2 {
+		t.Errorf("Expected 2 requests for session 1, got %d", stats.BySession["20260215-120000-12345"])
+	}
+}
+
+func TestRecorder_ListInteractions(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "recorder-list-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+	session1 := "20260215-120000-12345"
+	session2 := "20260215-130000-67890"
+
+	// Create some dummy interactions
+	files := []struct {
+		path    string
+		content string
+	}{
+		{
+			path:    filepath.Join("interactions", session1, "self", "setup", "0001-12-00-01.555-GET.http"),
+			content: "### GET /setup\n\n> {% \n    // Response: 200 OK\n%}\n",
+		},
+		{
+			path:    filepath.Join("interactions", session1, "upstream", "marge", "0002-12-00-02.000-POST.http"),
+			content: "### POST /marge\n\n> {% \n    // Response: 201 Created\n%}\n",
+		},
+		{
+			path:    filepath.Join("interactions", session2, "self", "info", "0001-13-00-05.000-GET.http"),
+			content: "### GET /info\n\n> {% \n    // Response: 404 Not Found\n%}\n",
+		},
+	}
+
+	for _, f := range files {
+		path := filepath.Join(tmpDir, f.path)
+		os.MkdirAll(filepath.Dir(path), 0755)
+		os.WriteFile(path, []byte(f.content), 0644)
+	}
+
+	t.Run("List_all", func(t *testing.T) {
+		list, err := r.ListInteractions("", "", "")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		if len(list) != 3 {
+			t.Errorf("Expected 3 interactions, got %d", len(list))
+		}
+	})
+
+	t.Run("Filter_by_session", func(t *testing.T) {
+		list, err := r.ListInteractions(session1, "", "")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		if len(list) != 2 {
+			t.Errorf("Expected 2 interactions for session1, got %d", len(list))
+		}
+		for _, i := range list {
+			if i.Session != session1 {
+				t.Errorf("Expected session %s, got %s", session1, i.Session)
+			}
+		}
+	})
+
+	t.Run("Filter_by_category", func(t *testing.T) {
+		list, err := r.ListInteractions("", "upstream", "")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		if len(list) != 1 {
+			t.Errorf("Expected 1 upstream interaction, got %d", len(list))
+		}
+		if list[0].Category != "upstream" {
+			t.Errorf("Expected category upstream, got %s", list[0].Category)
+		}
+	})
+
+	t.Run("Check_enhanced_fields", func(t *testing.T) {
+		list, err := r.ListInteractions(session1, "self", "")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		if len(list) == 0 {
+			t.Fatal("Expected at least one interaction")
+		}
+		i := list[0]
+		if i.Counter != 1 {
+			t.Errorf("Expected counter 1, got %d", i.Counter)
+		}
+		if i.Status != 200 {
+			t.Errorf("Expected status 200, got %d", i.Status)
+		}
+		if i.Method != "GET" {
+			t.Errorf("Expected method GET, got %s", i.Method)
+		}
+		if i.Timestamp != "2026-02-15 12:00:01.555" {
+			t.Errorf("Expected timestamp 2026-02-15 12:00:01.555, got %s", i.Timestamp)
+		}
+		if i.Path != "/setup" {
+			t.Errorf("Expected path /setup, got %s", i.Path)
+		}
+	})
+
+	t.Run("Filter_by_since", func(t *testing.T) {
+		// session1 has 2026-02-15 12:00:01.555 and 12:00:02.000
+		// session2 has 2026-02-15 13:00:05.000
+		list, err := r.ListInteractions("", "", "2026-02-15 12:30:00")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		if len(list) != 1 {
+			t.Errorf("Expected 1 interaction since 12:30:00, got %d", len(list))
+		}
+		if list[0].Session != session2 {
+			t.Errorf("Expected session2, got %s", list[0].Session)
+		}
+
+		list, err = r.ListInteractions("", "", "2026-02-15 12:00:01.600")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+		// Should include 12:00:02.000 and 13:00:05.000
+		if len(list) != 2 {
+			t.Errorf("Expected 2 interactions since 12:00:01.600, got %d", len(list))
+		}
+	})
+}
+
+func TestRecorder_DeleteAndCleanup(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "recorder-delete-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+
+	// Create 15 dummy sessions
+	for i := 1; i <= 15; i++ {
+		// Use a format that sorts correctly: YYYYMMDD-HHmmss-PID
+		sessionID := fmt.Sprintf("20260215-12%02d00-12345", i)
+		sessionDir := filepath.Join(tmpDir, "interactions", sessionID)
+		os.MkdirAll(sessionDir, 0755)
+		os.WriteFile(filepath.Join(sessionDir, "test.http"), []byte("test"), 0644)
+	}
+
+	t.Run("Delete_specific_session", func(t *testing.T) {
+		sessionToDelete := "20260215-120500-12345"
+		err := r.DeleteSession(sessionToDelete)
+		if err != nil {
+			t.Fatalf("DeleteSession failed: %v", err)
+		}
+
+		if _, err := os.Stat(filepath.Join(tmpDir, "interactions", sessionToDelete)); !os.IsNotExist(err) {
+			t.Errorf("Session %s still exists after deletion", sessionToDelete)
+		}
+	})
+
+	t.Run("Cleanup_sessions", func(t *testing.T) {
+		err := r.CleanupSessions(10)
+		if err != nil {
+			t.Fatalf("CleanupSessions failed: %v", err)
+		}
+
+		entries, _ := os.ReadDir(filepath.Join(tmpDir, "interactions"))
+		if len(entries) != 10 {
+			t.Errorf("Expected 10 sessions to remain, got %d", len(entries))
+		}
+
+		// Ensure newest sessions are kept
+		// We created 1 to 15, deleted 5. Remaining: 1-4, 6-15 (14 sessions)
+		// Cleanup(10) should keep 15, 14, 13, 12, 11, 10, 9, 8, 7, 6.
+		expectedRemaining := []string{
+			"20260215-120600-12345",
+			"20260215-120700-12345",
+			"20260215-120800-12345",
+			"20260215-120900-12345",
+			"20260215-121000-12345",
+			"20260215-121100-12345",
+			"20260215-121200-12345",
+			"20260215-121300-12345",
+			"20260215-121400-12345",
+			"20260215-121500-12345",
+		}
+
+		for _, sessionID := range expectedRemaining {
+			if _, err := os.Stat(filepath.Join(tmpDir, "interactions", sessionID)); os.IsNotExist(err) {
+				t.Errorf("Expected session %s to remain, but it was deleted", sessionID)
+			}
+		}
+
+		// Check one that should be deleted
+		if _, err := os.Stat(filepath.Join(tmpDir, "interactions", "20260215-120100-12345")); !os.IsNotExist(err) {
+			t.Errorf("Session 20260215-120100-12345 should have been cleaned up")
+		}
+	})
+}
+
+func TestRecorder_GetInteractionContent(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "recorder-content-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+	relPath := filepath.Join(r.SessionID, "self", "test", "0001-GET.http")
+	fullPath := filepath.Join(tmpDir, "interactions", relPath)
+	os.MkdirAll(filepath.Dir(fullPath), 0755)
+
+	expectedContent := "test content"
+	os.WriteFile(fullPath, []byte(expectedContent), 0644)
+
+	content, err := r.GetInteractionContent(relPath)
+	if err != nil {
+		t.Fatalf("GetInteractionContent failed: %v", err)
+	}
+
+	if string(content) != expectedContent {
+		t.Errorf("Expected %s, got %s", expectedContent, string(content))
+	}
+
+	_, err = r.GetInteractionContent("non-existent")
+	if err == nil {
+		t.Error("Expected error for non-existent file, got nil")
+	}
+}
+
+func TestRecorder_ArchiveSession(t *testing.T) {
+	tmpDir, _ := os.MkdirTemp("", "archive-test")
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+
+	sessionID := "test-session-123"
+	sessionDir := filepath.Join(tmpDir, "interactions", sessionID)
+	os.MkdirAll(filepath.Join(sessionDir, "category1"), 0755)
+	os.WriteFile(filepath.Join(sessionDir, "category1", "file1.http"), []byte("content1"), 0644)
+	os.WriteFile(filepath.Join(sessionDir, "file2.http"), []byte("content2"), 0644)
+
+	var buf bytes.Buffer
+	err := r.ArchiveSession(sessionID, &buf)
+	if err != nil {
+		t.Fatalf("ArchiveSession failed: %v", err)
+	}
+
+	if buf.Len() == 0 {
+		t.Fatal("Archive buffer is empty")
+	}
+
+	// Verify it's a valid tar.gz
+	gr, err := gzip.NewReader(&buf)
+	if err != nil {
+		t.Fatalf("Failed to create gzip reader: %v", err)
+	}
+	defer gr.Close()
+
+	tr := tar.NewReader(gr)
+	files := make(map[string]string)
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatalf("Failed to read tar: %v", err)
+		}
+
+		if header.Typeflag == tar.TypeReg {
+			var b bytes.Buffer
+			io.Copy(&b, tr)
+			files[header.Name] = b.String()
+		}
+	}
+
+	if len(files) != 2 {
+		t.Errorf("Expected 2 files in archive, got %d", len(files))
+	}
+	if files["category1/file1.http"] != "content1" {
+		t.Errorf("Unexpected content for category1/file1.http: %s", files["category1/file1.http"])
+	}
+	if files["file2.http"] != "content2" {
+		t.Errorf("Unexpected content for file2.http: %s", files["file2.http"])
+	}
+}
+
+func TestRecorder_Record_FullExchange(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "recorder-full-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+
+	req := &http.Request{
+		Method: "POST",
+		URL: &url.URL{
+			Path: "/test",
+		},
+		Header: make(http.Header),
+		Body:   io.NopCloser(strings.NewReader("request body")),
+	}
+	req.Header.Set("Content-Type", "text/plain")
+
+	res := &http.Response{
+		StatusCode: 200,
+		Header:     make(http.Header),
+		Body:       io.NopCloser(strings.NewReader("response body")),
+		Request:    req,
+	}
+	res.Header.Set("Content-Type", "application/json")
+
+	err = r.Record("self", req, res)
+	if err != nil {
+		t.Fatalf("Record failed: %v", err)
+	}
+
+	// Verify file content
+	interactionsDir := filepath.Join(tmpDir, "interactions", r.SessionID, "self", "test")
+	files, _ := os.ReadDir(interactionsDir)
+	if len(files) == 0 {
+		t.Fatal("No recording file found")
+	}
+
+	content, _ := os.ReadFile(filepath.Join(interactionsDir, files[0].Name()))
+	contentStr := string(content)
+
+	if !strings.Contains(contentStr, "request body") {
+		t.Error("Recording does not contain request body")
+	}
+	if !strings.Contains(contentStr, "Response: 200 OK") {
+		t.Error("Recording does not contain response status")
+	}
+	if !strings.Contains(contentStr, "response body") {
+		t.Error("Recording does not contain response body")
+	}
+}
+
+func TestRecorder_Record_BinaryResponse(t *testing.T) {
+	t.Setenv("RECORDER_ASYNC", "false")
+	tmpDir, err := os.MkdirTemp("", "recorder-binary-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+
+	req := &http.Request{
+		Method: "GET",
+		URL:    &url.URL{Path: "/image"},
+	}
+
+	res := &http.Response{
+		StatusCode: 200,
+		Header:     make(http.Header),
+		Body:       io.NopCloser(bytes.NewBuffer([]byte{0x00, 0x01, 0x02, 0x03})),
+		Request:    req,
+	}
+	res.Header.Set("Content-Type", "image/png")
+
+	err = r.Record("self", req, res)
+	if err != nil {
+		t.Fatalf("Record failed: %v", err)
+	}
+
+	interactionsDir := filepath.Join(tmpDir, "interactions", r.SessionID, "self", "image")
+	files, _ := os.ReadDir(interactionsDir)
+	content, _ := os.ReadFile(filepath.Join(interactionsDir, files[0].Name()))
+	contentStr := string(content)
+
+	if !strings.Contains(contentStr, "[Binary response body: 4 bytes]") {
+		t.Error("Recording does not correctly report binary response")
+	}
+}
+
+func TestRecorder_ListInteractions_FullTimestamp(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "recorder-full-ts-test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	r := NewRecorder(tmpDir)
+	sessionID := "20260215-100000-12345"
+	r.SessionID = sessionID
+
+	// Create some dummy recordings
+	basePath := filepath.Join(tmpDir, "interactions", sessionID, "self", "test")
+	os.MkdirAll(basePath, 0755)
+
+	files := []string{
+		"0001-10-00-01.000-GET.http",
+		"0002-11-00-00.000-GET.http",
+	}
+
+	for _, f := range files {
+		os.WriteFile(filepath.Join(basePath, f), []byte("test"), 0644)
+	}
+
+	t.Run("Check_Full_Timestamp_Display", func(t *testing.T) {
+		interactions, err := r.ListInteractions(sessionID, "", "")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+
+		if len(interactions) != 2 {
+			t.Fatalf("Expected 2 interactions, got %d", len(interactions))
+		}
+
+		expectedTS := "2026-02-15 10:00:01.000"
+		if interactions[0].Timestamp != expectedTS {
+			t.Errorf("Expected timestamp %s, got %s", expectedTS, interactions[0].Timestamp)
+		}
+	})
+
+	t.Run("Filter_By_Full_Date_Time", func(t *testing.T) {
+		// Filter for interactions since 10:30:00 on that day
+		interactions, err := r.ListInteractions(sessionID, "", "2026-02-15 10:30:00")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+
+		if len(interactions) != 1 {
+			t.Fatalf("Expected 1 interaction, got %d", len(interactions))
+		}
+
+		if interactions[0].ID != "0002-11-00-00.000-GET.http" {
+			t.Errorf("Expected 0002-..., got %s", interactions[0].ID)
+		}
+	})
+
+	t.Run("Filter_By_Date_Only", func(t *testing.T) {
+		// Filter for interactions since the day before
+		interactions, err := r.ListInteractions(sessionID, "", "2026-02-14")
+		if err != nil {
+			t.Fatalf("ListInteractions failed: %v", err)
+		}
+
+		if len(interactions) != 2 {
+			t.Fatalf("Expected 2 interactions, got %d", len(interactions))
+		}
+	})
+}

pkg/service/setup/setup.go

@@ -59,9 +59,12 @@ type MigrationSummary struct {
 	DeviceName               string      `json:"device_name,omitempty"`
 	DeviceModel              string      `json:"device_model,omitempty"`
 	DeviceSerial             string      `json:"device_serial,omitempty"`
+	DeviceID                 string      `json:"device_id,omitempty"`
+	AccountID                string      `json:"account_id,omitempty"`
 	FirmwareVersion          string      `json:"firmware_version,omitempty"`
 	CACertTrusted            bool        `json:"ca_cert_trusted"`
 	ServerHTTPSURL           string      `json:"server_https_url,omitempty"`
+	IsMigrated               bool        `json:"is_migrated"`
 }
 
 // SSHClient defines the interface for SSH operations.
@@ -70,7 +73,7 @@ type SSHClient interface {
 	UploadContent(content []byte, remotePath string) error
 }
 
-// Manager handles the migration of speakers to the soundcork service.
+// Manager handles the migration of speakers to the service.
 type Manager struct {
 	ServerURL string
 	DataStore *datastore.DataStore
@@ -92,14 +95,15 @@ func NewManager(serverURL string, ds *datastore.DataStore, cm *certmanager.Certi
 
 // DeviceInfoXML represents the XML structure from :8090/info
 type DeviceInfoXML struct {
-	XMLName      xml.Name `xml:"info" json:"-"`
-	DeviceID     string   `xml:"deviceID,attr" json:"deviceID"`
-	Name         string   `xml:"name" json:"name"`
-	Type         string   `xml:"type" json:"type"`
-	MaccAddress  string   `xml:"maccAddress" json:"maccAddress"`
-	SoftwareVer  string   `xml:"-" json:"softwareVersion"`
-	SerialNumber string   `xml:"-" json:"serialNumber"`
-	Components   []struct {
+	XMLName          xml.Name `xml:"info" json:"-"`
+	DeviceID         string   `xml:"deviceID,attr" json:"deviceID"`
+	Name             string   `xml:"name" json:"name"`
+	Type             string   `xml:"type" json:"type"`
+	MaccAddress      string   `xml:"maccAddress" json:"maccAddress"`
+	SoftwareVer      string   `xml:"-" json:"softwareVersion"`
+	SerialNumber     string   `xml:"-" json:"serialNumber"`
+	MargeAccountUUID string   `xml:"margeAccountUUID" json:"margeAccountUUID"`
+	Components       []struct {
 		Category        string `xml:"componentCategory"`
 		SoftwareVersion string `xml:"softwareVersion"`
 		SerialNumber    string `xml:"serialNumber"`
@@ -211,6 +215,10 @@ func (m *Manager) GetMigrationSummary(deviceIP, targetURL, proxyURL string, opti
 				"stats.bose.com",
 				"bmx.bose.com",
 				"content.api.bose.io",
+				"events.api.bosecm.com",
+				"bose-prod.apigee.net",
+				"worldwide.bose.com",
+				"music.api.bose.com",
 			}
 
 			var hostsLines []string
@@ -242,9 +250,60 @@ func (m *Manager) GetMigrationSummary(deviceIP, targetURL, proxyURL string, opti
 		}
 	}
 
+	// 6. Check if migrated
+	m.checkIsMigrated(summary, deviceIP)
+
 	return summary, nil
 }
 
+// checkIsMigrated determines if the device is already migrated to AfterTouch.
+func (m *Manager) checkIsMigrated(summary *MigrationSummary, deviceIP string) {
+	if !summary.SSHSuccess {
+		return
+	}
+
+	// Case 1: XML Migration
+	// Check if any URL in the current config points to our server (targetURL)
+	if summary.ParsedCurrentConfig != nil {
+		targetURL := m.ServerURL
+		// Strip protocol for comparison if needed, or just check for substring
+		parsedTarget, err := url.Parse(targetURL)
+		if err == nil {
+			targetHost := parsedTarget.Hostname()
+			if strings.Contains(summary.ParsedCurrentConfig.MargeServerUrl, targetHost) ||
+				strings.Contains(summary.ParsedCurrentConfig.StatsServerUrl, targetHost) ||
+				strings.Contains(summary.ParsedCurrentConfig.SwUpdateUrl, targetHost) ||
+				strings.Contains(summary.ParsedCurrentConfig.BmxRegistryUrl, targetHost) {
+				summary.IsMigrated = true
+				return
+			}
+		}
+	}
+
+	// Case 2: /etc/hosts + Trust CA Migration
+	// Check if /etc/hosts contains redirections for Bose domains
+	client := m.NewSSH(deviceIP)
+
+	hostsContent, err := client.Run("cat /etc/hosts")
+	if err == nil {
+		boseDomains := []string{
+			"streaming.bose.com",
+			"updates.bose.com",
+			"stats.bose.com",
+			"bmx.bose.com",
+		}
+		for _, domain := range boseDomains {
+			if strings.Contains(hostsContent, domain) {
+				// If CA is also trusted, it's a strong indicator of migration
+				if summary.CACertTrusted {
+					summary.IsMigrated = true
+					return
+				}
+			}
+		}
+	}
+}
+
 // populateDeviceInfo fills in device information from datastore and live info
 func (m *Manager) populateDeviceInfo(summary *MigrationSummary, deviceIP string) {
 	// Populate from datastore if available
@@ -260,6 +319,8 @@ func (m *Manager) populateDeviceInfo(summary *MigrationSummary, deviceIP string)
 				summary.DeviceName = d.Name
 				summary.DeviceModel = d.ProductCode
 				summary.DeviceSerial = d.DeviceSerialNumber
+				summary.DeviceID = d.DeviceID
+				summary.AccountID = d.AccountID
 				summary.FirmwareVersion = d.FirmwareVersion
 
 				break
@@ -284,6 +345,14 @@ func (m *Manager) populateDeviceInfo(summary *MigrationSummary, deviceIP string)
 		if infoXML.SoftwareVer != "" {
 			summary.FirmwareVersion = infoXML.SoftwareVer
 		}
+
+		if infoXML.DeviceID != "" {
+			summary.DeviceID = infoXML.DeviceID
+		}
+
+		if infoXML.MargeAccountUUID != "" {
+			summary.AccountID = infoXML.MargeAccountUUID
+		}
 	}
 }
 
@@ -341,19 +410,19 @@ func (m *Manager) applyProxyOptions(plannedCfg *PrivateCfg, proxyURL string, opt
 		return
 	}
 
-	if options["marge"] == "original" && currentCfg.MargeServerUrl != "" {
+	if options["marge"] == "upstream" && currentCfg.MargeServerUrl != "" {
 		plannedCfg.MargeServerUrl = fmt.Sprintf("%s/proxy/%s", proxyURL, currentCfg.MargeServerUrl)
 	}
 
-	if options["stats"] == "original" && currentCfg.StatsServerUrl != "" {
+	if options["stats"] == "upstream" && currentCfg.StatsServerUrl != "" {
 		plannedCfg.StatsServerUrl = fmt.Sprintf("%s/proxy/%s", proxyURL, currentCfg.StatsServerUrl)
 	}
 
-	if options["sw_update"] == "original" && currentCfg.SwUpdateUrl != "" {
+	if options["sw_update"] == "upstream" && currentCfg.SwUpdateUrl != "" {
 		plannedCfg.SwUpdateUrl = fmt.Sprintf("%s/proxy/%s", proxyURL, currentCfg.SwUpdateUrl)
 	}
 
-	if options["bmx"] == "original" && currentCfg.BmxRegistryUrl != "" {
+	if options["bmx"] == "upstream" && currentCfg.BmxRegistryUrl != "" {
 		plannedCfg.BmxRegistryUrl = fmt.Sprintf("%s/proxy/%s", proxyURL, currentCfg.BmxRegistryUrl)
 	}
 }
@@ -424,7 +493,7 @@ func (m *Manager) checkCACertTrusted(summary *MigrationSummary, deviceIP string)
 	}
 }
 
-// MigrateSpeaker configures the speaker at the given IP to use this soundcork service.
+// MigrateSpeaker configures the speaker at the given IP to use this service.
 func (m *Manager) MigrateSpeaker(deviceIP, targetURL, proxyURL string, options map[string]string, method MigrationMethod) (string, error) {
 	if targetURL == "" {
 		targetURL = m.ServerURL
@@ -557,18 +626,39 @@ func (m *Manager) BackupConfigOffDevice(deviceIP string) error {
 
 	client := m.NewSSH(deviceIP)
 
-	// We need the serial number to find the right directory in DataStore
+	// We need the serial number and account identifier to find the right directory in DataStore
 	info, err := m.GetLiveDeviceInfo(deviceIP)
 	if err != nil {
 		return fmt.Errorf("failed to get device info: %w", err)
 	}
 
-	serial := info.SerialNumber
-	if serial == "" {
-		return fmt.Errorf("could not determine device serial number")
+	accountID := info.MargeAccountUUID
+	deviceID := info.SerialNumber
+
+	if deviceID == "" {
+		deviceID = info.DeviceID
 	}
 
-	deviceDir := m.DataStore.AccountDeviceDir("default", serial)
+	if deviceID == "" {
+		deviceID = deviceIP
+	}
+
+	if accountID == "" {
+		// Try to find account ID from existing device entries if info didn't have it
+		devices, _ := m.DataStore.ListAllDevices()
+		for i := range devices {
+			if devices[i].DeviceSerialNumber == info.SerialNumber || (info.DeviceID != "" && devices[i].DeviceID == info.DeviceID) {
+				accountID = devices[i].AccountID
+				break
+			}
+		}
+	}
+
+	if accountID == "" {
+		accountID = "default"
+	}
+
+	deviceDir := m.DataStore.AccountDeviceDir(accountID, deviceID)
 	if err := os.MkdirAll(deviceDir, 0755); err != nil {
 		return fmt.Errorf("failed to create device directory: %w", err)
 	}
@@ -772,6 +862,9 @@ func (m *Manager) migrateViaHosts(deviceIP, targetURL string) (string, error) {
 		"stats.bose.com",
 		"bmx.bose.com",
 		"content.api.bose.io",
+		"events.api.bosecm.com",
+		"bose-prod.apigee.net",
+		"worldwide.bose.com",
 	}
 
 	hostsContent, err := client.Run("cat /etc/hosts")
@@ -781,16 +874,53 @@ func (m *Manager) migrateViaHosts(deviceIP, targetURL string) (string, error) {
 		return logs, fmt.Errorf("failed to read /etc/hosts: %w", err)
 	}
 
-	for _, domain := range domains {
-		if !strings.Contains(hostsContent, domain) {
-			entry := fmt.Sprintf("%s\t%s", hostIP, domain)
+	lines := strings.Split(hostsContent, "\n")
 
-			if hostsContent != "" && !strings.HasSuffix(hostsContent, "\n") {
-				hostsContent += "\n"
+	var newLines []string
+
+	domainFound := make(map[string]bool)
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
+			newLines = append(newLines, line)
+			continue
+		}
+
+		fields := strings.Fields(trimmed)
+		if len(fields) >= 2 {
+			domain := fields[1]
+			isBoseDomain := false
+
+			for _, d := range domains {
+				if d == domain {
+					isBoseDomain = true
+					break
+				}
 			}
 
-			hostsContent += entry + "\n"
+			if isBoseDomain {
+				// Update existing entry with new IP
+				newLines = append(newLines, fmt.Sprintf("%s\t%s", hostIP, domain))
+				domainFound[domain] = true
+
+				continue
+			}
 		}
+
+		newLines = append(newLines, line)
+	}
+
+	// Add missing domains
+	for _, domain := range domains {
+		if !domainFound[domain] {
+			newLines = append(newLines, fmt.Sprintf("%s\t%s", hostIP, domain))
+		}
+	}
+
+	hostsContent = strings.Join(newLines, "\n")
+	if !strings.HasSuffix(hostsContent, "\n") {
+		hostsContent += "\n"
 	}
 
 	// 3. Upload new /etc/hosts
@@ -966,7 +1096,7 @@ func (m *Manager) Reboot(deviceIP string) (string, error) {
 const TestDomain = "custom-test-api.bose.fake"
 
 // CALabel is the label used to identify the local CA certificate in the trust store.
-const CALabel = "# Soundcork Local Root CA"
+const CALabel = "# AfterTouch"
 
 // TestHostsRedirection performs a preliminary check to see if /etc/hosts redirection works.
 func (m *Manager) TestHostsRedirection(deviceIP, targetURL string) (string, error) {
@@ -1207,13 +1337,32 @@ func (m *Manager) SyncDeviceData(deviceIP string) error {
 		return fmt.Errorf("failed to get device info: %w", err)
 	}
 
-	accountID := "default"
+	accountID := ""
 
 	deviceID := info.SerialNumber
 	if deviceID == "" {
 		deviceID = deviceIP
 	}
 
+	if info.MargeAccountUUID != "" {
+		accountID = info.MargeAccountUUID
+	}
+
+	if accountID == "" {
+		// Try to find account ID from existing device entries if info didn't have it
+		devices, _ := m.DataStore.ListAllDevices()
+		for i := range devices {
+			if devices[i].DeviceSerialNumber == info.SerialNumber || devices[i].DeviceID == info.DeviceID {
+				accountID = devices[i].AccountID
+				break
+			}
+		}
+	}
+
+	if accountID == "" {
+		accountID = "default"
+	}
+
 	// 2. Fetch Presets from :8090
 	m.syncPresets(deviceIP, accountID, deviceID)
 

pkg/service/setup/setup_test.go

@@ -109,6 +109,60 @@ func TestMigrateViaHosts(t *testing.T) {
 	}
 }
 
+func TestMigrateViaHosts_UpdateExisting(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "setup-test-update")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	cm := certmanager.NewCertificateManager(filepath.Join(tempDir, "certs"))
+	_ = cm.EnsureCA()
+
+	m := NewManager("http://192.168.1.100:8000", nil, cm)
+
+	m.NewSSH = func(host string) SSHClient {
+		return &mockSSH{
+			runFunc: func(command string) (string, error) {
+				if command == "cat /etc/hosts" {
+					return "127.0.0.1 localhost\n1.2.3.4\tstreaming.bose.com\n1.2.3.4\tupdates.bose.com", nil
+				}
+				if strings.HasPrefix(command, "[ -f") {
+					return "", nil // Backup already exists
+				}
+				if strings.HasPrefix(command, "grep -F") {
+					return "matched", nil // CA already trusted
+				}
+				return "", nil
+			},
+			uploadContentFunc: func(content []byte, remotePath string) error {
+				if remotePath == "/etc/hosts" {
+					c := string(content)
+					if !strings.Contains(c, "192.168.1.100\tstreaming.bose.com") {
+						t.Errorf("Expected updated IP for streaming.bose.com, got:\n%s", c)
+					}
+					if !strings.Contains(c, "192.168.1.100\tupdates.bose.com") {
+						t.Errorf("Expected updated IP for updates.bose.com, got:\n%s", c)
+					}
+					if !strings.Contains(c, "192.168.1.100\tevents.api.bosecm.com") {
+						t.Errorf("Expected new domain events.api.bosecm.com, got:\n%s", c)
+					}
+					// Ensure no duplicates
+					if strings.Count(c, "streaming.bose.com") != 1 {
+						t.Errorf("Expected streaming.bose.com to appear exactly once, got %d", strings.Count(c, "streaming.bose.com"))
+					}
+				}
+				return nil
+			},
+		}
+	}
+
+	_, err = m.migrateViaHosts("192.168.1.10", "http://192.168.1.100:8000")
+	if err != nil {
+		t.Fatalf("migrateViaHosts failed: %v", err)
+	}
+}
+
 func TestGetLiveDeviceInfo(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path != "/info" {
@@ -187,7 +241,7 @@ func TestGetMigrationSummary_WithProxyOptions(t *testing.T) {
 	defer server.Close()
 
 	host := server.Listener.Addr().String()
-	manager := NewManager("http://soundcork:8000", nil, nil)
+	manager := NewManager("http://st-service:8000", nil, nil)
 
 	// Since we can't easily mock SSH here without a full SSH server,
 	// we are testing the logic that depends on ParsedCurrentConfig being nil or not.
@@ -195,10 +249,10 @@ func TestGetMigrationSummary_WithProxyOptions(t *testing.T) {
 	// If SSH fails, ParsedCurrentConfig will be nil.
 
 	options := map[string]string{
-		"marge":     "original",
-		"stats":     "soundcork",
-		"sw_update": "original",
-		"bmx":       "soundcork",
+		"marge":     "upstream",
+		"stats":     "self",
+		"sw_update": "upstream",
+		"bmx":       "self",
 	}
 
 	summary, err := manager.GetMigrationSummary(host, "http://target:8000", "http://proxy:8000", options)
@@ -776,11 +830,12 @@ func TestBackupConfigOffDevice(t *testing.T) {
 	m := NewManager("http://localhost:8000", ds, nil)
 
 	serial := "08DF1F0BA325"
+	accountID := "3230304"
 
 	// Mock info server
 	infoServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/xml")
-		fmt.Fprintf(w, `<info deviceID="%s"><name>Test</name><components><component><componentCategory>SCM</componentCategory><serialNumber>%s</serialNumber></component></components></info>`, serial, serial)
+		fmt.Fprintf(w, `<info deviceID="%s"><name>Test</name><margeAccountUUID>%s</margeAccountUUID><components><component><componentCategory>SCM</componentCategory><serialNumber>%s</serialNumber></component></components></info>`, serial, accountID, serial)
 	}))
 	defer infoServer.Close()
 
@@ -808,7 +863,7 @@ func TestBackupConfigOffDevice(t *testing.T) {
 	}
 
 	// Verify files were created in datastore
-	deviceDir := m.DataStore.AccountDeviceDir("default", serial)
+	deviceDir := m.DataStore.AccountDeviceDir(accountID, serial)
 	configPath := filepath.Join(deviceDir, "SoundTouchSdkPrivateCfg.xml.bak")
 	hostsPath := filepath.Join(deviceDir, "hosts.bak")
 
@@ -857,3 +912,65 @@ func TestMigrateSpeaker_PreFlightFailure(t *testing.T) {
 func contains(s, substr string) bool {
 	return strings.Contains(s, substr)
 }
+
+func TestCheckIsMigrated(t *testing.T) {
+	m := NewManager("http://aftertouch:8000", nil, nil)
+
+	t.Run("XML Migrated", func(t *testing.T) {
+		summary := &MigrationSummary{
+			SSHSuccess: true,
+			ParsedCurrentConfig: &PrivateCfg{
+				MargeServerUrl: "http://aftertouch:8000/marge",
+			},
+		}
+		m.checkIsMigrated(summary, "127.0.0.1")
+		if !summary.IsMigrated {
+			t.Errorf("Expected IsMigrated to be true for XML migration")
+		}
+	})
+
+	t.Run("Hosts Migrated", func(t *testing.T) {
+		m.NewSSH = func(host string) SSHClient {
+			return &mockSSH{
+				runFunc: func(command string) (string, error) {
+					if command == "cat /etc/hosts" {
+						return "127.0.0.1\tstreaming.bose.com", nil
+					}
+					return "", nil
+				},
+			}
+		}
+		summary := &MigrationSummary{
+			SSHSuccess:    true,
+			CACertTrusted: true,
+		}
+		m.checkIsMigrated(summary, "127.0.0.1")
+		if !summary.IsMigrated {
+			t.Errorf("Expected IsMigrated to be true for hosts migration")
+		}
+	})
+
+	t.Run("Not Migrated", func(t *testing.T) {
+		m.NewSSH = func(host string) SSHClient {
+			return &mockSSH{
+				runFunc: func(command string) (string, error) {
+					if command == "cat /etc/hosts" {
+						return "127.0.0.1\tlocalhost", nil
+					}
+					return "", nil
+				},
+			}
+		}
+		summary := &MigrationSummary{
+			SSHSuccess: true,
+			ParsedCurrentConfig: &PrivateCfg{
+				MargeServerUrl: "http://streaming.bose.com/marge",
+			},
+			CACertTrusted: false,
+		}
+		m.checkIsMigrated(summary, "127.0.0.1")
+		if summary.IsMigrated {
+			t.Errorf("Expected IsMigrated to be false for non-migrated device")
+		}
+	})
+}

scripts/raspberry-pi/install.sh

@@ -28,7 +28,7 @@ set -euo pipefail
 # - Safe to re-run; it will update binary/config/unit and restart the service.
 # ==============================================================================
 
-VERSION="${1:-${VERSION:-v0.18.1}}"
+VERSION="${1:-${VERSION:-v0.24.0}}"
 # Normalize version prefix
 if [[ ! "$VERSION" =~ ^v ]]; then
   VERSION="v${VERSION}"
@@ -141,7 +141,7 @@ ensure_dirs() {
 }
 
 download_binary() {
-  local asset url tmp
+  local asset url tmp=""
   asset="${ARCH_ASSET:-$(detect_arch_asset)}"
   url="$(download_url_for "$asset")"