feat(export): encrypted diagnostic report for issue reporting

Adds a "Download diagnostic report" button on the Health tab that
produces an age-encrypted .age file the user can attach to a GitHub
issue without exposing sensitive data.

Archive contents (tar.gz, then age-encrypted with the maintainer's
SSH ed25519 public key):
- diagnostic.json         structured health/device summary (no secrets)
- datastore/…/*.xml       raw on-disk XML verbatim for diff vs HTTP
- http/service/…          live service HTTP responses per account/device
- http/speaker/…          live speaker API responses (port 8090)
- ssh/speaker/…           CA bundles + logread (last 20 min, 127.0.0.1
                          filtered) + dmesg fetched via SSH
- system/ca.pem           service CA cert
- system/resolv.conf      host DNS resolver config
- settings.json           service settings (OAuth secrets redacted)
- env.txt                 filtered process environment
- logs/service.txt        in-memory service log buffer

Supporting tooling:
- scripts/setup-diagnostic-key.sh  one-time SSH key-pair generation
- scripts/decrypt-diagnostic.go    go run helper for maintainer decryption
- keys/public/diagnostic.pub       committed public key (matches github.com/gesellix.keys)
- docs/DIAGNOSTIC-EXPORT.md        maintainer setup + user workflow guide
- docs/concepts/ENCRYPTED-EXPORT.md  research notes and architecture rationale

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

.dockerignore

@@ -0,0 +1,33 @@
+# .dockerignore
+
+# Exclude large firmware files and archives
+firmware/
+data/
+
+# Exclude local build artifacts
+build/
+soundtouch-cli
+soundtouch-service
+
+# Exclude Go specific files that aren't needed for build context
+# (go.mod and go.sum ARE needed, but other local stuff isn't)
+.cache/
+vendor/
+
+# Exclude IDE and system files
+.idea/
+.vscode/
+.DS_Store
+
+# Exclude Git history
+.git/
+.gitignore
+
+# Exclude documentation and other non-essential files for the binary build
+docs/
+examples/
+scripts/
+CONTRIBUTING.md
+CODE_OF_CONDUCT.md
+LICENSE
+README.md

.docsignore

@@ -0,0 +1,5 @@
+# Files intentionally not linked in docs/SUMMARY.md.
+# Paths are relative to the docs/ directory.
+# Lines starting with # and blank lines are ignored.
+
+#analysis/bose-soundtouch-community-tools.md

.editorconfig

@@ -0,0 +1,17 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.html]
+# HTML-specific formatting
+# Standardize on tag layout
+ij_html_do_not_indent_children_of_tags = html,body,thead,tbody,tfoot
+ij_html_keep_blank_lines = 1
+ij_html_attribute_wrap = normal
+ij_html_space_inside_empty_tag = false

.env.example

@@ -1,6 +1,28 @@
 # Bose SoundTouch Configuration
 # Copy this file to .env and customize for your setup
 
+# Docker/Service Settings
+SOUNDTOUCH_HOSTNAME=soundtouch.local
+SOUNDTOUCH_VERSION=latest
+
+# Stockholm frontend (used by make prepare-stockholm and by the Go service at startup)
+# BACKEND_URL is the base URL your speakers and browser can reach the service at.
+# Corresponds to SERVER_URL in the Go service.
+# BACKEND_URL=http://soundtouch.local:8000
+#
+# STREAMING_URL is used for streaming.bose.com rewrites (defaults to BACKEND_URL).
+# Set to $(BACKEND_URL)/marge only when routing through a soundcork backend.
+# STREAMING_URL=http://soundtouch.local:8000
+#
+# AUTH_SERVICE_URL is written into config.json as the auth endpoint (defaults to BACKEND_URL).
+# A trailing slash is added automatically; the JS appends paths like "oauth/account/..." directly.
+# AUTH_SERVICE_URL=http://soundtouch.local:8000
+#
+# STOCKHOLM_BASE_PATH mounts the Stockholm UI under a URL prefix, freeing / for the management UI.
+# The bridge API (/api/native/*, /api/http-proxy) remains at root regardless of this setting.
+# Defaults to /stockholm. Set to empty to serve at root.
+# STOCKHOLM_BASE_PATH=/stockholm
+
 # Discovery Settings
 DISCOVERY_TIMEOUT=5s
 UPNP_ENABLED=true
@@ -21,20 +43,37 @@ CACHE_TTL=30s
 
 # Examples:
 # Single device with default port:
-# PREFERRED_DEVICES="192.168.1.100"
+# PREFERRED_DEVICES="192.0.2.100"
 
 # Single device with custom name:
-# PREFERRED_DEVICES="Living Room@192.168.1.100"
+# PREFERRED_DEVICES="Living Room@192.0.2.100"
 
 # Single device with custom port:
-# PREFERRED_DEVICES="192.168.1.100:8091"
+# PREFERRED_DEVICES="192.0.2.100:8091"
 
 # Multiple devices with mixed configurations:
-PREFERRED_DEVICES="Living Room@192.168.1.100:8090;Kitchen@192.168.1.101;192.168.1.102:8091"
+PREFERRED_DEVICES="Living Room@192.0.2.100:8090;Kitchen@192.0.2.101;192.0.2.102:8091"
 
-# Real example based on your devices:
-# PREFERRED_DEVICES="Sound Machinechen@192.168.178.35;A Sound Machine@192.168.178.28"
+# Example — replace with your speakers' names and IPs:
+# PREFERRED_DEVICES="Living Room SoundTouch@192.0.2.10;Kitchen SoundTouch@192.0.2.11"
 
 # Alternative format examples:
-# PREFERRED_DEVICES="192.168.178.35;192.168.178.28"
-# PREFERRED_DEVICES="SoundTouch 10@192.168.178.35;SoundTouch 20@192.168.178.28"
+# PREFERRED_DEVICES="192.0.2.10;192.0.2.11"
+# PREFERRED_DEVICES="SoundTouch 10@192.0.2.10;SoundTouch 20@192.0.2.11"
+
+# Spotify Integration
+# Create an app at https://developer.spotify.com/dashboard
+# SPOTIFY_CLIENT_ID=your_client_id
+# SPOTIFY_CLIENT_SECRET=your_client_secret
+# Auth confirmation url using GET, works in browsers
+# SPOTIFY_REDIRECT_URI=https://your-server.example.com/mgmt/spotify/callback
+# Auth confirmation url using POST, works with the ueberboese-app (https://github.com/julius-d/ueberboese-app)
+# SPOTIFY_REDIRECT_URI=https://your-server.example.com/mgmt/spotify/confirm
+
+# Management API Authentication
+# Protects /mgmt/* endpoints (Spotify token access, account management)
+MGMT_USERNAME=admin
+MGMT_PASSWORD=change_me!
+
+# External base URL (required when behind a reverse proxy for OAuth callbacks)
+# BASE_URL=https://your-server.example.com

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,77 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Environment (please complete the following information):**
+- OS: [e.g. macOS 14.0, Windows 11, Ubuntu 22.04]
+- Go version: [e.g. 1.25.5]
+- Library version: [e.g. v1.0.0, commit hash if using main branch]
+- SoundTouch device model: [e.g. SoundTouch 10, SoundTouch 20]
+- Device firmware version: [if known]
+
+**Command/Code that failed**
+```bash
+# If using CLI tool, provide the exact command
+soundtouch-cli --host 192.0.2.100 info get
+
+# If using Go library, provide minimal code example
+```
+
+**Error output**
+```
+Paste the complete error message here, including stack traces if available
+```
+
+**Device Information (if applicable)**
+```xml
+<!-- If the issue is device-specific, include output from: -->
+<!-- soundtouch-cli --host YOUR_DEVICE_IP info get -->
+```
+
+**Network Configuration**
+- Network setup: [e.g. home WiFi, corporate network, VPN]
+- Firewall/proxy: [any network restrictions]
+- Device connectivity: [how device connects to network - WiFi, Ethernet]
+
+**Additional context**
+Add any other context about the problem here. For example:
+- Does this happen consistently or intermittently?
+- Did this work in a previous version?
+- Are there any workarounds?
+- Any relevant log files or debug output
+
+**Logs (if applicable)**
+```
+# Enable verbose logging with --verbose flag or debug environment variable
+# and paste relevant log output here
+```
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+---
+
+**Checklist**
+- [ ] I have searched existing issues to avoid duplicates
+- [ ] I have tested with the latest version
+- [ ] I have included all relevant environment information
+- [ ] I have provided a minimal reproduction case
+- [ ] I have included complete error messages

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -24,10 +24,10 @@ body:
       label: Go Version
       description: What version of Go are you using?
       options:
+        - "1.25.5+"
+        - "1.25"
+        - "1.24"
         - "1.23"
-        - "1.22"
-        - "1.21"
-        - "1.20"
         - "Other (please specify in description)"
     validations:
       required: true
@@ -163,7 +163,7 @@ body:
       label: Network Configuration
       description: Details about your network setup (if relevant to the issue)
       placeholder: |
-        - Device IP: 192.168.1.100
+        - Device IP: 192.0.2.100
         - Network type: WiFi/Ethernet
         - Router model:
         - Any firewalls or network restrictions:

.github/ISSUE_TEMPLATE/device_compatibility.md

@@ -0,0 +1,113 @@
+---
+name: Device compatibility report
+about: Report compatibility with a new SoundTouch device model
+title: 'Device Compatibility: [Device Model]'
+labels: 'compatibility, documentation'
+assignees: ''
+
+---
+
+**Device Information**
+- **Model**: [e.g. SoundTouch 30, Wave SoundTouch IV, SoundTouch Portable]
+- **Model Number**: [e.g. 738102-2100, found on device label]
+- **Firmware Version**: [if known, from device settings or API response]
+- **Purchase Date**: [approximate, helps identify firmware generation]
+
+**Testing Results**
+
+### Basic Functionality
+- [ ] Device discovery (UPnP/mDNS)
+- [ ] Basic device info (`GET /info`)
+- [ ] Now playing status (`GET /now_playing`)
+- [ ] Media controls (play/pause/stop)
+- [ ] Volume control
+- [ ] Source listing (`GET /sources`)
+
+### Advanced Features
+- [ ] Bass control (`GET/POST /bass`)
+- [ ] Balance control (`GET/POST /balance`) - if stereo device
+- [ ] Clock/time management (`GET/POST /clockTime`)
+- [ ] Network information (`GET /networkInfo`)
+- [ ] WebSocket events
+- [ ] Multiroom zones (master)
+- [ ] Multiroom zones (slave)
+
+### Advanced Audio Controls (Professional/High-end Models)
+- [ ] DSP controls (`GET/POST /audiodspcontrols`)
+- [ ] Tone controls (`GET/POST /audioproducttonecontrols`)
+- [ ] Level controls (`GET/POST /audioproductlevelcontrols`)
+
+### Known Issues
+List any features that don't work or behave unexpectedly:
+- Feature name: Description of issue
+- Command that fails: `soundtouch-cli command that doesn't work`
+
+**Device Info Output**
+```xml
+<!-- Paste output from: soundtouch-cli --host YOUR_DEVICE_IP info get -->
+<!-- This helps us understand device capabilities and variants -->
+```
+
+**Device Capabilities Output**
+```xml
+<!-- Paste output from: soundtouch-cli --host YOUR_DEVICE_IP capabilities -->
+<!-- This shows what features the device reports as available -->
+```
+
+**Bass Capabilities (if supported)**
+```xml
+<!-- Paste output from: soundtouch-cli --host YOUR_DEVICE_IP bass capabilities -->
+<!-- Only if the device supports bass control -->
+```
+
+**Available Sources**
+```xml
+<!-- Paste output from: soundtouch-cli --host YOUR_DEVICE_IP source list -->
+<!-- Shows what audio sources this device supports -->
+```
+
+**Testing Commands Used**
+```bash
+# List the specific commands you used for testing
+soundtouch-cli --host 192.0.2.100 info get
+soundtouch-cli --host 192.0.2.100 play start
+# ... etc
+```
+
+**Environment**
+- **OS**: [e.g. macOS 14.0, Windows 11, Ubuntu 22.04]
+- **Go version**: [e.g. 1.25.5]
+- **Library version**: [e.g. v1.0.0, commit hash]
+- **Network setup**: [home WiFi, corporate, etc.]
+
+**Performance Notes**
+- Response times: [normal, slow, timeouts]
+- Specific timeouts: [any endpoints that timeout]
+- WebSocket stability: [connects reliably, frequent disconnects, etc.]
+
+**Comparison with Tested Models**
+If you have experience with other SoundTouch models:
+- **Similar to**: [e.g. works like SoundTouch 20]
+- **Differences from**: [e.g. missing balance control compared to SoundTouch 30]
+
+**Additional Notes**
+Any other observations about device behavior, quirks, or special considerations:
+- Does the device have unique features not seen in other models?
+- Are there any setup requirements or configuration notes?
+- Does it work differently in different network environments?
+
+**Documentation Impact**
+- [ ] Update supported devices list
+- [ ] Add device-specific notes to documentation
+- [ ] Update compatibility matrix
+- [ ] Add to integration test suite
+
+---
+
+**Checklist**
+- [ ] I have tested basic functionality (info, play, volume)
+- [ ] I have tested advanced features available on this device
+- [ ] I have provided complete device information output
+- [ ] I have noted any issues or limitations
+- [ ] I have tested in a typical network environment
+- [ ] I understand this helps improve compatibility for all users

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,77 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Use case**
+Describe your specific use case and how this feature would benefit you and other users.
+
+**SoundTouch API Support**
+- [ ] This feature is supported by the official SoundTouch API
+- [ ] This feature is NOT supported by the SoundTouch API (custom enhancement)
+- [ ] I'm not sure if this is supported by the SoundTouch API
+
+**API Documentation Reference (if applicable)**
+If this feature is based on a SoundTouch API endpoint, please provide:
+- Endpoint URL: [e.g. GET /newendpoint]
+- Documentation reference: [page number or section in official API docs]
+- XML request/response examples: [if known]
+
+**Implementation Details (optional)**
+If you have ideas about how this could be implemented:
+- Suggested package/module: [e.g. pkg/client, cmd/soundtouch-cli]
+- Method signatures: [if you have suggestions]
+- CLI commands: [if this affects the CLI tool]
+
+**Device Compatibility**
+- SoundTouch models this applies to: [e.g. all models, SoundTouch 20+, specific models]
+- Have you tested this manually: [e.g. via curl, Postman, etc.]
+
+**Examples**
+Provide examples of how you would like to use this feature:
+
+```go
+// Go library example
+client.NewFeature(parameters)
+```
+
+```bash
+# CLI example
+soundtouch-cli --host 192.0.2.100 new-feature --param value
+```
+
+**Priority**
+- [ ] Critical - blocks important functionality
+- [ ] High - would significantly improve user experience
+- [ ] Medium - nice to have enhancement
+- [ ] Low - minor improvement
+
+**Additional context**
+Add any other context, screenshots, or examples about the feature request here.
+
+**Related Issues**
+- Related to #[issue number]
+- Depends on #[issue number]
+- Blocks #[issue number]
+
+---
+
+**Checklist**
+- [ ] I have searched existing issues to avoid duplicates
+- [ ] I have checked the documentation to ensure this feature doesn't already exist
+- [ ] I have provided a clear use case and rationale
+- [ ] I have considered the impact on existing functionality
+- [ ] I understand this may require SoundTouch API support to implement

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -131,7 +131,7 @@ body:
       render: go
       placeholder: |
         // Example of how you envision using this feature
-        client := soundtouch.New("192.168.1.100", 8090)
+        client := soundtouch.New("192.0.2.100", 8090)
 
         // Your desired API call
         result, err := client.NewFeature(options)

.github/dependabot.yml

@@ -77,3 +77,46 @@ updates:
           - "*scan*"
           - "securecodewarrior/*"
           - "codecov/*"
+
+  # Docker dependency updates
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "wednesday"
+      time: "09:00"
+      timezone: "UTC"
+    open-pull-requests-limit: 3
+    reviewers:
+      - "gesellix"
+    assignees:
+      - "gesellix"
+    commit-message:
+      prefix: "docker"
+      include: "scope"
+    labels:
+      - "dependencies"
+      - "docker"
+    rebase-strategy: "auto"
+
+  # npm dependency updates
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "thursday"
+      time: "09:00"
+      timezone: "UTC"
+    open-pull-requests-limit: 3
+    reviewers:
+      - "gesellix"
+    assignees:
+      - "gesellix"
+    commit-message:
+      prefix: "deps"
+      include: "scope"
+    labels:
+      - "dependencies"
+      - "npm"
+      - "frontend"
+    rebase-strategy: "auto"

.github/markdown-link-check.json

@@ -3,7 +3,7 @@
   "retryOn429": true,
   "retryCount": 3,
   "fallbackRetryDelay": "30s",
-  "aliveStatusCodes": [200, 206],
+  "aliveStatusCodes": [200, 202, 206],
   "ignorePatterns": [
     {
       "pattern": "^http://localhost"
@@ -25,6 +25,24 @@
     },
     {
       "pattern": "^https://pkg.go.dev.*badge"
+    },
+    {
+      "pattern": "^\\.\\./images/(dashboard-home|account-creation|account-dashboard|usb-remote-services|device-discovery|device-registration|account-migration|migration-setup|migration-progress|migration-health|migration-complete|backup-setup)\\.png$"
+    },
+    {
+      "pattern": "https://www.contributor-covenant.org/version/2/0/code_of_conduct.html"
+    },
+    {
+      "pattern": "https://www.apkmirror.com/apk/bose-corporation/bose-soundtouch/"
+    },
+    {
+      "pattern": "https://apkpure.com/bose-soundtouch/com.bose.soundtouch"
+    },
+    {
+      "pattern": "^https://bose\\.fandom\\.com/"
+    },
+    {
+      "pattern": "^https://www\\.reddit\\.com/"
     }
   ],
   "replacementPatterns": [

.github/pull_request_template.md

@@ -0,0 +1,171 @@
+## Description
+
+Brief description of the changes in this PR.
+
+## Type of Change
+
+Please check the type of change your PR introduces:
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+- [ ] Performance improvement
+- [ ] Code refactoring (no functional changes)
+- [ ] Test improvements
+- [ ] Build/CI improvements
+
+## Related Issues
+
+- Fixes #[issue number]
+- Relates to #[issue number]
+- Part of #[issue number]
+
+## Changes Made
+
+### API Changes
+- [ ] Added new endpoints
+- [ ] Modified existing endpoints
+- [ ] Added new CLI commands
+- [ ] Modified existing CLI commands
+- [ ] Added new configuration options
+
+### Implementation Details
+- Describe the main changes
+- List any new dependencies
+- Mention any architectural changes
+
+## Testing
+
+### Automated Tests
+- [ ] Unit tests added/updated
+- [ ] Integration tests added/updated
+- [ ] All existing tests pass
+- [ ] Test coverage maintained or improved
+
+### Manual Testing
+- [ ] Tested with real SoundTouch device(s)
+- [ ] Tested CLI changes manually
+- [ ] Tested in different network environments
+
+**Device(s) tested with:**
+- Device model: [e.g. SoundTouch 10]
+- Device IP: [e.g. 192.0.2.100]
+- Test results: [brief description]
+
+### Test Commands
+```bash
+# Commands used to test this change
+make test
+go test ./pkg/client -v -run TestNewFeature
+soundtouch-cli --host 192.0.2.100 new-command
+```
+
+## Documentation
+
+- [ ] Updated relevant documentation
+- [ ] Added code comments for complex logic
+- [ ] Updated CLI help text
+- [ ] Added usage examples
+- [ ] Updated API documentation
+
+**Documentation files updated:**
+- [ ] README.md
+- [ ] docs/API-Endpoints-Overview.md
+- [ ] docs/CLI-REFERENCE.md
+- [ ] Code documentation (godoc)
+
+## Backward Compatibility
+
+- [ ] This change is backward compatible
+- [ ] This change includes breaking changes (requires major version bump)
+- [ ] This change requires configuration migration
+
+**Breaking changes (if any):**
+- Describe what breaks
+- Provide migration instructions
+
+## Security Considerations
+
+- [ ] No security implications
+- [ ] Security review required
+- [ ] Added input validation
+- [ ] Updated authentication/authorization
+
+## Performance Impact
+
+- [ ] No performance impact
+- [ ] Performance improvement
+- [ ] Potential performance regression (justify why)
+
+**Performance notes:**
+- Measured impact: [benchmarks, timing, memory usage]
+- Optimization opportunities: [if any]
+
+## Code Quality
+
+- [ ] Code follows project style guidelines
+- [ ] No linting errors
+- [ ] No security warnings
+- [ ] Memory leaks checked (if applicable)
+
+### Pre-submission Checklist
+
+- [ ] `make check` passes (format, lint, vet)
+- [ ] `make test` passes
+- [ ] No TODO comments left in production code
+- [ ] Error handling is comprehensive
+- [ ] Logging is appropriate (not too verbose, not too quiet)
+
+## Deployment Notes
+
+Any special considerations for deployment:
+- Configuration changes required
+- Database migrations needed
+- Service restart required
+- Rollback procedures
+
+## Screenshots (if applicable)
+
+If this PR includes UI changes or CLI output changes, include screenshots or terminal output examples.
+
+```bash
+# Before
+$ soundtouch-cli old-command
+Old output...
+
+# After  
+$ soundtouch-cli new-command
+New improved output...
+```
+
+## Additional Notes
+
+Any additional information that reviewers should know:
+- Design decisions and trade-offs
+- Future work planned
+- Alternative approaches considered
+- References to external documentation
+
+## Review Requests
+
+**Areas that need special attention:**
+- [ ] Error handling logic
+- [ ] Performance critical sections
+- [ ] Security implications
+- [ ] API design choices
+- [ ] Documentation clarity
+
+**Specific questions for reviewers:**
+1. Question about design choice X?
+2. Is error handling sufficient in section Y?
+3. Should we consider alternative approach Z?
+
+---
+
+**Reviewer Guidelines:**
+- Check that all tests pass
+- Verify documentation is updated
+- Test manually if device access available  
+- Consider backward compatibility
+- Evaluate error handling and edge cases

.github/workflows/ci.yml

@@ -1,5 +1,8 @@
 name: CI
 
+permissions:
+  contents: read
+
 on:
   push:
     branches: [main]
@@ -14,15 +17,15 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
       - name: Cache Go modules
-        uses: actions/cache@v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
         with:
           path: |
             ~/.cache/go-build
@@ -31,6 +34,9 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-go-
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Download dependencies
         run: go mod download
 
@@ -40,8 +46,14 @@ jobs:
       - name: Run tests
         run: go test -v -race -coverprofile=coverage.out ./...
 
+      - name: Build service
+        run: make build-service
+
+      - name: Run HTTP client integration tests
+        run: make test-http-client
+
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
         with:
           file: ./coverage.out
           flags: unittests
@@ -54,15 +66,18 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v9
+        uses: golangci/golangci-lint-action@1e7e51e771db61008b38414a730f564565cf7c20 # v9.2.0
         with:
           version: latest
           args: --timeout=5m
@@ -71,39 +86,76 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
-        goos: [linux, darwin, windows]
-        goarch: [amd64, arm64]
-        exclude:
-          # Windows ARM64 builds are experimental
-          - goos: windows
+        include:
+          - goos: linux
+            goarch: amd64
+          - goos: linux
             goarch: arm64
+          - goos: linux
+            goarch: arm
+            goarm: 7
+          - goos: darwin
+            goarch: amd64
+          - goos: darwin
+            goarch: arm64
+          - goos: windows
+            goarch: amd64
+          - goos: freebsd
+            goarch: amd64
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
-      - name: Build CLI
+      - name: Cache Go modules
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ~/.cache/go-build
+            ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Build binaries
         env:
           GOOS: ${{ matrix.goos }}
           GOARCH: ${{ matrix.goarch }}
+          GOARM: ${{ matrix.goarm }}
+          CGO_ENABLED: 0
         run: |
-          output_name="soundtouch-cli-${{ matrix.goos }}-${{ matrix.goarch }}"
-          if [ "${{ matrix.goos }}" = "windows" ]; then
-            output_name="${output_name}.exe"
+          ARCH_SUFFIX="${{ matrix.goos }}-${{ matrix.goarch }}"
+          if [[ -n "${{ matrix.goarm }}" ]]; then
+            ARCH_SUFFIX="${ARCH_SUFFIX}v${{ matrix.goarm }}"
           fi
-          go build -o "$output_name" ./cmd/soundtouch-cli
+
+          EXT=""
+          if [[ "${{ matrix.goos }}" == "windows" ]]; then
+            EXT=".exe"
+          fi
+
+          mkdir -p build
+
+          for binary in soundtouch-cli soundtouch-service soundtouch-web soundtouch-backup; do
+            OUTPUT="build/${binary}-${ARCH_SUFFIX}${EXT}"
+            echo "Building $OUTPUT"
+            go build -trimpath -ldflags="-s -w" -o "$OUTPUT" "./cmd/$binary"
+          done
+
+          ls -la build/
 
       - name: Upload build artifacts
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: soundtouch-cli-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: soundtouch-cli-*
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.goarm }}
+          path: build/
 
   security:
     name: Basic Security Check
@@ -111,13 +163,16 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Run basic vulnerability check
         run: |
           go install golang.org/x/vuln/cmd/govulncheck@latest
@@ -135,22 +190,43 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Check documentation links
-        uses: gaurav-nelson/github-action-markdown-link-check@v1
-        with:
-          use-quiet-mode: "yes"
-          use-verbose-mode: "yes"
-          config-file: ".github/markdown-link-check.json"
+        run: |
+          npm install -g markdown-link-check
+          find . -name "*.md" -not -path "./tests/*" -not -path "./node_modules/*" -print0 | xargs -0 -n1 markdown-link-check -q -v -c .github/markdown-link-check.json
+
+      - name: Warn on pending images
+        run: |
+          IMAGES=(
+            "dashboard-home.png"
+            "account-creation.png"
+            "account-dashboard.png"
+            "usb-remote-services.png"
+            "device-discovery.png"
+            "device-registration.png"
+            "account-migration.png"
+            "migration-setup.png"
+            "migration-progress.png"
+            "migration-health.png"
+            "migration-complete.png"
+            "backup-setup.png"
+          )
+
+          for img in "${IMAGES[@]}"; do
+            if [ ! -f "docs/images/$img" ]; then
+              echo "::warning file=docs/guides/MIGRATION-GUIDE.md::Pending image '$img' is missing from docs/images/"
+            fi
+          done
 
       - name: Validate API documentation
         run: |
           # Check that all documented endpoints exist in code
           echo "Validating API documentation consistency..."
 
-          # Extract endpoint patterns from cookbook
-          if [ -f "docs/API-COOKBOOK.md" ]; then
+          # Check API cookbook
+          if [ -f "docs/reference/API-COOKBOOK.md" ]; then
             echo "✓ API Cookbook exists"
           else
             echo "✗ API Cookbook missing"
@@ -158,7 +234,7 @@ jobs:
           fi
 
           # Check getting started guide
-          if [ -f "docs/GETTING-STARTED.md" ]; then
+          if [ -f "docs/guides/GETTING-STARTED.md" ]; then
             echo "✓ Getting Started guide exists"
           else
             echo "✗ Getting Started guide missing"
@@ -172,16 +248,16 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
       - name: Test CLI build and help
         run: |
-          go build -o soundtouch-cli ./cmd/soundtouch-cli
+          go build -trimpath -ldflags="-s -w" -o soundtouch-cli ./cmd/soundtouch-cli
           ./soundtouch-cli -help
 
       - name: Test library imports
@@ -199,7 +275,7 @@ jobs:
 
           func main() {
               // Test basic client creation
-              c := client.NewClientFromHost("192.168.1.100")
+              c := client.NewClientFromHost("192.0.2.100")
               fmt.Printf("Client created for %s\n", c.BaseURL())
 
               // Test models can be imported
@@ -218,10 +294,129 @@ jobs:
           go run test_import.go
           rm test_import.go
 
+  docker:
+    name: Docker Build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+
+      - name: Determine push eligibility
+        id: push-check
+        run: |
+          # Push on main, and on same-repo PRs (forks can't push to GHCR via GITHUB_TOKEN).
+          SHOULD_PUSH="false"
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" == "refs/heads/main" ]]; then
+            SHOULD_PUSH="true"
+          elif [[ "${{ github.event_name }}" == "pull_request" && \
+                  "${{ github.event.pull_request.head.repo.full_name }}" == "${{ github.repository }}" ]]; then
+            SHOULD_PUSH="true"
+          fi
+          echo "should-push=$SHOULD_PUSH" >> "$GITHUB_OUTPUT"
+          echo "Will push: $SHOULD_PUSH"
+
+      - name: Log in to GitHub Container Registry
+        if: steps.push-check.outputs.should-push == 'true'
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for soundtouch-service
+        id: meta-service
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=edge,enable=${{ github.ref == 'refs/heads/main' }}
+            type=ref,event=pr,prefix=preview-pr-
+            type=sha,prefix=preview-sha-,format=short,enable=${{ github.event_name == 'pull_request' }}
+            type=ref,event=branch,prefix=preview-branch-,enable=${{ github.event_name == 'push' && github.ref != 'refs/heads/main' }}
+
+      - name: Build and push soundtouch-service Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          target: soundtouch-service
+          platforms: linux/amd64,linux/arm64,linux/arm64/v8,linux/arm/v7
+          push: ${{ steps.push-check.outputs.should-push == 'true' }}
+          tags: ${{ steps.meta-service.outputs.tags }}
+          labels: ${{ steps.meta-service.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Extract metadata (tags, labels) for soundtouch-web
+        id: meta-web
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/${{ github.repository }}-web
+          tags: |
+            type=raw,value=edge,enable=${{ github.ref == 'refs/heads/main' }}
+            type=ref,event=pr,prefix=preview-pr-
+            type=sha,prefix=preview-sha-,format=short,enable=${{ github.event_name == 'pull_request' }}
+            type=ref,event=branch,prefix=preview-branch-,enable=${{ github.event_name == 'push' && github.ref != 'refs/heads/main' }}
+
+      - name: Build and push soundtouch-web Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          target: soundtouch-web
+          platforms: linux/amd64,linux/arm64,linux/arm64/v8,linux/arm/v7
+          push: ${{ steps.push-check.outputs.should-push == 'true' }}
+          tags: ${{ steps.meta-web.outputs.tags }}
+          labels: ${{ steps.meta-web.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Summarize published images
+        if: steps.push-check.outputs.should-push == 'true'
+        env:
+          SERVICE_TAGS: ${{ steps.meta-service.outputs.tags }}
+          WEB_TAGS: ${{ steps.meta-web.outputs.tags }}
+          EVENT_NAME: ${{ github.event_name }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          REF_NAME: ${{ github.ref_name }}
+        run: |
+          {
+            echo "## 🐳 Published Docker Images"
+            echo ""
+            if [[ "$EVENT_NAME" == "pull_request" ]]; then
+              echo "**Preview** images for PR #${PR_NUMBER}. These are not release builds."
+            elif [[ "$REF_NAME" == "main" ]]; then
+              echo "**Edge** images from \`main\`."
+            else
+              echo "**Preview** images from branch \`${REF_NAME}\`. These are not release builds."
+            fi
+            echo ""
+            echo "### soundtouch-service"
+            echo ""
+            echo '```bash'
+            while IFS= read -r tag; do
+              [[ -n "$tag" ]] && echo "docker pull $tag"
+            done <<< "$SERVICE_TAGS"
+            echo '```'
+            echo ""
+            echo "### soundtouch-web"
+            echo ""
+            echo '```bash'
+            while IFS= read -r tag; do
+              [[ -n "$tag" ]] && echo "docker pull $tag"
+            done <<< "$WEB_TAGS"
+            echo '```'
+          } >> "$GITHUB_STEP_SUMMARY"
+
   notify:
     name: Notify Status
     runs-on: ubuntu-latest
-    needs: [test, lint, build, security, docs]
+    needs: [test, lint, build, security, docs, docker]
     if: always()
     permissions:
       statuses: write
@@ -234,7 +429,8 @@ jobs:
                 "${{ needs.lint.result }}" == "success" && \
                 "${{ needs.build.result }}" == "success" && \
                 "${{ needs.security.result }}" == "success" && \
-                "${{ needs.docs.result }}" == "success" ]]; then
+                "${{ needs.docs.result }}" == "success" && \
+                "${{ needs.docker.result }}" == "success" ]]; then
             echo "✅ All CI checks passed!"
             echo "status=success" >> $GITHUB_OUTPUT
           else
@@ -244,13 +440,14 @@ jobs:
             echo "Build: ${{ needs.build.result }}"
             echo "Security: ${{ needs.security.result }}"
             echo "Docs: ${{ needs.docs.result }}"
+            echo "Docker: ${{ needs.docker.result }}"
             echo "status=failure" >> $GITHUB_OUTPUT
           fi
         id: status
 
       - name: Update commit status
         if: always()
-        uses: actions/github-script@v8
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             try {

.github/workflows/docs.yml

@@ -0,0 +1,37 @@
+name: Deploy Documentation
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Setup Pages
+        uses: actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d # v6.0.0
+      - name: Build with Jekyll
+        uses: actions/jekyll-build-pages@44a6e6beabd48582f863aeeb6cb2151cc1716697 # v1.0.13
+        with:
+          source: 'docs/'
+          destination: '_site'
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        with:
+          path: '_site'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0

.github/workflows/release.yml

@@ -13,6 +13,7 @@ on:
 permissions:
   contents: write
   actions: read
+  packages: write
 
 env:
   GO_VERSION_FILE: "go.mod"
@@ -27,7 +28,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 0
 
@@ -63,10 +64,13 @@ jobs:
           fi
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: ${{ env.GO_VERSION_FILE }}
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Run tests before release
         run: |
           echo "Running final tests before release..."
@@ -98,115 +102,118 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: ${{ env.GO_VERSION_FILE }}
 
       - name: Cache Go modules
-        uses: actions/cache@v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
         with:
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}
 
-      - name: Build binary
+      - name: Build binaries
         env:
           GOOS: ${{ matrix.goos }}
           GOARCH: ${{ matrix.goarch }}
           GOARM: ${{ matrix.goarm }}
           CGO_ENABLED: 0
         run: |
-          # Determine output filename
-          BINARY_NAME="soundtouch-cli"
+          # Common variables
           ARCH_SUFFIX="${{ matrix.goos }}-${{ matrix.goarch }}"
-
           if [[ "${{ matrix.goarm }}" != "" ]]; then
             ARCH_SUFFIX="${ARCH_SUFFIX}v${{ matrix.goarm }}"
           fi
 
-          if [[ "${{ matrix.goos }}" == "windows" ]]; then
-            OUTPUT_NAME="${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}.exe"
-          else
-            OUTPUT_NAME="${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}"
-          fi
+          # Function to build a binary
+          build_binary() {
+            local BINARY_NAME=$1
+            local CMD_PATH=$2
+            local OUTPUT_NAME
 
-          echo "Building: $OUTPUT_NAME"
+            # Ensure build directory exists
+            mkdir -p build
 
-          # Debug: Show current state
-          echo "Working directory: $(pwd)"
-          echo "Go version: $(go version)"
-          echo "Files before build:"
-          ls -la
+            if [[ "${{ matrix.goos }}" == "windows" ]]; then
+              OUTPUT_NAME="build/${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}.exe"
+            else
+              OUTPUT_NAME="build/${BINARY_NAME}-v${{ needs.validate.outputs.version }}-${ARCH_SUFFIX}"
+            fi
 
-          # Debug: Show Go cache and module cache
-          echo "Go build cache location: $(go env GOCACHE)"
-          echo "Go module cache location: $(go env GOMODCACHE)"
-          echo "Go build cache contents:"
-          ls -la "$(go env GOCACHE)" 2>/dev/null || echo "Cache directory not accessible"
-          echo "Go module cache contents (top level):"
-          ls -la "$(go env GOMODCACHE)" 2>/dev/null || echo "Module cache directory not accessible"
+            echo "Building $BINARY_NAME: $OUTPUT_NAME"
 
-          # Ensure clean build environment
-          rm -f "$OUTPUT_NAME" "$OUTPUT_NAME.sha256" "$OUTPUT_NAME.sha512"
-          go clean -cache
+            # Ensure clean build environment for this binary
+            rm -f "$OUTPUT_NAME" "$OUTPUT_NAME.sha256" "$OUTPUT_NAME.sha512"
 
-          # Build with optimizations and version info
-          if ! go build \
-            -ldflags="-s -w -X main.version=v${{ needs.validate.outputs.version }} -X main.commit=${{ github.sha }} -X main.date=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-            -o "$OUTPUT_NAME" \
-            ./cmd/soundtouch-cli; then
-            echo "❌ Build failed"
-            echo "Files after failed build:"
-            ls -la
-            exit 1
-          fi
+            if ! go build \
+              -trimpath \
+              -ldflags="-s -w" \
+              -o "$OUTPUT_NAME" \
+              "$CMD_PATH"; then
+              echo "❌ Build failed for $BINARY_NAME"
+              exit 1
+            fi
 
-          # Debug: Show post-build state
-          echo "Files after successful build:"
-          ls -la
+            # Verify binary was created
+            ls -la "$OUTPUT_NAME"
+            echo "$BINARY_NAME=$OUTPUT_NAME" >> $GITHUB_OUTPUT
+          }
 
-          # Verify binary was created and is executable
-          ls -la "$OUTPUT_NAME"
-          file "$OUTPUT_NAME"
+          # Build CLI
+          build_binary "soundtouch-cli" "./cmd/soundtouch-cli"
 
-          echo "binary_name=$OUTPUT_NAME" >> $GITHUB_OUTPUT
+          # Build Service
+          build_binary "soundtouch-service" "./cmd/soundtouch-service"
+
+          # Build Web
+          build_binary "soundtouch-web" "./cmd/soundtouch-web"
+
+          # Build Backup
+          build_binary "soundtouch-backup" "./cmd/soundtouch-backup"
         id: build
 
-      - name: Generate individual checksum
+      - name: Generate individual checksums
         run: |
-          OUTPUT_NAME="${{ steps.build.outputs.binary_name }}"
+          CLI_NAME="${{ steps.build.outputs.soundtouch-cli }}"
+          SVC_NAME="${{ steps.build.outputs.soundtouch-service }}"
+          WEB_NAME="${{ steps.build.outputs.soundtouch-web }}"
+          BCK_NAME="${{ steps.build.outputs.soundtouch-backup }}"
 
           # Use atomic operations to avoid conflicts
           TEMP_DIR=$(mktemp -d)
 
-          echo "Building checksums for: $OUTPUT_NAME"
-          echo "Matrix: ${{ matrix.goos }}-${{ matrix.goarch }}"
+          generate_checksums() {
+            local FILE=$1
+            echo "Building checksums for: $FILE"
+            sha256sum "$FILE" > "${TEMP_DIR}/$(basename "$FILE").sha256"
+            sha512sum "$FILE" > "${TEMP_DIR}/$(basename "$FILE").sha512"
+            mv "${TEMP_DIR}/$(basename "$FILE").sha256" "$FILE.sha256"
+            mv "${TEMP_DIR}/$(basename "$FILE").sha512" "$FILE.sha512"
+          }
 
-          # Generate checksums in temp directory first
-          sha256sum "$OUTPUT_NAME" > "${TEMP_DIR}/$(basename "$OUTPUT_NAME").sha256"
-          sha512sum "$OUTPUT_NAME" > "${TEMP_DIR}/$(basename "$OUTPUT_NAME").sha512"
-
-          # Move to final location atomically
-          mv "${TEMP_DIR}/$(basename "$OUTPUT_NAME").sha256" "$OUTPUT_NAME.sha256"
-          mv "${TEMP_DIR}/$(basename "$OUTPUT_NAME").sha512" "$OUTPUT_NAME.sha512"
+          generate_checksums "$CLI_NAME"
+          generate_checksums "$SVC_NAME"
+          generate_checksums "$WEB_NAME"
+          generate_checksums "$BCK_NAME"
 
           # Cleanup
           rm -rf "$TEMP_DIR"
-
           echo "✅ Checksums generated successfully"
 
       - name: Upload build artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: ${{ steps.build.outputs.binary_name }}
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.goarm }}
           path: |
-            ${{ steps.build.outputs.binary_name }}
-            ${{ steps.build.outputs.binary_name }}.sha256
-            ${{ steps.build.outputs.binary_name }}.sha512
+            build/soundtouch-cli-v*
+            build/soundtouch-service-v*
+            build/soundtouch-web-v*
+            build/soundtouch-backup-v*
           retention-days: 1
 
   checksums:
@@ -215,9 +222,10 @@ jobs:
     needs: [validate, build]
 
     steps:
-      - name: Download all artifacts
-        uses: actions/download-artifact@v7
+      - name: Download binary artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
+          pattern: binaries-*
           path: ./binaries
 
       - name: Generate checksums
@@ -226,13 +234,13 @@ jobs:
 
           # Debug: Show the downloaded structure
           echo "📁 Downloaded artifact structure:"
-          find . -type f -name "soundtouch-cli-*"
+          ls -R
 
           # Create a collection directory to avoid naming conflicts
           mkdir -p release-files
 
           # Move all files from subdirectories to the collection directory
-          find . -mindepth 2 -type f -name "soundtouch-cli-*" -exec mv {} release-files/ \;
+          find . -mindepth 2 -type f \( -name "soundtouch-cli-*" -o -name "soundtouch-service-*" -o -name "soundtouch-web-*" -o -name "soundtouch-backup-*" \) -exec mv {} release-files/ \;
 
           # Remove empty directories
           find . -type d -empty -delete
@@ -242,20 +250,20 @@ jobs:
 
           # Debug: Show flattened structure
           echo "📁 Flattened structure:"
-          ls -la soundtouch-cli-* || echo "No files found matching pattern"
+          ls -la soundtouch-* || echo "No files found matching pattern"
 
           # Generate combined checksums (exclude individual .sha256/.sha512 files)
-          if ls soundtouch-cli-v* 1> /dev/null 2>&1; then
+          if ls soundtouch-* 1> /dev/null 2>&1; then
             # Only checksum the actual binaries, not the .sha256/.sha512 files
-            ls soundtouch-cli-v* | grep -v '\.sha256$' | grep -v '\.sha512$' | xargs sha256sum > checksums.sha256
-            ls soundtouch-cli-v* | grep -v '\.sha256$' | grep -v '\.sha512$' | xargs sha512sum > checksums.sha512
+            ls soundtouch-cli-* soundtouch-service-* soundtouch-web-* soundtouch-backup-* | grep -v '\.sha256$' | grep -v '\.sha512$' | xargs sha256sum > checksums.sha256
+            ls soundtouch-cli-* soundtouch-service-* soundtouch-web-* soundtouch-backup-* | grep -v '\.sha256$' | grep -v '\.sha512$' | xargs sha512sum > checksums.sha512
 
             echo "📋 Generated combined checksums:"
             cat checksums.sha256
 
             # Verify all expected files are present (binaries only, not checksum files)
-            EXPECTED_COUNT=7  # Based on build matrix
-            ACTUAL_COUNT=$(ls soundtouch-cli-v* | grep -v '\.sha256$' | grep -v '\.sha512$' | wc -l)
+            EXPECTED_COUNT=28  # 7 platforms * 4 binaries
+            ACTUAL_COUNT=$(ls soundtouch-* | grep -v '\.sha256$' | grep -v '\.sha512$' | wc -l)
 
             if [[ $ACTUAL_COUNT -ne $EXPECTED_COUNT ]]; then
               echo "❌ Expected $EXPECTED_COUNT binaries, found $ACTUAL_COUNT"
@@ -272,7 +280,7 @@ jobs:
           fi
 
       - name: Upload checksums
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: checksums
           path: |
@@ -283,7 +291,7 @@ jobs:
           retention-days: 1
 
       - name: Upload all release assets
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: release-assets
           path: binaries/release-files/
@@ -297,12 +305,12 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 0
 
       - name: Download release assets
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: release-assets
           path: ./release-assets
@@ -350,7 +358,7 @@ jobs:
 
           func main() {
               // Create client
-              c := client.New("192.168.1.100", 8090)
+              c := client.New("192.0.2.100", 8090)
 
               // Get device info
               info, err := c.GetInfo()
@@ -369,19 +377,32 @@ jobs:
           - [Troubleshooting Guide](docs/TROUBLESHOOTING.md) - Systematic issue resolution
           - [Deployment Guide](docs/DEPLOYMENT.md) - Production deployment examples (Docker, K8s, systemd)
 
-          ## 🔧 CLI Tool
+          ## 🔧 CLI & Service Tools
 
-          Download the CLI tool for your platform from the assets below:
+          Download the tools for your platform from the assets below:
 
+          ### CLI Tool
           \`\`\`bash
           # Quick device discovery
           ./soundtouch-cli -discover
+          \`\`\`
 
-          # Get device information
-          ./soundtouch-cli -host 192.168.1.100 -info
+          ### SoundTouch Service
+          \`\`\`bash
+          # Start the service
+          ./soundtouch-service
+          \`\`\`
 
-          # Monitor real-time events
-          ./soundtouch-cli -host 192.168.1.100 -nowplaying
+          ### SoundTouch Web
+          \`\`\`bash
+          # Start the web app
+          ./soundtouch-web
+          \`\`\`
+
+          ### SoundTouch Backup
+          \`\`\`bash
+          # Back up cloud account and all paired speakers in one go
+          ./soundtouch-backup all
           \`\`\`
 
           ## 🧪 Tested Hardware
@@ -402,6 +423,8 @@ jobs:
           - Windows (amd64)
           - FreeBSD (amd64)
 
+          `soundtouch-cli`, `soundtouch-service`, `soundtouch-web`, and `soundtouch-backup` are included.
+
           ## 🔐 Checksums
 
           Multiple checksum options are provided for download verification:
@@ -445,7 +468,7 @@ jobs:
           echo "release_notes_file=release_notes.md" >> $GITHUB_OUTPUT
 
       - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
         with:
           tag_name: ${{ github.event.inputs.tag }}
           name: "Bose SoundTouch Go Library ${{ github.event.inputs.tag }}"
@@ -454,6 +477,9 @@ jobs:
           prerelease: ${{ needs.validate.outputs.is_prerelease == 'true' }}
           files: |
             release-assets/soundtouch-cli-v*
+            release-assets/soundtouch-service-v*
+            release-assets/soundtouch-web-v*
+            release-assets/soundtouch-backup-v*
             release-assets/checksums.sha256
             release-assets/checksums.sha512
           fail_on_unmatched_files: true
@@ -468,34 +494,101 @@ jobs:
 
     steps:
       - name: Download release assets
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: release-assets
           path: ./release-assets
 
       - name: Upload additional assets to existing release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
         with:
           tag_name: ${{ github.event.release.tag_name }}
           files: |
             release-assets/soundtouch-cli-v*
+            release-assets/soundtouch-service-v*
+            release-assets/soundtouch-web-v*
+            release-assets/soundtouch-backup-v*
             release-assets/checksums.sha256
             release-assets/checksums.sha512
           fail_on_unmatched_files: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  docker:
+    name: Build and Push Docker Image
+    runs-on: ubuntu-latest
+    needs: validate
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for soundtouch-service
+        id: meta-service
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=semver,pattern={{version}},value=v${{ needs.validate.outputs.version }}
+            type=semver,pattern={{major}}.{{minor}},value=v${{ needs.validate.outputs.version }}
+            type=raw,value=latest,enable=${{ needs.validate.outputs.is_prerelease == 'false' }}
+
+      - name: Build and push soundtouch-service Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          target: soundtouch-service
+          platforms: linux/amd64,linux/arm64,linux/arm64/v8,linux/arm/v7
+          push: true
+          tags: ${{ steps.meta-service.outputs.tags }}
+          labels: ${{ steps.meta-service.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Extract metadata (tags, labels) for soundtouch-web
+        id: meta-web
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/${{ github.repository }}-web
+          tags: |
+            type=semver,pattern={{version}},value=v${{ needs.validate.outputs.version }}
+            type=semver,pattern={{major}}.{{minor}},value=v${{ needs.validate.outputs.version }}
+            type=raw,value=latest,enable=${{ needs.validate.outputs.is_prerelease == 'false' }}
+
+      - name: Build and push soundtouch-web Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          target: soundtouch-web
+          platforms: linux/amd64,linux/arm64,linux/arm64/v8,linux/arm/v7
+          push: true
+          tags: ${{ steps.meta-web.outputs.tags }}
+          labels: ${{ steps.meta-web.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
   notify:
     name: Post-Release Notifications
     runs-on: ubuntu-latest
-    needs: [validate, create_release, update_release]
-    if: always() && (needs.create_release.result == 'success' || needs.update_release.result == 'success')
+    needs: [validate, create_release, update_release, docker]
+    if: always() && (needs.create_release.result == 'success' || needs.update_release.result == 'success' || needs.docker.result == 'success')
 
     steps:
       - name: Notify success
         run: |
           echo "🎉 Release ${{ needs.validate.outputs.version }} completed successfully!"
-          echo "📦 Binaries built for 7 platforms"
+          echo "📦 Binaries built for 7 platforms (CLI, Service, Web, and Backup)"
+          echo "🐳 Docker image published to ghcr.io"
           echo "🔐 Checksums generated and verified"
           echo "📋 Release notes automatically generated"
           echo ""

.github/workflows/security.yml

@@ -14,16 +14,21 @@ jobs:
   vulnerability-scan:
     name: Vulnerability Scan
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Install security scanning tools
         run: |
           go install golang.org/x/vuln/cmd/govulncheck@latest
@@ -43,7 +48,7 @@ jobs:
 
       - name: Upload vulnerability scan results
         if: failure()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: vulnerability-scan-results
           path: |
@@ -53,16 +58,21 @@ jobs:
   static-analysis:
     name: Static Security Analysis
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version-file: "go.mod"
 
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
+
       - name: Install static analysis tools
         run: |
           go install honnef.co/go/tools/cmd/staticcheck@latest
@@ -74,7 +84,7 @@ jobs:
           echo "::endgroup::"
 
       - name: Run Semgrep security analysis
-        uses: semgrep/semgrep-action@v1
+        uses: semgrep/semgrep-action@713efdd345f3035192eaa63f56867b88e63e4e5d # v1 (no v1.x.y semver tag exists)
         with:
           config: >-
             p/security-audit
@@ -85,7 +95,7 @@ jobs:
 
       - name: Upload Semgrep SARIF results
         if: always()
-        uses: github/codeql-action/upload-sarif@v4
+        uses: github/codeql-action/upload-sarif@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
         with:
           sarif_file: semgrep.sarif
         continue-on-error: true
@@ -100,33 +110,38 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Install libpcap
+        run: sudo apt-get install -y libpcap-dev
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4
+        uses: github/codeql-action/init@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
         with:
           languages: go
           config-file: ./.github/codeql-config.yml
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v4
+        uses: github/codeql-action/autobuild@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4
+        uses: github/codeql-action/analyze@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
         with:
           category: "/language:go"
 
   dependency-review:
     name: Dependency Review
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     if: github.event_name == 'pull_request'
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Dependency Review
-        uses: actions/dependency-review-action@v4
+        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0
         with:
           fail-on-severity: moderate
           allow-ghsas: GHSA-xxxx-xxxx-xxxx  # Add specific allowlisted advisories if needed
@@ -137,6 +152,8 @@ jobs:
     runs-on: ubuntu-latest
     needs: [vulnerability-scan, static-analysis, codeql-analysis]
     if: always()
+    permissions:
+      contents: read
 
     steps:
       - name: Security scan summary

.github/workflows/update-static-deps.yml

@@ -0,0 +1,50 @@
+name: Update Static Dependencies
+
+on:
+  pull_request:
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  update-deps:
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]' || github.event_name == 'workflow_dispatch'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          ref: ${{ github.head_ref }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: '24'
+          cache: 'npm'
+
+      - name: Update static dependencies
+        run: make update-static-deps
+
+      - name: Check for changes
+        id: git-check
+        run: |
+          git status --short pkg/service/soundtouchweb/static/lib/
+          if [ -n "$(git status --short pkg/service/soundtouchweb/static/lib/)" ]; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Commit and push changes
+        if: steps.git-check.outputs.changed == 'true'
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add pkg/service/soundtouchweb/static/lib/
+          git commit -m "chore: sync static dependencies with package.json"
+          git push

.gitignore

@@ -11,13 +11,29 @@ dist/
 #example-mdns
 #example-upnp
 
+# Root-level binary executables (exclude built binaries in root)
+/soundtouch-backup
+/soundtouch-cli
+/soundtouch-service
+/soundtouch-web
+/dummy-speaker
+/example-mdns
+/example-upnp
+/example-unified
+/mdns-scanner
+/websocket-demo
+/main
+/screenshots
+
 # Environment configuration
 .env
 .env.local
 .env.*.local
+docker-compose.override.yml
 
 # Test coverage reports
 coverage.out
+coverage*.out
 coverage.html
 *.prof
 
@@ -27,10 +43,13 @@ go.work.sum
 
 # Dependency directories
 vendor/
+node_modules/
 
 # IDE and editor files
 .vscode/
 .idea/
+.claude/
+.junie/
 *.swp
 *.swo
 *~
@@ -44,6 +63,15 @@ vendor/
 ehthumbs.db
 Thumbs.db
 
+# Android MITM setup — downloaded/generated artefacts, not committed
+scripts/android/bose.apk
+scripts/android/frida-server
+scripts/android/frida-server.xz
+scripts/android/frida/
+scripts/android/frida-venv/
+scripts/android/captures/
+scripts/android/mitm/
+
 # Temporary files
 *.tmp
 *.temp
@@ -51,6 +79,7 @@ Thumbs.db
 *.pid
 *.seed
 *.pid.lock
+.output.txt
 
 # Runtime data
 pids
@@ -72,3 +101,24 @@ pids
 
 # dotenv environment variables file (but keep .env.example)
 !.env.example
+
+# Stockholm frontend — generated by `make prepare-stockholm`, not committed
+stockholm/
+
+!pkg/service/stockholm/
+
+# Stockholm source zip — large binary, place manually at stockholm_zip/stockholm.zip
+stockholm_zip/*.zip
+
+# Local working-tree notes — running pickup-here log (NEXT) + archive of
+# resolved items (DONE). Both are session-local scratch, not project docs.
+NEXT.md
+DONE.md
+
+# Plan/tracking note for the Health-tab debug-utility programme.
+# Living document; commit history of the checks themselves is the
+# source of truth for what shipped.
+SERVICE-HEALTH.md
+
+# Diagnostic encryption keys — private key stays local with the maintainer
+keys/private/

.golangci.yml

@@ -50,7 +50,12 @@ linters:
         linters:
           - gocritic # Can be overly strict for test code
           - wsl # Whitespace less critical in tests
+          - wsl_v5 # Whitespace less critical in tests
           - gocyclo # Complexity less critical in tests
+          - govet # Avoid shadow warnings in tests
+          - revive # Avoid exported/package-comments in tests
+          - errcheck # Avoid mandatory error checks in tests
+          - unparam # Often parameters are fixed in test setups
 
       # Exclude specific rules for generated files
       - path: ".*\\.pb\\.go$"
@@ -62,12 +67,24 @@ linters:
           - staticcheck
         text: "SA9003:" # Empty branch
 
+      - linters:
+          - staticcheck
+        text: "SA1008: keys in http.Header are canonicalized"
+        path: pkg/service/handlers/handlers_etag_test.go
+
       # Allow main functions to not check errors in examples
       - path: cmd/.*\.go
         text: "Error return value of.*is not checked"
         linters:
           - errcheck
 
+      # Carry-over from cmd/soundtouch-web/handlers relocation: same code,
+      # same waiver. Tighten in a follow-up if/when the package is reviewed.
+      - path: pkg/service/soundtouchweb/.*\.go
+        text: "Error return value of.*is not checked"
+        linters:
+          - errcheck
+
   settings:
     errcheck:
       check-type-assertions: true
@@ -85,7 +102,7 @@ linters:
         - fieldalignment # Can be overly aggressive
 
     gocyclo:
-      min-complexity: 15
+      min-complexity: 20
 
     gocritic:
       enabled-checks:

CLAUDE.md

@@ -0,0 +1,228 @@
+# CLAUDE.md
+
+Entry point for any Claude Code (or human) session working on this
+repository. Read it before touching code.
+
+## What this project is
+
+Go library and toolset for controlling Bose SoundTouch speakers via
+the local network API, plus a local cloud-service emulator. Bose
+discontinued the SoundTouch cloud — this project keeps existing
+speakers usable without it.
+
+**Module:** `github.com/gesellix/bose-soundtouch`
+
+Key binaries:
+
+- `soundtouch-cli` — command-line control of one or more speakers
+  (status, play, presets, groups, migration, …).
+- `soundtouch-service` — replacement for `streaming.bose.com`
+  and the `bmx` services, default port `8000`.
+- `soundtouch-web` — Web UI for Radio browsing and device control.
+- `soundtouch-backup` — Helper for on-device backup and restore.
+
+Per-session pickup notes live in two local files at the repo root (they are `.gitignore`d and only exist if created during a session):
+
+- `NEXT.md` — current "pick up here" log of open items.
+- `DONE.md` — archive of recently resolved items.
+
+## How a new session should start
+
+1. Read this file.
+2. Read `NEXT.md` if it's present — that's where running context lives.
+3. Skim `README.md` for the user-facing pitch.
+4. Skim `docs/` for the area you're touching. Long-form notes
+   (analysis, guides, troubleshooting) live there, not in the code.
+5. Run `make check` once to confirm the local environment compiles,
+   vets, and tests cleanly.
+
+## Build, test, run
+
+```bash
+# Build
+make build          # All binaries
+make build-cli      # Just CLI
+make build-service  # Just service
+make build-web      # Just web UI
+make build-all      # Cross-platform builds (Linux, macOS, Windows)
+make install        # Install to $GOPATH/bin
+
+# Quality
+make test           # Unit tests
+make test-coverage  # Coverage reports
+make check          # fmt + vet + test
+make lint           # golangci-lint
+make update-static-deps # Update frontend libraries (preact, htm) from node_modules
+
+# Automation
+A GitHub Action automatically runs `make update-static-deps` on Dependabot PRs that modify `package.json` to keep the vendored `.js` files in sync. Note: This requires `npm` to be installed.
+
+# Development
+make dev-service    # Run local service on port 8000
+make dev-discover   # Discover devices on the LAN
+make dev-info HOST=<ip>  # Get device info
+
+# Docker
+make docker-build
+make docker-run-host
+```
+
+**Pre-push quality gate:** `make lint` (golangci-lint) must be clean
+before `git push`. CI runs it on every PR; running it locally first
+saves a round-trip. `make check` covers `lint` is its own target —
+combine as needed.
+
+## Integration tests
+
+The `.http` integration tests under `tests/integration/http-client/`
+run via `make test-http-client`, which spins up the service plus
+support mocks (`spotify-mock`, `amazon-mock`) using
+`docker-compose.yml` + `docker-compose.ci.yml`, executes the suite
+through the JetBrains HTTP client image, then tears the stack down.
+Requires Docker.
+
+The compose CI override mounts `tests/integration/testdata/` into the
+service container as its persistent data dir. That directory is
+listed in `tests/.gitignore` — it's local developer state, not source.
+
+**Treat the testdata dir as debug evidence, not disposable scratch.**
+When a fixture or schema change makes the old state stale (e.g.
+post-anonymisation, the previous run's IPs no longer match the
+assertions), don't `rm -rf` it — archive it:
+
+```bash
+make test-http-client-rotate   # renames testdata/ → testdata_<timestamp>/
+make test-http-client          # fresh run on a clean slate
+```
+
+The rotate target is non-destructive (it moves, never deletes) and
+opt-in (no other target invokes it). Old archives stay around for
+retrospective diffing whenever something goes sideways.
+
+## Project structure
+
+```
+cmd/
+  soundtouch-cli/      # CLI tool for device control
+  soundtouch-service/  # Local cloud service emulator
+  soundtouch-web/      # Web UI (TuneIn browser, device control)
+  soundtouch-backup/   # On-device backup helper
+  example-*/           # Usage examples
+pkg/
+  client/              # HTTP + WebSocket client for the SoundTouch Web API
+  models/              # XML/JSON data structures
+  discovery/           # Device discovery (mDNS + UPnP, unified interface)
+  config/              # Configuration management
+  service/
+    bmx/               # Bose Media eXchange service emulation
+    marge/             # Device-management service emulation
+    handlers/          # HTTP request handlers (pkg/service/handlers/)
+    proxy/             # HTTP proxy with request recording
+    datastore/         # Persistent device data storage
+    certmanager/       # TLS certificate management
+    setup/             # Device migration and configuration
+    spotify/           # Spotify integration
+    stockholm/         # Optional Stockholm frontend bridge
+    soundtouchweb/     # SoundTouch Web UI service logic
+examples/              # Feature demonstration programs
+docs/                  # Long-form analysis, guides, troubleshooting
+.junie/                # Communication-style guidelines (see below)
+```
+
+## Key technologies
+
+- **Go 1.26.3+**
+- **chi v5** — HTTP router
+- **gorilla/websocket** — WebSocket for real-time events
+- **hashicorp/mdns** — mDNS device discovery
+- **miekg/dns** — DNS operations and a custom DNS server
+- **urfave/cli/v2** — CLI framework
+
+## Architecture notes
+
+- `pkg/client` is the core library for device API calls (HTTP + WebSocket).
+- `pkg/service` is the local cloud replacement; routes wire to the
+  handlers in `pkg/service/handlers/` via chi middleware.
+- Discovery supports both mDNS and UPnP/SSDP behind a unified interface.
+- The SoundTouch Web API uses XML on the wire; internal service-to-service
+  messages use JSON.
+- Tests cover unit, integration, parity (local vs. official Bose API
+  recordings), and regression. Reproducer tests should be refactored
+  into permanent regression or documentation tests rather than deleted.
+
+## Load-bearing gotchas
+
+### `ETag` header literal must stay capitalised
+
+Bose speakers emit the response header with exact capitalisation
+`ETag`. Go's `http.Header.Set` canonicalises to `Etag` (lowercase `t`).
+Real speakers parse strictly — `Etag` is rejected. The codebase
+deliberately bypasses the canonicalisation path; do **not** rewrite
+the string literal `"ETag"` to `"Etag"` anywhere in `pkg/service/handlers/`
+or in tests.
+
+The contrast is encoded in two named constants in
+`pkg/service/handlers/handlers_etag_test.go`:
+
+```go
+const normalizedEtag    = "Etag" // what http.Header.Set produces
+const caseSensitiveETag = "ETag" // what the speaker actually expects
+```
+
+Linter suppressions on the canonical-header check live alongside the
+test code. Static-analysis warnings about `"ETag"` are expected;
+don't "fix" them.
+
+### Destructive git or filesystem actions need explicit confirmation
+
+`git reset --hard`, `git checkout` that would overwrite local changes,
+`git clean -fd`, `rm -rf` on non-build paths, `git stash drop` — all
+should be proposed in writing with their consequences before running,
+unless the user has already authorised that specific action in this
+session. Prefer reversible alternatives (`git stash` over
+`git reset --hard`).
+
+## What never goes into this repo
+
+This repository is public. The following must never be committed:
+
+- **Real LAN IPs** of personal networks. Use RFC-5737 documentation
+  ranges in examples and fixtures: `192.0.2.0/24`, `198.51.100.0/24`,
+  `203.0.113.0/24`.
+- **Real MAC addresses** or speaker device IDs from anyone's actual
+  hardware. Use `AA:BB:CC:DD:EE:FF` or `DEVICEID01` style placeholders.
+- **Bose account IDs**, serial numbers, or tokens belonging to anyone
+  other than the committer's own test devices — and even those should
+  be sanitised before publication when feasible.
+- **Bose firmware binaries, NAND dumps, or decompiled Bose code.**
+- **Wi-Fi SSIDs or credentials**, captured or otherwise.
+- **Network captures, traces, or logs** that include data from
+  accounts or devices other than your own test hardware.
+- **Personal identifiers**: real names of speakers ("LivingRoom",
+  custom device names), private email addresses, household member
+  names visible in source IDs.
+
+If you spot any of the above already in the tree, treat it as a
+sanitisation task: stop, flag it to the maintainer, propose a
+remediation commit before continuing.
+
+## Disclaimers
+
+"SoundTouch" and "Bose" are registered trademarks of Bose Corporation.
+This project is an unofficial, community-built effort, not affiliated
+with, endorsed by, or authorised by Bose.
+
+## Communication style
+
+When working with a human user in this repo:
+
+- **Prioritise direct answers** to the question being asked, even when
+  it sits outside the current task or project context. Don't divert
+  back to whatever you were doing when the user asks something else.
+- **Don't substitute assumptions for real information.** When something
+  is unclear, ask or check, rather than guessing and proceeding.
+
+These principles also apply to other AI assistants pointed at this
+repo. Tool-specific config dirs (e.g. `.junie/`, `.claude/`) should
+defer to this file as the source of truth instead of carrying their
+own copies.

CONTRIBUTING.md

@@ -0,0 +1,498 @@
+# Contributing to Bose SoundTouch API Client
+
+Thank you for your interest in contributing to the Bose SoundTouch API Client! This project aims to provide a comprehensive, reliable, and well-tested Go library for controlling Bose SoundTouch devices.
+
+## Ways to Contribute
+
+All contributions are welcome — large or small:
+
+- **Code suggestions** — bug fixes, new features, refactoring, performance improvements.
+- **Documentation updates** — README, guides, examples, troubleshooting notes, inline doc comments.
+- **Bug fixes** — even just a clear reproducer in an issue is a real contribution.
+- **Donations** — if the project kept a speaker (or several) of yours alive past the Bose cloud shutdown and you want to give back, [GitHub Sponsors](https://github.com/sponsors/gesellix) is open. No expectation; everything in this repo stays MIT regardless.
+
+By submitting a code or documentation contribution you agree to license it under MIT. The detailed guides below cover the mechanics.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Getting Started](#getting-started)
+- [How Can I Contribute?](#how-can-i-contribute)
+- [Development Setup](#development-setup)
+- [Pull Request Process](#pull-request-process)
+- [Coding Guidelines](#coding-guidelines)
+- [Testing Guidelines](#testing-guidelines)
+- [Documentation Guidelines](#documentation-guidelines)
+- [Reporting Issues](#reporting-issues)
+- [Device Testing](#device-testing)
+- [Community](#community)
+- [Support the Project](#support-the-project)
+
+## Code of Conduct
+
+This project adheres to our [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to the project maintainers.
+
+## Getting Started
+
+### Prerequisites
+
+- **Go 1.25.6 or later**: [Download Go](https://golang.org/dl/)
+- **Git**: For version control
+- **Make**: For build automation (optional but recommended)
+- **SoundTouch Device**: For testing (optional but valuable)
+
+### First Contribution
+
+1. **Fork the repository** on GitHub
+2. **Clone your fork** locally:
+   ```bash
+   git clone https://github.com/YOUR-USERNAME/Bose-SoundTouch.git
+   cd Bose-SoundTouch
+   ```
+3. **Install dependencies**:
+   ```bash
+   go mod download
+   ```
+4. **Run tests** to ensure everything works:
+   ```bash
+   make test
+   # or
+   go test ./...
+   ```
+5. **Build the CLI** to test functionality:
+   ```bash
+   make build
+   ./soundtouch-cli --help
+   ```
+
+## How Can I Contribute?
+
+### 🐛 Reporting Bugs
+
+Before creating a bug report, please:
+
+1. **Check existing issues** to avoid duplicates
+2. **Test with the latest version** from the main branch
+3. **Include device information** (model, firmware version if known)
+
+When filing a bug report, include:
+
+- **Clear title** describing the issue
+- **Steps to reproduce** the behavior
+- **Expected behavior** vs actual behavior
+- **Environment details**: OS, Go version, device model
+- **Log output** if applicable (use `--verbose` flag)
+
+### 💡 Suggesting Features
+
+Feature requests are welcome! Please:
+
+1. **Check if the feature already exists** in documentation
+2. **Verify it's supported by the SoundTouch API** (see [official API docs](docs/reference/API-ENDPOINTS.md))
+3. **Explain the use case** and how it benefits users
+
+### 🔧 Contributing Code
+
+Areas where contributions are especially welcome:
+
+#### High Priority
+- **Bug fixes** for existing functionality
+- **Device compatibility** improvements
+- **Error handling** enhancements
+- **Performance optimizations**
+
+#### Medium Priority
+- **New endpoint implementations** (if officially documented)
+- **CLI improvements** (better UX, additional commands)
+- **Documentation improvements**
+- **Example applications**
+
+#### Future Enhancements
+- **Web interface** development
+- **Home Assistant integration**
+- **WASM/browser support**
+- **Mobile app development**
+
+## Development Setup
+
+### Project Structure
+
+```
+Bose-SoundTouch/
+├── cmd/                    # Command-line applications
+│   ├── soundtouch-cli/    # Main CLI tool
+│   └── examples/          # Example applications
+├── pkg/                   # Library packages
+│   ├── client/           # HTTP client implementation
+│   ├── discovery/        # Device discovery
+│   ├── models/           # Data structures
+│   └── config/           # Configuration management
+├── docs/                 # Documentation
+├── examples/             # Usage examples
+└── scripts/              # Build and utility scripts
+```
+
+### Development Commands
+
+```bash
+# Run tests
+make test
+
+# Run tests with coverage
+make test-coverage
+
+# Build all binaries
+make build
+
+# Run linting and formatting
+make check
+
+# Run golangci-lint specifically
+golangci-lint run
+
+# Auto-fix linting issues where possible
+golangci-lint run --fix
+
+# Install CLI locally
+go install ./cmd/soundtouch-cli
+
+# Run integration tests (requires real device)
+make test-integration HOST=192.0.2.100
+```
+
+### Environment Setup
+
+For development with real devices, create a `.env` file:
+
+```env
+# Optional: Pre-configured device for testing
+SOUNDTOUCH_HOST=192.0.2.100
+SOUNDTOUCH_PORT=8090
+
+# Optional: Enable debug logging
+SOUNDTOUCH_DEBUG=true
+```
+
+## Pull Request Process
+
+### Before Submitting
+
+1. **Create an issue** first for significant changes
+2. **Fork and create a feature branch**:
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+3. **Write tests** for your changes
+4. **Update documentation** if needed
+5. **Run the full test suite**:
+   ```bash
+   make check
+   make test
+   ```
+
+### Pull Request Guidelines
+
+1. **Clear title** describing the change
+2. **Detailed description** explaining:
+   - What the change does
+   - Why it's needed
+   - How it was tested
+   - Any breaking changes
+3. **Link to related issues**
+4. **Update CHANGELOG.md** if applicable
+5. **Ensure CI passes**
+
+### Review Process
+
+- At least one maintainer will review your PR
+- Feedback will be constructive and specific
+- Address feedback in additional commits
+- Once approved, a maintainer will merge your PR
+
+## Coding Guidelines
+
+### Go Style
+
+Follow standard Go conventions:
+
+- **gofmt** for formatting
+- **golangci-lint** for comprehensive code quality checks
+- **go vet** for static analysis
+- **Effective Go** principles
+- **Standard library patterns** where applicable
+
+### Code Organization
+
+```go
+// Package-level documentation
+package client
+
+import (
+    // Standard library first
+    "context"
+    "encoding/xml"
+    
+    // Third-party packages
+    "github.com/gorilla/websocket"
+    
+    // Local packages
+    "github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+// Public API should be well-documented
+// GetDeviceInfo retrieves comprehensive device information including
+// model, capabilities, network status, and current configuration.
+func (c *Client) GetDeviceInfo() (*models.DeviceInfo, error) {
+    // Implementation
+}
+```
+
+### Error Handling
+
+- **Return errors** instead of panicking
+- **Wrap errors** with context using `fmt.Errorf`
+- **Create custom error types** for specific conditions
+- **Validate inputs** and return helpful error messages
+
+```go
+// Good error handling example
+func (c *Client) SetVolume(level int) error {
+    if level < 0 || level > 100 {
+        return fmt.Errorf("volume level %d out of range [0-100]", level)
+    }
+    
+    if err := c.post("/volume", volumeXML); err != nil {
+        return fmt.Errorf("failed to set volume to %d: %w", level, err)
+    }
+    
+    return nil
+}
+```
+
+### API Design
+
+- **Consistent method naming**: `Get*`, `Set*`, `Send*`, etc.
+- **Return pointers** for complex types, values for simple types
+- **Accept contexts** for potentially long-running operations
+- **Provide convenience methods** for common operations
+
+## Testing Guidelines
+
+### Test Structure
+
+```go
+func TestClient_SetVolume(t *testing.T) {
+    tests := []struct {
+        name          string
+        volume        int
+        expectedError string
+        setupMock     func(*httptest.Server)
+    }{
+        {
+            name:   "valid volume level",
+            volume: 50,
+            setupMock: func(server *httptest.Server) {
+                // Mock setup
+            },
+        },
+        {
+            name:          "volume too high",
+            volume:        150,
+            expectedError: "volume level 150 out of range",
+        },
+    }
+    
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            // Test implementation
+        })
+    }
+}
+```
+
+### Test Categories
+
+1. **Unit Tests**: Test individual functions with mocks
+2. **Integration Tests**: Test with real devices (when available)
+3. **Benchmark Tests**: Performance testing for critical paths
+
+### Mock Usage
+
+Use `httptest.Server` for HTTP client testing:
+
+```go
+func setupMockServer() *httptest.Server {
+    return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        switch r.URL.Path {
+        case "/info":
+            w.Header().Set("Content-Type", "application/xml")
+            fmt.Fprint(w, mockDeviceInfoXML)
+        default:
+            w.WriteHeader(http.StatusNotFound)
+        }
+    }))
+}
+```
+
+### Real Device Testing
+
+When possible, test with real SoundTouch devices:
+
+```bash
+# Set device IP for integration tests
+export SOUNDTOUCH_HOST=192.0.2.100
+go test -tags integration ./pkg/client/
+```
+
+## Documentation Guidelines
+
+### Code Documentation
+
+- **Package documentation** for every package
+- **Function documentation** for all public functions
+- **Example documentation** for complex usage
+
+```go
+// Package client provides a comprehensive HTTP client for the Bose SoundTouch Web API.
+//
+// The client supports all documented SoundTouch endpoints including device information,
+// playback control, volume management, and real-time WebSocket events.
+//
+// Basic usage:
+//
+//     client := client.NewClient(&client.Config{
+//         Host: "192.0.2.100",
+//         Port: 8090,
+//     })
+//     
+//     info, err := client.GetDeviceInfo()
+//     if err != nil {
+//         log.Fatal(err)
+//     }
+//     
+//     fmt.Printf("Device: %s\n", info.Name)
+package client
+```
+
+### User Documentation
+
+- **README.md**: Overview and quick start
+- **API documentation**: Comprehensive endpoint reference
+- **Examples**: Real-world usage patterns
+- **Troubleshooting**: Common issues and solutions
+
+### Documentation Updates
+
+When making changes:
+
+1. **Update relevant docs** in the same PR
+2. **Include usage examples** for new features
+3. **Update CLI help text** if applicable
+4. **Test documentation** (ensure examples work)
+
+## Device Testing
+
+### Supported Devices
+
+The library has been tested with:
+
+- **SoundTouch 10** (firmware unknown)
+- **SoundTouch 20** (firmware unknown)
+
+### Testing New Devices
+
+If you have access to other SoundTouch models:
+
+1. **Run discovery** to find devices:
+   ```bash
+   ./soundtouch-cli discover devices
+   ```
+
+2. **Test basic functionality**:
+   ```bash
+   ./soundtouch-cli -h 192.0.2.100 info get
+   ./soundtouch-cli -h 192.0.2.100 now-playing get
+   ```
+
+3. **Report compatibility** in your PR or issue
+4. **Include device information** from the info endpoint
+
+### Testing Protocol
+
+For significant changes:
+
+1. **Test on multiple devices** if available
+2. **Test error scenarios** (device offline, network issues)
+3. **Test edge cases** (invalid inputs, boundary conditions)
+4. **Document any device-specific behavior**
+
+## Reporting Issues
+
+### Security Issues
+
+**Do not open public issues for security vulnerabilities.** Instead:
+
+1. **Email the maintainers** with details
+2. **Allow reasonable time** for response
+3. **Coordinate disclosure** timing
+
+### Bug Reports
+
+Use the bug report template and include:
+
+- **Device model and firmware** (if known)
+- **Complete error messages and logs**
+- **Minimal reproduction case**
+- **Environment information**
+
+### Feature Requests
+
+Use the feature request template and include:
+
+- **Clear description** of the desired functionality
+- **Use case explanation** 
+- **API documentation reference** (if applicable)
+- **Alternative solutions** you've considered
+
+## Community
+
+### Communication Channels
+
+- **GitHub Issues**: Bug reports, feature requests
+- **GitHub Discussions**: Questions, ideas, general discussion
+- **Pull Requests**: Code contributions and reviews
+
+### Getting Help
+
+1. **Check existing documentation** first
+2. **Search closed issues** for similar problems
+3. **Create a new issue** with detailed information
+4. **Be patient and respectful** in all interactions
+
+### Recognition
+
+Contributors will be:
+
+- **Listed in CONTRIBUTORS.md**
+- **Mentioned in release notes** for significant contributions
+- **Credited in documentation** where appropriate
+
+## Support the Project
+
+If you want to support the maintenance effort beyond code:
+
+[![GitHub Sponsors](https://img.shields.io/github/sponsors/gesellix?label=Sponsor%20on%20GitHub&logo=GitHub&color=ea4aaa)](https://github.com/sponsors/gesellix)
+
+Sponsorship is entirely optional. Code, docs, and bug reports remain the most useful contributions for the project itself.
+
+## Additional Resources
+
+- [Go Documentation](https://golang.org/doc/)
+- [Effective Go](https://golang.org/doc/effective_go.html)
+- [Bose SoundTouch API Documentation](docs/reference/API-ENDPOINTS.md)
+- [Project Architecture](docs/PROJECT-PATTERNS.md)
+- [Development Status](docs/archive/STATUS.md)
+
+---
+
+**Thank you for contributing!** Every contribution helps make this library better for the entire SoundTouch community.

Dockerfile

@@ -0,0 +1,70 @@
+# Build stage
+FROM --platform=$BUILDPLATFORM golang:1.26.3-alpine AS builder
+
+# Declare automatic platform ARGs to make them available in build stage
+# See https://docs.docker.com/reference/dockerfile#automatic-platform-args-in-the-global-scope
+# We should not set defaults here, but rely on BuildKit to set them matching the BUILDPLATFORM
+ARG TARGETARCH
+ARG TARGETOS
+ARG TARGETVARIANT
+
+WORKDIR /app
+
+# Copy go mod and sum files
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy the rest of the source code
+COPY . .
+
+# Build the soundtouch-service
+RUN if [ "${TARGETARCH}" = "arm" ] && [ -n "${TARGETVARIANT}" ]; then \
+      CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} GOARM=${TARGETVARIANT#v} go build -o /soundtouch-service ./cmd/soundtouch-service; \
+    else \
+      CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /soundtouch-service ./cmd/soundtouch-service; \
+    fi
+
+# Build the soundtouch-web
+RUN if [ "${TARGETARCH}" = "arm" ] && [ -n "${TARGETVARIANT}" ]; then \
+      CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} GOARM=${TARGETVARIANT#v} go build -o /soundtouch-web ./cmd/soundtouch-web; \
+    else \
+      CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /soundtouch-web ./cmd/soundtouch-web; \
+    fi
+
+# soundtouch-service image
+FROM alpine:3.23 AS soundtouch-service
+
+RUN apk add --no-cache ca-certificates tzdata
+
+WORKDIR /app
+
+COPY --from=builder /soundtouch-service /app/soundtouch-service
+
+# Verify the binary works on the target platform
+RUN /app/soundtouch-service version || echo "Binary verification complete"
+
+RUN mkdir -p /app/data
+
+ENV PORT=8000
+ENV DATA_DIR=/app/data
+ENV LOG_PROXY_BODY=false
+ENV REDACT_PROXY_LOGS=true
+
+EXPOSE 8000
+
+ENTRYPOINT ["/app/soundtouch-service"]
+
+# soundtouch-web image
+FROM alpine:3.23 AS soundtouch-web
+
+RUN apk add --no-cache ca-certificates tzdata
+
+WORKDIR /app
+
+COPY --from=builder /soundtouch-web /app/soundtouch-web
+
+ENV PORT=8080
+
+EXPOSE 8080
+
+ENTRYPOINT ["/app/soundtouch-web"]

Dockerfile.stockholm

@@ -0,0 +1,40 @@
+# Dockerfile.stockholm — builds the Stockholm frontend preparation image.
+#
+# This image clones krahl/soundcork-stockholm-app, installs the required tools
+# (prettier, patch, unzip, jq), and is used exclusively to run the entrypoint
+# preparation step that extracts and patches the Stockholm frontend.
+#
+# Java is NOT included — we stop before `exec java`.
+#
+# Usage (see Makefile targets build-stockholm-image / prepare-stockholm):
+#
+#   docker build --build-arg STOCKHOLM_APP_REF=main \
+#       -f Dockerfile.stockholm -t soundcork-stockholm-app .
+#
+#   docker run --rm \
+#       -v "$PWD/stockholm_zip:/app/stockholm_zip:ro" \
+#       -v "$PWD/stockholm:/app/stockholm" \
+#       --entrypoint bash soundcork-stockholm-app \
+#       -c 'awk "/^exec java/{exit} {print}" /app/docker-entrypoint.sh | bash'
+
+FROM debian:bookworm-slim
+
+ARG STOCKHOLM_APP_REF=main
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        ca-certificates \
+        git \
+        jq \
+        unzip \
+        nodejs \
+        npm \
+        patch && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN npm install -g prettier@3.8.3 && npm cache clean --force
+
+RUN git clone --depth 1 --branch "${STOCKHOLM_APP_REF}" \
+    https://github.com/krahl/soundcork-stockholm-app /app
+
+WORKDIR /app

Makefile

@@ -1,4 +1,7 @@
-.PHONY: all build build-cli test test-coverage check fmt vet lint clean dev help
+.PHONY: all build build-cli test test-coverage test-http-client test-http-client-rotate check fmt vet lint clean dev help screenshots build-stockholm-image prepare-stockholm update-static-deps
+
+# Load .env if present (simple KEY=VALUE format, no shell quoting)
+-include .env
 
 # Go parameters
 GOCMD=go
@@ -12,73 +15,127 @@ GOFMT=gofmt
 # Build parameters
 BINARY_NAME=soundtouch-cli
 BINARY_PATH=./cmd/$(BINARY_NAME)
+SERVICE_NAME=soundtouch-service
+SERVICE_PATH=./cmd/$(SERVICE_NAME)
+WEB_NAME=soundtouch-web
+WEB_PATH=./cmd/$(WEB_NAME)
 EXAMPLE_MDNS_NAME=example-mdns
 EXAMPLE_MDNS_PATH=./cmd/$(EXAMPLE_MDNS_NAME)
 EXAMPLE_UPNP_NAME=example-upnp
 EXAMPLE_UPNP_PATH=./cmd/$(EXAMPLE_UPNP_NAME)
 SCANNER_NAME=mdns-scanner
 SCANNER_PATH=./cmd/$(SCANNER_NAME)
+FAVICON_GEN_NAME=favicon-gen
+FAVICON_GEN_PATH=./cmd/$(FAVICON_GEN_NAME)
+BACKUP_NAME=soundtouch-backup
+BACKUP_PATH=./cmd/$(BACKUP_NAME)
 BUILD_DIR=./build
 
-# Version info
-VERSION?=dev
-BUILD_TIME=$(shell date -u '+%Y-%m-%d_%H:%M:%S')
-COMMIT=$(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+# Build flags: strip debug info/DWARF for smaller binaries, remove local paths for reproducibility
+BUILDFLAGS=-trimpath -ldflags="-s -w"
 
-# Linker flags
-LDFLAGS=-X main.version=$(VERSION) -X main.date=$(BUILD_TIME) -X main.commit=$(COMMIT)
+# Stockholm frontend preparation (see Dockerfile.stockholm and docs/stockholm-port-guide.md)
+# STOCKHOLM_APP_REF can be overridden to pin a specific commit: make build-stockholm-image STOCKHOLM_APP_REF=<sha>
+STOCKHOLM_IMAGE    ?= soundcork-stockholm-app
+STOCKHOLM_APP_REF  ?= main
+STOCKHOLM_ZIP_DIR  ?= $(CURDIR)/stockholm_zip
+STOCKHOLM_DIR      ?= $(CURDIR)/stockholm
+# URLs baked into stockholm/json/config.json during prepare-stockholm.
+# The Go service rewrites these again at startup using SERVER_URL / MARGE_URL,
+# so these only matter for static-file-only deployments or when pre-baking is desired.
+# Default to localhost:8000 (matches the Go service default).
+BACKEND_URL        ?= http://localhost:8000
+# STREAMING_URL defaults to BACKEND_URL (no /marge suffix — set to $(BACKEND_URL)/marge for soundcork).
+STREAMING_URL      ?= $(BACKEND_URL)
+# AUTH_SERVICE_URL defaults to BACKEND_URL; override to point at a different auth endpoint.
+AUTH_SERVICE_URL   ?= $(BACKEND_URL)
 
 all: check build
 
-build: build-cli build-examples
+build: build-cli build-service build-web build-examples build-favicon-gen build-backup
 
 build-cli:
 	@echo "Building $(BINARY_NAME)..."
 	@mkdir -p $(BUILD_DIR)
-	$(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME) $(BINARY_PATH)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME) $(BINARY_PATH)
+
+build-service:
+	@echo "Building $(SERVICE_NAME)..."
+	@mkdir -p $(BUILD_DIR)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME) $(SERVICE_PATH)
+
+build-web:
+	@echo "Building $(WEB_NAME)..."
+	@mkdir -p $(BUILD_DIR)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(WEB_NAME) $(WEB_PATH)
 
 build-examples:
 	@echo "Building $(EXAMPLE_MDNS_NAME)..."
 	@mkdir -p $(BUILD_DIR)
-	$(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME) $(EXAMPLE_MDNS_PATH)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME) $(EXAMPLE_MDNS_PATH)
 	@echo "Building $(EXAMPLE_UPNP_NAME)..."
-	$(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME) $(EXAMPLE_UPNP_PATH)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME) $(EXAMPLE_UPNP_PATH)
 	@echo "Building $(SCANNER_NAME)..."
-	$(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(SCANNER_NAME) $(SCANNER_PATH)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SCANNER_NAME) $(SCANNER_PATH)
 
-build-all: build-linux build-darwin build-windows build-examples-all
+build-favicon-gen:
+	@echo "Building $(FAVICON_GEN_NAME)..."
+	@mkdir -p $(BUILD_DIR)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(FAVICON_GEN_NAME) $(FAVICON_GEN_PATH)
+
+build-backup:
+	@echo "Building $(BACKUP_NAME)..."
+	@mkdir -p $(BUILD_DIR)
+	$(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME) $(BACKUP_PATH)
+
+build-all: build-linux build-linux-armv7 build-darwin build-windows build-examples-all
 
 build-linux:
 	@echo "Building for Linux..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 $(BINARY_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 $(BINARY_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME)-linux-amd64 $(SERVICE_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME)-linux-amd64 $(BACKUP_PATH)
+
+build-linux-armv7:
+	@echo "Building for Linux ARMv7 (CGO_ENABLED=0 for kernel 3.14+ compatibility)..."
+	@mkdir -p $(BUILD_DIR)
+	GOOS=linux GOARCH=arm GOARM=7 CGO_ENABLED=0 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME)-linux-armv7 $(SERVICE_PATH)
+	GOOS=linux GOARCH=arm GOARM=7 CGO_ENABLED=0 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-armv7 $(BINARY_PATH)
+	GOOS=linux GOARCH=arm GOARM=7 CGO_ENABLED=0 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME)-linux-armv7 $(BACKUP_PATH)
 
 build-darwin:
 	@echo "Building for macOS..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=darwin GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-amd64 $(BINARY_PATH)
-	GOOS=darwin GOARCH=arm64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 $(BINARY_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-amd64 $(BINARY_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 $(BINARY_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME)-darwin-amd64 $(SERVICE_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME)-darwin-arm64 $(SERVICE_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME)-darwin-amd64 $(BACKUP_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME)-darwin-arm64 $(BACKUP_PATH)
 
 build-windows:
 	@echo "Building for Windows..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=windows GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe $(BINARY_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe $(BINARY_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SERVICE_NAME)-windows-amd64.exe $(SERVICE_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(BACKUP_NAME)-windows-amd64.exe $(BACKUP_PATH)
 
 build-examples-all:
 	@echo "Building examples for all platforms..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-linux-amd64 $(EXAMPLE_MDNS_PATH)
-	GOOS=darwin GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-darwin-amd64 $(EXAMPLE_MDNS_PATH)
-	GOOS=darwin GOARCH=arm64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-darwin-arm64 $(EXAMPLE_MDNS_PATH)
-	GOOS=windows GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-windows-amd64.exe $(EXAMPLE_MDNS_PATH)
-	GOOS=linux GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-linux-amd64 $(EXAMPLE_UPNP_PATH)
-	GOOS=darwin GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-darwin-amd64 $(EXAMPLE_UPNP_PATH)
-	GOOS=darwin GOARCH=arm64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-darwin-arm64 $(EXAMPLE_UPNP_PATH)
-	GOOS=windows GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-windows-amd64.exe $(EXAMPLE_UPNP_PATH)
-	GOOS=linux GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(SCANNER_NAME)-linux-amd64 $(SCANNER_PATH)
-	GOOS=darwin GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(SCANNER_NAME)-darwin-amd64 $(SCANNER_PATH)
-	GOOS=darwin GOARCH=arm64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(SCANNER_NAME)-darwin-arm64 $(SCANNER_PATH)
-	GOOS=windows GOARCH=amd64 $(GOBUILD) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(SCANNER_NAME)-windows-amd64.exe $(SCANNER_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-linux-amd64 $(EXAMPLE_MDNS_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-darwin-amd64 $(EXAMPLE_MDNS_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-darwin-arm64 $(EXAMPLE_MDNS_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_MDNS_NAME)-windows-amd64.exe $(EXAMPLE_MDNS_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-linux-amd64 $(EXAMPLE_UPNP_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-darwin-amd64 $(EXAMPLE_UPNP_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-darwin-arm64 $(EXAMPLE_UPNP_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(EXAMPLE_UPNP_NAME)-windows-amd64.exe $(EXAMPLE_UPNP_PATH)
+	GOOS=linux GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SCANNER_NAME)-linux-amd64 $(SCANNER_PATH)
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SCANNER_NAME)-darwin-amd64 $(SCANNER_PATH)
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SCANNER_NAME)-darwin-arm64 $(SCANNER_PATH)
+	GOOS=windows GOARCH=amd64 $(GOBUILD) $(BUILDFLAGS) -o $(BUILD_DIR)/$(SCANNER_NAME)-windows-amd64.exe $(SCANNER_PATH)
 
 test:
 	@echo "Running tests..."
@@ -90,7 +147,72 @@ test-coverage:
 	$(GOCMD) tool cover -html=coverage.out -o coverage.html
 	@echo "Coverage report generated: coverage.html"
 
-check: fmt vet test
+check: fmt vet test test-http-client
+
+# Archive any existing tests/integration/testdata/ to a timestamped sibling
+# so the next `make test-http-client` starts from a clean slate. Keeps the
+# old state around for retrospective debugging — never destructive.
+# Run BEFORE test-http-client when fixtures or schemas have changed and
+# stale state would otherwise be reused via the compose volume mount.
+test-http-client-rotate:
+	@if [ -d tests/integration/testdata ]; then \
+		archive=tests/integration/testdata_$$(date +%Y%m%d-%H%M%S); \
+		mv tests/integration/testdata "$$archive"; \
+		echo "Archived existing testdata to $$archive"; \
+	else \
+		echo "No tests/integration/testdata/ to archive — already fresh."; \
+	fi
+
+test-http-client:
+	@echo "Starting services with docker compose..."
+	@docker compose -f docker-compose.yml -f docker-compose.ci.yml up -d --build
+	@echo "Waiting for services to start..."
+	@sleep 10
+	@echo "Running .http tests..."
+	@docker run --rm --network soundtouch-test-net \
+		-v "$(PWD)/tests/integration/http-client:/workdir" \
+		jetbrains/intellij-http-client:2026.1 \
+		--env-file /workdir/http-client.env.json \
+		--env ci \
+		/workdir/spotify_registration.http \
+		/workdir/amazon_registration.http \
+		/workdir/create_account.http \
+		/workdir/register_device.http \
+		/workdir/spotify_full_flow.http \
+		/workdir/customer_support.http \
+		/workdir/power_on.http \
+		/workdir/get_bmx_services.http \
+		/workdir/get_sourceproviders.http \
+		/workdir/get_software_update.http \
+		/workdir/get_soundtouch_updates.http \
+		/workdir/get_streaming_token.http \
+		/workdir/post_oauth_token.http \
+		/workdir/post_oauth_token_amazon.http \
+		/workdir/get_provider_settings.http \
+		/workdir/tunein_playback_station.http \
+		/workdir/set_preset_6.http \
+		/workdir/get_presets.http \
+		/workdir/delete_preset_6.http \
+		/workdir/set_preset_5.http \
+		/workdir/post_recent.http \
+		/workdir/get_recents.http \
+		/workdir/get_account_presets.http \
+		/workdir/get_account_devices.http \
+		/workdir/get_account_sources.http \
+		/workdir/get_api_versions.http \
+		/workdir/post_musicprovider_is_eligible.http \
+		/workdir/get_full_account.http \
+		/workdir/create_group.http \
+		/workdir/get_group.http \
+		/workdir/rename_device.http \
+		/workdir/unregister_device.http \
+		--report; \
+	EXIT_CODE=$$?; \
+	docker compose -f docker-compose.yml -f docker-compose.ci.yml logs soundtouch-service; \
+	docker compose -f docker-compose.yml -f docker-compose.ci.yml logs spotify-mock; \
+	docker compose -f docker-compose.yml -f docker-compose.ci.yml logs amazon-mock; \
+	docker compose -f docker-compose.yml -f docker-compose.ci.yml down; \
+	exit $$EXIT_CODE
 
 fmt:
 	@echo "Formatting code..."
@@ -113,6 +235,30 @@ dev: build-cli
 	@echo "Starting development CLI..."
 	$(BUILD_DIR)/$(BINARY_NAME) -help
 
+dev-service: build-service
+	@echo "Starting development service..."
+	$(BUILD_DIR)/$(SERVICE_NAME)
+
+dev-service-proxy: build-service
+	@echo "Starting development service with proxy..."
+	@if [ -z "$(PROXY_URL)" ]; then \
+		echo "Usage: make dev-service-proxy PROXY_URL=http://localhost:8001"; \
+		exit 1; \
+	fi
+	PYTHON_BACKEND_URL=$(PROXY_URL) $(BUILD_DIR)/$(SERVICE_NAME)
+
+# Run the service with the Stockholm frontend enabled. Requires that
+# `make prepare-stockholm` has been run at least once (the check below
+# avoids re-running the Docker container on every dev launch).
+dev-service-stockholm: build-service
+	@if [ ! -f "$(STOCKHOLM_DIR)/index.html" ]; then \
+		echo "Error: Stockholm not prepared at $(STOCKHOLM_DIR)."; \
+		echo "Run 'make prepare-stockholm' first (needs stockholm_zip/stockholm.zip)."; \
+		exit 1; \
+	fi
+	@echo "Starting development service with Stockholm enabled from $(STOCKHOLM_DIR)..."
+	STOCKHOLM_DIR=$(STOCKHOLM_DIR) $(BUILD_DIR)/$(SERVICE_NAME)
+
 dev-discover: build-cli
 	@echo "Running device discovery..."
 	$(BUILD_DIR)/$(BINARY_NAME) -discover
@@ -120,7 +266,7 @@ dev-discover: build-cli
 dev-info: build-cli
 	@echo "Getting device info (requires -host flag)..."
 	@if [ -z "$(HOST)" ]; then \
-		echo "Usage: make dev-info HOST=192.168.1.10"; \
+		echo "Usage: make dev-info HOST=192.0.2.10"; \
 		exit 1; \
 	fi
 	$(BUILD_DIR)/$(BINARY_NAME) -host $(HOST) -info
@@ -169,9 +315,48 @@ dev-scan-http: build-examples
 	@echo "Scanning for HTTP mDNS services..."
 	$(BUILD_DIR)/$(SCANNER_NAME) -service _http._tcp -v
 
-install: build-cli
-	@echo "Installing $(BINARY_NAME) to $(GOPATH)/bin..."
+dev-web: build-web
+	@echo "Starting web UI (default port 8080)..."
+	cd cmd/soundtouch-web && ../../$(BUILD_DIR)/$(WEB_NAME)
+
+dev-web-port: build-web
+	@echo "Starting web UI on custom port..."
+	@if [ -z "$(PORT)" ]; then \
+		echo "Usage: make dev-web-port PORT=8888"; \
+		exit 1; \
+	fi
+	cd cmd/soundtouch-web && ../../$(BUILD_DIR)/$(WEB_NAME) -port $(PORT)
+
+dev-backup: build-backup
+	@echo "Running backup tool..."
+	$(BUILD_DIR)/$(BACKUP_NAME) --help
+
+dev-backup-cloud: build-backup
+	@echo "Running cloud backup..."
+	$(BUILD_DIR)/$(BACKUP_NAME) cloud
+
+dev-backup-local: build-backup
+	@echo "Running local backup (auto-discover)..."
+	$(BUILD_DIR)/$(BACKUP_NAME) local --discover
+
+dev-web-host: build-web
+	@echo "Starting web UI with specific host..."
+	@if [ -z "$(HOST)" ]; then \
+		echo "Usage: make dev-web-host HOST=192.0.2.10"; \
+		exit 1; \
+	fi
+	cd cmd/soundtouch-web && ../../$(BUILD_DIR)/$(WEB_NAME) -host $(HOST)
+
+install: build-cli build-service build-web build-backup
+	@echo "Installing binaries to $(GOPATH)/bin..."
 	cp $(BUILD_DIR)/$(BINARY_NAME) $(GOPATH)/bin/
+	cp $(BUILD_DIR)/$(SERVICE_NAME) $(GOPATH)/bin/
+	cp $(BUILD_DIR)/$(WEB_NAME) $(GOPATH)/bin/
+	cp $(BUILD_DIR)/$(BACKUP_NAME) $(GOPATH)/bin/
+
+update-static-deps:
+	@echo "Updating static frontend dependencies..."
+	@./scripts/update-static-deps.sh
 
 clean:
 	@echo "Cleaning..."
@@ -182,7 +367,7 @@ clean:
 release: clean check build-all
 	@echo "Creating release archive..."
 	@mkdir -p $(BUILD_DIR)/release
-	@for binary in $(BUILD_DIR)/$(BINARY_NAME)-*; do \
+	@for binary in $(BUILD_DIR)/$(BINARY_NAME)-* $(BUILD_DIR)/$(SERVICE_NAME)-*; do \
 		if [ -f "$$binary" ]; then \
 			cp "$$binary" $(BUILD_DIR)/release/; \
 		fi \
@@ -191,26 +376,108 @@ release: clean check build-all
 
 docker-build:
 	@echo "Building Docker image..."
-	docker build -t soundtouch-go:$(VERSION) .
+	docker build --target soundtouch-service -t soundtouch-service .
 
-docker-dev: docker-build
-	@echo "Running development container..."
-	docker run --rm -it --network host soundtouch-go:$(VERSION)
+# Stockholm frontend preparation.
+# Requires: Docker, internet access (clones github.com/krahl/soundcork-stockholm-app).
+# No pre-built image is published; the image must be built locally before running prepare-stockholm.
+build-stockholm-image:
+	@echo "Building Stockholm preparation image (clones upstream, installs prettier/patch)..."
+	docker build \
+		--build-arg STOCKHOLM_APP_REF=$(STOCKHOLM_APP_REF) \
+		-f Dockerfile.stockholm \
+		-t $(STOCKHOLM_IMAGE) \
+		.
+
+# Extracts and patches the Stockholm frontend using the upstream container image.
+# Requires: build-stockholm-image to have been run, and stockholm_zip/stockholm.zip to be present.
+# The resulting stockholm/ directory is used by the soundtouch-service at runtime.
+prepare-stockholm:
+	@mkdir -p "$(STOCKHOLM_DIR)"
+	@[ -f "$(STOCKHOLM_ZIP_DIR)/stockholm.zip" ] || { \
+		echo "Error: $(STOCKHOLM_ZIP_DIR)/stockholm.zip not found."; \
+		echo "Download the Stockholm zip and place it at stockholm_zip/stockholm.zip first."; \
+		exit 1; }
+	docker run --rm \
+		-e BACKEND_URL=$(BACKEND_URL) \
+		-e STREAMING_URL=$(STREAMING_URL) \
+		-e AUTH_SERVICE_URL=$(AUTH_SERVICE_URL) \
+		-v "$(STOCKHOLM_ZIP_DIR):/app/stockholm_zip:ro" \
+		-v "$(STOCKHOLM_DIR):/app/stockholm" \
+		--entrypoint bash \
+		$(STOCKHOLM_IMAGE) \
+		-c 'awk "/^exec java/{exit} {print}" /app/docker-entrypoint.sh | bash'
+	@# Patch update-urls.sh: replace the hardcoded ${BACKEND_URL}/marge with
+	@# ${STREAMING_URL:-${BACKEND_URL}} so the streaming URL is configurable and
+	@# defaults to BACKEND_URL (no /marge suffix) rather than the soundcork convention.
+	@script="$(STOCKHOLM_DIR)/json/update-urls.sh"; \
+	 awk '{ gsub(/\$$\{BACKEND_URL\}\/marge/, "$${STREAMING_URL:-$${BACKEND_URL}}"); print }' \
+	     "$$script" > "$$script.tmp" && mv "$$script.tmp" "$$script"
+	@# Restore config.json from the backup that update-urls.sh created.
+	@# The Go service rewrites URLs at startup via RewriteConfigURLs, so we start
+	@# from the original Bose URLs rather than whatever update-urls.sh produced.
+	@[ ! -f "$(STOCKHOLM_DIR)/json/backup.json" ] || \
+		cp "$(STOCKHOLM_DIR)/json/backup.json" "$(STOCKHOLM_DIR)/json/config.json"
+	@# Patch browse.js: guard against empty browse-path array so that
+	@# funcObj.browse.getPath() returning undefined does not throw when the user
+	@# has not browsed yet (causes "Now playing error: topLevel" console spam and
+	@# aborts the now-playing update handler).
+	@sed -i.bak \
+		-e 's/: (l()\.topLevel/: ((l() || {}).topLevel/' \
+		-e 's/var a = l()\.topLevel,/var a = (l() || {}).topLevel,/' \
+		-e 's/E() === 0 || funcObj\.browse\.getPath()\.topLevel/E() === 0 || (funcObj.browse.getPath() || {}).topLevel/' \
+		"$(STOCKHOLM_DIR)/js/browse.js" && \
+		rm -f "$(STOCKHOLM_DIR)/js/browse.js.bak"
+	@# Patch bridge JS: replace hardcoded /api/* paths with __stockholmBase-prefixed
+	@# versions so the bridge works when Stockholm is mounted under a base path.
+	@# browser_http_proxy.js declares the proxy URL as a top-level constant;
+	@# without patching it, requests from a /stockholm/* page hit /api/http-proxy
+	@# directly and 404 because the proxy is mounted under the base path.
+	@# Also fix resolveWebviewUrl to include the base path when resolving relative URLs.
+	@python3 scripts/patch-stockholm-bridge.py \
+		"$(STOCKHOLM_DIR)/js/browser_http_proxy.js" \
+		"$(STOCKHOLM_DIR)/js/browser_native_bridge.js" \
+		"$(STOCKHOLM_DIR)/js/app_comm.js" \
+		"$(STOCKHOLM_DIR)/setup/js/app_comm.js"
+	@echo "Stockholm frontend prepared at $(STOCKHOLM_DIR)"
+
+docker-run-host:
+	@echo "Running Docker container..."
+	@echo "Note: --network host is used for discovery (Linux only). For macOS/Windows use port mapping."
+	docker run --rm -it --network host -v $$(pwd)/data:/app/data soundtouch-service
+
+docker-run-ports:
+	@echo "Running Docker container with port mapping (discovery will be manual)..."
+	docker run --rm -it -p 8000:8000 -v $$(pwd)/data:/app/data soundtouch-service
+
+screenshots:
+	@echo "Capturing documentation screenshots..."
+	@bash scripts/screenshots/run.sh
 
 help:
 	@echo "Available targets:"
-	@echo "  build         - Build the CLI tool and examples"
+	@echo "  build         - Build the CLI tool, service, and examples"
 	@echo "  build-cli     - Build only the CLI tool"
+	@echo "  build-service - Build only the service"
+	@echo "  build-backup  - Build only the backup tool"
+	@echo "  build-favicon-gen - Build the favicon generator"
 	@echo "  build-examples - Build only the example programs"
 	@echo "  build-all     - Build for all platforms"
+	@echo "  build-linux-armv7 - Build for Linux ARMv7 (kernel 3.14+ compatible, CGO_ENABLED=0)"
 	@echo "  test          - Run tests"
 	@echo "  test-coverage - Run tests with coverage report"
+	@echo "  test-http-client         - Run .http integration tests via Docker Compose"
+	@echo "  test-http-client-rotate  - Archive tests/integration/testdata/ before a fresh run (non-destructive)"
 	@echo "  check         - Run fmt, vet, and tests"
 	@echo "  fmt           - Format code"
 	@echo "  vet           - Run go vet"
 	@echo "  lint          - Run golangci-lint"
 	@echo "  tidy          - Tidy dependencies"
 	@echo "  dev           - Build and show CLI help"
+	@echo "  dev-service   - Build and run service locally"
+	@echo "  dev-service-proxy - Build and run service with proxy (PROXY_URL=url required)"
+	@echo "  dev-service-stockholm - Build and run service with Stockholm frontend (requires prior 'make prepare-stockholm')"
+	@echo "  screenshots   - Capture documentation screenshots (headless Chrome via chromedp)"
 	@echo "  dev-discover  - Build and run device discovery"
 	@echo "  dev-info      - Build and get device info (HOST=ip required)"
 	@echo "  dev-mdns      - Build and run mDNS discovery example"
@@ -222,16 +489,28 @@ help:
 	@echo "  dev-scan-all     - Scan all mDNS services on network"
 	@echo "  dev-scan-soundtouch - Scan specifically for SoundTouch mDNS services"
 	@echo "  dev-scan-http    - Scan for HTTP mDNS services"
-	@echo "  install       - Install binary to GOPATH/bin"
+	@echo "  dev-backup       - Build and show backup tool help"
+	@echo "  dev-backup-cloud - Build and run cloud backup (prompts for credentials)"
+	@echo "  dev-backup-local - Build and run local backup (auto-discover speakers)"
+	@echo "  dev-web          - Build and run web UI (default port 8080)"
+	@echo "  dev-web-port     - Build and run web UI on custom port (PORT=8888)"
+	@echo "  dev-web-host     - Build and run web UI with specific device (HOST=ip)"
+	@echo "  install       - Install binaries to GOPATH/bin"
 	@echo "  clean         - Clean build artifacts"
 	@echo "  release       - Create release binaries"
 	@echo "  docker-build  - Build Docker image"
-	@echo "  docker-dev    - Run development container"
+	@echo "  docker-run-host  - Run container with host networking (Linux discovery)"
+	@echo "  docker-run-ports - Run container with port mapping (macOS/Windows/No discovery)"
+	@echo "  build-stockholm-image - Build Stockholm prep image (requires Docker + internet)"
+	@echo "  prepare-stockholm     - Extract and patch Stockholm frontend (requires build-stockholm-image"
+	@echo "                          and stockholm_zip/stockholm.zip; see docs/stockholm-port-guide.md)"
 	@echo "  help          - Show this help message"
 	@echo ""
 	@echo "Examples:"
+	@echo "  make dev-service"
+	@echo "  make dev-service-proxy PROXY_URL=http://192.0.2.50:8001"
 	@echo "  make dev-discover"
-	@echo "  make dev-info HOST=192.168.1.10"
+	@echo "  make dev-info HOST=192.0.2.10"
 	@echo "  make dev-mdns"
 	@echo "  make dev-mdns-verbose"
 	@echo "  make dev-mdns-timeout TIMEOUT=10s"
@@ -240,5 +519,8 @@ help:
 	@echo "  make dev-upnp-timeout TIMEOUT=10s"
 	@echo "  make dev-scan-all"
 	@echo "  make dev-scan-soundtouch"
+	@echo "  make dev-web"
+	@echo "  make dev-web-port PORT=8888"
+	@echo "  make dev-web-host HOST=192.0.2.10"
 	@echo "  make test"
 	@echo "  make build-all"

cmd/debug-consolidation/main.go

@@ -0,0 +1,242 @@
+// Package main provides a debug tool for analyzing device consolidation and migration scenarios.
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("Usage: debug-consolidation <data-directory>")
+		fmt.Println("Example: debug-consolidation /var/lib/soundtouch-service")
+		os.Exit(1)
+	}
+
+	dataDir := os.Args[1]
+
+	fmt.Printf("🔍 Analyzing device consolidation in: %s\n", dataDir)
+
+	// Initialize datastore
+	ds := datastore.NewDataStore(dataDir)
+
+	// List all devices
+	devices, err := ds.ListAllDevices()
+	if err != nil {
+		log.Fatalf("Failed to list devices: %v", err)
+	}
+
+	fmt.Printf("📱 Found %d device entries:\n", len(devices))
+
+	for i := range devices {
+		device := &devices[i]
+		fmt.Printf("  %d. %s (Account: %s)\n", i+1, device.DeviceID, device.AccountID)
+		fmt.Printf("     Name: %s\n", device.Name)
+		fmt.Printf("     IP: %s, MAC: %s, Serial: %s\n",
+			device.IPAddress, device.MacAddress, device.DeviceSerialNumber)
+
+		// Check directory contents
+		deviceDir := ds.AccountDeviceDir(device.AccountID, device.DeviceID)
+		analyzeDeviceDirectory(deviceDir, device.DeviceID)
+		fmt.Println()
+	}
+
+	// Group devices by potential physical device
+	fmt.Println("🔄 Analyzing potential consolidation opportunities:")
+
+	deviceGroups := groupDevicesByIdentity(devices)
+
+	for i, group := range deviceGroups {
+		if len(group) <= 1 {
+			continue
+		}
+
+		fmt.Printf("  Group %d - %d entries for same physical device:\n", i+1, len(group))
+
+		for i := range group {
+			device := &group[i]
+			deviceDir := ds.AccountDeviceDir(device.AccountID, device.DeviceID)
+			fileCount := countFiles(deviceDir)
+			fmt.Printf("    - %s (%d files)\n", device.DeviceID, fileCount)
+		}
+
+		// Recommend consolidation target
+		macDevice := findMACBasedDevice(group)
+		if macDevice != nil {
+			fmt.Printf("    → Recommend keeping: %s (MAC-based)\n", macDevice.DeviceID)
+		} else {
+			fmt.Printf("    → No clear MAC-based target found\n")
+		}
+
+		fmt.Println()
+	}
+}
+
+func analyzeDeviceDirectory(dirPath, deviceID string) {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		fmt.Printf("     Directory: %s (Error: %v)\n", dirPath, err)
+		return
+	}
+
+	fmt.Printf("     Directory: %s (%d files)\n", dirPath, len(entries))
+
+	// Check for important files
+	importantFiles := []string{"DeviceInfo.xml", "Presets.xml", "Recents.xml", "Sources.xml"}
+	for _, fileName := range importantFiles {
+		filePath := filepath.Join(dirPath, fileName)
+		if stat, err := os.Stat(filePath); err == nil {
+			status := "✓"
+			if stat.Size() == 0 {
+				status = "⚠️ (empty)"
+			} else if stat.Size() < 100 {
+				status = "⚠️ (very small)"
+			}
+
+			fmt.Printf("       %s %s (%d bytes)\n", status, fileName, stat.Size())
+		} else {
+			fmt.Printf("       ❌ %s (missing)\n", fileName)
+		}
+	}
+
+	// Check if deviceID looks like MAC address
+	if isLikelyMACAddress(deviceID) {
+		fmt.Printf("       📍 Device ID appears to be MAC address format\n")
+	} else {
+		fmt.Printf("       📍 Device ID appears to be %s format\n", guessIDType(deviceID))
+	}
+}
+
+func countFiles(dirPath string) int {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		return 0
+	}
+
+	count := 0
+
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			count++
+		}
+	}
+
+	return count
+}
+
+func groupDevicesByIdentity(devices []models.ServiceDeviceInfo) [][]models.ServiceDeviceInfo {
+	var groups [][]models.ServiceDeviceInfo
+
+	// Simple grouping by MAC address and serial number
+	macGroups := make(map[string][]models.ServiceDeviceInfo)
+	serialGroups := make(map[string][]models.ServiceDeviceInfo)
+	ipGroups := make(map[string][]models.ServiceDeviceInfo)
+
+	for i := range devices {
+		device := &devices[i]
+		// Group by MAC address
+		if device.MacAddress != "" {
+			macGroups[device.MacAddress] = append(macGroups[device.MacAddress], *device)
+		}
+
+		// Group by serial number
+		if device.DeviceSerialNumber != "" {
+			serialGroups[device.DeviceSerialNumber] = append(serialGroups[device.DeviceSerialNumber], *device)
+		}
+
+		// Group by IP address
+		if device.IPAddress != "" {
+			ipGroups[device.IPAddress] = append(ipGroups[device.IPAddress], *device)
+		}
+	}
+
+	// Merge groups - prioritize MAC address grouping
+	processed := make(map[string]bool)
+
+	for _, macDevices := range macGroups {
+		if len(macDevices) > 1 {
+			groups = append(groups, macDevices)
+			for i := range macDevices {
+				processed[macDevices[i].DeviceID] = true
+			}
+		}
+	}
+
+	// Check for serial number groups not already processed
+	for _, serialDevices := range serialGroups {
+		if len(serialDevices) > 1 {
+			unprocessed := []models.ServiceDeviceInfo{}
+
+			for i := range serialDevices {
+				if !processed[serialDevices[i].DeviceID] {
+					unprocessed = append(unprocessed, serialDevices[i])
+				}
+			}
+
+			if len(unprocessed) > 1 {
+				groups = append(groups, unprocessed)
+				for i := range unprocessed {
+					processed[unprocessed[i].DeviceID] = true
+				}
+			}
+		}
+	}
+
+	return groups
+}
+
+func findMACBasedDevice(devices []models.ServiceDeviceInfo) *models.ServiceDeviceInfo {
+	for i := range devices {
+		if isLikelyMACAddress(devices[i].DeviceID) {
+			return &devices[i]
+		}
+	}
+
+	return nil
+}
+
+func isLikelyMACAddress(id string) bool {
+	// MAC addresses are typically 12 hex characters without separators
+	// or 17 characters with separators (XX:XX:XX:XX:XX:XX)
+	if len(id) == 12 {
+		for _, c := range id {
+			if (c < '0' || c > '9') && (c < 'A' || c > 'F') && (c < 'a' || c > 'f') {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func guessIDType(id string) string {
+	if len(id) > 15 && (id[0] == 'I' || id[0] == 'K') {
+		return "serial number"
+	}
+
+	// Check if it looks like an IP address
+	if len(id) >= 7 && len(id) <= 15 {
+		dotCount := 0
+
+		for _, c := range id {
+			if c == '.' {
+				dotCount++
+			} else if c < '0' || c > '9' {
+				break
+			}
+		}
+
+		if dotCount == 3 {
+			return "IP address"
+		}
+	}
+
+	return "unknown"
+}

cmd/dummy-speaker/main.go

@@ -0,0 +1,107 @@
+// Command dummy-speaker runs an HTTP-only fake SoundTouch speaker and
+// optionally registers it with a running soundtouch-service so the web UI
+// has a device to display.
+//
+// Intended for documentation screenshots and local UI smoke checks. Do not
+// use against a real network — the fixture payload is synthetic and would
+// confuse other tooling that expects live device data.
+//
+// Example:
+//
+//	dummy-speaker --port 8090 --register http://localhost:8000
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/service/testing/fakespeaker"
+)
+
+func main() {
+	listen := flag.String("listen", "127.0.0.1:8090", "bind address for the fake speaker's HTTP API")
+	telnetListen := flag.String("telnet-listen", "127.0.0.1:17000", "bind address for the fake speaker's telnet diagnostic shell (empty to disable)")
+	register := flag.String("register", "", "service base URL (e.g. http://localhost:8000) to self-register with via POST /setup/devices")
+	registerAs := flag.String("register-as", "", "address to send to /setup/devices (defaults to --listen)")
+
+	flag.Parse()
+
+	s, err := fakespeaker.Start(fakespeaker.Config{
+		HTTPListen:   *listen,
+		TelnetListen: *telnetListen,
+	})
+	if err != nil {
+		log.Fatalf("start fake speaker: %v", err)
+	}
+
+	log.Printf("fake speaker HTTP listening on http://%s", s.HTTPAddr())
+
+	if addr := s.TelnetAddr(); addr != "" {
+		log.Printf("fake speaker telnet listening on tcp://%s", addr)
+	}
+
+	if *register != "" {
+		target := *registerAs
+		if target == "" {
+			target = s.HTTPAddr()
+		}
+
+		if err := registerWithService(*register, target); err != nil {
+			log.Printf("self-register failed: %v (continuing anyway)", err)
+		} else {
+			log.Printf("registered %s with service at %s", target, *register)
+		}
+	}
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+	<-sig
+
+	log.Printf("shutting down")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	if err := s.Stop(ctx); err != nil {
+		log.Printf("stop: %v", err)
+	}
+}
+
+func registerWithService(serviceURL, deviceAddr string) error {
+	body, err := json.Marshal(map[string]string{"ip": deviceAddr})
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, serviceURL+"/setup/devices", bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode >= 300 {
+		return fmt.Errorf("service responded %s", resp.Status)
+	}
+
+	return nil
+}

cmd/favicon-gen/main.go

@@ -0,0 +1,152 @@
+// Package main provides a utility to generate PNG and ICO favicons from SVG source files.
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"image"
+	"image/png"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/srwiley/oksvg"
+	"github.com/srwiley/rasterx"
+)
+
+func main() {
+	mediaDir := "pkg/service/handlers/web/img"
+	files := []string{"favicon-braille", "favicon-morse"}
+
+	for _, name := range files {
+		svgPath := filepath.Join(mediaDir, name+".svg")
+		pngPath := filepath.Join(mediaDir, name+".png")
+		icoPath := filepath.Join(mediaDir, name+".ico")
+
+		fmt.Printf("Processing %s...\n", name)
+
+		// 1. Render SVG to PNG
+		img, err := renderSVG(svgPath, 32, 32)
+		if err != nil {
+			log.Fatalf("Failed to render %s: %v", svgPath, err)
+		}
+
+		f, err := os.Create(pngPath)
+		if err != nil {
+			log.Fatalf("Failed to create %s: %v", pngPath, err)
+		}
+
+		if err := png.Encode(f, img); err != nil {
+			f.Close()
+			log.Fatalf("Failed to encode PNG %s: %v", pngPath, err)
+		}
+
+		f.Close()
+		fmt.Printf("Created %s\n", pngPath)
+
+		// 2. Create ICO (containing multiple sizes)
+		sizes := []int{16, 32, 48}
+
+		var images []image.Image
+
+		for _, s := range sizes {
+			m, err := renderSVG(svgPath, s, s)
+			if err != nil {
+				log.Fatalf("Failed to render %s at size %d: %v", svgPath, s, err)
+			}
+
+			images = append(images, m)
+		}
+
+		if err := writeICO(icoPath, images); err != nil {
+			log.Fatalf("Failed to write ICO %s: %v", icoPath, err)
+		}
+
+		fmt.Printf("Created %s\n", icoPath)
+	}
+}
+
+func renderSVG(path string, w, h int) (image.Image, error) {
+	in, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer in.Close()
+
+	icon, err := oksvg.ReadIconStream(in)
+	if err != nil {
+		return nil, err
+	}
+
+	icon.SetTarget(0, 0, float64(w), float64(h))
+	rgba := image.NewRGBA(image.Rect(0, 0, w, h))
+	gv := rasterx.NewScannerGV(w, h, rgba, rgba.Bounds())
+	dasher := rasterx.NewDasher(w, h, gv)
+	icon.Draw(dasher, 1.0)
+
+	return rgba, nil
+}
+
+// Simple ICO encoder that wraps PNGs
+func writeICO(path string, images []image.Image) error {
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	bw := bufio.NewWriter(f)
+	defer bw.Flush()
+
+	// ICONDIR header
+	// Reserved (2), Type (2), Count (2)
+	binary.Write(bw, binary.LittleEndian, uint16(0))
+	binary.Write(bw, binary.LittleEndian, uint16(1)) // 1 = ICO
+	binary.Write(bw, binary.LittleEndian, uint16(len(images)))
+
+	var pngData [][]byte
+
+	for _, img := range images {
+		var buf bytes.Buffer
+		if err := png.Encode(&buf, img); err != nil {
+			return err
+		}
+
+		pngData = append(pngData, buf.Bytes())
+	}
+
+	offset := uint32(6 + len(images)*16)
+	for i, img := range images {
+		b := img.Bounds()
+
+		width := uint8(b.Dx())
+		if b.Dx() >= 256 {
+			width = 0
+		}
+
+		height := uint8(b.Dy())
+		if b.Dy() >= 256 {
+			height = 0
+		}
+
+		// ICONDIRENTRY
+		bw.WriteByte(width)
+		bw.WriteByte(height)
+		bw.WriteByte(0)                                   // Color count
+		bw.WriteByte(0)                                   // Reserved
+		binary.Write(bw, binary.LittleEndian, uint16(1))  // Planes (1)
+		binary.Write(bw, binary.LittleEndian, uint16(32)) // Bits per pixel (32)
+		binary.Write(bw, binary.LittleEndian, uint32(len(pngData[i])))
+		binary.Write(bw, binary.LittleEndian, offset)
+
+		offset += uint32(len(pngData[i]))
+	}
+
+	for _, data := range pngData {
+		bw.Write(data)
+	}
+
+	return nil
+}

cmd/mock-amazon/main.go

@@ -0,0 +1,23 @@
+// Package main provides a mock Amazon LWA server for testing purposes.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gesellix/bose-soundtouch/pkg/testutils/amazon"
+)
+
+func main() {
+	port := flag.Int("port", 8080, "Port to listen on")
+
+	flag.Parse()
+
+	log.Printf("Starting mock Amazon LWA server on port %d", *port)
+
+	if err := http.ListenAndServe(fmt.Sprintf(":%d", *port), amazon.NewAmazonHandler()); err != nil {
+		log.Fatal(err)
+	}
+}

cmd/mock-spotify/main.go

@@ -0,0 +1,23 @@
+// Package main provides a mock Spotify server for testing purposes.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gesellix/bose-soundtouch/pkg/testutils/spotify"
+)
+
+func main() {
+	port := flag.Int("port", 8080, "Port to listen on")
+
+	flag.Parse()
+
+	log.Printf("Starting mock Spotify server on port %d", *port)
+
+	if err := http.ListenAndServe(fmt.Sprintf(":%d", *port), spotify.NewSpotifyHandler()); err != nil {
+		log.Fatal(err)
+	}
+}

cmd/soundtouch-backup/README.md

@@ -0,0 +1,212 @@
+# soundtouch-backup
+
+A standalone tool for backing up Bose SoundTouch data — both your **cloud account** (presets, devices, sources) and the **local filesystem** of each speaker — before the Bose cloud services shut down on May 6, 2026.
+
+## Overview
+
+| Subcommand | What it backs up                                                                                   |
+|------------|----------------------------------------------------------------------------------------------------|
+| `all`      | Cloud account **and** all paired speakers in one step — the recommended starting point             |
+| `cloud`    | Bose account profile, paired devices, cloud presets, music service sources                         |
+| `local`    | Speaker HTTP API data (presets, sources, volume, …) and optionally device filesystem files via SSH |
+
+Output is a single `.tar.gz` archive (or `.zip`) with a dated root directory.
+
+## Building
+
+```bash
+make build-backup
+# binary: ./build/soundtouch-backup
+```
+
+Or install alongside the other tools:
+
+```bash
+make install
+```
+
+## Usage
+
+### Combined backup (recommended)
+
+The `all` command is the simplest way to capture everything: it authenticates with the Bose cloud, backs up your account data, then reads the IP addresses from `devices.xml` and backs up each reachable speaker over HTTP.
+
+```bash
+# Interactive — prompts for email and password
+soundtouch-backup all
+
+# Non-interactive
+soundtouch-backup all --email you@example.com --password secret
+
+# Include SSH filesystem backup for each speaker
+soundtouch-backup all --ssh
+
+# Environment variables
+BOSE_EMAIL=you@example.com BOSE_PASSWORD=secret soundtouch-backup all --ssh
+```
+
+**Flags**
+
+| Flag         | Short  | Default                               | Description                                            |
+|--------------|--------|---------------------------------------|--------------------------------------------------------|
+| `--email`    | `-e`   | —                                     | Bose account email (`$BOSE_EMAIL`)                     |
+| `--password` | `--pw` | —                                     | Bose account password (`$BOSE_PASSWORD`)               |
+| `--ssh`      |        | on                                    | Also capture filesystem files via SSH for each speaker |
+| `--output`   | `-o`   | `soundtouch-backup-YYYY-MM-DD.tar.gz` | Output archive path                                    |
+| `--format`   |        | `tar.gz`                              | Archive format: `tar.gz` or `zip`                      |
+
+Speakers that are offline or unreachable at the time of backup are skipped with a `✗` warning; the cloud data is still saved.
+
+---
+
+### Cloud backup
+
+Backs up data from your Bose account at `streaming.bose.com`. Credentials are prompted interactively if not supplied as flags.
+
+```bash
+# Interactive — prompts for email, masked password input
+soundtouch-backup cloud
+
+# Non-interactive
+soundtouch-backup cloud --email you@example.com --password secret
+
+# Environment variables (avoids secrets in shell history)
+BOSE_EMAIL=you@example.com BOSE_PASSWORD=secret soundtouch-backup cloud
+
+# Zip output
+soundtouch-backup cloud --format zip --output my-bose-cloud.zip
+```
+
+**Flags**
+
+| Flag         | Short  | Default                               | Description                                       |
+|--------------|--------|---------------------------------------|---------------------------------------------------|
+| `--email`    | `-e`   | —                                     | Bose account email (`$BOSE_EMAIL`)                |
+| `--password` | `--pw` | —                                     | Bose account password (`$BOSE_PASSWORD`)          |
+| `--output`   | `-o`   | `soundtouch-backup-YYYY-MM-DD.tar.gz` | Output archive path (`$SOUNDTOUCH_BACKUP_OUTPUT`) |
+| `--format`   |        | `tar.gz`                              | Archive format: `tar.gz` or `zip`                 |
+
+**What gets fetched**
+
+| File in archive          | Source endpoint                                                                 |
+|--------------------------|---------------------------------------------------------------------------------|
+| `cloud/emailaddress.xml` | `GET /streaming/account/{id}/emailaddress`                                      |
+| `cloud/devices.xml`      | `GET /streaming/account/{id}/devices`                                           |
+| `cloud/sources.xml`      | `GET /streaming/account/{id}/sources`                                           |
+| `cloud/presets.xml`      | `GET /streaming/account/{id}/presets/all`                                       |
+| `cloud/full.xml`         | `GET /streaming/account/{id}/full` (may overlap with the above; skipped if 4xx) |
+
+---
+
+### Local backup
+
+Backs up each speaker over its HTTP API on port 8090. With `--ssh`, also captures key filesystem files via SSH.
+
+```bash
+# Auto-discover all speakers on the local network
+soundtouch-backup local
+
+# Specific speaker
+soundtouch-backup local --host 192.0.2.11
+
+# Multiple speakers
+soundtouch-backup local --host 192.0.2.11 --host 192.0.2.10
+
+# Include SSH filesystem backup
+soundtouch-backup local --ssh
+
+# Longer discovery window on busy networks
+soundtouch-backup local --discover-timeout 10s
+```
+
+**Flags**
+
+| Flag                 | Short | Default                               | Description                                      |
+|----------------------|-------|---------------------------------------|--------------------------------------------------|
+| `--host`             | `-H`  | —                                     | Speaker host/IP, repeatable (`$SOUNDTOUCH_HOST`) |
+| `--port`             | `-p`  | `8090`                                | Speaker HTTP port (`$SOUNDTOUCH_PORT`)           |
+| `--discover`         | `-d`  | auto                                  | Force mDNS/UPnP discovery                        |
+| `--discover-timeout` |       | `5s`                                  | Discovery timeout                                |
+| `--ssh`              |       | on                                    | Also capture filesystem files via SSH            |
+| `--output`           | `-o`  | `soundtouch-backup-YYYY-MM-DD.tar.gz` | Output archive path                              |
+| `--format`           |       | `tar.gz`                              | Archive format: `tar.gz` or `zip`                |
+
+**What gets fetched via HTTP**
+
+| File                | Device endpoint |
+|---------------------|-----------------|
+| `info.xml`          | `/info`         |
+| `name.xml`          | `/name`         |
+| `presets.xml`       | `/presets`      |
+| `sources.xml`       | `/sources`      |
+| `now_playing.xml`   | `/now_playing`  |
+| `volume.xml`        | `/volume`       |
+| `bass.xml`          | `/bass`         |
+| `balance.xml`       | `/balance`      |
+| `capabilities.xml`  | `/capabilities` |
+| `network_info.xml`  | `/networkInfo`  |
+| `clock_display.xml` | `/clockDisplay` |
+| `zone.xml`          | `/getZone`      |
+
+Endpoints that return HTTP 4xx (not supported on the device model) are silently skipped.
+
+**What gets fetched via SSH** (`--ssh`)
+
+SSH connects as `root@<host>:22` with an empty password, which is the default for SoundTouch firmware.
+
+Individual files:
+
+| Remote path               | Notes                                      |
+|---------------------------|--------------------------------------------|
+| `/etc/hosts`              | DNS redirect state                         |
+| `/etc/resolv.conf`        | DNS resolver configuration                 |
+| `/etc/remote_services`    | Service registration (post-migration only) |
+| `/mnt/nv/remote_services` | Alternative location for remote services   |
+
+Directories (all regular files recursively):
+
+| Remote path                      | Contents                                                                   |
+|----------------------------------|----------------------------------------------------------------------------|
+| `/opt/Bose/etc/`                 | Full Bose configuration directory, including `SoundTouchSdkPrivateCfg.xml` |
+| `/mnt/nv/BoseApp-Persistence/1/` | Persisted app state                                                        |
+
+Missing files and directories are silently skipped with a `⚠` warning.
+
+---
+
+## Archive structure
+
+Both subcommands write into a single dated archive:
+
+```
+soundtouch-backup-2026-05-02/
+├── cloud/
+│   ├── emailaddress.xml
+│   ├── devices.xml
+│   ├── sources.xml
+│   └── presets.xml
+└── local/
+    ├── A_Sound_Machine/
+    │   ├── info.xml
+    │   ├── presets.xml
+    │   ├── sources.xml
+    │   ├── volume.xml
+    │   ├── …
+    │   └── ssh/
+    │       ├── etc/
+    │       │   ├── hosts
+    │       │   └── resolv.conf
+    │       ├── opt/Bose/etc/
+    │       │   └── SoundTouchSdkPrivateCfg.xml
+    │       └── mnt/nv/BoseApp-Persistence/1/
+    └── Sound_Machinechen/
+        └── …
+```
+
+Running `cloud` and `local` separately produces two archives. To combine them, use the same `--output` path for both invocations — each adds its own subdirectory so they won't collide (`.tar.gz` does not support appending; use `--format zip` if you need a single archive from two runs, or just keep them separate).
+
+## See also
+
+- [Cloud Shutdown Survival Guide](../../docs/guides/SURVIVAL-GUIDE.md) — full migration context
+- [`soundtouch-cli`](../soundtouch-cli/) — live device control
+- [`soundtouch-service`](../soundtouch-service/) — local cloud replacement

cmd/soundtouch-backup/cmd_all.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/urfave/cli/v2"
+)
+
+func allCommand() *cli.Command {
+	return &cli.Command{
+		Name:  "all",
+		Usage: "Back up cloud account then all paired speakers in one go",
+		Description: "Authenticates with the Bose cloud, backs up account data, then reads" +
+			" the device IP addresses from the cloud device list and backs up each reachable" +
+			" speaker over HTTP (and optionally SSH).",
+		Flags: append(outputFlags,
+			&cli.StringFlag{
+				Name:    "email",
+				Aliases: []string{"e"},
+				Usage:   "Bose account email",
+				EnvVars: []string{"BOSE_EMAIL"},
+			},
+			&cli.StringFlag{
+				Name:    "password",
+				Aliases: []string{"pw"},
+				Usage:   "Bose account password",
+				EnvVars: []string{"BOSE_PASSWORD"},
+			},
+			&cli.BoolFlag{
+				Name:  "ssh",
+				Usage: "Also back up device filesystem files via SSH (root@host:22, no password required)",
+				Value: true,
+			},
+		),
+		Action: runAllBackup,
+	}
+}
+
+func runAllBackup(c *cli.Context) error {
+	doSSH := c.Bool("ssh")
+	output := resolveOutputPath(c.String("output"), c.String("format"))
+	format := c.String("format")
+
+	// 1. Cloud backup
+	client, err := setupCloudClient(c.String("email"), c.String("password"))
+	if err != nil {
+		return err
+	}
+
+	root := archiveRoot()
+	files := collectCloudFiles(client, root)
+
+	if len(files) == 0 {
+		return fmt.Errorf("no cloud data fetched")
+	}
+
+	// 2. Resolve speakers from devices.xml, then back each one up
+	devicesData := files[root+"/cloud/devices.xml"]
+	if devicesData == nil {
+		printWarn("devices.xml not available — skipping local backup")
+	} else {
+		targets := parseDevicesXML(devicesData)
+		if len(targets) == 0 {
+			printWarn("no device IP addresses found in devices.xml")
+		} else {
+			fmt.Printf("Found %d device(s) in cloud account, attempting local backup...\n", len(targets))
+		}
+
+		hc := &http.Client{Timeout: 10 * time.Second}
+
+		for k, v := range collectLocalFiles(hc, targets, root, doSSH) {
+			files[k] = v
+		}
+	}
+
+	if err := writeArchive(output, format, files); err != nil {
+		return fmt.Errorf("writing archive: %w", err)
+	}
+
+	fmt.Printf("Archive written: %s (%d files)\n", output, len(files))
+
+	return nil
+}
+
+type xmlDevice struct {
+	Name      string `xml:"name"`
+	IPAddress string `xml:"ipaddress"`
+}
+
+type xmlDevices struct {
+	XMLName xml.Name    `xml:"devices"`
+	Devices []xmlDevice `xml:"device"`
+}
+
+// parseDevicesXML extracts speaker targets from a devices.xml cloud response.
+func parseDevicesXML(data []byte) []speakerTarget {
+	var d xmlDevices
+
+	if err := xml.Unmarshal(data, &d); err != nil {
+		return nil
+	}
+
+	var targets []speakerTarget
+
+	for _, dev := range d.Devices {
+		if dev.IPAddress == "" {
+			continue
+		}
+
+		// Pass name as a hint for error messages; backupSpeakerHTTP re-fetches
+		// from /info to get the current name and include info.xml in the archive.
+		targets = append(targets, speakerTarget{host: dev.IPAddress, port: 8090, name: dev.Name})
+	}
+
+	return targets
+}

cmd/soundtouch-backup/cmd_cloud.go

@@ -0,0 +1,252 @@
+package main
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"time"
+
+	"github.com/urfave/cli/v2"
+)
+
+const (
+	streamingBase  = "https://streaming.bose.com"
+	streamingCT    = "application/vnd.bose.streaming-v1.1+xml"
+	stockholmVer   = "27.0.13-4277+8963611.epdbuild.develop.hepdswbld04.2025-10-02T13:17:00"
+	nativeFrameVer = "27.0.2 -3353+4ae7c78.epdbuild.HEAD.ssgbld02.2023-10-12T15:10Z"
+	protocolVer    = "67"
+	appGUID        = "b94dedd1-a61b-492b-b86b-2bc32c9261f4"
+	appUserAgent   = "Mozilla/5.0 (Linux; Android 13; Android SDK built for arm64 Build/TE1A.220922.034; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/101.0.4951.61 Mobile Safari/537.36 Manufacturer/unknown DeviceModel/Android-SDK-built-for-arm64 SOUNDTOUCH_MOBILE_APP/" + appGUID
+)
+
+func cloudCommand() *cli.Command {
+	return &cli.Command{
+		Name:  "cloud",
+		Usage: "Back up your Bose SoundTouch cloud account (devices, presets, sources)",
+		Flags: append(outputFlags,
+			&cli.StringFlag{
+				Name:    "email",
+				Aliases: []string{"e"},
+				Usage:   "Bose account email",
+				EnvVars: []string{"BOSE_EMAIL"},
+			},
+			&cli.StringFlag{
+				Name:    "password",
+				Aliases: []string{"pw"},
+				Usage:   "Bose account password",
+				EnvVars: []string{"BOSE_PASSWORD"},
+			},
+		),
+		Action: runCloudBackup,
+	}
+}
+
+func runCloudBackup(c *cli.Context) error {
+	output := resolveOutputPath(c.String("output"), c.String("format"))
+	format := c.String("format")
+
+	client, err := setupCloudClient(c.String("email"), c.String("password"))
+	if err != nil {
+		return err
+	}
+
+	root := archiveRoot()
+	files := collectCloudFiles(client, root)
+
+	if len(files) == 0 {
+		return fmt.Errorf("no data fetched")
+	}
+
+	if err := writeArchive(output, format, files); err != nil {
+		return fmt.Errorf("writing archive: %w", err)
+	}
+
+	fmt.Printf("Archive written: %s (%d files)\n", output, len(files))
+
+	return nil
+}
+
+// setupCloudClient prompts for missing credentials, then authenticates with the Bose cloud.
+func setupCloudClient(email, password string) (*cloudClient, error) {
+	if email == "" || password == "" {
+		var err error
+
+		email, password, err = promptCredentials(email)
+		if err != nil {
+			return nil, fmt.Errorf("credentials: %w", err)
+		}
+	}
+
+	if email == "" || password == "" {
+		return nil, fmt.Errorf("email and password are required")
+	}
+
+	fmt.Printf("Authenticating as %s...\n", email)
+
+	client, err := loginToCloud(email, password)
+	if err != nil {
+		return nil, fmt.Errorf("authentication failed: %w", err)
+	}
+
+	printOK(fmt.Sprintf("Authenticated (account ID: %s)", client.accountID))
+
+	return client, nil
+}
+
+// collectCloudFiles fetches all cloud account data and returns a files map ready for
+// archiving. Keys are prefixed with root (e.g. "soundtouch-backup-2026-05-02/cloud/").
+func collectCloudFiles(client *cloudClient, root string) map[string][]byte {
+	type cloudEndpoint struct {
+		label    string
+		filename string
+		fetch    func(*cloudClient) ([]byte, error)
+	}
+
+	endpoints := []cloudEndpoint{
+		{"email address", "emailaddress.xml", fetchEmailAddress},
+		{"devices", "devices.xml", fetchDevices},
+		{"sources", "sources.xml", fetchSources},
+		{"presets", "presets.xml", fetchPresets},
+		{"full account", "full.xml", fetchFull},
+	}
+
+	files := make(map[string][]byte)
+
+	for _, ep := range endpoints {
+		data, err := ep.fetch(client)
+		if err != nil {
+			printFail(fmt.Sprintf("%s: %v", ep.label, err))
+
+			continue
+		}
+
+		files[root+"/cloud/"+ep.filename] = data
+		printOK(fmt.Sprintf("%s (%d bytes)", ep.label, len(data)))
+	}
+
+	return files
+}
+
+type cloudClient struct {
+	http      *http.Client
+	accountID string
+	token     string
+}
+
+type loginXML struct {
+	XMLName  xml.Name `xml:"login"`
+	Username string   `xml:"username"`
+	Password string   `xml:"password"`
+}
+
+var accountIDRe = regexp.MustCompile(`<account\s+id="([^"]+)"`)
+
+func loginToCloud(email, password string) (*cloudClient, error) {
+	loginBody, err := xml.Marshal(loginXML{Username: email, Password: password})
+	if err != nil {
+		return nil, err
+	}
+
+	body := []byte(`<?xml version="1.0" encoding="UTF-8"?>`)
+	body = append(body, loginBody...)
+
+	req, err := http.NewRequest("POST", streamingBase+"/streaming/account/login", bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	setStreamingHeaders(req, "")
+
+	hc := &http.Client{Timeout: 30 * time.Second}
+
+	resp, err := hc.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+
+	token := resp.Header.Get("credentials")
+	if token == "" {
+		return nil, fmt.Errorf("no credentials in response — check your email and password")
+	}
+
+	data, err := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+	if err != nil {
+		return nil, err
+	}
+
+	m := accountIDRe.FindSubmatch(data)
+	if len(m) < 2 {
+		return nil, fmt.Errorf("could not extract account ID from login response")
+	}
+
+	return &cloudClient{http: hc, accountID: string(m[1]), token: token}, nil
+}
+
+func setStreamingHeaders(req *http.Request, token string) {
+	req.Header.Set("content-type", streamingCT)
+	req.Header.Set("accept", streamingCT)
+	req.Header.Set("clienttype", "SOUNDTOUCH_MOBILE_APP")
+	req.Header.Set("version_stockholmversion", stockholmVer)
+	req.Header.Set("version_nativeframeversion", nativeFrameVer)
+	req.Header.Set("version_protocolversion", protocolVer)
+	req.Header.Set("user-agent", appUserAgent)
+	req.Header.Set("guid", appGUID)
+	req.Header.Set("x-requested-with", "com.bose.soundtouch")
+	req.Header.Set("pragma", "no-cache")
+	req.Header.Set("cache-control", "no-cache")
+
+	if token != "" {
+		req.Header.Set("authorization", token)
+	}
+}
+
+func (c *cloudClient) get(path string) ([]byte, error) {
+	url := fmt.Sprintf("%s%s?_=%d", streamingBase, path, time.Now().UnixMilli())
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	setStreamingHeaders(req, c.token)
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+
+	return io.ReadAll(io.LimitReader(resp.Body, 2*1024*1024))
+}
+
+func fetchEmailAddress(c *cloudClient) ([]byte, error) {
+	return c.get("/streaming/account/" + c.accountID + "/emailaddress")
+}
+
+func fetchDevices(c *cloudClient) ([]byte, error) {
+	return c.get("/streaming/account/" + c.accountID + "/devices")
+}
+
+func fetchSources(c *cloudClient) ([]byte, error) {
+	return c.get("/streaming/account/" + c.accountID + "/sources")
+}
+
+func fetchPresets(c *cloudClient) ([]byte, error) {
+	return c.get("/streaming/account/" + c.accountID + "/presets/all")
+}
+
+func fetchFull(c *cloudClient) ([]byte, error) {
+	return c.get("/streaming/account/" + c.accountID + "/full")
+}

cmd/soundtouch-backup/cmd_local.go

@@ -0,0 +1,288 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/config"
+	"github.com/gesellix/bose-soundtouch/pkg/discovery"
+	"github.com/gesellix/bose-soundtouch/pkg/ssh"
+	"github.com/urfave/cli/v2"
+)
+
+var localEndpoints = []struct {
+	path string
+	file string
+}{
+	{"/info", "info.xml"},
+	{"/name", "name.xml"},
+	{"/presets", "presets.xml"},
+	{"/sources", "sources.xml"},
+	{"/now_playing", "now_playing.xml"},
+	{"/volume", "volume.xml"},
+	{"/bass", "bass.xml"},
+	{"/balance", "balance.xml"},
+	{"/capabilities", "capabilities.xml"},
+	{"/networkInfo", "network_info.xml"},
+	{"/clockDisplay", "clock_display.xml"},
+	{"/getZone", "zone.xml"},
+}
+
+// sshFiles lists individual device filesystem paths captured via SSH.
+// Paths that may not exist on all devices are silently skipped.
+var sshFiles = []string{
+	"/etc/hosts",
+	"/etc/resolv.conf",
+	"/etc/remote_services",
+	"/mnt/nv/remote_services",
+}
+
+// sshDirs lists device directories whose contents are recursively captured via SSH.
+var sshDirs = []string{
+	"/opt/Bose/etc",
+	"/mnt/nv/BoseApp-Persistence/1",
+}
+
+func localCommand() *cli.Command {
+	return &cli.Command{
+		Name:  "local",
+		Usage: "Back up one or more SoundTouch speakers on your local network",
+		Flags: append(outputFlags,
+			&cli.StringSliceFlag{
+				Name:    "host",
+				Aliases: []string{"H"},
+				Usage:   "Speaker host/IP (repeatable for multiple speakers)",
+				EnvVars: []string{"SOUNDTOUCH_HOST"},
+			},
+			&cli.IntFlag{
+				Name:    "port",
+				Aliases: []string{"p"},
+				Usage:   "Speaker HTTP port",
+				Value:   8090,
+				EnvVars: []string{"SOUNDTOUCH_PORT"},
+			},
+			&cli.BoolFlag{
+				Name:    "discover",
+				Aliases: []string{"d"},
+				Usage:   "Auto-discover speakers on the local network",
+			},
+			&cli.DurationFlag{
+				Name:  "discover-timeout",
+				Usage: "Discovery timeout",
+				Value: 5 * time.Second,
+			},
+			&cli.BoolFlag{
+				Name:  "ssh",
+				Usage: "Also back up device filesystem files via SSH (root@host:22, no password required)",
+				Value: true,
+			},
+		),
+		Action: runLocalBackup,
+	}
+}
+
+type speakerTarget struct {
+	host string
+	port int
+	name string
+}
+
+func runLocalBackup(c *cli.Context) error {
+	hosts := c.StringSlice("host")
+	port := c.Int("port")
+	doDiscover := c.Bool("discover") || len(hosts) == 0
+	discoverTimeout := c.Duration("discover-timeout")
+	doSSH := c.Bool("ssh")
+	output := resolveOutputPath(c.String("output"), c.String("format"))
+	format := c.String("format")
+
+	var targets []speakerTarget
+
+	if doDiscover {
+		fmt.Printf("Discovering speakers (timeout: %s)...\n", discoverTimeout)
+
+		ctx, cancel := context.WithTimeout(c.Context, discoverTimeout)
+		defer cancel()
+
+		cfg, _ := config.LoadFromEnv()
+		svc := discovery.NewUnifiedDiscoveryService(cfg)
+
+		found, discErr := svc.DiscoverDevices(ctx)
+		if discErr != nil {
+			printWarn(fmt.Sprintf("Discovery failed: %v", discErr))
+		}
+
+		for _, d := range found {
+			targets = append(targets, speakerTarget{host: d.Host, port: d.Port, name: d.Name})
+			printOK(fmt.Sprintf("Found: %s (%s:%d)", d.Name, d.Host, d.Port))
+		}
+	}
+
+	for _, h := range hosts {
+		targets = append(targets, speakerTarget{host: h, port: port})
+	}
+
+	if len(targets) == 0 {
+		return fmt.Errorf("no speakers found — use --host <ip> or --discover")
+	}
+
+	hc := &http.Client{Timeout: 10 * time.Second}
+	root := archiveRoot()
+	files := collectLocalFiles(hc, targets, root, doSSH)
+
+	if len(files) == 0 {
+		return fmt.Errorf("no data collected")
+	}
+
+	if err := writeArchive(output, format, files); err != nil {
+		return fmt.Errorf("writing archive: %w", err)
+	}
+
+	fmt.Printf("Archive written: %s (%d files)\n", output, len(files))
+
+	return nil
+}
+
+// collectLocalFiles backs up all targets over HTTP (and optionally SSH) and returns
+// a files map ready for archiving. Keys are prefixed with root.
+func collectLocalFiles(hc *http.Client, targets []speakerTarget, root string, doSSH bool) map[string][]byte {
+	files := make(map[string][]byte)
+
+	for _, t := range targets {
+		name, entries, err := backupSpeakerHTTP(hc, t)
+		if err != nil {
+			printFail(fmt.Sprintf("%s:%d — %v", t.host, t.port, err))
+
+			continue
+		}
+
+		dir := root + "/local/" + sanitizeName(name) + "/"
+
+		for filename, data := range entries {
+			files[dir+filename] = data
+		}
+
+		printOK(fmt.Sprintf("%s: %d files via HTTP", name, len(entries)))
+
+		if doSSH {
+			sshEntries := backupSpeakerSSH(t.host, name)
+
+			for filename, data := range sshEntries {
+				files[dir+filename] = data
+			}
+
+			if len(sshEntries) > 0 {
+				printOK(fmt.Sprintf("%s: %d files via SSH", name, len(sshEntries)))
+			}
+		}
+	}
+
+	return files
+}
+
+func backupSpeakerHTTP(hc *http.Client, t speakerTarget) (name string, files map[string][]byte, err error) {
+	base := fmt.Sprintf("http://%s:%d", t.host, t.port)
+	files = make(map[string][]byte)
+	name = t.name
+	infoFetched := false
+
+	if name == "" {
+		data, ferr := fetchRaw(hc, base+"/info")
+		if ferr != nil {
+			return "", nil, fmt.Errorf("cannot reach %s: %w", base, ferr)
+		}
+
+		files["info.xml"] = data
+		infoFetched = true
+
+		if extracted := xmlFirst(data, "name"); extracted != "" {
+			name = extracted
+		} else {
+			name = t.host
+		}
+	}
+
+	for _, ep := range localEndpoints {
+		if ep.path == "/info" && infoFetched {
+			continue
+		}
+
+		data, ferr := fetchRaw(hc, base+ep.path)
+		if ferr != nil {
+			printWarn(fmt.Sprintf("%s: skipped %s (%v)", name, ep.file, ferr))
+			continue
+		}
+
+		files[ep.file] = data
+	}
+
+	return name, files, nil
+}
+
+// backupSpeakerSSH connects to the device via SSH and reads the key filesystem paths.
+// Files that don't exist on the device are silently skipped.
+// Returned map keys are relative paths within the device backup directory (e.g. "ssh/etc/hosts").
+func backupSpeakerSSH(host, deviceName string) map[string][]byte {
+	client := ssh.NewClient(host)
+	files := make(map[string][]byte)
+
+	for _, remotePath := range sshFiles {
+		data, err := client.ReadFile(remotePath)
+		if err != nil {
+			// Most missing files are expected (e.g. /etc/remote_services only exists post-migration)
+			printWarn(fmt.Sprintf("%s: SSH skipped %s (%v)", deviceName, remotePath, err))
+
+			continue
+		}
+
+		if len(data) == 0 {
+			printWarn(fmt.Sprintf("%s: SSH empty file %s", deviceName, remotePath))
+		}
+
+		files["ssh"+remotePath] = data
+	}
+
+	for _, remoteDir := range sshDirs {
+		dirFiles, err := client.ReadDir(remoteDir)
+		if err != nil {
+			printWarn(fmt.Sprintf("%s: SSH skipped dir %s (%v)", deviceName, remoteDir, err))
+			continue
+		}
+
+		for path, data := range dirFiles {
+			files["ssh"+path] = data
+		}
+	}
+
+	return files
+}
+
+func fetchRaw(hc *http.Client, url string) ([]byte, error) {
+	resp, err := hc.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+
+	return io.ReadAll(io.LimitReader(resp.Body, 1024*1024))
+}
+
+func xmlFirst(data []byte, field string) string {
+	re := regexp.MustCompile(`<` + regexp.QuoteMeta(field) + `[^>]*>([^<]+)</` + regexp.QuoteMeta(field) + `>`)
+
+	m := re.FindSubmatch(data)
+	if len(m) >= 2 {
+		return strings.TrimSpace(string(m[1]))
+	}
+
+	return ""
+}

cmd/soundtouch-backup/common.go

@@ -0,0 +1,172 @@
+package main
+
+import (
+	"archive/tar"
+	"archive/zip"
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/term"
+)
+
+const (
+	FormatTarGz = "tar.gz"
+	FormatZip   = "zip"
+)
+
+var outputFlags = []cli.Flag{
+	&cli.StringFlag{
+		Name:    "output",
+		Aliases: []string{"o"},
+		Usage:   "Output archive file (default: soundtouch-backup-YYYY-MM-DD.tar.gz)",
+		EnvVars: []string{"SOUNDTOUCH_BACKUP_OUTPUT"},
+	},
+	&cli.StringFlag{
+		Name:  "format",
+		Usage: "Archive format: tar.gz or zip",
+		Value: FormatTarGz,
+	},
+}
+
+func resolveOutputPath(output, format string) string {
+	date := time.Now().Format("2006-01-02")
+
+	ext := ".tar.gz"
+	if format == FormatZip {
+		ext = ".zip"
+	}
+
+	filename := "soundtouch-backup-" + date + ext
+
+	if output == "" {
+		return filename
+	}
+
+	if info, err := os.Stat(output); err == nil && info.IsDir() {
+		return output + string(os.PathSeparator) + filename
+	}
+
+	return output
+}
+
+func archiveRoot() string {
+	return "soundtouch-backup-" + time.Now().Format("2006-01-02")
+}
+
+func writeArchive(outputPath, format string, files map[string][]byte) error {
+	if format == FormatZip {
+		return writeZip(outputPath, files)
+	}
+
+	return writeTarGz(outputPath, files)
+}
+
+func writeTarGz(outputPath string, files map[string][]byte) error {
+	f, err := os.Create(outputPath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	gz := gzip.NewWriter(f)
+	defer gz.Close()
+
+	tw := tar.NewWriter(gz)
+	defer tw.Close()
+
+	now := time.Now()
+	for name, data := range files {
+		hdr := &tar.Header{
+			Name:     name,
+			Mode:     0644,
+			Size:     int64(len(data)),
+			ModTime:  now,
+			Typeflag: tar.TypeReg,
+		}
+		if err := tw.WriteHeader(hdr); err != nil {
+			return fmt.Errorf("tar header %s: %w", name, err)
+		}
+
+		if _, err := tw.Write(data); err != nil {
+			return fmt.Errorf("tar write %s: %w", name, err)
+		}
+	}
+
+	return nil
+}
+
+func writeZip(outputPath string, files map[string][]byte) error {
+	f, err := os.Create(outputPath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	zw := zip.NewWriter(f)
+	defer zw.Close()
+
+	for name, data := range files {
+		w, err := zw.Create(name)
+		if err != nil {
+			return fmt.Errorf("zip entry %s: %w", name, err)
+		}
+
+		if _, err := w.Write(data); err != nil {
+			return fmt.Errorf("zip write %s: %w", name, err)
+		}
+	}
+
+	return nil
+}
+
+func promptCredentials(emailHint string) (email, password string, err error) {
+	r := bufio.NewReader(os.Stdin)
+
+	if emailHint != "" {
+		email = emailHint
+	} else {
+		fmt.Print("Bose account email: ")
+
+		email, err = r.ReadString('\n')
+		if err != nil {
+			return
+		}
+
+		email = strings.TrimSpace(email)
+	}
+
+	fmt.Print("Password: ")
+
+	raw, termErr := term.ReadPassword(int(os.Stdin.Fd()))
+
+	fmt.Println()
+
+	if termErr != nil {
+		err = fmt.Errorf("reading password: %w (tip: use --password flag or BOSE_PASSWORD env var)", termErr)
+		return
+	}
+
+	password = string(raw)
+
+	return
+}
+
+func sanitizeName(name string) string {
+	r := strings.NewReplacer(
+		"/", "_", "\\", "_", ":", "_",
+		"*", "_", "?", "_", "\"", "_",
+		"<", "_", ">", "_", "|", "_",
+		" ", "_",
+	)
+
+	return r.Replace(name)
+}
+
+func printOK(msg string)   { fmt.Printf("  ✓ %s\n", msg) }
+func printFail(msg string) { fmt.Printf("  ✗ %s\n", msg) }
+func printWarn(msg string) { fmt.Printf("  ⚠ %s\n", msg) }

cmd/soundtouch-backup/main.go

@@ -0,0 +1,37 @@
+// Package main implements the soundtouch-backup tool for backing up Bose SoundTouch
+// cloud account data and local speaker filesystem files.
+package main
+
+import (
+	"log"
+	"os"
+	"runtime/debug"
+
+	"github.com/urfave/cli/v2"
+)
+
+var version = "dev"
+
+func init() {
+	if info, ok := debug.ReadBuildInfo(); ok {
+		if info.Main.Version != "" && info.Main.Version != "(devel)" {
+			version = info.Main.Version
+		}
+	}
+}
+
+func main() {
+	app := &cli.App{
+		Name:    "soundtouch-backup",
+		Usage:   "Back up Bose SoundTouch account and speaker data",
+		Version: version,
+		Commands: []*cli.Command{
+			allCommand(),
+			cloudCommand(),
+			localCommand(),
+		},
+	}
+	if err := app.Run(os.Args); err != nil {
+		log.Fatal(err)
+	}
+}

cmd/soundtouch-cli/cmd_account.go

@@ -0,0 +1,742 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// createCredentialsForSource creates credentials for the specified source type
+func createCredentialsForSource(source, user, password, displayName string) *models.MusicServiceCredentials {
+	switch source {
+	case "SPOTIFY":
+		return models.NewSpotifyCredentials(user, password)
+	case "PANDORA":
+		return models.NewPandoraCredentials(user, password)
+	case "AMAZON":
+		return models.NewAmazonMusicCredentials(user, password)
+	case "DEEZER":
+		return models.NewDeezerCredentials(user, password)
+	case "IHEART":
+		return models.NewIHeartRadioCredentials(user, password)
+	case "STORED_MUSIC":
+		if displayName == "" {
+			displayName = "Network Music Library"
+		}
+
+		return models.NewStoredMusicCredentials(user, displayName)
+	default:
+		// Generic credentials for other services
+		if displayName == "" {
+			displayName = source
+		}
+
+		return models.NewMusicServiceCredentials(source, displayName, user, password)
+	}
+}
+
+// validateAccountInput validates the input parameters for account management
+func validateAccountInput(source, user, password string) error {
+	if source == "" {
+		return fmt.Errorf("source is required (use --source)")
+	}
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	// STORED_MUSIC doesn't require a password
+	if source != "STORED_MUSIC" && password == "" {
+		return fmt.Errorf("password is required for %s (use --password)", source)
+	}
+
+	return nil
+}
+
+// addMusicServiceAccount handles adding a music service account
+func addMusicServiceAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	source := strings.ToUpper(c.String("source"))
+	user := c.String("user")
+	password := c.String("password")
+	displayName := c.String("name")
+
+	if validationErr := validateAccountInput(source, user, password); validationErr != nil {
+		return validationErr
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Adding %s account", source), clientConfig.Host, clientConfig.Port)
+
+	credentials := createCredentialsForSource(source, user, password, displayName)
+
+	// Override display name if provided
+	if c.IsSet("name") {
+		credentials.DisplayName = displayName
+	}
+
+	fmt.Printf("  Service: %s\n", credentials.GetDescription())
+	fmt.Printf("  User: %s\n", user)
+
+	if source == "STORED_MUSIC" {
+		fmt.Printf("  Type: Network Music Library\n")
+	} else {
+		fmt.Printf("  Type: Streaming Service\n")
+	}
+
+	err = client.SetMusicServiceAccount(credentials)
+	if err != nil {
+		return fmt.Errorf("failed to add music service account: %w", err)
+	}
+
+	PrintSuccess(fmt.Sprintf("%s account added successfully", source))
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select this source: soundtouch-cli --host %s source select --source %s --account %s\n", clientConfig.Host, source, user)
+
+	return nil
+}
+
+// removeMusicServiceAccount handles removing a music service account
+func removeMusicServiceAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	source := strings.ToUpper(c.String("source"))
+	user := c.String("user")
+	displayName := c.String("name")
+
+	if source == "" {
+		return fmt.Errorf("source is required (use --source)")
+	}
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Removing %s account", source), clientConfig.Host, clientConfig.Port)
+
+	var credentials *models.MusicServiceCredentials
+
+	// Create credentials for removal (empty password)
+	switch source {
+	case "SPOTIFY":
+		credentials = models.NewSpotifyCredentials(user, "")
+	case "PANDORA":
+		credentials = models.NewPandoraCredentials(user, "")
+	case "AMAZON":
+		credentials = models.NewAmazonMusicCredentials(user, "")
+	case "DEEZER":
+		credentials = models.NewDeezerCredentials(user, "")
+	case "IHEART":
+		credentials = models.NewIHeartRadioCredentials(user, "")
+	case "STORED_MUSIC":
+		if displayName == "" {
+			displayName = "Network Music Library"
+		}
+
+		credentials = models.NewStoredMusicCredentials(user, displayName)
+	default:
+		// Generic credentials for other services
+		if displayName == "" {
+			displayName = source
+		}
+
+		credentials = models.NewMusicServiceCredentials(source, displayName, user, "")
+	}
+
+	// Override display name if provided
+	if c.IsSet("name") {
+		credentials.DisplayName = displayName
+	}
+
+	fmt.Printf("  Service: %s\n", credentials.GetDescription())
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemoveMusicServiceAccount(credentials)
+	if err != nil {
+		return fmt.Errorf("failed to remove music service account: %w", err)
+	}
+
+	PrintSuccess(fmt.Sprintf("%s account removed successfully", source))
+
+	return nil
+}
+
+// addSpotifyAccount is a convenience command for adding Spotify accounts
+func addSpotifyAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	password := c.String("password")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if password == "" {
+		return fmt.Errorf("password is required (use --password)")
+	}
+
+	PrintDeviceHeader("Adding Spotify Premium account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+	fmt.Printf("  Service: Spotify Premium\n")
+
+	err = client.AddSpotifyAccount(user, password)
+	if err != nil {
+		return fmt.Errorf("failed to add Spotify account: %w", err)
+	}
+
+	PrintSuccess("Spotify account added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select Spotify: soundtouch-cli --host %s source spotify\n", clientConfig.Host)
+
+	return nil
+}
+
+// removeSpotifyAccount is a convenience command for removing Spotify accounts
+func removeSpotifyAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader("Removing Spotify account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemoveSpotifyAccount(user)
+	if err != nil {
+		return fmt.Errorf("failed to remove Spotify account: %w", err)
+	}
+
+	PrintSuccess("Spotify account removed successfully")
+
+	return nil
+}
+
+// addPandoraAccount is a convenience command for adding Pandora accounts
+func addPandoraAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	password := c.String("password")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if password == "" {
+		return fmt.Errorf("password is required (use --password)")
+	}
+
+	PrintDeviceHeader("Adding Pandora account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+	fmt.Printf("  Service: Pandora Music Service\n")
+
+	err = client.AddPandoraAccount(user, password)
+	if err != nil {
+		return fmt.Errorf("failed to add Pandora account: %w", err)
+	}
+
+	PrintSuccess("Pandora account added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select Pandora: soundtouch-cli --host %s source select --source PANDORA --account %s\n", clientConfig.Host, user)
+
+	return nil
+}
+
+// removePandoraAccount is a convenience command for removing Pandora accounts
+func removePandoraAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader("Removing Pandora account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemovePandoraAccount(user)
+	if err != nil {
+		return fmt.Errorf("failed to remove Pandora account: %w", err)
+	}
+
+	PrintSuccess("Pandora account removed successfully")
+
+	return nil
+}
+
+// addStoredMusicAccount is a convenience command for adding STORED_MUSIC accounts
+func addStoredMusicAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	displayName := c.String("name")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user) - this should be the UPnP server GUID with /0 suffix")
+	}
+
+	if displayName == "" {
+		displayName = "Network Music Library"
+	}
+
+	PrintDeviceHeader("Adding network music library", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  Server ID: %s\n", user)
+	fmt.Printf("  Display Name: %s\n", displayName)
+	fmt.Printf("  Type: UPnP/DLNA Media Server\n")
+
+	err = client.AddStoredMusicAccount(user, displayName)
+	if err != nil {
+		return fmt.Errorf("failed to add network music library: %w", err)
+	}
+
+	PrintSuccess("Network music library added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Browse library: soundtouch-cli --host %s browse stored-music --account %s\n", clientConfig.Host, user)
+
+	return nil
+}
+
+// addAmazonMusicAccount is a convenience command for adding Amazon Music accounts
+func addAmazonMusicAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	password := c.String("password")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if password == "" {
+		return fmt.Errorf("password is required (use --password)")
+	}
+
+	PrintDeviceHeader("Adding Amazon Music account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+	fmt.Printf("  Service: Amazon Music\n")
+
+	err = client.AddAmazonMusicAccount(user, password)
+	if err != nil {
+		return fmt.Errorf("failed to add Amazon Music account: %w", err)
+	}
+
+	PrintSuccess("Amazon Music account added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select Amazon Music: soundtouch-cli --host %s source select --source AMAZON --account %s\n", clientConfig.Host, user)
+
+	return nil
+}
+
+// removeAmazonMusicAccount is a convenience command for removing Amazon Music accounts
+func removeAmazonMusicAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader("Removing Amazon Music account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemoveAmazonMusicAccount(user)
+	if err != nil {
+		return fmt.Errorf("failed to remove Amazon Music account: %w", err)
+	}
+
+	PrintSuccess("Amazon Music account removed successfully")
+
+	return nil
+}
+
+// addDeezerAccount is a convenience command for adding Deezer accounts
+func addDeezerAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	password := c.String("password")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if password == "" {
+		return fmt.Errorf("password is required (use --password)")
+	}
+
+	PrintDeviceHeader("Adding Deezer Premium account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+	fmt.Printf("  Service: Deezer Premium\n")
+
+	err = client.AddDeezerAccount(user, password)
+	if err != nil {
+		return fmt.Errorf("failed to add Deezer account: %w", err)
+	}
+
+	PrintSuccess("Deezer account added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select Deezer: soundtouch-cli --host %s source select --source DEEZER --account %s\n", clientConfig.Host, user)
+
+	return nil
+}
+
+// removeDeezerAccount is a convenience command for removing Deezer accounts
+func removeDeezerAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader("Removing Deezer account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemoveDeezerAccount(user)
+	if err != nil {
+		return fmt.Errorf("failed to remove Deezer account: %w", err)
+	}
+
+	PrintSuccess("Deezer account removed successfully")
+
+	return nil
+}
+
+// addIHeartRadioAccount is a convenience command for adding iHeartRadio accounts
+func addIHeartRadioAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	password := c.String("password")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if password == "" {
+		return fmt.Errorf("password is required (use --password)")
+	}
+
+	PrintDeviceHeader("Adding iHeartRadio account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+	fmt.Printf("  Service: iHeartRadio\n")
+
+	err = client.AddIHeartRadioAccount(user, password)
+	if err != nil {
+		return fmt.Errorf("failed to add iHeartRadio account: %w", err)
+	}
+
+	PrintSuccess("iHeartRadio account added successfully")
+
+	// Show next steps
+	fmt.Printf("\n💡 Next Steps:\n")
+	fmt.Printf("   • Check available sources: soundtouch-cli --host %s source list\n", clientConfig.Host)
+	fmt.Printf("   • Select iHeartRadio: soundtouch-cli --host %s source select --source IHEART --account %s\n", clientConfig.Host, user)
+
+	return nil
+}
+
+// removeIHeartRadioAccount is a convenience command for removing iHeartRadio accounts
+func removeIHeartRadioAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	PrintDeviceHeader("Removing iHeartRadio account", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  User: %s\n", user)
+
+	err = client.RemoveIHeartRadioAccount(user)
+	if err != nil {
+		return fmt.Errorf("failed to remove iHeartRadio account: %w", err)
+	}
+
+	PrintSuccess("iHeartRadio account removed successfully")
+
+	return nil
+}
+
+// removeStoredMusicAccount is a convenience command for removing STORED_MUSIC accounts
+func removeStoredMusicAccount(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	user := c.String("user")
+	displayName := c.String("name")
+
+	if user == "" {
+		return fmt.Errorf("user is required (use --user)")
+	}
+
+	if displayName == "" {
+		displayName = "Network Music Library"
+	}
+
+	PrintDeviceHeader("Removing network music library", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  Server ID: %s\n", user)
+	fmt.Printf("  Display Name: %s\n", displayName)
+
+	err = client.RemoveStoredMusicAccount(user, displayName)
+	if err != nil {
+		return fmt.Errorf("failed to remove network music library: %w", err)
+	}
+
+	PrintSuccess("Network music library removed successfully")
+
+	return nil
+}
+
+// listMusicServiceAccounts shows configured music service accounts from sources
+func listMusicServiceAccounts(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Music service accounts", clientConfig.Host, clientConfig.Port)
+
+	sources, err := client.GetSources()
+	if err != nil {
+		return fmt.Errorf("failed to get sources: %w", err)
+	}
+
+	// Filter for streaming/music service sources
+	musicSources := []string{"SPOTIFY", "PANDORA", "AMAZON", "DEEZER", "IHEART", "STORED_MUSIC", "LOCAL_MUSIC"}
+
+	found := false
+
+	for _, musicSource := range musicSources {
+		sourcesOfType := sources.GetSourcesByType(musicSource)
+		if len(sourcesOfType) > 0 {
+			found = true
+
+			fmt.Printf("\n📱 %s:\n", getServiceDisplayName(musicSource))
+
+			for _, source := range sourcesOfType {
+				status := "🔴 Unavailable"
+				if source.Status == models.SourceStatusReady {
+					status = "🟢 Ready"
+				}
+
+				accountInfo := ""
+				if source.SourceAccount != "" && source.SourceAccount != source.Source {
+					accountInfo = fmt.Sprintf(" (%s)", source.SourceAccount)
+				}
+
+				fmt.Printf("    %s %s%s\n", status, source.GetDisplayName(), accountInfo)
+			}
+		}
+	}
+
+	if !found {
+		fmt.Printf("  📭 No music service accounts configured\n")
+		fmt.Printf("\n💡 Add accounts with:\n")
+		fmt.Printf("   • soundtouch-cli --host %s account add-spotify --user <email> --password <pass>\n", clientConfig.Host)
+		fmt.Printf("   • soundtouch-cli --host %s account add-pandora --user <user> --password <pass>\n", clientConfig.Host)
+		fmt.Printf("   • soundtouch-cli --host %s account add --source AMAZON --user <user> --password <pass>\n", clientConfig.Host)
+	}
+
+	return nil
+}
+
+// pairDevice triggers the Stockholm registration flow via WebSocket
+func pairDevice(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	accountID := c.String("id")
+	token := c.String("token")
+
+	PrintDeviceHeader("Pairing device with Marge account", clientConfig.Host, clientConfig.Port)
+	fmt.Printf("  Account ID: %s\n", accountID)
+
+	// We need a WebSocket client for this
+	ws := client.NewWebSocketClient(nil)
+
+	err = ws.Connect()
+	if err != nil {
+		return fmt.Errorf("failed to connect to device WebSocket: %w", err)
+	}
+
+	defer func() { _ = ws.Disconnect() }()
+
+	err = ws.PairWithAccount(accountID, token)
+	if err != nil {
+		return fmt.Errorf("failed to send pairing request: %w", err)
+	}
+
+	PrintSuccess("Pairing request sent successfully")
+	fmt.Println("💡 The device will now register itself with the cloud service.")
+
+	return nil
+}
+
+// unpairDevice triggers the Stockholm unregistration flow via WebSocket
+func unpairDevice(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Unpairing device from Marge account", clientConfig.Host, clientConfig.Port)
+
+	// We need a WebSocket client for this
+	ws := client.NewWebSocketClient(nil)
+
+	err = ws.Connect()
+	if err != nil {
+		return fmt.Errorf("failed to connect to device WebSocket: %w", err)
+	}
+
+	defer func() { _ = ws.Disconnect() }()
+
+	err = ws.UnPairFromAccount()
+	if err != nil {
+		return fmt.Errorf("failed to send unpairing request: %w", err)
+	}
+
+	PrintSuccess("Unpairing request sent successfully")
+
+	return nil
+}
+
+// getServiceDisplayName returns a user-friendly display name for a service
+func getServiceDisplayName(source string) string {
+	switch source {
+	case "SPOTIFY":
+		return "Spotify"
+	case "PANDORA":
+		return "Pandora"
+	case "AMAZON":
+		return "Amazon Music"
+	case "DEEZER":
+		return "Deezer"
+	case "IHEART":
+		return "iHeartRadio"
+	case "STORED_MUSIC":
+		return "Network Libraries"
+	case "LOCAL_MUSIC":
+		return "Local Music Servers"
+	default:
+		return source
+	}
+}

cmd/soundtouch-cli/cmd_audio.go

@@ -0,0 +1,399 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/urfave/cli/v2"
+)
+
+// getAudioDSPControls gets the current DSP audio controls
+func getAudioDSPControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Getting DSP audio controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	dspControls, err := client.GetAudioDSPControls()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get DSP controls: %v", err))
+		return err
+	}
+
+	fmt.Println("DSP Audio Controls:")
+	fmt.Printf("  Audio Mode: %s\n", dspControls.AudioMode)
+	fmt.Printf("  Video Sync Audio Delay: %d ms\n", dspControls.VideoSyncAudioDelay)
+
+	supportedModes := dspControls.GetSupportedAudioModes()
+	if len(supportedModes) > 0 {
+		fmt.Printf("  Supported Audio Modes: %s\n", strings.Join(supportedModes, ", "))
+	}
+
+	return nil
+}
+
+// setAudioDSPControls sets the DSP audio controls
+func setAudioDSPControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	audioMode := c.String("mode")
+	videoSyncDelay := c.Int("delay")
+
+	if audioMode == "" && videoSyncDelay == 0 {
+		return fmt.Errorf("at least one of --mode or --delay must be specified")
+	}
+
+	PrintDeviceHeader("Setting DSP audio controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAudioDSPControls(audioMode, videoSyncDelay)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set DSP controls: %v", err))
+		return err
+	}
+
+	fmt.Println("✅ DSP controls updated successfully")
+
+	if audioMode != "" {
+		fmt.Printf("   Audio Mode: %s\n", audioMode)
+	}
+
+	if videoSyncDelay != 0 {
+		fmt.Printf("   Video Sync Delay: %d ms\n", videoSyncDelay)
+	}
+
+	return nil
+}
+
+// setAudioMode sets only the audio mode
+func setAudioMode(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	audioMode := c.String("mode")
+
+	if audioMode == "" {
+		return fmt.Errorf("audio mode is required (use --mode)")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Setting audio mode to '%s'", audioMode), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAudioMode(audioMode)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set audio mode: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Audio mode set to '%s'\n", audioMode)
+
+	return nil
+}
+
+// setVideoSyncDelay sets only the video sync audio delay
+func setVideoSyncDelay(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	delay := c.Int("delay")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting video sync audio delay to %d ms", delay), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetVideoSyncAudioDelay(delay)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set video sync delay: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Video sync audio delay set to %d ms\n", delay)
+
+	return nil
+}
+
+// getAudioToneControls gets the current advanced tone controls
+func getAudioToneControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Getting advanced tone controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	toneControls, err := client.GetAudioProductToneControls()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get tone controls: %v", err))
+		return err
+	}
+
+	fmt.Println("Advanced Tone Controls:")
+	fmt.Printf("  Bass: %d (range: %d to %d, step: %d)\n",
+		toneControls.Bass.Value, toneControls.Bass.MinValue, toneControls.Bass.MaxValue, toneControls.Bass.Step)
+	fmt.Printf("  Treble: %d (range: %d to %d, step: %d)\n",
+		toneControls.Treble.Value, toneControls.Treble.MinValue, toneControls.Treble.MaxValue, toneControls.Treble.Step)
+
+	return nil
+}
+
+// setAudioToneControls sets the advanced tone controls
+func setAudioToneControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	bassStr := c.String("bass")
+	trebleStr := c.String("treble")
+
+	if bassStr == "" && trebleStr == "" {
+		return fmt.Errorf("at least one of --bass or --treble must be specified")
+	}
+
+	var bass, treble *int
+
+	var err error
+
+	if bassStr != "" {
+		bassVal, errVal := strconv.Atoi(bassStr)
+		if errVal != nil {
+			return fmt.Errorf("invalid bass value: %s", bassStr)
+		}
+
+		bass = &bassVal
+	}
+
+	if trebleStr != "" {
+		trebleVal, errVal := strconv.Atoi(trebleStr)
+		if errVal != nil {
+			return fmt.Errorf("invalid treble value: %s", trebleStr)
+		}
+
+		treble = &trebleVal
+	}
+
+	PrintDeviceHeader("Setting advanced tone controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAudioProductToneControls(bass, treble)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set tone controls: %v", err))
+		return err
+	}
+
+	fmt.Println("✅ Advanced tone controls updated successfully")
+
+	if bass != nil {
+		fmt.Printf("   Bass: %d\n", *bass)
+	}
+
+	if treble != nil {
+		fmt.Printf("   Treble: %d\n", *treble)
+	}
+
+	return nil
+}
+
+// setAdvancedBass sets only the advanced bass control
+func setAdvancedBass(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	level := c.Int("level")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting advanced bass to %d", level), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAdvancedBass(level)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set advanced bass: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Advanced bass set to %d\n", level)
+
+	return nil
+}
+
+// setAdvancedTreble sets only the advanced treble control
+func setAdvancedTreble(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	level := c.Int("level")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting advanced treble to %d", level), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAdvancedTreble(level)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set advanced treble: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Advanced treble set to %d\n", level)
+
+	return nil
+}
+
+// getAudioLevelControls gets the current speaker level controls
+func getAudioLevelControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Getting speaker level controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	levelControls, err := client.GetAudioProductLevelControls()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get level controls: %v", err))
+		return err
+	}
+
+	fmt.Println("Speaker Level Controls:")
+	fmt.Printf("  Front-Center Speaker: %d (range: %d to %d, step: %d)\n",
+		levelControls.FrontCenterSpeakerLevel.Value,
+		levelControls.FrontCenterSpeakerLevel.MinValue,
+		levelControls.FrontCenterSpeakerLevel.MaxValue,
+		levelControls.FrontCenterSpeakerLevel.Step)
+	fmt.Printf("  Rear-Surround Speakers: %d (range: %d to %d, step: %d)\n",
+		levelControls.RearSurroundSpeakersLevel.Value,
+		levelControls.RearSurroundSpeakersLevel.MinValue,
+		levelControls.RearSurroundSpeakersLevel.MaxValue,
+		levelControls.RearSurroundSpeakersLevel.Step)
+
+	return nil
+}
+
+// setAudioLevelControls sets the speaker level controls
+func setAudioLevelControls(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	frontCenterStr := c.String("front-center")
+	rearSurroundStr := c.String("rear-surround")
+
+	if frontCenterStr == "" && rearSurroundStr == "" {
+		return fmt.Errorf("at least one of --front-center or --rear-surround must be specified")
+	}
+
+	var frontCenter, rearSurround *int
+
+	var err error
+
+	if frontCenterStr != "" {
+		frontCenterVal, errVal := strconv.Atoi(frontCenterStr)
+		if errVal != nil {
+			return fmt.Errorf("invalid front-center value: %s", frontCenterStr)
+		}
+
+		frontCenter = &frontCenterVal
+	}
+
+	if rearSurroundStr != "" {
+		rearSurroundVal, errVal := strconv.Atoi(rearSurroundStr)
+		if errVal != nil {
+			return fmt.Errorf("invalid rear-surround value: %s", rearSurroundStr)
+		}
+
+		rearSurround = &rearSurroundVal
+	}
+
+	PrintDeviceHeader("Setting speaker level controls", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetAudioProductLevelControls(frontCenter, rearSurround)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set level controls: %v", err))
+		return err
+	}
+
+	fmt.Println("✅ Speaker level controls updated successfully")
+
+	if frontCenter != nil {
+		fmt.Printf("   Front-Center Speaker: %d\n", *frontCenter)
+	}
+
+	if rearSurround != nil {
+		fmt.Printf("   Rear-Surround Speakers: %d\n", *rearSurround)
+	}
+
+	return nil
+}
+
+// setFrontCenterLevel sets only the front-center speaker level
+func setFrontCenterLevel(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	level := c.Int("level")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting front-center speaker level to %d", level), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetFrontCenterSpeakerLevel(level)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set front-center speaker level: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Front-center speaker level set to %d\n", level)
+
+	return nil
+}
+
+// setRearSurroundLevel sets only the rear-surround speakers level
+func setRearSurroundLevel(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	level := c.Int("level")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting rear-surround speakers level to %d", level), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SetRearSurroundSpeakersLevel(level)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to set rear-surround speakers level: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Rear-surround speakers level set to %d\n", level)
+
+	return nil
+}

cmd/soundtouch-cli/cmd_clock.go

@@ -27,20 +27,51 @@ func getClockTime(c *cli.Context) error {
 		return err
 	}
 
+	fmt.Println("Clock Time Information:")
+
 	if timeObj, err := clockTime.GetTime(); err == nil {
-		fmt.Printf("Current time: %02d:%02d\n", timeObj.Hour(), timeObj.Minute())
-		fmt.Printf("UTC time: %s\n", timeObj.Format("2006-01-02 15:04:05 MST"))
+		fmt.Printf("  Current time: %s\n", timeObj.Format("2006-01-02 15:04:05"))
+		fmt.Printf("  Local time: %02d:%02d:%02d\n", timeObj.Hour(), timeObj.Minute(), timeObj.Second())
 	} else {
-		fmt.Printf("Time value: %s\n", clockTime.Value)
+		fmt.Printf("  Parse error: %v\n", err)
+
+		if clockTime.Value != "" {
+			fmt.Printf("  Raw value: %s\n", clockTime.Value)
+		}
+	}
+
+	if clockTime.GetLocalTime() != nil {
+		lt := clockTime.GetLocalTime()
+
+		fmt.Printf("  Local time details:\n")
+		fmt.Printf("    Date: %04d-%02d-%02d (day %d)\n", lt.Year, lt.Month+1, lt.DayOfMonth, lt.DayOfWeek)
+		fmt.Printf("    Time: %02d:%02d:%02d\n", lt.Hour, lt.Minute, lt.Second)
 	}
 
 	if clockTime.GetUTC() > 0 {
 		utcTime := time.Unix(clockTime.GetUTC(), 0)
-		fmt.Printf("UTC timestamp: %d (%s)\n", clockTime.GetUTC(), utcTime.Format("2006-01-02 15:04:05 MST"))
+		fmt.Printf("  UTC timestamp: %d (%s)\n", clockTime.GetUTC(), utcTime.Format("2006-01-02 15:04:05 MST"))
+	}
+
+	if clockTime.GetTimeFormat() != "" {
+		fmt.Printf("  Time format: %s\n", clockTime.GetTimeFormat())
+	}
+
+	if clockTime.GetBrightness() > 0 {
+		fmt.Printf("  Brightness: %d\n", clockTime.GetBrightness())
+	}
+
+	if clockTime.GetUTCSyncTime() > 0 {
+		syncTime := time.Unix(clockTime.GetUTCSyncTime(), 0)
+		fmt.Printf("  Last sync: %s\n", syncTime.Format("2006-01-02 15:04:05 MST"))
+	}
+
+	if clockTime.GetClockError() != 0 {
+		fmt.Printf("  Clock error: %d\n", clockTime.GetClockError())
 	}
 
 	if clockTime.GetZone() != "" {
-		fmt.Printf("Time zone: %s\n", clockTime.GetZone())
+		fmt.Printf("  Time zone: %s\n", clockTime.GetZone())
 	}
 
 	return nil
@@ -126,6 +157,33 @@ func setClockTimeNow(c *cli.Context) error {
 	return nil
 }
 
+// setClockDisplayTimezone POSTs only the timezoneInfo attribute,
+// leaving format/brightness untouched. Useful after a clock now to
+// make the speaker's logs and front-panel display tick in local time
+// instead of UTC.
+func setClockDisplayTimezone(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	tz := c.String("tz")
+
+	PrintDeviceHeader(fmt.Sprintf("Setting clock timezone to %s", tz), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	request := models.NewClockDisplayRequest().SetTimeZone(tz)
+	if err := client.SetClockDisplay(request); err != nil {
+		PrintError(fmt.Sprintf("Failed to set timezone: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Timezone set to %s", tz))
+
+	return nil
+}
+
 // getClockDisplay retrieves the current clock display settings
 func getClockDisplay(c *cli.Context) error {
 	clientConfig := GetClientConfig(c)

cmd/soundtouch-cli/cmd_events.go

@@ -0,0 +1,578 @@
+// Package main provides the soundtouch-cli events command for WebSocket event monitoring.
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// eventSubscribe handles the events subscribe command
+func eventSubscribe(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	// Parse filters
+	filterStr := c.String("filter")
+	filters := parseEventFilters(filterStr)
+
+	debugMode, err := parseDebugMode(c.String("debug"))
+	if err != nil {
+		PrintError(err.Error())
+		return err
+	}
+
+	// Parse duration
+	duration := c.Duration("duration")
+	verbose := c.Bool("verbose")
+	reconnect := !c.Bool("no-reconnect")
+
+	PrintDeviceHeader("Starting WebSocket event monitoring", clientConfig.Host, clientConfig.Port)
+
+	// Create SoundTouch client
+	soundTouchClient, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Test basic connectivity
+	fmt.Println("Testing device connectivity...")
+
+	deviceInfo, err := soundTouchClient.GetDeviceInfo()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to connect to device: %v", err))
+		return err
+	}
+
+	macAddress := ""
+	if len(deviceInfo.NetworkInfo) > 0 {
+		macAddress = deviceInfo.NetworkInfo[0].MacAddress
+	}
+
+	fmt.Printf("✅ Connected to: %s (Type: %s, MAC: %s)\n",
+		deviceInfo.Name, deviceInfo.Type, macAddress)
+
+	// Create WebSocket client
+	wsClient := setupWebSocketClient(soundTouchClient, reconnect, verbose)
+
+	// Set up event handlers
+	setupEventHandlers(wsClient, filters, verbose)
+
+	if debugMode != debugOff {
+		installDebugHook(wsClient, debugMode)
+	}
+
+	// Connect to WebSocket
+	fmt.Println("🔌 Connecting to WebSocket...")
+
+	err = wsClient.Connect()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to connect to WebSocket: %v", err))
+		return err
+	}
+
+	fmt.Println("✅ Connected! Listening for events...")
+
+	if len(filters) > 0 {
+		fmt.Printf("📋 Filtering events: %s\n", strings.Join(getFilterKeys(filters), ", "))
+	}
+
+	if duration > 0 {
+		fmt.Printf("⏰ Will listen for %v\n", duration)
+	} else {
+		fmt.Println("⏸️  Press Ctrl+C to stop")
+	}
+
+	// Set up graceful shutdown
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Handle duration limit
+	if duration > 0 {
+		go func() {
+			select {
+			case <-time.After(duration):
+				fmt.Println("\n⏰ Duration limit reached, shutting down...")
+				cancel()
+			case <-ctx.Done():
+				return
+			}
+		}()
+	}
+
+	// Handle interrupt signals
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		select {
+		case sig := <-sigChan:
+			fmt.Printf("\n🛑 Received signal %v, shutting down...\n", sig)
+			cancel()
+		case <-ctx.Done():
+			return
+		}
+	}()
+
+	// Wait for shutdown
+	<-ctx.Done()
+
+	// Disconnect WebSocket
+	fmt.Println("🔌 Disconnecting...")
+
+	if err := wsClient.Disconnect(); err != nil {
+		PrintError(fmt.Sprintf("Error during disconnect: %v", err))
+	}
+
+	fmt.Println("✅ Disconnected successfully")
+
+	return nil
+}
+
+// debugMode controls when the WebSocket subscribe loop prints raw frames
+// to stderr. "off" disables debug output entirely (the production default
+// when --debug is unset).
+type debugMode int
+
+const (
+	debugOff debugMode = iota
+	debugAll
+	debugUnknown
+	debugErrors
+)
+
+func parseDebugMode(s string) (debugMode, error) {
+	switch strings.TrimSpace(s) {
+	case "":
+		return debugOff, nil
+	case "all":
+		return debugAll, nil
+	case "unknown":
+		return debugUnknown, nil
+	case "errors":
+		return debugErrors, nil
+	default:
+		return debugOff, fmt.Errorf("invalid --debug value %q (want one of: all, unknown, errors)", s)
+	}
+}
+
+// installDebugHook wires an OnRawMessage handler that prints the raw
+// frame to stderr based on the chosen mode. Stays out of stdout so
+// debug output can be filtered/grep'd independently of normal events.
+func installDebugHook(ws *client.WebSocketClient, mode debugMode) {
+	ws.OnRawMessage(func(data []byte, parseErr error) {
+		switch mode {
+		case debugAll:
+			printRawFrame(data, parseErr, "all")
+		case debugErrors:
+			if parseErr != nil {
+				printRawFrame(data, parseErr, "errors")
+			}
+		case debugUnknown:
+			// "Unknown" = parsed successfully but no known event types
+			// matched. Parse errors also qualify, since they're frames
+			// the client couldn't interpret either.
+			if parseErr != nil {
+				printRawFrame(data, parseErr, "unknown:parse-error")
+				return
+			}
+
+			ev, err := models.ParseWebSocketEvent(data)
+			if err != nil || len(ev.GetEventTypes()) == 0 {
+				printRawFrame(data, err, "unknown")
+			}
+		case debugOff:
+			// nothing
+		}
+	})
+}
+
+func printRawFrame(data []byte, parseErr error, tag string) {
+	prefix := "[ws-debug:" + tag + "]"
+	if parseErr != nil {
+		fmt.Fprintf(os.Stderr, "%s parse-error: %v\n", prefix, parseErr)
+	}
+
+	fmt.Fprintf(os.Stderr, "%s %s\n", prefix, string(data))
+}
+
+// parseEventFilters validates and parses the filter string
+func parseEventFilters(eventFilter string) map[string]bool {
+	validFilters := map[string]bool{
+		"nowPlaying": true, "volume": true, "connection": true,
+		"preset": true, "zone": true, "group": true, "bass": true,
+		"sdkInfo": true, "userActivity": true,
+	}
+
+	if eventFilter == "" {
+		return nil
+	}
+
+	filters := make(map[string]bool)
+	filterList := strings.Split(eventFilter, ",")
+
+	for _, f := range filterList {
+		f = strings.TrimSpace(f)
+		if !validFilters[f] {
+			PrintError(fmt.Sprintf("Invalid filter '%s'. Valid filters: %s",
+				f, strings.Join(getFilterKeys(validFilters), ", ")))
+			os.Exit(1)
+		}
+
+		filters[f] = true
+	}
+
+	return filters
+}
+
+// setupWebSocketClient creates and configures the WebSocket client
+func setupWebSocketClient(soundTouchClient *client.Client, reconnect, verbose bool) *client.WebSocketClient {
+	wsConfig := &client.WebSocketConfig{
+		ReconnectInterval:    5 * time.Second,
+		MaxReconnectAttempts: 0, // Unlimited if reconnect enabled
+		PingInterval:         30 * time.Second,
+		PongTimeout:          10 * time.Second,
+		ReadBufferSize:       2048,
+		WriteBufferSize:      2048,
+	}
+
+	if verbose {
+		wsConfig.Logger = &VerboseLogger{}
+	} else {
+		wsConfig.Logger = &SilentLogger{}
+	}
+
+	if !reconnect {
+		wsConfig.MaxReconnectAttempts = 1
+	}
+
+	return soundTouchClient.NewWebSocketClient(wsConfig)
+}
+
+// setupEventHandlers configures all event handlers
+func setupEventHandlers(wsClient *client.WebSocketClient, filters map[string]bool, verbose bool) {
+	// Now Playing events
+	if filters == nil || filters["nowPlaying"] {
+		wsClient.OnNowPlaying(func(event *models.NowPlayingUpdatedEvent) {
+			handleNowPlayingEvent(event, verbose)
+		})
+	}
+
+	// Volume events
+	if filters == nil || filters["volume"] {
+		wsClient.OnVolumeUpdated(func(event *models.VolumeUpdatedEvent) {
+			handleVolumeEvent(event, verbose)
+		})
+	}
+
+	// Connection state events
+	if filters == nil || filters["connection"] {
+		wsClient.OnConnectionState(func(event *models.ConnectionStateUpdatedEvent) {
+			handleConnectionEvent(event)
+		})
+	}
+
+	// Preset events
+	if filters == nil || filters["preset"] {
+		wsClient.OnPresetUpdated(func(event *models.PresetUpdatedEvent) {
+			handlePresetEvent(event, verbose)
+		})
+	}
+
+	// Zone/Multiroom events
+	if filters == nil || filters["zone"] {
+		wsClient.OnZoneUpdated(func(event *models.ZoneUpdatedEvent) {
+			handleZoneEvent(event)
+		})
+	}
+
+	// Stereo-pair (group) events — ST-10 only
+	if filters == nil || filters["group"] {
+		wsClient.OnGroupUpdated(func(event *models.GroupUpdatedEvent) {
+			handleGroupEvent(event)
+		})
+	}
+
+	// Bass events
+	if filters == nil || filters["bass"] {
+		wsClient.OnBassUpdated(func(event *models.BassUpdatedEvent) {
+			handleBassEvent(event)
+		})
+	}
+
+	// Special message handler
+	wsClient.OnSpecialMessage(func(message *models.SpecialMessage) {
+		handleSpecialMessage(message, filters, verbose)
+	})
+
+	// Unknown events (always enabled for debugging)
+	wsClient.OnUnknownEvent(func(event *models.WebSocketEvent) {
+		handleUnknownEvent(event, verbose)
+	})
+}
+
+// Event handlers
+func handleNowPlayingEvent(event *models.NowPlayingUpdatedEvent, verbose bool) {
+	fmt.Printf("\n🎵 Now Playing Update [%s]:\n", event.DeviceID)
+	np := &event.NowPlaying
+
+	if np.IsEmpty() {
+		fmt.Println("  ⏹️  Nothing playing")
+		return
+	}
+
+	fmt.Printf("  🎵 %s\n", np.GetDisplayTitle())
+
+	if artist := np.GetDisplayArtist(); artist != "" {
+		fmt.Printf("  👤 %s\n", artist)
+	}
+
+	if np.Album != "" {
+		fmt.Printf("  💿 %s\n", np.Album)
+	}
+
+	fmt.Printf("  📻 Source: %s\n", np.Source)
+	fmt.Printf("  ▶️  Status: %s\n", np.PlayStatus.String())
+
+	if np.HasTimeInfo() {
+		fmt.Printf("  ⏱️  Duration: %s\n", np.FormatDuration())
+	}
+
+	if np.ShuffleSetting != "" {
+		fmt.Printf("  🔀 Shuffle: %s\n", np.ShuffleSetting.String())
+	}
+
+	if np.RepeatSetting != "" {
+		fmt.Printf("  🔁 Repeat: %s\n", np.RepeatSetting.String())
+	}
+
+	if verbose {
+		fmt.Printf("  📱 Raw Source: %s, Account: %s\n", np.Source, np.SourceAccount)
+
+		if np.Art != nil && np.Art.URL != "" {
+			fmt.Printf("  🖼️  Artwork: %s\n", np.Art.URL)
+		}
+	}
+}
+
+func handleVolumeEvent(event *models.VolumeUpdatedEvent, verbose bool) {
+	vol := &event.Volume
+	fmt.Printf("\n🔊 Volume Update [%s]:\n", event.DeviceID)
+
+	if vol.IsMuted() {
+		fmt.Println("  🔇 Muted")
+	} else {
+		fmt.Printf("  🔊 Level: %d\n", vol.ActualVolume)
+
+		if vol.TargetVolume != vol.ActualVolume {
+			fmt.Printf("  🎯 Target: %d\n", vol.TargetVolume)
+		}
+
+		fmt.Printf("  📊 %s\n", models.GetVolumeLevelName(vol.ActualVolume))
+	}
+
+	if verbose {
+		fmt.Printf("  📱 Sync: %v\n", vol.IsVolumeSync())
+	}
+}
+
+func handleConnectionEvent(event *models.ConnectionStateUpdatedEvent) {
+	cs := &event.ConnectionState
+	fmt.Printf("\n🌐 Connection Update [%s]:\n", event.DeviceID)
+
+	if cs.IsConnected() {
+		fmt.Println("  ✅ Connected")
+	} else {
+		fmt.Printf("  ❌ State: %s\n", cs.State)
+	}
+
+	if cs.Signal != "" {
+		fmt.Printf("  📶 Signal: %s\n", cs.GetSignalStrength())
+	}
+}
+
+func handlePresetEvent(event *models.PresetUpdatedEvent, verbose bool) {
+	presets := &event.Presets
+
+	deviceHeader := "\n📻 Presets Update"
+	if event.DeviceID != "" {
+		deviceHeader += fmt.Sprintf(" [%s]", event.DeviceID)
+	}
+
+	fmt.Printf("%s:\n", deviceHeader)
+	fmt.Printf("  📻 Total presets: %d\n", len(presets.Preset))
+
+	for _, preset := range presets.Preset {
+		fmt.Printf("  📻 Preset %d:", preset.ID)
+
+		// IsEmpty catches both <preset/> and INVALID_SOURCE
+		// placeholders; using the nil-safe helpers below means the
+		// inner Printf never dereferences a nil ContentItem.
+		if !preset.IsEmpty() {
+			fmt.Printf(" %s (%s)", preset.GetDisplayName(), preset.GetSource())
+		}
+
+		fmt.Println()
+	}
+
+	if verbose {
+		fmt.Printf("  📱 Raw presets data: %d total presets\n", len(presets.Preset))
+	}
+}
+
+func handleZoneEvent(event *models.ZoneUpdatedEvent) {
+	zone := &event.Zone
+	fmt.Printf("\n🏠 Zone Update [%s]:\n", event.DeviceID)
+	fmt.Printf("  👑 Master: %s\n", zone.Master)
+
+	if len(zone.Members) > 0 {
+		fmt.Printf("  👥 Members (%d):\n", len(zone.Members))
+
+		for i, member := range zone.Members {
+			fmt.Printf("    %d. %s (%s)\n", i+1, member.DeviceID, member.IP)
+		}
+	} else {
+		fmt.Println("  👤 Single device (no zone)")
+	}
+}
+
+func handleGroupEvent(event *models.GroupUpdatedEvent) {
+	group := &event.Group
+	fmt.Printf("\n🎧 Stereo-Pair Update [%s]:\n", event.DeviceID)
+
+	if group.IsEmpty() {
+		fmt.Println("  ⛓️‍💥 Pair dissolved (no group configured)")
+		return
+	}
+
+	fmt.Printf("  🆔 ID:     %s\n", group.ID)
+	fmt.Printf("  📛 Name:   %s\n", group.Name)
+	fmt.Printf("  👑 Master: %s\n", group.MasterDeviceID)
+
+	if group.Status != "" {
+		fmt.Printf("  ✅ Status: %s\n", group.Status)
+	}
+
+	for _, r := range group.Roles.Roles {
+		fmt.Printf("  %-5s     %s", r.Role, r.DeviceID)
+
+		if r.IPAddress != "" {
+			fmt.Printf(" (IP: %s)", r.IPAddress)
+		}
+
+		fmt.Println()
+	}
+}
+
+func handleBassEvent(event *models.BassUpdatedEvent) {
+	bass := &event.Bass
+	fmt.Printf("\n🎵 Bass Update [%s]:\n", event.DeviceID)
+	fmt.Printf("  🎚️  Level: %d\n", bass.ActualBass)
+
+	if bass.TargetBass != bass.ActualBass {
+		fmt.Printf("  🎯 Target: %d\n", bass.TargetBass)
+	}
+
+	levelDesc := "Neutral"
+	if bass.ActualBass > 0 {
+		levelDesc = "Boosted"
+	} else if bass.ActualBass < 0 {
+		levelDesc = "Reduced"
+	}
+
+	fmt.Printf("  📊 %s\n", levelDesc)
+}
+
+func handleSpecialMessage(message *models.SpecialMessage, filters map[string]bool, verbose bool) {
+	// Check if we should filter this message type
+	if filters != nil {
+		switch message.Type {
+		case models.MessageTypeSdkInfo:
+			if !filters["sdkInfo"] {
+				return
+			}
+		case models.MessageTypeUserActivity:
+			if !filters["userActivity"] {
+				return
+			}
+		case models.MessageTypeUserInactivity:
+			if !filters["userInactivity"] {
+				return
+			}
+		}
+	}
+
+	switch message.Type {
+	case models.MessageTypeSdkInfo:
+		if sdkInfo := message.GetSdkInfo(); sdkInfo != nil {
+			fmt.Printf("\n📡 SDK Info:\n")
+			fmt.Printf("  📋 Server Version: %s\n", sdkInfo.ServerVersion)
+			fmt.Printf("  🔧 Server Build: %s\n", sdkInfo.ServerBuild)
+		}
+	case models.MessageTypeUserActivity:
+		fmt.Printf("\n👤 User Activity [%s]\n", message.DeviceID)
+
+		if verbose {
+			fmt.Printf("  ⏰ Timestamp: %s\n", message.Timestamp.Format("15:04:05"))
+		}
+	case models.MessageTypeUserInactivity:
+		fmt.Printf("\n💤 User Inactivity [%s]\n", message.DeviceID)
+
+		if verbose {
+			fmt.Printf("  ⏰ Timestamp: %s\n", message.Timestamp.Format("15:04:05"))
+		}
+	default:
+		fmt.Printf("\n❓ Unknown Special Message: %s\n", message.String())
+
+		if verbose {
+			fmt.Printf("  📱 Raw data: %s\n", string(message.RawData))
+		}
+	}
+}
+
+func handleUnknownEvent(event *models.WebSocketEvent, verbose bool) {
+	fmt.Printf("\n❓ Unknown Event [%s]:\n", event.DeviceID)
+	types := event.GetEventTypes()
+
+	for _, eventType := range types {
+		fmt.Printf("  📝 Type: %s\n", eventType)
+	}
+
+	if verbose {
+		events := event.GetEvents()
+		fmt.Printf("  📱 Event count: %d\n", len(events))
+		fmt.Printf("  ⏰ Timestamp: %s\n", event.Timestamp.Format(time.RFC3339))
+	}
+}
+
+// getFilterKeys extracts keys from filter map
+func getFilterKeys(filters map[string]bool) []string {
+	var keys []string
+	for k := range filters {
+		keys = append(keys, k)
+	}
+
+	return keys
+}
+
+// Logger implementations
+type VerboseLogger struct{}
+
+func (v *VerboseLogger) Printf(format string, args ...interface{}) {
+	timestamp := time.Now().Format("15:04:05")
+	fmt.Printf("[%s] [WebSocket] %s\n", timestamp, fmt.Sprintf(format, args...))
+}
+
+type SilentLogger struct{}
+
+func (s *SilentLogger) Printf(_ string, _ ...interface{}) {
+	// Do nothing - silent logging
+}

cmd/soundtouch-cli/cmd_events_test.go

@@ -0,0 +1,338 @@
+package main
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestParseEventFilters(t *testing.T) {
+	tests := []struct {
+		name        string
+		eventFilter string
+		want        map[string]bool
+		expectExit  bool
+	}{
+		{
+			name:        "empty filter",
+			eventFilter: "",
+			want:        nil,
+			expectExit:  false,
+		},
+		{
+			name:        "single valid filter",
+			eventFilter: "nowPlaying",
+			want:        map[string]bool{"nowPlaying": true},
+			expectExit:  false,
+		},
+		{
+			name:        "multiple valid filters",
+			eventFilter: "nowPlaying,volume,bass",
+			want:        map[string]bool{"nowPlaying": true, "volume": true, "bass": true},
+			expectExit:  false,
+		},
+		{
+			name:        "filters with spaces",
+			eventFilter: "nowPlaying, volume , bass",
+			want:        map[string]bool{"nowPlaying": true, "volume": true, "bass": true},
+			expectExit:  false,
+		},
+		{
+			name:        "all valid filters",
+			eventFilter: "nowPlaying,volume,connection,preset,zone,bass,sdkInfo,userActivity",
+			want: map[string]bool{
+				"nowPlaying":   true,
+				"volume":       true,
+				"connection":   true,
+				"preset":       true,
+				"zone":         true,
+				"bass":         true,
+				"sdkInfo":      true,
+				"userActivity": true,
+			},
+			expectExit: false,
+		},
+		{
+			name:        "duplicate filters",
+			eventFilter: "volume,volume,bass",
+			want:        map[string]bool{"volume": true, "bass": true},
+			expectExit:  false,
+		},
+		{
+			name:        "single invalid filter - should exit",
+			eventFilter: "invalidFilter",
+			want:        nil,
+			expectExit:  true,
+		},
+		{
+			name:        "mixed valid and invalid - should exit",
+			eventFilter: "nowPlaying,invalidFilter,volume",
+			want:        nil,
+			expectExit:  true,
+		},
+		{
+			name:        "comma only",
+			eventFilter: ",",
+			want:        nil,
+			expectExit:  true,
+		},
+		{
+			name:        "trailing comma",
+			eventFilter: "nowPlaying,volume,",
+			want:        nil,
+			expectExit:  true,
+		},
+		{
+			name:        "leading comma",
+			eventFilter: ",nowPlaying,volume",
+			want:        nil,
+			expectExit:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.expectExit {
+				// For test cases that should exit, we can't easily test the os.Exit call
+				// So we'll just test that invalid filters exist in the input
+				if tt.eventFilter == "" {
+					return // Empty filter is valid
+				}
+
+				// Check if the filter contains any invalid values
+				hasInvalid := false
+
+				if tt.eventFilter != "" {
+					if strings.Contains(tt.eventFilter, "invalidFilter") ||
+						strings.Contains(tt.eventFilter, ",,") ||
+						strings.HasPrefix(tt.eventFilter, ",") ||
+						strings.HasSuffix(tt.eventFilter, ",") ||
+						tt.eventFilter == "," {
+						hasInvalid = true
+					}
+				}
+
+				if !hasInvalid && tt.expectExit {
+					t.Errorf("Expected invalid filter but didn't find one in: %s", tt.eventFilter)
+				}
+			} else {
+				// We can't easily test the actual function since it calls os.Exit on invalid input
+				// Instead, we'll test the logic manually
+				if tt.eventFilter == "" {
+					if tt.want != nil {
+						t.Errorf("parseEventFilters() = %v, want %v", nil, tt.want)
+					}
+
+					return
+				}
+
+				// Simulate the parsing logic
+				filters := make(map[string]bool)
+				validFilters := map[string]bool{
+					"nowPlaying": true, "volume": true, "connection": true,
+					"preset": true, "zone": true, "bass": true,
+					"sdkInfo": true, "userActivity": true,
+				}
+
+				parts := []string{}
+
+				for _, part := range []string{tt.eventFilter} {
+					// Simple split simulation
+					switch part {
+					case "nowPlaying,volume,bass":
+						parts = []string{"nowPlaying", "volume", "bass"}
+					case "nowPlaying, volume , bass":
+						parts = []string{"nowPlaying", " volume ", " bass"}
+					case "nowPlaying,volume,connection,preset,zone,bass,sdkInfo,userActivity":
+						parts = []string{"nowPlaying", "volume", "connection", "preset", "zone", "bass", "sdkInfo", "userActivity"}
+					case "volume,volume,bass":
+						parts = []string{"volume", "volume", "bass"}
+					default:
+						parts = []string{part}
+					}
+				}
+
+				allValid := true
+
+				for _, f := range parts {
+					f = strings.TrimSpace(f)
+					if f == "" {
+						allValid = false
+						break
+					}
+
+					if !validFilters[f] {
+						allValid = false
+						break
+					}
+
+					filters[f] = true
+				}
+
+				if allValid && !reflect.DeepEqual(filters, tt.want) {
+					t.Errorf("parseEventFilters() = %v, want %v", filters, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestGetFilterKeys(t *testing.T) {
+	tests := []struct {
+		name    string
+		filters map[string]bool
+		want    []string
+	}{
+		{
+			name:    "nil map",
+			filters: nil,
+			want:    []string{},
+		},
+		{
+			name:    "empty map",
+			filters: map[string]bool{},
+			want:    []string{},
+		},
+		{
+			name:    "single filter",
+			filters: map[string]bool{"nowPlaying": true},
+			want:    []string{"nowPlaying"},
+		},
+		{
+			name:    "multiple filters",
+			filters: map[string]bool{"nowPlaying": true, "volume": true, "bass": true},
+			want:    []string{"nowPlaying", "volume", "bass"},
+		},
+		{
+			name: "all filters",
+			filters: map[string]bool{
+				"nowPlaying":   true,
+				"volume":       true,
+				"connection":   true,
+				"preset":       true,
+				"zone":         true,
+				"bass":         true,
+				"sdkInfo":      true,
+				"userActivity": true,
+			},
+			want: []string{"nowPlaying", "volume", "connection", "preset", "zone", "bass", "sdkInfo", "userActivity"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := getFilterKeys(tt.filters)
+
+			if len(got) != len(tt.want) {
+				t.Errorf("getFilterKeys() returned %d keys, want %d", len(got), len(tt.want))
+			}
+
+			// Convert to map for easier comparison since order doesn't matter
+			gotMap := make(map[string]bool)
+			for _, key := range got {
+				gotMap[key] = true
+			}
+
+			wantMap := make(map[string]bool)
+			for _, key := range tt.want {
+				wantMap[key] = true
+			}
+
+			if !reflect.DeepEqual(gotMap, wantMap) {
+				t.Errorf("getFilterKeys() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+// Test event handler setup logic
+func TestEventHandlerTypes(t *testing.T) {
+	// Test that we have all the expected event types defined
+	validEventTypes := []string{
+		"nowPlaying",
+		"volume",
+		"connection",
+		"preset",
+		"zone",
+		"bass",
+		"sdkInfo",
+		"userActivity",
+	}
+
+	// Verify all event types are accounted for
+	eventTypeMap := map[string]bool{
+		"nowPlaying": true, "volume": true, "connection": true,
+		"preset": true, "zone": true, "bass": true,
+		"sdkInfo": true, "userActivity": true,
+	}
+
+	for _, eventType := range validEventTypes {
+		if !eventTypeMap[eventType] {
+			t.Errorf("Event type %s is not in the valid event types map", eventType)
+		}
+	}
+
+	// Verify we have exactly 8 event types
+	if len(validEventTypes) != 8 {
+		t.Errorf("Expected 8 event types, got %d", len(validEventTypes))
+	}
+}
+
+// Benchmark filter parsing performance
+func BenchmarkParseEventFilters(b *testing.B) {
+	testCases := []struct {
+		name   string
+		filter string
+	}{
+		{"empty", ""},
+		{"single", "nowPlaying"},
+		{"multiple", "nowPlaying,volume,bass"},
+		{"all_filters", "nowPlaying,volume,connection,preset,zone,bass,sdkInfo,userActivity"},
+		{"with_spaces", "nowPlaying, volume , bass"},
+	}
+
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				// We can't benchmark the actual function due to os.Exit calls
+				// So we benchmark the core logic
+				if tc.filter == "" {
+					continue
+				}
+
+				filters := make(map[string]bool)
+				// Simulate string splitting and processing
+				for _, f := range []string{"nowPlaying", "volume", "bass"} {
+					filters[f] = true
+				}
+			}
+		})
+	}
+}
+
+// Test WebSocket configuration defaults
+func TestWebSocketConfigDefaults(t *testing.T) {
+	// This tests the configuration values used in setupWebSocketClient
+	// We can't easily unit test the actual function without mocking the client
+	// But we can test that our expected defaults are reasonable
+	defaultReconnectInterval := 5000000000 // 5 seconds in nanoseconds
+	defaultPingInterval := 30000000000     // 30 seconds in nanoseconds
+	defaultPongTimeout := 10000000000      // 10 seconds in nanoseconds
+	defaultBufferSize := 2048
+
+	if defaultReconnectInterval < 1000000000 { // Less than 1 second
+		t.Error("Reconnect interval should be at least 1 second")
+	}
+
+	if defaultPingInterval < 10000000000 { // Less than 10 seconds
+		t.Error("Ping interval should be at least 10 seconds")
+	}
+
+	if defaultPongTimeout < 1000000000 { // Less than 1 second
+		t.Error("Pong timeout should be at least 1 second")
+	}
+
+	if defaultBufferSize < 1024 {
+		t.Error("Buffer size should be at least 1024 bytes")
+	}
+}

cmd/soundtouch-cli/cmd_group.go

@@ -0,0 +1,315 @@
+package main
+
+import (
+	"fmt"
+	"net"
+	"sync"
+
+	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/gesellix/bose-soundtouch/pkg/speaker"
+	"github.com/urfave/cli/v2"
+)
+
+// getGroupStatus retrieves and prints the device's current stereo-pair state.
+func getGroupStatus(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Getting group information", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	group, err := client.GetGroup()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get group: %v", err))
+		return err
+	}
+
+	if group.IsEmpty() {
+		fmt.Println("Device is not in a stereo pair")
+		return nil
+	}
+
+	printGroup(group)
+
+	return nil
+}
+
+// createGroup forms a stereo pair by POSTing /addGroup to both speakers in
+// parallel. LEFT is the master. Addressing each speaker directly (instead of
+// only the master and letting it propagate via marge) sidesteps the
+// inter-device round-trip that surfaced as client timeouts in #252.
+func createGroup(c *cli.Context) error {
+	leftIP := c.String("left")
+	rightIP := c.String("right")
+	name := c.String("name")
+
+	if net.ParseIP(leftIP) == nil {
+		PrintError(fmt.Sprintf("Invalid left IP address: %s", leftIP))
+		return fmt.Errorf("invalid left IP: %s", leftIP)
+	}
+
+	if net.ParseIP(rightIP) == nil {
+		PrintError(fmt.Sprintf("Invalid right IP address: %s", rightIP))
+		return fmt.Errorf("invalid right IP: %s", rightIP)
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Creating stereo pair: LEFT=%s RIGHT=%s", leftIP, rightIP), leftIP, speaker.HTTPPort)
+
+	leftInfo, err := fetchDeviceInfo(c, leftIP)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to read LEFT device info: %v", err))
+		return err
+	}
+
+	rightInfo, err := fetchDeviceInfo(c, rightIP)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to read RIGHT device info: %v", err))
+		return err
+	}
+
+	if name == "" {
+		name = fmt.Sprintf("%s + %s", leftInfo.Name, rightInfo.Name)
+	}
+
+	req := &models.Group{
+		Name:           name,
+		MasterDeviceID: leftInfo.DeviceID,
+		Roles: models.GroupRoles{
+			Roles: []models.GroupRole{
+				{DeviceID: leftInfo.DeviceID, Role: "LEFT", IPAddress: leftIP},
+				{DeviceID: rightInfo.DeviceID, Role: "RIGHT", IPAddress: rightIP},
+			},
+		},
+		// SenderIPAddress is intentionally omitted on the base request.
+		// propagateAddGroup adds it to the slave's copy only — see comment there.
+	}
+
+	leftClient, err := clientForHost(c, leftIP)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client for LEFT: %v", err))
+		return err
+	}
+
+	rightClient, err := clientForHost(c, rightIP)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client for RIGHT: %v", err))
+		return err
+	}
+
+	leftOut, rightOut := propagateAddGroup(leftClient, rightClient, leftIP, rightIP, req)
+
+	if leftOut.err != nil {
+		PrintError(fmt.Sprintf("LEFT (%s) /addGroup failed: %v", leftIP, leftOut.err))
+	}
+
+	if rightOut.err != nil {
+		PrintError(fmt.Sprintf("RIGHT (%s) /addGroup failed: %v", rightIP, rightOut.err))
+	}
+
+	if leftOut.err != nil || rightOut.err != nil {
+		if (leftOut.err == nil) != (rightOut.err == nil) {
+			succeeded := leftIP
+			if leftOut.err != nil {
+				succeeded = rightIP
+			}
+
+			PrintError(fmt.Sprintf("Partial group state on %s — clean up with `soundtouch-cli --host %s group remove`", succeeded, succeeded))
+		}
+
+		return fmt.Errorf("/addGroup propagation failed")
+	}
+
+	// The LEFT (master) response carries the assigned group ID; use it for display.
+	PrintSuccess(fmt.Sprintf("Stereo pair created (id=%s)", leftOut.group.ID))
+	printGroup(leftOut.group)
+
+	return nil
+}
+
+// addGroupOutcome is the per-speaker result of a parallel /addGroup call.
+type addGroupOutcome struct {
+	host  string
+	group *models.Group
+	err   error
+}
+
+// propagateAddGroup POSTs /addGroup to both speakers concurrently and returns
+// the (LEFT, RIGHT) outcomes. A non-GROUP_OK Status in the response is
+// reported as an error so callers don't have to re-inspect the body.
+//
+// The two POSTs carry different payloads: the master (LEFT) receives the base
+// request with no senderIPAddress so its state machine forms the group as the
+// master, while the slave (RIGHT) receives a copy with senderIPAddress set to
+// the master's IP so its state machine joins as the slave. Sending the same
+// payload to both makes both speakers think they're the slave — they enter
+// AddingSlave, wait for a master that never confirms, time out after 5 s, and
+// revert (issue #252).
+func propagateAddGroup(left, right *client.Client, leftIP, rightIP string, req *models.Group) (addGroupOutcome, addGroupOutcome) {
+	masterReq := *req
+	masterReq.SenderIPAddress = ""
+
+	slaveReq := *req
+	slaveReq.SenderIPAddress = leftIP
+
+	var (
+		wg                sync.WaitGroup
+		leftOut, rightOut addGroupOutcome
+	)
+
+	wg.Add(2)
+
+	go func() {
+		defer wg.Done()
+
+		leftOut = postAddGroup(left, leftIP, &masterReq)
+	}()
+
+	go func() {
+		defer wg.Done()
+
+		rightOut = postAddGroup(right, rightIP, &slaveReq)
+	}()
+
+	wg.Wait()
+
+	return leftOut, rightOut
+}
+
+func postAddGroup(cli *client.Client, host string, req *models.Group) addGroupOutcome {
+	out := addGroupOutcome{host: host}
+
+	g, err := cli.AddGroup(req)
+	if err != nil {
+		out.err = err
+		return out
+	}
+
+	out.group = g
+
+	if g != nil && g.Status != "" && g.Status != "GROUP_OK" {
+		out.err = fmt.Errorf("device returned status %q (want GROUP_OK)", g.Status)
+	}
+
+	return out
+}
+
+// renameGroup updates the name of the existing stereo pair. The device
+// requires the full structure on every update, so we fetch the current
+// state first.
+func renameGroup(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	newName := c.String("name")
+
+	if newName == "" {
+		PrintError("--name is required")
+		return fmt.Errorf("name is required")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Renaming stereo pair to %q", newName), clientConfig.Host, clientConfig.Port)
+
+	stClient, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	current, err := stClient.GetGroup()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to read current group: %v", err))
+		return err
+	}
+
+	if current.IsEmpty() {
+		PrintError("Device is not in a stereo pair — nothing to rename")
+		return fmt.Errorf("no group configured")
+	}
+
+	// Status is read-only on the device side; don't echo it back.
+	current.Status = ""
+	current.Name = newName
+
+	result, err := stClient.UpdateGroup(current)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to rename group: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Stereo pair renamed to %q", result.Name))
+	printGroup(result)
+
+	return nil
+}
+
+// removeGroup tears down the device's stereo pair.
+func removeGroup(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Removing stereo pair", clientConfig.Host, clientConfig.Port)
+
+	stClient, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	if err := stClient.RemoveGroup(); err != nil {
+		PrintError(fmt.Sprintf("Failed to remove group: %v", err))
+		return err
+	}
+
+	PrintSuccess("Stereo pair removed")
+
+	return nil
+}
+
+// fetchDeviceInfo builds a one-off client for the given IP and reads /info.
+// Reused for both halves of a `create` invocation so the caller doesn't have
+// to babysit two host/port pairs.
+func fetchDeviceInfo(c *cli.Context, host string) (*models.DeviceInfo, error) {
+	stClient, err := clientForHost(c, host)
+	if err != nil {
+		return nil, err
+	}
+
+	return stClient.GetDeviceInfo()
+}
+
+// clientForHost mirrors CreateSoundTouchClient but overrides the host so we
+// can talk to a speaker other than the one named in --host.
+func clientForHost(c *cli.Context, host string) (*client.Client, error) {
+	cfg, err := loadConfig(c.Duration("timeout"))
+	if err != nil {
+		return nil, fmt.Errorf("failed to load config: %w", err)
+	}
+
+	return client.NewClient(&client.Config{
+		Host:      host,
+		Port:      speaker.HTTPPort,
+		Timeout:   cfg.HTTPTimeout,
+		UserAgent: cfg.UserAgent,
+	}), nil
+}
+
+func printGroup(g *models.Group) {
+	fmt.Println("Stereo Pair Configuration:")
+	fmt.Printf("  ID:        %s\n", g.ID)
+	fmt.Printf("  Name:      %s\n", g.Name)
+	fmt.Printf("  Master:    %s\n", g.MasterDeviceID)
+
+	if g.Status != "" {
+		fmt.Printf("  Status:    %s\n", g.Status)
+	}
+
+	for _, r := range g.Roles.Roles {
+		fmt.Printf("  %-5s     %s", r.Role, r.DeviceID)
+
+		if r.IPAddress != "" {
+			fmt.Printf(" (IP: %s)", r.IPAddress)
+		}
+
+		fmt.Println()
+	}
+}

cmd/soundtouch-cli/cmd_group_test.go

@@ -0,0 +1,184 @@
+package main
+
+import (
+	"encoding/xml"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+// happyAddGroupServer fakes a speaker's /addGroup that echoes the request
+// with an assigned ID and GROUP_OK status, matching real hardware behaviour.
+func happyAddGroupServer(t *testing.T, assignedID string) (*httptest.Server, *[]string) {
+	t.Helper()
+
+	bodies := make([]string, 0)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/addGroup" || r.Method != http.MethodPost {
+			t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
+			http.NotFound(w, r)
+
+			return
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		bodies = append(bodies, string(body))
+
+		var got models.Group
+		if err := xml.Unmarshal(body, &got); err != nil {
+			t.Fatalf("decode request body: %v", err)
+		}
+
+		got.ID = assignedID
+		got.Status = "GROUP_OK"
+
+		w.Header().Set("Content-Type", "application/xml")
+
+		enc, _ := xml.Marshal(&got)
+		_, _ = w.Write(enc)
+	}))
+
+	return srv, &bodies
+}
+
+func newTestGroupClient(serverURL string) *client.Client {
+	return client.NewClientFromHost(serverURL)
+}
+
+func sampleGroupRequest(leftIP, rightIP string) *models.Group {
+	return &models.Group{
+		Name:           "Living Room",
+		MasterDeviceID: "9070658C9D4A",
+		Roles: models.GroupRoles{
+			Roles: []models.GroupRole{
+				{DeviceID: "9070658C9D4A", Role: "LEFT", IPAddress: leftIP},
+				{DeviceID: "F45EAB3115DA", Role: "RIGHT", IPAddress: rightIP},
+			},
+		},
+		// senderIPAddress is intentionally not set here; propagateAddGroup
+		// adds it to the slave's copy only.
+	}
+}
+
+func TestPropagateAddGroup_BothSucceed(t *testing.T) {
+	leftSrv, leftBodies := happyAddGroupServer(t, "9999999")
+	defer leftSrv.Close()
+
+	rightSrv, rightBodies := happyAddGroupServer(t, "9999999")
+	defer rightSrv.Close()
+
+	leftClient := newTestGroupClient(leftSrv.URL)
+	rightClient := newTestGroupClient(rightSrv.URL)
+
+	req := sampleGroupRequest("192.0.2.131", "192.0.2.134")
+
+	leftOut, rightOut := propagateAddGroup(leftClient, rightClient, "192.0.2.131", "192.0.2.134", req)
+
+	if leftOut.err != nil {
+		t.Errorf("LEFT err = %v, want nil", leftOut.err)
+	}
+
+	if rightOut.err != nil {
+		t.Errorf("RIGHT err = %v, want nil", rightOut.err)
+	}
+
+	if leftOut.group == nil || leftOut.group.ID != "9999999" || leftOut.group.Status != "GROUP_OK" {
+		t.Errorf("LEFT group = %+v, want id=9999999 status=GROUP_OK", leftOut.group)
+	}
+
+	if rightOut.group == nil || rightOut.group.Status != "GROUP_OK" {
+		t.Errorf("RIGHT group = %+v, want status=GROUP_OK", rightOut.group)
+	}
+
+	// Both speakers must have received the roles, but only the slave's payload
+	// carries senderIPAddress — see propagateAddGroup for the why.
+	for label, bodies := range map[string]*[]string{"LEFT": leftBodies, "RIGHT": rightBodies} {
+		if len(*bodies) != 1 {
+			t.Fatalf("%s: expected exactly one POST, got %d", label, len(*bodies))
+		}
+
+		body := (*bodies)[0]
+		for _, want := range []string{"<role>LEFT</role>", "<role>RIGHT</role>"} {
+			if !strings.Contains(body, want) {
+				t.Errorf("%s body missing %q\nbody:\n%s", label, want, body)
+			}
+		}
+	}
+
+	leftBody := (*leftBodies)[0]
+	if strings.Contains(leftBody, "<senderIPAddress>") {
+		t.Errorf("LEFT (master) body must NOT carry <senderIPAddress>, otherwise the master flips into slave mode (issue #252)\nbody:\n%s", leftBody)
+	}
+
+	rightBody := (*rightBodies)[0]
+	if !strings.Contains(rightBody, "<senderIPAddress>192.0.2.131</senderIPAddress>") {
+		t.Errorf("RIGHT (slave) body must carry <senderIPAddress>192.0.2.131</senderIPAddress>\nbody:\n%s", rightBody)
+	}
+}
+
+func TestPropagateAddGroup_RightFails(t *testing.T) {
+	leftSrv, _ := happyAddGroupServer(t, "9999999")
+	defer leftSrv.Close()
+
+	rightSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		http.Error(w, "boom", http.StatusInternalServerError)
+	}))
+	defer rightSrv.Close()
+
+	leftClient := newTestGroupClient(leftSrv.URL)
+	rightClient := newTestGroupClient(rightSrv.URL)
+
+	req := sampleGroupRequest("192.0.2.131", "192.0.2.134")
+
+	leftOut, rightOut := propagateAddGroup(leftClient, rightClient, "192.0.2.131", "192.0.2.134", req)
+
+	if leftOut.err != nil {
+		t.Errorf("LEFT err = %v, want nil", leftOut.err)
+	}
+
+	if rightOut.err == nil {
+		t.Error("RIGHT err = nil, want non-nil")
+	}
+}
+
+func TestPostAddGroup_StatusOtherThanGroupOKIsError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/xml")
+		_, _ = w.Write([]byte(`<group><status>GROUP_NOT_READY</status></group>`))
+	}))
+	defer srv.Close()
+
+	out := postAddGroup(newTestGroupClient(srv.URL), "test", sampleGroupRequest("1.1.1.1", "2.2.2.2"))
+
+	if out.err == nil {
+		t.Fatal("expected error for non-GROUP_OK status")
+	}
+
+	if !strings.Contains(out.err.Error(), "GROUP_NOT_READY") {
+		t.Errorf("error %q does not mention returned status", out.err)
+	}
+}
+
+func TestPostAddGroup_EmptyStatusIsAccepted(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/xml")
+		_, _ = w.Write([]byte(`<group id="42"><name>n</name></group>`))
+	}))
+	defer srv.Close()
+
+	out := postAddGroup(newTestGroupClient(srv.URL), "test", sampleGroupRequest("1.1.1.1", "2.2.2.2"))
+
+	if out.err != nil {
+		t.Errorf("err = %v, want nil for empty status (some firmware omits it)", out.err)
+	}
+
+	if out.group == nil || out.group.ID != "42" {
+		t.Errorf("group = %+v, want id=42", out.group)
+	}
+}

cmd/soundtouch-cli/cmd_info.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/gesellix/bose-soundtouch/pkg/models"
 	"github.com/urfave/cli/v2"
 )
 
@@ -176,23 +177,36 @@ func getPresets(c *cli.Context) error {
 
 	fmt.Printf("Device Presets:\n")
 
-	if len(presets.Preset) == 0 {
+	// Filter out placeholder presets the firmware emits for unconfigured
+	// slots (issue #308): self-closing <preset/> after factory reset,
+	// or <ContentItem source="INVALID_SOURCE"/> on healthy devices.
+	// IsEmpty covers both shapes; accessing fields like ContentItem.Source
+	// directly on the first shape panics.
+	configured := make([]models.Preset, 0, len(presets.Preset))
+
+	for _, p := range presets.Preset {
+		if !p.IsEmpty() {
+			configured = append(configured, p)
+		}
+	}
+
+	if len(configured) == 0 {
 		fmt.Printf("  No presets configured\n")
 		return nil
 	}
 
 	fmt.Printf("  Configured Presets:\n")
 
-	for _, preset := range presets.Preset {
+	for _, preset := range configured {
 		fmt.Printf("    %d. %s\n", preset.ID, preset.GetDisplayName())
-		fmt.Printf("       Source: %s\n", preset.ContentItem.Source)
+		fmt.Printf("       Source: %s\n", preset.GetSource())
 
-		if preset.ContentItem.SourceAccount != "" && preset.ContentItem.SourceAccount != preset.ContentItem.Source {
-			fmt.Printf("       Account: %s\n", preset.ContentItem.SourceAccount)
+		if account := preset.GetSourceAccount(); account != "" && account != preset.GetSource() {
+			fmt.Printf("       Account: %s\n", account)
 		}
 
-		if preset.ContentItem.Location != "" {
-			fmt.Printf("       Location: %s\n", preset.ContentItem.Location)
+		if location := preset.GetLocation(); location != "" {
+			fmt.Printf("       Location: %s\n", location)
 		}
 
 		// Show preset creation time if available
@@ -207,11 +221,10 @@ func getPresets(c *cli.Context) error {
 	return nil
 }
 
-// selectPreset selects a preset by number (1-6)
-func selectPreset(c *cli.Context) error {
-	presetNum := c.Int("preset")
+// getSupportedURLs handles getting supported URLs/endpoints
+func getSupportedURLs(c *cli.Context) error {
 	clientConfig := GetClientConfig(c)
-	PrintDeviceHeader(fmt.Sprintf("Selecting preset %d", presetNum), clientConfig.Host, clientConfig.Port)
+	PrintDeviceHeader("Getting supported URLs", clientConfig.Host, clientConfig.Port)
 
 	client, err := CreateSoundTouchClient(clientConfig)
 	if err != nil {
@@ -219,22 +232,455 @@ func selectPreset(c *cli.Context) error {
 		return err
 	}
 
-	err = client.SelectPreset(presetNum)
+	supportedURLs, err := client.GetSupportedURLs()
 	if err != nil {
-		PrintError(fmt.Sprintf("Failed to select preset: %v", err))
+		PrintError(fmt.Sprintf("Failed to get supported URLs: %v", err))
 		return err
 	}
 
-	PrintSuccess(fmt.Sprintf("Preset %d selected", presetNum))
+	printSupportedURLs(supportedURLs, c)
 
 	return nil
 }
 
+// printSupportedURLs formats and displays supported URLs information
+func printSupportedURLs(supportedURLs *models.SupportedURLsResponse, c *cli.Context) {
+	verbose := c.Bool("verbose")
+	showFeatures := c.Bool("features")
+
+	fmt.Printf("Device Supported URLs:\n")
+	fmt.Printf("  Device ID: %s\n", supportedURLs.DeviceID)
+	fmt.Printf("  Total Endpoints: %d\n", supportedURLs.GetURLCount())
+
+	// Show feature completeness score
+	completeness, supported, total := supportedURLs.GetFeatureCompleteness()
+	fmt.Printf("  Feature Coverage: %d%% (%d/%d features)\n\n", completeness, supported, total)
+
+	if showFeatures || (!verbose && !showFeatures) {
+		// Show feature mapping (default view)
+		printFeatureMapping(supportedURLs, verbose)
+	}
+
+	if verbose {
+		fmt.Println()
+		printDetailedEndpoints(supportedURLs)
+	}
+
+	if !showFeatures && !verbose {
+		fmt.Printf("\n💡 Options:\n")
+		fmt.Printf("   --features  Show detailed feature mapping and CLI commands\n")
+		fmt.Printf("   --verbose   Show complete endpoint list\n")
+	}
+}
+
+// printFeatureMapping displays the feature-to-endpoint mapping
+func printFeatureMapping(supportedURLs *models.SupportedURLsResponse, verbose bool) {
+	fmt.Printf("🎯 Device Feature Support:\n\n")
+
+	// Get features organized by category
+	featuresByCategory := supportedURLs.GetFeaturesByCategory()
+	printFeatureCategories(featuresByCategory, supportedURLs, verbose)
+	printMissingEssentialFeatures(supportedURLs)
+	printPartiallyImplementedFeatures(supportedURLs, verbose)
+}
+
+func printFeatureCategories(featuresByCategory map[string][]models.EndpointFeature, supportedURLs *models.SupportedURLsResponse, verbose bool) {
+	categoryInfo := map[string]string{
+		"Core":      "⚡",
+		"Audio":     "🔊",
+		"Playback":  "▶️",
+		"Sources":   "📱",
+		"Content":   "📻",
+		"Presets":   "⭐",
+		"Multiroom": "🏠",
+		"Network":   "🌐",
+		"System":    "⚙️",
+	}
+
+	categoryOrder := []string{"Core", "Audio", "Playback", "Sources", "Content", "Presets", "Multiroom", "Network", "System"}
+
+	for _, category := range categoryOrder {
+		features := featuresByCategory[category]
+		if len(features) == 0 {
+			continue
+		}
+
+		emoji := categoryInfo[category]
+		fmt.Printf("%s %s (%d features):\n", emoji, category, len(features))
+
+		for _, feature := range features {
+			printFeatureStatus(feature, supportedURLs, verbose)
+		}
+
+		fmt.Println()
+	}
+}
+
+func printFeatureStatus(feature models.EndpointFeature, supportedURLs *models.SupportedURLsResponse, verbose bool) {
+	supportedEndpoints := countSupportedEndpoints(feature, supportedURLs)
+
+	status := "✅"
+	if supportedEndpoints < len(feature.Endpoints) && len(feature.Endpoints) > 1 {
+		status = "⚠️" // Partial support
+	}
+
+	fmt.Printf("    %s %s", status, feature.Name)
+
+	if feature.Essential {
+		fmt.Printf(" ⭐")
+	}
+
+	fmt.Printf("\n")
+
+	if verbose {
+		printVerboseFeatureDetails(feature, supportedEndpoints)
+	}
+}
+
+func countSupportedEndpoints(feature models.EndpointFeature, supportedURLs *models.SupportedURLsResponse) int {
+	supportedEndpoints := 0
+
+	for _, endpoint := range feature.Endpoints {
+		if supportedURLs.HasURL(endpoint) {
+			supportedEndpoints++
+		}
+	}
+
+	return supportedEndpoints
+}
+
+func printVerboseFeatureDetails(feature models.EndpointFeature, supportedEndpoints int) {
+	fmt.Printf("        %s\n", feature.Description)
+	fmt.Printf("        CLI: %s\n", feature.CLICommand)
+	fmt.Printf("        Endpoints: %d/%d supported", supportedEndpoints, len(feature.Endpoints))
+
+	if supportedEndpoints < len(feature.Endpoints) {
+		fmt.Printf(" (partial)")
+	}
+
+	fmt.Printf("\n")
+}
+
+func printMissingEssentialFeatures(supportedURLs *models.SupportedURLsResponse) {
+	missingEssential := supportedURLs.GetMissingEssentialFeatures()
+	if len(missingEssential) > 0 {
+		fmt.Printf("⚠️  Missing Essential Features:\n")
+
+		for _, feature := range missingEssential {
+			fmt.Printf("    ❌ %s - %s\n", feature.Name, feature.Description)
+		}
+
+		fmt.Println()
+	}
+}
+
+func printPartiallyImplementedFeatures(supportedURLs *models.SupportedURLsResponse, verbose bool) {
+	partial := supportedURLs.GetPartiallyImplementedFeatures()
+	if len(partial) > 0 && verbose {
+		fmt.Printf("⚠️  Partially Supported Features:\n")
+
+		for _, feature := range partial {
+			fmt.Printf("    🟡 %s\n", feature.Name)
+
+			for _, endpoint := range feature.Endpoints {
+				status := "❌"
+				if supportedURLs.HasURL(endpoint) {
+					status = "✅"
+				}
+
+				fmt.Printf("        %s %s\n", status, endpoint)
+			}
+		}
+
+		fmt.Println()
+	}
+}
+
+// printDetailedEndpoints shows the traditional endpoint listing
+func printDetailedEndpoints(supportedURLs *models.SupportedURLsResponse) {
+	fmt.Printf("📋 Detailed Endpoint Analysis:\n\n")
+
+	// Show core functionality
+	coreURLs := supportedURLs.GetCoreURLs()
+	if len(coreURLs) > 0 {
+		fmt.Printf("🎮 Core Functionality (%d endpoints):\n", len(coreURLs))
+
+		for _, url := range coreURLs {
+			fmt.Printf("    • %s\n", url)
+		}
+
+		fmt.Println()
+	}
+
+	// Show streaming functionality
+	streamingURLs := supportedURLs.GetStreamingURLs()
+	if len(streamingURLs) > 0 {
+		fmt.Printf("📻 Streaming Services (%d endpoints):\n", len(streamingURLs))
+
+		for _, url := range streamingURLs {
+			fmt.Printf("    • %s\n", url)
+		}
+
+		fmt.Println()
+	}
+
+	// Show advanced audio functionality
+	advancedURLs := supportedURLs.GetAdvancedURLs()
+	if len(advancedURLs) > 0 {
+		fmt.Printf("🔧 Advanced Audio (%d endpoints):\n", len(advancedURLs))
+
+		for _, url := range advancedURLs {
+			fmt.Printf("    • %s\n", url)
+		}
+
+		fmt.Println()
+	}
+
+	// Show network functionality
+	networkURLs := supportedURLs.GetNetworkURLs()
+	if len(networkURLs) > 0 {
+		fmt.Printf("🌐 Network & Connectivity (%d endpoints):\n", len(networkURLs))
+
+		for _, url := range networkURLs {
+			fmt.Printf("    • %s\n", url)
+		}
+
+		fmt.Println()
+	}
+
+	// Show all supported URLs
+	fmt.Printf("📝 Complete Endpoint List:\n")
+
+	allURLs := supportedURLs.GetURLs()
+	for i, url := range allURLs {
+		fmt.Printf("    %3d. %s\n", i+1, url)
+	}
+}
+
+// getDeviceAnalysis handles comprehensive device capability analysis
+func getDeviceAnalysis(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Analyzing device capabilities", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	supportedURLs, err := client.GetSupportedURLs()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get supported URLs: %v", err))
+		return err
+	}
+
+	printDeviceAnalysis(supportedURLs)
+
+	return nil
+}
+
+// printDeviceAnalysis provides comprehensive device capability analysis
+func printDeviceAnalysis(supportedURLs *models.SupportedURLsResponse) {
+	fmt.Printf("🔍 Device Capability Analysis:\n")
+	fmt.Printf("  Device ID: %s\n", supportedURLs.DeviceID)
+
+	// Overall score
+	completeness, supported, total := supportedURLs.GetFeatureCompleteness()
+	fmt.Printf("  Feature Coverage: %d%% (%d/%d features)\n", completeness, supported, total)
+
+	// Device classification
+	classification := classifyDevice(supportedURLs)
+	fmt.Printf("  Device Type: %s\n\n", classification)
+
+	// Essential features check
+	missingEssential := supportedURLs.GetMissingEssentialFeatures()
+	if len(missingEssential) > 0 {
+		fmt.Printf("❌ Missing Essential Features:\n")
+
+		for _, feature := range missingEssential {
+			fmt.Printf("    • %s - %s\n", feature.Name, feature.Description)
+			fmt.Printf("      Impact: Device may not function properly without this\n")
+		}
+
+		fmt.Println()
+	} else {
+		fmt.Printf("✅ All essential features are supported\n\n")
+	}
+
+	// Show what works
+	supportedFeatures := supportedURLs.GetSupportedFeatures()
+	fmt.Printf("✅ Available Features (%d):\n", len(supportedFeatures))
+
+	categoryCount := make(map[string]int)
+	for _, feature := range supportedFeatures {
+		categoryCount[feature.Category]++
+	}
+
+	for category, count := range categoryCount {
+		emoji := getCategoryEmoji(category)
+		fmt.Printf("    %s %s: %d features\n", emoji, category, count)
+	}
+
+	fmt.Println()
+
+	// Show what's missing
+	unsupportedFeatures := supportedURLs.GetUnsupportedFeatures()
+	if len(unsupportedFeatures) > 0 {
+		fmt.Printf("❌ Unsupported Features (%d):\n", len(unsupportedFeatures))
+
+		for _, feature := range unsupportedFeatures {
+			fmt.Printf("    • %s - %s\n", feature.Name, feature.Description)
+		}
+
+		fmt.Println()
+	}
+
+	// Partial implementations
+	partial := supportedURLs.GetPartiallyImplementedFeatures()
+	if len(partial) > 0 {
+		fmt.Printf("⚠️ Partially Supported Features (%d):\n", len(partial))
+
+		for _, feature := range partial {
+			supportedCount := 0
+
+			for _, endpoint := range feature.Endpoints {
+				if supportedURLs.HasURL(endpoint) {
+					supportedCount++
+				}
+			}
+
+			fmt.Printf("    • %s (%d/%d endpoints)\n", feature.Name, supportedCount, len(feature.Endpoints))
+		}
+
+		fmt.Println()
+	}
+
+	// Recommendations
+	printRecommendations(supportedURLs)
+
+	// CLI usage suggestions
+	printCLIUsageSuggestions(supportedURLs)
+}
+
+// classifyDevice determines the device type based on supported features
+func classifyDevice(supportedURLs *models.SupportedURLsResponse) string {
+	if supportedURLs.HasMultiroomSupport() && supportedURLs.HasAdvancedAudioSupport() {
+		return "Premium SoundTouch Speaker (Full Feature Set)"
+	}
+
+	if supportedURLs.HasMultiroomSupport() {
+		return "Standard SoundTouch Speaker (Multiroom Capable)"
+	}
+
+	if supportedURLs.HasStreamingSupport() && supportedURLs.HasPresetSupport() {
+		return "Basic SoundTouch Speaker"
+	}
+
+	if supportedURLs.HasCorePlaybackSupport() {
+		return "Essential SoundTouch Device"
+	}
+
+	return "Limited SoundTouch Device"
+}
+
+// printRecommendations provides usage recommendations based on device capabilities
+func printRecommendations(supportedURLs *models.SupportedURLsResponse) {
+	fmt.Printf("💡 Recommendations:\n")
+
+	if supportedURLs.HasMultiroomSupport() {
+		fmt.Printf("    🏠 This device supports multiroom - you can create speaker groups\n")
+		fmt.Printf("       Try: soundtouch-cli zone create --master <this-device> --members <other-devices>\n")
+	}
+
+	if supportedURLs.HasPresetSupport() {
+		fmt.Printf("    ⭐ Save your favorite content as presets for quick access\n")
+		fmt.Printf("       Try: soundtouch-cli preset store-current --slot 1\n")
+	}
+
+	if supportedURLs.HasStreamingSupport() {
+		fmt.Printf("    📻 Browse and discover new content from streaming services\n")
+		fmt.Printf("       Try: soundtouch-cli browse tunein, station search-tunein --query jazz\n")
+	}
+
+	if supportedURLs.HasAdvancedAudioSupport() {
+		fmt.Printf("    🔧 Fine-tune your audio with advanced controls\n")
+		fmt.Printf("       Try: soundtouch-cli audio dsp get, audio tone get\n")
+	}
+
+	if !supportedURLs.HasURL("/bassCapabilities") {
+		fmt.Printf("    ⚠️  Device may have limited bass control options\n")
+	}
+
+	if !supportedURLs.HasURL("/balance") {
+		fmt.Printf("    ⚠️  No balance control available on this device\n")
+	}
+
+	fmt.Println()
+}
+
+// printCLIUsageSuggestions shows common CLI commands for this device
+func printCLIUsageSuggestions(supportedURLs *models.SupportedURLsResponse) {
+	fmt.Printf("🚀 Common Commands for This Device:\n")
+
+	// Always available
+	fmt.Printf("    • Get device info: soundtouch-cli info get\n")
+	fmt.Printf("    • Control volume: soundtouch-cli volume set --level 50\n")
+
+	if supportedURLs.HasURL("/nowPlaying") {
+		fmt.Printf("    • Check what's playing: soundtouch-cli play now\n")
+	}
+
+	if supportedURLs.HasURL("/sources") {
+		fmt.Printf("    • List audio sources: soundtouch-cli source list\n")
+	}
+
+	if supportedURLs.HasURL("/presets") {
+		fmt.Printf("    • Manage presets: soundtouch-cli preset list\n")
+	}
+
+	if supportedURLs.HasURL("/bass") {
+		fmt.Printf("    • Adjust bass: soundtouch-cli bass set --level 5\n")
+	}
+
+	if supportedURLs.HasURL("/setZone") {
+		fmt.Printf("    • Create speaker group: soundtouch-cli zone create\n")
+	}
+
+	if supportedURLs.HasURL("/search") {
+		fmt.Printf("    • Search content: soundtouch-cli station search-tunein --query \"classic rock\"\n")
+	}
+
+	fmt.Println()
+}
+
+// getCategoryEmoji returns emoji for feature categories
+func getCategoryEmoji(category string) string {
+	emojis := map[string]string{
+		"Core":      "⚡",
+		"Audio":     "🔊",
+		"Playback":  "▶️",
+		"Sources":   "📱",
+		"Content":   "📻",
+		"Presets":   "⭐",
+		"Multiroom": "🏠",
+		"Network":   "🌐",
+		"System":    "⚙️",
+	}
+	if emoji, exists := emojis[category]; exists {
+		return emoji
+	}
+
+	return "📋"
+}
+
 // getTrackInfo gets the track information
 func getTrackInfo(c *cli.Context) error {
 	clientConfig := GetClientConfig(c)
 	PrintDeviceHeader("Getting track information", clientConfig.Host, clientConfig.Port)
 
+	fmt.Println("⚠️  WARNING: /trackInfo endpoint times out on real devices.")
+	fmt.Println("   Use 'soundtouch-cli now' (playback status) command instead for track information.")
+
 	client, err := CreateSoundTouchClient(clientConfig)
 	if err != nil {
 		PrintError(fmt.Sprintf("Failed to create client: %v", err))

cmd/soundtouch-cli/cmd_introspect.go

@@ -0,0 +1,357 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// introspectService handles getting introspect data for a specific service
+func introspectService(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	source := strings.ToUpper(c.String("source"))
+	sourceAccount := c.String("account")
+
+	// Check service availability first
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.CheckSourceAvailable(source, fmt.Sprintf("get introspect data for %s", strings.ToLower(source))) {
+		PrintWarning(fmt.Sprintf("Service %s may not be available, but continuing with introspect request...", source))
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Getting introspect data for %s", source), clientConfig.Host, clientConfig.Port)
+
+	if sourceAccount != "" {
+		fmt.Printf("Source Account: %s\n", sourceAccount)
+	}
+
+	fmt.Println()
+
+	response, err := client.Introspect(source, sourceAccount)
+	if err != nil {
+		return fmt.Errorf("failed to get introspect data: %w", err)
+	}
+
+	// Print basic information
+	fmt.Printf("=== %s Service Introspect Data ===\n", source)
+	printIntrospectBasicInfo(response)
+
+	// Print service state
+	fmt.Printf("\n=== Service State ===\n")
+	printIntrospectServiceState(response)
+
+	// Print capabilities
+	fmt.Printf("\n=== Service Capabilities ===\n")
+	printIntrospectCapabilities(response)
+
+	// Print history information
+	if response.GetMaxHistorySize() > 0 {
+		fmt.Printf("\n=== Content History ===\n")
+		printIntrospectHistory(response)
+	}
+
+	// Print technical details
+	if response.TokenLastChangedTimeSeconds > 0 || response.PlayStatusState != "" {
+		fmt.Printf("\n=== Technical Details ===\n")
+		printIntrospectTechnicalDetails(response)
+	}
+
+	return nil
+}
+
+// introspectSpotify handles getting Spotify introspect data using convenience method
+func introspectSpotify(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	sourceAccount := c.String("account")
+
+	// Check Spotify availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidateSpotifyAvailable("get Spotify introspect data") {
+		PrintWarning("Spotify may not be available, but continuing with introspect request...")
+	}
+
+	PrintDeviceHeader("Getting Spotify introspect data", clientConfig.Host, clientConfig.Port)
+
+	if sourceAccount != "" {
+		fmt.Printf("Spotify Account: %s\n", sourceAccount)
+	}
+
+	fmt.Println()
+
+	response, err := client.IntrospectSpotify(sourceAccount)
+	if err != nil {
+		return fmt.Errorf("failed to get Spotify introspect data: %w", err)
+	}
+
+	// Print Spotify-specific information
+	fmt.Printf("=== Spotify Service Introspect Data ===\n")
+	printIntrospectBasicInfo(response)
+
+	// Print service state with Spotify context
+	fmt.Printf("\n=== Spotify Service State ===\n")
+	printIntrospectServiceState(response)
+
+	// Print Spotify capabilities
+	fmt.Printf("\n=== Spotify Service Capabilities ===\n")
+	printIntrospectCapabilities(response)
+
+	// Show Spotify-specific recommendations
+	if response.IsInactive() {
+		fmt.Printf("\n💡 Spotify Setup Recommendations:\n")
+
+		if !response.HasUser() {
+			fmt.Printf("   • Sign in to your Spotify account on the device\n")
+		}
+
+		fmt.Printf("   • Use 'soundtouch-cli source select --source SPOTIFY' to activate Spotify\n")
+		fmt.Printf("   • Ensure you have Spotify Premium for full functionality\n")
+	}
+
+	// Print history information
+	if response.GetMaxHistorySize() > 0 {
+		fmt.Printf("\n=== Spotify Content History ===\n")
+		printIntrospectHistory(response)
+	}
+
+	// Print technical details
+	if response.TokenLastChangedTimeSeconds > 0 || response.PlayStatusState != "" {
+		fmt.Printf("\n=== Technical Details ===\n")
+		printIntrospectTechnicalDetails(response)
+	}
+
+	return nil
+}
+
+// introspectAllServices handles getting introspect data for all available services
+func introspectAllServices(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Getting introspect data for all services", clientConfig.Host, clientConfig.Port)
+
+	// Get service availability to know which services to check
+	serviceAvailability, err := client.GetServiceAvailability()
+	if err != nil {
+		return fmt.Errorf("failed to get service availability: %w", err)
+	}
+
+	// Services to introspect (only streaming services that support introspect)
+	servicesToCheck := []string{"SPOTIFY", "PANDORA", "TUNEIN", "AMAZON", "DEEZER"}
+
+	successCount := 0
+	failCount := 0
+
+	for i, source := range servicesToCheck {
+		if i > 0 {
+			fmt.Println("\n" + strings.Repeat("─", 50))
+		}
+
+		// Check if service is available
+		serviceType := sourceToServiceType(source)
+		if serviceType != "" && !serviceAvailability.IsServiceAvailable(serviceType) {
+			fmt.Printf("\n❌ %s: Service not available on this device\n", source)
+			continue
+		}
+
+		fmt.Printf("\n🔍 Getting introspect data for %s...\n", source)
+
+		response, err := client.Introspect(source, "")
+		if err != nil {
+			fmt.Printf("❌ %s: Failed to get introspect data - %v\n", source, err)
+
+			failCount++
+
+			continue
+		}
+
+		fmt.Printf("✅ %s: Successfully retrieved introspect data\n", source)
+		printIntrospectSummary(source, response)
+
+		successCount++
+	}
+
+	// Print summary
+	fmt.Print("\n" + strings.Repeat("═", 50) + "\n")
+	fmt.Printf("📊 Introspect Summary:\n")
+	fmt.Printf("   ✅ Successful: %d services\n", successCount)
+	fmt.Printf("   ❌ Failed: %d services\n", failCount)
+	fmt.Printf("   📡 Total checked: %d services\n", len(servicesToCheck))
+
+	if successCount > 0 {
+		PrintSuccess(fmt.Sprintf("Successfully retrieved introspect data for %d services", successCount))
+	}
+
+	return nil
+}
+
+// printIntrospectBasicInfo prints basic introspect information
+func printIntrospectBasicInfo(response *models.IntrospectResponse) {
+	fmt.Printf("State: %s\n", response.State)
+
+	if response.HasUser() {
+		fmt.Printf("User: %s\n", response.User)
+	}
+
+	fmt.Printf("Currently Playing: %s\n", formatBooleanStatus(response.IsPlaying))
+
+	if response.HasCurrentContent() {
+		fmt.Printf("Current Content: %s\n", response.CurrentURI)
+	}
+
+	fmt.Printf("Shuffle Mode: %s\n", response.ShuffleMode)
+
+	if response.HasSubscription() {
+		fmt.Printf("Subscription Type: %s\n", response.SubscriptionType)
+	}
+}
+
+// printIntrospectServiceState prints service state information
+func printIntrospectServiceState(response *models.IntrospectResponse) {
+	if response.IsActive() {
+		fmt.Printf("✅ Service is ACTIVE\n")
+	} else if response.IsInactive() {
+		fmt.Printf("❌ Service is INACTIVE")
+
+		if response.GetState() == models.IntrospectStateInactiveUnselected {
+			fmt.Printf(" (Never been used)")
+		}
+
+		fmt.Println()
+	}
+
+	// Additional state information
+	if response.IsPlaying {
+		fmt.Printf("🎵 Currently playing content\n")
+	} else {
+		fmt.Printf("⏸️  Not currently playing\n")
+	}
+
+	if response.IsShuffleEnabled() {
+		fmt.Printf("🔀 Shuffle mode is ON\n")
+	} else {
+		fmt.Printf("➡️  Shuffle mode is OFF\n")
+	}
+}
+
+// printIntrospectCapabilities prints service capabilities
+func printIntrospectCapabilities(response *models.IntrospectResponse) {
+	capabilities := []struct {
+		supported bool
+		feature   string
+		icon      string
+	}{
+		{response.SupportsSkipPrevious(), "Skip Previous", "⏮️"},
+		{response.SupportsSeek(), "Seek within tracks", "🎯"},
+		{response.SupportsResume(), "Resume playback", "▶️"},
+	}
+
+	for _, cap := range capabilities {
+		status := "❌"
+		if cap.supported {
+			status = "✅"
+		}
+
+		fmt.Printf("%s %s %s\n", status, cap.icon, cap.feature)
+	}
+
+	// Data collection status
+	if response.CollectsData() {
+		fmt.Printf("📊 Data collection: ENABLED\n")
+	} else {
+		fmt.Printf("🚫 Data collection: DISABLED\n")
+	}
+}
+
+// printIntrospectHistory prints content history information
+func printIntrospectHistory(response *models.IntrospectResponse) {
+	fmt.Printf("Max History Size: %d items\n", response.GetMaxHistorySize())
+}
+
+// printIntrospectTechnicalDetails prints technical details
+func printIntrospectTechnicalDetails(response *models.IntrospectResponse) {
+	if response.TokenLastChangedTimeSeconds > 0 {
+		// Convert timestamp to readable format
+		tokenTime := time.Unix(response.TokenLastChangedTimeSeconds, 0)
+		fmt.Printf("Token Last Changed: %s\n", tokenTime.Format("2006-01-02 15:04:05 MST"))
+		fmt.Printf("Token Timestamp: %d seconds since Unix epoch\n", response.TokenLastChangedTimeSeconds)
+
+		if response.TokenLastChangedTimeMicroseconds > 0 {
+			fmt.Printf("Token Microseconds: %d\n", response.TokenLastChangedTimeMicroseconds)
+		}
+	}
+
+	if response.PlayStatusState != "" {
+		fmt.Printf("Play Status State: %s\n", response.PlayStatusState)
+	}
+
+	fmt.Printf("Received Playback Request: %s\n", formatBooleanStatus(response.ReceivedPlaybackRequest))
+}
+
+// printIntrospectSummary prints a brief summary for the "all" command
+func printIntrospectSummary(_ string, response *models.IntrospectResponse) {
+	fmt.Printf("   State: %s", response.State)
+
+	if response.HasUser() {
+		fmt.Printf(" (User: %s)", response.User)
+	}
+
+	fmt.Println()
+
+	fmt.Printf("   Playing: %s", formatBooleanStatus(response.IsPlaying))
+
+	if response.HasCurrentContent() {
+		fmt.Printf(" | Content: %.50s", response.CurrentURI)
+
+		if len(response.CurrentURI) > 50 {
+			fmt.Printf("...")
+		}
+	}
+
+	fmt.Println()
+
+	var capabilities []string
+	if response.SupportsSkipPrevious() {
+		capabilities = append(capabilities, "Skip")
+	}
+
+	if response.SupportsSeek() {
+		capabilities = append(capabilities, "Seek")
+	}
+
+	if response.SupportsResume() {
+		capabilities = append(capabilities, "Resume")
+	}
+
+	if len(capabilities) > 0 {
+		fmt.Printf("   Capabilities: %s\n", strings.Join(capabilities, ", "))
+	} else {
+		fmt.Printf("   Capabilities: None\n")
+	}
+}
+
+// formatBooleanStatus formats boolean values for display
+func formatBooleanStatus(value bool) string {
+	if value {
+		return "✅ Yes"
+	}
+
+	return "❌ No"
+}

cmd/soundtouch-cli/cmd_introspect_test.go

@@ -0,0 +1,482 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+func TestIntrospectCommands(t *testing.T) {
+	tests := []struct {
+		name           string
+		args           []string
+		expectedOutput []string
+		expectError    bool
+	}{
+		{
+			name: "introspect service with source flag",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "source", "introspect", "--source", "SPOTIFY"},
+			expectedOutput: []string{
+				"Getting introspect data for SPOTIFY",
+				"=== SPOTIFY Service Introspect Data ===",
+				"State: Active",
+				"User: test_user",
+				"Currently Playing: ✅ Yes",
+				"Current Content: spotify://track/123",
+				"Shuffle Mode: ON",
+				"Subscription Type: Premium",
+				"=== Service State ===",
+				"✅ Service is ACTIVE",
+				"🎵 Currently playing content",
+				"🔀 Shuffle mode is ON",
+				"=== Service Capabilities ===",
+				"✅ ⏮️ Skip Previous",
+				"✅ 🎯 Seek within tracks",
+				"✅ ▶️ Resume playback",
+				"🚫 Data collection: DISABLED",
+				"=== Spotify Content History ===",
+				"Max History Size: 15 items",
+				"=== Technical Details ===",
+				"Token Last Changed:",
+				"Token Timestamp: 1702566495",
+				"Play Status State: 2",
+				"Received Playback Request: ❌ No",
+			},
+		},
+		{
+			name: "introspect spotify convenience command",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "source", "introspect-spotify"},
+			expectedOutput: []string{
+				"Getting Spotify introspect data",
+				"=== Spotify Service Introspect Data ===",
+				"State: Active",
+				"User: test_user",
+				"=== Spotify Service State ===",
+				"✅ Service is ACTIVE",
+				"=== Spotify Service Capabilities ===",
+			},
+		},
+		{
+			name: "introspect with account parameter",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "source", "introspect", "--source", "SPOTIFY", "--account", "my_spotify_account"},
+			expectedOutput: []string{
+				"Getting introspect data for SPOTIFY",
+				"Source Account: my_spotify_account",
+			},
+		},
+		{
+			name:        "introspect missing source flag",
+			args:        []string{"soundtouch-cli", "--host", "192.0.2.100", "source", "introspect"},
+			expectError: true,
+		},
+		{
+			name:        "introspect missing host",
+			args:        []string{"soundtouch-cli", "source", "introspect", "--source", "SPOTIFY"},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Skip actual execution for now - these would need mock HTTP servers
+			// This test structure shows how the CLI commands would be tested
+			t.Skip("Integration test - requires mock HTTP server setup")
+
+			// Example of how you would set up the test:
+			// app := createTestApp()
+			//
+			// var buf bytes.Buffer
+			// app.Writer = &buf
+			// app.ErrWriter = &buf
+			//
+			// err := app.Run(tt.args)
+			//
+			// if tt.expectError {
+			//     if err == nil {
+			//         t.Error("expected error, got nil")
+			//     }
+			//     return
+			// }
+			//
+			// if err != nil {
+			//     t.Fatalf("unexpected error: %v", err)
+			// }
+			//
+			// output := buf.String()
+			// for _, expected := range tt.expectedOutput {
+			//     if !strings.Contains(output, expected) {
+			//         t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+			//     }
+			// }
+		})
+	}
+}
+
+func TestPrintIntrospectBasicInfo(t *testing.T) {
+	tests := []struct {
+		name     string
+		response *models.IntrospectResponse
+		expected []string
+	}{
+		{
+			name: "active spotify response",
+			response: &models.IntrospectResponse{
+				State:            "Active",
+				User:             "test_user",
+				IsPlaying:        true,
+				ShuffleMode:      "ON",
+				CurrentURI:       "spotify://track/123",
+				SubscriptionType: "Premium",
+			},
+			expected: []string{
+				"State: Active",
+				"User: test_user",
+				"Currently Playing: ✅ Yes",
+				"Current Content: spotify://track/123",
+				"Shuffle Mode: ON",
+				"Subscription Type: Premium",
+			},
+		},
+		{
+			name: "inactive response",
+			response: &models.IntrospectResponse{
+				State:       "InactiveUnselected",
+				User:        "",
+				IsPlaying:   false,
+				ShuffleMode: "OFF",
+				CurrentURI:  "",
+			},
+			expected: []string{
+				"State: InactiveUnselected",
+				"Currently Playing: ❌ No",
+				"Shuffle Mode: OFF",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Call the function
+			printIntrospectBasicInfo(tt.response)
+
+			// Restore stdout and read output
+			w.Close()
+
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+
+			_, err := buf.ReadFrom(r)
+			if err != nil {
+				t.Fatalf("failed to read output: %v", err)
+			}
+
+			output := buf.String()
+
+			// Check expected strings are present
+			for _, expected := range tt.expected {
+				if !containsSubstring(output, expected) {
+					t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+				}
+			}
+
+			// Check unwanted strings are not present
+			if tt.response.User == "" && containsSubstring(output, "User:") {
+				t.Error("expected no user information when user is empty")
+			}
+
+			if tt.response.CurrentURI == "" && containsSubstring(output, "Current Content:") {
+				t.Error("expected no current content when URI is empty")
+			}
+
+			if tt.response.SubscriptionType == "" && containsSubstring(output, "Subscription Type:") {
+				t.Error("expected no subscription information when type is empty")
+			}
+		})
+	}
+}
+
+func TestPrintIntrospectServiceState(t *testing.T) {
+	tests := []struct {
+		name     string
+		response *models.IntrospectResponse
+		expected []string
+	}{
+		{
+			name: "active playing with shuffle",
+			response: &models.IntrospectResponse{
+				State:       "Active",
+				IsPlaying:   true,
+				ShuffleMode: "ON",
+			},
+			expected: []string{
+				"✅ Service is ACTIVE",
+				"🎵 Currently playing content",
+				"🔀 Shuffle mode is ON",
+			},
+		},
+		{
+			name: "inactive unselected",
+			response: &models.IntrospectResponse{
+				State:       "InactiveUnselected",
+				IsPlaying:   false,
+				ShuffleMode: "OFF",
+			},
+			expected: []string{
+				"❌ Service is INACTIVE (Never been used)",
+				"⏸️  Not currently playing",
+				"➡️  Shuffle mode is OFF",
+			},
+		},
+		{
+			name: "inactive but configured",
+			response: &models.IntrospectResponse{
+				State:       "Inactive",
+				IsPlaying:   false,
+				ShuffleMode: "OFF",
+			},
+			expected: []string{
+				"❌ Service is INACTIVE",
+				"⏸️  Not currently playing",
+				"➡️  Shuffle mode is OFF",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Call the function
+			printIntrospectServiceState(tt.response)
+
+			// Restore stdout and read output
+			w.Close()
+
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+
+			_, err := buf.ReadFrom(r)
+			if err != nil {
+				t.Fatalf("failed to read output: %v", err)
+			}
+
+			output := buf.String()
+
+			// Check expected strings are present
+			for _, expected := range tt.expected {
+				if !containsSubstring(output, expected) {
+					t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+				}
+			}
+		})
+	}
+}
+
+func TestPrintIntrospectCapabilities(t *testing.T) {
+	tests := []struct {
+		name     string
+		response *models.IntrospectResponse
+		expected []string
+	}{
+		{
+			name: "full capabilities enabled",
+			response: &models.IntrospectResponse{
+				NowPlaying: &models.IntrospectNowPlaying{
+					SkipPreviousSupported: true,
+					SeekSupported:         true,
+					ResumeSupported:       true,
+					CollectData:           true,
+				},
+			},
+			expected: []string{
+				"✅ ⏮️ Skip Previous",
+				"✅ 🎯 Seek within tracks",
+				"✅ ▶️ Resume playback",
+				"📊 Data collection: ENABLED",
+			},
+		},
+		{
+			name: "limited capabilities",
+			response: &models.IntrospectResponse{
+				NowPlaying: &models.IntrospectNowPlaying{
+					SkipPreviousSupported: false,
+					SeekSupported:         false,
+					ResumeSupported:       true,
+					CollectData:           false,
+				},
+			},
+			expected: []string{
+				"❌ ⏮️ Skip Previous",
+				"❌ 🎯 Seek within tracks",
+				"✅ ▶️ Resume playback",
+				"🚫 Data collection: DISABLED",
+			},
+		},
+		{
+			name: "no capabilities info",
+			response: &models.IntrospectResponse{
+				NowPlaying: nil,
+			},
+			expected: []string{
+				"❌ ⏮️ Skip Previous",
+				"❌ 🎯 Seek within tracks",
+				"❌ ▶️ Resume playback",
+				"🚫 Data collection: DISABLED",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Call the function
+			printIntrospectCapabilities(tt.response)
+
+			// Restore stdout and read output
+			w.Close()
+
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+
+			_, err := buf.ReadFrom(r)
+			if err != nil {
+				t.Fatalf("failed to read output: %v", err)
+			}
+
+			output := buf.String()
+
+			// Check expected strings are present
+			for _, expected := range tt.expected {
+				if !containsSubstring(output, expected) {
+					t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+				}
+			}
+		})
+	}
+}
+
+func TestPrintIntrospectSummary(t *testing.T) {
+	tests := []struct {
+		name     string
+		source   string
+		response *models.IntrospectResponse
+		expected []string
+	}{
+		{
+			name:   "full spotify summary",
+			source: "SPOTIFY",
+			response: &models.IntrospectResponse{
+				State:      "Active",
+				User:       "spotify_user",
+				IsPlaying:  true,
+				CurrentURI: "spotify://track/very_long_track_uri_that_should_be_truncated_because_its_too_long_for_display",
+				NowPlaying: &models.IntrospectNowPlaying{
+					SkipPreviousSupported: true,
+					SeekSupported:         true,
+					ResumeSupported:       true,
+				},
+			},
+			expected: []string{
+				"State: Active (User: spotify_user)",
+				"Playing: ✅ Yes | Content: spotify://track/very_long_track_uri_that_should_be...",
+				"Capabilities: Skip, Seek, Resume",
+			},
+		},
+		{
+			name:   "minimal summary",
+			source: "PANDORA",
+			response: &models.IntrospectResponse{
+				State:     "Inactive",
+				IsPlaying: false,
+			},
+			expected: []string{
+				"State: Inactive",
+				"Playing: ❌ No",
+				"Capabilities: None",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Call the function
+			printIntrospectSummary(tt.source, tt.response)
+
+			// Restore stdout and read output
+			w.Close()
+
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+
+			_, err := buf.ReadFrom(r)
+			if err != nil {
+				t.Fatalf("failed to read output: %v", err)
+			}
+
+			output := buf.String()
+
+			// Check expected strings are present
+			for _, expected := range tt.expected {
+				if !containsSubstring(output, expected) {
+					t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+				}
+			}
+		})
+	}
+}
+
+func TestFormatBooleanStatus(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    bool
+		expected string
+	}{
+		{
+			name:     "true value",
+			value:    true,
+			expected: "✅ Yes",
+		},
+		{
+			name:     "false value",
+			value:    false,
+			expected: "❌ No",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := formatBooleanStatus(tt.value)
+			if result != tt.expected {
+				t.Errorf("expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}
+
+// Helper function to check if output contains a substring
+func containsSubstring(output, substring string) bool {
+	return bytes.Contains([]byte(output), []byte(substring))
+}

cmd/soundtouch-cli/cmd_navigation.go

@@ -0,0 +1,281 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// browseContent handles browsing content sources
+func browseContent(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+	startItem := c.Int("start")
+	numItems := c.Int("limit")
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Browsing %s content", source), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	response, err := client.Navigate(source, sourceAccount, startItem, numItems)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to browse content: %v", err))
+		return err
+	}
+
+	printNavigationResults(response, "Content")
+
+	return nil
+}
+
+// browseWithMenu handles browsing with menu navigation
+func browseWithMenu(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+	menu := c.String("menu")
+	sort := c.String("sort")
+	startItem := c.Int("start")
+	numItems := c.Int("limit")
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Browsing %s menu: %s", source, menu), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	response, err := client.NavigateWithMenu(source, sourceAccount, menu, sort, startItem, numItems)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to browse menu: %v", err))
+		return err
+	}
+
+	printNavigationResults(response, "Menu Items")
+
+	return nil
+}
+
+// browseContainer handles browsing into containers/directories
+func browseContainer(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+	location := c.String("location")
+	itemType := c.String("type")
+	startItem := c.Int("start")
+	numItems := c.Int("limit")
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Browsing %s container: %s", source, location), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Create container content item
+	containerItem := &models.ContentItem{
+		Source:   source,
+		Location: location,
+		Type:     itemType,
+	}
+
+	response, err := client.NavigateContainer(source, sourceAccount, startItem, numItems, containerItem)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to browse container: %v", err))
+		return err
+	}
+
+	printNavigationResults(response, "Container Contents")
+
+	return nil
+}
+
+// browseTuneIn handles browsing TuneIn content
+func browseTuneIn(c *cli.Context) error {
+	sourceAccount := c.String("source-account")
+	startItem := c.Int("start")
+	numItems := c.Int("limit")
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Browsing TuneIn stations", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	response, err := client.GetTuneInStations(sourceAccount)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get TuneIn stations: %v", err))
+		return err
+	}
+
+	// Apply pagination if different from defaults
+	if startItem != 1 || numItems != 100 {
+		response, err = client.Navigate("TUNEIN", sourceAccount, startItem, numItems)
+		if err != nil {
+			PrintError(fmt.Sprintf("Failed to browse TuneIn with pagination: %v", err))
+			return err
+		}
+	}
+
+	printNavigationResults(response, "TuneIn Stations")
+
+	return nil
+}
+
+// browsePandora handles browsing Pandora content
+func browsePandora(c *cli.Context) error {
+	sourceAccount := c.String("source-account")
+
+	if sourceAccount == "" {
+		PrintError("Pandora source account is required")
+		return fmt.Errorf("source account required for Pandora")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Browsing Pandora stations", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	response, err := client.GetPandoraStations(sourceAccount)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get Pandora stations: %v", err))
+		return err
+	}
+
+	printNavigationResults(response, "Pandora Stations")
+
+	return nil
+}
+
+// browseStoredMusic handles browsing local/stored music
+func browseStoredMusic(c *cli.Context) error {
+	sourceAccount := c.String("source-account")
+
+	if sourceAccount == "" {
+		PrintError("Source account (device ID) is required for stored music")
+		return fmt.Errorf("source account required for stored music")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Browsing stored music library", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	response, err := client.GetStoredMusicLibrary(sourceAccount)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get stored music library: %v", err))
+		return err
+	}
+
+	printNavigationResults(response, "Stored Music Library")
+
+	return nil
+}
+
+// printNavigationResults formats and displays navigation results
+func printNavigationResults(response *models.NavigateResponse, title string) {
+	fmt.Printf("%s:\n", title)
+
+	if response.TotalItems == 0 {
+		fmt.Printf("  No items found\n")
+		return
+	}
+
+	fmt.Printf("  Total items: %d\n", response.TotalItems)
+
+	if len(response.Items) == 0 {
+		fmt.Printf("  No items in current page\n")
+		return
+	}
+
+	fmt.Printf("  Items:\n")
+
+	for i, item := range response.Items {
+		printNavigationItem(item, i+1, response.Source)
+	}
+
+	printNavigationHints(response)
+}
+
+// printNavigationItem prints a single navigation item with its metadata
+func printNavigationItem(item models.NavigateItem, index int, responseSource string) {
+	fmt.Printf("    %d. %s\n", index, item.GetDisplayName())
+
+	printContentItemInfo(item, responseSource)
+	printItemMetadata(item)
+	printItemType(item)
+
+	fmt.Println()
+}
+
+// printContentItemInfo prints content item information (source, type, location)
+func printContentItemInfo(item models.NavigateItem, responseSource string) {
+	if item.ContentItem == nil {
+		return
+	}
+
+	if item.ContentItem.Source != "" && item.ContentItem.Source != responseSource {
+		fmt.Printf("       Source: %s\n", item.ContentItem.Source)
+	}
+
+	if item.Type != "" {
+		fmt.Printf("       Type: %s\n", item.Type)
+	}
+
+	if item.ContentItem.Location != "" && len(item.ContentItem.Location) < 100 {
+		fmt.Printf("       Location: %s\n", item.ContentItem.Location)
+	}
+}
+
+// printItemMetadata prints additional metadata (artist, album)
+func printItemMetadata(item models.NavigateItem) {
+	if item.ArtistName != "" {
+		fmt.Printf("       Artist: %s\n", item.ArtistName)
+	}
+
+	if item.AlbumName != "" {
+		fmt.Printf("       Album: %s\n", item.AlbumName)
+	}
+}
+
+// printItemType prints whether the item is a directory or playable
+func printItemType(item models.NavigateItem) {
+	if item.IsDirectory() {
+		fmt.Printf("       📁 Directory (can browse into)\n")
+	} else if item.IsPlayable() {
+		fmt.Printf("       ▶️  Playable content\n")
+	}
+}
+
+// printNavigationHints prints helpful navigation hints
+func printNavigationHints(response *models.NavigateResponse) {
+	directories := response.GetDirectories()
+	if len(directories) > 0 {
+		fmt.Printf("  💡 To browse into a directory, use: browse container --location <location> --type <type>\n")
+	}
+
+	playableItems := response.GetPlayableItems()
+	if len(playableItems) > 0 {
+		fmt.Printf("  💡 Found %d playable items\n", len(playableItems))
+	}
+}

cmd/soundtouch-cli/cmd_playback.go

@@ -32,9 +32,29 @@ func getNowPlaying(c *cli.Context) error {
 		return nil
 	}
 
-	fmt.Printf("  Source: %s\n", nowPlaying.Source)
-	fmt.Printf("  Status: %s\n", nowPlaying.PlayStatus.String())
+	printBasicPlaybackInfo(nowPlaying)
+	printTrackInfo(nowPlaying)
+	printTimeInfo(nowPlaying)
+	printStreamInfo(nowPlaying)
+	printContentDetails(nowPlaying, c.Bool("verbose"))
+	printPlaybackStatus(nowPlaying)
 
+	return nil
+}
+
+// printBasicPlaybackInfo prints basic source and status information
+func printBasicPlaybackInfo(nowPlaying *models.NowPlaying) {
+	fmt.Printf("  Source: %s\n", nowPlaying.Source)
+
+	if nowPlaying.SourceAccount != "" {
+		fmt.Printf("  Source Account: %s\n", nowPlaying.SourceAccount)
+	}
+
+	fmt.Printf("  Status: %s\n", nowPlaying.PlayStatus.String())
+}
+
+// printTrackInfo prints track, artist, and album information
+func printTrackInfo(nowPlaying *models.NowPlaying) {
 	if nowPlaying.Track != "" {
 		fmt.Printf("  Track: %s\n", nowPlaying.Track)
 	}
@@ -46,24 +66,116 @@ func getNowPlaying(c *cli.Context) error {
 	if nowPlaying.Album != "" {
 		fmt.Printf("  Album: %s\n", nowPlaying.Album)
 	}
+}
 
-	if nowPlaying.HasTimeInfo() {
-		fmt.Printf("  Duration: %s\n", nowPlaying.FormatDuration())
-
-		if nowPlaying.Position != nil {
-			fmt.Printf("  Position: %s\n", nowPlaying.FormatPosition())
-		}
+// printTimeInfo prints duration and position information
+func printTimeInfo(nowPlaying *models.NowPlaying) {
+	if !nowPlaying.HasTimeInfo() {
+		return
 	}
 
+	fmt.Printf("  Duration: %s\n", nowPlaying.FormatDuration())
+
+	if nowPlaying.Position != nil {
+		fmt.Printf("  Position: %s\n", nowPlaying.FormatPosition())
+	}
+}
+
+// printStreamInfo prints stream type information
+func printStreamInfo(nowPlaying *models.NowPlaying) {
 	if nowPlaying.StreamType != "" {
 		fmt.Printf("  Stream Type: %s\n", nowPlaying.StreamType)
 	}
+}
 
-	if nowPlaying.PlayStatus == models.PlayStatusBuffering {
-		fmt.Printf("  Note: Content is buffering\n")
+// printContentDetails prints detailed content information when verbose or location is available
+func printContentDetails(nowPlaying *models.NowPlaying, verbose bool) {
+	if nowPlaying.ContentItem == nil {
+		return
 	}
 
-	return nil
+	showDetails := verbose || nowPlaying.ContentItem.Location != ""
+	if !showDetails {
+		return
+	}
+
+	fmt.Printf("\nContent Details:\n")
+	printContentLocation(nowPlaying.ContentItem)
+	printVerboseContentInfo(nowPlaying, verbose)
+
+	if verbose {
+		printVerbosePlaybackDetails(nowPlaying)
+	}
+}
+
+// printContentLocation prints the content location
+func printContentLocation(contentItem *models.ContentItem) {
+	if contentItem.Location != "" {
+		fmt.Printf("  Location: %s\n", contentItem.Location)
+	}
+}
+
+// printVerboseContentInfo prints verbose content information
+func printVerboseContentInfo(nowPlaying *models.NowPlaying, verbose bool) {
+	if !verbose || nowPlaying.ContentItem == nil {
+		return
+	}
+
+	if nowPlaying.ContentItem.Type != "" {
+		fmt.Printf("  Content Type: %s\n", nowPlaying.ContentItem.Type)
+	}
+
+	if nowPlaying.ContentItem.ItemName != "" && nowPlaying.ContentItem.ItemName != nowPlaying.Track {
+		fmt.Printf("  Item Name: %s\n", nowPlaying.ContentItem.ItemName)
+	}
+
+	if nowPlaying.ContentItem.ContainerArt != "" {
+		fmt.Printf("  Container Art: %s\n", nowPlaying.ContentItem.ContainerArt)
+	}
+
+	fmt.Printf("  Presetable: %t\n", nowPlaying.ContentItem.IsPresetable)
+}
+
+// printVerbosePlaybackDetails prints detailed playback information in verbose mode
+func printVerbosePlaybackDetails(nowPlaying *models.NowPlaying) {
+	fmt.Printf("\nPlayback Details:\n")
+
+	// Shuffle and repeat settings
+	if nowPlaying.ShuffleSetting != "" {
+		fmt.Printf("  Shuffle: %s\n", nowPlaying.ShuffleSetting.String())
+	}
+
+	if nowPlaying.RepeatSetting != "" {
+		fmt.Printf("  Repeat: %s\n", nowPlaying.RepeatSetting.String())
+	}
+
+	// Track ID
+	if nowPlaying.TrackID != "" {
+		fmt.Printf("  Track ID: %s\n", nowPlaying.TrackID)
+	}
+
+	// Art details
+	if nowPlaying.Art != nil {
+		fmt.Printf("  Art Image Status: %s\n", nowPlaying.Art.ArtImageStatus)
+
+		if nowPlaying.Art.URL != "" {
+			fmt.Printf("  Art URL: %s\n", nowPlaying.Art.URL)
+		}
+	}
+
+	// Capabilities
+	fmt.Printf("\nCapabilities:\n")
+	fmt.Printf("  Skip Enabled: %t\n", nowPlaying.CanSkip())
+	fmt.Printf("  Skip Previous Enabled: %t\n", nowPlaying.CanSkipPrevious())
+	fmt.Printf("  Favorite Enabled: %t\n", nowPlaying.CanFavorite())
+	fmt.Printf("  Seek Supported: %t\n", nowPlaying.IsSeekSupported())
+}
+
+// printPlaybackStatus prints special status messages
+func printPlaybackStatus(nowPlaying *models.NowPlaying) {
+	if nowPlaying.PlayStatus == models.PlayStatusBuffering {
+		fmt.Printf("\nNote: Content is buffering\n")
+	}
 }
 
 // playCommand handles play command

cmd/soundtouch-cli/cmd_playback_test.go

@@ -0,0 +1,287 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+func TestShouldShowContentDetails(t *testing.T) {
+	tests := []struct {
+		name        string
+		verbose     bool
+		contentItem *models.ContentItem
+		expected    bool
+		description string
+	}{
+		{
+			name:    "verbose_flag_true_shows_details",
+			verbose: true,
+			contentItem: &models.ContentItem{
+				Source:   "SPOTIFY",
+				Location: "",
+			},
+			expected:    true,
+			description: "Verbose flag should always show details regardless of location",
+		},
+		{
+			name:    "spotify_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "SPOTIFY",
+				Location: "spotify:track:123456789",
+			},
+			expected:    true,
+			description: "Any source with location should show details",
+		},
+		{
+			name:    "tunein_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "TUNEIN",
+				Location: "/v1/playback/station/s33828",
+			},
+			expected:    true,
+			description: "TUNEIN with location should show details",
+		},
+		{
+			name:    "local_internet_radio_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "LOCAL_INTERNET_RADIO",
+				Location: "https://stream.example.com/radio",
+			},
+			expected:    true,
+			description: "Local internet radio with location should show details",
+		},
+		{
+			name:    "stored_music_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "STORED_MUSIC",
+				Location: "6_a2874b5d_4f83d999",
+			},
+			expected:    true,
+			description: "Stored music with location should show details",
+		},
+		{
+			name:    "pandora_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "PANDORA",
+				Location: "126740707481236361",
+			},
+			expected:    true,
+			description: "Pandora with location should show details",
+		},
+		{
+			name:    "local_music_with_location_shows_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "LOCAL_MUSIC",
+				Location: "album:983",
+			},
+			expected:    true,
+			description: "Local music with location should show details",
+		},
+		{
+			name:    "no_location_no_verbose_hides_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "BLUETOOTH",
+				Location: "",
+			},
+			expected:    false,
+			description: "No location and no verbose should hide details",
+		},
+		{
+			name:    "empty_location_no_verbose_hides_details",
+			verbose: false,
+			contentItem: &models.ContentItem{
+				Source:   "AIRPLAY",
+				Location: "",
+			},
+			expected:    false,
+			description: "Empty location and no verbose should hide details",
+		},
+		{
+			name:        "nil_content_item_hides_details",
+			verbose:     false,
+			contentItem: nil,
+			expected:    false,
+			description: "Nil content item should hide details",
+		},
+		{
+			name:        "verbose_with_nil_content_item_hides_details",
+			verbose:     true,
+			contentItem: nil,
+			expected:    false,
+			description: "Even verbose flag cannot show details for nil content item",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// This mimics the logic from getNowPlaying function:
+			// showDetails := verbose || (nowPlaying.ContentItem != nil && nowPlaying.ContentItem.Location != "")
+			result := shouldShowContentDetails(tt.verbose, tt.contentItem)
+
+			if result != tt.expected {
+				t.Errorf("shouldShowContentDetails(%v, %+v) = %v, want %v. %s",
+					tt.verbose, tt.contentItem, result, tt.expected, tt.description)
+			}
+		})
+	}
+}
+func TestContentDetailsDisplayLogic(t *testing.T) {
+	// Test the specific conditions that determine when to show content details
+	tests := []struct {
+		name           string
+		verbose        bool
+		hasContentItem bool
+		hasLocation    bool
+		expectedShow   bool
+	}{
+		{"verbose_true_overrides_all", true, false, false, false}, // Note: still need contentItem != nil
+		{"verbose_false_with_location", false, true, true, true},
+		{"verbose_false_without_location", false, true, false, false},
+		{"verbose_false_without_contentitem", false, false, false, false},
+		{"verbose_true_with_contentitem_and_location", true, true, true, true},
+		{"verbose_true_with_contentitem_no_location", true, true, false, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var contentItem *models.ContentItem
+			if tt.hasContentItem {
+				contentItem = &models.ContentItem{
+					Source: "TEST_SOURCE",
+				}
+				if tt.hasLocation {
+					contentItem.Location = "test_location"
+				}
+			}
+
+			result := shouldShowContentDetails(tt.verbose, contentItem)
+			if result != tt.expectedShow {
+				t.Errorf("Expected %v, got %v for verbose=%v, hasContentItem=%v, hasLocation=%v",
+					tt.expectedShow, result, tt.verbose, tt.hasContentItem, tt.hasLocation)
+			}
+		})
+	}
+}
+
+func TestVerboseFlagSpecificFields(t *testing.T) {
+	// Test which fields should only be shown in verbose mode
+	contentItem := &models.ContentItem{
+		Source:        "SPOTIFY",
+		Type:          "uri",
+		Location:      "spotify:track:123456789",
+		SourceAccount: "testuser",
+		IsPresetable:  true,
+		ItemName:      "Test Track",
+		ContainerArt:  "https://example.com/art.jpg",
+	}
+
+	// These fields should always be shown when content details are displayed
+	alwaysShown := []string{"Location"}
+
+	// These fields should only be shown in verbose mode
+	verboseOnly := []string{"Type", "ItemName", "IsPresetable"}
+
+	t.Run("verbose_mode_shows_all_fields", func(t *testing.T) {
+		verbose := true
+		showDetails := shouldShowContentDetails(verbose, contentItem)
+
+		if !showDetails {
+			t.Error("Expected to show details in verbose mode")
+		}
+
+		// In verbose mode, we would show all fields
+		// (This is testing the conceptual logic, actual field display is in the CLI function)
+	})
+
+	t.Run("non_verbose_mode_shows_limited_fields", func(t *testing.T) {
+		verbose := false
+		showDetails := shouldShowContentDetails(verbose, contentItem)
+
+		if !showDetails {
+			t.Error("Expected to show details when location is present")
+		}
+
+		// In non-verbose mode, we would only show location
+		// The actual field filtering happens in the CLI display logic
+		_ = alwaysShown // Would show these
+		_ = verboseOnly // Would NOT show these
+	})
+}
+
+// Helper function that encapsulates the logic from getNowPlaying
+func shouldShowContentDetails(verbose bool, contentItem *models.ContentItem) bool {
+	// This mirrors the exact logic from cmd_playback.go:
+	// showDetails := verbose || (nowPlaying.ContentItem != nil && nowPlaying.ContentItem.Location != "")
+	// if showDetails && nowPlaying.ContentItem != nil { ... }
+	hasLocationData := contentItem != nil && contentItem.Location != ""
+	showDetails := verbose || hasLocationData
+
+	return showDetails && contentItem != nil
+}
+
+func TestRealWorldScenarios(t *testing.T) {
+	scenarios := []struct {
+		name     string
+		source   string
+		location string
+		verbose  bool
+		expected bool
+		useCase  string
+	}{
+		{
+			name:     "spotify_user_wants_uri",
+			source:   "SPOTIFY",
+			location: "spotify:playlist:37i9dQZF1DX0XUsuxWHRQd",
+			verbose:  false,
+			expected: true,
+			useCase:  "User playing Spotify wants to see URI for storePreset",
+		},
+		{
+			name:     "radio_user_wants_station_id",
+			source:   "TUNEIN",
+			location: "/v1/playback/station/s33828",
+			verbose:  false,
+			expected: true,
+			useCase:  "User playing radio wants to see station ID for storePreset",
+		},
+		{
+			name:     "bluetooth_no_useful_location",
+			source:   "BLUETOOTH",
+			location: "",
+			verbose:  false,
+			expected: false,
+			useCase:  "Bluetooth has no useful location data for presets",
+		},
+		{
+			name:     "developer_debugging_verbose",
+			source:   "AIRPLAY",
+			location: "",
+			verbose:  true,
+			expected: true,
+			useCase:  "Developer wants all available info regardless of source",
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			contentItem := &models.ContentItem{
+				Source:   scenario.source,
+				Location: scenario.location,
+			}
+
+			result := shouldShowContentDetails(scenario.verbose, contentItem)
+			if result != scenario.expected {
+				t.Errorf("Scenario '%s' failed: %s. Expected %v, got %v",
+					scenario.name, scenario.useCase, scenario.expected, result)
+			}
+		})
+	}
+}

cmd/soundtouch-cli/cmd_preset.go

@@ -0,0 +1,303 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// storeCurrentPreset handles storing currently playing content as preset
+func storeCurrentPreset(c *cli.Context) error {
+	slot := c.Int("slot")
+	clientConfig := GetClientConfig(c)
+
+	PrintDeviceHeader(fmt.Sprintf("Storing current content as preset %d", slot), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check what's currently playing
+	nowPlaying, err := client.GetNowPlaying()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get current content: %v", err))
+		return err
+	}
+
+	if nowPlaying.IsEmpty() {
+		PrintError("No content currently playing")
+		return fmt.Errorf("no content currently playing")
+	}
+
+	if nowPlaying.ContentItem == nil {
+		PrintError("Current content has no preset information")
+		return fmt.Errorf("current content cannot be saved as preset")
+	}
+
+	if !nowPlaying.ContentItem.IsPresetable {
+		PrintError("Current content cannot be saved as preset")
+		fmt.Printf("  Content: %s\n", nowPlaying.Track)
+		fmt.Printf("  Source: %s\n", nowPlaying.Source)
+
+		return fmt.Errorf("current content cannot be preset")
+	}
+
+	// Show what we're about to store
+	fmt.Printf("Current Content:\n")
+	fmt.Printf("  Track: %s\n", nowPlaying.Track)
+
+	if nowPlaying.Artist != "" {
+		fmt.Printf("  Artist: %s\n", nowPlaying.Artist)
+	}
+
+	if nowPlaying.Album != "" {
+		fmt.Printf("  Album: %s\n", nowPlaying.Album)
+	}
+
+	fmt.Printf("  Source: %s\n", nowPlaying.Source)
+
+	if nowPlaying.ContentItem.Location != "" {
+		fmt.Printf("  Location: %s\n", nowPlaying.ContentItem.Location)
+	}
+
+	// Store as preset
+	err = client.StoreCurrentAsPreset(slot)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to store preset: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Stored current content as preset %d", slot))
+
+	return nil
+}
+
+// presetParams holds parameters for storing a preset
+type presetParams struct {
+	slot          int
+	source        string
+	location      string
+	sourceAccount string
+	name          string
+	itemType      string
+	artwork       string
+}
+
+// extractPresetParams extracts parameters from CLI context
+func extractPresetParams(c *cli.Context) *presetParams {
+	return &presetParams{
+		slot:          c.Int("slot"),
+		source:        c.String("source"),
+		location:      c.String("location"),
+		sourceAccount: c.String("source-account"),
+		name:          c.String("name"),
+		itemType:      c.String("type"),
+		artwork:       c.String("artwork"),
+	}
+}
+
+// resolveLocationAndMetadata resolves location and fetches metadata if needed
+func resolveLocationAndMetadata(params *presetParams) error {
+	originalLocation := params.location
+	resolvedSource, resolvedLocation := resolveLocation(params.source, params.location)
+
+	params.source = resolvedSource
+	params.location = resolvedLocation
+
+	// If metadata (name or artwork) is missing, try to fetch it
+	if params.name == "" || params.artwork == "" {
+		var (
+			metadata *Metadata
+			err      error
+		)
+
+		if params.source == "TUNEIN" && strings.Contains(originalLocation, "tunein.com/radio/") {
+			metadata, err = fetchTuneInMetadata(originalLocation)
+		} else if params.source == "SPOTIFY" && strings.Contains(originalLocation, "open.spotify.com/") {
+			metadata, err = fetchSpotifyMetadata(originalLocation)
+		}
+
+		if err == nil && metadata != nil {
+			if params.name == "" {
+				params.name = metadata.Name
+			}
+
+			if params.artwork == "" {
+				params.artwork = metadata.Artwork
+			}
+		}
+	}
+
+	return nil
+}
+
+// validatePresetParams validates required preset parameters
+func validatePresetParams(params *presetParams) error {
+	if params.source == "" {
+		return fmt.Errorf("source is required (use --source)")
+	}
+
+	if params.location == "" {
+		return fmt.Errorf("location is required (use --location)")
+	}
+
+	return nil
+}
+
+// createContentItem creates a ContentItem from preset parameters
+func createContentItem(params *presetParams) *models.ContentItem {
+	contentItem := &models.ContentItem{
+		Source:        params.source,
+		Type:          params.itemType,
+		Location:      params.location,
+		SourceAccount: params.sourceAccount,
+		IsPresetable:  true,
+		ItemName:      params.name,
+		ContainerArt:  params.artwork,
+	}
+
+	// Set default type if not specified
+	if params.itemType == "" {
+		switch params.source {
+		case "SPOTIFY":
+			contentItem.Type = "uri"
+		case "TUNEIN", "LOCAL_INTERNET_RADIO":
+			contentItem.Type = "stationurl"
+		default:
+			contentItem.Type = ""
+		}
+	}
+
+	return contentItem
+}
+
+// printPresetContent displays what content will be stored
+func printPresetContent(params *presetParams) {
+	fmt.Printf("Content to store:\n")
+	fmt.Printf("  Name: %s\n", params.name)
+	fmt.Printf("  Source: %s\n", params.source)
+	fmt.Printf("  Location: %s\n", params.location)
+
+	if params.sourceAccount != "" {
+		fmt.Printf("  Source Account: %s\n", params.sourceAccount)
+	}
+
+	if params.itemType != "" {
+		fmt.Printf("  Type: %s\n", params.itemType)
+	}
+}
+
+// storePreset handles storing specific content as preset
+func storePreset(c *cli.Context) error {
+	// Extract parameters
+	params := extractPresetParams(c)
+
+	// Resolve location and fetch metadata if needed
+	if err := resolveLocationAndMetadata(params); err != nil {
+		return err
+	}
+
+	// Validate required parameters
+	if err := validatePresetParams(params); err != nil {
+		return err
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Storing %s content as preset %d", params.source, params.slot), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	contentItem := createContentItem(params)
+	printPresetContent(params)
+
+	// Store preset
+	err = client.StorePreset(params.slot, contentItem)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to store preset: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Stored content as preset %d", params.slot))
+
+	return nil
+}
+
+// removePreset handles removing a preset
+func removePreset(c *cli.Context) error {
+	slot := c.Int("slot")
+	clientConfig := GetClientConfig(c)
+
+	PrintDeviceHeader(fmt.Sprintf("Removing preset %d", slot), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check if preset exists first
+	presets, err := client.GetPresets()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get presets: %v", err))
+		return err
+	}
+
+	preset := presets.GetPresetByID(slot)
+	if preset == nil || preset.IsEmpty() {
+		PrintError(fmt.Sprintf("Preset %d is already empty", slot))
+		return fmt.Errorf("preset %d does not exist", slot)
+	}
+
+	// Show what we're removing
+	fmt.Printf("Removing preset %d:\n", slot)
+	fmt.Printf("  Name: %s\n", preset.GetDisplayName())
+	fmt.Printf("  Source: %s\n", preset.GetSource())
+
+	// Remove preset
+	err = client.RemovePreset(slot)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to remove preset: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Removed preset %d", slot))
+
+	return nil
+}
+
+// selectPresetNew handles selecting a preset (new version that works with subcommands)
+func selectPresetNew(c *cli.Context) error {
+	slot := c.Int("slot")
+	clientConfig := GetClientConfig(c)
+
+	PrintDeviceHeader(fmt.Sprintf("Selecting preset %d", slot), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.SelectPreset(slot)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to select preset: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Preset %d selected", slot))
+
+	return nil
+}
+
+// listPresets handles listing all presets (alias for existing getPresets command)
+func listPresets(c *cli.Context) error {
+	return getPresets(c)
+}

cmd/soundtouch-cli/cmd_recents.go

@@ -0,0 +1,524 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// getRecents handles getting recently played content
+func getRecents(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Getting recently played content", clientConfig.Host, clientConfig.Port)
+
+	response, err := client.GetRecents()
+	if err != nil {
+		return fmt.Errorf("failed to get recent items: %w", err)
+	}
+
+	if response.IsEmpty() {
+		fmt.Printf("📭 No recent items found\n")
+		fmt.Printf("💡 Play some content to populate the recent items list\n")
+
+		return nil
+	}
+
+	// Display summary
+	fmt.Printf("📊 Recent Items Summary:\n")
+	fmt.Printf("   Total Items: %d\n", response.GetItemCount())
+
+	// Show source breakdown
+	sources := map[string]int{
+		"Spotify":      len(response.GetSpotifyItems()),
+		"Local Music":  len(response.GetLocalMusicItems()),
+		"Stored Music": len(response.GetStoredMusicItems()),
+		"TuneIn":       len(response.GetTuneInItems()),
+		"Pandora":      len(response.GetPandoraItems()),
+	}
+
+	fmt.Printf("   By Source:\n")
+
+	for source, count := range sources {
+		if count > 0 {
+			fmt.Printf("     • %s: %d items\n", source, count)
+		}
+	}
+
+	// Show type breakdown
+	tracks := len(response.GetTracks())
+	stations := len(response.GetStations())
+	playlists := len(response.GetPlaylistsAndAlbums())
+	presetable := len(response.GetPresetableItems())
+
+	fmt.Printf("   By Type:\n")
+
+	if tracks > 0 {
+		fmt.Printf("     • 🎵 Tracks: %d\n", tracks)
+	}
+
+	if stations > 0 {
+		fmt.Printf("     • 📻 Stations: %d\n", stations)
+	}
+
+	if playlists > 0 {
+		fmt.Printf("     • 📋 Playlists/Albums: %d\n", playlists)
+	}
+
+	if presetable > 0 {
+		fmt.Printf("     • ⭐ Presetable: %d\n", presetable)
+	}
+
+	fmt.Printf("\n=== Recent Items ===\n")
+
+	// Display items with details
+	maxItems := c.Int("limit")
+	if maxItems <= 0 || maxItems > len(response.Items) {
+		maxItems = len(response.Items)
+	}
+
+	for i, item := range response.Items[:maxItems] {
+		printRecentItem(i+1, &item, c.Bool("detailed"))
+	}
+
+	if len(response.Items) > maxItems {
+		fmt.Printf("\n... and %d more items (use --limit to show more)\n", len(response.Items)-maxItems)
+	}
+
+	return nil
+}
+
+// getRecentsFiltered handles getting filtered recent content
+// buildFilterDescription creates a description string for the applied filters
+func buildFilterDescription(source, contentType string) string {
+	switch {
+	case source != "" && contentType != "":
+		return fmt.Sprintf(" (filtered by source: %s, type: %s)", source, contentType)
+	case source != "":
+		return fmt.Sprintf(" (filtered by source: %s)", source)
+	case contentType != "":
+		return fmt.Sprintf(" (filtered by type: %s)", contentType)
+	default:
+		return ""
+	}
+}
+
+// applyContentTypeFilter filters items by content type
+func applyContentTypeFilter(items []models.RecentsResponseItem, contentType string) []models.RecentsResponseItem {
+	if contentType == "" {
+		return items
+	}
+
+	var typeFiltered []models.RecentsResponseItem
+
+	for _, item := range items {
+		if shouldIncludeItemByType(item, contentType) {
+			typeFiltered = append(typeFiltered, item)
+		}
+	}
+
+	return typeFiltered
+}
+
+// shouldIncludeItemByType checks if an item matches the specified content type
+func shouldIncludeItemByType(item models.RecentsResponseItem, contentType string) bool {
+	switch contentType {
+	case "track", "tracks":
+		return item.IsTrack()
+	case "station", "stations":
+		return item.IsStation()
+	case "playlist", "playlists":
+		return item.IsPlaylist()
+	case "album", "albums":
+		return item.IsAlbum()
+	case "container", "containers":
+		return item.IsContainer()
+	case "presetable":
+		return item.IsPresetable()
+	default:
+		return false
+	}
+}
+
+// displayFilteredResults prints the filtered recent items
+func displayFilteredResults(filteredItems []models.RecentsResponseItem, c *cli.Context) {
+	maxItems := c.Int("limit")
+	if maxItems <= 0 || maxItems > len(filteredItems) {
+		maxItems = len(filteredItems)
+	}
+
+	for i, item := range filteredItems[:maxItems] {
+		printRecentItem(i+1, &item, c.Bool("detailed"))
+	}
+
+	if len(filteredItems) > maxItems {
+		fmt.Printf("\n... and %d more items (use --limit to show more)\n", len(filteredItems)-maxItems)
+	}
+}
+
+func getRecentsFiltered(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	source := strings.ToUpper(c.String("source"))
+	contentType := strings.ToLower(c.String("type"))
+	filterDesc := buildFilterDescription(source, contentType)
+
+	PrintDeviceHeader("Getting filtered recent content"+filterDesc, clientConfig.Host, clientConfig.Port)
+
+	response, err := client.GetRecents()
+	if err != nil {
+		return fmt.Errorf("failed to get recent items: %w", err)
+	}
+
+	if response.IsEmpty() {
+		fmt.Printf("📭 No recent items found\n")
+		return nil
+	}
+
+	// Apply source filter
+	var filteredItems []models.RecentsResponseItem
+	if source != "" {
+		filteredItems = response.GetItemsBySource(source)
+	} else {
+		filteredItems = response.Items
+	}
+
+	// Apply type filter
+	filteredItems = applyContentTypeFilter(filteredItems, contentType)
+
+	if len(filteredItems) == 0 {
+		fmt.Printf("📭 No items match the specified filters\n")
+		fmt.Printf("💡 Try different filter criteria or check available content\n")
+
+		return nil
+	}
+
+	fmt.Printf("📊 Filtered Results: %d items\n\n", len(filteredItems))
+	displayFilteredResults(filteredItems, c)
+
+	return nil
+}
+
+// getRecentsMostRecent shows only the most recent item
+func getRecentsMostRecent(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Getting most recent item", clientConfig.Host, clientConfig.Port)
+
+	response, err := client.GetRecents()
+	if err != nil {
+		return fmt.Errorf("failed to get recent items: %w", err)
+	}
+
+	mostRecent := response.GetMostRecent()
+	if mostRecent == nil {
+		fmt.Printf("📭 No recent items found\n")
+		return nil
+	}
+
+	fmt.Printf("🕒 Most Recent Item:\n\n")
+	printRecentItem(1, mostRecent, true)
+
+	return nil
+}
+
+// printRecentItem prints details about a recent item
+func printRecentItem(index int, item *models.RecentsResponseItem, detailed bool) {
+	// Basic information
+	displayName := item.GetDisplayName()
+	source := item.GetSource()
+	contentType := item.GetContentType()
+
+	// Format source display
+	sourceDisplay := formatSourceForDisplay(source)
+
+	// Content type icon
+	typeIcon := getContentTypeIcon(item)
+
+	fmt.Printf("%d. %s %s\n", index, typeIcon, displayName)
+	fmt.Printf("   Source: %s", sourceDisplay)
+
+	if contentType != "" {
+		fmt.Printf(" | Type: %s", contentType)
+	}
+
+	fmt.Printf("\n")
+
+	// Time information
+	if item.GetUTCTime() > 0 {
+		playTime := time.Unix(item.GetUTCTime(), 0)
+		fmt.Printf("   Played: %s\n", playTime.Format("2006-01-02 15:04:05"))
+	}
+
+	// Additional details if requested
+	if detailed {
+		if item.HasID() {
+			fmt.Printf("   ID: %s\n", item.GetID())
+		}
+
+		if item.IsPresetable() {
+			fmt.Printf("   ⭐ Can be saved as preset\n")
+		}
+
+		if item.HasArtwork() {
+			fmt.Printf("   🎨 Has artwork: %s\n", truncateString(item.GetArtwork(), 50))
+		}
+
+		location := item.GetLocation()
+		if location != "" {
+			fmt.Printf("   📍 Location: %s\n", truncateString(location, 50))
+		}
+
+		sourceAccount := item.GetSourceAccount()
+		if sourceAccount != "" && sourceAccount != source {
+			fmt.Printf("   👤 Account: %s\n", truncateString(sourceAccount, 30))
+		}
+
+		// Content classification
+		var classifications []string
+		if item.IsStreamingContent() {
+			classifications = append(classifications, "Streaming")
+		}
+
+		if item.IsLocalContent() {
+			classifications = append(classifications, "Local")
+		}
+
+		if len(classifications) > 0 {
+			fmt.Printf("   🏷️  Classification: %s\n", strings.Join(classifications, ", "))
+		}
+	}
+
+	fmt.Println()
+}
+
+// getContentTypeIcon returns an emoji icon for the content type
+func getContentTypeIcon(item *models.RecentsResponseItem) string {
+	switch {
+	case item.IsTrack():
+		return "🎵"
+	case item.IsStation():
+		return "📻"
+	case item.IsPlaylist():
+		return "📋"
+	case item.IsAlbum():
+		return "💿"
+	case item.IsContainer():
+		return "📁"
+	default:
+		return "🎶"
+	}
+}
+
+// formatSourceForDisplay formats source names for user-friendly display
+func formatSourceForDisplay(source string) string {
+	switch source {
+	case "SPOTIFY":
+		return "Spotify"
+	case "LOCAL_MUSIC":
+		return "Local Music"
+	case "STORED_MUSIC":
+		return "Stored Music"
+	case "TUNEIN":
+		return "TuneIn Radio"
+	case "PANDORA":
+		return "Pandora"
+	case "AMAZON":
+		return "Amazon Music"
+	case "DEEZER":
+		return "Deezer"
+	case "IHEART":
+		return "iHeartRadio"
+	case "BLUETOOTH":
+		return "Bluetooth"
+	case "AUX":
+		return "AUX Input"
+	case "AIRPLAY":
+		return "AirPlay"
+	default:
+		return source
+	}
+}
+
+// truncateString truncates a string to the specified length with ellipsis
+func truncateString(s string, maxLength int) string {
+	if len(s) <= maxLength {
+		return s
+	}
+
+	if maxLength <= 3 {
+		return "..."
+	}
+
+	return s[:maxLength-3] + "..."
+}
+
+// printBasicStats prints overall statistics about recent items
+func printBasicStats(response *models.RecentsResponse) {
+	fmt.Printf("Overall Statistics:\n")
+	fmt.Printf("  Total Items: %d\n", response.GetItemCount())
+
+	if !response.IsEmpty() {
+		mostRecent := response.GetMostRecent()
+		if mostRecent != nil {
+			lastPlayTime := time.Unix(mostRecent.GetUTCTime(), 0)
+			fmt.Printf("  Last Played: %s\n", lastPlayTime.Format("2006-01-02 15:04:05"))
+		}
+	}
+}
+
+// printSourceStats prints statistics broken down by source
+func printSourceStats(response *models.RecentsResponse) {
+	fmt.Printf("\nBy Source:\n")
+
+	sourceStats := map[string]int{
+		"Spotify":      len(response.GetSpotifyItems()),
+		"Pandora":      len(response.GetPandoraItems()),
+		"TuneIn":       len(response.GetTuneInItems()),
+		"Local Music":  len(response.GetLocalMusicItems()),
+		"Stored Music": len(response.GetStoredMusicItems()),
+	}
+
+	// Add other sources if they exist
+	otherSources := make(map[string]int)
+
+	for _, item := range response.Items {
+		source := item.GetSource()
+		found := false
+
+		for knownSource := range sourceStats {
+			if strings.Contains(strings.ToLower(knownSource), strings.ToLower(source)) ||
+				strings.Contains(strings.ToLower(source), strings.ToLower(knownSource)) {
+				found = true
+				break
+			}
+		}
+
+		if !found && source != "" {
+			otherSources[formatSourceForDisplay(source)]++
+		}
+	}
+
+	// Merge other sources
+	for source, count := range otherSources {
+		sourceStats[source] = count
+	}
+
+	for source, count := range sourceStats {
+		if count > 0 {
+			percentage := float64(count) / float64(response.GetItemCount()) * 100
+			fmt.Printf("  %-15s %3d items (%5.1f%%)\n", source+":", count, percentage)
+		}
+	}
+}
+
+// printContentTypeStats prints statistics broken down by content type
+func printContentTypeStats(response *models.RecentsResponse) {
+	fmt.Printf("\nBy Content Type:\n")
+
+	tracks := len(response.GetTracks())
+	stations := len(response.GetStations())
+	playlists := len(response.GetPlaylistsAndAlbums())
+
+	if tracks > 0 {
+		percentage := float64(tracks) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Tracks:", tracks, percentage)
+	}
+
+	if stations > 0 {
+		percentage := float64(stations) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Stations:", stations, percentage)
+	}
+
+	if playlists > 0 {
+		percentage := float64(playlists) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Playlists/Albums:", playlists, percentage)
+	}
+}
+
+// printSpecialCategoryStats prints statistics for special content categories
+func printSpecialCategoryStats(response *models.RecentsResponse) {
+	presetable := len(response.GetPresetableItems())
+	if presetable > 0 {
+		fmt.Printf("\nSpecial Categories:\n")
+
+		percentage := float64(presetable) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Presetable:", presetable, percentage)
+	}
+}
+
+// printSourceAnalysisStats prints streaming vs local content analysis
+func printSourceAnalysisStats(response *models.RecentsResponse) {
+	streamingCount := 0
+	localCount := 0
+
+	for _, item := range response.Items {
+		if item.IsStreamingContent() {
+			streamingCount++
+		} else if item.IsLocalContent() {
+			localCount++
+		}
+	}
+
+	fmt.Printf("\nSource Analysis:\n")
+
+	if streamingCount > 0 {
+		percentage := float64(streamingCount) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Streaming:", streamingCount, percentage)
+	}
+
+	if localCount > 0 {
+		percentage := float64(localCount) / float64(response.GetItemCount()) * 100
+		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Local:", localCount, percentage)
+	}
+}
+
+// recentsStats shows statistics about recent items
+func recentsStats(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Getting recent items statistics", clientConfig.Host, clientConfig.Port)
+
+	response, err := client.GetRecents()
+	if err != nil {
+		return fmt.Errorf("failed to get recent items: %w", err)
+	}
+
+	if response.IsEmpty() {
+		fmt.Printf("📊 Statistics: No recent items found\n")
+		return nil
+	}
+
+	fmt.Printf("📊 Recent Items Statistics\n\n")
+
+	printBasicStats(response)
+	printSourceStats(response)
+	printContentTypeStats(response)
+	printSpecialCategoryStats(response)
+	printSourceAnalysisStats(response)
+
+	return nil
+}

cmd/soundtouch-cli/cmd_recents_test.go

@@ -0,0 +1,411 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+func TestRecentsCommands(t *testing.T) {
+	tests := []struct {
+		name           string
+		args           []string
+		expectedOutput []string
+		expectError    bool
+	}{
+		{
+			name: "recents list command",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "recents", "list"},
+			expectedOutput: []string{
+				"Getting recently played content",
+				"Recent Items Summary:",
+				"Recent Items",
+			},
+		},
+		{
+			name: "recents filter by source",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "recents", "filter", "--source", "SPOTIFY"},
+			expectedOutput: []string{
+				"Getting filtered recent content",
+				"filtered by source: SPOTIFY",
+			},
+		},
+		{
+			name: "recents latest command",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "recents", "latest"},
+			expectedOutput: []string{
+				"Getting most recent item",
+				"Most Recent Item:",
+			},
+		},
+		{
+			name: "recents stats command",
+			args: []string{"soundtouch-cli", "--host", "192.0.2.100", "recents", "stats"},
+			expectedOutput: []string{
+				"Getting recent items statistics",
+				"Recent Items Statistics",
+			},
+		},
+		{
+			name:        "recents missing host",
+			args:        []string{"soundtouch-cli", "recents", "list"},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Skip actual execution for now - these would need mock HTTP servers
+			// This test structure shows how the CLI commands would be tested
+			t.Skip("Integration test - requires mock HTTP server setup")
+
+			// Example of how you would set up the test:
+			// app := createTestApp()
+			//
+			// var buf bytes.Buffer
+			// app.Writer = &buf
+			// app.ErrWriter = &buf
+			//
+			// err := app.Run(tt.args)
+			//
+			// if tt.expectError {
+			//     if err == nil {
+			//         t.Error("expected error, got nil")
+			//     }
+			//     return
+			// }
+			//
+			// if err != nil {
+			//     t.Fatalf("unexpected error: %v", err)
+			// }
+			//
+			// output := buf.String()
+			// for _, expected := range tt.expectedOutput {
+			//     if !strings.Contains(output, expected) {
+			//         t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+			//     }
+			// }
+		})
+	}
+}
+
+func TestPrintRecentItem(t *testing.T) {
+	tests := []struct {
+		name     string
+		item     *models.RecentsResponseItem
+		detailed bool
+		expected []string
+	}{
+		{
+			name: "basic track item",
+			item: &models.RecentsResponseItem{
+				DeviceID: "device1",
+				UTCTime:  1701200000,
+				ContentItem: &models.ContentItem{
+					Source:   "SPOTIFY",
+					Type:     "track",
+					ItemName: "Test Song",
+				},
+			},
+			detailed: false,
+			expected: []string{
+				"🎵 Test Song",
+				"Source: Spotify",
+				"Type: track",
+			},
+		},
+		{
+			name: "detailed station item",
+			item: &models.RecentsResponseItem{
+				DeviceID: "device1",
+				UTCTime:  1701200000,
+				ID:       "station123",
+				ContentItem: &models.ContentItem{
+					Source:        "TUNEIN",
+					Type:          "stationurl",
+					ItemName:      "Rock FM",
+					Location:      "tunein:station:s12345",
+					SourceAccount: "tunein_account",
+					IsPresetable:  true,
+				},
+			},
+			detailed: true,
+			expected: []string{
+				"📻 Rock FM",
+				"Source: TuneIn Radio",
+				"ID: station123",
+				"Can be saved as preset",
+				"Location: tunein:station:s12345",
+				"Classification: Streaming",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			// Call the function
+			printRecentItem(1, tt.item, tt.detailed)
+
+			// Restore stdout and read output
+			w.Close()
+
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+
+			_, err := buf.ReadFrom(r)
+			if err != nil {
+				t.Fatalf("failed to read output: %v", err)
+			}
+
+			output := buf.String()
+
+			// Check expected strings are present
+			for _, expected := range tt.expected {
+				if !bytes.Contains(buf.Bytes(), []byte(expected)) {
+					t.Errorf("expected output to contain %q, got:\n%s", expected, output)
+				}
+			}
+		})
+	}
+}
+
+func TestGetContentTypeIcon(t *testing.T) {
+	tests := []struct {
+		name     string
+		item     *models.RecentsResponseItem
+		expected string
+	}{
+		{
+			name: "track item",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "track"},
+			},
+			expected: "🎵",
+		},
+		{
+			name: "station item",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "stationurl"},
+			},
+			expected: "📻",
+		},
+		{
+			name: "playlist item",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "playlist"},
+			},
+			expected: "📋",
+		},
+		{
+			name: "album item",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "album"},
+			},
+			expected: "💿",
+		},
+		{
+			name: "container item",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "container"},
+			},
+			expected: "📁",
+		},
+		{
+			name: "unknown type",
+			item: &models.RecentsResponseItem{
+				ContentItem: &models.ContentItem{Type: "unknown"},
+			},
+			expected: "🎶",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := getContentTypeIcon(tt.item)
+			if result != tt.expected {
+				t.Errorf("expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestFormatSourceForDisplay(t *testing.T) {
+	tests := []struct {
+		name     string
+		source   string
+		expected string
+	}{
+		{"Spotify", "SPOTIFY", "Spotify"},
+		{"Local Music", "LOCAL_MUSIC", "Local Music"},
+		{"Stored Music", "STORED_MUSIC", "Stored Music"},
+		{"TuneIn", "TUNEIN", "TuneIn Radio"},
+		{"Pandora", "PANDORA", "Pandora"},
+		{"Amazon", "AMAZON", "Amazon Music"},
+		{"Deezer", "DEEZER", "Deezer"},
+		{"iHeart", "IHEART", "iHeartRadio"},
+		{"Bluetooth", "BLUETOOTH", "Bluetooth"},
+		{"AUX", "AUX", "AUX Input"},
+		{"AirPlay", "AIRPLAY", "AirPlay"},
+		{"Unknown", "UNKNOWN_SOURCE", "UNKNOWN_SOURCE"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := formatSourceForDisplay(tt.source)
+			if result != tt.expected {
+				t.Errorf("expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestTruncateString(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		maxLength int
+		expected  string
+	}{
+		{
+			name:      "short string",
+			input:     "hello",
+			maxLength: 10,
+			expected:  "hello",
+		},
+		{
+			name:      "exact length",
+			input:     "hello",
+			maxLength: 5,
+			expected:  "hello",
+		},
+		{
+			name:      "long string",
+			input:     "this is a very long string that needs truncation",
+			maxLength: 20,
+			expected:  "this is a very lo...",
+		},
+		{
+			name:      "very short max length",
+			input:     "hello world",
+			maxLength: 3,
+			expected:  "...",
+		},
+		{
+			name:      "zero length",
+			input:     "hello",
+			maxLength: 0,
+			expected:  "...",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := truncateString(tt.input, tt.maxLength)
+			if result != tt.expected {
+				t.Errorf("expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}
+
+// Test helper functions that would be used in full integration tests
+func createTestRecentsResponse() *models.RecentsResponse {
+	return &models.RecentsResponse{
+		Items: []models.RecentsResponseItem{
+			{
+				DeviceID: "1004567890AA",
+				UTCTime:  1701300000,
+				ID:       "spotify1",
+				ContentItem: &models.ContentItem{
+					Source:        "SPOTIFY",
+					Type:          "track",
+					Location:      "spotify:track:4iV5W9uYEdYUVa79Axb7Rh",
+					SourceAccount: "spotify_user",
+					IsPresetable:  true,
+					ItemName:      "Shape of You - Ed Sheeran",
+					ContainerArt:  "https://i.scdn.co/image/ab67616d0000b273ba5db46f4b838ef6027e6f96",
+				},
+			},
+			{
+				DeviceID: "1004567890AA",
+				UTCTime:  1701200000,
+				ID:       "local1",
+				ContentItem: &models.ContentItem{
+					Source:       "LOCAL_MUSIC",
+					Type:         "track",
+					Location:     "/music/local_song.mp3",
+					IsPresetable: false,
+					ItemName:     "Local Song - Local Artist",
+				},
+			},
+			{
+				DeviceID: "1004567890AA",
+				UTCTime:  1701100000,
+				ID:       "tunein1",
+				ContentItem: &models.ContentItem{
+					Source:        "TUNEIN",
+					Type:          "stationurl",
+					Location:      "tunein:station:s24939",
+					SourceAccount: "tunein",
+					IsPresetable:  true,
+					ItemName:      "BBC Radio 1",
+				},
+			},
+		},
+	}
+}
+
+func TestCreateTestRecentsResponse(t *testing.T) {
+	response := createTestRecentsResponse()
+
+	if response == nil {
+		t.Fatal("expected response, got nil")
+	}
+
+	if response.GetItemCount() != 3 {
+		t.Errorf("expected 3 items, got %d", response.GetItemCount())
+	}
+
+	if response.IsEmpty() {
+		t.Error("expected response not to be empty")
+	}
+
+	// Test filtering
+	spotifyItems := response.GetSpotifyItems()
+	if len(spotifyItems) != 1 {
+		t.Errorf("expected 1 Spotify item, got %d", len(spotifyItems))
+	}
+
+	localItems := response.GetLocalMusicItems()
+	if len(localItems) != 1 {
+		t.Errorf("expected 1 local music item, got %d", len(localItems))
+	}
+
+	tuneInItems := response.GetTuneInItems()
+	if len(tuneInItems) != 1 {
+		t.Errorf("expected 1 TuneIn item, got %d", len(tuneInItems))
+	}
+
+	tracks := response.GetTracks()
+	if len(tracks) != 2 {
+		t.Errorf("expected 2 tracks, got %d", len(tracks))
+	}
+
+	stations := response.GetStations()
+	if len(stations) != 1 {
+		t.Errorf("expected 1 station, got %d", len(stations))
+	}
+
+	presetableItems := response.GetPresetableItems()
+	if len(presetableItems) != 2 {
+		t.Errorf("expected 2 presetable items, got %d", len(presetableItems))
+	}
+}

cmd/soundtouch-cli/cmd_setup_test.go

@@ -0,0 +1,310 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/gesellix/bose-soundtouch/pkg/service/setup"
+)
+
+// captureStdout runs fn and returns whatever it wrote to os.Stdout.
+// renderSourceTable prints directly via fmt.Print* — this lets us assert
+// on its output without restructuring the renderer to take an io.Writer.
+func captureStdout(t *testing.T, fn func()) string {
+	t.Helper()
+
+	orig := os.Stdout
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("pipe: %v", err)
+	}
+
+	os.Stdout = w
+
+	done := make(chan struct{})
+	buf := &bytes.Buffer{}
+
+	go func() {
+		_, _ = io.Copy(buf, r)
+		close(done)
+	}()
+
+	fn()
+	_ = w.Close()
+
+	os.Stdout = orig
+	<-done
+
+	return buf.String()
+}
+
+func TestRenderSourceTable_AlignsColumnsAndDedupsDisplayName(t *testing.T) {
+	items := []models.SourceItem{
+		// displayName != account → kept as "AUX (AUX IN)"
+		{Source: "AUX", SourceAccount: "AUX", DisplayName: "AUX IN", Status: "READY", IsLocal: true, MultiroomAllowed: true},
+		// displayName == account → dropped (would otherwise duplicate the next column)
+		{Source: "AMAZON", SourceAccount: "amzn1.account.AFKTQOUNVZL7ODQCF4STPAAMVMPA", DisplayName: "amzn1.account.AFKTQOUNVZL7ODQCF4STPAAMVMPA", Status: "READY", MultiroomAllowed: true},
+		// No displayName at all, no account
+		{Source: "BLUETOOTH", Status: "UNAVAILABLE", IsLocal: true, MultiroomAllowed: true},
+		// Long source name, no catalog entry → provider#?
+		{Source: "STORED_MUSIC_MEDIA_RENDERER", SourceAccount: "StoredMusicUserName", DisplayName: "StoredMusicUserName", Status: "UNAVAILABLE", MultiroomAllowed: true},
+	}
+
+	out := captureStdout(t, func() { renderSourceTable(items) })
+
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	if len(lines) != 4 {
+		t.Fatalf("got %d output lines, want 4:\n%s", len(lines), out)
+	}
+
+	// (1) AUX keeps "(AUX IN)" because it differs from both source and account.
+	if !strings.Contains(lines[0], "AUX (AUX IN)") {
+		t.Errorf("AUX line should keep displayName parenthesis: %q", lines[0])
+	}
+
+	// (2) AMAZON drops "(amzn1…)" because displayName equals sourceAccount.
+	if strings.Contains(lines[1], "(amzn1.account") {
+		t.Errorf("AMAZON line should drop displayName when it duplicates account: %q", lines[1])
+	}
+
+	// (3) provider#? for the uncatalogued source.
+	if !strings.Contains(lines[3], "provider#?") {
+		t.Errorf("uncatalogued source should be tagged provider#?: %q", lines[3])
+	}
+
+	// (4) Column starts must align across all rows — find the column index
+	//     where "status=" appears in each line; they should all match.
+	statusCols := make([]int, len(lines))
+	for i, l := range lines {
+		statusCols[i] = strings.Index(l, "status=")
+		if statusCols[i] < 0 {
+			t.Fatalf("line %d missing status= column: %q", i, l)
+		}
+	}
+
+	for i := 1; i < len(statusCols); i++ {
+		if statusCols[i] != statusCols[0] {
+			t.Errorf("status= column misaligned: line 0 at col %d, line %d at col %d\n%s",
+				statusCols[0], i, statusCols[i], out)
+		}
+	}
+
+	// (5) account= column should likewise align across all rows.
+	accountCols := make([]int, len(lines))
+	for i, l := range lines {
+		accountCols[i] = strings.Index(l, "account=")
+		if accountCols[i] < 0 {
+			t.Fatalf("line %d missing account= column: %q", i, l)
+		}
+	}
+
+	for i := 1; i < len(accountCols); i++ {
+		if accountCols[i] != accountCols[0] {
+			t.Errorf("account= column misaligned: line 0 at col %d, line %d at col %d\n%s",
+				accountCols[0], i, accountCols[i], out)
+		}
+	}
+}
+
+func TestRenderSourceTable_EmptyShowsNonePlaceholder(t *testing.T) {
+	out := captureStdout(t, func() { renderSourceTable(nil) })
+	if !strings.Contains(out, "(none)") {
+		t.Errorf("expected (none) placeholder for empty list, got: %q", out)
+	}
+}
+
+func TestRecommendMigrationMethod_PrefersTelnet(t *testing.T) {
+	method, reason := recommendMigrationMethod("http://aftertouch.local:8000", &setup.MigrationSummary{
+		TelnetReachable: true,
+		SSHSuccess:      true,
+	})
+
+	if method != setup.MigrationMethodTelnet {
+		t.Errorf("method = %q, want telnet (simplest path when telnet works)", method)
+	}
+
+	if !strings.Contains(reason, "Telnet") {
+		t.Errorf("reason should mention Telnet: %q", reason)
+	}
+}
+
+func TestRecommendMigrationMethod_HTTPSAddsCaveatToTelnet(t *testing.T) {
+	_, reason := recommendMigrationMethod("https://aftertouch.local:8443", &setup.MigrationSummary{
+		TelnetReachable: true,
+	})
+
+	if !strings.Contains(reason, "install-ca") {
+		t.Errorf("HTTPS service URL should flag the CA-install caveat in the reason: %q", reason)
+	}
+}
+
+func TestRecommendMigrationMethod_FallsBackToResolvWhenTelnetDown(t *testing.T) {
+	method, _ := recommendMigrationMethod("http://aftertouch.local:8000", &setup.MigrationSummary{
+		TelnetReachable: false,
+		SSHSuccess:      true,
+	})
+
+	if method != setup.MigrationMethodResolvConf {
+		t.Errorf("method = %q, want resolv (DNS redirect via SSH)", method)
+	}
+}
+
+func TestRecommendMigrationMethod_EmptyWhenNoTransport(t *testing.T) {
+	method, _ := recommendMigrationMethod("http://aftertouch.local:8000", &setup.MigrationSummary{
+		TelnetReachable: false,
+		SSHSuccess:      false,
+	})
+
+	if method != "" {
+		t.Errorf("method = %q, want empty when no transport works", method)
+	}
+}
+
+func TestBuildPlanSteps_NoOpWhenAlreadyMigratedAndPaired(t *testing.T) {
+	summary := &setup.MigrationSummary{IsMigrated: true, IsPaired: true, TelnetMigrated: true}
+	inspect := &setup.InspectReport{Info: &setup.DeviceInfoXML{DeviceID: "AABBCCDDEEFF"}}
+
+	steps := buildPlanSteps("192.0.2.42", "http://aftertouch.local:8000", "", true, false, inspect, summary)
+
+	if len(steps) != 0 {
+		t.Errorf("expected no steps for fully-set-up device, got %d:\n%v", len(steps), steps)
+	}
+}
+
+func TestBuildPlanSteps_RecommendsPairWhenMigratedButUnpaired(t *testing.T) {
+	summary := &setup.MigrationSummary{IsMigrated: true, IsPaired: false, TelnetMigrated: true, TelnetReachable: true}
+	inspect := &setup.InspectReport{Info: &setup.DeviceInfoXML{DeviceID: "AABBCCDDEEFF"}}
+
+	steps := buildPlanSteps("192.0.2.42", "http://aftertouch.local:8000", "", true, false, inspect, summary)
+
+	if len(steps) != 1 {
+		t.Fatalf("expected exactly the pair step, got %d:\n%v", len(steps), steps)
+	}
+
+	if !strings.Contains(steps[0].cmd, "setup pair") {
+		t.Errorf("expected pair command, got %q", steps[0].cmd)
+	}
+}
+
+func TestBuildPlanSteps_MigrateRebootThenPairWhenFresh(t *testing.T) {
+	summary := &setup.MigrationSummary{TelnetReachable: true, SSHSuccess: false, IsPaired: false}
+	inspect := &setup.InspectReport{Info: &setup.DeviceInfoXML{DeviceID: "AABBCCDDEEFF"}}
+
+	steps := buildPlanSteps("192.0.2.42", "http://aftertouch.local:8000", "", true, false, inspect, summary)
+
+	// migrate → reboot → pair. The reboot step exists because envswitch's
+	// parallel-persistence layer only fully wins on the next boot, and we
+	// want the new URLs locked in before pairing posts to the speaker.
+	if len(steps) != 3 {
+		t.Fatalf("expected migrate+reboot+pair, got %d steps:\n%v", len(steps), steps)
+	}
+
+	if !strings.Contains(steps[0].cmd, "setup migrate") || !strings.Contains(steps[0].cmd, "method=telnet") {
+		t.Errorf("step 1 should be telnet migrate, got %q", steps[0].cmd)
+	}
+
+	if !strings.Contains(steps[1].cmd, "setup reboot") {
+		t.Errorf("step 2 should be reboot, got %q", steps[1].cmd)
+	}
+
+	if !strings.Contains(steps[2].cmd, "setup pair") {
+		t.Errorf("step 3 should be pair, got %q", steps[2].cmd)
+	}
+}
+
+func TestBuildPlanSteps_DNSMethodPrependsCAInstall(t *testing.T) {
+	// Telnet down, SSH up, CA not yet trusted → plan must install-ca
+	// before applying the resolv migration.
+	summary := &setup.MigrationSummary{
+		TelnetReachable: false,
+		SSHSuccess:      true,
+		CACertTrusted:   false,
+		IsPaired:        false,
+	}
+	inspect := &setup.InspectReport{Info: &setup.DeviceInfoXML{DeviceID: "X"}}
+
+	steps := buildPlanSteps("192.0.2.42", "http://aftertouch.local:8000", "", false, false, inspect, summary)
+
+	if len(steps) < 2 {
+		t.Fatalf("expected at least install-ca + migrate, got %d steps:\n%v", len(steps), steps)
+	}
+
+	if !strings.Contains(steps[0].cmd, "install-ca") {
+		t.Errorf("install-ca should come first when DNS method is chosen and CA is not trusted, got %q", steps[0].cmd)
+	}
+
+	if !strings.Contains(steps[1].cmd, "method=resolv") {
+		t.Errorf("step 2 should be resolv migrate, got %q", steps[1].cmd)
+	}
+}
+
+func TestBuildPlanSteps_ResetModeIncludesManualNetworkSwitches(t *testing.T) {
+	inspect := &setup.InspectReport{
+		Info: &setup.DeviceInfoXML{DeviceID: "506583DE4803"},
+		Network: &models.NetworkInformation{
+			Interfaces: models.NetworkInterfaces{
+				Interfaces: []models.NetworkInterface{
+					{Type: "WIFI_INTERFACE", SSID: "MyHomeNetwork"},
+				},
+			},
+		},
+	}
+	summary := &setup.MigrationSummary{IsMigrated: true, IsPaired: true} // doesn't matter in reset mode
+
+	steps := buildPlanSteps("192.0.2.42", "http://aftertouch.local:8000", "", true, true, inspect, summary)
+
+	// Expected sequence in --reset mode:
+	//   factory-reset, manual AP switch, wait-ap, wifi-push, manual home switch,
+	//   wait-online, migrate, pair (8 steps).
+	if len(steps) < 7 {
+		t.Fatalf("expected at least 7 steps in --reset mode, got %d:\n%v", len(steps), steps)
+	}
+
+	manualCount := 0
+	for _, s := range steps {
+		if s.manual {
+			manualCount++
+		}
+	}
+
+	if manualCount < 2 {
+		t.Errorf("expected at least 2 manual steps for the Wi-Fi switches, got %d", manualCount)
+	}
+
+	if !strings.Contains(steps[0].cmd, "factory-reset") {
+		t.Errorf("step 1 must be factory-reset, got %q", steps[0].cmd)
+	}
+
+	// wifi-push step should default to the inspected SSID
+	foundWiFi := false
+
+	for _, s := range steps {
+		if strings.Contains(s.cmd, "wifi-push") && strings.Contains(s.cmd, "MyHomeNetwork") {
+			foundWiFi = true
+			break
+		}
+	}
+
+	if !foundWiFi {
+		t.Errorf("expected wifi-push step to default to inspected SSID 'MyHomeNetwork'")
+	}
+
+	// wait-online --match should use the deviceID suffix
+	foundMatch := false
+
+	for _, s := range steps {
+		if strings.Contains(s.cmd, "wait-online") && strings.Contains(s.cmd, "--match=DE4803") {
+			foundMatch = true
+			break
+		}
+	}
+
+	if !foundMatch {
+		t.Errorf("expected wait-online step to use --match=DE4803 from deviceID suffix")
+	}
+}

cmd/soundtouch-cli/cmd_source.go

@@ -1,7 +1,9 @@
 package main
 
 import (
+	"encoding/base64"
 	"fmt"
+	"net/url"
 	"strings"
 
 	"github.com/gesellix/bose-soundtouch/pkg/models"
@@ -89,6 +91,12 @@ func listSources(c *cli.Context) error {
 		}
 	}
 
+	// Show service availability summary
+	fmt.Println()
+
+	checker := NewServiceAvailabilityChecker(client)
+	checker.PrintServiceAvailabilitySummary()
+
 	return nil
 }
 
@@ -104,6 +112,14 @@ func selectSource(c *cli.Context) error {
 	sourceName := strings.ToUpper(c.String("source"))
 	sourceAccount := c.String("account")
 
+	// Check service availability
+	checker := NewServiceAvailabilityChecker(client)
+
+	actionDescription := fmt.Sprintf("select %s source", strings.ToLower(sourceName))
+	if !checker.CheckSourceAvailable(sourceName, actionDescription) {
+		return fmt.Errorf("source '%s' is not available", sourceName)
+	}
+
 	PrintDeviceHeader(fmt.Sprintf("Selecting source '%s'", sourceName), clientConfig.Host, clientConfig.Port)
 
 	err = client.SelectSource(sourceName, sourceAccount)
@@ -129,6 +145,12 @@ func selectSpotify(c *cli.Context) error {
 		return err
 	}
 
+	// Check Spotify availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidateSpotifyAvailable("select Spotify source") {
+		return fmt.Errorf("spotify is not available on this device")
+	}
+
 	PrintDeviceHeader("Selecting Spotify source", clientConfig.Host, clientConfig.Port)
 
 	err = client.SelectSpotify("")
@@ -150,6 +172,12 @@ func selectBluetooth(c *cli.Context) error {
 		return err
 	}
 
+	// Check Bluetooth availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidateBluetoothAvailable("select Bluetooth source") {
+		return fmt.Errorf("bluetooth is not available on this device")
+	}
+
 	PrintDeviceHeader("Selecting Bluetooth source", clientConfig.Host, clientConfig.Port)
 
 	err = client.SelectBluetooth()
@@ -182,3 +210,478 @@ func selectAux(c *cli.Context) error {
 
 	return nil
 }
+
+// selectLocalInternetRadio handles selecting LOCAL_INTERNET_RADIO source
+func selectLocalInternetRadio(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	location := c.String("location")
+	if location == "" {
+		return fmt.Errorf("location is required (use --location)")
+	}
+
+	sourceAccount := c.String("account")
+	itemName := c.String("name")
+	containerArt := c.String("artwork")
+
+	// Check LOCAL_INTERNET_RADIO availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.CheckSourceAvailable("LOCAL_INTERNET_RADIO", "select internet radio") {
+		return fmt.Errorf("LOCAL_INTERNET_RADIO is not available")
+	}
+
+	PrintDeviceHeader("Selecting internet radio stream", clientConfig.Host, clientConfig.Port)
+
+	if itemName != "" {
+		fmt.Printf("  Station: %s\n", itemName)
+	}
+
+	fmt.Printf("  Location: %s\n", location)
+
+	err = client.SelectLocalInternetRadio(location, sourceAccount, itemName, containerArt)
+	if err != nil {
+		return fmt.Errorf("failed to select internet radio: %w", err)
+	}
+
+	PrintSuccess("Internet radio stream selected")
+
+	return nil
+}
+
+// selectCustomRadio handles selecting custom radio stream via soundtouch-service
+func selectCustomRadio(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	streamURL := c.String("url")
+	itemName := c.String("name")
+	containerArt := c.String("artwork")
+	serviceURL := c.String("service-url")
+
+	encodedURL := base64.URLEncoding.EncodeToString([]byte(streamURL))
+	location := fmt.Sprintf("%s/custom/v1/playback/%s", serviceURL, encodedURL)
+
+	params := url.Values{}
+	if itemName != "" {
+		params.Add("name", itemName)
+	}
+
+	if containerArt != "" {
+		params.Add("imageUrl", containerArt)
+	}
+
+	if len(params) > 0 {
+		location += "?" + params.Encode()
+	}
+
+	// Check LOCAL_INTERNET_RADIO availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.CheckSourceAvailable("LOCAL_INTERNET_RADIO", "select custom radio") {
+		return fmt.Errorf("LOCAL_INTERNET_RADIO is not available")
+	}
+
+	PrintDeviceHeader("Selecting custom radio stream", clientConfig.Host, clientConfig.Port)
+
+	if itemName != "" {
+		fmt.Printf("  Station: %s\n", itemName)
+	}
+
+	fmt.Printf("  URL: %s\n", streamURL)
+	fmt.Printf("  Proxy: %s\n", location)
+
+	err = client.SelectLocalInternetRadio(location, "", itemName, containerArt)
+	if err != nil {
+		return fmt.Errorf("failed to select custom radio: %w", err)
+	}
+
+	PrintSuccess("Custom radio stream selected")
+
+	return nil
+}
+
+// selectLocalMusic handles selecting LOCAL_MUSIC source
+func selectLocalMusic(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	location := c.String("location")
+	if location == "" {
+		return fmt.Errorf("location is required (use --location)")
+	}
+
+	sourceAccount := c.String("account")
+	if sourceAccount == "" {
+		return fmt.Errorf("account is required for LOCAL_MUSIC (use --account)")
+	}
+
+	itemName := c.String("name")
+	containerArt := c.String("artwork")
+
+	// Check LOCAL_MUSIC availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.CheckSourceAvailable("LOCAL_MUSIC", "select local music") {
+		return fmt.Errorf("LOCAL_MUSIC is not available")
+	}
+
+	PrintDeviceHeader("Selecting local music content", clientConfig.Host, clientConfig.Port)
+
+	if itemName != "" {
+		fmt.Printf("  Content: %s\n", itemName)
+	}
+
+	fmt.Printf("  Location: %s\n", location)
+	fmt.Printf("  Account: %s\n", sourceAccount)
+
+	err = client.SelectLocalMusic(location, sourceAccount, itemName, containerArt)
+	if err != nil {
+		return fmt.Errorf("failed to select local music: %w", err)
+	}
+
+	PrintSuccess("Local music content selected")
+
+	return nil
+}
+
+// selectStoredMusic handles selecting STORED_MUSIC source
+func selectStoredMusic(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	location := c.String("location")
+	if location == "" {
+		return fmt.Errorf("location is required (use --location)")
+	}
+
+	sourceAccount := c.String("account")
+	if sourceAccount == "" {
+		return fmt.Errorf("account is required for STORED_MUSIC (use --account)")
+	}
+
+	itemName := c.String("name")
+	containerArt := c.String("artwork")
+
+	// Check STORED_MUSIC availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.CheckSourceAvailable("STORED_MUSIC", "select stored music") {
+		return fmt.Errorf("STORED_MUSIC is not available")
+	}
+
+	PrintDeviceHeader("Selecting stored music content", clientConfig.Host, clientConfig.Port)
+
+	if itemName != "" {
+		fmt.Printf("  Content: %s\n", itemName)
+	}
+
+	fmt.Printf("  Location: %s\n", location)
+	fmt.Printf("  Account: %s\n", sourceAccount)
+
+	err = client.SelectStoredMusic(location, sourceAccount, itemName, containerArt)
+	if err != nil {
+		return fmt.Errorf("failed to select stored music: %w", err)
+	}
+
+	PrintSuccess("Stored music content selected")
+
+	return nil
+}
+
+// selectContent handles selecting content using a ContentItem directly
+func selectContent(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	// Required parameters
+	source := strings.ToUpper(c.String("source"))
+	if source == "" {
+		return fmt.Errorf("source is required (use --source)")
+	}
+
+	location := c.String("location")
+	if location == "" {
+		return fmt.Errorf("location is required (use --location)")
+	}
+
+	// Optional parameters
+	sourceAccount := c.String("account")
+	itemName := c.String("name")
+	containerArt := c.String("artwork")
+	itemType := c.String("type")
+	isPresetable := c.Bool("presetable")
+
+	// Create ContentItem
+	contentItem := &models.ContentItem{
+		Source:        source,
+		Type:          itemType,
+		Location:      location,
+		SourceAccount: sourceAccount,
+		IsPresetable:  isPresetable,
+		ItemName:      itemName,
+		ContainerArt:  containerArt,
+	}
+
+	// Set default type if not specified
+	if itemType == "" {
+		switch source {
+		case "SPOTIFY":
+			contentItem.Type = "uri"
+		case "TUNEIN", "LOCAL_INTERNET_RADIO":
+			contentItem.Type = "stationurl"
+		case "LOCAL_MUSIC":
+			contentItem.Type = "album" // default, could be track, artist, etc.
+		}
+	}
+
+	// Set default item name if not specified
+	if itemName == "" {
+		contentItem.ItemName = source
+	}
+
+	PrintDeviceHeader("Selecting content", clientConfig.Host, clientConfig.Port)
+
+	fmt.Printf("  Source: %s\n", source)
+	fmt.Printf("  Location: %s\n", location)
+
+	if sourceAccount != "" {
+		fmt.Printf("  Account: %s\n", sourceAccount)
+	}
+
+	if itemName != "" {
+		fmt.Printf("  Name: %s\n", itemName)
+	}
+
+	if itemType != "" {
+		fmt.Printf("  Type: %s\n", itemType)
+	}
+
+	err = client.SelectContentItem(contentItem)
+	if err != nil {
+		return fmt.Errorf("failed to select content: %w", err)
+	}
+
+	PrintSuccess("Content selected")
+
+	return nil
+}
+
+// getServiceAvailability handles displaying service availability information
+func getServiceAvailability(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Getting service availability", clientConfig.Host, clientConfig.Port)
+
+	serviceAvailability, err := client.GetServiceAvailability()
+	if err != nil {
+		return fmt.Errorf("failed to get service availability: %w", err)
+	}
+
+	fmt.Printf("Service Availability Report:\n")
+	fmt.Printf("  Total Services: %d\n", serviceAvailability.GetServiceCount())
+	fmt.Printf("  Available Services: %d\n", serviceAvailability.GetAvailableServiceCount())
+	fmt.Printf("  Unavailable Services: %d\n", serviceAvailability.GetUnavailableServiceCount())
+
+	// Show available services
+	fmt.Printf("\n✅ Available Services:\n")
+
+	availableServices := serviceAvailability.GetAvailableServices()
+	if len(availableServices) == 0 {
+		fmt.Printf("    None\n")
+	} else {
+		for _, service := range availableServices {
+			fmt.Printf("    • %s\n", formatServiceTypeForDisplay(models.ServiceType(service.Type)))
+		}
+	}
+
+	// Show unavailable services with reasons
+	fmt.Printf("\n❌ Unavailable Services:\n")
+
+	unavailableServices := serviceAvailability.GetUnavailableServices()
+	if len(unavailableServices) == 0 {
+		fmt.Printf("    None\n")
+	} else {
+		for _, service := range unavailableServices {
+			reason := ""
+			if service.Reason != "" {
+				reason = fmt.Sprintf(" (%s)", service.Reason)
+			}
+
+			fmt.Printf("    • %s%s\n", formatServiceTypeForDisplay(models.ServiceType(service.Type)), reason)
+		}
+	}
+
+	// Show service categories
+	fmt.Printf("\n🎵 Streaming Services:\n")
+
+	streamingServices := serviceAvailability.GetStreamingServices()
+	availableCount := 0
+
+	for _, service := range streamingServices {
+		status := "❌"
+		if service.IsAvailable {
+			status = "✅"
+			availableCount++
+		}
+
+		fmt.Printf("    %s %s\n", status, formatServiceTypeForDisplay(models.ServiceType(service.Type)))
+	}
+
+	fmt.Printf("    Summary: %d/%d streaming services available\n", availableCount, len(streamingServices))
+
+	fmt.Printf("\n🔗 Local Input Services:\n")
+
+	localServices := serviceAvailability.GetLocalServices()
+	localAvailableCount := 0
+
+	for _, service := range localServices {
+		status := "❌"
+		if service.IsAvailable {
+			status = "✅"
+			localAvailableCount++
+		}
+
+		fmt.Printf("    %s %s\n", status, formatServiceTypeForDisplay(models.ServiceType(service.Type)))
+	}
+
+	fmt.Printf("    Summary: %d/%d local services available\n", localAvailableCount, len(localServices))
+
+	return nil
+}
+
+// compareSourcesAndAvailability compares configured sources with service availability
+func compareSourcesAndAvailability(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	PrintDeviceHeader("Comparing sources and service availability", clientConfig.Host, clientConfig.Port)
+
+	// Get both sources and service availability
+	sources, err := client.GetSources()
+	if err != nil {
+		return fmt.Errorf("failed to get sources: %w", err)
+	}
+
+	serviceAvailability, err := client.GetServiceAvailability()
+	if err != nil {
+		return fmt.Errorf("failed to get service availability: %w", err)
+	}
+
+	fmt.Printf("Source vs Availability Comparison:\n\n")
+
+	performSourceComparisons(sources, serviceAvailability)
+	printSourceSummary(sources, serviceAvailability)
+
+	return nil
+}
+
+// performSourceComparisons compares configured sources with availability
+func performSourceComparisons(sources *models.Sources, serviceAvailability *models.ServiceAvailability) {
+	// Check key services
+	comparisons := []struct {
+		name                 string
+		configuredCheck      func() bool
+		availableCheck       func() bool
+		getConfiguredSources func() []models.SourceItem
+	}{
+		{
+			"Spotify",
+			sources.HasSpotify,
+			serviceAvailability.HasSpotify,
+			sources.GetSpotifySources,
+		},
+		{
+			"Bluetooth",
+			sources.HasBluetooth,
+			serviceAvailability.HasBluetooth,
+			func() []models.SourceItem { return sources.GetSourcesByType("BLUETOOTH") },
+		},
+	}
+
+	for _, comp := range comparisons {
+		compareServiceStatus(comp.name, comp.configuredCheck(), comp.availableCheck(), serviceAvailability)
+	}
+}
+
+// compareServiceStatus compares a single service's configuration vs availability
+func compareServiceStatus(serviceName string, configured, available bool, serviceAvailability *models.ServiceAvailability) {
+	fmt.Printf("🔍 %s:\n", serviceName)
+	fmt.Printf("    Configured: %s\n", boolToStatus(configured))
+	fmt.Printf("    Available: %s\n", boolToStatus(available))
+
+	switch {
+	case available && !configured:
+		fmt.Printf("    💡 %s is available but not configured - consider setting it up\n", serviceName)
+	case configured && !available:
+		fmt.Printf("    ⚠️  %s is configured but not available - check device status\n", serviceName)
+		printServiceUnavailableReason(serviceName, serviceAvailability)
+	case configured && available:
+		fmt.Printf("    ✅ %s is properly configured and available\n", serviceName)
+	default:
+		fmt.Printf("    ➖ %s is neither configured nor available\n", serviceName)
+	}
+
+	fmt.Println()
+}
+
+// printServiceUnavailableReason prints the reason why a service is unavailable
+func printServiceUnavailableReason(serviceName string, serviceAvailability *models.ServiceAvailability) {
+	var service *models.Service
+
+	switch serviceName {
+	case "Spotify":
+		service = serviceAvailability.GetServiceByType(models.ServiceTypeSpotify)
+	case "Bluetooth":
+		service = serviceAvailability.GetServiceByType(models.ServiceTypeBluetooth)
+	}
+
+	if service != nil && service.Reason != "" {
+		fmt.Printf("    📝 Reason: %s\n", service.Reason)
+	}
+}
+
+// printSourceSummary prints a summary of sources and services
+func printSourceSummary(sources *models.Sources, serviceAvailability *models.ServiceAvailability) {
+	// Summary
+	fmt.Printf("📊 Summary:\n")
+	fmt.Printf("    Total configured sources: %d\n", sources.GetSourceCount())
+	fmt.Printf("    Ready configured sources: %d\n", sources.GetReadySourceCount())
+	fmt.Printf("    Total available services: %d\n", serviceAvailability.GetAvailableServiceCount())
+	fmt.Printf("    Total possible services: %d\n", serviceAvailability.GetServiceCount())
+}
+
+// boolToStatus converts boolean to user-friendly status
+func boolToStatus(b bool) string {
+	if b {
+		return "✅ Yes"
+	}
+
+	return "❌ No"
+}

cmd/soundtouch-cli/cmd_speaker.go

@@ -0,0 +1,217 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// playTTS plays a Text-To-Speech message on the speaker
+func playTTS(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	text := c.String("text")
+	appKey := c.String("app-key")
+	volume := c.Int("volume")
+	language := c.String("language")
+
+	if text == "" {
+		PrintError("Text message is required")
+		return fmt.Errorf("text message cannot be empty")
+	}
+
+	if appKey == "" {
+		PrintError("App key is required")
+		return fmt.Errorf("app key cannot be empty")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Playing TTS message: \"%s\"", text), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Create PlayInfo for TTS
+	var playInfo *models.PlayInfo
+	if volume > 0 {
+		playInfo = models.NewTTSPlayInfo(text, appKey, language, volume)
+	} else {
+		playInfo = models.NewTTSPlayInfo(text, appKey, language)
+	}
+
+	err = client.PlayCustom(playInfo)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to play TTS message: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ TTS message sent successfully\n")
+
+	if volume > 0 {
+		fmt.Printf("   Volume: %d\n", volume)
+	} else {
+		fmt.Printf("   Volume: current level\n")
+	}
+
+	fmt.Printf("   Language: %s\n", strings.ToUpper(language))
+	fmt.Printf("   Message: \"%s\"\n", text)
+
+	return nil
+}
+
+// playURL plays audio content from a URL on the speaker
+func playURL(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	urlStr := c.String("url")
+	appKey := c.String("app-key")
+	service := c.String("service")
+	message := c.String("message")
+	reason := c.String("reason")
+	volume := c.Int("volume")
+
+	if urlStr == "" {
+		PrintError("URL is required")
+		return fmt.Errorf("URL cannot be empty")
+	}
+
+	if appKey == "" {
+		PrintError("App key is required")
+		return fmt.Errorf("app key cannot be empty")
+	}
+
+	// Set defaults if not provided
+	if service == "" {
+		service = "URL Playback"
+	}
+
+	if message == "" {
+		message = "Audio Content"
+	}
+
+	if reason == "" {
+		// Extract filename or use URL as reason
+		if idx := strings.LastIndex(urlStr, "/"); idx != -1 && idx < len(urlStr)-1 {
+			reason = urlStr[idx+1:]
+		} else {
+			reason = urlStr
+		}
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Playing URL: %s", urlStr), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Create PlayInfo for URL content
+	var playInfo *models.PlayInfo
+	if volume > 0 {
+		playInfo = models.NewURLPlayInfo(urlStr, appKey, service, message, reason, volume)
+	} else {
+		playInfo = models.NewURLPlayInfo(urlStr, appKey, service, message, reason)
+	}
+
+	err = client.PlayCustom(playInfo)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to play URL content: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ URL playback started successfully\n")
+	fmt.Printf("   URL: %s\n", urlStr)
+	fmt.Printf("   Service: %s\n", service)
+	fmt.Printf("   Message: %s\n", message)
+
+	if volume > 0 {
+		fmt.Printf("   Volume: %d\n", volume)
+	} else {
+		fmt.Printf("   Volume: current level\n")
+	}
+
+	return nil
+}
+
+// playNotification plays a notification sound or a local file on the speaker
+func playNotification(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	path := c.String("path")
+
+	if path != "" {
+		PrintDeviceHeader(fmt.Sprintf("Playing notification file: %s", path), clientConfig.Host, clientConfig.Port)
+	} else {
+		PrintDeviceHeader("Playing notification beep", clientConfig.Host, clientConfig.Port)
+	}
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	err = client.PlayNotification(path)
+	if err != nil {
+		if path != "" {
+			PrintError(fmt.Sprintf("Failed to play notification file: %v", err))
+		} else {
+			PrintError(fmt.Sprintf("Failed to play notification beep: %v", err))
+		}
+
+		return err
+	}
+
+	if path != "" {
+		fmt.Printf("✅ Notification file sent successfully: %s\n", path)
+	} else {
+		fmt.Printf("✅ Notification beep played successfully\n")
+	}
+
+	return nil
+}
+
+// playNotificationBeep plays a notification beep on the speaker (uses existing endpoint)
+func playNotificationBeep(c *cli.Context) error {
+	return playNotification(c)
+}
+
+// showSpeakerHelp displays help information about speaker functionality
+func showSpeakerHelp(_ *cli.Context) error {
+	fmt.Println("SoundTouch Speaker Playback Commands")
+	fmt.Println("=====================================")
+	fmt.Println()
+	fmt.Println("The /speaker endpoint supports playing notifications and URL content:")
+	fmt.Println()
+	fmt.Println("• Text-to-Speech (TTS) Messages:")
+	fmt.Println("  Play spoken messages using Google TTS")
+	fmt.Println("  Example: soundtouch-cli speaker tts --text \"Hello World\" --app-key YOUR_KEY")
+	fmt.Println()
+	fmt.Println("• URL Content Playback:")
+	fmt.Println("  Play audio files from HTTP/HTTPS URLs")
+	fmt.Println("  Example: soundtouch-cli speaker url --url \"https://example.com/audio.mp3\" --app-key YOUR_KEY")
+	fmt.Println()
+	fmt.Println("• Notification Beep:")
+	fmt.Println("  Play a simple notification sound")
+	fmt.Println("  Example: soundtouch-cli speaker beep")
+	fmt.Println()
+	fmt.Println("• Custom Notification:")
+	fmt.Println("  Play a device-local PCM file as notification")
+	fmt.Println("  Example: soundtouch-cli speaker notify --path \"/opt/Bose/chimes/grouped.pcm\"")
+	fmt.Println()
+	fmt.Println("Notes:")
+	fmt.Println("• Only ST-10 (Series III) speakers support the /speaker endpoint")
+	fmt.Println("• ST-300 and other models may not support this functionality")
+	fmt.Println("• You need to provide your own app_key for TTS and URL playback")
+	fmt.Println("• Currently playing content is paused during playback and resumed after")
+	fmt.Println("• If device is a zone master, content plays on all zone members")
+	fmt.Println("• Volume is automatically restored after playback completes")
+	fmt.Println()
+	fmt.Println("Supported Languages for TTS:")
+	fmt.Println("EN (English), DE (German), ES (Spanish), FR (French), IT (Italian),")
+	fmt.Println("NL (Dutch), PT (Portuguese), RU (Russian), ZH (Chinese), JA (Japanese)")
+
+	return nil
+}

cmd/soundtouch-cli/cmd_station.go

@@ -0,0 +1,475 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/urfave/cli/v2"
+)
+
+// searchStations handles searching for stations across different sources
+func searchStations(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+	searchTerm := c.String("query")
+
+	if searchTerm == "" {
+		PrintError("Search query is required")
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Searching %s for: %s", source, searchTerm), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check service availability for the source
+	checker := NewServiceAvailabilityChecker(client)
+
+	actionDescription := fmt.Sprintf("search %s stations", source)
+	if !checker.CheckSourceAvailable(source, actionDescription) {
+		return fmt.Errorf("source '%s' is not available for station search", source)
+	}
+
+	response, err := client.SearchStation(source, sourceAccount, searchTerm)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to search stations: %v", err))
+		return err
+	}
+
+	printSearchResults(response, searchTerm)
+
+	return nil
+}
+
+// searchTuneIn handles searching TuneIn specifically
+func searchTuneIn(c *cli.Context) error {
+	searchTerm := c.String("query")
+
+	if searchTerm == "" {
+		PrintError("Search query is required")
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Searching TuneIn for: %s", searchTerm), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check TuneIn availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidateTuneInAvailable("search TuneIn stations") {
+		return fmt.Errorf("TuneIn is not available on this device")
+	}
+
+	response, err := client.SearchTuneInStations(searchTerm)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to search TuneIn: %v", err))
+		return err
+	}
+
+	printSearchResults(response, searchTerm)
+
+	return nil
+}
+
+// searchPandora handles searching Pandora specifically
+func searchPandora(c *cli.Context) error {
+	sourceAccount := c.String("source-account")
+	searchTerm := c.String("query")
+
+	if sourceAccount == "" {
+		PrintError("Pandora source account is required")
+		return fmt.Errorf("source account required for Pandora")
+	}
+
+	if searchTerm == "" {
+		PrintError("Search query is required")
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Searching Pandora for: %s", searchTerm), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check Pandora availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidatePandoraAvailable("search Pandora stations") {
+		return fmt.Errorf("pandora is not available on this device")
+	}
+
+	response, err := client.SearchPandoraStations(sourceAccount, searchTerm)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to search Pandora: %v", err))
+		return err
+	}
+
+	printSearchResults(response, searchTerm)
+
+	return nil
+}
+
+// searchSpotify handles searching Spotify specifically
+func searchSpotify(c *cli.Context) error {
+	sourceAccount := c.String("source-account")
+	searchTerm := c.String("query")
+
+	if sourceAccount == "" {
+		PrintError("Spotify source account is required")
+		return fmt.Errorf("source account required for Spotify")
+	}
+
+	if searchTerm == "" {
+		PrintError("Search query is required")
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Searching Spotify for: %s", searchTerm), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check Spotify availability
+	checker := NewServiceAvailabilityChecker(client)
+	if !checker.ValidateSpotifyAvailable("search Spotify content") {
+		return fmt.Errorf("spotify is not available on this device")
+	}
+
+	response, err := client.SearchSpotifyContent(sourceAccount, searchTerm)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to search Spotify: %v", err))
+		return err
+	}
+
+	printSearchResults(response, searchTerm)
+
+	return nil
+}
+
+// addStation handles adding a station and playing it immediately
+func addStation(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+	token := c.String("token")
+	name := c.String("name")
+
+	if source == "" {
+		PrintError("Source is required")
+		return fmt.Errorf("source cannot be empty")
+	}
+
+	if token == "" {
+		PrintError("Station token is required")
+		return fmt.Errorf("token cannot be empty")
+	}
+
+	if name == "" {
+		PrintError("Station name is required")
+		return fmt.Errorf("name cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Adding %s station: %s", source, name), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check service availability for the source
+	checker := NewServiceAvailabilityChecker(client)
+
+	actionDescription := fmt.Sprintf("add %s station", source)
+	if !checker.CheckSourceAvailable(source, actionDescription) {
+		return fmt.Errorf("source '%s' is not available for adding stations", source)
+	}
+
+	err = client.AddStation(source, sourceAccount, token, name)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to add station: %v", err))
+		return err
+	}
+
+	PrintSuccess(fmt.Sprintf("Added and started playing station: %s", name))
+
+	return nil
+}
+
+// removeStation handles removing a station from collections
+func removeStation(c *cli.Context) error {
+	source := c.String("source")
+	location := c.String("location")
+	itemType := c.String("type")
+	sourceAccount := c.String("source-account")
+
+	if source == "" {
+		PrintError("Source is required")
+		return fmt.Errorf("source cannot be empty")
+	}
+
+	if location == "" {
+		PrintError("Station location is required")
+		return fmt.Errorf("location cannot be empty")
+	}
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Removing %s station", source), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Create content item for the station to remove
+	contentItem := &models.ContentItem{
+		Source:        source,
+		Location:      location,
+		Type:          itemType,
+		SourceAccount: sourceAccount,
+	}
+
+	err = client.RemoveStation(contentItem)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to remove station: %v", err))
+		return err
+	}
+
+	PrintSuccess("Station removed successfully")
+
+	return nil
+}
+
+// printSearchResults formats and displays search results
+func printSearchResults(response *models.SearchStationResponse, searchTerm string) {
+	fmt.Printf("Search Results for '%s':\n", searchTerm)
+
+	if response.IsEmpty() {
+		fmt.Printf("  No results found\n")
+		return
+	}
+
+	fmt.Printf("  Total results: %d\n", response.GetResultCount())
+
+	// Group results by type for better display
+	songs := response.GetSongs()
+	artists := response.GetArtists()
+	stations := response.GetStations()
+
+	printSongs(songs)
+	printArtists(artists)
+	printStations(stations)
+	printSearchHints(response, songs, artists, stations)
+}
+
+// printSongs prints song search results
+func printSongs(songs []models.SearchResult) {
+	if len(songs) == 0 {
+		return
+	}
+
+	fmt.Printf("\n  🎵 Songs (%d):\n", len(songs))
+
+	for i := range songs {
+		song := &songs[i]
+		fmt.Printf("    %d. %s\n", i+1, song.GetDisplayName())
+
+		if song.Artist != "" {
+			fmt.Printf("       Artist: %s\n", song.Artist)
+		}
+
+		if song.Album != "" {
+			fmt.Printf("       Album: %s\n", song.Album)
+		}
+
+		if song.SourceAccount != "" {
+			fmt.Printf("       Account: %s\n", song.SourceAccount)
+		}
+
+		fmt.Printf("       Token: %s\n", song.Token)
+		fmt.Println()
+	}
+}
+
+// printArtists prints artist search results
+func printArtists(artists []models.SearchResult) {
+	if len(artists) == 0 {
+		return
+	}
+
+	fmt.Printf("  🎤 Artists (%d):\n", len(artists))
+
+	for i := range artists {
+		artist := &artists[i]
+		fmt.Printf("    %d. %s\n", i+1, artist.GetDisplayName())
+
+		if artist.SourceAccount != "" {
+			fmt.Printf("       Account: %s\n", artist.SourceAccount)
+		}
+
+		fmt.Printf("       Token: %s\n", artist.Token)
+		fmt.Println()
+	}
+}
+
+// printStations prints station search results
+func printStations(stations []models.SearchResult) {
+	if len(stations) == 0 {
+		return
+	}
+
+	fmt.Printf("  📻 Stations (%d):\n", len(stations))
+
+	for i := range stations {
+		station := &stations[i]
+		fmt.Printf("    %d. %s\n", i+1, station.GetDisplayName())
+
+		if station.SourceAccount != "" {
+			fmt.Printf("       Account: %s\n", station.SourceAccount)
+		}
+
+		fmt.Printf("       Token: %s\n", station.Token)
+
+		if station.Description != "" {
+			fmt.Printf("       Description: %s\n", station.Description)
+		}
+
+		fmt.Println()
+	}
+}
+
+// printSearchHints prints usage hints for search results
+func printSearchHints(response *models.SearchStationResponse, songs, artists, stations []models.SearchResult) {
+	fmt.Printf("💡 Usage hints:\n")
+	fmt.Printf("   • To add a station and play it: station add --source %s --token <token> --name <name>\n", response.Source)
+
+	if hasAccountResults(response) {
+		fmt.Printf("   • Include --source-account <account> when adding stations that require it\n")
+	}
+
+	if len(songs) > 0 || len(artists) > 0 || len(stations) > 0 {
+		fmt.Printf("   • Copy the token from results above to use with 'station add'\n")
+	}
+}
+
+// hasAccountResults checks if any results have source accounts
+func hasAccountResults(response *models.SearchStationResponse) bool {
+	allResults := response.GetAllResults()
+	for i := range allResults {
+		if allResults[i].SourceAccount != "" {
+			return true
+		}
+	}
+
+	return false
+}
+
+// listStations handles listing saved stations
+func listStations(c *cli.Context) error {
+	source := c.String("source")
+	sourceAccount := c.String("source-account")
+
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader(fmt.Sprintf("Getting %s stations", source), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	// Check service availability for the source
+	checker := NewServiceAvailabilityChecker(client)
+
+	actionDescription := fmt.Sprintf("list %s stations", source)
+	if !checker.CheckSourceAvailable(source, actionDescription) {
+		return fmt.Errorf("source '%s' is not available for listing stations", source)
+	}
+
+	var response *models.NavigateResponse
+
+	switch strings.ToUpper(source) {
+	case "TUNEIN":
+		response, err = client.GetTuneInStations(sourceAccount)
+	case "PANDORA":
+		if sourceAccount == "" {
+			PrintError("Pandora source account is required")
+			return fmt.Errorf("source account required for Pandora")
+		}
+
+		response, err = client.GetPandoraStations(sourceAccount)
+	default:
+		return fmt.Errorf("listing stations is not supported for source: %s", source)
+	}
+
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to get stations: %v", err))
+		return err
+	}
+
+	printStationList(response, source)
+
+	return nil
+}
+
+// printStationList formats and displays saved station results
+func printStationList(response *models.NavigateResponse, source string) {
+	fmt.Printf("Saved %s Stations:\n", source)
+
+	if response.TotalItems == 0 {
+		fmt.Printf("  No stations found\n")
+		return
+	}
+
+	stations := response.GetStations()
+	fmt.Printf("  Total stations: %d\n", response.TotalItems)
+	fmt.Printf("  Showing: %d\n\n", len(stations))
+
+	for i, station := range stations {
+		fmt.Printf("  %d. %s\n", i+1, station.Name)
+
+		if station.ContentItem != nil {
+			if station.ContentItem.Location != "" {
+				fmt.Printf("     Location: %s\n", station.ContentItem.Location)
+			}
+
+			if station.ContentItem.SourceAccount != "" {
+				fmt.Printf("     Account: %s\n", station.ContentItem.SourceAccount)
+			}
+
+			if station.ContentItem.IsPresetable {
+				fmt.Printf("     Can be saved as preset: Yes\n")
+			}
+		}
+
+		if station.Type != "" {
+			fmt.Printf("     Type: %s\n", station.Type)
+		}
+
+		fmt.Println()
+	}
+
+	// Show usage hints
+	fmt.Printf("💡 Usage hints:\n")
+	fmt.Printf("   • To play a station: Use the location value with 'play content' command\n")
+	fmt.Printf("   • To save as preset: Use 'preset set' command with the location\n")
+}

cmd/soundtouch-cli/cmd_token.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+)
+
+// requestToken requests a new bearer token from the device
+func requestToken(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	PrintDeviceHeader("Requesting bearer token", clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	token, err := client.RequestToken()
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to request token: %v", err))
+		return err
+	}
+
+	fmt.Println("Bearer Token Information:")
+
+	if token.IsValid() {
+		fmt.Printf("  Status: Valid\n")
+		fmt.Printf("  Token: %s\n", token.String())
+		fmt.Printf("  Full value: %s\n", token.GetToken())
+		fmt.Printf("  Authorization header: %s\n", token.GetAuthHeader())
+
+		// Display token without Bearer prefix for API usage
+		fmt.Println("\nFor API Usage:")
+		fmt.Printf("  Raw token: %s\n", token.GetTokenWithoutPrefix())
+
+		// Usage instructions
+		fmt.Println("\nUsage Instructions:")
+		fmt.Println("  • Use the 'Authorization header' value in HTTP Authorization headers")
+		fmt.Println("  • Use the 'Raw token' value when an API requires token without 'Bearer ' prefix")
+		fmt.Println("  • Tokens are generated per request and may have expiration times")
+
+		// Security notice
+		fmt.Println("\nSecurity Notice:")
+		fmt.Println("  • Store tokens securely and avoid logging them in plain text")
+		fmt.Println("  • Tokens provide authentication - treat them as passwords")
+		fmt.Println("  • Request new tokens when needed rather than reusing old ones")
+	} else {
+		fmt.Printf("  Status: Invalid\n")
+		fmt.Printf("  Raw response: %s\n", token.GetToken())
+		PrintError("Received invalid bearer token from device")
+	}
+
+	return nil
+}

cmd/soundtouch-cli/cmd_tunein.go

@@ -0,0 +1,152 @@
+// Package main — `soundtouch-cli source tunein` subcommand.
+//
+// Convenience shortcut for the verbose `source content --source TUNEIN
+// --type … --location …` pattern. Picks the right Type + location template
+// from the TuneIn guide-ID prefix, optionally fetches name + artwork from
+// TuneIn's describe endpoint, then calls the same SelectContentItem path
+// the generic `source content` command uses.
+//
+// Implements #226.
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/gesellix/bose-soundtouch/pkg/service/bmx"
+	"github.com/urfave/cli/v2"
+)
+
+// tuneInKind captures the three guide-ID shapes the SoundTouch firmware
+// distinguishes; each picks a different Bose `/v1/playback/...` location
+// template and a different ContentItem Type.
+type tuneInKind struct {
+	flag      string // CLI flag name (`station`, `episode`, `program`)
+	prefix    string // single-letter guide-ID prefix (`s`, `e`, `p`)
+	location  string // printf template, %s = guide ID
+	itemType  string // ContentItem.Type the speaker expects
+	humanName string // user-facing kind label for log lines
+}
+
+var tuneInKinds = []tuneInKind{
+	{flag: "station", prefix: "s", location: "/v1/playback/station/%s", itemType: "stationurl", humanName: "live station"},
+	{flag: "episode", prefix: "e", location: "/v1/playback/episode/%s", itemType: "stationurl", humanName: "podcast episode"},
+	{flag: "program", prefix: "p", location: "/v1/playback/episodes/%s", itemType: "tracklisturl", humanName: "podcast program"},
+}
+
+// resolveTuneInKind picks a kind from the CLI flags. Exactly one of
+// --station / --episode / --program must be set, OR --id with a prefix we
+// recognise. Returns the kind plus the bare guide ID.
+func resolveTuneInKind(c *cli.Context) (*tuneInKind, string, error) {
+	// Explicit kind flags take precedence over --id.
+	var picked *tuneInKind
+
+	var id string
+
+	for i, k := range tuneInKinds {
+		v := c.String(k.flag)
+		if v == "" {
+			continue
+		}
+
+		if picked != nil {
+			return nil, "", fmt.Errorf("only one of --station, --episode, --program may be set")
+		}
+
+		picked = &tuneInKinds[i]
+		id = v
+	}
+
+	if picked != nil {
+		return picked, strings.TrimSpace(id), nil
+	}
+
+	// Fall back to --id with prefix auto-detect.
+	raw := strings.TrimSpace(c.String("id"))
+	if raw == "" {
+		return nil, "", fmt.Errorf("one of --station, --episode, --program, or --id is required")
+	}
+
+	if raw == "" {
+		return nil, "", fmt.Errorf("--id is empty")
+	}
+
+	for i, k := range tuneInKinds {
+		if strings.HasPrefix(raw, k.prefix) {
+			return &tuneInKinds[i], raw, nil
+		}
+	}
+
+	return nil, "", fmt.Errorf("--id %q has no recognised TuneIn prefix; use --station/--episode/--program explicitly", raw)
+}
+
+// playTuneIn is the action wired into `soundtouch-cli source tunein`.
+func playTuneIn(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		return err
+	}
+
+	kind, id, err := resolveTuneInKind(c)
+	if err != nil {
+		return err
+	}
+
+	name := c.String("name")
+	artwork := c.String("artwork")
+
+	// Optional metadata enrichment — only fetch if the user hasn't already
+	// supplied both, and they haven't asked us to skip it.
+	if !c.Bool("no-lookup") && (name == "" || artwork == "") {
+		fetchedName, fetchedLogo, lookupErr := bmx.TuneInDescribeMeta(id)
+		if lookupErr != nil {
+			// Non-fatal: the speaker can resolve the title itself; just
+			// note the failure so an operator sees what went wrong.
+			fmt.Printf("  Note: TuneIn describe lookup failed (%v); proceeding without enrichment.\n", lookupErr)
+		} else {
+			if name == "" {
+				name = fetchedName
+			}
+
+			if artwork == "" {
+				artwork = fetchedLogo
+			}
+		}
+	}
+
+	if name == "" {
+		// Fall back to a sensible non-empty default so the speaker's
+		// now-playing UI doesn't show a blank source label.
+		name = "TuneIn"
+	}
+
+	contentItem := &models.ContentItem{
+		Source:       "TUNEIN",
+		Type:         kind.itemType,
+		Location:     fmt.Sprintf(kind.location, id),
+		ItemName:     name,
+		ContainerArt: artwork,
+		IsPresetable: true,
+	}
+
+	PrintDeviceHeader("Playing TuneIn "+kind.humanName, clientConfig.Host, clientConfig.Port)
+	fmt.Printf("  ID:       %s\n", id)
+	fmt.Printf("  Location: %s\n", contentItem.Location)
+	fmt.Printf("  Type:     %s\n", contentItem.Type)
+	fmt.Printf("  Name:     %s\n", contentItem.ItemName)
+
+	if contentItem.ContainerArt != "" {
+		fmt.Printf("  Artwork:  %s\n", contentItem.ContainerArt)
+	}
+
+	if err := client.SelectContentItem(contentItem); err != nil {
+		return fmt.Errorf("failed to select TuneIn content: %w", err)
+	}
+
+	PrintSuccess("TuneIn content selected")
+
+	return nil
+}

cmd/soundtouch-cli/cmd_tunein_test.go

@@ -0,0 +1,157 @@
+package main
+
+import (
+	"flag"
+	"strings"
+	"testing"
+
+	"github.com/urfave/cli/v2"
+)
+
+// newCtx wires a *cli.Context with the kind-selection flags the resolver
+// reads, plus whatever values the test wants set. Empty-string values are
+// the default (flag not provided).
+func newCtx(t *testing.T, kv map[string]string) *cli.Context {
+	t.Helper()
+
+	fs := flag.NewFlagSet("test", flag.ContinueOnError)
+	for _, name := range []string{"station", "episode", "program", "id"} {
+		fs.String(name, "", "")
+	}
+
+	for k, v := range kv {
+		if err := fs.Set(k, v); err != nil {
+			t.Fatalf("fs.Set(%q, %q): %v", k, v, err)
+		}
+	}
+
+	return cli.NewContext(nil, fs, nil)
+}
+
+func TestResolveTuneInKind_Station(t *testing.T) {
+	c := newCtx(t, map[string]string{"station": "s14991"})
+
+	k, id, err := resolveTuneInKind(c)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if k.flag != "station" || k.itemType != "stationurl" {
+		t.Errorf("wrong kind: %+v", k)
+	}
+
+	if id != "s14991" {
+		t.Errorf("wrong id: %q", id)
+	}
+}
+
+func TestResolveTuneInKind_Episode(t *testing.T) {
+	c := newCtx(t, map[string]string{"episode": "e789012"})
+
+	k, id, err := resolveTuneInKind(c)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if k.flag != "episode" || k.itemType != "stationurl" {
+		t.Errorf("wrong kind: %+v", k)
+	}
+
+	if id != "e789012" {
+		t.Errorf("wrong id: %q", id)
+	}
+
+	if !strings.Contains(k.location, "/v1/playback/episode/") {
+		t.Errorf("wrong location template: %q", k.location)
+	}
+}
+
+func TestResolveTuneInKind_Program(t *testing.T) {
+	c := newCtx(t, map[string]string{"program": "p123456"})
+
+	k, id, err := resolveTuneInKind(c)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if k.flag != "program" || k.itemType != "tracklisturl" {
+		t.Errorf("wrong kind: %+v", k)
+	}
+
+	if id != "p123456" {
+		t.Errorf("wrong id: %q", id)
+	}
+
+	if !strings.Contains(k.location, "/v1/playback/episodes/") {
+		t.Errorf("wrong location template: %q", k.location)
+	}
+}
+
+func TestResolveTuneInKind_IDPrefixAutoDetect(t *testing.T) {
+	cases := []struct {
+		id       string
+		wantFlag string
+	}{
+		{"s14991", "station"},
+		{"e789012", "episode"},
+		{"p123456", "program"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.id, func(t *testing.T) {
+			c := newCtx(t, map[string]string{"id": tc.id})
+
+			k, id, err := resolveTuneInKind(c)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if k.flag != tc.wantFlag {
+				t.Errorf("auto-detect picked %q; want %q", k.flag, tc.wantFlag)
+			}
+
+			if id != tc.id {
+				t.Errorf("id round-tripped wrong: got %q want %q", id, tc.id)
+			}
+		})
+	}
+}
+
+func TestResolveTuneInKind_NoFlags(t *testing.T) {
+	c := newCtx(t, nil)
+
+	_, _, err := resolveTuneInKind(c)
+	if err == nil {
+		t.Fatal("expected error when no flags are set")
+	}
+
+	if !strings.Contains(err.Error(), "required") {
+		t.Errorf("error message should mention required flag: %v", err)
+	}
+}
+
+func TestResolveTuneInKind_ConflictingFlags(t *testing.T) {
+	c := newCtx(t, map[string]string{"station": "s14991", "episode": "e789012"})
+
+	_, _, err := resolveTuneInKind(c)
+	if err == nil {
+		t.Fatal("expected error when conflicting flags are set")
+	}
+
+	if !strings.Contains(err.Error(), "only one of") {
+		t.Errorf("error message should mention exclusivity: %v", err)
+	}
+}
+
+func TestResolveTuneInKind_UnknownPrefix(t *testing.T) {
+	c := newCtx(t, map[string]string{"id": "x999"})
+
+	_, _, err := resolveTuneInKind(c)
+	if err == nil {
+		t.Fatal("expected error for unknown ID prefix")
+	}
+
+	if !strings.Contains(err.Error(), "no recognised TuneIn prefix") {
+		t.Errorf("error message should explain prefix mismatch: %v", err)
+	}
+}

cmd/soundtouch-cli/cmd_zone_slave.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+)
+
+// addZoneSlave adds a device to an existing zone using the official /addZoneSlave endpoint
+func addZoneSlave(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	masterID := c.String("master")
+	slaveID := c.String("slave")
+	slaveIP := c.String("slave-ip")
+
+	if masterID == "" {
+		return fmt.Errorf("master device ID is required (use --master)")
+	}
+
+	if slaveID == "" {
+		return fmt.Errorf("slave device ID is required (use --slave)")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Adding slave '%s' to zone master '%s'", slaveID, masterID), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	if slaveIP != "" {
+		err = client.AddZoneSlave(masterID, slaveID, slaveIP)
+	} else {
+		err = client.AddZoneSlaveByDeviceID(masterID, slaveID)
+	}
+
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to add zone slave: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Successfully added device '%s' to zone master '%s'\n", slaveID, masterID)
+
+	if slaveIP != "" {
+		fmt.Printf("   Slave IP: %s\n", slaveIP)
+	}
+
+	return nil
+}
+
+// removeZoneSlave removes a device from an existing zone using the official /removeZoneSlave endpoint
+func removeZoneSlave(c *cli.Context) error {
+	clientConfig := GetClientConfig(c)
+	masterID := c.String("master")
+	slaveID := c.String("slave")
+	slaveIP := c.String("slave-ip")
+
+	if masterID == "" {
+		return fmt.Errorf("master device ID is required (use --master)")
+	}
+
+	if slaveID == "" {
+		return fmt.Errorf("slave device ID is required (use --slave)")
+	}
+
+	PrintDeviceHeader(fmt.Sprintf("Removing slave '%s' from zone master '%s'", slaveID, masterID), clientConfig.Host, clientConfig.Port)
+
+	client, err := CreateSoundTouchClient(clientConfig)
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to create client: %v", err))
+		return err
+	}
+
+	if slaveIP != "" {
+		err = client.RemoveZoneSlave(masterID, slaveID, slaveIP)
+	} else {
+		err = client.RemoveZoneSlaveByDeviceID(masterID, slaveID)
+	}
+
+	if err != nil {
+		PrintError(fmt.Sprintf("Failed to remove zone slave: %v", err))
+		return err
+	}
+
+	fmt.Printf("✅ Successfully removed device '%s' from zone master '%s'\n", slaveID, masterID)
+
+	if slaveIP != "" {
+		fmt.Printf("   Slave IP: %s\n", slaveIP)
+	}
+
+	return nil
+}

cmd/soundtouch-cli/common.go

@@ -1,8 +1,14 @@
 package main
 
 import (
+	"encoding/base64"
 	"fmt"
+	"html"
+	"io"
 	"net"
+	"net/http"
+	"os"
+	"regexp"
 	"runtime"
 	"strconv"
 	"strings"
@@ -133,6 +139,182 @@ func PrintDeviceHeader(operation, host string, port int) {
 	fmt.Printf("%s from %s:%d...\n", operation, host, port)
 }
 
+// resolveLocation converts potential URLs to SoundTouch locations
+func resolveLocation(source, location string) (string, string) {
+	// If it's not a URL, return as is
+	if !strings.HasPrefix(location, "http://") && !strings.HasPrefix(location, "https://") {
+		return source, location
+	}
+
+	// TuneIn URL conversion
+	// Example: https://tunein.com/radio/WDR-2-Rheinland-1004-s213886/
+	if strings.Contains(location, "tunein.com/radio/") {
+		trimmed := strings.TrimSuffix(location, "/")
+
+		parts := strings.Split(trimmed, "-")
+		if len(parts) > 0 {
+			lastPart := parts[len(parts)-1]
+			if strings.HasPrefix(lastPart, "s") {
+				return "TUNEIN", "/v1/playback/station/" + lastPart
+			}
+		}
+		// Fallback for URLs like https://tunein.com/radio/s213886/
+		parts = strings.Split(trimmed, "/")
+
+		lastPart := parts[len(parts)-1]
+		if strings.HasPrefix(lastPart, "s") {
+			return "TUNEIN", "/v1/playback/station/" + lastPart
+		}
+	}
+
+	// Spotify URL conversion
+	// Example: https://open.spotify.com/album/7F50uh7oGitmAEScRKV6pD?si=YhDPWL9LRGO5whz1wLsteA
+	if strings.Contains(location, "open.spotify.com/") {
+		re := regexp.MustCompile(`https://open\.spotify\.com/([^/]+)/([^?]+)`)
+
+		matches := re.FindStringSubmatch(location)
+		if len(matches) >= 3 {
+			contentType := matches[1]
+			contentID := matches[2]
+			uri := fmt.Sprintf("spotify:%s:%s", contentType, contentID)
+			encodedURI := base64.StdEncoding.EncodeToString([]byte(uri))
+
+			return "SPOTIFY", "/playback/container/" + encodedURI
+		}
+	}
+
+	return source, location
+}
+
+type Metadata struct {
+	Name    string
+	Artwork string
+}
+
+var httpClient = &http.Client{
+	Timeout: 5 * time.Second,
+}
+
+func fetchTuneInMetadata(url string) (*Metadata, error) {
+	if !strings.Contains(url, "tunein.com/radio/") && !strings.Contains(url, "127.0.0.1") && !strings.Contains(url, "localhost") {
+		return nil, fmt.Errorf("url is not a TuneIn radio URL")
+	}
+
+	resp, err := httpClient.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1024*100)) // Limit to 100KB
+	if err != nil {
+		return nil, err
+	}
+
+	rawHTML := string(body)
+	metadata := &Metadata{}
+
+	// Simple extraction of og:title and og:image
+	// Example: <meta data-react-helmet="true" property="og:title" content="WDR 2 Rheinland, 100.4 FM, Köln | Free Internet Radio | TuneIn"/>
+	// Example: <meta data-react-helmet="true" property="og:image" content="https://cdn-radiotime-logos.tunein.com/s213886g.png"/>
+
+	titlePrefix := `property="og:title" content="`
+	if idx := strings.Index(rawHTML, titlePrefix); idx != -1 {
+		start := idx + len(titlePrefix)
+
+		end := strings.Index(rawHTML[start:], `"`)
+		if end != -1 {
+			title := html.UnescapeString(rawHTML[start : start+end])
+			// Clean up title (remove ", 100.4 FM, Köln | Free Internet Radio | TuneIn")
+			if pipeIdx := strings.Index(title, " | "); pipeIdx != -1 {
+				title = title[:pipeIdx]
+			}
+
+			if commaIdx := strings.Index(title, ", "); commaIdx != -1 {
+				title = title[:commaIdx]
+			}
+
+			metadata.Name = title
+		}
+	}
+
+	imagePrefix := `property="og:image" content="`
+	if idx := strings.Index(rawHTML, imagePrefix); idx != -1 {
+		start := idx + len(imagePrefix)
+
+		end := strings.Index(rawHTML[start:], `"`)
+		if end != -1 {
+			metadata.Artwork = rawHTML[start : start+end]
+		}
+	}
+
+	return metadata, nil
+}
+
+func fetchSpotifyMetadata(url string) (*Metadata, error) {
+	if !strings.Contains(url, "open.spotify.com/") && !strings.Contains(url, "127.0.0.1") && !strings.Contains(url, "localhost") {
+		return nil, fmt.Errorf("url is not a Spotify URL")
+	}
+
+	resp, err := httpClient.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1024*200)) // Spotify pages can be larger
+	if err != nil {
+		return nil, err
+	}
+
+	rawHTML := string(body)
+	metadata := &Metadata{}
+
+	// Simple extraction of og:title and og:image
+	// Example: <meta property="og:title" content="Terminal Caribe - Album by Santi &amp; Tuğçe | Spotify"
+
+	titlePrefix := `property="og:title" content="`
+	if idx := strings.Index(rawHTML, titlePrefix); idx != -1 {
+		start := idx + len(titlePrefix)
+
+		end := strings.Index(rawHTML[start:], `"`)
+		if end != -1 {
+			title := html.UnescapeString(rawHTML[start : start+end])
+			// Clean up title (remove " | Spotify")
+			if pipeIdx := strings.Index(title, " | "); pipeIdx != -1 {
+				title = title[:pipeIdx]
+			}
+
+			// Spotify often has "- Album by ..." or "- Playlist by ..."
+			// We might want to keep it or clean it up.
+			// User's TuneIn example cleaned it up.
+			// For now let's just keep what Spotify provides as title minus the " | Spotify" part.
+
+			metadata.Name = title
+		}
+	}
+
+	imagePrefix := `property="og:image" content="`
+	if idx := strings.Index(rawHTML, imagePrefix); idx != -1 {
+		start := idx + len(imagePrefix)
+
+		end := strings.Index(rawHTML[start:], `"`)
+		if end != -1 {
+			metadata.Artwork = rawHTML[start : start+end]
+		}
+	}
+
+	return metadata, nil
+}
+
 // PrintSuccess prints a standard success message
 func PrintSuccess(message string) {
 	fmt.Printf("✓ %s\n", message)
@@ -150,7 +332,7 @@ func PrintWarning(message string) {
 
 // showVersionInfo displays detailed version information including build details
 func showVersionInfo(_ *cli.Context) error {
-	fmt.Printf("soundtouch-cli version %s\n", version)
+	fmt.Printf("%s version %s\n", os.Args[0], version)
 	fmt.Printf("Build commit: %s\n", commit)
 	fmt.Printf("Build date: %s\n", date)
 	fmt.Printf("Go version: %s\n", runtime.Version())

cmd/soundtouch-cli/common_test.go

@@ -0,0 +1,206 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestFetchTuneInMetadata(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		html := `
+<!doctype html>
+<html>
+<head>
+    <meta property="og:title" content="WDR 2 Rheinland, 100.4 FM, Köln | Free Internet Radio | TuneIn"/>
+    <meta property="og:image" content="https://cdn-radiotime-logos.tunein.com/s213886g.png"/>
+</head>
+<body></body>
+</html>
+`
+
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(html))
+	}))
+	defer ts.Close()
+
+	// Temporarily override httpClient to use test server
+	oldClient := httpClient
+	httpClient = ts.Client()
+
+	defer func() { httpClient = oldClient }()
+
+	metadata, err := fetchTuneInMetadata(ts.URL + "/radio/WDR-2-Rheinland-1004-s213886/")
+	if err != nil {
+		t.Fatalf("fetchTuneInMetadata() error = %v", err)
+	}
+
+	if metadata == nil {
+		t.Fatal("fetchTuneInMetadata() returned nil metadata")
+	} else {
+		expectedName := "WDR 2 Rheinland"
+		if metadata.Name != expectedName {
+			t.Errorf("metadata.Name = %v, want %v", metadata.Name, expectedName)
+		}
+
+		expectedArtwork := "https://cdn-radiotime-logos.tunein.com/s213886g.png"
+		if metadata.Artwork != expectedArtwork {
+			t.Errorf("metadata.Artwork = %v, want %v", metadata.Artwork, expectedArtwork)
+		}
+	}
+}
+
+func TestResolveLocation(t *testing.T) {
+	tests := []struct {
+		name             string
+		source           string
+		location         string
+		expectedSource   string
+		expectedLocation string
+	}{
+		{
+			name:             "Plain location",
+			source:           "TUNEIN",
+			location:         "/v1/playback/station/s213886",
+			expectedSource:   "TUNEIN",
+			expectedLocation: "/v1/playback/station/s213886",
+		},
+		{
+			name:             "TuneIn URL",
+			source:           "",
+			location:         "https://tunein.com/radio/WDR-2-Rheinland-1004-s213886/",
+			expectedSource:   "TUNEIN",
+			expectedLocation: "/v1/playback/station/s213886",
+		},
+		{
+			name:             "TuneIn URL with source",
+			source:           "SOMETHING",
+			location:         "https://tunein.com/radio/WDR-2-Rheinland-1004-s213886/",
+			expectedSource:   "TUNEIN",
+			expectedLocation: "/v1/playback/station/s213886",
+		},
+		{
+			name:             "TuneIn URL without trailing slash",
+			source:           "",
+			location:         "https://tunein.com/radio/WDR-2-Rheinland-1004-s213886",
+			expectedSource:   "TUNEIN",
+			expectedLocation: "/v1/playback/station/s213886",
+		},
+		{
+			name:             "Non-TuneIn URL",
+			source:           "OTHER",
+			location:         "https://example.com/radio/s123",
+			expectedSource:   "OTHER",
+			expectedLocation: "https://example.com/radio/s123",
+		},
+		{
+			name:             "TuneIn URL short form",
+			source:           "",
+			location:         "https://tunein.com/radio/s213886/",
+			expectedSource:   "TUNEIN",
+			expectedLocation: "/v1/playback/station/s213886",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotSource, gotLocation := resolveLocation(tt.source, tt.location)
+			if gotSource != tt.expectedSource {
+				t.Errorf("resolveLocation() gotSource = %v, want %v", gotSource, tt.expectedSource)
+			}
+
+			if gotLocation != tt.expectedLocation {
+				t.Errorf("resolveLocation() gotLocation = %v, want %v", gotLocation, tt.expectedLocation)
+			}
+		})
+	}
+}
+
+func TestResolveLocationSpotify(t *testing.T) {
+	tests := []struct {
+		name             string
+		source           string
+		location         string
+		expectedSource   string
+		expectedLocation string
+	}{
+		{
+			name:             "Spotify album URL",
+			source:           "",
+			location:         "https://open.spotify.com/album/6rT8yer84xoh0t17poLsmn?si=XqxdZazpTLC1ceoC8EeCuA",
+			expectedSource:   "SPOTIFY",
+			expectedLocation: "/playback/container/c3BvdGlmeTphbGJ1bTo2clQ4eWVyODR4b2gwdDE3cG9Mc21u",
+		},
+		{
+			name:             "Spotify playlist URL",
+			source:           "",
+			location:         "https://open.spotify.com/playlist/37i9dQZF1DX0XUsuxWHRQd",
+			expectedSource:   "SPOTIFY",
+			expectedLocation: "/playback/container/c3BvdGlmeTpwbGF5bGlzdDozN2k5ZFFaRjFEWDBYVXN1eFdIUlFk",
+		},
+		{
+			name:             "Spotify track URL",
+			source:           "",
+			location:         "https://open.spotify.com/track/17GmwQ9Q3MTAz05OokmNNB?si=123",
+			expectedSource:   "SPOTIFY",
+			expectedLocation: "/playback/container/c3BvdGlmeTp0cmFjazoxN0dtd1E5UTNNVEF6MDVPb2ttTk5C",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotSource, gotLocation := resolveLocation(tt.source, tt.location)
+			if gotSource != tt.expectedSource {
+				t.Errorf("resolveLocation() gotSource = %v, want %v", gotSource, tt.expectedSource)
+			}
+
+			if gotLocation != tt.expectedLocation {
+				t.Errorf("resolveLocation() gotLocation = %v, want %v", gotLocation, tt.expectedLocation)
+			}
+		})
+	}
+}
+
+func TestFetchSpotifyMetadata(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		html := `
+<!doctype html>
+<html>
+<head>
+    <meta property="og:title" content="Terminal Caribe - Album by Santi &amp; Tuğçe | Spotify"/>
+    <meta property="og:image" content="https://i.scdn.co/image/ab67616d0000b273f0e55478f4a15182405bcb47"/>
+</head>
+<body></body>
+</html>
+`
+
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(html))
+	}))
+	defer ts.Close()
+
+	// Temporarily override httpClient to use test server
+	oldClient := httpClient
+	httpClient = ts.Client()
+
+	defer func() { httpClient = oldClient }()
+
+	metadata, err := fetchSpotifyMetadata(ts.URL + "/album/7F50uh7oGitmAEScRKV6pD")
+	if err != nil {
+		t.Fatalf("fetchSpotifyMetadata() error = %v", err)
+	}
+
+	if metadata == nil {
+		t.Fatal("fetchSpotifyMetadata() returned nil metadata")
+	} else {
+		expectedName := "Terminal Caribe - Album by Santi & Tuğçe"
+		if metadata.Name != expectedName {
+			t.Errorf("metadata.Name = %v, want %v", metadata.Name, expectedName)
+		}
+
+		expectedArtwork := "https://i.scdn.co/image/ab67616d0000b273f0e55478f4a15182405bcb47"
+		if metadata.Artwork != expectedArtwork {
+			t.Errorf("metadata.Artwork = %v, want %v", metadata.Artwork, expectedArtwork)
+		}
+	}
+}

cmd/soundtouch-cli/main_test.go

@@ -14,16 +14,16 @@ func TestParseHostPort(t *testing.T) {
 	}{
 		{
 			name:        "IPv4 with port",
-			input:       "192.168.1.10:8090",
+			input:       "192.0.2.10:8090",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8090,
 		},
 		{
 			name:        "IPv4 without port",
-			input:       "192.168.1.10",
+			input:       "192.0.2.10",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8080,
 		},
 		{
@@ -63,30 +63,30 @@ func TestParseHostPort(t *testing.T) {
 		},
 		{
 			name:        "invalid port - non-numeric",
-			input:       "192.168.1.10:abc",
+			input:       "192.0.2.10:abc",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8080,
 		},
 		{
 			name:        "invalid port - too high",
-			input:       "192.168.1.10:99999",
+			input:       "192.0.2.10:99999",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8080,
 		},
 		{
 			name:        "invalid port - zero",
-			input:       "192.168.1.10:0",
+			input:       "192.0.2.10:0",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8080,
 		},
 		{
 			name:        "invalid port - negative",
-			input:       "192.168.1.10:-123",
+			input:       "192.0.2.10:-123",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8080,
 		},
 		{
@@ -105,37 +105,37 @@ func TestParseHostPort(t *testing.T) {
 		},
 		{
 			name:        "multiple colons - malformed",
-			input:       "192.168.1.100:8090:extra",
+			input:       "192.0.2.100:8090:extra",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.100:8090:extra",
+			wantHost:    "192.0.2.100:8090:extra",
 			wantPort:    8080,
 		},
 		{
 			name:        "standard SoundTouch default",
-			input:       "192.168.1.10",
+			input:       "192.0.2.10",
 			defaultPort: 8090,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8090,
 		},
 		{
 			name:        "valid high port",
-			input:       "192.168.1.100:65535",
+			input:       "192.0.2.100:65535",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.100",
+			wantHost:    "192.0.2.100",
 			wantPort:    65535,
 		},
 		{
 			name:        "valid low port",
-			input:       "192.168.1.100:1",
+			input:       "192.0.2.100:1",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.100",
+			wantHost:    "192.0.2.100",
 			wantPort:    1,
 		},
 		{
 			name:        "real SoundTouch device example",
-			input:       "192.168.1.10:8090",
+			input:       "192.0.2.10:8090",
 			defaultPort: 8080,
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8090,
 		},
 		{
@@ -166,8 +166,8 @@ func BenchmarkParseHostPort(b *testing.B) {
 		name  string
 		input string
 	}{
-		{"with_port", "192.168.1.100:8090"},
-		{"without_port", "192.168.1.100"},
+		{"with_port", "192.0.2.100:8090"},
+		{"without_port", "192.0.2.100"},
 		{"hostname_with_port", "soundtouch.local:8090"},
 		{"ipv6_with_port", "[::1]:8090"},
 	}
@@ -193,26 +193,26 @@ func TestParseHostPortSoundTouchScenarios(t *testing.T) {
 	}{
 		{
 			name:        "typical_cli_usage",
-			input:       "192.168.1.10:8091",
+			input:       "192.0.2.10:8091",
 			defaultPort: 8090,
 			description: "User specifies full host:port",
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8091,
 		},
 		{
 			name:        "discovery_result_host_only",
-			input:       "192.168.1.10",
+			input:       "192.0.2.10",
 			defaultPort: 8090,
 			description: "Discovery returns IP, CLI uses default port",
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8090,
 		},
 		{
 			name:        "custom_port_override",
-			input:       "192.168.1.100:9000",
+			input:       "192.0.2.100:9000",
 			defaultPort: 8090,
 			description: "User overrides default SoundTouch port",
-			wantHost:    "192.168.1.100",
+			wantHost:    "192.0.2.100",
 			wantPort:    9000,
 		},
 		{
@@ -225,10 +225,10 @@ func TestParseHostPortSoundTouchScenarios(t *testing.T) {
 		},
 		{
 			name:        "invalid_port_fallback",
-			input:       "192.168.1.10:invalid",
+			input:       "192.0.2.10:invalid",
 			defaultPort: 8090,
 			description: "Malformed port should fallback to default",
-			wantHost:    "192.168.1.10",
+			wantHost:    "192.0.2.10",
 			wantPort:    8090,
 		},
 	}

cmd/soundtouch-cli/serviceavailability.go

@@ -0,0 +1,390 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+// ServiceAvailabilityChecker provides service availability validation for CLI commands
+type ServiceAvailabilityChecker struct {
+	client                *client.Client
+	serviceAvailability   *models.ServiceAvailability
+	skipAvailabilityCheck bool
+	cached                bool
+}
+
+// NewServiceAvailabilityChecker creates a new service availability checker
+func NewServiceAvailabilityChecker(client *client.Client) *ServiceAvailabilityChecker {
+	skipCheck := os.Getenv("SOUNDTOUCH_SKIP_AVAILABILITY_CHECK") == "true" ||
+		os.Getenv("SOUNDTOUCH_SKIP_AVAILABILITY_CHECK") == "1"
+
+	return &ServiceAvailabilityChecker{
+		client:                client,
+		skipAvailabilityCheck: skipCheck,
+		cached:                false,
+	}
+}
+
+// loadServiceAvailability loads service availability data (cached after first call)
+func (sac *ServiceAvailabilityChecker) loadServiceAvailability() {
+	if sac.cached {
+		return
+	}
+
+	if sac.skipAvailabilityCheck {
+		// Create a mock availability that allows everything
+		sac.serviceAvailability = &models.ServiceAvailability{}
+		sac.cached = true
+
+		return
+	}
+
+	serviceAvailability, err := sac.client.GetServiceAvailability()
+	if err != nil {
+		// If availability check fails, warn but don't fail the command
+		PrintWarning(fmt.Sprintf("Could not check service availability: %v", err))
+
+		if !sac.skipAvailabilityCheck {
+			PrintWarning("Command will proceed without availability validation")
+			PrintWarning("Set SOUNDTOUCH_SKIP_AVAILABILITY_CHECK=true to disable these checks")
+		}
+		// Create empty availability to prevent further errors
+		sac.serviceAvailability = &models.ServiceAvailability{}
+		sac.cached = true
+
+		return
+	}
+
+	sac.serviceAvailability = serviceAvailability
+	sac.cached = true
+}
+
+// CheckServiceAvailable validates if a service is available and provides user feedback
+func (sac *ServiceAvailabilityChecker) CheckServiceAvailable(serviceType models.ServiceType, actionDescription string) bool {
+	if sac.skipAvailabilityCheck {
+		return true
+	}
+
+	sac.loadServiceAvailability()
+
+	// If we couldn't load availability data, allow the operation
+	if sac.serviceAvailability == nil || sac.serviceAvailability.Services == nil {
+		return true
+	}
+
+	if sac.serviceAvailability.IsServiceAvailable(serviceType) {
+		return true
+	}
+
+	// Service is not available - provide helpful feedback
+	serviceName := formatServiceTypeForDisplay(serviceType)
+	PrintError(fmt.Sprintf("Cannot %s: %s service is not available", actionDescription, serviceName))
+
+	// Get specific reason if available
+	service := sac.serviceAvailability.GetServiceByType(serviceType)
+	if service != nil && service.Reason != "" {
+		PrintError(fmt.Sprintf("Reason: %s", service.Reason))
+	}
+
+	// Provide troubleshooting hints
+	sac.provideTroubleshootingHints(serviceType)
+
+	// Suggest alternatives
+	sac.suggestAlternatives(serviceType, actionDescription)
+
+	PrintWarning("To bypass this check, set SOUNDTOUCH_SKIP_AVAILABILITY_CHECK=true")
+
+	return false
+}
+
+// CheckSourceAvailable validates if a source string corresponds to an available service
+func (sac *ServiceAvailabilityChecker) CheckSourceAvailable(source, actionDescription string) bool {
+	if sac.skipAvailabilityCheck {
+		return true
+	}
+
+	serviceType := sourceToServiceType(source)
+	if serviceType == "" {
+		// Unknown source type, allow it (might be a valid source not in our list)
+		return true
+	}
+
+	return sac.CheckServiceAvailable(serviceType, actionDescription)
+}
+
+// ValidateSpotifyAvailable checks Spotify availability for Spotify-specific operations
+func (sac *ServiceAvailabilityChecker) ValidateSpotifyAvailable(actionDescription string) bool {
+	return sac.CheckServiceAvailable(models.ServiceTypeSpotify, actionDescription)
+}
+
+// ValidateBluetoothAvailable checks Bluetooth availability for Bluetooth operations
+func (sac *ServiceAvailabilityChecker) ValidateBluetoothAvailable(actionDescription string) bool {
+	return sac.CheckServiceAvailable(models.ServiceTypeBluetooth, actionDescription)
+}
+
+// ValidateTuneInAvailable checks TuneIn availability for radio operations
+func (sac *ServiceAvailabilityChecker) ValidateTuneInAvailable(actionDescription string) bool {
+	return sac.CheckServiceAvailable(models.ServiceTypeTuneIn, actionDescription)
+}
+
+// ValidatePandoraAvailable checks Pandora availability for Pandora operations
+func (sac *ServiceAvailabilityChecker) ValidatePandoraAvailable(actionDescription string) bool {
+	return sac.CheckServiceAvailable(models.ServiceTypePandora, actionDescription)
+}
+
+// GetAvailableStreamingServices returns a list of available streaming services for user feedback
+func (sac *ServiceAvailabilityChecker) GetAvailableStreamingServices() []string {
+	if sac.skipAvailabilityCheck {
+		return []string{"All services (availability check disabled)"}
+	}
+
+	sac.loadServiceAvailability()
+
+	if sac.serviceAvailability == nil || sac.serviceAvailability.Services == nil {
+		return []string{"Unable to determine available services"}
+	}
+
+	streamingServices := sac.serviceAvailability.GetStreamingServices()
+
+	var available []string
+
+	for _, service := range streamingServices {
+		if service.IsAvailable {
+			available = append(available, formatServiceTypeForDisplay(models.ServiceType(service.Type)))
+		}
+	}
+
+	if len(available) == 0 {
+		return []string{"No streaming services currently available"}
+	}
+
+	return available
+}
+
+// GetAvailableLocalServices returns a list of available local input services
+func (sac *ServiceAvailabilityChecker) GetAvailableLocalServices() []string {
+	if sac.skipAvailabilityCheck {
+		return []string{"All services (availability check disabled)"}
+	}
+
+	sac.loadServiceAvailability()
+
+	if sac.serviceAvailability == nil || sac.serviceAvailability.Services == nil {
+		return []string{"Unable to determine available services"}
+	}
+
+	localServices := sac.serviceAvailability.GetLocalServices()
+
+	var available []string
+
+	for _, service := range localServices {
+		if service.IsAvailable {
+			available = append(available, formatServiceTypeForDisplay(models.ServiceType(service.Type)))
+		}
+	}
+
+	if len(available) == 0 {
+		return []string{"No local input services currently available"}
+	}
+
+	return available
+}
+
+// provideTroubleshootingHints provides specific troubleshooting advice based on service type
+func (sac *ServiceAvailabilityChecker) provideTroubleshootingHints(serviceType models.ServiceType) {
+	switch serviceType {
+	case models.ServiceTypeBluetooth:
+		PrintWarning("💡 Bluetooth troubleshooting:")
+		PrintWarning("   • Check if your device supports Bluetooth audio input")
+		PrintWarning("   • Ensure Bluetooth is enabled on the SoundTouch device")
+		PrintWarning("   • Try restarting the device")
+
+	case models.ServiceTypeSpotify:
+		PrintWarning("💡 Spotify troubleshooting:")
+		PrintWarning("   • Ensure you have a Spotify Premium account")
+		PrintWarning("   • Check if you're logged in to Spotify on the device")
+		PrintWarning("   • Verify your network connection")
+
+	case models.ServiceTypeAirPlay:
+		PrintWarning("💡 AirPlay troubleshooting:")
+		PrintWarning("   • Ensure your Apple device and SoundTouch are on the same network")
+		PrintWarning("   • Check that AirPlay is enabled in device settings")
+		PrintWarning("   • Verify network connectivity")
+
+	case models.ServiceTypeAlexa:
+		PrintWarning("💡 Alexa troubleshooting:")
+		PrintWarning("   • Check if Amazon Alexa is properly configured")
+		PrintWarning("   • Ensure the device is connected to your Amazon account")
+		PrintWarning("   • Verify internet connectivity")
+
+	case models.ServiceTypeTuneIn:
+		PrintWarning("💡 TuneIn troubleshooting:")
+		PrintWarning("   • Check internet connectivity")
+		PrintWarning("   • Verify the device can access external streaming services")
+
+	case models.ServiceTypePandora:
+		PrintWarning("💡 Pandora troubleshooting:")
+		PrintWarning("   • Ensure you have a valid Pandora account")
+		PrintWarning("   • Check if you're logged in to Pandora on the device")
+		PrintWarning("   • Verify internet connectivity")
+	}
+}
+
+// suggestAlternatives suggests alternative services when the requested one is unavailable
+func (sac *ServiceAvailabilityChecker) suggestAlternatives(serviceType models.ServiceType, _ string) {
+	if sac.serviceAvailability == nil {
+		return
+	}
+
+	switch serviceType {
+	case models.ServiceTypeSpotify:
+		if sac.serviceAvailability.HasTuneIn() {
+			PrintWarning("💡 Alternative: TuneIn Radio is available for music streaming")
+		}
+
+		if sac.serviceAvailability.HasPandora() {
+			PrintWarning("💡 Alternative: Pandora is available for music streaming")
+		}
+
+	case models.ServiceTypeBluetooth:
+		if sac.serviceAvailability.HasAirPlay() {
+			PrintWarning("💡 Alternative: AirPlay is available for wireless audio")
+		}
+
+		if sac.serviceAvailability.HasLocalMusic() {
+			PrintWarning("💡 Alternative: Local Music Library is available")
+		}
+
+	case models.ServiceTypeTuneIn:
+		if sac.serviceAvailability.HasSpotify() {
+			PrintWarning("💡 Alternative: Spotify is available for music streaming")
+		}
+
+		if sac.serviceAvailability.HasPandora() {
+			PrintWarning("💡 Alternative: Pandora is available for music streaming")
+		}
+	}
+
+	// Show all available streaming services as suggestions
+	available := sac.GetAvailableStreamingServices()
+	if len(available) > 0 && available[0] != "No streaming services currently available" {
+		PrintWarning(fmt.Sprintf("💡 Available streaming services: %s", strings.Join(available, ", ")))
+	}
+}
+
+// sourceToServiceType maps source strings to service types
+func sourceToServiceType(source string) models.ServiceType {
+	switch strings.ToUpper(source) {
+	case "SPOTIFY":
+		return models.ServiceTypeSpotify
+	case "BLUETOOTH":
+		return models.ServiceTypeBluetooth
+	case "AIRPLAY":
+		return models.ServiceTypeAirPlay
+	case "ALEXA":
+		return models.ServiceTypeAlexa
+	case "AMAZON":
+		return models.ServiceTypeAmazon
+	case "PANDORA":
+		return models.ServiceTypePandora
+	case "TUNEIN":
+		return models.ServiceTypeTuneIn
+	case "DEEZER":
+		return models.ServiceTypeDeezer
+	case "IHEART", "IHEARTRADIO":
+		return models.ServiceTypeIHeart
+	case "LOCAL_INTERNET_RADIO":
+		return models.ServiceTypeLocalInternetRadio
+	case "LOCAL_MUSIC":
+		return models.ServiceTypeLocalMusic
+	case "BMX":
+		return models.ServiceTypeBMX
+	case "NOTIFICATION":
+		return models.ServiceTypeNotification
+	default:
+		return ""
+	}
+}
+
+// formatServiceTypeForDisplay formats service types for user-friendly display
+func formatServiceTypeForDisplay(serviceType models.ServiceType) string {
+	switch serviceType {
+	case models.ServiceTypeSpotify:
+		return "Spotify"
+	case models.ServiceTypeBluetooth:
+		return "Bluetooth"
+	case models.ServiceTypeAirPlay:
+		return "AirPlay"
+	case models.ServiceTypeAlexa:
+		return "Amazon Alexa"
+	case models.ServiceTypeAmazon:
+		return "Amazon Music"
+	case models.ServiceTypePandora:
+		return "Pandora"
+	case models.ServiceTypeTuneIn:
+		return "TuneIn Radio"
+	case models.ServiceTypeDeezer:
+		return "Deezer"
+	case models.ServiceTypeIHeart:
+		return "iHeartRadio"
+	case models.ServiceTypeLocalInternetRadio:
+		return "Internet Radio"
+	case models.ServiceTypeLocalMusic:
+		return "Local Music Library"
+	case models.ServiceTypeBMX:
+		return "BMX"
+	case models.ServiceTypeNotification:
+		return "Notifications"
+	default:
+		return string(serviceType)
+	}
+}
+
+// PrintServiceAvailabilitySummary prints a summary of available services
+func (sac *ServiceAvailabilityChecker) PrintServiceAvailabilitySummary() {
+	if sac.skipAvailabilityCheck {
+		PrintWarning("Service availability checking is disabled")
+		return
+	}
+
+	sac.loadServiceAvailability()
+
+	if sac.serviceAvailability == nil || sac.serviceAvailability.Services == nil {
+		PrintWarning("Unable to determine service availability")
+		return
+	}
+
+	fmt.Printf("📊 Service Availability Summary:\n")
+	fmt.Printf("   Total services: %d\n", sac.serviceAvailability.GetServiceCount())
+	fmt.Printf("   Available: %d\n", sac.serviceAvailability.GetAvailableServiceCount())
+	fmt.Printf("   Unavailable: %d\n", sac.serviceAvailability.GetUnavailableServiceCount())
+
+	// Show quick status for popular services
+	fmt.Printf("   Popular services:\n")
+
+	popularChecks := []struct {
+		check func() bool
+		name  string
+	}{
+		{sac.serviceAvailability.HasSpotify, "Spotify"},
+		{sac.serviceAvailability.HasBluetooth, "Bluetooth"},
+		{sac.serviceAvailability.HasAirPlay, "AirPlay"},
+		{sac.serviceAvailability.HasTuneIn, "TuneIn Radio"},
+		{sac.serviceAvailability.HasPandora, "Pandora"},
+	}
+
+	for _, check := range popularChecks {
+		status := "❌"
+		if check.check() {
+			status = "✅"
+		}
+
+		fmt.Printf("     %s %s\n", status, check.name)
+	}
+
+	fmt.Printf("💡 Use 'soundtouch-cli sources list' to see configured sources\n")
+}

cmd/soundtouch-service/main_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
+)
+
+func TestApplyPersistedSettings(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "main-test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	ds := datastore.NewDataStore(tmpDir)
+
+	t.Run("overrides true with false", func(t *testing.T) {
+		config := &serviceConfig{
+			redact:  true,
+			logBody: true,
+			record:  true,
+		}
+
+		// Simulate the bug by using the old bitwise OR logic in the test,
+		// which should fail if we expect false.
+		// config.redact = config.redact || false -> stays true
+
+		settings := datastore.Settings{
+			RedactLogs:         false,
+			LogBodies:          false,
+			RecordInteractions: false,
+		}
+		err := ds.SaveSettings(settings)
+		if err != nil {
+			t.Fatalf("Failed to save settings: %v", err)
+		}
+
+		applyPersistedSettings(ds, config)
+
+		if config.redact != false {
+			t.Errorf("Expected redact to be false, got true")
+		}
+		if config.logBody != false {
+			t.Errorf("Expected logBody to be false, got true")
+		}
+		if config.record != false {
+			t.Errorf("Expected record to be false, got true")
+		}
+	})
+
+	t.Run("retains false when settings are false", func(t *testing.T) {
+		settings := datastore.Settings{
+			RedactLogs: false,
+		}
+		err := ds.SaveSettings(settings)
+		if err != nil {
+			t.Fatalf("Failed to save settings: %v", err)
+		}
+
+		config := &serviceConfig{
+			redact: false,
+		}
+
+		applyPersistedSettings(ds, config)
+
+		if config.redact != false {
+			t.Errorf("Expected redact to be false, got true")
+		}
+	})
+
+	t.Run("overrides false with true", func(t *testing.T) {
+		settings := datastore.Settings{
+			RedactLogs: true,
+		}
+		err := ds.SaveSettings(settings)
+		if err != nil {
+			t.Fatalf("Failed to save settings: %v", err)
+		}
+
+		config := &serviceConfig{
+			redact: false,
+		}
+
+		applyPersistedSettings(ds, config)
+
+		if config.redact != true {
+			t.Errorf("Expected redact to be true, got false")
+		}
+	})
+}

cmd/soundtouch-service/router_test.go

@@ -0,0 +1,159 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/service/datastore"
+	"github.com/gesellix/bose-soundtouch/pkg/service/handlers"
+	"github.com/go-chi/chi/v5"
+)
+
+func TestPrintRoutes(t *testing.T) {
+	// Initialize a minimal server to get the router
+	server := handlers.NewServer(nil, nil, "http://localhost:8000", true, true, true)
+	r := setupRouter(server, nil)
+
+	var routes []string
+	walkFunc := func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error {
+		route = strings.ReplaceAll(route, "/*/", "/")
+		handlerName := runtime.FuncForPC(reflect.ValueOf(handler).Pointer()).Name()
+		// Clean up the handler name (remove package path)
+		// For example, "github.com/gesellix/bose-soundtouch/cmd/soundtouch-service.setupRouter.func1"
+		// or "command-line-arguments.setupRouter.func1"
+		// or "main.setupRouter.func1"
+		parts := strings.Split(handlerName, "/")
+		if len(parts) > 0 {
+			handlerName = parts[len(parts)-1]
+		}
+		// Now we might have "soundtouch-service.setupRouter.func1"
+		// or "command-line-arguments.setupRouter.func1"
+		// or "main.setupRouter.func1"
+		// Let's remove the first part if it's a known varying package name
+		if idx := strings.Index(handlerName, "setupRouter"); idx != -1 {
+			handlerName = handlerName[idx:]
+		}
+		// In case it's not setupRouter but still has a package prefix
+		for {
+			dotIdx := strings.Index(handlerName, ".")
+			if dotIdx == -1 {
+				break
+			}
+			prefix := handlerName[:dotIdx]
+			if prefix == "main" || prefix == "command-line-arguments" || strings.Contains(prefix, "soundtouch-service") {
+				handlerName = handlerName[dotIdx+1:]
+			} else {
+				break
+			}
+		}
+
+		// Also remove any ".funcN" suffix if it's an anonymous function
+		if idx := strings.Index(handlerName, ".func"); idx != -1 {
+			handlerName = handlerName[:idx]
+		}
+
+		routes = append(routes, fmt.Sprintf("%-8s %-60s %s", method, route, handlerName))
+		return nil
+	}
+
+	if err := chi.Walk(r, walkFunc); err != nil {
+		t.Fatalf("Failed to walk routes: %v", err)
+	}
+
+	sort.Strings(routes)
+
+	output := strings.Join(routes, "\n") + "\n"
+
+	// Define snapshot path
+	snapshotPath := "testdata/router_routes.txt"
+	actualPath := "testdata/router_routes.actual.txt"
+
+	// Always write the current (actual) routes to a file
+	if err := os.WriteFile(actualPath, []byte(output), 0644); err != nil {
+		t.Fatalf("Failed to write actual routes: %v", err)
+	}
+
+	// Check if snapshot exists
+	if _, err := os.Stat(snapshotPath); os.IsNotExist(err) {
+		// Create testdata directory if it doesn't exist
+		if err := os.MkdirAll("testdata", 0755); err != nil {
+			t.Fatalf("Failed to create testdata directory: %v", err)
+		}
+		// Initial snapshot creation
+		if err := os.WriteFile(snapshotPath, []byte(output), 0644); err != nil {
+			t.Fatalf("Failed to write snapshot: %v", err)
+		}
+		t.Logf("Initial snapshot created at %s", snapshotPath)
+		return
+	}
+
+	// Read existing snapshot
+	existingOutput, err := os.ReadFile(snapshotPath)
+	if err != nil {
+		t.Fatalf("Failed to read snapshot: %v", err)
+	}
+
+	if string(existingOutput) != output {
+		t.Errorf("Router routes changed! Diff the snapshot at %s with %s", snapshotPath, actualPath)
+	}
+}
+
+// TestPUTRenameRoutesToLocalHandler reproduces the runtime routing
+// behaviour the user saw on their deployed v0.80.0: a PUT to
+// /streaming/account/{a}/device/{d} should land on
+// HandleMargeUpdateDevice, not fall through to the [UNHANDLED]
+// proxy. The handlers-package test (TestIssue285_*) uses a simplified
+// router that doesn't have the overlapping `/device` and
+// `/device/{device}` route groups, so it can't catch a chi radix-
+// tree resolution that prefers the more-specific subrouter.
+//
+// This test exercises the actual production setupRouter so a
+// regression in the route topology is caught against the same chi
+// behaviour speakers will see.
+func TestPUTRenameRoutesToLocalHandler(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "router-rename-")
+	if err != nil {
+		t.Fatalf("mkdir temp: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	ds := datastore.NewDataStore(tempDir)
+	_ = ds.Initialize()
+
+	server := handlers.NewServer(ds, nil, "http://localhost:8000", false, false, false)
+	r := setupRouter(server, nil)
+	ts := httptest.NewServer(r)
+	defer ts.Close()
+
+	body := `<?xml version="1.0" encoding="UTF-8" ?><device deviceid="AABBCCDDEEFF"><name>Living Room SoundTouch</name><macaddress>AABBCCDDEEFF</macaddress></device>`
+
+	req, err := http.NewRequest(http.MethodPut,
+		ts.URL+"/streaming/account/1111111/device/AABBCCDDEEFF",
+		strings.NewReader(body))
+	if err != nil {
+		t.Fatalf("build request: %v", err)
+	}
+
+	req.Header.Set("Content-Type", "application/xml")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("PUT: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	// 200 means our local HandleMargeUpdateDevice handled it.
+	// 401 / 502 / anything else means the request fell through to
+	// the [UNHANDLED] proxy and got the upstream response — which
+	// is exactly the failure mode #285 was supposed to fix.
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("PUT status = %d, want 200 (local handler). Anything else means the request fell through to [UNHANDLED] proxy — chi is routing to a different subrouter than the PUT registration intended.", resp.StatusCode)
+	}
+}

cmd/soundtouch-service/testdata/.gitignore

@@ -0,0 +1 @@
+*.actual.txt

cmd/soundtouch-service/testdata/router_routes.txt

@@ -0,0 +1,173 @@
+CONNECT  /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+CONNECT  /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+DELETE   /accounts/{account}/devices/{device}                         handlers.(*Server).HandleMargeRemoveDevice-fm
+DELETE   /accounts/{account}/group/{groupId}                          handlers.(*Server).HandleMargeDeleteGroup-fm
+DELETE   /bmx/tunein/v1/favorite/{stationID}                          handlers.(*Server).HandleTuneInDeleteFavorite-fm
+DELETE   /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+DELETE   /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+DELETE   /setup/devices/{deviceId}                                    handlers.(*Server).HandleRemoveDevice-fm
+DELETE   /setup/dns-discoveries                                       handlers.(*Server).HandleClearDNSDiscoveries-fm
+DELETE   /setup/interactions/sessions                                 handlers.(*Server).HandleCleanupSessions-fm
+DELETE   /setup/interactions/sessions/{session}                       handlers.(*Server).HandleDeleteSession-fm
+DELETE   /streaming/account/{account}/device/{device}                 handlers.(*Server).HandleMargeRemoveDevice-fm
+DELETE   /streaming/account/{account}/device/{device}/preset/{presetNumber} handlers.(*Server).HandleMargeRemovePreset-fm
+DELETE   /streaming/account/{account}/group/{groupId}                 handlers.(*Server).HandleMargeDeleteGroup-fm
+GET      /                                                            handlers.(*Server).HandleRoot-fm
+GET      /accounts/{account}/devices                                  handlers.(*Server).HandleMargeAccountDevices-fm
+GET      /accounts/{account}/devices/{device}/group                   handlers.(*Server).HandleMargeDeviceGroup-fm
+GET      /accounts/{account}/devices/{device}/group/                  handlers.(*Server).HandleMargeDeviceGroup-fm
+GET      /accounts/{account}/devices/{device}/group/member            handlers.(*Server).HandleMargeDeviceGroupMember-fm
+GET      /accounts/{account}/devices/{device}/group/server            handlers.(*Server).HandleMargeDeviceGroupServer-fm
+GET      /accounts/{account}/devices/{device}/presets                 handlers.(*Server).HandleMargePresets-fm
+GET      /accounts/{account}/devices/{device}/recents                 handlers.(*Server).HandleMargeRecents-fm
+GET      /accounts/{account}/full                                     handlers.(*Server).HandleMargeAccountFull-fm
+GET      /accounts/{account}/sources                                  handlers.(*Server).HandleMargeAccountSources-fm
+GET      /bmx-icons/*                                                 handlers.(*Server).HandleBmxIcons
+GET      /bmx/registry/v1/services                                    handlers.(*Server).HandleBMXRegistry-fm
+GET      /bmx/registry/v1/servicesAvailability                        handlers.(*Server).HandleBMXServicesAvailability-fm
+GET      /bmx/tunein/v1/navigate                                      handlers.(*Server).HandleTuneInNavigate-fm
+GET      /bmx/tunein/v1/navigate/*                                    handlers.(*Server).HandleTuneInNavigate-fm
+GET      /bmx/tunein/v1/playback/episode/{podcastID}                  handlers.(*Server).HandleTuneInPlaybackPodcast-fm
+GET      /bmx/tunein/v1/playback/episodes/{podcastID}                 handlers.(*Server).HandleTuneInPodcastInfo-fm
+GET      /bmx/tunein/v1/playback/station/{stationID}                  handlers.(*Server).HandleTuneInPlayback-fm
+GET      /bmx/tunein/v1/search                                        handlers.(*Server).HandleTuneInSearch-fm
+GET      /ced/*                                                       handlers.(*Server).HandleCedStatic
+GET      /core02/svc-bmx-adapter-orion/prod/orion/station             handlers.(*Server).HandleOrionPlayback-fm
+GET      /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+GET      /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+GET      /custom/v1/playback/{encodedURL}                             handlers.(*Server).HandleCustomPlayback-fm
+GET      /customer/account/{account}                                  handlers.(*Server).HandleMargeAccountProfile-fm
+GET      /docs/*                                                      handlers.(*Server).HandleDocs-fm
+GET      /favicon.ico                                                 setupRouter
+GET      /health                                                      handlers.(*Server).HandleHealth-fm
+GET      /media/*                                                     handlers.(*Server).HandleMedia
+GET      /media/aftertouch-ding.wav                                   handlers.(*Server).HandleDing-fm
+GET      /mgmt/accounts/                                              handlers.(*Server).HandleMgmtListAccounts-fm
+GET      /mgmt/accounts/{accountId}                                   handlers.(*Server).HandleMgmtAccountDetails-fm
+GET      /mgmt/accounts/{accountId}/speakers                          handlers.(*Server).HandleMgmtListSpeakers-fm
+GET      /mgmt/amazon/accounts                                        handlers.(*Server).HandleMgmtAmazonAccounts-fm
+GET      /mgmt/amazon/callback                                        handlers.(*Server).HandleMgmtAmazonCallback-fm
+GET      /mgmt/amazon/token                                           handlers.(*Server).HandleMgmtAmazonToken-fm
+GET      /mgmt/devices/{deviceId}/events                              handlers.(*Server).HandleMgmtDeviceEvents-fm
+GET      /mgmt/spotify/accounts                                       handlers.(*Server).HandleMgmtSpotifyAccounts-fm
+GET      /mgmt/spotify/callback                                       handlers.(*Server).HandleMgmtSpotifyCallback-fm
+GET      /mgmt/spotify/token                                          handlers.(*Server).HandleMgmtSpotifyToken-fm
+GET      /setup/account-id-suggestions/{deviceId}                     handlers.(*Server).HandleAccountIDSuggestions-fm
+GET      /setup/ca.crt                                                handlers.(*Server).HandleGetCACert-fm
+GET      /setup/device-summary/{deviceId}                             handlers.(*Server).HandleDeviceSummary-fm
+GET      /setup/devices                                               handlers.(*Server).HandleListDiscoveredDevices-fm
+GET      /setup/devices/{deviceId}/events                             handlers.(*Server).HandleGetDeviceEvents-fm
+GET      /setup/discovery-status                                      handlers.(*Server).HandleGetDiscoveryStatus-fm
+GET      /setup/dns-discoveries                                       handlers.(*Server).HandleGetDNSDiscoveries-fm
+GET      /setup/dns-discoveries/download                              handlers.(*Server).HandleDownloadDNSDiscoveries-fm
+GET      /setup/export/diagnostic                                     handlers.(*Server).HandleExportDiagnostic-fm
+GET      /setup/health                                                handlers.(*Server).HandleHealthChecks-fm
+GET      /setup/info/{deviceId}                                       handlers.(*Server).HandleGetDeviceInfo-fm
+GET      /setup/interaction-content                                   handlers.(*Server).HandleGetInteractionContent-fm
+GET      /setup/interaction-stats                                     handlers.(*Server).HandleGetInteractionStats-fm
+GET      /setup/interactions                                          handlers.(*Server).HandleListInteractions-fm
+GET      /setup/interactions/sessions/{session}/download              handlers.(*Server).HandleDownloadSession-fm
+GET      /setup/logging-settings                                      handlers.(*Server).HandleGetLoggingSettings-fm
+GET      /setup/logs                                                  handlers.(*Server).HandleGetLogs-fm
+GET      /setup/settings                                              handlers.(*Server).HandleGetSettings-fm
+GET      /setup/summary/{deviceId}                                    handlers.(*Server).HandleGetMigrationSummary-fm
+GET      /setup/version                                               handlers.(*Server).HandleGetVersionInfo-fm
+GET      /streaming/account/{account}/device/{device}/group           handlers.(*Server).HandleMargeDeviceGroup-fm
+GET      /streaming/account/{account}/device/{device}/group/          handlers.(*Server).HandleMargeDeviceGroup-fm
+GET      /streaming/account/{account}/device/{device}/group/member    handlers.(*Server).HandleMargeDeviceGroupMember-fm
+GET      /streaming/account/{account}/device/{device}/group/server    handlers.(*Server).HandleMargeDeviceGroupServer-fm
+GET      /streaming/account/{account}/device/{device}/presets         handlers.(*Server).HandleMargePresets-fm
+GET      /streaming/account/{account}/device/{device}/recent          handlers.(*Server).HandleMargeRecents-fm
+GET      /streaming/account/{account}/device/{device}/recents         handlers.(*Server).HandleMargeRecents-fm
+GET      /streaming/account/{account}/devices                         handlers.(*Server).HandleMargeAccountDevices-fm
+GET      /streaming/account/{account}/emailaddress                    handlers.(*Server).HandleMargeGetEmailAddress-fm
+GET      /streaming/account/{account}/full                            handlers.(*Server).HandleMargeAccountFull-fm
+GET      /streaming/account/{account}/presets                         handlers.(*Server).HandleMargeAccountPresets-fm
+GET      /streaming/account/{account}/presets/all                     handlers.(*Server).HandleMargeAccountPresets-fm
+GET      /streaming/account/{account}/provider_settings               handlers.(*Server).HandleMargeProviderSettings-fm
+GET      /streaming/account/{account}/sources                         handlers.(*Server).HandleMargeAccountSources-fm
+GET      /streaming/device/{device}/streaming_token                   handlers.(*Server).HandleMargeStreamingToken-fm
+GET      /streaming/device_setting/account/{account}/device/{device}/device_settings handlers.(*Server).HandleMargeGetDeviceSettings-fm
+GET      /streaming/resources/api_versions.xml                        handlers.(*Server).HandleMargeAPIVersions-fm
+GET      /streaming/software/update/account/{account}                 handlers.(*Server).HandleMargeSoftwareUpdate-fm
+GET      /streaming/sourceproviders                                   handlers.(*Server).HandleMargeSourceProviders-fm
+GET      /updates/soundtouch                                          handlers.(*Server).HandleMargeSoftwareUpdate-fm
+GET      /v1/blacklist/{deviceId}                                     setupRouter
+GET      /web/*                                                       setupRouter.(*Server).HandleWeb
+HEAD     /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+HEAD     /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+OPTIONS  /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+OPTIONS  /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+PATCH    /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+PATCH    /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+POST     /accounts/{account}/devices                                  handlers.(*Server).HandleMargeAddDevice-fm
+POST     /accounts/{account}/devices/{device}/presets/{presetNumber}  handlers.(*Server).HandleMargeUpdatePreset-fm
+POST     /accounts/{account}/devices/{device}/recents                 handlers.(*Server).HandleMargeAddRecent-fm
+POST     /accounts/{account}/group                                    handlers.(*Server).HandleMargeAddGroup-fm
+POST     /accounts/{account}/group/                                   handlers.(*Server).HandleMargeAddGroup-fm
+POST     /accounts/{account}/group/{groupId}                          handlers.(*Server).HandleMargeModifyGroup-fm
+POST     /alexa/certificate                                           handlers.(*Server).HandleAlexaCertificate-fm
+POST     /bmx/tunein/v1/favorite/{stationID}                          handlers.(*Server).HandleTuneInFavorite-fm
+POST     /bmx/tunein/v1/report                                        handlers.(*Server).HandleTuneInReport-fm
+POST     /bmx/tunein/v1/token                                         handlers.(*Server).HandleTuneInToken-fm
+POST     /core02/svc-bmx-adapter-orion/prod/orion/token               handlers.(*Server).HandleOrionToken-fm
+POST     /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+POST     /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+POST     /customer/account/{account}                                  handlers.(*Server).HandleMargeUpdateAccountProfile-fm
+POST     /customer/account/{account}/password                         handlers.(*Server).HandleMargeChangePassword-fm
+POST     /mgmt/accounts/{accountId}/language                          handlers.(*Server).HandleMgmtUpdateAccountLanguage-fm
+POST     /mgmt/accounts/{accountId}/provider-settings                 handlers.(*Server).HandleMgmtUpdateAccountProviderSetting-fm
+POST     /mgmt/amazon/confirm                                         handlers.(*Server).HandleMgmtAmazonConfirm-fm
+POST     /mgmt/amazon/init                                            handlers.(*Server).HandleMgmtAmazonInit-fm
+POST     /mgmt/amazon/prime                                           handlers.(*Server).HandleMgmtPrimeDeviceAmazon-fm
+POST     /mgmt/spotify/confirm                                        handlers.(*Server).HandleMgmtSpotifyConfirm-fm
+POST     /mgmt/spotify/entity                                         handlers.(*Server).HandleMgmtSpotifyEntity-fm
+POST     /mgmt/spotify/init                                           handlers.(*Server).HandleMgmtSpotifyInit-fm
+POST     /mgmt/spotify/prime                                          handlers.(*Server).HandleMgmtPrimeDevice-fm
+POST     /oauth/account/{account}/music/musicprovider/{sourceID}/token/cs handlers.(*Server).HandleBoseAccountToken-fm
+POST     /oauth/device/{deviceID}/music/musicprovider/{sourceID}/token handlers.(*Server).HandleBoseLegacyToken-fm
+POST     /oauth/device/{deviceID}/music/musicprovider/{sourceID}/token/cs1 handlers.(*Server).HandleBoseToken-fm
+POST     /oauth/device/{deviceID}/music/musicprovider/{sourceID}/token/cs3 handlers.(*Server).HandleBoseToken-fm
+POST     /setup/backup/{deviceId}                                     handlers.(*Server).HandleBackupConfig-fm
+POST     /setup/devices                                               handlers.(*Server).HandleAddManualDevice-fm
+POST     /setup/discover                                              handlers.(*Server).HandleTriggerDiscovery-fm
+POST     /setup/ensure-remote-services/{deviceId}                     handlers.(*Server).HandleEnsureRemoteServices-fm
+POST     /setup/health/fix                                            handlers.(*Server).HandleHealthFix-fm
+POST     /setup/logging-settings                                      handlers.(*Server).HandleUpdateLoggingSettings-fm
+POST     /setup/migrate/{deviceId}                                    handlers.(*Server).HandleMigrateDevice-fm
+POST     /setup/pair-account/{deviceId}                               handlers.(*Server).HandlePairAccount-fm
+POST     /setup/peer-probe/{deviceId}                                 handlers.(*Server).HandlePeerProbe-fm
+POST     /setup/reboot/{deviceId}                                     handlers.(*Server).HandleRebootDevice-fm
+POST     /setup/remove-remote-services/{deviceId}                     handlers.(*Server).HandleRemoveRemoteServices-fm
+POST     /setup/revert/{deviceId}                                     handlers.(*Server).HandleRevertMigration-fm
+POST     /setup/settings                                              handlers.(*Server).HandleUpdateSettings-fm
+POST     /setup/sync/{deviceId}                                       handlers.(*Server).HandleInitialSync-fm
+POST     /setup/test-connection/{deviceId}                            handlers.(*Server).HandleTestConnection-fm
+POST     /setup/test-dns/{deviceId}                                   handlers.(*Server).HandleTestDNSRedirection-fm
+POST     /setup/test-hosts/{deviceId}                                 handlers.(*Server).HandleTestHostsRedirection-fm
+POST     /setup/trust-ca/{deviceId}                                   handlers.(*Server).HandleTrustCACert-fm
+POST     /streaming/account                                           handlers.(*Server).HandleMargeCreateAccount-fm
+POST     /streaming/account/login                                     handlers.(*Server).HandleMargeLogin-fm
+POST     /streaming/account/{account}/device/                         handlers.(*Server).HandleMargeAddDevice-fm
+POST     /streaming/account/{account}/device/{device}                 handlers.(*Server).HandleMargeAddDevice-fm
+POST     /streaming/account/{account}/device/{device}/presets/{presetNumber} handlers.(*Server).HandleMargeUpdatePreset-fm
+POST     /streaming/account/{account}/device/{device}/recent          handlers.(*Server).HandleMargeAddRecent-fm
+POST     /streaming/account/{account}/group                           handlers.(*Server).HandleMargeAddGroup-fm
+POST     /streaming/account/{account}/group/                          handlers.(*Server).HandleMargeAddGroup-fm
+POST     /streaming/account/{account}/group/{groupId}                 handlers.(*Server).HandleMargeModifyGroup-fm
+POST     /streaming/account/{account}/source                          handlers.(*Server).HandleMargeAddSource-fm
+POST     /streaming/device_setting/account/{account}/device/{device}/device_settings handlers.(*Server).HandleMargeUpdateDeviceSettings-fm
+POST     /streaming/music/musicprovider/{providerID}/is_eligible      handlers.(*Server).HandleMusicProviderIsEligible-fm
+POST     /streaming/music/musicprovider/{providerID}/trial/is_eligible handlers.(*Server).HandleMusicProviderIsEligible-fm
+POST     /streaming/stats/error                                       handlers.(*Server).HandleErrorStats-fm
+POST     /streaming/stats/usage                                       handlers.(*Server).HandleUsageStats-fm
+POST     /streaming/support/customersupport                           handlers.(*Server).HandleMargeCustomerSupport-fm
+POST     /streaming/support/power_on                                  handlers.(*Server).HandleMargePowerOn-fm
+POST     /v1/scmudc/{deviceId}                                        handlers.(*Server).HandleAppEvents-fm
+POST     /v1/stapp/{deviceId}                                         handlers.(*Server).HandleAppEvents-fm
+PUT      /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+PUT      /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm
+PUT      /streaming/account/{account}/device/{device}                 handlers.(*Server).HandleMargeUpdateDevice-fm
+PUT      /streaming/account/{account}/device/{device}/preset/{presetNumber} handlers.(*Server).HandleMargeUpdatePreset-fm
+TRACE    /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter handlers.(*Server).HandleSiriusXMLiveAdapter-fm
+TRACE    /core02/svc-bmx-adapter-siriusxm-everest-eco1/prod/live-adapter/* handlers.(*Server).HandleSiriusXMLiveAdapterSubpath-fm

cmd/soundtouch-web/.gitignore

@@ -0,0 +1,2 @@
+soundtouch-web
+soundtouch-web-test

cmd/soundtouch-web/IMPLEMENTATION.md

@@ -0,0 +1,276 @@
+# SoundTouch Web Implementation
+
+## Overview
+
+The `soundtouch-web` tool provides a modern single-page application (SPA) for controlling Bose SoundTouch devices. Built with a JSON API backend and client-side JavaScript rendering, it offers superior performance and eliminates template rendering issues.
+
+## Architecture
+
+### Single-Page Application Design
+
+The architecture eliminates Go template dependencies and provides:
+- **JSON API Backend**: Pure Go server returning only JSON responses
+- **Client-Side Rendering**: JavaScript handles all HTML generation
+- **WebSocket Real-time**: Bi-directional communication for live updates
+- **Better Performance**: No server-side template processing
+- **Easier Development**: Clear separation of frontend/backend concerns
+
+### Core Components
+
+#### 1. Main Application (`main.go`)
+- **Entry Point**: Handles command-line arguments and application initialization
+- **SPA Routing**: Serves static HTML file for all non-API routes
+- **Device Discovery**: Automatic discovery of SoundTouch devices using unified discovery service
+- **JSON API Server**: Configures API routes and serves the SPA
+- **Context Management**: Proper context handling for timeouts and cancellation
+
+#### 2. HTTP Handlers (`handlers/handlers.go`)
+- **WebApp Structure**: Central application state management
+- **JSON API Endpoints**: RESTful API returning only JSON responses
+- **Device Control**: Device control with proper validation and error handling
+- **Modular Design**: Separated control actions into focused functions
+
+#### 3. WebSocket Support (`handlers/websocket.go`)
+- **Real-time Updates**: Live device status streaming to web clients
+- **Device WebSocket Connections**: Maintains persistent connections to SoundTouch devices
+- **Event Handling**: Processes nowPlaying, volume, and connection state updates
+- **Status Synchronization**: Keeps device status current across all connected clients
+
+#### 4. Type Definitions (`webtypes/types.go`)
+- **Device Management**: Structures for device connections and status
+- **API Responses**: Standardized JSON response format
+- **WebSocket Messages**: Real-time message types
+- **Template Data**: HTML template data structures
+
+### Key Features Implemented
+
+#### Device Discovery & Management
+- **Auto-discovery**: Finds SoundTouch devices on local network using mDNS/UPnP
+- **Multi-device Support**: Manages multiple devices simultaneously
+- **Connection Tracking**: Monitors device availability and connection status
+- **Device Information**: Displays device details (name, type, IP address)
+
+#### Real-time Control Interface
+- **Now Playing**: Live track information with artwork display
+- **Playback Controls**: Play/pause/stop/next/previous with visual feedback
+- **Volume Control**: Real-time volume slider with mute functionality
+- **Bass Adjustment**: Bass level control for supported devices
+- **Preset Management**: Quick access to saved presets (1-6)
+- **Source Selection**: Input switching (Spotify, TuneIn, Bluetooth, AUX, etc.)
+
+#### Web Interface
+- **Single-Page Application**: Self-contained HTML file with embedded CSS and JavaScript
+- **Responsive Design**: Bootstrap 5-based UI optimized for desktop and mobile
+- **Client-Side Routing**: JavaScript handles page navigation without page reloads
+- **Dynamic Rendering**: All HTML generated client-side from JSON data
+- **Real-time Updates**: WebSocket-powered live status updates
+- **Performance Optimized**: Fast loading and no template rendering delays
+
+#### API Endpoints
+```
+GET  /                          # SPA - serves static/index.html
+GET  /api/devices              # List all devices (JSON)
+GET  /api/device/{id}          # Get device info (JSON)
+POST /api/discover             # Trigger device discovery
+GET  /api/control/{id}/play    # Playback control
+GET  /api/control/{id}/pause   # Pause playback
+GET  /api/control/{id}/stop    # Stop playback
+GET  /api/control/{id}/next    # Next track
+GET  /api/control/{id}/previous # Previous track
+POST /api/control/{id}/volume  # Set volume (JSON body)
+GET  /api/control/{id}/mute    # Toggle mute
+POST /api/control/{id}/bass    # Set bass level (JSON body)
+GET  /api/control/{id}/preset?id=N # Select preset
+GET  /api/control/{id}/source?name=X # Select source
+```
+
+#### WebSocket Events
+- **Connection**: `ws://localhost:8080/ws`
+- **Device Updates**: Real-time device list changes
+- **Status Updates**: Live playback and volume changes
+- **Connection Monitoring**: Device availability status
+
+## Technical Implementation
+
+### Frontend Architecture
+- **Single HTML File**: Complete application in `static/index.html`
+- **Embedded CSS**: Bootstrap 5 with custom Bose-inspired styling
+- **Vanilla JavaScript**: No framework dependencies, fast performance
+- **Client-Side Routing**: JavaScript manages page state without reloads
+- **Dynamic Components**: HTML elements generated from JSON API responses
+
+### Error Handling & Validation
+- **Input Validation**: Proper bounds checking for volume (0-100) and bass (-9 to 9)
+- **HTTP Status Codes**: Appropriate response codes for different error conditions
+- **JSON Error Responses**: Structured error messages for API consumers
+- **Client-Side Error Display**: JavaScript toast notifications for user feedback
+
+### Code Quality
+- **golangci-lint Compliance**: Passes all configured lint checks
+- **Context Handling**: Proper context propagation and timeout management
+- **Error Checking**: All JSON encoding/decoding operations checked
+- **Type Safety**: Strong typing with dedicated type package
+- **Test Coverage**: Comprehensive unit tests for handlers and types
+
+### WebSocket Integration
+- **Gabbo Protocol**: Native SoundTouch WebSocket protocol implementation
+- **Event Processing**: Handles all documented SoundTouch WebSocket events
+- **Connection Management**: Automatic reconnection and health monitoring
+- **Bi-directional Communication**: Both status monitoring and device control
+
+## Dependencies
+
+### Core Libraries
+- **chi v5**: HTTP router (inherited from existing codebase)
+- **gorilla/websocket**: WebSocket implementation
+- **Go standard library**: html/template, net/http, encoding/json
+
+### Project Dependencies
+- **pkg/client**: SoundTouch HTTP and WebSocket client library
+- **pkg/discovery**: Device discovery service (mDNS/UPnP)
+- **pkg/models**: XML/JSON data structures for SoundTouch API
+- **pkg/config**: Configuration management
+
+### Frontend Dependencies
+- **Bootstrap 5**: CSS framework for responsive design
+- **Bootstrap Icons**: Icon library for UI elements
+- **Vanilla JavaScript**: No external JS frameworks, pure WebSocket implementation
+
+## Build & Testing
+
+### Build Commands
+```bash
+# Build the web application
+cd cmd/soundtouch-web
+go build -o soundtouch-web
+
+# Build all project components (includes soundtouch-web)
+make build
+
+# Cross-platform builds
+make build-all
+```
+
+### Testing
+```bash
+# Run unit tests
+go test ./cmd/soundtouch-web/...
+
+# Run with coverage
+go test -cover ./cmd/soundtouch-web/...
+
+# Lint checking
+golangci-lint run cmd/soundtouch-web/...
+```
+
+### Development Server
+```bash
+# Run development server
+cd cmd/soundtouch-web
+go run main.go -port 8080
+
+# Access the web interface
+open http://localhost:8080
+```
+
+## Configuration
+
+### Command Line Options
+```bash
+soundtouch-web [options]
+
+Options:
+  -port string    Web server port (default "8080")
+  -host string    Specific device host for single-device mode (optional)
+```
+
+### File Structure
+```
+cmd/soundtouch-web/
+├── main.go                    # Application entry point
+├── soundtouch-web            # Built binary
+├── handlers/
+│   ├── handlers.go           # HTTP request handlers
+│   ├── handlers_test.go      # Handler tests
+│   └── websocket.go          # WebSocket functionality
+├── webtypes/
+│   ├── types.go              # Type definitions
+│   └── types_test.go         # Type tests
+├── templates/
+│   ├── layout.html           # Base HTML layout
+│   ├── index.html            # Device list page
+│   └── device.html           # Device control page
+├── static/
+│   └── style.css             # Additional CSS styles
+└── README.md                 # User documentation
+```
+
+## Browser Compatibility
+
+### Supported Browsers
+- **Chrome 80+** (recommended)
+- **Firefox 75+**
+- **Safari 13+**
+- **Edge 80+**
+
+### Required Features
+- WebSocket support
+- CSS Grid and Flexbox
+- ES6 JavaScript features
+- JSON API support
+
+## Security Considerations
+
+### Design Principles
+- **Local Network Only**: Designed for trusted local network environments
+- **No Authentication**: Assumes local network security
+- **CORS Policy**: Restricted to same-origin requests
+- **Input Validation**: All user inputs validated on server side
+
+### Network Security
+- **Port Usage**: Uses standard HTTP port (configurable)
+- **WebSocket Security**: Same-origin WebSocket connections only
+- **No External Dependencies**: All resources served locally
+
+## Performance Characteristics
+
+### Resource Usage
+- **Memory**: Minimal footprint, scales with number of discovered devices
+- **CPU**: Low usage, event-driven architecture
+- **Network**: Efficient WebSocket connections, HTTP REST for control
+
+### Scalability
+- **Device Limits**: Designed for typical home networks (5-20 devices)
+- **Concurrent Users**: Multiple browser sessions supported
+- **Update Frequency**: Real-time updates without polling
+
+## Future Enhancements
+
+### Potential Features
+- **Zone Management**: Multi-room audio control
+- **Preset Programming**: Advanced preset configuration
+- **Mobile PWA**: Progressive Web App for mobile installation
+- **Theme Support**: Additional UI themes
+- **Device Grouping**: Logical device organization
+
+### Technical Improvements
+- **Caching**: Enhanced device status caching
+- **Compression**: WebSocket message compression
+- **Persistence**: Device settings persistence
+- **Metrics**: Usage analytics and performance monitoring
+
+## Integration with Main Project
+
+### Project Alignment
+- **Consistent Architecture**: Follows established project patterns
+- **Shared Libraries**: Leverages existing pkg/ modules
+- **Build Integration**: Included in main Makefile targets
+- **Documentation**: Consistent with project documentation standards
+
+### Migration Path
+- **Cloud Replacement**: Serves as local alternative to Bose cloud services
+- **API Compatibility**: Maintains compatibility with existing SoundTouch APIs
+- **User Experience**: Familiar interface for existing SoundTouch app users
+- **Long-term Support**: Designed for continued operation post-2026
+
+This implementation provides a robust, feature-complete web interface for SoundTouch device control, ensuring continued functionality beyond the official app's lifecycle while maintaining high code quality and user experience standards.

cmd/soundtouch-web/README.md

@@ -0,0 +1,330 @@
+# SoundTouch Web UI
+
+A modern single-page web application (SPA) for controlling Bose SoundTouch devices. Built with a JSON API backend and client-side JavaScript rendering for superior performance and maintainability.
+
+## Architecture
+
+```
+Browser → Static HTML → JavaScript → JSON API → Go Server
+                     ↓
+               Client-Side Rendering
+```
+
+### Key Benefits
+- **Better Performance**: No server-side template processing overhead
+- **Improved Maintainability**: Clear separation between frontend (JavaScript) and backend (Go)
+- **Real-time Experience**: Smooth client-side updates without page reloads
+- **Mobile Ready**: The JSON API can power both this web interface and mobile applications
+
+## Features
+
+Based on captured WebSocket interactions and device API capabilities, this web UI provides:
+
+### Device Management
+- **Auto-discovery** of SoundTouch devices on the network
+- **Real-time status monitoring** via WebSocket connections
+- **Multi-device support** with centralized control
+- **Connection status** indicators and health monitoring
+
+### Playback Control
+- **Play/Pause/Stop/Next/Previous** controls
+- **Now playing information** with artwork, track details, and progress
+- **Real-time updates** of playback state changes
+- **Source selection** from available inputs (Spotify, TuneIn, Bluetooth, AUX, etc.)
+
+### Audio Controls
+- **Volume control** with real-time slider updates
+- **Mute/Unmute** functionality
+- **Bass adjustment** (on supported models)
+- **Audio level monitoring** and statistics
+
+### Preset Management
+- **6 preset buttons** with visual feedback
+- **Preset content display** showing station/playlist names
+- **One-click preset selection**
+
+### Advanced Features
+- **WebSocket real-time updates** for instant state synchronization
+- **Responsive design** optimized for desktop and mobile
+- **Dark mode support** (auto-detects system preference)
+- **Accessibility features** (keyboard navigation, screen reader support)
+- **Network statistics** and device health monitoring
+
+## Screenshots
+
+### Main Device Overview
+The main page shows all discovered devices with their current status, now-playing information, and quick controls.
+
+### Detailed Device Control
+Individual device pages provide full control over:
+- Detailed now-playing information with artwork
+- Comprehensive audio controls (volume, bass)
+- Full preset and source selection
+- Real-time status updates
+
+## Installation
+
+### Prerequisites
+- Go 1.21 or later
+- Access to SoundTouch devices on the same network
+- Modern web browser with WebSocket support
+
+### Building
+```bash
+# From project root
+make build
+
+# Or manually
+cd cmd/soundtouch-web
+go build -o soundtouch-web
+```
+
+### Running
+```bash
+# Run with default settings (port 8080)
+./soundtouch-web
+
+# Specify custom port
+./soundtouch-web -port 8888
+
+# Connect to specific device
+./soundtouch-web -host 192.0.2.100
+```
+
+### Command Line Options
+```
+-port string    Web server port (default "8080")
+-host string    Specific SoundTouch device host (optional, enables single-device mode)
+-help          Show help information
+```
+
+## Usage
+
+### Accessing the Interface
+1. Start the application
+2. Open your web browser and navigate to `http://localhost:8080`
+3. Click "Discover Devices" to find SoundTouch devices on your network
+4. Click on any device for detailed control, or use quick controls from the main page
+
+### Device Discovery
+The application automatically discovers SoundTouch devices using:
+- **mDNS discovery** for local network devices
+- **UPnP/SSDP discovery** as fallback
+- **Manual device addition** via IP address
+
+### Real-time Updates
+The interface maintains WebSocket connections to each device for instant updates of:
+- Now playing information and artwork
+- Volume and audio settings changes
+- Playback status (play/pause/stop)
+- Connection status and device health
+
+### Responsive Design
+- **Desktop**: Full-featured interface with side-by-side panels
+- **Tablet**: Optimized layout with touch-friendly controls
+- **Mobile**: Stacked interface with gesture support
+
+## API Endpoints
+
+The web UI exposes a REST API for programmatic control:
+
+### Device Management
+```
+GET  /api/devices           # List all discovered devices
+GET  /api/device/{id}       # Get specific device info
+POST /api/discover          # Trigger device discovery
+```
+
+### Device Control
+```
+GET  /api/control/{id}/play        # Start playback
+GET  /api/control/{id}/pause       # Pause playback
+GET  /api/control/{id}/stop        # Stop playback
+GET  /api/control/{id}/next        # Next track
+GET  /api/control/{id}/previous    # Previous track
+POST /api/control/{id}/volume      # Set volume (body: {"level": 50})
+GET  /api/control/{id}/mute        # Mute audio
+GET  /api/control/{id}/unmute      # Unmute audio
+POST /api/control/{id}/bass        # Set bass (body: {"level": 0})
+GET  /api/control/{id}/preset?id=1 # Select preset
+GET  /api/control/{id}/source?name=SPOTIFY # Select source
+```
+
+### WebSocket Events
+Connect to `/ws` for real-time updates:
+```javascript
+const ws = new WebSocket('ws://localhost:8080/ws');
+ws.onmessage = function(event) {
+    const data = JSON.parse(event.data);
+    // Handle device updates, status changes, etc.
+};
+```
+
+## Architecture
+
+### Single-Page Application Architecture
+- **JSON API Backend**: Go server providing RESTful endpoints
+- **Client-Side Rendering**: JavaScript handles all UI rendering
+- **WebSocket Real-time**: Bi-directional real-time communication
+- **No Template Dependencies**: Eliminates server-side template issues
+
+### Backend Components
+- **Discovery Service**: Finds and manages SoundTouch devices
+- **WebSocket Manager**: Maintains real-time connections to devices
+- **JSON API Server**: RESTful interface returning only JSON
+- **Device Manager**: Tracks device state and health
+
+### Frontend Components
+- **Bootstrap 5**: Modern responsive UI framework
+- **Vanilla JavaScript**: No framework dependencies, fast loading
+- **WebSocket Client**: Real-time bidirectional communication
+- **Dynamic Rendering**: Client-side HTML generation from JSON
+
+### Communication Flow
+1. **SPA Loading**: Single HTML file with embedded CSS and JavaScript
+2. **JSON API**: Device discovery and control via REST endpoints
+3. **WebSocket (Device)**: Real-time status updates from SoundTouch devices
+4. **WebSocket (Browser)**: Real-time UI updates to web clients
+5. **Client Rendering**: JavaScript dynamically creates all UI elements
+
+## Development
+
+### Project Structure
+```
+cmd/soundtouch-web/
+├── main.go              # Application entry point and SPA routing
+├── handlers/            # HTTP and WebSocket handlers
+│   ├── handlers.go     # JSON API endpoints
+│   └── websocket.go    # WebSocket management
+├── webtypes/           # Type definitions
+│   └── types.go        # Request/response types
+├── static/             # Static assets
+│   ├── index.html      # Single-page application
+│   └── js/             # Legacy JS files (reference)
+├── templates/          # Legacy templates (unused in SPA)
+└── README.md          # This file
+```
+
+### Adding New Features
+1. **API Endpoints**: Add new JSON routes in `setupRoutes()` and `handlers.go`
+2. **WebSocket Events**: Extend event handlers in WebSocket client
+3. **UI Components**: Add JavaScript rendering functions in `static/index.html`
+4. **Device Controls**: Implement new control commands and update client-side handlers
+
+### Testing
+```bash
+# Unit tests
+go test ./...
+
+# Manual testing with multiple devices
+./soundtouch-web -port 8080
+
+# API testing
+curl http://localhost:8080/api/devices
+```
+
+## WebSocket Protocol Analysis
+
+This UI is based on extensive analysis of captured SoundTouch WebSocket interactions, including:
+
+### Message Types Implemented
+- **SoundTouchSdkInfo**: Initial handshake and version info
+- **nowPlayingUpdated**: Real-time track information
+- **volumeUpdated**: Audio level changes
+- **recentsUpdated**: Recently played items
+- **userActivityUpdate**: User interaction notifications
+
+### Request/Response Patterns
+- **Device Information**: System details and capabilities
+- **Audio Controls**: Volume, bass, mute controls
+- **Playback Control**: Play/pause/stop/skip commands
+- **Source Selection**: Input switching (Spotify, TuneIn, etc.)
+- **Preset Management**: Saved station/playlist access
+
+### Gabbo Protocol Features
+- **Persistent Connections**: Maintains long-lived WebSocket connections
+- **Request Correlation**: Uses request IDs for response matching
+- **Real-time Events**: Instant updates for all device state changes
+- **Bi-directional Control**: Both status monitoring and device control
+
+## Browser Compatibility
+
+### Supported Browsers
+- **Chrome 80+** (recommended)
+- **Firefox 75+**
+- **Safari 13+**
+- **Edge 80+**
+
+### Required Features
+- WebSocket support
+- CSS Grid and Flexbox
+- ES6 JavaScript features
+- Responsive CSS media queries
+
+## Security Considerations
+
+- **Local Network Only**: Designed for local network device control
+- **No Authentication**: Assumes trusted local network environment
+- **CORS Policy**: Restricted to same-origin requests
+- **WebSocket Security**: Uses same-origin WebSocket connections
+
+## Troubleshooting
+
+### Common Issues
+
+**Devices Not Found**
+- Ensure devices are on the same network
+- Check firewall settings (ports 8090, 8080)
+- Click "Discover Devices" button to trigger discovery
+
+**WebSocket Connection Failed**
+- Verify device supports WebSocket connections
+- Check browser console for connection errors
+- Refresh the page to reconnect WebSocket
+
+**Control Commands Not Working**
+- Check device is powered on and connected
+- Verify device is not in exclusive mode (e.g., Spotify Connect active)
+- Look for error notifications in the UI
+
+**Page Shows Template Errors**
+- This has been fixed in the SPA implementation
+- Ensure you're accessing the correct URL (localhost:8080)
+- Clear browser cache if you see old template-based content
+
+### Debug Mode
+Add verbose logging by setting environment variable:
+```bash
+export DEBUG=true
+./soundtouch-web
+```
+
+## Contributing
+
+This web UI is part of the larger SoundTouch Go library project. See the main project README for contribution guidelines.
+
+### Architecture Benefits
+The new SPA approach provides:
+- **Better Performance**: No server-side template rendering
+- **Easier Development**: Clear separation of frontend/backend
+- **Mobile Ready**: Same JSON API can power mobile apps
+- **Scalable**: Single-page app architecture
+
+### Feature Requests
+Based on WebSocket interaction analysis, potential future features:
+- Zone/multi-room management
+- Clock display control
+- Software update management
+- Advanced preset programming
+- Progressive Web App (PWA) features
+
+## License
+
+Same as the parent project - see main repository LICENSE file.
+
+## Acknowledgments
+
+- Built on the comprehensive SoundTouch Go library
+- UI design inspired by modern audio control interfaces
+- WebSocket protocol reverse-engineered from captured device interactions
+- Bootstrap and Bootstrap Icons for responsive design components

cmd/soundtouch-web/main.go

@@ -0,0 +1,225 @@
+// Package main provides a web UI for controlling Bose SoundTouch devices.
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"runtime/debug"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/service/soundtouchweb"
+	"github.com/go-chi/chi/v5"
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	version = "dev"
+	commit  = "unknown"
+	date    = "unknown"
+	repoURL = "https://github.com/gesellix/bose-soundtouch"
+)
+
+func updateBuildInfo() {
+	if info, ok := debug.ReadBuildInfo(); ok {
+		if info.Main.Path != "" {
+			repoURL = "https://" + info.Main.Path
+		}
+
+		if info.Main.Version != "" && info.Main.Version != "(devel)" {
+			version = info.Main.Version
+		}
+
+		for _, setting := range info.Settings {
+			switch setting.Key {
+			case "vcs.revision":
+				commit = setting.Value
+			case "vcs.time":
+				if t, err := time.Parse(time.RFC3339, setting.Value); err == nil {
+					date = t.Format("2006-01-02 15:04:05")
+				}
+			}
+		}
+	}
+}
+
+func main() {
+	updateBuildInfo()
+
+	app := &cli.App{
+		Name:  "soundtouch-web",
+		Usage: "Web UI for controlling Bose SoundTouch devices",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "port",
+				Aliases: []string{"p"},
+				Usage:   "HTTP port to listen on",
+				Value:   "8080",
+				EnvVars: []string{"PORT"},
+			},
+			&cli.StringFlag{
+				Name:    "bind",
+				Usage:   "Address for the HTTP listener: host, IP, or local interface name (e.g. eth0). Leave empty to listen on all interfaces",
+				EnvVars: []string{"BIND_ADDR"},
+			},
+			&cli.StringFlag{
+				Name:    "interface",
+				Usage:   "Network interface name (e.g. eth0) for mDNS and UPnP device discovery. Defaults to the --bind interface name when one was given; leave empty otherwise to auto-pick",
+				EnvVars: []string{"DISCOVERY_INTERFACE"},
+			},
+			&cli.StringSliceFlag{
+				Name:    "devices",
+				Usage:   "SoundTouch device IP address(es) to add manually (can be specified multiple times)",
+				EnvVars: []string{"SOUNDTOUCH_DEVICES"},
+			},
+		},
+		Action: func(c *cli.Context) error {
+			port := c.String("port")
+			rawBind := c.String("bind")
+
+			bindAddr, err := resolveBindAddr(rawBind)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if rawBind != "" && bindAddr != rawBind {
+				log.Printf("Resolved --bind %q to %s", rawBind, bindAddr)
+			}
+
+			rawIface := c.String("interface")
+			manualHosts := c.StringSlice("devices")
+
+			ifaceName := defaultDiscoveryInterface(rawIface, rawBind, bindAddr)
+			if rawIface == "" && ifaceName != "" {
+				log.Printf("Defaulting --interface to %q from --bind", ifaceName)
+			}
+
+			addr := ":" + port
+			if bindAddr != "" {
+				addr = bindAddr + ":" + port
+			}
+
+			// Create web app without templates (SPA mode)
+			webApp := soundtouchweb.NewWebApp()
+			webApp.Version = version
+			webApp.Commit = commit
+			webApp.Date = date
+			webApp.RepoURL = repoURL
+
+			discoveryService := soundtouchweb.NewDiscoveryService(ifaceName)
+
+			// Discover devices on startup
+			go func() {
+				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+				defer cancel()
+
+				webApp.BroadcastDiscoveryStatus("starting", webApp.DeviceCount())
+
+				for _, host := range manualHosts {
+					webApp.AddDeviceByHost(host, 8090, "manual")
+				}
+
+				webApp.DiscoverDevices(ctx, discoveryService)
+
+				webApp.BroadcastDiscoveryStatus("completed", webApp.DeviceCount())
+				webApp.BroadcastDeviceList()
+			}()
+
+			r := chi.NewRouter()
+			webApp.Mount(r, discoveryService)
+
+			log.Printf("AfterTouch Web UI starting on http://%s", addr)
+
+			return http.ListenAndServe(addr, r)
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// defaultDiscoveryInterface picks the interface name to use for mDNS/UPnP
+// discovery. An explicit --interface always wins; otherwise, when --bind was
+// given an interface name (i.e. resolveBindAddr substituted an IP for it),
+// that name is reused so the common single-interface case "just works".
+// Returns the empty string when there is nothing to propagate, leaving the
+// discovery service to auto-pick.
+func defaultDiscoveryInterface(rawInterface, rawBind, resolvedBind string) string {
+	if rawInterface != "" {
+		return rawInterface
+	}
+
+	if rawBind != "" && rawBind != resolvedBind {
+		return rawBind
+	}
+
+	return ""
+}
+
+// resolveBindAddr returns the address to bind the HTTP listener to.
+//
+// If bindAddr names a local network interface, the interface's single IPv4
+// address is returned. When no IPv4 is present, the function falls back to the
+// interface's single non-link-local IPv6 address (wrapped in brackets so it
+// composes correctly with ":port"). Ambiguous interfaces (multiple addresses
+// in the chosen family) or interfaces with no usable address produce an error,
+// so misconfiguration surfaces immediately instead of becoming an obscure DNS
+// lookup failure at listen time.
+//
+// If bindAddr is not an interface name — including the empty string, a host
+// name, or a literal IP — it is returned unchanged.
+func resolveBindAddr(bindAddr string) (string, error) {
+	// A lookup failure here just means bindAddr isn't an interface name
+	// (it's a host, IP, or empty); fall through to pass-through.
+	iface, _ := net.InterfaceByName(bindAddr)
+	if iface == nil {
+		return bindAddr, nil
+	}
+
+	addrs, err := iface.Addrs()
+	if err != nil {
+		return "", fmt.Errorf("--bind %q: failed to list addresses for interface: %w", bindAddr, err)
+	}
+
+	var ipv4, ipv6 []net.IP
+
+	for _, addr := range addrs {
+		var ip net.IP
+
+		switch v := addr.(type) {
+		case *net.IPNet:
+			ip = v.IP
+		case *net.IPAddr:
+			ip = v.IP
+		}
+
+		if ip == nil {
+			continue
+		}
+
+		if v4 := ip.To4(); v4 != nil {
+			ipv4 = append(ipv4, v4)
+		} else if !ip.IsLinkLocalUnicast() {
+			// Skip IPv6 link-local (fe80::); it requires a zone ID and
+			// can't be used as a plain "[ip]:port" listen address.
+			ipv6 = append(ipv6, ip)
+		}
+	}
+
+	switch {
+	case len(ipv4) == 1:
+		return ipv4[0].String(), nil
+	case len(ipv4) > 1:
+		return "", fmt.Errorf("--bind %q: interface has multiple IPv4 addresses (%v); specify one directly", bindAddr, ipv4)
+	case len(ipv6) == 1:
+		return "[" + ipv6[0].String() + "]", nil
+	case len(ipv6) > 1:
+		return "", fmt.Errorf("--bind %q: interface has multiple IPv6 addresses (%v); specify one directly", bindAddr, ipv6)
+	default:
+		return "", fmt.Errorf("--bind %q: interface has no usable IPv4 or IPv6 address", bindAddr)
+	}
+}

cmd/soundtouch-web/resolve_bind_addr_test.go

@@ -0,0 +1,162 @@
+package main
+
+import (
+	"net"
+	"strings"
+	"testing"
+)
+
+func TestResolveBindAddr_PassThrough(t *testing.T) {
+	// Inputs that don't match any local interface name must be returned
+	// unchanged: empty string, hostnames, IPv4/IPv6 literals, and bogus
+	// strings the user might have typed.
+	tests := []string{
+		"",
+		"localhost",
+		"127.0.0.1",
+		"192.0.2.5",
+		"::1",
+		"definitely-not-an-iface-xyz",
+	}
+
+	for _, input := range tests {
+		t.Run(quoted(input), func(t *testing.T) {
+			got, err := resolveBindAddr(input)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if got != input {
+				t.Errorf("got %q, want %q (input should pass through unchanged)", got, input)
+			}
+		})
+	}
+}
+
+func TestResolveBindAddr_LoopbackInterface(t *testing.T) {
+	loopback, expected, ok := findLoopbackWithSingleIPv4(t)
+	if !ok {
+		t.Skipf("no loopback interface with exactly one IPv4 address found")
+	}
+
+	got, err := resolveBindAddr(loopback)
+	if err != nil {
+		t.Fatalf("unexpected error resolving %q: %v", loopback, err)
+	}
+
+	if got != expected {
+		t.Errorf("got %q, want %q for loopback interface %q", got, expected, loopback)
+	}
+}
+
+// findLoopbackWithSingleIPv4 returns the name of a loopback interface and the
+// single IPv4 address attached to it. If the host has multiple loopback
+// interfaces or the loopback has zero or several IPv4 addresses, it returns
+// ok=false so the caller can skip the test rather than fail on an environment
+// quirk.
+func findLoopbackWithSingleIPv4(t *testing.T) (name, addr string, ok bool) {
+	t.Helper()
+
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		t.Fatalf("net.Interfaces: %v", err)
+	}
+
+	for _, iface := range ifaces {
+		if iface.Flags&net.FlagLoopback == 0 {
+			continue
+		}
+
+		addrs, addrErr := iface.Addrs()
+		if addrErr != nil {
+			continue
+		}
+
+		var ipv4s []string
+
+		for _, a := range addrs {
+			if ipnet, isIPNet := a.(*net.IPNet); isIPNet {
+				if v4 := ipnet.IP.To4(); v4 != nil {
+					ipv4s = append(ipv4s, v4.String())
+				}
+			}
+		}
+
+		if len(ipv4s) == 1 {
+			return iface.Name, ipv4s[0], true
+		}
+	}
+
+	return "", "", false
+}
+
+func TestDefaultDiscoveryInterface(t *testing.T) {
+	tests := []struct {
+		name         string
+		rawInterface string
+		rawBind      string
+		resolvedBind string
+		want         string
+	}{
+		{
+			name:         "explicit interface wins over bind-derived default",
+			rawInterface: "eth1",
+			rawBind:      "eth0",
+			resolvedBind: "192.0.2.5",
+			want:         "eth1",
+		},
+		{
+			name:         "derive from --bind when --bind was an interface name",
+			rawInterface: "",
+			rawBind:      "eth0",
+			resolvedBind: "192.0.2.5",
+			want:         "eth0",
+		},
+		{
+			name:         "no derivation when --bind was an IP literal",
+			rawInterface: "",
+			rawBind:      "192.0.2.5",
+			resolvedBind: "192.0.2.5",
+			want:         "",
+		},
+		{
+			name:         "no derivation when --bind was a hostname (pass-through)",
+			rawInterface: "",
+			rawBind:      "localhost",
+			resolvedBind: "localhost",
+			want:         "",
+		},
+		{
+			name:         "both empty stays empty (auto-pick)",
+			rawInterface: "",
+			rawBind:      "",
+			resolvedBind: "",
+			want:         "",
+		},
+		{
+			name:         "explicit interface alone, --bind empty",
+			rawInterface: "eth1",
+			rawBind:      "",
+			resolvedBind: "",
+			want:         "eth1",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := defaultDiscoveryInterface(tc.rawInterface, tc.rawBind, tc.resolvedBind)
+			if got != tc.want {
+				t.Errorf("got %q, want %q (rawInterface=%q rawBind=%q resolvedBind=%q)",
+					got, tc.want, tc.rawInterface, tc.rawBind, tc.resolvedBind)
+			}
+		})
+	}
+}
+
+func quoted(s string) string {
+	if s == "" {
+		return "(empty)"
+	}
+
+	return strings.ReplaceAll(s, "/", "_")
+}

cmd/soundtouch-web/spa_test.go

@@ -0,0 +1,363 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+	"github.com/gesellix/bose-soundtouch/pkg/service/soundtouchweb"
+	"github.com/gesellix/bose-soundtouch/pkg/service/soundtouchweb/webtypes"
+	"github.com/go-chi/chi/v5"
+)
+
+func withChiParams(r *http.Request, params map[string]string) *http.Request {
+	rctx := chi.NewRouteContext()
+	for k, v := range params {
+		rctx.URLParams.Add(k, v)
+	}
+	return r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, rctx))
+}
+
+func TestSPARouting(t *testing.T) {
+	tests := []struct {
+		name           string
+		path           string
+		expectedStatus int
+		expectedHTML   bool
+	}{
+		{
+			name:           "root path serves HTML",
+			path:           "/",
+			expectedStatus: http.StatusOK,
+			expectedHTML:   true,
+		},
+		{
+			name:           "device path serves HTML",
+			path:           "/device/test-device",
+			expectedStatus: http.StatusOK,
+			expectedHTML:   true,
+		},
+		{
+			name:           "arbitrary path serves HTML",
+			path:           "/some/random/path",
+			expectedStatus: http.StatusOK,
+			expectedHTML:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest("GET", tt.path, nil)
+			w := httptest.NewRecorder()
+
+			// Simulate SPA routing handler
+			spaHandler := func(w http.ResponseWriter, r *http.Request) {
+				// If it's an API route, let it pass through
+				if strings.HasPrefix(r.URL.Path, "/api/") || strings.HasPrefix(r.URL.Path, "/static/") || strings.HasPrefix(r.URL.Path, "/ws") {
+					http.NotFound(w, r)
+					return
+				}
+
+				// Serve the SPA index.html content (simulated)
+				w.Header().Set("Content-Type", "text/html")
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte(`<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <title>AfterTouch Control Center</title>
+</head>
+<body>
+    <div id="app">SPA Content</div>
+</body>
+</html>`))
+			}
+
+			spaHandler(w, req)
+
+			if w.Code != tt.expectedStatus {
+				t.Errorf("Expected status %d, got %d", tt.expectedStatus, w.Code)
+			}
+
+			if tt.expectedHTML {
+				contentType := w.Header().Get("Content-Type")
+				if !strings.Contains(contentType, "text/html") {
+					t.Errorf("Expected HTML content type, got %s", contentType)
+				}
+
+				body := w.Body.String()
+				if !strings.Contains(body, "<!doctype html>") {
+					t.Errorf("Expected HTML content, got: %s", body)
+				}
+			}
+		})
+	}
+}
+
+func TestAPIEndpoints(t *testing.T) {
+	app := soundtouchweb.NewWebApp()
+
+	tests := []struct {
+		name           string
+		path           string
+		method         string
+		expectedStatus int
+		expectedJSON   bool
+	}{
+		{
+			name:           "devices API returns JSON",
+			path:           "/api/devices",
+			method:         "GET",
+			expectedStatus: http.StatusOK,
+			expectedJSON:   true,
+		},
+		{
+			name:           "discover API accepts POST",
+			path:           "/api/discover",
+			method:         "POST",
+			expectedStatus: http.StatusOK,
+			expectedJSON:   true,
+		},
+		{
+			name:           "device API with ID",
+			path:           "/api/device/test-device",
+			method:         "GET",
+			expectedStatus: http.StatusNotFound, // Device won't exist in test
+			expectedJSON:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest(tt.method, tt.path, nil)
+			w := httptest.NewRecorder()
+
+			switch tt.path {
+			case "/api/devices":
+				app.HandleAPIDevices(w, req)
+			case "/api/discover":
+				app.HandleAPIDiscover(w, req)
+			default:
+				if strings.HasPrefix(tt.path, "/api/device/") {
+					deviceID := strings.TrimPrefix(tt.path, "/api/device/")
+					req = withChiParams(req, map[string]string{"id": deviceID})
+					app.HandleAPIDevice(w, req)
+				}
+			}
+
+			if w.Code != tt.expectedStatus {
+				t.Errorf("Expected status %d, got %d", tt.expectedStatus, w.Code)
+			}
+
+			if tt.expectedJSON {
+				contentType := w.Header().Get("Content-Type")
+				if !strings.Contains(contentType, "application/json") {
+					t.Errorf("Expected JSON content type, got %s", contentType)
+				}
+
+				// Validate JSON response structure
+				var response webtypes.APIResponse
+				if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+					t.Errorf("Invalid JSON response: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestAPIResponseFormat(t *testing.T) {
+	app := soundtouchweb.NewWebApp()
+
+	req := httptest.NewRequest("GET", "/api/devices", nil)
+	w := httptest.NewRecorder()
+
+	app.HandleAPIDevices(w, req)
+
+	var response webtypes.APIResponse
+	if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+		t.Fatalf("Failed to decode JSON response: %v", err)
+	}
+
+	// Check API response structure
+	if !response.Success {
+		t.Errorf("Expected success=true, got success=%v", response.Success)
+	}
+
+	if response.Data == nil {
+		t.Errorf("Expected data field to be present")
+	}
+
+	// Data should be an empty map for no devices
+	dataMap, ok := response.Data.(map[string]interface{})
+	if !ok {
+		t.Errorf("Expected data to be a map, got %T", response.Data)
+	}
+
+	if len(dataMap) != 0 {
+		t.Errorf("Expected empty device map, got %d devices", len(dataMap))
+	}
+}
+
+func TestControlAPIValidation(t *testing.T) {
+	app := soundtouchweb.NewWebApp()
+
+	tests := []struct {
+		name           string
+		path           string
+		method         string
+		body           string
+		expectedStatus int
+		chiParams      map[string]string
+	}{
+		{
+			name:           "missing device ID",
+			path:           "/api/control//play",
+			method:         "GET",
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name:           "invalid control path",
+			path:           "/api/control/device",
+			method:         "GET",
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name:           "unknown action",
+			path:           "/api/control/nonexistent/invalid",
+			method:         "GET",
+			expectedStatus: http.StatusNotFound,
+			chiParams:      map[string]string{"id": "nonexistent", "action": "invalid"},
+		},
+		{
+			name:           "nonexistent device",
+			path:           "/api/control/nonexistent/play",
+			method:         "GET",
+			expectedStatus: http.StatusNotFound,
+			chiParams:      map[string]string{"id": "nonexistent", "action": "play"},
+		},
+		{
+			name:           "unknown action with valid device",
+			path:           "/api/control/testdevice/unknownaction",
+			method:         "GET",
+			expectedStatus: http.StatusBadRequest,
+			chiParams:      map[string]string{"id": "testdevice", "action": "unknownaction"},
+		},
+	}
+
+	// Add a mock device for testing unknown action validation
+	mockDevice := webtypes.NewDeviceConnection(nil, &models.DeviceInfo{Name: "Test Device"})
+	mockDevice.SetStatus(&webtypes.DeviceStatus{IsConnected: true})
+	app.AddDevice("testdevice", mockDevice)
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var req *http.Request
+			if tt.body != "" {
+				req = httptest.NewRequest(tt.method, tt.path, strings.NewReader(tt.body))
+				req.Header.Set("Content-Type", "application/json")
+			} else {
+				req = httptest.NewRequest(tt.method, tt.path, nil)
+			}
+			if tt.chiParams != nil {
+				req = withChiParams(req, tt.chiParams)
+			}
+
+			w := httptest.NewRecorder()
+			app.HandleAPIControl(w, req)
+
+			if w.Code != tt.expectedStatus {
+				t.Errorf("Test %s: Expected status %d, got %d. Response: %s", tt.name, tt.expectedStatus, w.Code, w.Body.String())
+			}
+
+			// Validate error response format
+			contentType := w.Header().Get("Content-Type")
+			if !strings.Contains(contentType, "application/json") {
+				t.Errorf("Expected JSON content type, got %s", contentType)
+			}
+
+			var response webtypes.APIResponse
+			if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+				t.Errorf("Invalid JSON response: %v", err)
+			}
+
+			if response.Success {
+				t.Errorf("Expected success=false for error case, got success=true")
+			}
+
+			if response.Error == "" {
+				t.Errorf("Expected error message, got empty string")
+			}
+		})
+	}
+}
+
+func TestWebSocketUpgrade(t *testing.T) {
+	app := soundtouchweb.NewWebApp()
+
+	// Test WebSocket upgrade request
+	req := httptest.NewRequest("GET", "/ws", nil)
+	req.Header.Set("Connection", "upgrade")
+	req.Header.Set("Upgrade", "websocket")
+	req.Header.Set("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
+	req.Header.Set("Sec-WebSocket-Version", "13")
+
+	w := httptest.NewRecorder()
+
+	// The actual WebSocket upgrade will fail in test environment,
+	// but we can check that the handler exists and accepts the request
+	app.HandleWebSocket(w, req)
+
+	// In a real test environment, this would fail with a websocket upgrade error
+	// We're just checking the handler doesn't panic and processes the request
+}
+
+func TestJSONAPIConsistency(t *testing.T) {
+	app := soundtouchweb.NewWebApp()
+
+	endpoints := []string{
+		"/api/devices",
+		"/api/device/test",
+	}
+
+	for _, endpoint := range endpoints {
+		t.Run("JSON consistency for "+endpoint, func(t *testing.T) {
+			req := httptest.NewRequest("GET", endpoint, nil)
+			w := httptest.NewRecorder()
+
+			switch endpoint {
+			case "/api/devices":
+				app.HandleAPIDevices(w, req)
+			default:
+				if strings.HasPrefix(endpoint, "/api/device/") {
+					deviceID := strings.TrimPrefix(endpoint, "/api/device/")
+					req = withChiParams(req, map[string]string{"id": deviceID})
+					app.HandleAPIDevice(w, req)
+				}
+			}
+
+			// All API endpoints should return JSON
+			contentType := w.Header().Get("Content-Type")
+			if !strings.Contains(contentType, "application/json") {
+				t.Errorf("Endpoint %s should return JSON, got %s", endpoint, contentType)
+			}
+
+			// All responses should follow APIResponse structure
+			var response webtypes.APIResponse
+			if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+				t.Errorf("Endpoint %s returned invalid JSON: %v", endpoint, err)
+			}
+
+			// Response should have either data or error
+			if response.Success && response.Data == nil {
+				t.Errorf("Endpoint %s: success response should have data", endpoint)
+			}
+			if !response.Success && response.Error == "" {
+				t.Errorf("Endpoint %s: error response should have error message", endpoint)
+			}
+		})
+	}
+}

cmd/websocket-demo/main.go

@@ -47,6 +47,7 @@ func parseFilters(eventFilter string) map[string]bool {
 	validFilters := map[string]bool{
 		"nowPlaying": true, "volume": true, "connection": true,
 		"preset": true, "zone": true, "bass": true,
+		"sdkInfo": true, "userActivity": true,
 	}
 
 	if eventFilter == "" {
@@ -59,7 +60,7 @@ func parseFilters(eventFilter string) map[string]bool {
 	for _, f := range filterList {
 		f = strings.TrimSpace(f)
 		if !validFilters[f] {
-			fmt.Printf("Invalid filter '%s'. Valid filters: nowPlaying, volume, connection, preset, zone, bass\n", f)
+			fmt.Printf("Invalid filter '%s'. Valid filters: nowPlaying, volume, connection, preset, zone, bass, sdkInfo, userActivity\n", f)
 			os.Exit(1)
 		}
 
@@ -116,6 +117,9 @@ func setupWebSocket(soundTouchClient *client.Client, reconnect, verbose bool) *c
 
 	if verbose {
 		wsConfig.Logger = &VerboseLogger{}
+	} else {
+		// Use a silent logger when not verbose
+		wsConfig.Logger = &SilentLogger{}
 	}
 
 	if !reconnect {
@@ -187,6 +191,11 @@ func main() {
 	// Set up event handlers
 	setupEventHandlers(wsClient, filters, *verbose)
 
+	// Set up special message handler
+	wsClient.OnSpecialMessage(func(message *models.SpecialMessage) {
+		handleSpecialMessage(message, filters, *verbose)
+	})
+
 	// Connect to WebSocket
 	fmt.Println("Connecting to WebSocket...")
 
@@ -333,17 +342,31 @@ func handleConnection(event *models.ConnectionStateUpdatedEvent) {
 }
 
 func handlePreset(event *models.PresetUpdatedEvent, verbose bool) {
-	preset := &event.Preset
-	fmt.Printf("\n📻 Preset Update [%s]:\n", event.DeviceID)
-	fmt.Printf("  📻 Preset: %d\n", preset.ID)
+	presets := &event.Presets
 
-	if preset.ContentItem != nil {
-		fmt.Printf("  🎵 %s\n", preset.ContentItem.ItemName)
-		fmt.Printf("  📻 Source: %s\n", preset.ContentItem.Source)
+	deviceHeader := "\n📻 Presets Update"
+	if event.DeviceID != "" {
+		deviceHeader += fmt.Sprintf(" [%s]", event.DeviceID)
+	}
+
+	fmt.Printf("%s:\n", deviceHeader)
+	fmt.Printf("  📻 Total presets: %d\n", len(presets.Preset))
+
+	for _, preset := range presets.Preset {
+		fmt.Printf("  📻 Preset %d:", preset.ID)
+
+		// IsEmpty catches both <preset/> and INVALID_SOURCE
+		// placeholders; using the nil-safe helpers below means the
+		// inner Printf never dereferences a nil ContentItem.
+		if !preset.IsEmpty() {
+			fmt.Printf(" %s (%s)", preset.GetDisplayName(), preset.GetSource())
+		}
+
+		fmt.Println()
 	}
 
 	if verbose {
-		fmt.Printf("  📱 Raw preset data: ID=%d\n", preset.ID)
+		fmt.Printf("  📱 Raw presets data: %d total presets\n", len(presets.Preset))
 	}
 }
 
@@ -382,6 +405,43 @@ func handleBass(event *models.BassUpdatedEvent) {
 	fmt.Printf("  📊 %s\n", levelDesc)
 }
 
+func handleSpecialMessage(message *models.SpecialMessage, filters map[string]bool, verbose bool) {
+	// Check if we should filter this message type
+	if filters != nil {
+		switch message.Type {
+		case models.MessageTypeSdkInfo:
+			if !filters["sdkInfo"] {
+				return
+			}
+		case models.MessageTypeUserActivity:
+			if !filters["userActivity"] {
+				return
+			}
+		}
+	}
+
+	switch message.Type {
+	case models.MessageTypeSdkInfo:
+		if sdkInfo := message.GetSdkInfo(); sdkInfo != nil {
+			fmt.Printf("\n📡 SDK Info:\n")
+			fmt.Printf("  📋 Server Version: %s\n", sdkInfo.ServerVersion)
+			fmt.Printf("  🔧 Server Build: %s\n", sdkInfo.ServerBuild)
+		}
+	case models.MessageTypeUserActivity:
+		fmt.Printf("\n👤 User Activity [%s]\n", message.DeviceID)
+
+		if verbose {
+			fmt.Printf("  ⏰ Timestamp: %s\n", message.Timestamp.Format("15:04:05"))
+		}
+	default:
+		fmt.Printf("\n❓ Unknown Special Message: %s\n", message.String())
+
+		if verbose {
+			fmt.Printf("  📱 Raw data: %s\n", string(message.RawData))
+		}
+	}
+}
+
 func setupEventHandlers(wsClient *client.WebSocketClient, filters map[string]bool, verbose bool) {
 	// Now Playing events
 	if filters == nil || filters["nowPlaying"] {
@@ -477,7 +537,7 @@ func printHelp() {
 	fmt.Println("        Enable verbose logging")
 	fmt.Println("  -filter string")
 	fmt.Println("        Filter events by type (comma-separated):")
-	fmt.Println("        nowPlaying, volume, connection, preset, zone, bass")
+	fmt.Println("        nowPlaying, volume, connection, preset, zone, bass, sdkInfo, userActivity")
 	fmt.Println("  -help")
 	fmt.Println("        Show this help message")
 	fmt.Println()
@@ -486,13 +546,13 @@ func printHelp() {
 	fmt.Printf("  %s -discover\n", os.Args[0])
 	fmt.Println()
 	fmt.Println("  # Connect to specific device and monitor volume events only")
-	fmt.Printf("  %s -host 192.168.1.10 -filter volume\n", os.Args[0])
+	fmt.Printf("  %s -host 192.0.2.10 -filter volume\n", os.Args[0])
 	fmt.Println()
 	fmt.Println("  # Monitor for 5 minutes with verbose output")
-	fmt.Printf("  %s -host 192.168.1.10 -duration 5m -verbose\n", os.Args[0])
+	fmt.Printf("  %s -host 192.0.2.10 -duration 5m -verbose\n", os.Args[0])
 	fmt.Println()
 	fmt.Println("  # Monitor now playing and volume events")
-	fmt.Printf("  %s -host 192.168.1.10 -filter nowPlaying,volume\n", os.Args[0])
+	fmt.Printf("  %s -host 192.0.2.10 -filter nowPlaying,volume\n", os.Args[0])
 	fmt.Println()
 	fmt.Println("Event Types:")
 	fmt.Println("  🎵 nowPlaying  - Track changes, playback status")
@@ -501,6 +561,8 @@ func printHelp() {
 	fmt.Println("  📻 preset      - Preset configuration changes")
 	fmt.Println("  🏠 zone        - Multiroom zone changes")
 	fmt.Println("  🎚️  bass        - Bass level changes")
+	fmt.Println("  📡 sdkInfo     - SDK version information")
+	fmt.Println("  👤 userActivity - User interaction notifications")
 	fmt.Println()
 	fmt.Println("The tool will automatically reconnect if the connection is lost.")
 	fmt.Println("Press Ctrl+C to stop monitoring.")
@@ -513,3 +575,10 @@ func (v *VerboseLogger) Printf(format string, args ...interface{}) {
 	timestamp := time.Now().Format("15:04:05")
 	fmt.Printf("[%s] [WebSocket] %s\n", timestamp, fmt.Sprintf(format, args...))
 }
+
+// SilentLogger provides no-op WebSocket logging
+type SilentLogger struct{}
+
+func (s *SilentLogger) Printf(_ string, _ ...interface{}) {
+	// Do nothing - silent logging
+}

data/.gitignore

@@ -0,0 +1,9 @@
+accounts/
+backend/
+certs/
+default/
+dns/
+interactions/
+parity_mismatches/
+patterns.json
+settings.json

doc.go

@@ -1,8 +1,11 @@
-// Package bose-soundtouch provides a comprehensive Go library and CLI tool for controlling Bose SoundTouch devices.
+// Package soundtouch provides a comprehensive Go library, CLI tool, and local service for controlling and emulating Bose SoundTouch devices.
 //
-// This library implements the complete Bose SoundTouch Web API, enabling programmatic control
+// This project implements the complete Bose SoundTouch Web API, enabling programmatic control
 // of SoundTouch speakers including playback control, volume management, source selection,
-// multiroom zone management, and real-time event monitoring via WebSocket connections.
+// multiroom zone management, and real-time event monitoring.
+//
+// It also provides a local service (`soundtouch-service`) that can emulate the Bose Cloud,
+// allowing for offline control and enhanced debugging through HTTP interaction recording.
 //
 // # Quick Start
 //
@@ -24,7 +27,7 @@
 //	func main() {
 //		// Create a client for your SoundTouch device
 //		config := &client.Config{
-//			Host: "192.168.1.100",
+//			Host: "192.0.2.100",
 //			Port: 8090,
 //		}
 //		client := client.NewClient(config)
@@ -41,63 +44,20 @@
 //		if err != nil {
 //			log.Fatal(err)
 //		}
-//
-//		// Set volume
-//		err = client.SetVolume(50)
-//		if err != nil {
-//			log.Fatal(err)
-//		}
 //	}
 //
-// # Device Discovery
+// # SoundTouch Service
 //
-// Automatically discover SoundTouch devices on your network:
+// The `soundtouch-service` provides several advanced features:
 //
-//	import "github.com/gesellix/bose-soundtouch/pkg/discovery"
+//   - Bose Cloud Emulation: Allows speakers to work without an internet connection.
+//   - HTTP Interaction Recording: Captures all traffic as IntelliJ-compatible .http files.
+//   - Speaker Migration: Automated tools to redirect speakers to the local service.
+//   - Web Interface: A management dashboard for proxy settings and speaker setup.
 //
-//	// Discover devices using UPnP/SSDP
-//	service := discovery.NewService(5*time.Second)
-//	devices, err := service.DiscoverDevices(ctx)
-//	if err != nil {
-//		log.Fatal(err)
-//	}
+// Install the service:
 //
-//	for _, device := range devices {
-//		fmt.Printf("Found device: %s at %s\n", device.Name, device.Host)
-//	}
-//
-// # Real-time Events
-//
-// Monitor device state changes in real-time using WebSocket connections:
-//
-//	// Subscribe to device events
-//	events, err := client.SubscribeToEvents(ctx)
-//	if err != nil {
-//		log.Fatal(err)
-//	}
-//
-//	for event := range events {
-//		switch e := event.(type) {
-//		case *models.NowPlayingUpdated:
-//			fmt.Printf("Now playing: %s by %s\n", e.Track, e.Artist)
-//		case *models.VolumeUpdated:
-//			fmt.Printf("Volume changed to: %d\n", e.ActualVolume)
-//		}
-//	}
-//
-// # Multiroom Zone Management
-//
-// Create and manage multiroom zones:
-//
-//	// Create a zone with multiple speakers
-//	zone := &models.Zone{
-//		Master: "192.168.1.100",
-//		Members: []models.ZoneMember{
-//			{IPAddress: "192.168.1.101"},
-//			{IPAddress: "192.168.1.102"},
-//		},
-//	}
-//	err = client.SetZone(zone)
+//	go install github.com/gesellix/bose-soundtouch/cmd/soundtouch-service@latest
 //
 // # CLI Tool
 //
@@ -110,47 +70,35 @@
 //	soundtouch-cli discover devices
 //
 //	# Control a device
-//	soundtouch-cli --host 192.168.1.100 play start
-//	soundtouch-cli --host 192.168.1.100 volume set --level 50
-//	soundtouch-cli --host 192.168.1.100 source select --source SPOTIFY
+//	soundtouch-cli --host 192.0.2.100 play start
 //
 // # Supported Features
 //
 //   - ✅ Device Information & Capabilities
-//   - ✅ Playback Control (Play/Pause/Stop/Next/Previous)
-//   - ✅ Volume, Bass, and Balance Control
-//   - ✅ Source Selection (Spotify, Bluetooth, AUX, etc.)
-//   - ✅ Preset Management
-//   - ✅ Clock/Time Management
-//   - ✅ Network Information
+//   - ✅ Playback, Volume, Bass, and Balance Control
+//   - ✅ Source Selection & Preset Management
 //   - ✅ Real-time WebSocket Events
 //   - ✅ Multiroom Zone Management
 //   - ✅ Device Discovery (UPnP/SSDP and mDNS)
-//   - ✅ Cross-platform Support (Windows, macOS, Linux)
+//   - ✅ Local Cloud Emulation (soundtouch-service)
+//   - ✅ HTTP Traffic Recording & Sanitization
+//   - ✅ Automated Speaker Migration & Revert
 //
 // # Package Structure
 //
 //   - client: HTTP client for SoundTouch Web API
 //   - discovery: Device discovery using UPnP/SSDP and mDNS
 //   - models: Data structures for API requests/responses
-//   - config: Configuration management
+//   - service: Core logic for the soundtouch-service (proxy, recording, setup)
 //   - cmd/soundtouch-cli: Command-line interface tool
-//
-// # Hardware Compatibility
-//
-// This library has been tested with real Bose SoundTouch hardware and supports
-// all SoundTouch-compatible devices including:
-//   - SoundTouch 10, 20, 30 series
-//   - SoundTouch Portable
-//   - Wave SoundTouch music system
-//   - And other SoundTouch-enabled Bose speakers
+//   - cmd/soundtouch-service: Local cloud emulation service
 //
 // # Implementation Notes
 //
-// This implementation is based on the official Bose SoundTouch Web API documentation
-// and provides 90% coverage of all available endpoints. It is an independent project
-// and is not affiliated with or endorsed by Bose Corporation.
+// This project is an independent effort to preserve the functionality of Bose SoundTouch
+// devices and provide enhanced debugging and control capabilities. It is not
+// affiliated with or endorsed by Bose Corporation.
 //
 // For detailed API documentation, examples, and advanced usage patterns, visit:
 // https://pkg.go.dev/github.com/gesellix/bose-soundtouch
-package main
+package soundtouch

docker-compose.ci.yml

@@ -0,0 +1,46 @@
+services:
+  soundtouch-service:
+    build:
+      context: .
+      target: soundtouch-service
+    networks:
+      - soundtouch-test-net
+    volumes:
+      - ./tests/integration/testdata:/app/data
+    environment:
+      - SPOTIFY_CLIENT_ID=mock-id
+      - SPOTIFY_CLIENT_SECRET=mock-secret
+      - SPOTIFY_TOKEN_URL=http://spotify-mock:8080/api/token
+      - SPOTIFY_API_BASE=http://spotify-mock:8080
+      - AMAZON_CLIENT_ID=mock-amazon-id
+      - AMAZON_CLIENT_SECRET=mock-amazon-secret
+      - AMAZON_TOKEN_URL=http://amazon-mock:8080/auth/o2/token
+      - AMAZON_PROFILE_URL=http://amazon-mock:8080/user/profile
+
+  spotify-mock:
+    image: golang:1.26.3-alpine
+    container_name: spotify-mock
+    working_dir: /app
+    volumes:
+      - .:/app
+    command: go run ./cmd/mock-spotify/main.go -port 8080
+    ports:
+      - "8081:8080"
+    networks:
+      - soundtouch-test-net
+
+  amazon-mock:
+    image: golang:1.26.3-alpine
+    container_name: amazon-mock
+    working_dir: /app
+    volumes:
+      - .:/app
+    command: go run ./cmd/mock-amazon/main.go -port 8080
+    ports:
+      - "8082:8080"
+    networks:
+      - soundtouch-test-net
+
+networks:
+  soundtouch-test-net:
+    name: soundtouch-test-net

docker-compose.yml

@@ -0,0 +1,41 @@
+services:
+  soundtouch-service:
+    image: ghcr.io/gesellix/bose-soundtouch:${SOUNDTOUCH_VERSION:-latest}
+    # build: .
+    container_name: soundtouch-service
+    # Linux only, required for discovery. Swarm requires host network at the task level.
+    # network_mode: host
+    ports:
+      - "8000:8000"
+      - "8443:8443"
+    environment:
+      - PORT=8000
+      - HTTPS_PORT=8443
+      - DATA_DIR=/app/data
+      - LOG_PROXY_BODY=false
+      - REDACT_PROXY_LOGS=true
+      - RECORD_INTERACTIONS=true
+      - DISCOVERY_INTERVAL=5m
+      - SERVER_URL=http://${SOUNDTOUCH_HOSTNAME:-soundtouch.local}:8000
+      - HTTPS_SERVER_URL=https://${SOUNDTOUCH_HOSTNAME:-soundtouch.local}:8443
+    volumes:
+      - soundtouch-data:/app/data
+      # Use host volume for local development if preferred:
+      # - ./data:/app/data
+    restart: unless-stopped
+    deploy:
+      replicas: 1
+      restart_policy:
+        condition: on-failure
+      resources:
+        limits:
+          cpus: '0.50'
+          memory: 512M
+        reservations:
+          cpus: '0.25'
+          memory: 128M
+
+volumes:
+  soundtouch-data:
+    # Named volumes are preferred in Swarm. For multi-node persistence,
+    # consider using a volume driver like NFS or GlusterFS.

docs/ANONYMIZATION-SUMMARY.md

@@ -1,115 +0,0 @@
-# Data Anonymization Summary
-
-This document summarizes all changes made to anonymize personal and specific data throughout the Bose SoundTouch Go client codebase.
-
-## Overview
-
-All specific IP addresses, device IDs, device names, and other potentially personal information have been replaced with generic, example values to protect privacy while maintaining the functionality and usefulness of the documentation and test examples.
-
-## Changes Made
-
-### IP Addresses
-
-**Original → Anonymized:**
-- `192.168.178.35` → `192.168.1.10`
-- `192.168.178.28` → `192.168.1.10`
-- `192.168.1.100` → `192.168.1.10`
-- `192.168.1.101` → `192.168.1.11`
-- `192.168.1.102` → `192.168.1.12`
-
-### Device IDs
-
-**Original → Anonymized:**
-- `A81B6A536A98` → `ABCD1234EFGH`
-- `1234567890AB` → `ABCD1234EFGH`
-- `1234567890AC` → `ABCD1234EFGH`
-
-### Device Names
-
-**Original → Anonymized:**
-- `Sound Machinechen` → `My SoundTouch Device`
-
-### MAC Addresses
-
-**Original → Anonymized:**
-- `A81B6A536A98` → `AA:BB:CC:DD:EE:FF`
-- `A81B6A849D99` → `AA:BB:CC:DD:EE:FF`
-- `A8:1B:6A:53:6A:98` → `AA:BB:CC:DD:EE:FF`
-- `A8:1B:6A:84:9D:99` → `AA:BB:CC:DD:EE:01`
-
-## Files Modified
-
-### Documentation Files
-- `README.md` - Updated all IP addresses and device examples
-- `Makefile` - Updated example IP addresses in help text
-- `docs/SYSTEM-ENDPOINTS.md` - Anonymized all example data
-- `docs/VOLUME-CONTROLS.md` - Updated device IDs and IP addresses
-- `docs/KEY-CONTROLS.md` - Updated IP addresses
-- `docs/BASS-CONTROLS.md` - Updated device IDs
-- `docs/HOST-PORT-PARSING.md` - Updated IP addresses and device names
-- `docs/STATUS.md` - Updated IP addresses
-
-### Source Code Files
-- `cmd/soundtouch-cli/main.go` - Updated all example IP addresses in help text
-- `cmd/soundtouch-cli/main_test.go` - Updated test IP addresses
-
-### Test Data Files
-- `pkg/client/testdata/info_response.xml` - Updated device ID, name, and network info
-- `pkg/client/testdata/info_response_st20.xml` - Updated device ID and network info
-- `pkg/client/testdata/capabilities_response.xml` - Updated device ID
-- `pkg/client/testdata/name_response.xml` - Updated device name
-- `pkg/client/testdata/networkinfo_response.xml` - Updated device ID and network info
-- `pkg/client/testdata/clockdisplay_response.xml` - Updated device ID
-
-### Test Files
-- `pkg/client/client_test.go` - Updated device IDs, names, and IP addresses
-- `pkg/client/system_test.go` - Updated device IDs and IP addresses
-- `pkg/client/balance_test.go` - Updated device IDs in test responses
-- `pkg/client/bass_test.go` - Updated device IDs in test responses
-- `pkg/models/networkinfo_test.go` - Updated device IDs and network info
-
-## Anonymization Strategy
-
-### IP Addresses
-- Used standard RFC 1918 private IP ranges (192.168.1.x)
-- Maintained realistic network structure (same subnet for related devices)
-- Used sequential numbering (.10, .11, .12) for clarity
-
-### Device IDs
-- Used generic alphanumeric pattern `ABCD1234EFGH`
-- Maintained consistent usage across all files
-- Preserved original length and format
-
-### Device Names
-- Used generic but descriptive names like "My SoundTouch Device"
-- Removed any potentially personal identifiers
-
-### MAC Addresses
-- Used standard placeholder format `AA:BB:CC:DD:EE:FF`
-- Used sequential variants (EE:01) when multiple addresses needed
-- Maintained proper MAC address format
-
-## Verification
-
-After anonymization:
-- ✅ All tests continue to pass
-- ✅ All builds succeed
-- ✅ Documentation remains accurate and useful
-- ✅ No personal data remains in examples
-- ✅ Functionality is preserved
-
-## Benefits
-
-1. **Privacy Protection**: No personal network information exposed
-2. **Professional Examples**: Clean, generic examples suitable for public documentation
-3. **Consistency**: Uniform use of example data across all files
-4. **Maintainability**: Easy to identify example vs. real data
-
-## Standards Used
-
-- **IP Addresses**: RFC 1918 private ranges (192.168.1.x/24)
-- **Device IDs**: Generic alphanumeric placeholders
-- **MAC Addresses**: Standard placeholder format
-- **Device Names**: Generic descriptive names
-
-All changes maintain the original functionality while ensuring no personal or specific network information is exposed in the codebase.

docs/API-Endpoints-Overview.md

@@ -1,387 +0,0 @@
-# Bose SoundTouch Web API - Endpoints Overview
-
-This document provides a comprehensive overview of the available API endpoints verified against the official Bose SoundTouch Web API v1.0 specification (January 7, 2026).
-
-## Implementation Status Legend
-- ✅ **Implemented** - Fully implemented with tests and real device validation
-- ❌ **Missing** - Documented in official API but not implemented
-- 🔍 **Extra** - Implemented but not in official API v1.0 (may be newer version or undocumented)
-- ⚠️ **Different** - Implemented with different approach than official API
-
-## API Basics
-
-- **Protocol**: HTTP REST-like
-- **Data Format**: XML Request/Response
-- **Standard Port**: 8090
-- **Base URL**: `http://<device-ip>:8090/`
-- **Authentication**: No complex authentication required
-- **Real-time Updates**: WebSocket connection available
-
-## Device Information
-
-### GET /info ✅ **Implemented**
-Retrieves basic device information.
-
-**Response XML Structure:**
-```xml
-<info deviceID="..." type="..." name="..." ...>
-  <name>Device Name</name>
-  <type>Device Type</type>
-  <margeAccountUUID>UUID</margeAccountUUID>
-  <components>...</components>
-</info>
-```
-
-## Playback Control
-
-### GET /now_playing ✅ **Implemented**
-Retrieves information about the currently playing music.
-
-**Response XML Structure:**
-```xml
-<nowPlaying deviceID="..." source="...">
-  <ContentItem source="..." type="..." location="..." sourceAccount="...">
-    <itemName>Track Name</itemName>
-    <containerArt>Album Art URL</containerArt>
-  </ContentItem>
-  <track>Track Name</track>
-  <artist>Artist Name</artist>
-  <album>Album Name</album>
-  <stationName>Station Name</stationName>
-  <art artImageStatus="...">Art URL</art>
-  <playStatus>PLAY_STATE</playStatus>
-  <shuffleSetting>...</shuffleSetting>
-  <repeatSetting>...</repeatSetting>
-</nowPlaying>
-```
-
-### POST /key ✅ **Implemented**
-Sends key commands to the device.
-
-**Important**: Proper key simulation requires sending both press and release states:
-
-**Request XML (Press + Release):**
-```xml
-<key state="press" sender="Gabbo">KEY_NAME</key>
-<key state="release" sender="Gabbo">KEY_NAME</key>
-```
-
-**Available Keys:**
-
-**Playback Controls:**
-- `PLAY` - Start playback
-- `PAUSE` - Pause current playback
-- `STOP` - Stop current playback
-- `PREV_TRACK` - Go to previous track
-- `NEXT_TRACK` - Go to next track
-
-**Rating and Bookmark Controls:**
-- `THUMBS_UP` - Rate current content positively (Pandora, etc.)
-- `THUMBS_DOWN` - Rate current content negatively
-- `BOOKMARK` - Bookmark current content
-
-**Power and System Controls:**
-- `POWER` - Toggle device power state
-- `MUTE` - Toggle mute state
-
-**Volume Controls:**
-- `VOLUME_UP` - Increase volume
-- `VOLUME_DOWN` - Decrease volume
-
-**Preset Controls:**
-- `PRESET_1` to `PRESET_6` - Select preset 1-6
-
-**Input Controls:**
-- `AUX_INPUT` - Switch to auxiliary input
-
-**Shuffle Controls:**
-- `SHUFFLE_OFF` - Turn shuffle mode off
-- `SHUFFLE_ON` - Turn shuffle mode on
-
-**Repeat Controls:**
-- `REPEAT_OFF` - Turn repeat mode off
-- `REPEAT_ONE` - Repeat current track
-- `REPEAT_ALL` - Repeat all tracks in playlist
-
-## Volume Control
-
-### GET /volume ✅ **Implemented**
-Retrieves the current volume.
-
-**Response XML:**
-```xml
-<volume deviceID="...">
-  <targetvolume>50</targetvolume>
-  <actualvolume>50</actualvolume>
-  <muteenabled>false</muteenabled>
-</volume>
-```
-
-### POST /volume ✅ **Implemented**
-Sets the volume.
-
-**Request XML:**
-```xml
-<volume>50</volume>
-```
-
-## Bass Settings
-
-### GET /bass ✅ **Implemented**
-Retrieves the current bass settings.
-
-**Response XML:**
-```xml
-<bass deviceID="...">
-  <targetbass>0</targetbass>
-  <actualbass>0</actualbass>
-</bass>
-```
-
-### POST /bass ✅ **Implemented**
-Sets the bass settings (-9 to +9).
-
-**Request XML:**
-```xml
-<bass>0</bass>
-```
-
-## Source Management
-
-### GET /sources ✅ **Implemented**
-Retrieves the available audio sources.
-
-**Response XML:**
-```xml
-<sources deviceID="...">
-  <sourceItem source="SPOTIFY" sourceAccount="..." status="READY" multiroomallowed="true">
-    <itemName>Spotify</itemName>
-  </sourceItem>
-  <sourceItem source="BLUETOOTH" status="READY" multiroomallowed="false">
-    <itemName>Bluetooth</itemName>
-  </sourceItem>
-  <!-- Additional sources -->
-</sources>
-```
-
-**Typical Sources:**
-- `SPOTIFY`
-- `AMAZON`
-- `PANDORA`
-- `IHEARTRADIO`
-- `TUNEIN`
-- `BLUETOOTH`
-- `AUX`
-- `STORED_MUSIC`
-
-### POST /select ✅ **Implemented**
-Selects an audio source.
-
-**Request XML:**
-```xml
-<ContentItem source="SPOTIFY" sourceAccount="...">
-  <itemName>Spotify</itemName>
-</ContentItem>
-```
-
-## Preset Management
-
-### GET /presets ✅ **Implemented**
-Retrieves the configured presets.
-
-**Response XML:**
-```xml
-<presets deviceID="...">
-  <preset id="1" createdOn="..." updatedOn="...">
-    <ContentItem source="..." sourceAccount="..." location="...">
-      <itemName>Preset Name</itemName>
-      <containerArt>Art URL</containerArt>
-    </ContentItem>
-  </preset>
-  <!-- Additional presets -->
-</presets>
-```
-
-### POST /presets ❌ **Not Supported**
-Creates or updates a preset.
-
-**Status**: According to the official Bose SoundTouch API documentation, POST operations on `/presets` are marked as "N/A" - this endpoint officially does not support preset creation or modification via API.
-
-**Alternative Methods**:
-- Use the official Bose SoundTouch mobile app
-- Use physical preset buttons on the device (long-press while content is playing)
-- Changes made via these methods will be visible through the GET endpoint
-
-## Advanced Features
-
-### GET /getZone 🔄 **Planned**
-Retrieves multiroom zone information.
-
-### POST /setZone 🔄 **Planned**
-Configures multiroom zones.
-
-### GET /balance ✅ **Implemented**
-Retrieves balance settings (stereo devices).
-
-### POST /balance ✅ **Implemented**
-Sets balance settings.
-
-### GET /clockTime ✅ **Implemented**
-Retrieves the device time.
-
-### POST /clockTime ✅ **Implemented**
-Sets the device time.
-
-### GET /clockDisplay ✅ **Implemented**
-Retrieves clock display settings.
-
-### POST /clockDisplay ✅ **Implemented**
-Configures the clock display.
-
-## WebSocket Connection
-
-### WebSocket / 🔄 **Planned**
-Establishes a persistent connection for live updates.
-
-**Event Types:**
-- `nowPlayingUpdated`
-- `volumeUpdated`
-- `connectionStateUpdated`
-- `presetUpdated`
-
-## Network and System
-
-### GET /networkInfo ✅ **Implemented**
-Retrieves network information.
-
-### GET /capabilities ✅ **Implemented**
-Retrieves device capabilities.
-
-### GET /name 🔍 **Extra** 
-Retrieves the device name.
-
-**Note**: Official API only documents `POST /name` for setting device name. Our GET implementation appears to be an undocumented extension.
-
-### POST /name ❌ **Missing**
-Sets the device name.
-
-**Official Request Format:**
-```xml
-<name>$STRING</name>
-```
-
-### GET /bassCapabilities ❌ **Missing**
-Checks if bass customization is supported on the device.
-
-**Official Response Format:**
-```xml
-<bassCapabilities deviceID="$MACADDR">
-    <bassAvailable>$BOOL</bassAvailable>
-    <bassMin>$INT</bassMin>
-    <bassMax>$INT</bassMax>
-    <bassDefault>$INT</bassDefault>
-</bassCapabilities>
-```
-
-### GET /trackInfo ❌ **Missing**
-Gets track information (appears to be duplicate of `/now_playing`).
-
-**Note**: Official API documents this as separate endpoint but with identical response format to `/now_playing`.
-
-### Zone Slave Management ⚠️ **Different Implementation**
-Our implementation uses high-level methods instead of official endpoints:
-- **Official**: `/addZoneSlave` (POST) - Add slave to zone
-- **Official**: `/removeZoneSlave` (POST) - Remove slave from zone  
-- **Our Implementation**: `AddToZone()` and `RemoveFromZone()` methods via `/setZone`
-
-**Status**: Functionally equivalent and arguably cleaner approach.
-
-### Advanced Audio Controls ❌ **Missing**
-Professional/high-end device features (only available via `/capabilities` check):
-
-#### `/audiodspcontrols` - GET/POST
-Access DSP settings including audio modes and video sync delay.
-
-#### `/audioproducttonecontrols` - GET/POST  
-Advanced bass and treble controls (beyond basic `/bass` endpoint).
-
-#### `/audioproductlevelcontrols` - GET/POST
-Speaker level controls for front-center and rear-surround speakers.
-
-### Clock and Network Endpoints 🔍 **Extra**
-These endpoints work with real hardware but are NOT in official API v1.0:
-- `GET/POST /clockTime` ✅ **Implemented** - Device time management
-- `GET/POST /clockDisplay` ✅ **Implemented** - Clock display settings  
-- `GET /networkInfo` ✅ **Implemented** - Network information
-
-### Balance Control 🔍 **Extra**
-- `GET/POST /balance` ✅ **Implemented** - Stereo balance adjustment
-
-**Note**: Not documented in official API v1.0 but works with real devices.
-
-## Coverage Summary
-
-### Official API Coverage: 94%
-- **Total Official Endpoints**: 19
-- **Implemented**: 15 (79%)
-- **Missing Low-Impact**: 4 (21%)
-
-### Feature Coverage: 100%
-- ✅ All essential user functionality implemented
-- ✅ All core device operations supported
-- ✅ Complete WebSocket event system
-- ✅ Full multiroom capabilities
-- 🔍 Additional features beyond official specification
-
-
-## Error Handling
-
-The API uses standard HTTP status codes:
-- `200 OK` - Successful request
-- `400 Bad Request` - Invalid request
-- `404 Not Found` - Endpoint or resource not found
-- `500 Internal Server Error` - Internal device error
-
-## Example Implementation
-
-```go
-// Example for a GET request
-func GetNowPlaying(deviceIP string) (*NowPlaying, error) {
-    url := fmt.Sprintf("http://%s:8090/now_playing", deviceIP)
-    resp, err := http.Get(url)
-    if err != nil {
-        return nil, err
-    }
-    defer resp.Body.Close()
-    
-    var nowPlaying NowPlaying
-    err = xml.NewDecoder(resp.Body).Decode(&nowPlaying)
-    return &nowPlaying, err
-}
-
-// Example for a POST request
-func SendKey(deviceIP string, key string) error {
-    url := fmt.Sprintf("http://%s:8090/key", deviceIP)
-    xmlData := fmt.Sprintf(`<key state="press" sender="GoClient">%s</key>`, key)
-    
-    resp, err := http.Post(url, "application/xml", strings.NewReader(xmlData))
-    if err != nil {
-        return err
-    }
-    resp.Body.Close()
-    return nil
-}
-```
-
-## Notes
-
-1. **XML Namespace**: Most responses use no explicit XML namespace
-2. **Encoding**: UTF-8 is used for all XML documents
-3. **Timeouts**: Recommended timeout for HTTP requests: 10 seconds
-4. **Rate Limiting**: No explicit limits documented, but moderate usage recommended
-5. **Device Discovery**: Devices can be found via UPnP on the local network
-
-## Reference
-
-Based on the official Bose SoundTouch Web API documentation:
-https://assets.bosecreative.com/m/496577402d128874/original/SoundTouch-Web-API.pdf

docs/API-NAVIGATION-REFERENCE.md

@@ -0,0 +1,809 @@
+# Navigation API Reference
+
+## Overview
+
+This document provides a complete API reference for the Bose SoundTouch navigation and station management functionality. For usage examples and workflows, see [NAVIGATION-GUIDE.md](NAVIGATION-GUIDE.md).
+
+## Table of Contents
+
+- [Client Methods](#client-methods)
+- [Models](#models)
+- [HTTP Endpoints](#http-endpoints)
+- [XML Schemas](#xml-schemas)
+- [Error Codes](#error-codes)
+
+## Client Methods
+
+### Navigation Methods
+
+#### `Navigate(source, sourceAccount string, startItem, numItems int) (*models.NavigateResponse, error)`
+
+Browse content within a source.
+
+**Parameters:**
+- `source` (string, required): Content source identifier
+  - Valid values: `"TUNEIN"`, `"PANDORA"`, `"SPOTIFY"`, `"STORED_MUSIC"`, `"BLUETOOTH"`, `"AUX"`
+- `sourceAccount` (string, optional): Account identifier for authenticated sources
+- `startItem` (int, required): Starting position (1-based index)
+- `numItems` (int, required): Number of items to retrieve
+
+**Returns:**
+- `*models.NavigateResponse`: Navigation results with items and metadata
+- `error`: Error if request fails
+
+**Example:**
+```go
+response, err := client.Navigate("TUNEIN", "", 1, 25)
+```
+
+**Validation:**
+- `source` cannot be empty
+- `startItem` must be >= 1
+- `numItems` must be >= 1
+
+---
+
+#### `NavigateWithMenu(source, sourceAccount, menu, sort string, startItem, numItems int) (*models.NavigateResponse, error)`
+
+Browse content with specific menu and sorting options (primarily for Pandora).
+
+**Parameters:**
+- `source` (string, required): Content source identifier
+- `sourceAccount` (string, optional): Account identifier
+- `menu` (string, optional): Menu context (e.g., `"radioStations"`)
+- `sort` (string, optional): Sort order (e.g., `"dateCreated"`)
+- `startItem` (int, required): Starting position (1-based)
+- `numItems` (int, required): Number of items to retrieve
+
+**Returns:**
+- `*models.NavigateResponse`: Navigation results
+- `error`: Error if request fails
+
+**Example:**
+```go
+response, err := client.NavigateWithMenu("PANDORA", "user123", "radioStations", "dateCreated", 1, 100)
+```
+
+---
+
+#### `NavigateContainer(source, sourceAccount string, startItem, numItems int, containerItem *models.ContentItem) (*models.NavigateResponse, error)`
+
+Browse into a specific container/directory.
+
+**Parameters:**
+- `source` (string, required): Content source identifier
+- `sourceAccount` (string, optional): Account identifier
+- `startItem` (int, required): Starting position (1-based)
+- `numItems` (int, required): Number of items to retrieve
+- `containerItem` (*models.ContentItem, required): Container to browse into
+
+**Returns:**
+- `*models.NavigateResponse`: Container contents
+- `error`: Error if request fails
+
+**Example:**
+```go
+response, err := client.NavigateContainer("STORED_MUSIC", "device/0", 1, 100, albumContentItem)
+```
+
+**Validation:**
+- `containerItem` cannot be nil
+- Container must have valid `Location` field
+
+---
+
+### Convenience Navigation Methods
+
+#### `GetTuneInStations(sourceAccount string) (*models.NavigateResponse, error)`
+
+Browse TuneIn radio stations.
+
+**Parameters:**
+- `sourceAccount` (string, optional): TuneIn account (usually empty)
+
+**Returns:**
+- `*models.NavigateResponse`: TuneIn stations and content
+
+**Example:**
+```go
+stations, err := client.GetTuneInStations("")
+```
+
+---
+
+#### `GetPandoraStations(sourceAccount string) (*models.NavigateResponse, error)`
+
+Browse Pandora radio stations with proper sorting.
+
+**Parameters:**
+- `sourceAccount` (string, required): Pandora user account identifier
+
+**Returns:**
+- `*models.NavigateResponse`: Pandora stations sorted by creation date
+
+**Example:**
+```go
+stations, err := client.GetPandoraStations("user123")
+```
+
+**Validation:**
+- `sourceAccount` cannot be empty
+
+---
+
+#### `GetStoredMusicLibrary(sourceAccount string) (*models.NavigateResponse, error)`
+
+Browse stored/local music library.
+
+**Parameters:**
+- `sourceAccount` (string, required): Device account identifier (format: `deviceID/index`)
+
+**Returns:**
+- `*models.NavigateResponse`: Music library root contents
+
+**Example:**
+```go
+library, err := client.GetStoredMusicLibrary("AABBCCDDEEFF/0")
+```
+
+**Validation:**
+- `sourceAccount` cannot be empty
+
+---
+
+### Search Methods
+
+#### `SearchStation(source, sourceAccount, searchTerm string) (*models.SearchStationResponse, error)`
+
+Search for stations and content within a music service.
+
+**Parameters:**
+- `source` (string, required): Service to search
+- `sourceAccount` (string, optional): Account identifier
+- `searchTerm` (string, required): Search query
+
+**Returns:**
+- `*models.SearchStationResponse`: Search results categorized by type
+- `error`: Error if request fails
+
+**Example:**
+```go
+results, err := client.SearchStation("PANDORA", "user123", "jazz")
+```
+
+**Validation:**
+- `source` cannot be empty
+- `searchTerm` cannot be empty
+
+---
+
+#### `SearchTuneInStations(searchTerm string) (*models.SearchStationResponse, error)`
+
+Search TuneIn radio stations.
+
+**Parameters:**
+- `searchTerm` (string, required): Search query
+
+**Returns:**
+- `*models.SearchStationResponse`: TuneIn search results
+
+**Example:**
+```go
+results, err := client.SearchTuneInStations("classical music")
+```
+
+---
+
+#### `SearchPandoraStations(sourceAccount, searchTerm string) (*models.SearchStationResponse, error)`
+
+Search Pandora for artists and stations.
+
+**Parameters:**
+- `sourceAccount` (string, required): Pandora account identifier
+- `searchTerm` (string, required): Artist or genre to search for
+
+**Returns:**
+- `*models.SearchStationResponse`: Pandora search results with songs, artists, stations
+
+**Example:**
+```go
+results, err := client.SearchPandoraStations("user123", "Taylor Swift")
+```
+
+**Validation:**
+- `sourceAccount` cannot be empty
+
+---
+
+#### `SearchSpotifyContent(sourceAccount, searchTerm string) (*models.SearchStationResponse, error)`
+
+Search Spotify for tracks, albums, and playlists.
+
+**Parameters:**
+- `sourceAccount` (string, required): Spotify account identifier
+- `searchTerm` (string, required): Content to search for
+
+**Returns:**
+- `*models.SearchStationResponse`: Spotify search results
+
+**Example:**
+```go
+results, err := client.SearchSpotifyContent("user@example.com", "Queen")
+```
+
+**Validation:**
+- `sourceAccount` cannot be empty
+
+---
+
+### Station Management Methods
+
+#### `AddStation(source, sourceAccount, token, name string) error`
+
+Add a station to music service collection and immediately start playing it.
+
+**Parameters:**
+- `source` (string, required): Music service identifier
+- `sourceAccount` (string, optional): Account identifier
+- `token` (string, required): Station token from search results
+- `name` (string, required): Display name for the station
+
+**Returns:**
+- `error`: Error if operation fails
+
+**Example:**
+```go
+err := client.AddStation("PANDORA", "user123", "R4328162", "Classic Rock Radio")
+```
+
+**Behavior:**
+- Station is immediately selected and starts playing
+- Station is added to user's collection permanently
+- Generates `presetsUpdated` WebSocket event if station is stored as preset
+
+**Validation:**
+- `source` cannot be empty
+- `token` cannot be empty
+- `name` cannot be empty
+
+---
+
+#### `RemoveStation(contentItem *models.ContentItem) error`
+
+Remove a station from music service collection.
+
+**Parameters:**
+- `contentItem` (*models.ContentItem, required): Station content item with source and location
+
+**Returns:**
+- `error`: Error if operation fails
+
+**Example:**
+```go
+err := client.RemoveStation(stationContentItem)
+```
+
+**Behavior:**
+- Station is removed from user's collection
+- If station is currently playing, playback stops
+- Generates `nowPlayingUpdated` WebSocket event if playing station was removed
+
+**Validation:**
+- `contentItem` cannot be nil
+- `contentItem.Source` cannot be empty
+- `contentItem.Location` cannot be empty
+
+---
+
+## Models
+
+### NavigateRequest
+
+Request structure for `/navigate` endpoint.
+
+```go
+type NavigateRequest struct {
+    Source        string        `xml:"source,attr"`
+    SourceAccount string        `xml:"sourceAccount,attr,omitempty"`
+    Menu          string        `xml:"menu,attr,omitempty"`
+    Sort          string        `xml:"sort,attr,omitempty"`
+    StartItem     int           `xml:"startItem"`
+    NumItems      int           `xml:"numItems"`
+    Item          *NavigateItem `xml:"item,omitempty"`
+}
+```
+
+**Constructors:**
+- `NewNavigateRequest(source, sourceAccount string, startItem, numItems int)`
+- `NewNavigateRequestWithMenu(source, sourceAccount, menu, sort string, startItem, numItems int)`
+- `NewNavigateRequestWithItem(source, sourceAccount string, startItem, numItems int, item *ContentItem)`
+
+---
+
+### NavigateResponse
+
+Response structure from navigation operations.
+
+```go
+type NavigateResponse struct {
+    Source        string         `xml:"source,attr"`
+    SourceAccount string         `xml:"sourceAccount,attr,omitempty"`
+    TotalItems    int            `xml:"totalItems"`
+    Items         []NavigateItem `xml:"items>item"`
+}
+```
+
+**Helper Methods:**
+- `GetPlayableItems() []NavigateItem` - Filter items with `Playable="1"`
+- `GetDirectories() []NavigateItem` - Filter directory items (`type="dir"`)
+- `GetTracks() []NavigateItem` - Filter track items (`type="track"`)
+- `GetStations() []NavigateItem` - Filter station items (`type="stationurl"`)
+- `IsEmpty() bool` - Check if response has no items
+
+---
+
+### NavigateItem
+
+Individual item within navigation response.
+
+```go
+type NavigateItem struct {
+    Playable           int                 `xml:"Playable,attr,omitempty"`
+    Name               string              `xml:"name"`
+    Type               string              `xml:"type"`
+    ContentItem        *ContentItem        `xml:"ContentItem,omitempty"`
+    MediaItemContainer *MediaItemContainer `xml:"mediaItemContainer,omitempty"`
+    ArtistName         string              `xml:"artistName,omitempty"`
+    AlbumName          string              `xml:"albumName,omitempty"`
+}
+```
+
+**Helper Methods:**
+- `GetDisplayName() string` - Get formatted display name
+- `IsPlayable() bool` - Check if `Playable="1"`
+- `IsDirectory() bool` - Check if `type="dir"`
+- `IsTrack() bool` - Check if `type="track"`
+- `IsStation() bool` - Check if `type="stationurl"`
+- `GetContentItem() *ContentItem` - Get associated content item
+- `GetArtwork() string` - Get artwork URL from content item
+
+**Common Type Values:**
+- `"dir"` - Directory/container
+- `"track"` - Music track
+- `"stationurl"` - Radio station
+- `"playlist"` - Playlist
+- `"album"` - Album
+
+---
+
+### SearchStationRequest
+
+Request structure for station search.
+
+```go
+type SearchStationRequest struct {
+    Source        string `xml:"source,attr"`
+    SourceAccount string `xml:"sourceAccount,attr,omitempty"`
+    SearchTerm    string `xml:",chardata"`
+}
+```
+
+**Constructor:**
+- `NewSearchStationRequest(source, sourceAccount, searchTerm string)`
+
+---
+
+### SearchStationResponse
+
+Response structure from search operations.
+
+```go
+type SearchStationResponse struct {
+    DeviceID      string         `xml:"deviceID,attr"`
+    Source        string         `xml:"source,attr"`
+    SourceAccount string         `xml:"sourceAccount,attr,omitempty"`
+    Songs         []SearchResult `xml:"songs>searchResult"`
+    Artists       []SearchResult `xml:"artists>searchResult"`
+    Stations      []SearchResult `xml:"stations>searchResult"`
+}
+```
+
+**Helper Methods:**
+- `GetSongs() []SearchResult` - Get song results
+- `GetArtists() []SearchResult` - Get artist results
+- `GetStations() []SearchResult` - Get station results
+- `GetAllResults() []SearchResult` - Get all results combined
+- `GetResultCount() int` - Count total results
+- `HasResults() bool` - Check if any results found
+- `IsEmpty() bool` - Check if no results
+
+---
+
+### SearchResult
+
+Individual search result item.
+
+```go
+type SearchResult struct {
+    Source        string `xml:"source,attr"`
+    SourceAccount string `xml:"sourceAccount,attr,omitempty"`
+    Token         string `xml:"token,attr"`
+    Name          string `xml:"name"`
+    Artist        string `xml:"artist,omitempty"`
+    Album         string `xml:"album,omitempty"`
+    Logo          string `xml:"logo,omitempty"`
+    Description   string `xml:"description,omitempty"`
+}
+```
+
+**Helper Methods:**
+- `IsSong() bool` - Check if result is a song (has `Artist` field)
+- `IsArtist() bool` - Check if result is an artist (no `Artist` or `Description`)
+- `IsStation() bool` - Check if result is a station (has `Description`)
+- `GetDisplayName() string` - Get formatted name
+- `GetFullTitle() string` - Get name with artist for songs
+- `GetArtworkURL() string` - Get logo/artwork URL
+
+**Token Usage:**
+The `Token` field is used with `AddStation()` to add the result to your collection.
+
+---
+
+### AddStationRequest
+
+Request structure for adding stations.
+
+```go
+type AddStationRequest struct {
+    Source        string `xml:"source,attr"`
+    SourceAccount string `xml:"sourceAccount,attr,omitempty"`
+    Token         string `xml:"token,attr"`
+    Name          string `xml:"name"`
+}
+```
+
+**Constructor:**
+- `NewAddStationRequest(source, sourceAccount, token, name string)`
+
+---
+
+### StationResponse
+
+Response structure from station management operations.
+
+```go
+type StationResponse struct {
+    Status string `xml:",chardata"`
+}
+```
+
+**Common Values:**
+- `"/addStation"` - Station added successfully
+- `"/removeStation"` - Station removed successfully
+
+---
+
+## HTTP Endpoints
+
+### POST /navigate
+
+Browse content within a source.
+
+**Request Body:**
+```xml
+<navigate source="TUNEIN" sourceAccount="">
+  <startItem>1</startItem>
+  <numItems>25</numItems>
+</navigate>
+```
+
+**Response Body:**
+```xml
+<navigateResponse source="TUNEIN">
+  <totalItems>5</totalItems>
+  <items>
+    <item Playable="1">
+      <name>Station Name</name>
+      <type>stationurl</type>
+      <ContentItem source="TUNEIN" location="/v1/playback/station/s12345" isPresetable="true">
+        <itemName>Station Name</itemName>
+      </ContentItem>
+    </item>
+  </items>
+</navigateResponse>
+```
+
+---
+
+### POST /searchStation
+
+Search for stations and content.
+
+**Request Body:**
+```xml
+<search source="PANDORA" sourceAccount="user123">Taylor Swift</search>
+```
+
+**Response Body:**
+```xml
+<results deviceID="AABBCCDDEEFF" source="PANDORA" sourceAccount="user123">
+  <songs>
+    <searchResult source="PANDORA" sourceAccount="user123" token="S123">
+      <name>Love Story</name>
+      <artist>Taylor Swift</artist>
+      <logo>http://example.com/artwork.jpg</logo>
+    </searchResult>
+  </songs>
+  <artists>
+    <searchResult source="PANDORA" sourceAccount="user123" token="R456">
+      <name>Taylor Swift</name>
+      <logo>http://example.com/artist.jpg</logo>
+    </searchResult>
+  </artists>
+</results>
+```
+
+---
+
+### POST /addStation
+
+Add a station to collection and start playing.
+
+**Request Body:**
+```xml
+<addStation source="PANDORA" sourceAccount="user123" token="R456">
+  <name>Taylor Swift Radio</name>
+</addStation>
+```
+
+**Response Body:**
+```xml
+<status>/addStation</status>
+```
+
+---
+
+### POST /removeStation
+
+Remove a station from collection.
+
+**Request Body:**
+```xml
+<ContentItem source="PANDORA" location="126740707481236361" sourceAccount="user123" isPresetable="true">
+  <itemName>Taylor Swift Radio</itemName>
+</ContentItem>
+```
+
+**Response Body:**
+```xml
+<status>/removeStation</status>
+```
+
+---
+
+## XML Schemas
+
+### Navigate Request Schema
+
+```xml
+<xs:element name="navigate">
+  <xs:complexType>
+    <xs:sequence>
+      <xs:element name="startItem" type="xs:int"/>
+      <xs:element name="numItems" type="xs:int"/>
+      <xs:element name="item" minOccurs="0">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="type" type="xs:string"/>
+            <xs:element name="ContentItem" type="ContentItemType"/>
+          </xs:sequence>
+          <xs:attribute name="Playable" type="xs:int"/>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="source" type="xs:string" use="required"/>
+    <xs:attribute name="sourceAccount" type="xs:string"/>
+    <xs:attribute name="menu" type="xs:string"/>
+    <xs:attribute name="sort" type="xs:string"/>
+  </xs:complexType>
+</xs:element>
+```
+
+### Search Request Schema
+
+```xml
+<xs:element name="search">
+  <xs:complexType>
+    <xs:simpleContent>
+      <xs:extension base="xs:string">
+        <xs:attribute name="source" type="xs:string" use="required"/>
+        <xs:attribute name="sourceAccount" type="xs:string"/>
+      </xs:extension>
+    </xs:simpleContent>
+  </xs:complexType>
+</xs:element>
+```
+
+### ContentItem Type Schema
+
+```xml
+<xs:complexType name="ContentItemType">
+  <xs:sequence>
+    <xs:element name="itemName" type="xs:string" minOccurs="0"/>
+    <xs:element name="containerArt" type="xs:string" minOccurs="0"/>
+  </xs:sequence>
+  <xs:attribute name="source" type="xs:string" use="required"/>
+  <xs:attribute name="type" type="xs:string"/>
+  <xs:attribute name="location" type="xs:string"/>
+  <xs:attribute name="sourceAccount" type="xs:string"/>
+  <xs:attribute name="isPresetable" type="xs:boolean"/>
+</xs:complexType>
+```
+
+---
+
+## Error Codes
+
+### HTTP Status Codes
+
+| Status | Meaning | Description |
+|--------|---------|-------------|
+| 200 | OK | Request successful |
+| 400 | Bad Request | Invalid parameters or XML |
+| 404 | Not Found | Endpoint or content not found |
+| 500 | Internal Server Error | Device error |
+
+### Common Error Responses
+
+**Invalid Source:**
+```xml
+<error>
+  <code>INVALID_SOURCE</code>
+  <message>Source 'INVALID' is not available</message>
+</error>
+```
+
+**Authentication Required:**
+```xml
+<error>
+  <code>AUTH_REQUIRED</code>
+  <message>Source account required for this service</message>
+</error>
+```
+
+**Service Unavailable:**
+```xml
+<error>
+  <code>SERVICE_UNAVAILABLE</code>
+  <message>PANDORA service is not configured</message>
+</error>
+```
+
+### Client-Side Validation Errors
+
+The Go client performs validation before sending requests:
+
+| Error Message | Cause | Solution |
+|---------------|-------|----------|
+| `"source cannot be empty"` | Empty source parameter | Provide valid source |
+| `"search term cannot be empty"` | Empty search query | Provide search term |
+| `"startItem must be >= 1"` | Invalid start position | Use 1-based indexing |
+| `"numItems must be >= 1"` | Invalid page size | Use positive number |
+| `"content item cannot be nil"` | Nil ContentItem | Provide valid ContentItem |
+| `"container item cannot be nil"` | Nil container for NavigateContainer | Provide valid container |
+| `"Pandora source account cannot be empty"` | Missing Pandora account | Configure Pandora account |
+| `"token cannot be empty"` | Missing station token | Use token from search results |
+| `"station name cannot be empty"` | Missing station name | Provide station name |
+
+---
+
+## WebSocket Events
+
+Navigation and station operations generate WebSocket events:
+
+### presetsUpdated
+
+Generated when stations are added/removed that affect presets.
+
+```xml
+<presetsUpdated deviceID="AABBCCDDEEFF">
+  <presets>
+    <!-- Updated preset list -->
+  </presets>
+</presetsUpdated>
+```
+
+### nowPlayingUpdated
+
+Generated when station operations affect current playback.
+
+```xml
+<nowPlayingUpdated deviceID="AABBCCDDEEFF">
+  <nowPlaying source="PANDORA">
+    <ContentItem source="PANDORA" location="R456" sourceAccount="user123" isPresetable="true">
+      <itemName>Taylor Swift Radio</itemName>
+    </ContentItem>
+    <track>Love Story</track>
+    <artist>Taylor Swift</artist>
+    <playStatus>PLAY_STATE</playStatus>
+  </nowPlaying>
+</nowPlayingUpdated>
+```
+
+---
+
+## Best Practices
+
+### Parameter Validation
+
+Always validate parameters before API calls:
+
+```go
+func validateNavigateParams(source string, startItem, numItems int) error {
+    if source == "" {
+        return fmt.Errorf("source cannot be empty")
+    }
+    if startItem < 1 {
+        return fmt.Errorf("startItem must be >= 1")
+    }
+    if numItems < 1 {
+        return fmt.Errorf("numItems must be >= 1")
+    }
+    return nil
+}
+```
+
+### Error Handling
+
+Handle both network and API errors:
+
+```go
+response, err := client.Navigate("TUNEIN", "", 1, 25)
+if err != nil {
+    // Check if it's a known API error
+    if strings.Contains(err.Error(), "not available") {
+        log.Printf("TuneIn not configured on device")
+        return
+    }
+    return fmt.Errorf("navigation failed: %w", err)
+}
+```
+
+### Pagination
+
+Use appropriate page sizes for different contexts:
+
+```go
+// Small pages for interactive browsing
+response, err := client.Navigate("TUNEIN", "", 1, 25)
+
+// Larger pages for bulk processing
+response, err := client.Navigate("STORED_MUSIC", "device/0", 1, 100)
+```
+
+### Resource Management
+
+Cache frequently accessed data:
+
+```go
+type CachedClient struct {
+    client      *client.Client
+    sources     *models.Sources
+    sourcesTime time.Time
+}
+
+func (c *CachedClient) GetSources() (*models.Sources, error) {
+    if c.sources == nil || time.Since(c.sourcesTime) > 5*time.Minute {
+        var err error
+        c.sources, err = c.client.GetSources()
+        c.sourcesTime = time.Now()
+        return c.sources, err
+    }
+    return c.sources, nil
+}
+```
+
+---
+
+*For complete usage examples and workflows, see [NAVIGATION-GUIDE.md](NAVIGATION-GUIDE.md).*

docs/CLAUDE.md

@@ -4,9 +4,9 @@
 
 This document contains important development guidelines for working on the Bose SoundTouch project. Please also read the following documentation:
 
-- **[PLAN.md](PLAN.md)** - Project planning and roadmap
+- **[PLAN.md](archive/PLAN.md)** - Project planning and roadmap
 - **[PROJECT-PATTERNS.md](PROJECT-PATTERNS.md)** - Project structure and design patterns
-- **[API-Endpoints-Overview.md](API-Endpoints-Overview.md)** - API endpoints overview
+- **[API-ENDPOINTS.md](reference/API-ENDPOINTS.md)** - API endpoints overview
 - **[SoundTouch Web API.pdf](2025.12.18%20SoundTouch%20Web%20API.pdf)** - Official API documentation
 
 ## Development Guidelines
@@ -73,8 +73,8 @@ For web components:
 When creating test data for API endpoints, prefer real device responses over hypothetical examples:
 
 - **Available test endpoints**:
-  - `http://192.168.178.28:8090/now_playing` - Different response type 1
-  - `http://192.168.178.35:8090/now_playing` - Different response type 2
+  - `http://192.0.2.11:8090/now_playing` - Different response type 1
+  - `http://192.0.2.10:8090/now_playing` - Different response type 2
 - **Usage**: Fetch real responses to create accurate test fixtures
 - **Privacy**: Anonymize any personal data (account names, personal playlists, etc.)
 - **Coverage**: Use multiple real devices to cover different response variations
@@ -95,4 +95,3 @@ When creating test data for API endpoints, prefer real device responses over hyp
 - **Documentation**: Completely in English for international accessibility
 - Conduct regular code reviews
 - Consider performance from the beginning
-

docs/CLI-REFERENCE.md

@@ -1,602 +0,0 @@
-# SoundTouch CLI Reference
-
-**Complete command reference for the soundtouch-cli tool**
-
-This document provides comprehensive documentation for all available commands and options in the `soundtouch-cli` tool.
-
-## Overview
-
-The SoundTouch CLI uses a hierarchical command structure with subcommands for different operations:
-
-```bash
-soundtouch-cli [global-flags] <command> [command-flags] [subcommand] [subcommand-flags]
-```
-
-## Global Flags
-
-These flags can be used with any command:
-
-| Flag | Short | Description | Default |
-|------|-------|-------------|---------|
-| `--host` | `-h` | Device IP address or hostname | Required for most commands |
-| `--port` | `-p` | Device port number | `8090` |
-| `--timeout` | `-t` | Request timeout duration | `10s` |
-| `--help` | | Show command help | |
-| `--version` | `-v` | Show CLI version | |
-
-## Commands
-
-### Discovery
-
-Discover SoundTouch devices on the network.
-
-#### `discover devices`
-
-Discover and list all SoundTouch devices.
-
-```bash
-soundtouch-cli discover devices [flags]
-```
-
-**Flags:**
-- `--all`, `-a`: Show detailed information for all devices
-- `--timeout`: Discovery timeout (default: 10s)
-
-**Examples:**
-```bash
-# Basic discovery
-soundtouch-cli discover devices
-
-# Show detailed info for all discovered devices
-soundtouch-cli discover devices --all
-
-# Discovery with custom timeout
-soundtouch-cli discover devices --timeout 15s
-```
-
-### Device Information
-
-Get information about your SoundTouch device.
-
-#### `info`
-
-Get basic device information.
-
-```bash
-soundtouch-cli --host <device> info
-```
-
-**Example:**
-```bash
-soundtouch-cli --host 192.168.1.10 info
-```
-
-#### `name get|set`
-
-Get or set the device name.
-
-```bash
-# Get current name
-soundtouch-cli --host <device> name get
-
-# Set new name
-soundtouch-cli --host <device> name set --value "My SoundTouch"
-```
-
-#### `capabilities`
-
-Get device capabilities and features.
-
-```bash
-soundtouch-cli --host <device> capabilities
-```
-
-#### `presets`
-
-Get configured presets.
-
-```bash
-soundtouch-cli --host <device> presets
-```
-
-### Playback Control
-
-Control music playback on your device.
-
-#### `play <subcommand>`
-
-Playback control commands.
-
-```bash
-# Get current playback status
-soundtouch-cli --host <device> play now
-
-# Start playback
-soundtouch-cli --host <device> play start
-
-# Pause playback
-soundtouch-cli --host <device> play pause
-
-# Stop playback
-soundtouch-cli --host <device> play stop
-
-# Next track
-soundtouch-cli --host <device> play next
-
-# Previous track
-soundtouch-cli --host <device> play prev
-```
-
-#### `preset`
-
-Select a preset by number.
-
-```bash
-soundtouch-cli --host <device> preset --preset <1-6>
-```
-
-**Examples:**
-```bash
-# Select preset 1
-soundtouch-cli --host 192.168.1.10 preset --preset 1
-
-# Select preset 6
-soundtouch-cli --host 192.168.1.10 preset --preset 6
-```
-
-#### `track`
-
-Get current track information.
-
-```bash
-soundtouch-cli --host <device> track
-```
-
-### Key Commands
-
-Send key commands to the device (simulates remote control).
-
-#### `key <subcommand>`
-
-Send various key commands.
-
-```bash
-# Send generic key command
-soundtouch-cli --host <device> key send --key <KEY_NAME>
-
-# Specific key commands
-soundtouch-cli --host <device> key power
-soundtouch-cli --host <device> key mute
-soundtouch-cli --host <device> key thumbs-up
-soundtouch-cli --host <device> key thumbs-down
-soundtouch-cli --host <device> key volume-up
-soundtouch-cli --host <device> key volume-down
-```
-
-**Available Key Names:**
-- `PLAY`, `PAUSE`, `STOP`
-- `POWER`, `MUTE`
-- `VOLUME_UP`, `VOLUME_DOWN`
-- `PRESET_1` through `PRESET_6`
-- `NEXT_TRACK`, `PREV_TRACK`
-- `THUMBS_UP`, `THUMBS_DOWN`
-- `SHUFFLE_ON`, `SHUFFLE_OFF`
-- `REPEAT_ON`, `REPEAT_OFF`
-
-### Volume Control
-
-Manage device volume.
-
-#### `volume <subcommand>`
-
-Volume control commands.
-
-```bash
-# Get current volume
-soundtouch-cli --host <device> volume get
-
-# Set specific volume level (0-100)
-soundtouch-cli --host <device> volume set --level <0-100>
-
-# Increase volume
-soundtouch-cli --host <device> volume up [--amount <1-10>]
-
-# Decrease volume
-soundtouch-cli --host <device> volume down [--amount <1-10>]
-```
-
-**Examples:**
-```bash
-# Get volume
-soundtouch-cli --host 192.168.1.10 volume get
-
-# Set volume to 50
-soundtouch-cli --host 192.168.1.10 volume set --level 50
-
-# Increase volume by 5
-soundtouch-cli --host 192.168.1.10 volume up --amount 5
-
-# Decrease volume by 3 (default amount is 2)
-soundtouch-cli --host 192.168.1.10 volume down --amount 3
-```
-
-### Audio Sources
-
-Manage audio input sources.
-
-#### `source <subcommand>`
-
-Audio source commands.
-
-```bash
-# List available sources
-soundtouch-cli --host <device> source list
-
-# Select specific source
-soundtouch-cli --host <device> source select --source <SOURCE> [--account <ACCOUNT>]
-
-# Quick source selection
-soundtouch-cli --host <device> source spotify
-soundtouch-cli --host <device> source bluetooth
-soundtouch-cli --host <device> source aux
-```
-
-**Source Names:**
-- `SPOTIFY` - Spotify streaming
-- `BLUETOOTH` - Bluetooth input
-- `AUX` - AUX input
-- `AIRPLAY` - AirPlay
-- `STORED_MUSIC` - Local music library
-- `INTERNET_RADIO` - Internet radio
-- `PRODUCT` - Product-specific sources
-
-**Examples:**
-```bash
-# List all sources
-soundtouch-cli --host 192.168.1.10 source list
-
-# Select Spotify
-soundtouch-cli --host 192.168.1.10 source spotify
-
-# Select Spotify with specific account
-soundtouch-cli --host 192.168.1.10 source select --source SPOTIFY --account user@example.com
-
-# Select Bluetooth
-soundtouch-cli --host 192.168.1.10 source bluetooth
-```
-
-### Bass Control
-
-Adjust bass levels (equalizer).
-
-#### `bass <subcommand>`
-
-Bass control commands.
-
-```bash
-# Get current bass level
-soundtouch-cli --host <device> bass get
-
-# Set bass level (-9 to 9)
-soundtouch-cli --host <device> bass set --level <-9 to 9>
-
-# Increase bass
-soundtouch-cli --host <device> bass up [--amount <1-5>]
-
-# Decrease bass
-soundtouch-cli --host <device> bass down [--amount <1-5>]
-
-# Get bass capabilities
-soundtouch-cli --host <device> bass capabilities
-```
-
-**Examples:**
-```bash
-# Get current bass
-soundtouch-cli --host 192.168.1.10 bass get
-
-# Set bass to +3
-soundtouch-cli --host 192.168.1.10 bass set --level 3
-
-# Increase bass by 2
-soundtouch-cli --host 192.168.1.10 bass up --amount 2
-
-# Decrease bass by 1 (default)
-soundtouch-cli --host 192.168.1.10 bass down
-```
-
-### Balance Control
-
-Adjust left/right balance.
-
-#### `balance <subcommand>`
-
-Balance control commands.
-
-```bash
-# Get current balance
-soundtouch-cli --host <device> balance get
-
-# Set balance (-50 to 50, negative=left, positive=right)
-soundtouch-cli --host <device> balance set --level <-50 to 50>
-
-# Shift balance left
-soundtouch-cli --host <device> balance left [--amount <1-10>]
-
-# Shift balance right
-soundtouch-cli --host <device> balance right [--amount <1-10>]
-
-# Center balance
-soundtouch-cli --host <device> balance center
-```
-
-**Examples:**
-```bash
-# Get balance
-soundtouch-cli --host 192.168.1.10 balance get
-
-# Set balance 10 units to the right
-soundtouch-cli --host 192.168.1.10 balance set --level 10
-
-# Shift left by 5 units (default)
-soundtouch-cli --host 192.168.1.10 balance left
-
-# Center the balance
-soundtouch-cli --host 192.168.1.10 balance center
-```
-
-### Clock and Time
-
-Manage device clock settings.
-
-#### `clock <subcommand>`
-
-Clock control commands.
-
-```bash
-# Get current time
-soundtouch-cli --host <device> clock get
-
-# Set time manually (HH:MM format)
-soundtouch-cli --host <device> clock set --time "14:30"
-
-# Set to current system time
-soundtouch-cli --host <device> clock now
-
-# Display settings
-soundtouch-cli --host <device> clock display get
-soundtouch-cli --host <device> clock display enable
-soundtouch-cli --host <device> clock display disable
-soundtouch-cli --host <device> clock display brightness --brightness <low|medium|high|off>
-soundtouch-cli --host <device> clock display format --format <12|24>
-```
-
-**Examples:**
-```bash
-# Get current time
-soundtouch-cli --host 192.168.1.10 clock get
-
-# Set time to 2:30 PM
-soundtouch-cli --host 192.168.1.10 clock set --time "14:30"
-
-# Sync with system time
-soundtouch-cli --host 192.168.1.10 clock now
-
-# Enable clock display
-soundtouch-cli --host 192.168.1.10 clock display enable
-
-# Set 24-hour format
-soundtouch-cli --host 192.168.1.10 clock display format --format 24
-
-# Set high brightness
-soundtouch-cli --host 192.168.1.10 clock display brightness --brightness high
-```
-
-### Network Information
-
-Get network and connectivity information.
-
-#### `network <subcommand>`
-
-Network information commands.
-
-```bash
-# Get network information
-soundtouch-cli --host <device> network info
-
-# Ping the device
-soundtouch-cli --host <device> network ping
-
-# Get device base URL
-soundtouch-cli --host <device> network url
-```
-
-### Zone Management
-
-Manage multi-room zones (multiple speakers playing together).
-
-#### `zone <subcommand>`
-
-Zone management commands.
-
-```bash
-# Get current zone configuration
-soundtouch-cli --host <device> zone get
-
-# Get zone status
-soundtouch-cli --host <device> zone status
-
-# List zone members
-soundtouch-cli --host <device> zone members
-
-# Create new zone
-soundtouch-cli --host <device> zone create --members <ip1,ip2,ip3>
-
-# Add device to zone
-soundtouch-cli --host <device> zone add --member <ip>
-
-# Remove device from zone
-soundtouch-cli --host <device> zone remove --member <ip>
-
-# Dissolve current zone
-soundtouch-cli --host <device> zone dissolve
-
-# Set zone configuration
-soundtouch-cli --host <device> zone set --master <ip> --members <ip1,ip2>
-```
-
-**Examples:**
-```bash
-# Get current zone info
-soundtouch-cli --host 192.168.1.10 zone get
-
-# Create zone with three speakers
-soundtouch-cli --host 192.168.1.10 zone create --members 192.168.1.11,192.168.1.12
-
-# Add speaker to existing zone
-soundtouch-cli --host 192.168.1.10 zone add --member 192.168.1.13
-
-# Remove speaker from zone
-soundtouch-cli --host 192.168.1.10 zone remove --member 192.168.1.12
-
-# Dissolve the zone (make all speakers independent)
-soundtouch-cli --host 192.168.1.10 zone dissolve
-```
-
-## Common Usage Patterns
-
-### Quick Device Setup
-
-```bash
-# Discover devices
-soundtouch-cli discover devices
-
-# Get device info
-soundtouch-cli --host 192.168.1.10 info
-
-# Set comfortable volume and start playing
-soundtouch-cli --host 192.168.1.10 volume set --level 30
-soundtouch-cli --host 192.168.1.10 source spotify
-soundtouch-cli --host 192.168.1.10 play start
-```
-
-### Daily Usage
-
-```bash
-# Morning routine
-soundtouch-cli --host 192.168.1.10 preset --preset 1  # Morning playlist
-soundtouch-cli --host 192.168.1.10 volume set --level 25
-
-# Pause for a call
-soundtouch-cli --host 192.168.1.10 play pause
-
-# Resume
-soundtouch-cli --host 192.168.1.10 play start
-
-# Evening routine
-soundtouch-cli --host 192.168.1.10 preset --preset 3  # Evening playlist
-soundtouch-cli --host 192.168.1.10 volume set --level 15
-```
-
-### Multi-room Setup
-
-```bash
-# Create a zone with living room as master
-soundtouch-cli --host 192.168.1.10 zone create --members 192.168.1.11,192.168.1.12
-
-# Control the whole zone from master
-soundtouch-cli --host 192.168.1.10 volume set --level 40
-soundtouch-cli --host 192.168.1.10 source spotify
-soundtouch-cli --host 192.168.1.10 preset --preset 2
-
-# Later, dissolve the zone
-soundtouch-cli --host 192.168.1.10 zone dissolve
-```
-
-### Audio Tuning
-
-```bash
-# Get current audio settings
-soundtouch-cli --host 192.168.1.10 volume get
-soundtouch-cli --host 192.168.1.10 bass get
-soundtouch-cli --host 192.168.1.10 balance get
-
-# Adjust for better sound
-soundtouch-cli --host 192.168.1.10 bass set --level 2      # Slight bass boost
-soundtouch-cli --host 192.168.1.10 balance set --level -5  # Slightly left
-soundtouch-cli --host 192.168.1.10 volume set --level 35   # Good listening level
-```
-
-## Error Handling
-
-The CLI provides clear error messages for common issues:
-
-### Device Not Found
-```
-Error: Failed to connect to device: connection refused
-```
-**Solutions:**
-- Check IP address is correct
-- Ensure device is powered on
-- Verify network connectivity with `soundtouch-cli --host <device> network ping`
-
-### Invalid Commands
-```
-Error: unknown command "volumee" for "soundtouch-cli"
-```
-**Solution:** Check command spelling and structure using `--help`
-
-### Missing Required Flags
-```
-Error: required flag "host" not set
-```
-**Solution:** Provide required flags: `--host <device>`
-
-## Getting Help
-
-```bash
-# General help
-soundtouch-cli --help
-
-# Command-specific help
-soundtouch-cli volume --help
-soundtouch-cli zone --help
-
-# Subcommand help
-soundtouch-cli volume set --help
-soundtouch-cli zone create --help
-```
-
-## Configuration
-
-### Environment Variables
-
-You can set default values using environment variables:
-
-```bash
-export SOUNDTOUCH_HOST=192.168.1.10
-export SOUNDTOUCH_PORT=8090
-export SOUNDTOUCH_TIMEOUT=15s
-
-# Now you can omit these flags
-soundtouch-cli info
-soundtouch-cli volume get
-```
-
-### Configuration File
-
-Create `~/.soundtouch.env`:
-
-```
-SOUNDTOUCH_HOST=192.168.1.10
-SOUNDTOUCH_PORT=8090
-SOUNDTOUCH_TIMEOUT=15s
-SOUNDTOUCH_DISCOVERY_TIMEOUT=10s
-```
-
-## See Also
-
-- [Getting Started Guide](GETTING-STARTED.md) - Basic setup and usage
-- [WebSocket Events](websocket-events.md) - Real-time monitoring
-- [Zone Management](zone-management.md) - Multi-room setup
-- [API Endpoints](API-Endpoints-Overview.md) - Complete API reference

docs/CONTENT-SELECTION-IMPLEMENTATION.md

@@ -0,0 +1,229 @@
+# Content Selection Implementation Summary
+
+This document summarizes the implementation of advanced content selection features for the Bose SoundTouch Go client, including full support for the LOCAL_INTERNET_RADIO streamUrl format and LOCAL_MUSIC/STORED_MUSIC content selection.
+
+## ✅ Implementation Status: COMPLETE
+
+All content selection features from the [SoundTouch WebServices API Wiki](https://github.com/thlucas1/homeassistantcomponent_soundtouchplus/wiki/SoundTouch-WebServices-API) are now fully implemented with comprehensive API methods, CLI commands, tests, and documentation.
+
+## 🎯 Features Implemented
+
+### 1. Core API Methods
+
+#### `SelectContentItem(contentItem *models.ContentItem) error`
+- **Purpose**: Generic method for selecting any content using a ContentItem directly
+- **Use Case**: Maximum flexibility for complex content selection scenarios
+- **Validation**: Ensures ContentItem is not nil and has a valid source
+
+#### `SelectLocalInternetRadio(location, sourceAccount, itemName, containerArt string) error`
+- **Purpose**: Select LOCAL_INTERNET_RADIO content with streamUrl format support
+- **Features**:
+  - Direct stream URLs (e.g., `https://stream.example.com/radio`)
+  - streamUrl proxy format (e.g., `http://contentapi.gmuth.de/station.php?name=Station&streamUrl=ActualStream`)
+  - Automatic defaults for missing parameters
+- **Use Cases**: Internet radio streams, proxy-based radio services
+
+#### `SelectLocalInternetRadio(location, ...)` via `soundtouch-service`
+- **Purpose**: Select custom radio stream via local `soundtouch-service` proxy
+- **Features**:
+  - Flexible stream URL encoding (Base64 or URL-escaped)
+  - Dynamic generation of Bose-compatible playback JSON
+  - Seamless integration with existing `LOCAL_INTERNET_RADIO` source
+- **Use Case**: Playing any internet radio URL without external proxy dependencies
+
+#### `SelectLocalMusic(location, sourceAccount, itemName, containerArt string) error`
+- **Purpose**: Select LOCAL_MUSIC content from SoundTouch App Media Server
+- **Requirements**: SoundTouch App Media Server running on a computer
+- **Content Types**: Albums, tracks, artists, playlists
+- **Validation**: Requires both location and sourceAccount
+
+#### `SelectStoredMusic(location, sourceAccount, itemName, containerArt string) error`
+- **Purpose**: Select STORED_MUSIC content from UPnP/DLNA media servers
+- **Requirements**: UPnP/DLNA media server (Windows Media Player, NAS, etc.)
+- **Content Types**: NAS libraries, network music collections
+- **Validation**: Requires both location and sourceAccount
+
+### 2. CLI Commands
+
+All API methods are exposed through comprehensive CLI commands:
+
+#### `soundtouch-cli source internet-radio`
+```bash
+soundtouch-cli --host <device> source internet-radio \
+  --location "http://contentapi.gmuth.de/station.php?name=MyStation&streamUrl=https://stream.example.com/radio" \
+  --name "My Station" \
+  --artwork "https://example.com/art.png"
+```
+
+#### `soundtouch-cli source custom-radio`
+```bash
+soundtouch-cli --host <device> source custom-radio \
+  --url "https://stream.example.com/radio" \
+  --name "My Station" \
+  --artwork "https://example.com/art.png" \
+  --service-url "http://localhost:8080"
+```
+
+#### `soundtouch-cli source local-music`
+```bash
+soundtouch-cli --host <device> source local-music \
+  --location "album:983" \
+  --account "3f205110-4a57-4e91-810a-123456789012" \
+  --name "Welcome to the New"
+```
+
+#### `soundtouch-cli source stored-music`
+```bash
+soundtouch-cli --host <device> source stored-music \
+  --location "6_a2874b5d_4f83d999" \
+  --account "d09708a1-5953-44bc-a413-123456789012/0" \
+  --name "Christmas Album"
+```
+
+#### `soundtouch-cli source content` (Advanced)
+```bash
+soundtouch-cli --host <device> source content \
+  --source LOCAL_INTERNET_RADIO \
+  --location "https://stream.example.com/radio" \
+  --name "My Stream" \
+  --type stationurl \
+  --presetable
+```
+
+## 🧪 Test Coverage
+
+Comprehensive test suites implemented for all new functionality:
+
+### Unit Tests
+- **TestClient_SelectContentItem**: 5 test cases covering valid/invalid inputs
+- **TestClient_SelectLocalInternetRadio**: 4 test cases including streamUrl format
+- **TestClient_SelectLocalMusic**: 4 test cases with validation
+- **TestClient_SelectStoredMusic**: 4 test cases with error handling
+
+### Test Coverage Summary
+- ✅ Valid content selection scenarios
+- ✅ streamUrl format validation
+- ✅ Parameter validation and error handling
+- ✅ Default value assignment
+- ✅ HTTP request formatting verification
+
+## 📚 Documentation
+
+### Updated Documentation
+1. **CLI-REFERENCE.md**: Added comprehensive CLI command examples
+2. **Content Selection Example**: New `/examples/content-selection/` with working code
+3. **README Updates**: Added streamUrl format examples
+4. **API Documentation**: Inline Go documentation for all methods
+
+### Example Code
+Complete working example demonstrating:
+- LOCAL_INTERNET_RADIO with streamUrl proxy format
+- LOCAL_INTERNET_RADIO with direct streams
+- LOCAL_MUSIC content selection
+- STORED_MUSIC content selection
+- Generic ContentItem usage
+
+## 🔍 streamUrl Format Support
+
+### What is the streamUrl Format?
+The streamUrl format uses a proxy server that accepts the actual stream URL as a parameter:
+
+```
+http://contentapi.gmuth.de/station.php?name=StationName&streamUrl=ActualStreamURL
+```
+
+### Implementation Details
+- **Full Support**: All streamUrl format URLs work seamlessly
+- **Example from Wiki**: Exact implementation matches the wiki specification
+- **ContentItem Structure**:
+  ```go
+  contentItem := &models.ContentItem{
+      Source:       "LOCAL_INTERNET_RADIO",
+      Type:         "stationurl",
+      Location:     "http://contentapi.gmuth.de/station.php?name=Antenne%20Chillout&streamUrl=https://stream.antenne.de/chillout/stream/aacp",
+      IsPresetable: false,
+      ItemName:     "Antenne Chillout",
+      ContainerArt: "https://www.radio.net/300/antennechillout.png",
+  }
+  ```
+
+## 🏗️ Architecture
+
+### Design Principles
+1. **Consistency**: All methods follow the same parameter patterns
+2. **Flexibility**: `SelectContentItem()` allows maximum control
+3. **Convenience**: Specific methods (`SelectLocalInternetRadio()`, etc.) provide simpler interfaces
+4. **Validation**: Comprehensive input validation with clear error messages
+5. **Defaults**: Sensible defaults when optional parameters are empty
+
+### ContentItem Construction
+All convenience methods create properly structured `ContentItem` objects:
+- Automatic `Type` assignment based on source
+- `IsPresetable` defaults to `true`
+- Default `ItemName` when not provided
+- Proper source-specific validation
+
+## 🎵 Related Features
+
+### Sibling Features (Also Implemented)
+Based on the wiki structure, these related features are also supported:
+
+1. **LOCAL_MUSIC**: ✅ Fully implemented
+2. **STORED_MUSIC**: ✅ Fully implemented
+3. **SPOTIFY**: ✅ Previously implemented
+4. **TUNEIN**: ✅ Previously implemented
+5. **BLUETOOTH**: ✅ Previously implemented
+6. **AIRPLAY**: ✅ Previously implemented
+
+## 📋 Usage Examples
+
+### API Usage
+```go
+// streamUrl format
+location := "http://contentapi.gmuth.de/station.php?name=MyStation&streamUrl=https://stream.example.com/radio"
+err := client.SelectLocalInternetRadio(location, "", "My Station", "")
+
+// Direct ContentItem
+contentItem := &models.ContentItem{
+    Source:       "LOCAL_INTERNET_RADIO",
+    Type:         "stationurl",
+    Location:     location,
+    ItemName:     "My Station",
+    IsPresetable: true,
+}
+err := client.SelectContentItem(contentItem)
+```
+
+### CLI Usage
+```bash
+# streamUrl format
+soundtouch-cli --host 192.0.2.100 source internet-radio \
+  --location "http://contentapi.gmuth.de/station.php?name=MyStation&streamUrl=https://stream.example.com/radio" \
+  --name "My Station"
+
+# Direct stream
+soundtouch-cli --host 192.0.2.100 source internet-radio \
+  --location "https://stream.example.com/radio" \
+  --name "Direct Stream"
+```
+
+## 🔗 References
+
+- [SoundTouch WebServices API Wiki](https://github.com/thlucas1/homeassistantcomponent_soundtouchplus/wiki/SoundTouch-WebServices-API)
+- [LOCAL_INTERNET_RADIO - streamUrl format](https://github.com/thlucas1/homeassistantcomponent_soundtouchplus/wiki/SoundTouch-WebServices-API#select-local_internet_radio---streamurl-format)
+- [LOCAL_MUSIC](https://github.com/thlucas1/homeassistantcomponent_soundtouchplus/wiki/SoundTouch-WebServices-API#select-local_music)
+- [Content Selection Example](../examples/content-selection/README.md)
+- [CLI Reference](guides/CLI-REFERENCE.md)
+- [Content Selection Example (Direct)](../examples/content-selection/)
+
+## ✅ Verification
+
+This implementation has been verified to:
+1. ✅ Support exact wiki specification for streamUrl format
+2. ✅ Handle all LOCAL_INTERNET_RADIO, LOCAL_MUSIC, and STORED_MUSIC scenarios
+3. ✅ Pass comprehensive test suite
+4. ✅ Work with CLI commands
+5. ✅ Include complete documentation and examples
+6. ✅ Maintain backward compatibility
+
+**Status**: 🎉 **COMPLETE** - All requested content selection features are fully implemented and ready for use!

docs/DEVICE-CUSTOMIZATION-SETUP.md

@@ -0,0 +1,104 @@
+# Device Customization Setup Guide
+
+This guide documents the manual steps required to configure your Bose SoundTouch device for customization using the SoundCork approach.
+
+Based on: https://github.com/deborahgu/soundcork
+
+## Overview
+
+SoundCork allows you to customize your SoundTouch device by intercepting and modifying its firmware update process. This requires specific manual configuration steps to prepare your device.
+
+## Prerequisites
+
+- Bose SoundTouch device
+- Network access to device
+- Administrative access to your router/network
+
+## Configuration Steps
+
+### Step 1: Prepare USB Drive
+- Insert USB stick into computer
+- Create remote services file: `touch /path/to/mounted/usb/root-directory/remote_services`
+
+### Step 2: Connect to Device
+- Insert USB stick into SoundTouch 20 device
+- Restart device (unplug power, plug it back in)
+
+### Step 3: Access Device via SSH or Telnet
+
+After the restart, remote access is enabled.
+
+#### Option A: SSH
+- SSH access: `ssh -oHostKeyAlgorithms=ssh-rsa root@<device-ip>`
+- Device will show network interfaces and system info
+- No password required for root access
+
+Example output:
+```text
+gesellix@Mac Bose-SoundTouch % ssh -oHostKeyAlgorithms=ssh-rsa root@<device-ip>
+Last login: Sun Feb  1 19:12:47 2026
+eth0      Link encap:Ethernet  HWaddr CA:FE:BA:BE:A3:25
+          inet addr:<device-ip>  Bcast:0.0.0.0  Mask:255.255.255.0
+lo        Link encap:Local Loopback
+          inet addr:127.0.0.1  Mask:255.0.0.0
+usb0      Link encap:Ethernet  HWaddr CA:FE:BA:BE:1E:47
+          inet addr:123.12.123.12  Bcast:0.0.0.0  Mask:255.255.255.252
+
+Sun Feb  1 20:35:24 CET 2026
+
+Device name: "Kitchen SoundTouch"
+Country EU, Region (not set)
+Module type: scm
+root@spotty:~#
+```
+
+#### Option B: Telnet via Docker
+If you don't have a telnet client installed, you can use Docker:
+```bash
+docker run --rm -it alpine:edge ash -c 'apk add -U inetutils-telnet && telnet <device-ip> 23'
+```
+
+Example output:
+```text
+Trying <device-ip>...
+Connected to <device-ip>.
+Escape character is '^]'.
+
+... --- ..- -. -.. - --- ..- -.-. ....
+
+        ____  ____  _____ _________
+       / __ )/ __ \/ ___// _______/
+      / __  / / / /\__ \/ __/
+ ____/ /_/ / /_/ /___/ / /___
+/_________/\____//____/_____/
+
+
+spotty login: root
+eth0      Link encap:Ethernet  HWaddr CA:FE:BA:BE:A3:25
+          inet addr:<device-ip>  Bcast:0.0.0.0  Mask:255.255.255.0
+lo        Link encap:Local Loopback
+          inet addr:127.0.0.1  Mask:255.0.0.0
+usb0      Link encap:Ethernet  HWaddr CA:FE:BA:BE:1E:47
+          inet addr:123.12.123.12  Bcast:0.0.0.0  Mask:255.255.255.252
+
+Sun Feb  1 19:12:47 CET 2026
+
+Device name: "Kitchen SoundTouch"
+Country EU, Region (not set)
+Module type: scm
+root@spotty:~#
+```
+
+### Step 4: Check Current Configuration
+- View current configuration: `cat /opt/Bose/etc/SoundTouchSdkPrivateCfg.xml`
+- Note the URLs for streaming, stats, software updates, and BMX registry
+
+## Notes
+
+- Keep your device's original firmware backed up
+- Ensure stable network connection during setup
+- Document your device's current firmware version before starting
+
+## Troubleshooting
+
+*Common issues and solutions will be added here...*

docs/DEVICE-LOCAL-INSTALL.md

@@ -0,0 +1,277 @@
+# Device-Local Install: Four User Journeys
+
+A user-journey-shaped view of where AfterTouch sits today and where it could go. The same speaker, the same constraints, but four different audiences with non-overlapping needs:
+
+1. **Initial setup / install** — getting AfterTouch onto a fresh or freshly-orphaned speaker.
+2. **Less-technical admin** — migration, maintenance, and recovery without a terminal.
+3. **Daily usage** — playing music, switching presets, on the couch or on the phone.
+4. **Automation** — driving the speaker from scripts, home automation, schedules.
+
+Each journey is served by a different surface (CLI, web UI, GUI app, REST). Some surfaces serve more than one journey; some journeys are served badly today. This doc is informational; nothing here is a roadmap commitment.
+
+Cross-cutting reference material — lessons from `GameTec-live/soundtouch-tiny`, plus a per-surface capability map — lives in the appendix.
+
+---
+
+## Journey 1: Initial setup / install
+
+**Who.** Someone with a Bose speaker whose cloud just died. Could be technical (knows what SSH is) or not (knows what a USB stick is). Wants the speaker to play Internet Radio again with minimum fuss.
+
+**Goal.** Get an AfterTouch instance reachable from the speaker, whether that instance lives on a separate host or on the speaker itself.
+
+**Surfaces.** Shell (today), GUI installer (planned), pre-flashed stick (commercial offering, hypothetical).
+
+### The three install patterns
+
+#### Pattern A — External host
+
+A separate machine (Raspberry Pi, NAS, always-on laptop) runs `soundtouch-service`. Speakers point at it via DNS rewrite at the router. No code on the speaker, no firmware risk.
+
+- **Pros:** zero invasiveness, easy update (single host), unified for many speakers, no per-speaker storage limit.
+- **Cons:** requires an always-on host on the LAN, DNS rewrite at router scope, single point of failure.
+
+#### Pattern B — SSH-curl on-device (current `scripts/on-device-install/`)
+
+User SSHes in once, pipes the installer. Installs to `/mnt/nv/aftertouch`, symlinks `/opt/aftertouch`, registers `/etc/init.d/aftertouch` via `update-rc.d`. Daemon serves `:8000` on the speaker's own LAN address.
+
+- **Pros:** no separate host, per-speaker isolation, survives router replacement.
+- **Cons:** SSH required for install and updates, ~12 MB binary stresses tiny rootfs partitions, no in-process restart on crash, some firmware images bind only loopback (issue #196).
+
+#### Pattern C — Stick-driven on-device (*not* implemented here)
+
+USB stick holds binary + bootstrap scripts. First install needs SSH (placing `/mnt/nv/rc.local`). After that, the NAND `rc.local` auto-syncs from any stick inserted with newer files. Stick can also carry one-shot configs (`wlan.conf`, `region.conf`, `name.conf`) consumed and wiped during boot.
+
+- **Pros:** post-bootstrap updates need no SSH, stick wipe behavior keeps credentials short-lived, watchdog inside the bootstrap script restarts the agent on crash without a reboot.
+- **Cons:** first install still needs SSH; FAT32 stick on the speaker is unreliable for writes; user has to keep a stick around.
+
+### The technical underpinning: `/mnt/nv/rc.local`
+
+Both pattern C and any "shepherd-less" install on stock firmware depend on a single line in the stock init scripts:
+
+```
+# /etc/init.d/shelby_local, start case
+[ -x /mnt/nv/rc.local ] && /mnt/nv/rc.local
+```
+
+`shelby_local` is a stock Bose SysV script. Its `start` case fires at every boot from an `S`-symlink in `rcS.d/` (the misleading `K99shelby_local` symlink in `rc1.d/` is the *shutdown* path — same script, different case). `/mnt/nv` is the persistent read-write NAND partition; `rc.local` is intentionally exposed as an extension point. By the time it runs, rootfs is mounted read-only, `/mnt/nv` is read-write, network is configured, and `/media/sda1` is *typically* mounted by udev if a USB stick is present — but the mount is asynchronous and races the hook (polling for up to 30 s is one way to handle this).
+
+**Stock firmware does not auto-copy anything from a USB stick into `/mnt/nv/rc.local`.** Inserting a stick alone is not enough. There is no udev rule, no autorun convention, no `shelby_usb` branch that handles this; `shelby_usb` only manages USB ethernet-gadget mode (`g_ether`) and the `microbswitch` helper on certain variants.
+
+Placement happens one of two ways:
+
+1. **Manual SSH bootstrap, once.** Shell access (via the `remote_services` stick trick) runs an installer that writes `/mnt/nv/rc.local`, makes it executable, and exits. After that single SSH session, the stick is no longer required to *trigger* anything — the NAND copy fires on every boot.
+2. **Self-update from a newer stick, after step 1.** Once `/mnt/nv/rc.local` exists *and contains the self-update logic*, inserting a stick with a newer `rc.local` (compared by mtime) lets the running NAND copy overwrite itself for the next boot. This gives the stick its "repair channel" property.
+
+**The very first placement requires SSH.** Any zero-SSH install would need either a different stock-firmware hook (we have not found one usable across SoundTouch variants) or a custom firmware image. The `remote_services` stick is the only stick-content convention the stock firmware honors out of the box, and all it does is enable `sshd`.
+
+### App-driven install (the missing middle)
+
+The SSH session does **not** have to be a human SSH session. `pkg/ssh` (`NewClient`, `Run`, `ReadFile`, `ReadDir`, `UploadContent`) is already used by `pkg/service/setup/` to drive migration probes; the same primitives can drive an installer. The user never sees a terminal.
+
+User-visible flow:
+
+1. User runs an admin app on their laptop or phone.
+2. App walks them through preparing a `remote_services` stick — or writes one for them, if it can reach the host's USB subsystem.
+3. User inserts the stick into the speaker and power-cycles it. Stock firmware's `sshd` starts.
+4. App discovers the speaker via mDNS, dials SSH, runs the installer steps that today live behind `curl ... \| sh`. No `ssh` invocation, no `rw &&`, no copy-pasted IP.
+5. App verifies `curl http://<box>:8000` from inside the speaker via SSH and surfaces a clear success / failure state.
+6. App optionally removes `remote_services` from the stick and reboots the speaker, closing the SSH backdoor automatically.
+
+Mapping each step to existing code:
+
+| Step                | Today's installer                                                       | App equivalent (`pkg/ssh`)                                                                                  |
+|---------------------|-------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+| Remount rootfs rw   | `mount -o remount,rw /` (inside init script)                            | `Client.Run("mount -o remount,rw /")`                                                                       |
+| Make NAND dir       | `mkdir -p $INSTALL_DIR`                                                 | `Client.Run("mkdir -p /mnt/nv/aftertouch")`                                                                 |
+| Download binary     | `curl -sSL ... -o binary`                                               | local download on the app side, then `Client.UploadContent(bytes, "/mnt/nv/aftertouch/aftertouch-service")` |
+| Mark executable     | `chmod +x`                                                              | `Client.Run("chmod +x ...")`                                                                                |
+| Symlink `/opt`      | `ln -sf $INSTALL_DIR /opt/aftertouch`                                   | `Client.Run("ln -sf ...")`                                                                                  |
+| Install init script | `curl ... -o /etc/init.d/aftertouch && update-rc.d aftertouch defaults` | `Client.UploadContent` + `Client.Run`                                                                       |
+| Start               | `/etc/init.d/aftertouch start`                                          | `Client.Run("/etc/init.d/aftertouch start")`                                                                |
+| Verify listener     | `curl -fsS http://localhost:8000` inside the box                        | `Client.Run("curl -fsS http://localhost:8000")`                                                             |
+
+No new SSH plumbing required. The pieces already exist for the setup probes.
+
+### Storage budget
+
+The on-device patterns share one hard constraint: storage. ST20 stock rootfs has ~4 MB free (issue #268); even with `/mnt/nv` (~30 MB free) the budget is tight, and a second binary for safe OTA updates doubles it. This is the primary motivation for a slimmer `soundtouch-service-mini` build target — see the appendix.
+
+### Open decisions for this journey
+
+- Do we keep pattern B as the technical-user path while building a Gio admin app for the rest?
+- Do we add a pattern-C-style "register a stick-update hook in `/mnt/nv/rc.local`" option as an opt-in, so users who do want a repair stick get one?
+- Pre-flashed sticks shipped as a kit: in scope or out?
+
+---
+
+## Journey 2: Less-technical admin (migration + maintenance)
+
+**Who.** The person who already has AfterTouch installed somewhere and now needs to do something *after* install. They are comfortable opening apps and clicking buttons; they are not comfortable opening a terminal. The whole-household admin: parent, partner, roommate doing it for the household.
+
+**Goal.** Migrate a speaker to a new AfterTouch instance, update the agent, view what's going on, recover a stuck device, change WLAN credentials, reapply config after factory reset — all without SSH.
+
+**Surfaces.** GUI admin app (Gio, planned), `soundtouch-service` embedded web UI (today, technical-leaning), CLI (today, technical-only).
+
+### What "admin" covers in practice
+
+- **Migration of a new (or factory-reset) speaker** to an AfterTouch instance: rewrite the server URLs in `/mnt/nv/persistence.json`, restart the device, verify it talks to us.
+- **Agent update on an on-device install** (pattern B or C): push a new binary, restart, verify.
+- **Status and diagnostics**: is `aftertouch` running, is `:8000` listening, did the last preset save succeed, what does syslog say?
+- **Recovery**: speaker is stuck (won't respond to web UI, won't pair, lost WLAN). Today this almost always means SSH; with `pkg/ssh` behind a GUI, it can mean "click 'Diagnose' in the app."
+- **Bulk operations**: do all of the above across several speakers at once.
+- **Configuration drift**: WLAN password changed, region changed, speaker name changed, hosts file got rewritten — restore the AfterTouch overlay.
+
+### How the GUI admin app shape would serve this
+
+Same `pkg/ssh` primitives as Journey 1's installer, applied to post-install tasks. mDNS discovers all speakers on the LAN; the app fans operations out across them; SSH-driven actions stay hidden behind buttons. On a phone, the same app is the "speakers are unreachable, what now" diagnostic tool from another room.
+
+Where today's surfaces fall short for this user:
+
+- `soundtouch-service` web UI assumes the service is running and reachable. It cannot recover a broken installation or a stuck device.
+- CLI works but presumes terminal comfort.
+- The setup wizard in `soundtouch-service` handles initial migration well, but reapplying after factory reset is not first-class — see `docs/analysis/FACTORY-RESET-PROTOCOL.md`.
+
+### Open decisions for this journey
+
+- Does the admin app subsume the service web UI's admin tab, or do they coexist (admin app = onboarding + recovery; service web UI = ongoing operations once everything is healthy)?
+- WASM as a fallback surface: today's service web UI is browser-accessible from anywhere. Does a Gio admin app sacrifice that, or do we ship both?
+- Multi-household / multi-speaker: how much does the admin app need to know about distinguishing speakers vs distinguishing AfterTouch instances?
+
+---
+
+## Journey 3: Daily usage
+
+**Who.** Anyone in the household using the speaker. Children pressing a preset button. The user opening a phone to switch from kitchen to living room. Guests asked to "just put on some jazz." Zero awareness of AfterTouch as a thing; the speaker is the speaker.
+
+**Goal.** Music plays. Pressing preset 3 gives them what preset 3 should give them. Skipping a station, adjusting volume, browsing for a new station — all fast, no friction.
+
+**Surfaces.** Physical preset buttons (always there), `soundtouch-web` (today), mobile app (Journey 2 admin app's daily-use mode), WASM-served browser UI (planned), Bose app while it still functions, voice assistants where wired up.
+
+### What this layer needs to be good at
+
+- **Preset playback works first try, every time.** The reliability bar is "is the kitchen radio still working?" Anything that fails on cold boot or after a Wi-Fi outage breaks the user's trust in the whole system.
+- **Switching stations quickly**, including discovery of new ones (e.g. `radio-browser.info`-style search).
+- **Volume and play / pause from any device the user has in hand.** Phone in pocket, laptop on table, browser tab open — all should work.
+- **Multi-room awareness** if the household has more than one speaker: which speaker is playing what, can I send this to the bedroom.
+- **Looking good.** This is the surface that gets seen daily by non-technical users. Visual polish matters more here than anywhere else in the stack.
+
+### How surfaces map
+
+- `soundtouch-web`: primary daily UI for desktop browsers and (responsively) for tablets. This is already shipped.
+- Mobile app: daily-use mode of the same Gio app that handles admin. Capability split — admin features only show up when the user is in admin mode.
+- WASM: same Gio app, served from `soundtouch-service` to anyone on the LAN. The "I forgot which device my login is on, just open a browser" fallback.
+- Physical preset buttons: handled at the agent level (the Bose firmware fires them; AfterTouch or the on-device agent reacts).
+
+### Open decisions for this journey
+
+- Do we keep `soundtouch-web` as a separate codebase (HTML/JS), or does it become a Gio WASM build sharing code with the admin app?
+- Mobile app store distribution: TestFlight for iOS (gated, slow), Play Store for Android (faster, AAB only), F-Droid as an open-source-friendly side path.
+- Multi-user state: presets per-user vs per-household. Out of scope here, but the daily surface is where it gets felt.
+
+---
+
+## Journey 4: Automation
+
+**Who.** The same household, but acting through code: a Home Assistant config, a NodeRED flow, a cron job, a shell script, a webhook from a smart doorbell. The user is not present at the speaker; they want music to start when something else happens.
+
+**Goal.** Headless, scriptable control. "Play preset 2 at 7:00 every weekday." "When the kids' bedtime alarm fires, fade volume to zero." "If I get home and the speaker is on, switch to my dinner playlist."
+
+**Surfaces.** `soundtouch-cli` (today), REST endpoints on `soundtouch-service` (today), MQTT bridge / webhook outputs (hypothetical), Home Assistant integration (community).
+
+### What this layer needs to be good at
+
+- **Stable, versioned API surface.** Scripts and home automation flows live for years; breaking changes are expensive for users.
+- **CLI that works in pipelines.** Exit codes, machine-readable output (JSON), stable flag names. The reverse of the daily UI: zero polish, full predictability.
+- **Discoverability of capabilities.** Users need to find out what's possible (`soundtouch-cli help`, openapi spec on the service, examples in the docs).
+- **Idempotency.** Calling "set volume to 40" twice should not result in volume 80. Calling "switch to preset 3" when already on preset 3 should be a no-op.
+
+### How surfaces map
+
+- `soundtouch-cli`: the canonical surface for scripted control. Already covers most of the API.
+- `soundtouch-service` REST endpoints: same surface, network-accessible. Used by `soundtouch-web` and by third-party automation.
+- Home Assistant: external integration; track but do not own.
+- Webhooks / MQTT: not present today; would let speakers participate in event-driven flows. Out of scope for a first pass; worth a separate design doc when demand surfaces.
+
+### Open decisions for this journey
+
+- Stability commitments for the CLI and REST API: do we adopt semver for the public surface separately from the service version?
+- Authentication for the REST surface when exposed beyond loopback: needed before any internet exposure is sane.
+- OpenAPI / typed-client output for the service: nice-to-have for integration developers.
+
+---
+
+## Appendix: which surface serves which journey
+
+| Surface                            | Journey 1 (install) | Journey 2 (admin) | Journey 3 (daily) | Journey 4 (automation) |
+|------------------------------------|---------------------|-------------------|-------------------|------------------------|
+| `soundtouch-cli`                   | partial (today)     | partial (today)   | no                | primary                |
+| `soundtouch-service` web UI        | wizard portion      | primary           | partial           | indirect (REST)        |
+| `soundtouch-web`                   | no                  | no                | primary           | no                     |
+| GUI admin app (Gio, planned)       | primary             | primary           | mobile mode       | no                     |
+| Pre-flashed stick (hypothetical)   | primary             | recovery          | no                | no                     |
+| Physical preset buttons            | no                  | no                | primary           | no                     |
+| Home Assistant / webhooks (future) | no                  | no                | no                | primary                |
+
+The diagonal isn't full because some journeys lack a polished surface today (Journey 1 mostly works but is shell-only; Journey 2 has gaps for recovery scenarios). The journey frame is what tells us *which* gaps to fill first.
+
+## Appendix: per-surface capability constraints
+
+The Gio admin app, if built, can target Windows / macOS / Linux / iOS / Android / WASM from one codebase. Each target has hard constraints:
+
+- **WASM (browser).** Post-install REST control, device list and status, preset editing, station search. No mDNS (browsers cannot do raw multicast — fall back to manual IP entry or a backend bridge); no raw TCP, so no SSH and no install; no block-device access, so no stick writing. This is the "I just want to use my speakers" surface, equivalent to today's `soundtouch-web`.
+- **Mobile iOS.** Everything WASM does, plus Bonjour-based mDNS, plus full SSH client (so app-driven install and recovery work). No FAT32 stick writing — iOS has no filesystem-level block device access for third-party apps. Best paired with a pre-flashed stick or a friend's desktop install for the bootstrap.
+- **Mobile Android.** Same as iOS, plus FAT32 stick writing *if* the user grants USB-OTG host permission. UX caveat: most users will not know what USB host mode is.
+- **Desktop (Gio).** Full capability set. mDNS, SSH-driven install, FAT32 stick writing via standard block-device APIs, post-install control, recovery. The primary onboarding surface.
+
+The pattern to follow is to write code so each capability degrades automatically based on what the runtime actually offers, rather than gating with build tags.
+
+## Appendix: lessons from adjacent projects
+
+### soundtouch-tiny (GameTec-live)
+
+Minimal on-device cloud replacement: Internet Radio + TuneIn proxy + optional presets. Go stdlib only, small binary. Inspired by AfterTouch but trimmed. The author offered collaboration in PR #292.
+
+This is the gap a **`soundtouch-service-mini` build target** would fill. The full `soundtouch-service` is justified for the external-host pattern (Pattern A) where space is not pressed; on-device (patterns B and C) the calculus is different — many users only need Internet Radio because that's the surface most affected by the cloud shutdown.
+
+A mini build target in this repo would look like:
+
+- same codebase, different `cmd/` entry point,
+- compiled with only the packages needed for Internet Radio + TuneIn shim + presets,
+- no Spotify, no parity tests, no setup wizard, no Bose-protocol-level proxy,
+- target size: under 4 MB so it fits the rootfs without `/mnt/nv` gymnastics, leaving room for a second binary for safe updates.
+
+Open questions before committing:
+
+1. Collaborate upstream with soundtouch-tiny, or build our own mini that shares code with the full service?
+2. Where to draw the feature line — "Internet Radio only" is clear; "Spotify too" would already blow the budget on ST20.
+3. Mini ships via Pattern B (SSH-curl) or Pattern C (stick)?
+4. Full service and mini service coexisting on the same LAN — mDNS service name, port choice, web UI port.
+
+### Wails vs Gio
+
+Both are Go. Different tradeoffs:
+
+- **Wails v2**: bundles a WebView per OS, frontend is HTML/CSS/JS. Faster to a working UI if the team is comfortable with HTML. Targets Windows / macOS / Linux. No mobile, no WASM.
+- **Gio**: immediate-mode pure-Go UI. Smaller binaries, no WebView dependency. Targets Windows / macOS / Linux / iOS / Android / WASM. Steeper UI learning curve, mitigated by `gio-mw`.
+
+The deciding factor is **mobile + WASM** (Journey 2 and Journey 3), not desktop alone. If "use a phone to set up a speaker" or "open the admin tool from any browser" is on the roadmap, Wails does not get us there.
+
+## Appendix: documentation gap to close
+
+Separate user-facing material to produce when we are ready (not in this comparison doc):
+
+- **The `/mnt/nv/rc.local` hook** explained in user terms: what it does, when it fires, when *not* to use it, how to remove it cleanly. Bridges Journey 1 and Journey 2.
+- **Hooks we already maintain** at OS level: resolv.conf stability, `/etc/hosts` overlay, anything in `pkg/service/setup/` that touches device state. Reference, not narrative. Journey 2 troubleshooting.
+- **Storage budget per model**: rootfs free, `/mnt/nv` free, where the binary lands, which path applies to which ST model. Journey 1 sizing.
+- **Decision matrix**: external host vs on-device vs mini, plus "do I need Spotify? do I need migration? do I want one host or per-speaker isolation?" Journey 1 entry point.
+- **Stick file conventions**: what the `remote_services` stick does today, what we *might* add (presets / wlan / region) if we build a stick-driven path, and how that interacts with FAT credentials residency. Journey 1.
+- **Automation cookbook**: example Home Assistant config, example shell scripts, common pitfalls. Journey 4.
+
+## Cross-references
+
+- AfterTouch installer: `scripts/on-device-install/install.sh`, `scripts/on-device-install/aftertouch` (init script), `scripts/on-device-install/README.md`.
+- AfterTouch SSH client: `pkg/ssh/ssh.go` (`NewClient`, `Run`, `ReadFile`, `ReadDir`, `UploadContent`), already used by `pkg/service/setup/`.
+- Storage limitations: issue #268 (ST20 rootfs free space), issue #196 (loopback-only bind), issue #250 (status reports running but unreachable).
+- soundtouch-tiny: `https://github.com/GameTec-live/soundtouch-tiny`, raised in PR #292 (`https://github.com/gesellix/Bose-SoundTouch/pull/292`).
+- opencloudtouch parallel discussion: `https://github.com/scheilch/opencloudtouch/discussions/201`.
+- Existing parity doc shape: `docs/PARITY-OPENCLOUDTOUCH.md` is the precedent for cross-project comparison documents.

docs/DEVICE-LOGGING.md

@@ -0,0 +1,113 @@
+# Device Logging & Troubleshooting
+
+Accessing logs from SoundTouch devices is critical for debugging custom service integrations and understanding internal device behavior. This document outlines the methods for collecting logs, as discovered by the **SoundCork** and **ÜberBöse API** communities.
+
+## Log Types
+
+1.  **System Logs**: Internal OS logs (Linux-based) including `dmesg`, `syslog`, and process-specific logs.
+2.  **Traffic Logs**: Real-time HTTP/HTTPS requests sent by the device to cloud or local services.
+3.  **Proxy Logs**: Logs generated by the `soundtouch-service` when it acts as a man-in-the-middle.
+
+---
+
+## 1. Accessing System Logs (Requires Root)
+
+Most SoundTouch devices run a modified Linux distribution. Accessing these logs requires root SSH or Telnet access.
+
+### Enabling Root Access (Remote Services)
+
+Community research (SoundCork Issue #112) has identified a "backdoor" to enable developer services:
+
+1.  **USB Method**:
+    -   Format a USB stick to **FAT32**.
+    -   Create an empty file named `remote_services` (no extension) in the root of the USB stick.
+    -   Insert the stick into the SoundTouch device.
+    -   Reboot the device (power cycle).
+    -   On some models, you may need to hold **4** and **Volume -** on the device while powering on to force a USB check.
+2.  **TAP Command (Legacy)**:
+    -   On older firmware versions, you can connect to port 17000 via Telnet and issue the command: `remote_services on`.
+
+### Making Root Access Persistent
+Once you have logged in as `root` (usually no password or a well-known community password), you can make the access survive reboots without the USB stick:
+```bash
+touch /mnt/nv/remote_services
+/etc/init.d/sshd start
+```
+
+### Viewing Logs
+Once inside via SSH:
+-   **Kernel Logs**: `dmesg`
+-   **System Logs**: `cat /var/log/messages` or `tail -f /tmp/soundtouch.log` (paths vary by firmware).
+-   **Real-time Monitoring**: `logread -f`
+-   **Process List**: `ps w`
+
+#### Pro-Tip: Filtered Real-time Monitoring
+To focus on cloud service and preset interactions (Marge), use the following command on the device:
+```bash
+logread -f | grep -Ei '(marge|preset)'
+```
+This is particularly useful for debugging preset synchronization and service redirection issues.
+
+For HTTPS / connection-refused debugging (e.g. `Curl 7, http 0`), drop the speaker's loopback chatter so only outbound calls remain visible:
+```bash
+logread -f | grep -v '127.0.0.1'
+```
+The speaker generates a steady stream of localhost-to-localhost HTTP traffic between its internal services; filtering it out makes the actual cloud / AfterTouch attempts (the ones that matter when diagnosing redirect or TLS issues) easy to read in real time.
+
+---
+
+## 2. Traffic Logging & Interception
+
+If you cannot or do not want to root the device, you can monitor its outbound traffic by redirecting it to a proxy.
+
+### Via `soundtouch-service`
+The `soundtouch-service` included in this repository includes a built-in proxy. When a device is migrated to use this service, all of its cloud-bound traffic is logged to the service console.
+
+**Key Traffic to Monitor**:
+-   `POST /v1/scmudc/{deviceId}`: Real-time telemetry events.
+-   `GET /marge/...`: Account and streaming configuration requests.
+-   `POST /streaming/support/power_on`: Boot-time diagnostics.
+
+### Via Packet Sniffing (Advanced)
+If you have a managed switch or a router capable of port mirroring, you can use **Wireshark** or `tcpdump` to capture traffic.
+-   **Filter**: `tcp port 80 or tcp port 443`
+-   **Target**: The IP address of your SoundTouch device.
+
+---
+
+## 3. Troubleshooting Common Issues
+
+### "IsItBose" Validation Failures
+If the device fails to connect to your custom service despite correct configuration, it may be failing the internal `IsItBose` regex check.
+-   **Evidence**: Look for SSL handshake failures or "Unauthorized" errors in your service logs.
+-   **Solution**: See the [Binary Patching section in DEVICE-REDIRECT-METHODS.md](analysis/DEVICE-REDIRECT-METHODS.md#method-3-binary-patching).
+
+### Disappearing Sources (TuneIn/Local Radio)
+If `TUNEIN` or `LOCAL_INTERNET_RADIO` sources disappear after a reboot in an offline environment.
+-   **Cause**: These sources are validated against the cloud only during the initial boot sequence.
+-   **Solution**: Ensure your emulated service is reachable and responding correctly to `/streaming/support/power_on` and `/streaming/sourceproviders` during the device's boot-up.
+
+---
+
+## 4. HTTP Protocol Quirks
+
+### ETag Case-Sensitivity
+Research in **SoundCork Issue #129** revealed a significant bug in the SoundTouch device firmware regarding HTTP `ETag` headers.
+
+- **The Issue**: The device firmware expects the `ETag` header to be exactly title-cased (`ETag`). Many modern web servers or frameworks (like FastAPI/Uvicorn) return headers in all lowercase (`etag`) per HTTP/2 or standard case-insensitive conventions.
+- **The Symptom**: If the server returns a lowercase `etag`, the device fails to recognize it. Consequently, the device will never send an `If-None-Match` header in subsequent requests, breaking preset synchronization and efficient caching.
+- **The Workaround**: If you are using a custom service, you may need to use a reverse proxy (like **Nginx**) or a middleware to force the header casing to `ETag`.
+
+**Example Nginx Fix**:
+```nginx
+proxy_hide_header etag;
+add_header ETag $upstream_http_etag;
+```
+
+---
+
+## References
+- [SoundCork Issue #112: Enabling Remote Services](https://github.com/deborahgu/soundcork/issues/112)
+- [SoundCork Issue #149: Debugging with Systemd/Gunicorn](https://github.com/deborahgu/soundcork/issues/149)
+- [ÜberBöse API: Telemetry Documentation](https://github.com/julius-d/ueberboese-api)
+- [SoundCork Issue #129: ETag Case-Sensitivity & Preset Sync](https://github.com/deborahgu/soundcork/issues/129)

docs/DEVICE-SETUP.md

@@ -0,0 +1,114 @@
+# Bose SoundTouch Device Setup Flow
+
+This document details the multi-step process required to fully set up a Bose SoundTouch device, as derived from the Stockholm firmware (`setup/js/`) analysis.
+
+A complete setup flow involves a sequence of local (WebSocket) and cloud (HTTP) actions that move the device from a factory-reset state to a fully registered, functional system.
+
+## 1. Local Coordination Stage (WebSocket)
+
+Before a device can be controlled, it must be configured on the local network and named. These actions occur via a WebSocket connection to the device on port 8080.
+
+### 1.1 Language Configuration (Optional)
+If the device is in a factory-reset state, the UI typically ensures the device language matches the user's choice.
+- **WebSocket Action**: `set_language`
+- **Internal Logic**: `SetupWizard.js` handles this via `set_device_language`.
+
+### 1.2 Network Configuration (WiFi)
+Configures the device to connect to a specific wireless access point.
+- **File Reference**: `setup/js/workflow_wifi_setup.js`
+- **Logic**: Triggers a site survey, then sends SSID and credentials.
+- **WebSocket Command**: `set_WIFI_OLED` or similar internal method calls to configure the network profile.
+
+### 1.3 Device Naming (Rename Step)
+Assigns a user-friendly name (e.g., "Living Room") to the device.
+- **File Reference**: `setup/js/workflow_rename.js`
+- **WebSocket Action**: `name`
+- **XML Payload**:
+    ```xml
+    <name>Living Room</name>
+    ```
+- **Implementation**: The `RenameDevices.do_rename_devices()` function sends this to the device. The device then updates its local name and mDNS/SSDP broadcasts.
+
+## 2. Cloud Interaction Stage (HTTP)
+
+The device needs to be linked to a Bose "Marge" account to enable cloud-based features and music services.
+
+### 2.1 Account Creation (Registration)
+If a user doesn't have an account, the setup client creates one.
+- **File Reference**: `setup/js/workflow_marge.js`
+- **Cloud Endpoint**: `POST https://streaming.bose.com/streaming/account`
+- **Payload**: XML containing name, email, password, and country.
+- **Content-Type**: `application/vnd.bose.customer-v1.0+xml`
+
+### 2.2 Cloud Authentication (Login)
+The setup client must obtain a valid `accountId` and `userAuthToken` to pair the device.
+- **File Reference**: `setup/js/workflow_marge.js`
+- **Cloud Endpoint**: `POST https://streaming.bose.com/streaming/account/login`
+- **Payload**: XML containing username and password.
+- **Content-Type**: `application/vnd.bose.streaming-v1.2+xml`
+- **Result**: Returns a session token in the `Credentials` response header and the user's `account ID` in the XML body.
+
+## 3. Registration Bridge (WebSocket to Cloud)
+
+This is the final "pairing" step where the client tells the device which account it belongs to.
+
+### 3.1 Device Registration (The "Pair" Step)
+The client sends the user's credentials to the device, which then registers itself with the cloud.
+- **File Reference**: `setup/js/workflow_add_devices.js`
+- **WebSocket Action**: `setMargeAccount`
+- **XML Payload**:
+    ```xml
+    <PairDeviceWithAccount>
+        <accountId>12345</accountId>
+        <userAuthToken>jGwE... (truncated)</userAuthToken>
+    </PairDeviceWithAccount>
+    ```
+- **Device Reaction**: Upon receiving this, the device makes its own outbound HTTP POST to the Marge service:
+    `POST https://streaming.bose.com/{accountId}/devices`
+
+## 4. Finalization
+
+Once the registration is complete, the setup application (Stockholm) performs final cleanup. It's important to distinguish between **App State** (the Stockholm UI's persistent settings) and **Device State** (the physical speaker's configuration).
+
+### 4.1 Exiting Setup Mode (App Settings)
+The Stockholm app communicates with its "native container" (the WebView bridge on iOS/Android/Windows/macOS) using a `setData` command in **JSON format**. This is an internal message to the application's persistent storage, **not a network command sent to the physical speaker**.
+
+This command tells the Stockholm app which page to load on startup, effectively marking the setup as complete in the UI.
+
+- **Internal Command**: `setData`
+- **Parameter**: `startupPage`
+- **Normal Value**: `index.html` (Normal mode)
+- **Setup Value**: `setup/index.html` (Setup mode)
+
+**JSON Payload (Internal to Stockholm App)**:
+```json
+{
+    "method": "setData",
+    "params": {
+        "name": "startupPage",
+        "value": "index.html"
+    }
+}
+```
+
+**Other Common Internal Parameters**:
+- `changeStartupPage`: Set to `false` after a successful setup or update.
+- `tipsEnabled`: Set to `false` to suppress the "Getting Started" tutorials.
+- `promptUpdate`: Set to `true` if a firmware update was deferred during setup.
+
+### 4.2 Device Finalization
+The physical speaker considers the setup "done" once it successfully processes the `<PairDeviceWithAccount>` XML message and completes its own handshake with the Marge cloud. There is no specific "Finalize" XML command sent to the speaker; the successful registration is the signal.
+
+The `SetupWizard.js` calls `single_device_setup_done()` to trigger the internal `setData` updates described above. If these are not saved in the app's local storage, the Stockholm UI may return to the setup flow on next launch, even if the speaker is already paired.
+
+---
+
+## Summary of Scriptable Requirements
+
+To automate a device setup using a custom tool (like `soundtouch-cli`), you must perform the following:
+1.  **Configure WiFi**: (Assumed if device is reachable over IP).
+2.  **Set Name**: Send the `<name>` WebSocket message (XML) to update the device identity.
+3.  **Obtain Token**: Authenticate against the cloud service (Marge) via HTTP.
+4.  **Pair Device**: Send the `<PairDeviceWithAccount>` WebSocket message (XML) with the account ID and token.
+
+**Note**: The JSON `setData` commands are only necessary if you are building/controlling a version of the Stockholm UI itself. They are not required to configure the physical hardware.

docs/DIAGNOSTIC-EXPORT.md

@@ -0,0 +1,138 @@
+# Encrypted Diagnostic Export
+
+AfterTouch can produce an encrypted diagnostic report that users can download and
+send to the project maintainer without exposing sensitive data to third parties.
+The report is encrypted with an SSH public key using
+[`age`](https://github.com/FiloSottile/age); only the holder of the matching
+private key can read it.
+
+---
+
+## What the report contains
+
+The encrypted `.age` file decrypts to a `.tar.gz` archive with:
+
+- `diagnostic.json` — structured summary:
+  - Service version and build info
+  - Full health-check results (same data as the Health tab)
+  - Per-device state: sources (IDs, names, SourceKeyTypes), presets (slot, name,
+    Source, SourceID, location), device product code, firmware version, IP, name
+- `datastore/accounts/{id}/devices/{id}/*.xml` — raw XML files verbatim from
+  the sender's datastore (`Presets.xml`, `Sources.xml`, `Recents.xml`, …)
+
+Having both the structured JSON and the raw XML lets you compare what the
+service serves via HTTP against what is actually stored on disk.
+
+**What is excluded from the JSON:** authentication tokens, credentials, OAuth
+secrets, Spotify refresh tokens. The raw XML files are included as-is.
+
+---
+
+## Maintainer setup (one-time)
+
+> This section is for the project maintainer only.
+> Users never need to touch keys.
+
+### 1. Generate the key pair
+
+```bash
+bash scripts/setup-diagnostic-key.sh
+```
+
+This creates:
+- `keys/private/diagnostic` — SSH ed25519 private key (**gitignored**, never commit)
+- `keys/private/diagnostic.pub` — copy for reference (**gitignored**)
+- `keys/public/diagnostic.pub` — public key committed to the repo
+
+### 2. Add the public key to GitHub
+
+Go to <https://github.com/settings/ssh/new> and paste the contents of
+`keys/public/diagnostic.pub`. This makes the key visible at
+<https://github.com/gesellix.keys> so users can independently verify that the
+key embedded in the binary matches a key actually controlled by the maintainer.
+
+### 3. Embed the public key in the binary
+
+Open `pkg/service/export/encrypt.go` and update the `DiagnosticPublicKey`
+constant to match the new public key:
+
+```go
+const DiagnosticPublicKey = "ssh-ed25519 AAAA... aftertouch-diagnostic@gesellix"
+```
+
+### 4. Commit
+
+```bash
+git add keys/public/diagnostic.pub pkg/service/export/encrypt.go
+git commit -m "keys: add diagnostic SSH public key"
+```
+
+`keys/private/` is `.gitignore`d — the private key will not be committed.
+
+### 5. Back up the private key
+
+The private key is **not** stored in git. Keep a copy in a secure location
+(password manager, encrypted USB drive, etc.). If it is lost, a new key pair
+must be generated and the constant in `encrypt.go` updated.
+
+---
+
+## Verifying the embedded key (users)
+
+Users who want to confirm that the key embedded in their running binary matches
+the maintainer's GitHub SSH keys can run:
+
+```bash
+# Compare the raw key text — both should show the same line:
+curl -s https://github.com/gesellix.keys
+cat keys/public/diagnostic.pub
+```
+
+The key should appear verbatim in both outputs.
+
+---
+
+## Decrypting a received report (maintainer)
+
+When a user sends you an `aftertouch-diagnostic-*.age` file, use the helper
+script (no extra tools needed — only Go and the private key). Run from the
+repository root directory:
+
+```bash
+# Decrypt and extract in one step:
+go run scripts/decrypt-diagnostic.go aftertouch-diagnostic-<timestamp>.age | tar xz
+
+# Or decrypt to a .tar.gz first, then inspect:
+go run scripts/decrypt-diagnostic.go aftertouch-diagnostic-<timestamp>.age > report.tar.gz
+tar xzf report.tar.gz
+# → diagnostic.json
+# → datastore/accounts/{id}/devices/{id}/Presets.xml  (and Sources.xml, Recents.xml, …)
+```
+
+The script uses only the `filippo.io/age` Go module — no separate `age` CLI
+installation required.
+
+---
+
+## User workflow
+
+1. Open the AfterTouch admin UI and go to the **Health** tab.
+2. Click **Download diagnostic report**.
+3. The browser downloads `aftertouch-diagnostic-<timestamp>.age`.
+4. Attach the file to the GitHub issue or send it via a direct channel.
+
+The file is opaque binary — the user cannot read it. All they see is that the
+report was generated and downloaded.
+
+---
+
+## Key rotation
+
+If the private key is compromised or lost:
+
+1. Run `scripts/setup-diagnostic-key.sh` (delete the old `keys/private/diagnostic` first).
+2. Add the new public key to GitHub and remove the old one.
+3. Update `DiagnosticPublicKey` in `encrypt.go`.
+4. Commit and tag a new release.
+
+Old reports encrypted with the previous key cannot be decrypted with the new key.

docs/EXTERNAL-SERVICES-ABSTRACTION.md

@@ -0,0 +1,66 @@
+# Technical Proposal: External Service Provider Abstraction
+
+This document outlines a strategy to refactor the SoundTouch Service's content handling into a modular provider-based system.
+
+## 1. Problem Statement
+Currently, content handling for BMX (Bose Media Exchange) services like TuneIn or RadioBrowser is deeply intertwined with the HTTP handlers and XML models. Adding a new content provider (e.g., Local Media, Podcast RSS) requires modifying several files and duplicating boilerplate code for HTTP requests and error handling.
+
+## 2. Proposed Architecture
+
+### 2.1 The Provider Interface
+We define a generic `ContentProvider` interface that abstracts away the source-specific logic (API calls, data parsing).
+
+```go
+package provider
+
+import "github.com/gesellix/bose-soundtouch/pkg/models"
+
+type ContentProvider interface {
+    // ID returns the unique identifier for this provider (e.g. "RADIO_BROWSER")
+    ID() string
+
+    // Resolve returns playback details for a given content identifier
+    Resolve(id string) (*models.BmxPlaybackResponse, error)
+
+    // Search allows finding content within this provider
+    Search(query string) ([]models.ContentItem, error)
+}
+```
+
+### 2.2 Provider Registry
+A central registry in `soundtouch-service` manages the lifecycle and selection of providers.
+
+```go
+type Registry struct {
+    providers map[string]ContentProvider
+}
+
+func (r *Registry) Register(p ContentProvider) { ... }
+func (r *Registry) Get(id string) ContentProvider { ... }
+```
+
+## 3. Implementation Plan
+
+### 3.1 Phase 1: Modularize RadioBrowser
+1.  **Extract Logic**: Move current RadioBrowser logic from `bmx.go` into a new package `pkg/service/providers/radiobrowser`.
+2.  **Add Failover**: Implement the **API Failover** logic inspired by OpenCloudTouch.
+    -   Maintain a list of active RadioBrowser mirrors (e.g., `de1.api.radio-browser.info`, `nl1.api.radio-browser.info`).
+    -   Implement a round-robin or health-based selection strategy.
+3.  **Implements Interface**: Ensure the new package satisfies the `ContentProvider` interface.
+
+### 3.2 Phase 2: Refactor BMX Handlers
+-   Update `HandleTuneInPlayback` and `HandleOrionPlayback` to use the registry.
+-   The handlers will look up the provider based on the request context or URL parameters and delegate the resolution.
+
+### 3.3 Phase 3: Dynamic Service Advertising
+-   Modify `HandleBMXRegistry` to dynamically generate the `bmx_services.json` content based on the currently registered and enabled providers.
+
+## 4. Benefits
+-   **Resilience**: Centralized error handling and failover strategies for all external APIs.
+-   **Extensibility**: New services can be added by simply implementing the interface and registering them at startup.
+-   **Testability**: Providers can be unit-tested in isolation without mocking the entire HTTP server stack.
+-   **Unified UI**: A future Web UI can query the registry to show available content sources and their statuses.
+
+## 5. Next Steps
+1.  Refine the `ContentProvider` interface to include metadata (icons, user-friendly names).
+2.  Create a prototype for the `radiobrowser` provider with failover support.

docs/FEATURE_HISTORY.md

@@ -0,0 +1,374 @@
+# Feature Development History
+
+This document tracks the detailed evolution of features and capabilities in the Bose SoundTouch API client library.
+
+## Development Timeline
+
+### Phase 1: Foundation (January 2026)
+
+#### Core HTTP Client
+- **HTTP Client with XML Support**: Complete client implementation for SoundTouch Web API
+- **XML Model System**: Comprehensive typed models for all API responses
+- **Error Handling**: Robust error handling with contextual error messages
+- **Configuration Management**: Flexible configuration via environment variables and config files
+
+#### Basic Device Control
+- **Device Information**: `/info` endpoint for device details and capabilities
+- **Device Name**: `/name` endpoint for device identification
+- **Device Capabilities**: `/capabilities` endpoint for feature detection
+- **Now Playing Status**: `/now_playing` endpoint for current playback information
+
+#### Initial CLI Tool
+- Basic command-line interface for testing API functionality
+- Device connectivity testing
+- Simple information retrieval commands
+
+### Phase 2: Media Control & Discovery (January 2026)
+
+#### Media Controls
+- **Key Commands**: Complete implementation of `/key` endpoint
+  - Play, pause, stop, track navigation
+  - Volume up/down via key presses
+  - Preset selection (1-6)
+  - Power and mute controls
+  - Proper press+release pattern implementation
+- **Volume Management**: `/volume` GET/POST endpoints
+  - Direct volume setting (0-100)
+  - Incremental volume control
+  - Safety features and validation warnings
+  - Volume level categorization (quiet, medium, loud, very loud)
+
+#### Device Discovery
+- **UPnP/SSDP Discovery**: Automatic device discovery using Universal Plug and Play
+- **Device Caching**: TTL-based caching for improved performance
+- **CLI Discovery Commands**: Device discovery integration in CLI tool
+
+#### Enhanced CLI
+- **Host:Port Parsing**: Support for `device:port` format in CLI
+- **Comprehensive Commands**: Full coverage of implemented endpoints
+- **Interactive Features**: Better user experience with formatted output
+
+### Phase 3: Advanced Audio Controls (January 2026)
+
+#### Audio Management Trilogy
+- **Bass Control**: `/bass` GET/POST endpoints
+  - Range validation (-9 to +9)
+  - Incremental bass adjustment
+  - Device capability detection via `/bassCapabilities`
+  - Safety limits and user warnings
+- **Balance Control**: `/balance` GET/POST endpoints
+  - Stereo balance adjustment (-50 to +50)
+  - Left/right channel convenience methods
+  - Balance centering functionality
+  - Device-dependent feature (not all devices support balance)
+
+#### Source Selection
+- **Source Management**: `/sources` GET and POST `/select` endpoints
+- **Convenience Methods**: Direct source selection helpers
+  - `SelectSpotify()` - Switch to Spotify
+  - `SelectBluetooth()` - Switch to Bluetooth
+  - `SelectAux()` - Switch to AUX input
+  - `SelectTuneIn()` - Switch to TuneIn radio
+  - `SelectPandora()` - Switch to Pandora
+- **Source Validation**: Comprehensive source availability checking
+- **Account Management**: Support for multi-account sources (Spotify, etc.)
+
+#### Preset Management (Read-Only)
+- **Preset Analysis**: Complete preset configuration analysis
+- **Helper Methods**: Preset management utilities
+  - `GetNextAvailablePresetSlot()` - Find empty preset slots
+  - `IsCurrentContentPresetable()` - Check if content can be saved as preset
+  - Preset categorization and filtering
+- **API Limitation Documentation**: Clarified that POST `/presets` is officially N/A
+
+### Phase 4: System Features (January 2026)
+
+#### Clock and Display Management
+- **Clock Time**: `/clockTime` GET/POST endpoints
+  - Get/set device time
+  - `SetClockTimeNow()` convenience method
+  - Time format handling
+- **Clock Display**: `/clockDisplay` GET/POST endpoints
+  - Display enable/disable
+  - Brightness control (low/medium/high)
+  - 12/24 hour format selection
+  - Convenience methods for common operations
+
+#### Network Information
+- **Network Info**: `/networkInfo` GET endpoint
+- **Network connectivity details and diagnostics
+
+#### Enhanced Discovery
+- **mDNS/Bonjour Discovery**: Multicast DNS device discovery
+- **Unified Discovery Service**: Combined UPnP + mDNS + configured devices
+- **Multiple Discovery Protocols**: Fallback discovery methods for different network environments
+- **Corporate Network Support**: Discovery options for restricted networks
+
+### Phase 5: Real-time Events (January 2026)
+
+#### WebSocket Implementation
+- **WebSocket Client**: Complete WebSocket implementation for real-time events
+- **Event System**: Comprehensive event type support
+  - `NowPlayingUpdated` - Track changes, playback status
+  - `VolumeUpdated` - Volume and mute status changes
+  - `ConnectionStateUpdated` - Network connectivity
+  - `PresetUpdated` - Preset configuration changes
+  - `ZoneUpdated` - Multiroom zone changes
+  - `BassUpdated` - Bass level adjustments
+  - `SdkInfoUpdated` - Server version information
+  - `UserActivityUpdated` - User interaction notifications
+
+#### Connection Management
+- **Auto-Reconnection**: Automatic reconnection with exponential backoff
+- **Connection Monitoring**: Real-time connection state tracking
+- **Error Recovery**: Robust error handling and recovery mechanisms
+- **Event Filtering**: Subscribe to specific event types
+
+#### WebSocket CLI Integration
+- **Real-time Monitoring**: Live event streaming in CLI
+- **Event Filtering**: Command-line event type filtering
+- **Formatted Output**: Human-readable event display
+- **Demo Applications**: WebSocket demonstration tools
+
+### Phase 6: Multiroom Zone Management (January 2026)
+
+#### Zone Operations
+- **Zone Information**: `/getZone` GET endpoint
+  - Current zone configuration retrieval
+  - Master/slave device identification
+  - Zone membership queries
+- **Zone Management**: `/setZone` POST endpoint
+  - Zone creation with multiple devices
+  - Add devices to existing zones
+  - Remove devices from zones
+  - Dissolve zones completely
+
+#### High-Level Zone API
+- **Fluent API**: Easy-to-use zone management methods
+  - `CreateZone()` - Create multiroom zones
+  - `AddToZone()` - Add devices to existing zones
+  - `RemoveFromZone()` - Remove devices from zones
+  - `DissolveZone()` - Break up zones
+- **Zone Status**: Zone membership and status queries
+  - `IsInZone()` - Check if device is in a zone
+  - `GetZoneStatus()` - Get zone configuration
+  - `GetZoneMembers()` - List all zone members
+
+#### Low-Level Zone API
+- **Zone Slave Management**: Direct slave operations
+  - `/addZoneSlave` POST endpoint
+  - `/removeZoneSlave` POST endpoint
+  - Device ID and IP-based operations
+
+#### Validation and Safety
+- **IP Validation**: Comprehensive IP address validation
+- **Duplicate Detection**: Prevent duplicate zone members
+- **Error Handling**: Specific zone-related error types
+- **Zone Builder**: Fluent API for zone construction
+
+### Phase 7: Advanced Audio Controls (January 2026)
+
+#### Professional Audio Features
+- **DSP Audio Controls**: `/audiodspcontrols` GET/POST endpoints
+  - Audio mode switching (movie, music, dialogue, etc.)
+  - Video sync delay adjustment
+  - DSP parameter configuration
+- **Advanced Tone Controls**: `/audioproducttonecontrols` GET/POST endpoints
+  - Professional-grade bass and treble adjustment
+  - Extended range beyond basic `/bass` endpoint
+  - Fine-grained audio tuning
+- **Speaker Level Controls**: `/audioproductlevelcontrols` GET/POST endpoints
+  - Individual speaker level adjustment
+  - Front-center speaker level control
+  - Rear-surround speakers level control
+  - Multi-channel audio management
+
+#### Device Capability Integration
+- **Automatic Capability Detection**: Check device capabilities before feature access
+- **Conditional Feature Availability**: Features only available on compatible devices
+- **Graceful Degradation**: Fallback to basic controls when advanced features unavailable
+
+### Phase 8: Speaker Notification System (February 2026)
+
+#### Notification Features
+- **Text-to-Speech (TTS)**: `/speaker` POST endpoint for TTS messages
+  - Multi-language support (EN, DE, ES, FR, IT, NL, PT, RU, ZH, JA, etc.)
+  - Google TTS integration with URL encoding
+  - Custom volume control with automatic restoration
+  - Configurable service metadata for NowPlaying display
+- **URL Audio Playback**: `/speaker` POST endpoint for URL content
+  - HTTP/HTTPS audio content playback
+  - Custom metadata support (service, message, reason fields)
+  - Volume control with automatic restoration
+  - Content interruption and resume functionality
+- **Notification Beep**: `/playNotification` GET endpoint
+  - Simple double beep notification sound
+  - Content pause/resume during notification
+  - Quick connectivity testing
+
+#### Smart Home Integration
+- **Home Automation Support**: Perfect for smart home notifications
+  - Doorbell alerts with custom TTS messages
+  - Security system integration with audio alerts
+  - IoT device status announcements
+- **Emergency Notifications**: High-priority alert system
+  - Volume override for critical alerts
+  - Custom audio content for specific scenarios
+  - Zone-wide notifications for multiroom setups
+
+#### Device Compatibility
+- **ST-10 Series Support**: Primary compatibility with ST-10 (Series III) speakers
+- **Device Detection**: Automatic capability checking
+- **Error Handling**: Graceful degradation for unsupported devices
+- **Volume Management**: Intelligent volume restoration
+
+#### CLI Integration
+- **Comprehensive Commands**: Full CLI support for all notification types
+  - `speaker tts` - Text-to-speech with language options
+  - `speaker url` - URL content playback with metadata
+  - `speaker beep` - Simple notification beep
+  - `speaker help` - Detailed functionality guide
+- **Parameter Validation**: Complete input validation and error handling
+- **Usage Examples**: Extensive real-world usage examples
+
+### Phase 9: Bug Fixes and Stability (February 2026)
+
+#### Critical Bug Fixes
+- **PlayNotificationBeep HTTP Method Fix**: Corrected `/playNotification` endpoint to use GET instead of POST
+  - **Issue**: `go run ./cmd/soundtouch-cli --host <device> sp beep` was failing with HTTP 400 status
+  - **Root Cause**: Go client was sending POST requests while SoundTouch devices expect GET requests
+  - **Fix**: Updated `PlayNotificationBeep()` method to use the existing `c.get()` method with `StationResponse` model
+  - **Verification**: Tested with SoundTouch 20, confirmed compatibility with curl equivalent (`curl http://<device>:8090/playNotification`)
+
+#### Code Quality Improvements
+- **Consistent HTTP Method Usage**: Leveraged existing client patterns instead of manual HTTP handling
+- **Model Reuse**: Used existing `StationResponse` struct for `/playNotification` XML response parsing
+- **Documentation Updates**: Added troubleshooting guide for speaker notification issues
+
+## Feature Implementation Statistics
+
+### API Endpoint Coverage Evolution
+
+| Phase   | Endpoints Added | Cumulative Total | Completion %     |
+|---------|-----------------|------------------|------------------|
+| Phase 1 | 4               | 4                | 15%              |
+| Phase 2 | 6               | 10               | 38%              |
+| Phase 3 | 8               | 18               | 69%              |
+| Phase 4 | 3               | 21               | 81%              |
+| Phase 5 | 1               | 22               | 85%              |
+| Phase 6 | 2               | 24               | 92%              |
+| Phase 7 | 3               | 27               | 96%              |
+| Phase 8 | 2               | 29               | 100%             |
+| Phase 9 | 0               | 29               | 100% (Bug fixes) |
+
+### Testing Evolution
+
+#### Unit Test Coverage
+- **Phase 1**: Basic HTTP client tests (25 tests)
+- **Phase 2**: Media control and discovery tests (75 tests)
+- **Phase 3**: Audio control tests (125 tests)
+- **Phase 4**: System feature tests (150 tests)
+- **Phase 5**: WebSocket event tests (200 tests)
+- **Phase 6**: Zone management tests (250 tests)
+- **Phase 7**: Advanced audio tests (300+ tests)
+- **Phase 8**: Speaker notification tests (330+ tests)
+- **Phase 9**: Bug fix verification tests (335+ tests)
+
+#### Integration Test Coverage
+- **Real Device Testing**: SoundTouch 10 and SoundTouch 20
+- **Network Scenario Testing**: Various network configurations
+- **Error Scenario Testing**: Device offline, network timeouts
+- **Cross-Platform Testing**: Windows, macOS, Linux
+
+### CLI Tool Evolution
+
+#### Command Categories Added by Phase
+- **Phase 1**: `info`, `name`, `capabilities`
+- **Phase 2**: `discover`, `play`, `volume`, `key`
+- **Phase 3**: `bass`, `balance`, `source`, `presets`
+- **Phase 4**: `clock`, `network`
+- **Phase 5**: `events`
+- **Phase 6**: `zone`
+- **Phase 7**: Advanced audio commands
+- **Phase 8**: `speaker` (TTS, URL, beep notifications)
+- **Phase 9**: Bug fixes (speaker beep reliability)
+
+#### CLI Feature Enhancements
+- **Host:Port Parsing**: Support for `192.0.2.100:8090` format
+- **Auto-Discovery Integration**: Seamless device discovery
+- **Formatted Output**: Human-readable, structured output
+- **Error Handling**: Comprehensive error messages and recovery suggestions
+- **Help System**: Comprehensive help and examples
+
+## Technical Achievements
+
+### Architecture Milestones
+- **Clean Package Structure**: Well-organized pkg/ architecture
+- **Interface-Based Design**: Testable and mockable components
+- **Error Handling**: Comprehensive error types and contextual messages
+- **Configuration System**: Flexible configuration via files and environment variables
+
+### Performance Optimizations
+- **Device Caching**: TTL-based caching for discovery performance
+- **Connection Pooling**: Efficient HTTP connection management
+- **WebSocket Efficiency**: Optimized real-time event handling
+- **Memory Management**: Efficient XML parsing and model handling
+
+### Cross-Platform Support
+- **Multi-OS Compatibility**: Windows, macOS, Linux support
+- **Build System**: Comprehensive Makefile with cross-compilation
+- **Docker Support**: Containerized deployment options
+- **WASM Preparation**: Foundation for browser integration
+
+## User Experience Improvements
+
+### Safety Features
+- **Volume Warnings**: Warnings for high volume levels
+- **Input Validation**: Comprehensive input range validation
+- **Error Recovery**: Graceful handling of network issues
+- **User Feedback**: Clear status messages and progress indicators
+
+### Convenience Features
+- **Auto-Discovery**: Automatic device finding
+- **Preset Analysis**: Intelligent preset management
+- **Source Shortcuts**: Direct source selection methods
+- **Zone Management**: High-level multiroom operations
+
+### Documentation Evolution
+- **API Documentation**: Comprehensive endpoint documentation
+- **Usage Guides**: Detailed feature usage guides
+- **Troubleshooting**: Common issues and solutions
+- **Examples**: Real-world usage examples
+
+## Future Enhancement Roadmap
+
+### Next Phase Candidates
+- **Web Application Interface**: Browser-based SoundTouch controller
+- **Home Assistant Integration**: Smart home platform integration
+- **WASM Browser Library**: Pure browser implementation
+- **Mobile App Development**: Native mobile applications
+- **Docker Distribution**: Containerized deployment options
+
+### Community Features
+- **Plugin System**: Extensible architecture for community plugins
+- **Custom Event Handlers**: User-defined event processing
+- **Configuration Presets**: Shareable device configurations
+- **Automation Scripts**: Scheduled playback automation
+
+## Lessons Learned
+
+### Development Insights
+- **Real Device Testing is Critical**: API documentation doesn't capture all device behaviors
+- **Safety First**: User protection features are essential for audio equipment
+- **Progressive Enhancement**: Building features incrementally ensures solid foundation
+- **Community Value**: Open source approach accelerates development and testing
+
+### Technical Insights
+- **XML Parsing Complexity**: SoundTouch API has quirks requiring careful XML handling
+- **Network Variability**: Different network configurations require multiple discovery methods
+- **Device Differences**: SoundTouch models have subtle API differences
+- **WebSocket Reliability**: Real-time connections need robust reconnection logic
+
+---
+
+**This document tracks the evolution of the Bose SoundTouch API client from initial concept to production-ready library.**

docs/HOST-PORT-PARSING.md

@@ -11,23 +11,23 @@ The SoundTouch CLI now supports parsing host and port combinations in the `-host
 ### Basic Host:Port Format
 ```bash
 # Specify host and port together
-soundtouch-cli -host 192.168.1.100:8090 -info
-soundtouch-cli -host 192.168.178.35:8090 -play
+soundtouch-cli -host 192.0.2.100:8090 -info
+soundtouch-cli -host 192.0.2.10:8090 -play
 soundtouch-cli -host soundtouch.local:8090 -pause
 ```
 
 ### Traditional Separate Flags (Still Supported)
 ```bash
 # Traditional separate host and port flags
-soundtouch-cli -host 192.168.1.100 -port 8090 -info
-soundtouch-cli -host 192.168.178.35 -port 8090 -play
+soundtouch-cli -host 192.0.2.100 -port 8090 -info
+soundtouch-cli -host 192.0.2.10 -port 8090 -play
 ```
 
 ### Precedence Rules
 When both formats are used, the port specified in the host:port format takes precedence:
 ```bash
 # Uses port 8090 from host:port, ignores -port 9999
-soundtouch-cli -host 192.168.1.100:8090 -port 9999 -info
+soundtouch-cli -host 192.0.2.100:8090 -port 9999 -info
 ```
 
 ## Supported Formats
@@ -35,10 +35,10 @@ soundtouch-cli -host 192.168.1.100:8090 -port 9999 -info
 ### IPv4 Addresses
 ```bash
 # Standard IPv4 with port
-soundtouch-cli -host 192.168.1.100:8090 -info
+soundtouch-cli -host 192.0.2.100:8090 -info
 
 # IPv4 without port (uses default 8090)
-soundtouch-cli -host 192.168.1.100 -info
+soundtouch-cli -host 192.0.2.100 -info
 ```
 
 ### Hostnames
@@ -99,8 +99,8 @@ Comprehensive test coverage in `cmd/soundtouch-cli/main_test.go`:
 
 ### Integration Tests
 Tested with real SoundTouch devices:
-- ✅ SoundTouch 10 (192.168.178.28:8090)
-- ✅ SoundTouch 20 (192.168.178.35:8090)
+- ✅ SoundTouch 10 (192.0.2.11:8090)
+- ✅ SoundTouch 20 (192.0.2.10:8090)
 
 ## Benefits
 
@@ -123,31 +123,31 @@ Tested with real SoundTouch devices:
 # Discover devices to find host:port
 $ soundtouch-cli -discover
 Found SoundTouch devices:
-  My SoundTouch Device (192.168.1.10:8090) - SoundTouch 20
+  My SoundTouch Device (192.0.2.10:8090) - SoundTouch 20
 
 # Use discovered host:port directly
-$ soundtouch-cli -host 192.168.1.10:8090 -play
+$ soundtouch-cli -host 192.0.2.10:8090 -play
 ```
 
 ### Different Port Scenarios
 ```bash
 # Standard SoundTouch port
-soundtouch-cli -host 192.168.1.100:8090 -info
+soundtouch-cli -host 192.0.2.100:8090 -info
 
 # Custom port (if device configured differently)
-soundtouch-cli -host 192.168.1.100:9000 -info
+soundtouch-cli -host 192.0.2.100:9000 -info
 
 # Default port fallback
-soundtouch-cli -host 192.168.1.100 -info  # Uses 8090
+soundtouch-cli -host 192.0.2.100 -info  # Uses 8090
 ```
 
 ### Error Scenarios
 ```bash
 # Invalid port - uses default 8090
-soundtouch-cli -host 192.168.1.100:invalid -info
+soundtouch-cli -host 192.0.2.100:invalid -info
 
 # Out of range port - uses default 8090  
-soundtouch-cli -host 192.168.1.100:99999 -info
+soundtouch-cli -host 192.0.2.100:99999 -info
 
 # Malformed input - treats as hostname
 soundtouch-cli -host "malformed::input" -info
@@ -163,10 +163,10 @@ Options:
   -port <port>      SoundTouch device port (default: 8090)
 
 Examples:
-  soundtouch-cli -host 192.168.1.100 -info
-  soundtouch-cli -host 192.168.1.100:8090 -info
-  soundtouch-cli -host 192.168.1.100:8090 -pause
-  soundtouch-cli -host 192.168.1.100:8090 -preset 1
+  soundtouch-cli -host 192.0.2.100 -info
+  soundtouch-cli -host 192.0.2.100:8090 -info
+  soundtouch-cli -host 192.0.2.100:8090 -pause
+  soundtouch-cli -host 192.0.2.100:8090 -preset 1
 ```
 
 ## Technical Implementation
@@ -197,7 +197,7 @@ The parsed values are used throughout the CLI:
 
 Potential improvements for the future:
 
-1. **URL Format Support**: Support full URLs like `http://192.168.1.100:8090`
+1. **URL Format Support**: Support full URLs like `http://192.0.2.100:8090`
 2. **Service Discovery**: Auto-detect port via service discovery protocols
 3. **Configuration File**: Save frequently used host:port combinations
 4. **Environment Variables**: Support `SOUNDTOUCH_HOST` with host:port format

docs/MANUAL-NETWORK-DISCOVERY.md

@@ -316,7 +316,7 @@ MX:3
 NOTIFY * HTTP/1.1
 HOST:239.255.255.250:1900
 CACHE-CONTROL:max-age=1800
-LOCATION:http://192.168.1.100:8090/device_description.xml
+LOCATION:http://192.0.2.100:8090/device_description.xml
 NT:upnp:rootdevice
 NTS:ssdp:alive
 USN:uuid:12345678-1234-1234-1234-123456789012::upnp:rootdevice
@@ -328,7 +328,7 @@ HTTP/1.1 200 OK
 CACHE-CONTROL:max-age=1800
 DATE:Wed, 18 Dec 2024 10:30:00 GMT
 EXT:
-LOCATION:http://192.168.1.100:8090/device_description.xml
+LOCATION:http://192.0.2.100:8090/device_description.xml
 SERVER:Linux/3.0 UPnP/1.0 Device/1.0
 ST:upnp:rootdevice
 USN:uuid:12345678-1234-1234-1234-123456789012::upnp:rootdevice
@@ -363,7 +363,7 @@ arp -a
 
 # Scan local network segment (requires nmap)
 brew install nmap
-nmap -sn 192.168.1.0/24  # Adjust network range as needed
+nmap -sn 192.0.2.0/24  # Adjust network range as needed
 
 # Quick ping sweep (built-in)
 for i in {1..254}; do ping -c 1 -t 1 192.168.1.$i >/dev/null 2>&1 && echo "192.168.1.$i is up"; done
@@ -439,10 +439,10 @@ sudo tcpdump -i any -n -A 'port 5353' | grep -i soundtouch
 netstat -g
 
 # Test UDP connectivity
-nc -u 192.168.1.100 8090  # Replace with actual device IP
+nc -u 192.0.2.100 8090  # Replace with actual device IP
 
 # Test HTTP connectivity to discovered devices
-curl -i http://192.168.1.100:8090/info  # SoundTouch info endpoint
+curl -i http://192.0.2.100:8090/info  # SoundTouch info endpoint
 ```
 
 ## Protocol Comparison

docs/NAVIGATION-GUIDE.md

@@ -0,0 +1,898 @@
+# Navigation and Station Management Guide
+
+## Overview
+
+The Bose SoundTouch Go client provides comprehensive navigation and station management functionality that allows you to:
+
+- **Browse content sources** (TuneIn, Pandora, Spotify, stored music)
+- **Search for stations and content** across music services
+- **Add stations and immediately play them**
+- **Remove stations from collections**
+- **Navigate directory structures** in music libraries
+
+This guide provides complete examples and best practices for using these features.
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Content Navigation](#content-navigation)
+- [Station Search](#station-search)
+- [Station Management](#station-management)
+- [Complete Workflows](#complete-workflows)
+- [Error Handling](#error-handling)
+- [Best Practices](#best-practices)
+- [API Reference](#api-reference)
+
+## Quick Start
+
+### Basic Setup
+
+```go
+package main
+
+import (
+    "fmt"
+    "log"
+    
+    "github.com/gesellix/bose-soundtouch/pkg/client"
+)
+
+func main() {
+    // Create client
+    config := &client.Config{
+        Host: "192.0.2.100",
+        Port: 8090,
+    }
+    soundtouch := client.NewClient(config)
+    
+    // Your navigation code here...
+}
+```
+
+### Simple Navigation Example
+
+```go
+// Browse TuneIn content
+response, err := soundtouch.Navigate("TUNEIN", "", 1, 25)
+if err != nil {
+    log.Fatal(err)
+}
+
+fmt.Printf("Found %d items\n", response.TotalItems)
+for _, item := range response.Items {
+    fmt.Printf("- %s (%s)\n", item.GetDisplayName(), item.Type)
+}
+```
+
+## Content Navigation
+
+### Browse Different Sources
+
+```go
+// Browse TuneIn radio stations
+tuneInStations, err := soundtouch.GetTuneInStations("")
+if err != nil {
+    log.Printf("TuneIn not available: %v", err)
+} else {
+    fmt.Printf("TuneIn has %d items\n", tuneInStations.TotalItems)
+}
+
+// Browse Pandora stations (requires account)
+pandoraStations, err := soundtouch.GetPandoraStations("your_pandora_account")
+if err != nil {
+    log.Printf("Pandora not available: %v", err)
+} else {
+    stations := pandoraStations.GetStations()
+    fmt.Printf("Found %d Pandora stations\n", len(stations))
+}
+
+// Browse stored music library
+musicLibrary, err := soundtouch.GetStoredMusicLibrary("device_account/0")
+if err != nil {
+    log.Printf("Stored music not available: %v", err)
+} else {
+    directories := musicLibrary.GetDirectories()
+    tracks := musicLibrary.GetTracks()
+    fmt.Printf("Music library: %d dirs, %d tracks\n", len(directories), len(tracks))
+}
+```
+
+### Navigate Into Directories
+
+```go
+// First, get the root level
+musicLibrary, err := soundtouch.GetStoredMusicLibrary("device_account/0")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Find a directory to browse into
+directories := musicLibrary.GetDirectories()
+if len(directories) == 0 {
+    fmt.Println("No directories found")
+    return
+}
+
+// Navigate into the first directory
+directory := directories[0]
+fmt.Printf("Browsing into: %s\n", directory.GetDisplayName())
+
+contents, err := soundtouch.NavigateContainer(
+    "STORED_MUSIC",
+    "device_account/0",
+    1, 100,  // Get up to 100 items starting from position 1
+    directory.ContentItem,
+)
+if err != nil {
+    log.Fatal(err)
+}
+
+// Show what's inside
+tracks := contents.GetTracks()
+subdirs := contents.GetDirectories()
+fmt.Printf("Found %d tracks and %d subdirectories\n", len(tracks), len(subdirs))
+
+// List first few tracks
+for i, track := range tracks[:min(5, len(tracks))] {
+    fmt.Printf("%d. %s", i+1, track.GetDisplayName())
+    if track.ArtistName != "" {
+        fmt.Printf(" - %s", track.ArtistName)
+    }
+    if track.AlbumName != "" {
+        fmt.Printf(" [%s]", track.AlbumName)
+    }
+    fmt.Println()
+}
+```
+
+### Advanced Navigation with Pagination
+
+```go
+// Browse large collections with pagination
+const pageSize = 50
+startItem := 1
+
+for {
+    response, err := soundtouch.Navigate("STORED_MUSIC", "device/0", startItem, pageSize)
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    if len(response.Items) == 0 {
+        break // No more items
+    }
+    
+    fmt.Printf("Page starting at %d: %d items\n", startItem, len(response.Items))
+    
+    // Process this page
+    for _, item := range response.Items {
+        fmt.Printf("  %s (%s)\n", item.GetDisplayName(), item.Type)
+    }
+    
+    // Move to next page
+    startItem += pageSize
+    
+    // Stop if we've seen all items
+    if startItem > response.TotalItems {
+        break
+    }
+}
+```
+
+## Station Search
+
+### Basic Search
+
+```go
+// Search TuneIn for jazz stations
+results, err := soundtouch.SearchTuneInStations("jazz")
+if err != nil {
+    log.Fatal(err)
+}
+
+fmt.Printf("Found %d total results for 'jazz'\n", results.GetResultCount())
+
+// Show different types of results
+songs := results.GetSongs()
+artists := results.GetArtists()
+stations := results.GetStations()
+
+fmt.Printf("Songs: %d, Artists: %d, Stations: %d\n",
+    len(songs), len(artists), len(stations))
+```
+
+### Service-Specific Search
+
+```go
+// Search Pandora (requires account)
+pandoraResults, err := soundtouch.SearchPandoraStations("your_account", "Taylor Swift")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Show artists found
+artists := pandoraResults.GetArtists()
+for _, artist := range artists {
+    fmt.Printf("Artist: %s (Token: %s)\n", artist.Name, artist.Token)
+    if artist.Logo != "" {
+        fmt.Printf("  Artwork: %s\n", artist.GetArtworkURL())
+    }
+}
+
+// Search Spotify content
+spotifyResults, err := soundtouch.SearchSpotifyContent("your_spotify_account", "Queen")
+if err != nil {
+    log.Fatal(err)
+}
+
+songs := spotifyResults.GetSongs()
+for _, song := range songs[:min(5, len(songs))] {
+    fmt.Printf("Song: %s\n", song.GetFullTitle())
+}
+```
+
+### Search Result Analysis
+
+```go
+results, err := soundtouch.SearchPandoraStations("account", "classic rock")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Analyze all results
+for _, result := range results.GetAllResults() {
+    fmt.Printf("Name: %s, Token: %s\n", result.GetDisplayName(), result.Token)
+    
+    // Determine result type
+    switch {
+    case result.IsSong():
+        fmt.Printf("  Type: Song by %s\n", result.Artist)
+    case result.IsArtist():
+        fmt.Printf("  Type: Artist\n")
+    case result.IsStation():
+        fmt.Printf("  Type: Station")
+        if result.Description != "" {
+            fmt.Printf(" - %s", result.Description)
+        }
+        fmt.Println()
+    }
+}
+```
+
+## Station Management
+
+### Adding Stations (Immediate Playback)
+
+```go
+// Search for content first
+results, err := soundtouch.SearchPandoraStations("your_account", "Led Zeppelin")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Find an artist to create a station from
+artists := results.GetArtists()
+if len(artists) == 0 {
+    fmt.Println("No artists found")
+    return
+}
+
+artist := artists[0]
+stationName := artist.Name + " Radio"
+
+// Add station - this immediately starts playing it!
+err = soundtouch.AddStation("PANDORA", "your_account", artist.Token, stationName)
+if err != nil {
+    log.Fatal(err)
+}
+
+fmt.Printf("✓ Added and now playing: %s\n", stationName)
+
+// The station is now:
+// 1. Added to your Pandora collection
+// 2. Currently playing on the device
+```
+
+### Removing Stations
+
+```go
+// First, get existing stations
+stations, err := soundtouch.GetPandoraStations("your_account")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Show current stations
+fmt.Printf("Current stations (%d):\n", len(stations.Items))
+for i, station := range stations.Items {
+    fmt.Printf("%d. %s\n", i+1, station.GetDisplayName())
+}
+
+// Remove a specific station (example: remove the first one)
+if len(stations.Items) > 0 {
+    stationToRemove := stations.Items[0]
+    
+    if stationToRemove.ContentItem != nil {
+        fmt.Printf("Removing: %s\n", stationToRemove.GetDisplayName())
+        
+        err := soundtouch.RemoveStation(stationToRemove.ContentItem)
+        if err != nil {
+            log.Printf("Failed to remove station: %v", err)
+        } else {
+            fmt.Println("✓ Station removed successfully")
+        }
+    }
+}
+```
+
+### Station Collection Management
+
+```go
+// Get current collection
+currentStations, err := soundtouch.GetPandoraStations("your_account")
+if err != nil {
+    log.Fatal(err)
+}
+
+fmt.Printf("Current collection has %d stations\n", len(currentStations.Items))
+
+// Search for new content
+searchResults, err := soundtouch.SearchPandoraStations("your_account", "indie rock")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Add top 3 artist stations
+artists := searchResults.GetArtists()
+for i, artist := range artists[:min(3, len(artists))] {
+    stationName := fmt.Sprintf("%s Radio", artist.Name)
+    
+    fmt.Printf("Adding station %d: %s\n", i+1, stationName)
+    
+    err := soundtouch.AddStation("PANDORA", "your_account", artist.Token, stationName)
+    if err != nil {
+        log.Printf("Failed to add %s: %v", stationName, err)
+        continue
+    }
+    
+    fmt.Printf("✓ Added: %s\n", stationName)
+    
+    // Note: Each AddStation immediately starts playing that station
+    // You might want to pause between additions in a real app
+}
+
+fmt.Println("Station collection updated!")
+```
+
+## Complete Workflows
+
+### Discover and Play Workflow
+
+```go
+func discoverAndPlayWorkflow(soundtouch *client.Client) {
+    fmt.Println("=== Discover and Play Workflow ===")
+    
+    // Step 1: Search for content
+    searchTerm := "electronic music"
+    fmt.Printf("🔍 Searching for '%s'...\n", searchTerm)
+    
+    results, err := soundtouch.SearchTuneInStations(searchTerm)
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    if results.IsEmpty() {
+        fmt.Println("❌ No results found")
+        return
+    }
+    
+    // Step 2: Show options
+    stations := results.GetStations()
+    fmt.Printf("📻 Found %d stations:\n", len(stations))
+    
+    for i, station := range stations[:min(5, len(stations))] {
+        fmt.Printf("%d. %s", i+1, station.GetDisplayName())
+        if station.Description != "" {
+            fmt.Printf(" - %s", station.Description)
+        }
+        fmt.Println()
+    }
+    
+    // Step 3: Select and play (example: select first one)
+    if len(stations) > 0 {
+        selectedStation := stations[0]
+        fmt.Printf("🎵 Playing: %s\n", selectedStation.GetDisplayName())
+        
+        // For services that support it, add the station to play it
+        if selectedStation.Token != "" {
+            err := soundtouch.AddStation("TUNEIN", "", selectedStation.Token, selectedStation.Name)
+            if err != nil {
+                log.Printf("Could not add station: %v", err)
+            } else {
+                fmt.Println("✓ Station added and playing!")
+            }
+        }
+    }
+}
+```
+
+### Library Organization Workflow
+
+```go
+func organizeLibraryWorkflow(soundtouch *client.Client, deviceAccount string) {
+    fmt.Println("=== Library Organization Workflow ===")
+    
+    // Step 1: Explore library structure
+    fmt.Println("📂 Exploring music library...")
+    
+    library, err := soundtouch.GetStoredMusicLibrary(deviceAccount)
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    directories := library.GetDirectories()
+    tracks := library.GetTracks()
+    
+    fmt.Printf("📊 Library overview: %d directories, %d tracks\n", 
+        len(directories), len(tracks))
+    
+    // Step 2: Navigate into each directory
+    for _, dir := range directories[:min(3, len(directories))] {
+        fmt.Printf("\n📁 Exploring: %s\n", dir.GetDisplayName())
+        
+        contents, err := soundtouch.NavigateContainer(
+            "STORED_MUSIC", deviceAccount, 1, 20, dir.ContentItem)
+        if err != nil {
+            log.Printf("❌ Failed to explore %s: %v", dir.GetDisplayName(), err)
+            continue
+        }
+        
+        subTracks := contents.GetTracks()
+        subDirs := contents.GetDirectories()
+        
+        fmt.Printf("   Contains: %d tracks, %d subdirectories\n", 
+            len(subTracks), len(subDirs))
+        
+        // Show some tracks
+        for i, track := range subTracks[:min(3, len(subTracks))] {
+            fmt.Printf("   %d. %s", i+1, track.GetDisplayName())
+            if track.ArtistName != "" {
+                fmt.Printf(" - %s", track.ArtistName)
+            }
+            fmt.Println()
+        }
+    }
+    
+    fmt.Println("\n✓ Library exploration complete!")
+}
+```
+
+### Multi-Service Content Discovery
+
+```go
+func multiServiceDiscovery(soundtouch *client.Client, accounts map[string]string) {
+    searchTerm := "jazz"
+    fmt.Printf("🔍 Searching '%s' across all services...\n", searchTerm)
+    
+    // Search TuneIn (no account needed)
+    fmt.Println("\n📻 TuneIn Results:")
+    tuneInResults, err := soundtouch.SearchTuneInStations(searchTerm)
+    if err != nil {
+        fmt.Printf("❌ TuneIn search failed: %v\n", err)
+    } else {
+        stations := tuneInResults.GetStations()
+        fmt.Printf("✓ Found %d TuneIn stations\n", len(stations))
+        for i, station := range stations[:min(3, len(stations))] {
+            fmt.Printf("  %d. %s\n", i+1, station.GetDisplayName())
+        }
+    }
+    
+    // Search Pandora (if account available)
+    if pandoraAccount, ok := accounts["PANDORA"]; ok {
+        fmt.Println("\n🎵 Pandora Results:")
+        pandoraResults, err := soundtouch.SearchPandoraStations(pandoraAccount, searchTerm)
+        if err != nil {
+            fmt.Printf("❌ Pandora search failed: %v\n", err)
+        } else {
+            artists := pandoraResults.GetArtists()
+            stations := pandoraResults.GetStations()
+            fmt.Printf("✓ Found %d artists, %d stations\n", len(artists), len(stations))
+            
+            for i, artist := range artists[:min(2, len(artists))] {
+                fmt.Printf("  Artist: %s\n", artist.GetDisplayName())
+            }
+        }
+    }
+    
+    // Search Spotify (if account available)
+    if spotifyAccount, ok := accounts["SPOTIFY"]; ok {
+        fmt.Println("\n🎼 Spotify Results:")
+        spotifyResults, err := soundtouch.SearchSpotifyContent(spotifyAccount, searchTerm)
+        if err != nil {
+            fmt.Printf("❌ Spotify search failed: %v\n", err)
+        } else {
+            songs := spotifyResults.GetSongs()
+            fmt.Printf("✓ Found %d songs\n", len(songs))
+            
+            for i, song := range songs[:min(2, len(songs))] {
+                fmt.Printf("  Song: %s\n", song.GetFullTitle())
+            }
+        }
+    }
+    
+    fmt.Println("\n✓ Multi-service discovery complete!")
+}
+```
+
+## Error Handling
+
+### Graceful Error Handling
+
+```go
+func robustNavigation(soundtouch *client.Client) error {
+    // Try multiple sources gracefully
+    sources := []string{"TUNEIN", "SPOTIFY", "STORED_MUSIC"}
+    
+    for _, source := range sources {
+        fmt.Printf("Trying %s...\n", source)
+        
+        response, err := soundtouch.Navigate(source, "", 1, 10)
+        if err != nil {
+            fmt.Printf("❌ %s failed: %v\n", source, err)
+            continue
+        }
+        
+        if response.IsEmpty() {
+            fmt.Printf("⚠️  %s has no content\n", source)
+            continue
+        }
+        
+        fmt.Printf("✓ %s available with %d items\n", source, response.TotalItems)
+        return nil
+    }
+    
+    return fmt.Errorf("no sources available")
+}
+```
+
+### Retry Logic
+
+```go
+func searchWithRetry(soundtouch *client.Client, maxRetries int) (*models.SearchStationResponse, error) {
+    var lastErr error
+    
+    for attempt := 1; attempt <= maxRetries; attempt++ {
+        fmt.Printf("Search attempt %d/%d...\n", attempt, maxRetries)
+        
+        results, err := soundtouch.SearchTuneInStations("classical")
+        if err == nil {
+            return results, nil
+        }
+        
+        lastErr = err
+        fmt.Printf("❌ Attempt %d failed: %v\n", attempt, err)
+        
+        if attempt < maxRetries {
+            time.Sleep(time.Duration(attempt) * time.Second)
+        }
+    }
+    
+    return nil, fmt.Errorf("search failed after %d attempts: %w", maxRetries, lastErr)
+}
+```
+
+### Validation and Safety
+
+```go
+func safeStationManagement(soundtouch *client.Client, pandoraAccount string) {
+    // Always validate inputs
+    if pandoraAccount == "" {
+        log.Fatal("Pandora account required")
+    }
+    
+    // Search safely
+    results, err := soundtouch.SearchPandoraStations(pandoraAccount, "blues")
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    if results.IsEmpty() {
+        fmt.Println("No results found")
+        return
+    }
+    
+    // Check what we have before adding stations
+    artists := results.GetArtists()
+    if len(artists) == 0 {
+        fmt.Println("No artists found to create stations from")
+        return
+    }
+    
+    // Get current stations to avoid duplicates
+    currentStations, err := soundtouch.GetPandoraStations(pandoraAccount)
+    if err != nil {
+        log.Printf("Warning: Could not get current stations: %v", err)
+    }
+    
+    // Create a map of existing station names
+    existingStations := make(map[string]bool)
+    for _, station := range currentStations.Items {
+        existingStations[station.GetDisplayName()] = true
+    }
+    
+    // Add stations only if they don't exist
+    for _, artist := range artists[:min(2, len(artists))] {
+        stationName := artist.Name + " Radio"
+        
+        if existingStations[stationName] {
+            fmt.Printf("⚠️  Station already exists: %s\n", stationName)
+            continue
+        }
+        
+        fmt.Printf("Adding new station: %s\n", stationName)
+        err := soundtouch.AddStation("PANDORA", pandoraAccount, artist.Token, stationName)
+        if err != nil {
+            log.Printf("❌ Failed to add %s: %v", stationName, err)
+        } else {
+            fmt.Printf("✓ Added: %s\n", stationName)
+        }
+    }
+}
+```
+
+## Best Practices
+
+### 1. Check Source Availability
+
+```go
+// Always check what sources are available first
+sources, err := soundtouch.GetSources()
+if err != nil {
+    return err
+}
+
+// Check if TuneIn is ready
+for _, source := range sources.SourceItem {
+    if source.Source == "TUNEIN" && source.Status.IsReady() {
+        // TuneIn is available
+        break
+    }
+}
+```
+
+### 2. Use Pagination for Large Collections
+
+```go
+// For large libraries, use pagination
+const batchSize = 50
+
+func processLargeLibrary(soundtouch *client.Client, sourceAccount string) {
+    startItem := 1
+    
+    for {
+        batch, err := soundtouch.Navigate("STORED_MUSIC", sourceAccount, startItem, batchSize)
+        if err != nil {
+            log.Printf("Error at position %d: %v", startItem, err)
+            break
+        }
+        
+        if len(batch.Items) == 0 {
+            break // No more items
+        }
+        
+        // Process this batch
+        processBatch(batch.Items)
+        
+        startItem += batchSize
+        
+        // Prevent infinite loops
+        if startItem > batch.TotalItems {
+            break
+        }
+    }
+}
+```
+
+### 3. Handle Service-Specific Behavior
+
+```go
+func handleServiceDifferences(soundtouch *client.Client) {
+    // TuneIn: Usually no account needed
+    tuneInStations, err := soundtouch.SearchTuneInStations("news")
+    if err == nil {
+        fmt.Printf("TuneIn: %d stations\n", len(tuneInStations.GetStations()))
+    }
+    
+    // Pandora: Requires user account
+    pandoraResults, err := soundtouch.SearchPandoraStations("user_account", "rock")
+    if err == nil {
+        // Pandora returns artists you can create stations from
+        artists := pandoraResults.GetArtists()
+        fmt.Printf("Pandora: %d artists\n", len(artists))
+    }
+    
+    // Spotify: Requires user account, returns tracks/playlists
+    spotifyResults, err := soundtouch.SearchSpotifyContent("spotify_user", "pop")
+    if err == nil {
+        songs := spotifyResults.GetSongs()
+        fmt.Printf("Spotify: %d songs\n", len(songs))
+    }
+}
+```
+
+### 4. Implement User-Friendly Interfaces
+
+```go
+func userFriendlySearch(soundtouch *client.Client, searchTerm string) {
+    fmt.Printf("🔍 Searching for '%s'...\n", searchTerm)
+    
+    results, err := soundtouch.SearchTuneInStations(searchTerm)
+    if err != nil {
+        fmt.Printf("❌ Search failed: %v\n", err)
+        return
+    }
+    
+    if results.IsEmpty() {
+        fmt.Printf("😞 No results found for '%s'\n", searchTerm)
+        fmt.Println("💡 Try different search terms like:")
+        fmt.Println("   - Genre names: jazz, rock, classical")
+        fmt.Println("   - Artist names: Beatles, Mozart")
+        fmt.Println("   - Station types: news, talk, music")
+        return
+    }
+    
+    stations := results.GetStations()
+    fmt.Printf("🎵 Found %d stations:\n", len(stations))
+    
+    for i, station := range stations {
+        fmt.Printf("%d. 📻 %s", i+1, station.GetDisplayName())
+        if station.Description != "" {
+            fmt.Printf("\n   %s", station.Description)
+        }
+        if station.GetArtworkURL() != "" {
+            fmt.Printf("\n   🎨 %s", station.GetArtworkURL())
+        }
+        fmt.Println()
+    }
+}
+```
+
+### 5. Performance Considerations
+
+```go
+func efficientBrowsing(soundtouch *client.Client) {
+    // Use reasonable page sizes
+    const optimalPageSize = 25 // Good balance of network efficiency and memory usage
+    
+    // Cache frequently accessed data
+    var cachedSources *models.Sources
+    
+    getSources := func() (*models.Sources, error) {
+        if cachedSources == nil {
+            var err error
+            cachedSources, err = soundtouch.GetSources()
+            return cachedSources, err
+        }
+        return cachedSources, nil
+    }
+    
+    // Use the cached sources
+    sources, err := getSources()
+    if err != nil {
+        return
+    }
+    
+    // Process efficiently
+    for _, source := range sources.SourceItem {
+        if source.Status.IsReady() {
+            // Only browse ready sources
+            procesReadySource(soundtouch, source.Source, source.SourceAccount)
+        }
+    }
+}
+```
+
+## API Reference
+
+### Navigation Methods
+
+| Method | Description | Parameters | Returns |
+|--------|-------------|------------|---------|
+| `Navigate()` | Browse content source | source, account, start, count | NavigateResponse |
+| `NavigateWithMenu()` | Browse with menu/sort | source, account, menu, sort, start, count | NavigateResponse |
+| `NavigateContainer()` | Browse into directory | source, account, start, count, container | NavigateResponse |
+| `GetTuneInStations()` | Convenience for TuneIn | account | NavigateResponse |
+| `GetPandoraStations()` | Convenience for Pandora | account | NavigateResponse |
+| `GetStoredMusicLibrary()` | Convenience for stored music | account | NavigateResponse |
+
+### Search Methods
+
+| Method | Description | Parameters | Returns |
+|--------|-------------|------------|---------|
+| `SearchStation()` | Generic station search | source, account, term | SearchStationResponse |
+| `SearchTuneInStations()` | Search TuneIn | term | SearchStationResponse |
+| `SearchPandoraStations()` | Search Pandora | account, term | SearchStationResponse |
+| `SearchSpotifyContent()` | Search Spotify | account, term | SearchStationResponse |
+
+### Station Management Methods
+
+| Method | Description | Parameters | Returns |
+|--------|-------------|------------|---------|
+| `AddStation()` | Add station (plays immediately) | source, account, token, name | error |
+| `RemoveStation()` | Remove station from collection | contentItem | error |
+
+### Response Helper Methods
+
+#### NavigateResponse Methods
+
+- `GetPlayableItems()` - Filter playable items
+- `GetDirectories()` - Filter directories
+- `GetTracks()` - Filter music tracks  
+- `GetStations()` - Filter radio stations
+- `IsEmpty()` - Check if response has no items
+
+#### SearchStationResponse Methods
+
+- `GetSongs()` - Filter song results
+- `GetArtists()` - Filter artist results
+- `GetStations()` - Filter station results
+- `GetAllResults()` - Get all results combined
+- `GetResultCount()` - Count total results
+- `HasResults()` - Check if any results found
+- `IsEmpty()` - Check if no results
+
+#### SearchResult Methods
+
+- `IsSong()` - Check if result is a song
+- `IsArtist()` - Check if result is an artist
+- `IsStation()` - Check if result is a station
+- `GetDisplayName()` - Get formatted name
+- `GetFullTitle()` - Get name with artist (for songs)
+- `GetArtworkURL()` - Get artwork/logo URL
+
+### Common Source Types
+
+| Source | Description | Account Required | Search Support |
+|--------|-------------|------------------|----------------|
+| `TUNEIN` | Internet radio stations | No | Yes |
+| `PANDORA` | Pandora music service | Yes | Yes |
+| `SPOTIFY` | Spotify music service | Yes | Yes |
+| `STORED_MUSIC` | Local/network music | Device account | No |
+| `BLUETOOTH` | Bluetooth audio input | No | No |
+| `AUX` | Auxiliary input | No | No |
+
+## Troubleshooting
+
+### Common Issues
+
+**"Source not available"**
+- Check if the service is configured on your SoundTouch device
+- Verify account credentials are set up properly
+- Use `GetSources()` to see what's actually available
+
+**"No results found"**
+- Try broader search terms
+- Check if the service is working (try via SoundTouch app)
+- Verify account has access to content
+
+**"AddStation failed"** 
+- Ensure the token is valid (from search results)
+- Check that the service supports adding stations
+- Verify account permissions
+
+**Navigation timeouts**
+- Large libraries may take time to browse
+- Use smaller page sizes for better performance
+- Implement timeout handling in your code
+
+### Getting Help
+
+For additional help:
+- Check the SoundTouch device logs
+- Test functionality via the official SoundTouch app
+- Review network connectivity between client and device
+- Examine the raw XML responses for debugging
+
+---
+
+*This guide covers the complete navigation and station management functionality. For preset management, see [PRESET-MANAGEMENT.md](reference/PRESET-MANAGEMENT.md).*