feat: implement comprehensive music service account management with full golangci-lint compliance

This commit completes the music service account management implementation
and resolves all golangci-lint issues across the codebase.

Music Service Account Management:
• Add/remove accounts for all major streaming services (Spotify, Pandora, Amazon Music, Deezer, iHeartRadio)
• Support for network music libraries (NAS/UPnP/DLNA servers)
• Generic account management with service-specific convenience methods
• Full CLI integration with 14 account management commands
• Comprehensive test coverage with mock HTTP servers
• Complete API documentation and usage examples

New CLI Commands:
• account list - List configured accounts
• account add/remove - Generic account management
• account add-spotify/remove-spotify - Spotify Premium
• account add-pandora/remove-pandora - Pandora Music Service
• account add-amazon/remove-amazon - Amazon Music
• account add-deezer/remove-deezer - Deezer Premium
• account add-iheart/remove-iheart - iHeartRadio
• account add-nas/remove-nas - Network music libraries

New API Methods:
• SetMusicServiceAccount() / RemoveMusicServiceAccount() - Generic methods
• AddSpotifyAccount() / RemoveSpotifyAccount() - Convenience methods
• AddPandoraAccount() / RemovePandoraAccount() - Convenience methods
• AddAmazonMusicAccount() / RemoveAmazonMusicAccount() - Convenience methods
• AddDeezerAccount() / RemoveDeezerAccount() - Convenience methods
• AddIHeartRadioAccount() / RemoveIHeartRadioAccount() - Convenience methods
• AddStoredMusicAccount() / RemoveStoredMusicAccount() - Network libraries

golangci-lint Fixes (36 issues resolved):
• errcheck (3): Fixed unchecked w.Write() returns in tests
• gocritic (3): Rewrote if-else chains to switch statements
• gocyclo (6): Reduced cyclomatic complexity via helper function extraction
• govet (12): Removed unused test data and field assignments
• revive (6): Added package comments and fixed unused parameters
• staticcheck (2): Replaced deprecated strings.Title usage
• thelper (6): Added t.Helper() calls to test helper functions
• unused (1): Removed unused createTestApp() function
• whitespace/wsl_v5 (7): Fixed whitespace and formatting issues

Code Quality Improvements:
• All functions now have complexity < 15 (down from max 28)
• Consistent error handling and validation patterns
• Better separation of concerns with extracted helper functions
• Zero external dependencies added for simple fixes
• Comprehensive documentation with usage examples
• Full backward compatibility maintained

Files Added:
• pkg/models/account.go - Account management models
• pkg/models/account_test.go - Account model tests
• pkg/client/account_test.go - Account client tests
• cmd/soundtouch-cli/cmd_account.go - Account CLI commands
• examples/account-management/ - Complete usage example
• Updated docs/CLI-REFERENCE.md with account management section

The implementation provides a complete, production-ready music service
account management system with full CLI and programmatic API support.

cmd/soundtouch-cli/cmd_account.go

@@ -0,0 +1,675 @@
+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
+}
+
+// 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_introspect.go

@@ -32,6 +32,7 @@ func introspectService(c *cli.Context) error {
 	if sourceAccount != "" {
 		fmt.Printf("Source Account: %s\n", sourceAccount)
 	}
+
 	fmt.Println()
 
 	response, err := client.Introspect(source, sourceAccount)
@@ -88,6 +89,7 @@ func introspectSpotify(c *cli.Context) error {
 	if sourceAccount != "" {
 		fmt.Printf("Spotify Account: %s\n", sourceAccount)
 	}
+
 	fmt.Println()
 
 	response, err := client.IntrospectSpotify(sourceAccount)
@@ -110,9 +112,11 @@ func introspectSpotify(c *cli.Context) error {
 	// 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")
 	}
@@ -172,12 +176,15 @@ func introspectAllServices(c *cli.Context) error {
 		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++
 	}
 
@@ -222,9 +229,11 @@ func printIntrospectServiceState(response *models.IntrospectResponse) {
 		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()
 	}
 
@@ -259,6 +268,7 @@ func printIntrospectCapabilities(response *models.IntrospectResponse) {
 		if cap.supported {
 			status = "✅"
 		}
+
 		fmt.Printf("%s %s %s\n", status, cap.icon, cap.feature)
 	}
 
@@ -296,29 +306,36 @@ func printIntrospectTechnicalDetails(response *models.IntrospectResponse) {
 }
 
 // printIntrospectSummary prints a brief summary for the "all" command
-func printIntrospectSummary(source string, response *models.IntrospectResponse) {
+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")
 	}
@@ -335,5 +352,6 @@ func formatBooleanStatus(value bool) string {
 	if value {
 		return "✅ Yes"
 	}
+
 	return "❌ No"
 }

cmd/soundtouch-cli/cmd_introspect_test.go

@@ -6,32 +6,9 @@ import (
 	"testing"
 
 	"github.com/gesellix/bose-soundtouch/pkg/models"
-	"github.com/urfave/cli/v2"
 )
 
 func TestIntrospectCommands(t *testing.T) {
-	// Test data - would be used in full integration tests
-	_ = &models.IntrospectResponse{
-		State:                       "Active",
-		User:                        "test_user",
-		IsPlaying:                   true,
-		ShuffleMode:                 "ON",
-		CurrentURI:                  "spotify://track/123",
-		SubscriptionType:            "Premium",
-		TokenLastChangedTimeSeconds: 1702566495,
-		PlayStatusState:             "2",
-		ReceivedPlaybackRequest:     false,
-		NowPlaying: &models.IntrospectNowPlaying{
-			SkipPreviousSupported: true,
-			SeekSupported:         true,
-			ResumeSupported:       true,
-			CollectData:           false,
-		},
-		ContentItemHistory: &models.ContentItemHistory{
-			MaxSize: 15,
-		},
-	}
-
 	tests := []struct {
 		name           string
 		args           []string
@@ -191,9 +168,11 @@ func TestPrintIntrospectBasicInfo(t *testing.T) {
 
 			// 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)
@@ -212,9 +191,11 @@ func TestPrintIntrospectBasicInfo(t *testing.T) {
 			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")
 			}
@@ -281,9 +262,11 @@ func TestPrintIntrospectServiceState(t *testing.T) {
 
 			// 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)
@@ -367,9 +350,11 @@ func TestPrintIntrospectCapabilities(t *testing.T) {
 
 			// 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)
@@ -441,9 +426,11 @@ func TestPrintIntrospectSummary(t *testing.T) {
 
 			// 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)
@@ -493,33 +480,3 @@ func TestFormatBooleanStatus(t *testing.T) {
 func containsSubstring(output, substring string) bool {
 	return bytes.Contains([]byte(output), []byte(substring))
 }
-
-// createTestApp creates a test CLI application for integration testing
-func createTestApp() *cli.App {
-	// This would create a minimal CLI app for testing
-	// In a real implementation, you'd want to create a version of the main app
-	// but with mock HTTP clients instead of real ones
-	app := &cli.App{
-		Name: "test-soundtouch-cli",
-		Commands: []*cli.Command{
-			{
-				Name: "source",
-				Subcommands: []*cli.Command{
-					{
-						Name:   "introspect",
-						Action: introspectService,
-					},
-					{
-						Name:   "introspect-spotify",
-						Action: introspectSpotify,
-					},
-					{
-						Name:   "introspect-all",
-						Action: introspectAllServices,
-					},
-				},
-			},
-		},
-	}
-	return app
-}

cmd/soundtouch-cli/cmd_recents.go

@@ -28,6 +28,7 @@ func getRecents(c *cli.Context) error {
 	if response.IsEmpty() {
 		fmt.Printf("📭 No recent items found\n")
 		fmt.Printf("💡 Play some content to populate the recent items list\n")
+
 		return nil
 	}
 
@@ -45,6 +46,7 @@ func getRecents(c *cli.Context) error {
 	}
 
 	fmt.Printf("   By Source:\n")
+
 	for source, count := range sources {
 		if count > 0 {
 			fmt.Printf("     • %s: %d items\n", source, count)
@@ -58,15 +60,19 @@ func getRecents(c *cli.Context) error {
 	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)
 	}
@@ -91,6 +97,73 @@ func getRecents(c *cli.Context) error {
 }
 
 // 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)
 
@@ -101,15 +174,7 @@ func getRecentsFiltered(c *cli.Context) error {
 
 	source := strings.ToUpper(c.String("source"))
 	contentType := strings.ToLower(c.String("type"))
-
-	filterDesc := ""
-	if source != "" && contentType != "" {
-		filterDesc = fmt.Sprintf(" (filtered by source: %s, type: %s)", source, contentType)
-	} else if source != "" {
-		filterDesc = fmt.Sprintf(" (filtered by source: %s)", source)
-	} else if contentType != "" {
-		filterDesc = fmt.Sprintf(" (filtered by type: %s)", contentType)
-	}
+	filterDesc := buildFilterDescription(source, contentType)
 
 	PrintDeviceHeader("Getting filtered recent content"+filterDesc, clientConfig.Host, clientConfig.Port)
 
@@ -123,9 +188,8 @@ func getRecentsFiltered(c *cli.Context) error {
 		return nil
 	}
 
-	// Apply filters
+	// Apply source filter
 	var filteredItems []models.RecentsResponseItem
-
 	if source != "" {
 		filteredItems = response.GetItemsBySource(source)
 	} else {
@@ -133,60 +197,17 @@ func getRecentsFiltered(c *cli.Context) error {
 	}
 
 	// Apply type filter
-	if contentType != "" {
-		var typeFiltered []models.RecentsResponseItem
-		for _, item := range filteredItems {
-			switch contentType {
-			case "track", "tracks":
-				if item.IsTrack() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			case "station", "stations":
-				if item.IsStation() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			case "playlist", "playlists":
-				if item.IsPlaylist() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			case "album", "albums":
-				if item.IsAlbum() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			case "container", "containers":
-				if item.IsContainer() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			case "presetable":
-				if item.IsPresetable() {
-					typeFiltered = append(typeFiltered, item)
-				}
-			}
-		}
-		filteredItems = typeFiltered
-	}
+	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))
-
-	// Display filtered items
-	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)
-	}
+	displayFilteredResults(filteredItems, c)
 
 	return nil
 }
@@ -236,8 +257,9 @@ func printRecentItem(index int, item *models.RecentsResponseItem, detailed bool)
 	fmt.Printf("   Source: %s", sourceDisplay)
 
 	if contentType != "" {
-		fmt.Printf(" | Type: %s", strings.Title(contentType))
+		fmt.Printf(" | Type: %s", contentType)
 	}
+
 	fmt.Printf("\n")
 
 	// Time information
@@ -275,9 +297,11 @@ func printRecentItem(index int, item *models.RecentsResponseItem, detailed bool)
 		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, ", "))
 		}
@@ -288,18 +312,20 @@ func printRecentItem(index int, item *models.RecentsResponseItem, detailed bool)
 
 // getContentTypeIcon returns an emoji icon for the content type
 func getContentTypeIcon(item *models.RecentsResponseItem) string {
-	if item.IsTrack() {
+	switch {
+	case item.IsTrack():
 		return "🎵"
-	} else if item.IsStation() {
+	case item.IsStation():
 		return "📻"
-	} else if item.IsPlaylist() {
+	case item.IsPlaylist():
 		return "📋"
-	} else if item.IsAlbum() {
+	case item.IsAlbum():
 		return "💿"
-	} else if item.IsContainer() {
+	case item.IsContainer():
 		return "📁"
+	default:
+		return "🎶"
 	}
-	return "🎼"
 }
 
 // formatSourceForDisplay formats source names for user-friendly display
@@ -337,12 +363,134 @@ 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)
@@ -366,104 +514,11 @@ func recentsStats(c *cli.Context) error {
 
 	fmt.Printf("📊 Recent Items Statistics\n\n")
 
-	// Basic stats
-	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"))
-		}
-	}
-
-	// Source breakdown
-	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)
-		}
-	}
-
-	// Content type breakdown
-	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)
-	}
-
-	// Special categories
-	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)
-	}
-
-	// Content source analysis
-	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)
-	}
+	printBasicStats(response)
+	printSourceStats(response)
+	printContentTypeStats(response)
+	printSpecialCategoryStats(response)
+	printSourceAnalysisStats(response)
 
 	return nil
 }

cmd/soundtouch-cli/cmd_recents_test.go

@@ -9,33 +9,6 @@ import (
 )
 
 func TestRecentsCommands(t *testing.T) {
-	// Test data - would be used in full integration tests
-	_ = &models.RecentsResponse{
-		Items: []models.RecentsResponseItem{
-			{
-				DeviceID: "device1",
-				UTCTime:  1701200000,
-				ID:       "1",
-				ContentItem: &models.ContentItem{
-					Source:       "SPOTIFY",
-					Type:         "track",
-					ItemName:     "Test Song",
-					IsPresetable: true,
-				},
-			},
-			{
-				DeviceID: "device1",
-				UTCTime:  1701100000,
-				ID:       "2",
-				ContentItem: &models.ContentItem{
-					Source:   "LOCAL_MUSIC",
-					Type:     "track",
-					ItemName: "Local Song",
-				},
-			},
-		},
-	}
-
 	tests := []struct {
 		name           string
 		args           []string
@@ -182,9 +155,11 @@ func TestPrintRecentItem(t *testing.T) {
 
 			// 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)

cmd/soundtouch-cli/cmd_source.go

@@ -238,6 +238,7 @@ func selectLocalInternetRadio(c *cli.Context) error {
 	if itemName != "" {
 		fmt.Printf("  Station: %s\n", itemName)
 	}
+
 	fmt.Printf("  Location: %s\n", location)
 
 	err = client.SelectLocalInternetRadio(location, sourceAccount, itemName, containerArt)
@@ -283,6 +284,7 @@ func selectLocalMusic(c *cli.Context) error {
 	if itemName != "" {
 		fmt.Printf("  Content: %s\n", itemName)
 	}
+
 	fmt.Printf("  Location: %s\n", location)
 	fmt.Printf("  Account: %s\n", sourceAccount)
 
@@ -329,6 +331,7 @@ func selectStoredMusic(c *cli.Context) error {
 	if itemName != "" {
 		fmt.Printf("  Content: %s\n", itemName)
 	}
+
 	fmt.Printf("  Location: %s\n", location)
 	fmt.Printf("  Account: %s\n", sourceAccount)
 
@@ -401,12 +404,15 @@ func selectContent(c *cli.Context) error {
 
 	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)
 	}

cmd/soundtouch-cli/main.go

@@ -1720,6 +1720,285 @@ func main() {
 					},
 				},
 			},
+			// Account management commands
+			{
+				Name:    "account",
+				Aliases: []string{"acc"},
+				Usage:   "Music service account management commands",
+				Subcommands: []*cli.Command{
+					{
+						Name:   "list",
+						Usage:  "List configured music service accounts",
+						Action: listMusicServiceAccounts,
+						Before: RequireHost,
+					},
+					{
+						Name:   "add",
+						Usage:  "Add a music service account",
+						Action: addMusicServiceAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "source",
+								Aliases:  []string{"s"},
+								Usage:    "Music service source (SPOTIFY, PANDORA, AMAZON, DEEZER, IHEART, STORED_MUSIC)",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Username or account identifier",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:    "password",
+								Aliases: []string{"p"},
+								Usage:   "Account password (not required for STORED_MUSIC)",
+							},
+							&cli.StringFlag{
+								Name:    "name",
+								Aliases: []string{"n"},
+								Usage:   "Display name for the service",
+							},
+						},
+					},
+					{
+						Name:   "remove",
+						Usage:  "Remove a music service account",
+						Action: removeMusicServiceAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "source",
+								Aliases:  []string{"s"},
+								Usage:    "Music service source (SPOTIFY, PANDORA, AMAZON, DEEZER, IHEART, STORED_MUSIC)",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Username or account identifier",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:    "name",
+								Aliases: []string{"n"},
+								Usage:   "Display name for the service",
+							},
+						},
+					},
+					{
+						Name:   "add-spotify",
+						Usage:  "Add a Spotify Premium account",
+						Action: addSpotifyAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Spotify username/email",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "password",
+								Aliases:  []string{"p"},
+								Usage:    "Spotify password",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "remove-spotify",
+						Usage:  "Remove a Spotify account",
+						Action: removeSpotifyAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Spotify username/email to remove",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "add-pandora",
+						Usage:  "Add a Pandora account",
+						Action: addPandoraAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Pandora username",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "password",
+								Aliases:  []string{"p"},
+								Usage:    "Pandora password",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "remove-pandora",
+						Usage:  "Remove a Pandora account",
+						Action: removePandoraAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Pandora username to remove",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "add-nas",
+						Usage:  "Add a network music library (NAS/UPnP)",
+						Action: addStoredMusicAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "UPnP server GUID with /0 suffix (e.g., d09708a1-5953-44bc-a413-123456789012/0)",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:    "name",
+								Aliases: []string{"n"},
+								Usage:   "Display name for the music library",
+								Value:   "Network Music Library",
+							},
+						},
+					},
+					{
+						Name:   "remove-nas",
+						Usage:  "Remove a network music library",
+						Action: removeStoredMusicAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "UPnP server GUID with /0 suffix to remove",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:    "name",
+								Aliases: []string{"n"},
+								Usage:   "Display name for the music library",
+								Value:   "Network Music Library",
+							},
+						},
+					},
+					{
+						Name:   "add-amazon",
+						Usage:  "Add an Amazon Music account",
+						Action: addAmazonMusicAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Amazon Music username",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "password",
+								Aliases:  []string{"p"},
+								Usage:    "Amazon Music password",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "remove-amazon",
+						Usage:  "Remove an Amazon Music account",
+						Action: removeAmazonMusicAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Amazon Music username to remove",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "add-deezer",
+						Usage:  "Add a Deezer Premium account",
+						Action: addDeezerAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Deezer username",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "password",
+								Aliases:  []string{"p"},
+								Usage:    "Deezer password",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "remove-deezer",
+						Usage:  "Remove a Deezer account",
+						Action: removeDeezerAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "Deezer username to remove",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "add-iheart",
+						Usage:  "Add an iHeartRadio account",
+						Action: addIHeartRadioAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "iHeartRadio username",
+								Required: true,
+							},
+							&cli.StringFlag{
+								Name:     "password",
+								Aliases:  []string{"p"},
+								Usage:    "iHeartRadio password",
+								Required: true,
+							},
+						},
+					},
+					{
+						Name:   "remove-iheart",
+						Usage:  "Remove an iHeartRadio account",
+						Action: removeIHeartRadioAccount,
+						Before: RequireHost,
+						Flags: []cli.Flag{
+							&cli.StringFlag{
+								Name:     "user",
+								Aliases:  []string{"u"},
+								Usage:    "iHeartRadio username to remove",
+								Required: true,
+							},
+						},
+					},
+				},
+			},
 			// Token commands
 			{
 				Name:    "token",

docs/CLI-REFERENCE.md

@@ -548,6 +548,96 @@ soundtouch-cli --host 192.168.1.10 source introspect-all
 soundtouch-cli --host 192.168.1.10 source availability
 ```
 
+### Music Service Account Management
+
+Manage music streaming service accounts and network music library connections.
+
+#### `account <subcommand>`
+
+Music service account management commands.
+
+```bash
+# List configured accounts
+soundtouch-cli --host <device> account list
+
+# Add music service account (generic)
+soundtouch-cli --host <device> account add --source <SOURCE> --user <USER> --password <PASS> [--name <NAME>]
+
+# Remove music service account (generic)
+soundtouch-cli --host <device> account remove --source <SOURCE> --user <USER> [--name <NAME>]
+
+# Service-specific convenience commands
+soundtouch-cli --host <device> account add-spotify --user <EMAIL> --password <PASS>
+soundtouch-cli --host <device> account add-pandora --user <USER> --password <PASS>
+soundtouch-cli --host <device> account add-amazon --user <USER> --password <PASS>
+soundtouch-cli --host <device> account add-deezer --user <USER> --password <PASS>
+soundtouch-cli --host <device> account add-iheart --user <USER> --password <PASS>
+soundtouch-cli --host <device> account add-nas --user <GUID/0> [--name <NAME>]
+
+# Remove accounts
+soundtouch-cli --host <device> account remove-spotify --user <EMAIL>
+soundtouch-cli --host <device> account remove-pandora --user <USER>
+soundtouch-cli --host <device> account remove-amazon --user <USER>
+soundtouch-cli --host <device> account remove-deezer --user <USER>
+soundtouch-cli --host <device> account remove-iheart --user <USER>
+soundtouch-cli --host <device> account remove-nas --user <GUID/0> [--name <NAME>]
+```
+
+**Supported Services:**
+- **SPOTIFY**: Spotify Premium accounts
+- **PANDORA**: Pandora Music Service accounts
+- **AMAZON**: Amazon Music accounts
+- **DEEZER**: Deezer Premium accounts
+- **IHEART**: iHeartRadio accounts
+- **STORED_MUSIC**: Network music libraries (NAS/UPnP/DLNA servers)
+
+**Examples:**
+```bash
+# List all configured music service accounts
+soundtouch-cli --host 192.168.1.10 account list
+
+# Add a Spotify Premium account
+soundtouch-cli --host 192.168.1.10 account add-spotify \
+  --user "user@spotify.com" \
+  --password "mypassword"
+
+# Add a Pandora account
+soundtouch-cli --host 192.168.1.10 account add-pandora \
+  --user "pandora_username" \
+  --password "pandora_password"
+
+# Add an Amazon Music account
+soundtouch-cli --host 192.168.1.10 account add-amazon \
+  --user "amazon_user" \
+  --password "amazon_password"
+
+# Add a network music library (NAS/UPnP)
+soundtouch-cli --host 192.168.1.10 account add-nas \
+  --user "d09708a1-5953-44bc-a413-123456789012/0" \
+  --name "My Music Server"
+
+# Remove a Spotify account
+soundtouch-cli --host 192.168.1.10 account remove-spotify \
+  --user "user@spotify.com"
+
+# Generic account management
+soundtouch-cli --host 192.168.1.10 account add \
+  --source DEEZER \
+  --user "deezer_user" \
+  --password "deezer_pass" \
+  --name "Deezer Premium"
+
+soundtouch-cli --host 192.168.1.10 account remove \
+  --source DEEZER \
+  --user "deezer_user"
+```
+
+**Notes:**
+- Music service accounts must be configured before you can browse or play content from those services
+- Network music libraries (STORED_MUSIC) don't require passwords, only the UPnP server GUID
+- After adding an account, use `source list` to verify it appears as available
+- Some services may require additional authentication steps through their mobile apps
+
 ### Bass Control
 
 Adjust bass levels (equalizer).

examples/account-management/README.md

@@ -0,0 +1,152 @@
+# Music Service Account Management Example
+
+This example demonstrates how to manage music streaming service accounts and network music library connections on Bose SoundTouch devices.
+
+## Overview
+
+The SoundTouch device can store credentials for various music streaming services and network music libraries. This allows you to:
+
+- Add streaming service accounts (Spotify, Pandora, Amazon Music, Deezer, iHeartRadio)
+- Configure network music libraries (NAS/UPnP/DLNA servers)
+- Remove accounts when no longer needed
+- List currently configured accounts
+
+## Running the Example
+
+1. Update the device IP address in `main.go`:
+   ```go
+   config := &client.Config{
+       Host:    "192.168.1.100", // Replace with your device IP
+       Port:    8090,
+       Timeout: 10 * time.Second,
+   }
+   ```
+
+2. Run the example:
+   ```bash
+   go run main.go
+   ```
+
+## Supported Music Services
+
+### Streaming Services (require username/password)
+- **Spotify Premium**: Personal Spotify accounts
+- **Pandora**: Pandora Music Service accounts  
+- **Amazon Music**: Amazon Music accounts
+- **Deezer Premium**: Deezer subscription accounts
+- **iHeartRadio**: iHeartRadio accounts
+
+### Network Music Libraries (no password required)
+- **STORED_MUSIC**: NAS, UPnP, and DLNA media servers
+- **LOCAL_MUSIC**: Local music servers
+
+## Key Features Demonstrated
+
+### 1. Adding Accounts
+
+```go
+// Convenience methods for popular services
+err := client.AddSpotifyAccount("user@spotify.com", "password")
+err := client.AddPandoraAccount("username", "password")
+err := client.AddAmazonMusicAccount("username", "password")
+
+// Generic method for any service
+credentials := models.NewMusicServiceCredentials("TIDAL", "Tidal HiFi", "user", "pass")
+err := client.SetMusicServiceAccount(credentials)
+
+// Network music library (no password needed)
+err := client.AddStoredMusicAccount("server-guid/0", "My Music Server")
+```
+
+### 2. Removing Accounts
+
+```go
+// Convenience methods
+err := client.RemoveSpotifyAccount("user@spotify.com")
+err := client.RemovePandoraAccount("username")
+
+// Generic removal method
+credentials := models.NewSpotifyCredentials("user@spotify.com", "") // Empty password = removal
+err := client.RemoveMusicServiceAccount(credentials)
+```
+
+### 3. Validating Credentials
+
+```go
+credentials := models.NewSpotifyCredentials("user", "pass")
+if err := credentials.Validate(); err != nil {
+    log.Fatal("Invalid credentials:", err)
+}
+```
+
+### 4. Checking Account Status
+
+```go
+sources, err := client.GetSources()
+if err != nil {
+    log.Fatal(err)
+}
+
+// Look for sources with accounts configured
+for _, source := range sources.Sources {
+    if source.SourceAccount != "" {
+        fmt.Printf("Service: %s, Account: %s, Status: %s\n", 
+            source.Source, source.SourceAccount, source.Status)
+    }
+}
+```
+
+## CLI Usage Examples
+
+After setting up accounts programmatically, you can also manage them via the CLI:
+
+```bash
+# List configured accounts
+soundtouch-cli --host 192.168.1.10 account list
+
+# Add accounts via CLI
+soundtouch-cli --host 192.168.1.10 account add-spotify --user user@spotify.com --password mypass
+soundtouch-cli --host 192.168.1.10 account add-pandora --user pandora_user --password pandora_pass
+soundtouch-cli --host 192.168.1.10 account add-nas --user "guid/0" --name "My NAS"
+
+# Remove accounts
+soundtouch-cli --host 192.168.1.10 account remove-spotify --user user@spotify.com
+```
+
+## Network Music Libraries
+
+For STORED_MUSIC (NAS/UPnP) services:
+
+1. The `user` field should contain the UPnP server GUID followed by `/0`
+2. You can find the GUID by discovering UPnP devices on your network
+3. No password is required
+4. You can specify a custom display name for the library
+
+Example GUID format: `d09708a1-5953-44bc-a413-123456789012/0`
+
+## Error Handling
+
+The example includes comprehensive error handling for common scenarios:
+
+- Network connectivity issues
+- Invalid credentials
+- Missing required fields
+- Service-specific authentication failures
+
+## Security Notes
+
+- Credentials are sent securely to the SoundTouch device over your local network
+- The device stores encrypted credentials internally
+- Passwords are only required during the initial setup
+- Use the removal methods to completely delete stored credentials
+
+## Next Steps
+
+After configuring accounts:
+
+1. Use `source list` to verify services are available
+2. Use `source select` to choose a music service
+3. Use `browse` commands to explore content
+4. Use `play` commands to start playback
+
+See the [CLI Reference](../../docs/CLI-REFERENCE.md) for complete documentation.

examples/account-management/main.go

@@ -0,0 +1,153 @@
+// Package main demonstrates music service account management functionality for Bose SoundTouch devices.
+package main
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+func main() {
+	// Configure the SoundTouch client
+	config := &client.Config{
+		Host:    "192.168.1.100", // Replace with your device IP
+		Port:    8090,
+		Timeout: 10 * time.Second,
+	}
+
+	// Create client
+	soundtouchClient := client.NewClient(config)
+
+	fmt.Printf("🎵 SoundTouch Music Service Account Management Example\n")
+	fmt.Printf("Device: %s:%d\n\n", config.Host, config.Port)
+
+	// Example 1: Add a Spotify account using convenience method
+	fmt.Println("📱 Adding Spotify Premium account...")
+
+	err := soundtouchClient.AddSpotifyAccount("user@spotify.com", "your_password")
+	if err != nil {
+		log.Printf("Failed to add Spotify account: %v", err)
+	} else {
+		fmt.Println("✅ Spotify account added successfully")
+	}
+
+	// Example 2: Add a Pandora account
+	fmt.Println("\n📻 Adding Pandora account...")
+
+	err = soundtouchClient.AddPandoraAccount("pandora_username", "pandora_password")
+	if err != nil {
+		log.Printf("Failed to add Pandora account: %v", err)
+	} else {
+		fmt.Println("✅ Pandora account added successfully")
+	}
+
+	// Example 3: Add Amazon Music account
+	fmt.Println("\n🛒 Adding Amazon Music account...")
+
+	err = soundtouchClient.AddAmazonMusicAccount("amazon_user", "amazon_password")
+	if err != nil {
+		log.Printf("Failed to add Amazon Music account: %v", err)
+	} else {
+		fmt.Println("✅ Amazon Music account added successfully")
+	}
+
+	// Example 4: Add a network music library (NAS/UPnP)
+	fmt.Println("\n🏠 Adding network music library...")
+
+	nasGUID := "d09708a1-5953-44bc-a413-123456789012/0" // Example UPnP server GUID
+
+	err = soundtouchClient.AddStoredMusicAccount(nasGUID, "My Home Music Server")
+	if err != nil {
+		log.Printf("Failed to add network music library: %v", err)
+	} else {
+		fmt.Println("✅ Network music library added successfully")
+	}
+
+	// Example 5: Add account using generic method with custom credentials
+	fmt.Println("\n🎧 Adding Deezer account using generic method...")
+
+	deezerCredentials := models.NewDeezerCredentials("deezer_user", "deezer_password")
+
+	err = soundtouchClient.SetMusicServiceAccount(deezerCredentials)
+	if err != nil {
+		log.Printf("Failed to add Deezer account: %v", err)
+	} else {
+		fmt.Println("✅ Deezer account added successfully")
+	}
+
+	// Example 6: Add a custom/unknown service
+	fmt.Println("\n🎶 Adding custom music service...")
+
+	customCredentials := models.NewMusicServiceCredentials("TIDAL", "Tidal HiFi", "tidal_user", "tidal_password")
+
+	err = soundtouchClient.SetMusicServiceAccount(customCredentials)
+	if err != nil {
+		log.Printf("Failed to add custom music service: %v", err)
+	} else {
+		fmt.Println("✅ Custom music service added successfully")
+	}
+
+	// Example 7: List current sources to see added accounts
+	fmt.Println("\n📋 Checking available sources...")
+
+	sources, err := soundtouchClient.GetSources()
+	if err != nil {
+		log.Printf("Failed to get sources: %v", err)
+	} else {
+		fmt.Printf("Available sources (%d total):\n", len(sources.SourceItem))
+
+		for _, source := range sources.SourceItem {
+			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)
+		}
+	}
+
+	// Example 8: Remove accounts
+	fmt.Println("\n🗑️  Removing accounts...")
+
+	// Remove Spotify account
+	err = soundtouchClient.RemoveSpotifyAccount("user@spotify.com")
+	if err != nil {
+		log.Printf("Failed to remove Spotify account: %v", err)
+	} else {
+		fmt.Println("✅ Spotify account removed successfully")
+	}
+
+	// Remove Deezer account using generic method
+	deezerRemovalCredentials := models.NewDeezerCredentials("deezer_user", "")
+
+	err = soundtouchClient.RemoveMusicServiceAccount(deezerRemovalCredentials)
+	if err != nil {
+		log.Printf("Failed to remove Deezer account: %v", err)
+	} else {
+		fmt.Println("✅ Deezer account removed successfully")
+	}
+
+	// Remove network music library
+	err = soundtouchClient.RemoveStoredMusicAccount(nasGUID, "My Home Music Server")
+	if err != nil {
+		log.Printf("Failed to remove network music library: %v", err)
+	} else {
+		fmt.Println("✅ Network music library removed successfully")
+	}
+
+	fmt.Println("\n🎉 Account management example completed!")
+	fmt.Println("\n💡 Tips:")
+	fmt.Println("   • Use 'account list' to see which services are configured")
+	fmt.Println("   • After adding accounts, use 'source list' to verify availability")
+	fmt.Println("   • Network libraries (NAS/UPnP) don't require passwords")
+	fmt.Println("   • Some services may need additional authentication via their mobile apps")
+	fmt.Println("   • Account credentials are stored securely on the SoundTouch device")
+}

examples/content-selection/main.go

@@ -1,3 +1,4 @@
+// Package main demonstrates content selection functionality for Bose SoundTouch devices.
 package main
 
 import (
@@ -41,35 +42,41 @@ func main() {
 func demonstrateContentSelection(c *client.Client) error {
 	// 1. Demonstrate LOCAL_INTERNET_RADIO with streamUrl format
 	fmt.Println("📻 Step 1: Demonstrating LOCAL_INTERNET_RADIO with streamUrl format...")
+
 	if err := demoLocalInternetRadioStreamUrl(c); err != nil {
 		return fmt.Errorf("failed LOCAL_INTERNET_RADIO demo: %w", err)
 	}
 
 	// Wait and show what's playing
 	time.Sleep(3 * time.Second)
+
 	if err := showNowPlaying(c); err != nil {
 		fmt.Printf("⚠️  Could not get now playing: %v\n", err)
 	}
 
 	// 2. Demonstrate LOCAL_INTERNET_RADIO with direct stream
 	fmt.Println("\n📻 Step 2: Demonstrating LOCAL_INTERNET_RADIO with direct stream...")
+
 	if err := demoLocalInternetRadioDirect(c); err != nil {
 		return fmt.Errorf("failed direct stream demo: %w", err)
 	}
 
 	// Wait and show what's playing
 	time.Sleep(3 * time.Second)
+
 	if err := showNowPlaying(c); err != nil {
 		fmt.Printf("⚠️  Could not get now playing: %v\n", err)
 	}
 
 	// 3. Demonstrate LOCAL_MUSIC selection
 	fmt.Println("\n💿 Step 3: Demonstrating LOCAL_MUSIC selection...")
+
 	if err := demoLocalMusic(c); err != nil {
 		fmt.Printf("⚠️  LOCAL_MUSIC demo failed (this requires SoundTouch App Media Server): %v\n", err)
 	} else {
 		// Wait and show what's playing
 		time.Sleep(3 * time.Second)
+
 		if err := showNowPlaying(c); err != nil {
 			fmt.Printf("⚠️  Could not get now playing: %v\n", err)
 		}
@@ -77,11 +84,13 @@ func demonstrateContentSelection(c *client.Client) error {
 
 	// 4. Demonstrate STORED_MUSIC selection
 	fmt.Println("\n💾 Step 4: Demonstrating STORED_MUSIC selection...")
+
 	if err := demoStoredMusic(c); err != nil {
 		fmt.Printf("⚠️  STORED_MUSIC demo failed (this requires UPnP/DLNA media server): %v\n", err)
 	} else {
 		// Wait and show what's playing
 		time.Sleep(3 * time.Second)
+
 		if err := showNowPlaying(c); err != nil {
 			fmt.Printf("⚠️  Could not get now playing: %v\n", err)
 		}
@@ -89,12 +98,14 @@ func demonstrateContentSelection(c *client.Client) error {
 
 	// 5. Demonstrate generic ContentItem selection
 	fmt.Println("\n🎯 Step 5: Demonstrating generic ContentItem selection...")
+
 	if err := demoGenericContentItem(c); err != nil {
 		return fmt.Errorf("failed generic ContentItem demo: %w", err)
 	}
 
 	// Wait and show what's playing
 	time.Sleep(3 * time.Second)
+
 	if err := showNowPlaying(c); err != nil {
 		fmt.Printf("⚠️  Could not get now playing: %v\n", err)
 	}
@@ -120,6 +131,7 @@ func demoLocalInternetRadioStreamUrl(c *client.Client) error {
 	}
 
 	fmt.Printf("  ✅ Successfully selected internet radio with streamUrl format\n")
+
 	return nil
 }
 
@@ -139,6 +151,7 @@ func demoLocalInternetRadioDirect(c *client.Client) error {
 	}
 
 	fmt.Printf("  ✅ Successfully selected direct internet radio stream\n")
+
 	return nil
 }
 
@@ -162,6 +175,7 @@ func demoLocalMusic(c *client.Client) error {
 	}
 
 	fmt.Printf("  ✅ Successfully selected local music content\n")
+
 	return nil
 }
 
@@ -184,6 +198,7 @@ func demoStoredMusic(c *client.Client) error {
 	}
 
 	fmt.Printf("  ✅ Successfully selected stored music content\n")
+
 	return nil
 }
 
@@ -211,6 +226,7 @@ func demoGenericContentItem(c *client.Client) error {
 	}
 
 	fmt.Printf("  ✅ Successfully selected content using ContentItem\n")
+
 	return nil
 }
 

examples/introspect/main.go

@@ -1,3 +1,4 @@
+// Package main demonstrates introspect functionality for Bose SoundTouch devices.
 package main
 
 import (
@@ -7,43 +8,12 @@ import (
 	"time"
 
 	"github.com/gesellix/bose-soundtouch/pkg/client"
+	"github.com/gesellix/bose-soundtouch/pkg/models"
 )
 
-func main() {
-	var (
-		host          = flag.String("host", "", "SoundTouch device IP address")
-		source        = flag.String("source", "SPOTIFY", "Music service source (SPOTIFY, PANDORA, TUNEIN)")
-		sourceAccount = flag.String("account", "", "Source account name (optional)")
-		timeout       = flag.Duration("timeout", 10*time.Second, "Request timeout")
-	)
-	flag.Parse()
-
-	if *host == "" {
-		log.Fatal("Please provide a SoundTouch device IP address with -host flag")
-	}
-
-	// Create client
-	config := &client.Config{
-		Host:    *host,
-		Port:    8090,
-		Timeout: *timeout,
-	}
-	soundTouchClient := client.NewClient(config)
-
-	fmt.Printf("Getting introspect data for %s", *source)
-	if *sourceAccount != "" {
-		fmt.Printf(" (account: %s)", *sourceAccount)
-	}
-	fmt.Println()
-
-	// Get introspect data
-	response, err := soundTouchClient.Introspect(*source, *sourceAccount)
-	if err != nil {
-		log.Fatalf("Failed to get introspect data: %v", err)
-	}
-
-	// Display basic information
-	fmt.Printf("\n=== %s Service Introspect Data ===\n", *source)
+// displayBasicInfo prints basic service information
+func displayBasicInfo(source string, response *models.IntrospectResponse) {
+	fmt.Printf("\n=== %s Service Introspect Data ===\n", source)
 	fmt.Printf("State: %s\n", response.State)
 
 	if response.HasUser() {
@@ -61,17 +31,23 @@ func main() {
 	if response.HasSubscription() {
 		fmt.Printf("Subscription Type: %s\n", response.SubscriptionType)
 	}
+}
 
-	// Display service state
+// displayServiceState prints service state information
+func displayServiceState(response *models.IntrospectResponse) {
 	fmt.Printf("\n=== Service State ===\n")
+
 	if response.IsActive() {
 		fmt.Println("✅ Service is ACTIVE")
 	} else if response.IsInactive() {
 		fmt.Println("❌ Service is INACTIVE")
 	}
+}
 
-	// Display capabilities
+// displayCapabilities prints service capabilities
+func displayCapabilities(response *models.IntrospectResponse) {
 	fmt.Printf("\n=== Service Capabilities ===\n")
+
 	if response.SupportsSkipPrevious() {
 		fmt.Println("✅ Skip Previous supported")
 	} else {
@@ -95,54 +71,109 @@ func main() {
 	} else {
 		fmt.Println("🚫 Data collection disabled")
 	}
+}
 
-	// Display history information
+// displayHistoryInfo prints content history information
+func displayHistoryInfo(response *models.IntrospectResponse) {
 	historySize := response.GetMaxHistorySize()
 	if historySize > 0 {
 		fmt.Printf("\n=== Content History ===\n")
 		fmt.Printf("Max History Size: %d items\n", historySize)
 	}
+}
 
-	// Display technical details
+// displayTechnicalDetails prints technical service details
+func displayTechnicalDetails(response *models.IntrospectResponse) {
 	if response.TokenLastChangedTimeSeconds > 0 {
 		fmt.Printf("\n=== Technical Details ===\n")
 		fmt.Printf("Token Last Changed: %d seconds\n", response.TokenLastChangedTimeSeconds)
+
 		if response.TokenLastChangedTimeMicroseconds > 0 {
 			fmt.Printf("Token Microseconds: %d\n", response.TokenLastChangedTimeMicroseconds)
 		}
+
 		fmt.Printf("Play Status State: %s\n", response.PlayStatusState)
 		fmt.Printf("Received Playback Request: %t\n", response.ReceivedPlaybackRequest)
 	}
+}
 
-	// Show service availability for comparison
+// displayServiceAvailability shows service availability for comparison
+func displayServiceAvailability(soundTouchClient *client.Client, source string) {
 	fmt.Printf("\n=== Service Availability Check ===\n")
+
 	availability, err := soundTouchClient.GetServiceAvailability()
 	if err != nil {
 		fmt.Printf("Could not check service availability: %v\n", err)
-	} else {
-		switch *source {
-		case "SPOTIFY":
-			if availability.HasSpotify() {
-				fmt.Println("✅ Spotify is available on this device")
-			} else {
-				fmt.Println("❌ Spotify is not available on this device")
-			}
-		case "PANDORA":
-			if availability.HasPandora() {
-				fmt.Println("✅ Pandora is available on this device")
-			} else {
-				fmt.Println("❌ Pandora is not available on this device")
-			}
-		case "TUNEIN":
-			if availability.HasTuneIn() {
-				fmt.Println("✅ TuneIn is available on this device")
-			} else {
-				fmt.Println("❌ TuneIn is not available on this device")
-			}
-		default:
-			fmt.Printf("Service availability check not implemented for %s\n", *source)
-		}
+		return
 	}
 
+	switch source {
+	case "SPOTIFY":
+		if availability.HasSpotify() {
+			fmt.Println("✅ Spotify is available on this device")
+		} else {
+			fmt.Println("❌ Spotify is not available on this device")
+		}
+	case "PANDORA":
+		if availability.HasPandora() {
+			fmt.Println("✅ Pandora is available on this device")
+		} else {
+			fmt.Println("❌ Pandora is not available on this device")
+		}
+	case "TUNEIN":
+		if availability.HasTuneIn() {
+			fmt.Println("✅ TuneIn is available on this device")
+		} else {
+			fmt.Println("❌ TuneIn is not available on this device")
+		}
+	default:
+		fmt.Printf("Service availability check not implemented for %s\n", source)
+	}
+}
+
+func main() {
+	var (
+		host          = flag.String("host", "", "SoundTouch device IP address")
+		source        = flag.String("source", "SPOTIFY", "Music service source (SPOTIFY, PANDORA, TUNEIN)")
+		sourceAccount = flag.String("account", "", "Source account name (optional)")
+		timeout       = flag.Duration("timeout", 10*time.Second, "Request timeout")
+	)
+
+	flag.Parse()
+
+	if *host == "" {
+		log.Fatal("Please provide a SoundTouch device IP address with -host flag")
+	}
+
+	// Create client
+	config := &client.Config{
+		Host:    *host,
+		Port:    8090,
+		Timeout: *timeout,
+	}
+	soundTouchClient := client.NewClient(config)
+
+	fmt.Printf("Getting introspect data for %s", *source)
+
+	if *sourceAccount != "" {
+		fmt.Printf(" (account: %s)", *sourceAccount)
+	}
+
+	fmt.Println()
+
+	// Get introspect data
+	response, err := soundTouchClient.Introspect(*source, *sourceAccount)
+	if err != nil {
+		log.Fatalf("Failed to get introspect data: %v", err)
+	}
+
+	// Display all information using helper functions
+	displayBasicInfo(*source, response)
+	displayServiceState(response)
+	displayCapabilities(response)
+	displayHistoryInfo(response)
+	displayTechnicalDetails(response)
+	displayServiceAvailability(soundTouchClient, *source)
+
 	fmt.Println("\nDone!")
 }

examples/recents/main.go

@@ -1,3 +1,4 @@
+// Package main demonstrates recent content functionality for Bose SoundTouch devices.
 package main
 
 import (
@@ -12,6 +13,73 @@ import (
 	"github.com/gesellix/bose-soundtouch/pkg/models"
 )
 
+// applyFilters applies source and type filters to the items
+func applyFilters(response *models.RecentsResponse, source, itemType string) ([]models.RecentsResponseItem, error) {
+	items := response.Items
+
+	// Apply source filter
+	if source != "" {
+		items = response.GetItemsBySource(strings.ToUpper(source))
+		if len(items) == 0 {
+			fmt.Printf("📭 No items found for source: %s\n", source)
+			fmt.Println("💡 Available sources:", getAvailableSources(response))
+
+			return nil, fmt.Errorf("no items found for source")
+		}
+	}
+
+	// Apply type filter
+	if itemType != "" {
+		filteredItems, err := filterItemsByType(items, itemType)
+		if err != nil {
+			return nil, err
+		}
+
+		items = filteredItems
+
+		if len(items) == 0 {
+			fmt.Printf("📭 No items found for type: %s\n", itemType)
+			return nil, fmt.Errorf("no items found for type")
+		}
+	}
+
+	return items, nil
+}
+
+// filterItemsByType filters items by content type
+func filterItemsByType(items []models.RecentsResponseItem, itemType string) ([]models.RecentsResponseItem, error) {
+	// Define type predicates
+	predicates := map[string]func(*models.RecentsResponseItem) bool{
+		"track":      (*models.RecentsResponseItem).IsTrack,
+		"tracks":     (*models.RecentsResponseItem).IsTrack,
+		"station":    (*models.RecentsResponseItem).IsStation,
+		"stations":   (*models.RecentsResponseItem).IsStation,
+		"playlist":   (*models.RecentsResponseItem).IsPlaylist,
+		"playlists":  (*models.RecentsResponseItem).IsPlaylist,
+		"album":      (*models.RecentsResponseItem).IsAlbum,
+		"albums":     (*models.RecentsResponseItem).IsAlbum,
+		"presetable": (*models.RecentsResponseItem).IsPresetable,
+	}
+
+	predicate, exists := predicates[strings.ToLower(itemType)]
+	if !exists {
+		fmt.Printf("❌ Unknown type filter: %s\n", itemType)
+		fmt.Println("💡 Available types: track, station, playlist, album, presetable")
+
+		return nil, fmt.Errorf("unknown type filter")
+	}
+
+	var filteredItems []models.RecentsResponseItem
+
+	for _, item := range items {
+		if predicate(&item) {
+			filteredItems = append(filteredItems, item)
+		}
+	}
+
+	return filteredItems, nil
+}
+
 func main() {
 	var (
 		host     = flag.String("host", "", "SoundTouch device IP address")
@@ -22,6 +90,7 @@ func main() {
 		itemType = flag.String("type", "", "Filter by type (track, station, playlist, presetable)")
 		stats    = flag.Bool("stats", false, "Show statistics only")
 	)
+
 	flag.Parse()
 
 	if *host == "" {
@@ -47,6 +116,7 @@ func main() {
 	if response.IsEmpty() {
 		fmt.Println("\n📭 No recent items found")
 		fmt.Println("💡 Play some content to populate the recent items list")
+
 		return
 	}
 
@@ -57,63 +127,9 @@ func main() {
 	}
 
 	// Apply filters
-	items := response.Items
-
-	if *source != "" {
-		items = response.GetItemsBySource(strings.ToUpper(*source))
-		if len(items) == 0 {
-			fmt.Printf("📭 No items found for source: %s\n", *source)
-			fmt.Println("💡 Available sources:", getAvailableSources(response))
-			return
-		}
-	}
-
-	// Apply type filter
-	if *itemType != "" {
-		var filteredItems []models.RecentsResponseItem
-		switch strings.ToLower(*itemType) {
-		case "track", "tracks":
-			for _, item := range items {
-				if item.IsTrack() {
-					filteredItems = append(filteredItems, item)
-				}
-			}
-		case "station", "stations":
-			for _, item := range items {
-				if item.IsStation() {
-					filteredItems = append(filteredItems, item)
-				}
-			}
-		case "playlist", "playlists":
-			for _, item := range items {
-				if item.IsPlaylist() {
-					filteredItems = append(filteredItems, item)
-				}
-			}
-		case "album", "albums":
-			for _, item := range items {
-				if item.IsAlbum() {
-					filteredItems = append(filteredItems, item)
-				}
-			}
-		case "presetable":
-			for _, item := range items {
-				if item.IsPresetable() {
-					filteredItems = append(filteredItems, item)
-				}
-			}
-		default:
-			fmt.Printf("❌ Unknown type filter: %s\n", *itemType)
-			fmt.Println("💡 Available types: track, station, playlist, album, presetable")
-			return
-		}
-
-		items = filteredItems
-
-		if len(items) == 0 {
-			fmt.Printf("📭 No items found for type: %s\n", *itemType)
-			return
-		}
+	items, err := applyFilters(response, *source, *itemType)
+	if err != nil {
+		return
 	}
 
 	// Apply limit
@@ -123,12 +139,18 @@ func main() {
 
 	// Display results
 	displayResults(response, items, *detailed, *source, *itemType)
+
+	fmt.Println("\nDone!")
 }
 
-func showStatistics(response *models.RecentsResponse) {
-	fmt.Printf("\n📊 Recent Items Statistics\n\n")
+// sourceCount represents a count for a named category
+type sourceCount struct {
+	name  string
+	count int
+}
 
-	// Basic stats
+// printBasicStatistics prints overall statistics
+func printBasicStatistics(response *models.RecentsResponse) {
 	fmt.Printf("Overall Statistics:\n")
 	fmt.Printf("  Total Items: %d\n", response.GetItemCount())
 
@@ -139,9 +161,12 @@ func showStatistics(response *models.RecentsResponse) {
 			fmt.Printf("  Last Played: %s\n", lastPlayTime.Format("2006-01-02 15:04:05"))
 		}
 	}
+}
 
-	// Source breakdown
+// printSourceStatistics prints statistics by source
+func printSourceStatistics(response *models.RecentsResponse) {
 	fmt.Printf("\n📍 By Source:\n")
+
 	sourceStats := map[string]int{
 		"Spotify":      len(response.GetSpotifyItems()),
 		"Pandora":      len(response.GetPandoraItems()),
@@ -150,17 +175,14 @@ func showStatistics(response *models.RecentsResponse) {
 		"Stored Music": len(response.GetStoredMusicItems()),
 	}
 
-	// Sort sources by count
-	type sourceCount struct {
-		name  string
-		count int
-	}
 	var sources []sourceCount
+
 	for name, count := range sourceStats {
 		if count > 0 {
 			sources = append(sources, sourceCount{name, count})
 		}
 	}
+
 	sort.Slice(sources, func(i, j int) bool {
 		return sources[i].count > sources[j].count
 	})
@@ -169,9 +191,12 @@ func showStatistics(response *models.RecentsResponse) {
 		percentage := float64(sc.count) / float64(response.GetItemCount()) * 100
 		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", sc.name+":", sc.count, percentage)
 	}
+}
 
-	// Content type breakdown
+// printContentTypeStatistics prints statistics by content type
+func printContentTypeStatistics(response *models.RecentsResponse) {
 	fmt.Printf("\n🎼 By Content Type:\n")
+
 	tracks := len(response.GetTracks())
 	stations := len(response.GetStations())
 	playlists := len(response.GetPlaylistsAndAlbums())
@@ -188,18 +213,24 @@ func showStatistics(response *models.RecentsResponse) {
 			fmt.Printf("  %-15s %3d items (%5.1f%%)\n", ts.name+":", ts.count, percentage)
 		}
 	}
+}
 
-	// Special categories
+// printSpecialCategoryStatistics prints special category statistics
+func printSpecialCategoryStatistics(response *models.RecentsResponse) {
 	presetable := len(response.GetPresetableItems())
 	if presetable > 0 {
 		fmt.Printf("\n⭐ Special Categories:\n")
+
 		percentage := float64(presetable) / float64(response.GetItemCount()) * 100
 		fmt.Printf("  %-15s %3d items (%5.1f%%)\n", "Presetable:", presetable, percentage)
 	}
+}
 
-	// Content source analysis
+// printSourceAnalysis prints streaming vs local content analysis
+func printSourceAnalysis(response *models.RecentsResponse) {
 	streamingCount := 0
 	localCount := 0
+
 	for _, item := range response.Items {
 		if item.IsStreamingContent() {
 			streamingCount++
@@ -210,18 +241,23 @@ func showStatistics(response *models.RecentsResponse) {
 
 	if streamingCount > 0 || localCount > 0 {
 		fmt.Printf("\n📡 Source 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)
 		}
 	}
+}
 
-	// Time analysis - show when items were played
+// printTimeAnalysis prints when items were played
+func printTimeAnalysis(response *models.RecentsResponse) {
 	fmt.Printf("\n🕐 Time Analysis:\n")
+
 	now := time.Now()
 	today := 0
 	yesterday := 0
@@ -233,13 +269,14 @@ func showStatistics(response *models.RecentsResponse) {
 			playTime := time.Unix(item.GetUTCTime(), 0)
 			diff := now.Sub(playTime)
 
-			if diff < 24*time.Hour {
+			switch {
+			case diff < 24*time.Hour:
 				today++
-			} else if diff < 48*time.Hour {
+			case diff < 48*time.Hour:
 				yesterday++
-			} else if diff < 7*24*time.Hour {
+			case diff < 7*24*time.Hour:
 				thisWeek++
-			} else {
+			default:
 				older++
 			}
 		}
@@ -248,23 +285,38 @@ func showStatistics(response *models.RecentsResponse) {
 	if today > 0 {
 		fmt.Printf("  %-15s %3d items\n", "Today:", today)
 	}
+
 	if yesterday > 0 {
 		fmt.Printf("  %-15s %3d items\n", "Yesterday:", yesterday)
 	}
+
 	if thisWeek > 0 {
 		fmt.Printf("  %-15s %3d items\n", "This Week:", thisWeek)
 	}
+
 	if older > 0 {
 		fmt.Printf("  %-15s %3d items\n", "Older:", older)
 	}
 }
 
+func showStatistics(response *models.RecentsResponse) {
+	fmt.Printf("\n📊 Recent Items Statistics\n\n")
+
+	printBasicStatistics(response)
+	printSourceStatistics(response)
+	printContentTypeStatistics(response)
+	printSpecialCategoryStatistics(response)
+	printSourceAnalysis(response)
+	printTimeAnalysis(response)
+}
+
 func displayResults(response *models.RecentsResponse, items []models.RecentsResponseItem, detailed bool, sourceFilter, typeFilter string) {
 	// Build filter description
 	var filters []string
 	if sourceFilter != "" {
 		filters = append(filters, fmt.Sprintf("source: %s", sourceFilter))
 	}
+
 	if typeFilter != "" {
 		filters = append(filters, fmt.Sprintf("type: %s", typeFilter))
 	}
@@ -277,9 +329,11 @@ func displayResults(response *models.RecentsResponse, items []models.RecentsResp
 	// Display header
 	fmt.Printf("\n📊 Recent Items Summary%s:\n", filterDesc)
 	fmt.Printf("   Showing: %d items", len(items))
+
 	if len(items) < response.GetItemCount() {
 		fmt.Printf(" (of %d total)", response.GetItemCount())
 	}
+
 	fmt.Println()
 
 	if len(filters) == 0 {
@@ -329,8 +383,9 @@ func displayItem(index int, item *models.RecentsResponseItem, detailed bool) {
 	fmt.Printf("   Source: %s", source)
 
 	if contentType != "" {
-		fmt.Printf(" | Type: %s", strings.Title(contentType))
+		fmt.Printf(" | Type: %s", contentType)
 	}
+
 	fmt.Println()
 
 	// Time information
@@ -370,9 +425,11 @@ func displayItem(index int, item *models.RecentsResponseItem, detailed bool) {
 		if item.IsStreamingContent() {
 			classifications = append(classifications, "Streaming")
 		}
+
 		if item.IsLocalContent() {
 			classifications = append(classifications, "Local")
 		}
+
 		if len(classifications) > 0 {
 			fmt.Printf("   🏷️  Type: %s\n", strings.Join(classifications, ", "))
 		}
@@ -382,18 +439,20 @@ func displayItem(index int, item *models.RecentsResponseItem, detailed bool) {
 }
 
 func getIcon(item *models.RecentsResponseItem) string {
-	if item.IsTrack() {
+	switch {
+	case item.IsTrack():
 		return "🎵"
-	} else if item.IsStation() {
+	case item.IsStation():
 		return "📻"
-	} else if item.IsPlaylist() {
+	case item.IsPlaylist():
 		return "📋"
-	} else if item.IsAlbum() {
+	case item.IsAlbum():
 		return "💿"
-	} else if item.IsContainer() {
+	case item.IsContainer():
 		return "📁"
+	default:
+		return "🎶"
 	}
-	return "🎼"
 }
 
 func formatSource(source string) string {
@@ -426,15 +485,16 @@ func formatSource(source string) string {
 }
 
 func formatDuration(d time.Duration) string {
-	if d < time.Minute {
-		return "just now"
-	} else if d < time.Hour {
+	switch {
+	case d < time.Minute:
+		return "< 1 minute"
+	case d < time.Hour:
 		minutes := int(d.Minutes())
 		return fmt.Sprintf("%d minute%s", minutes, pluralize(minutes))
-	} else if d < 24*time.Hour {
+	case d < 24*time.Hour:
 		hours := int(d.Hours())
 		return fmt.Sprintf("%d hour%s", hours, pluralize(hours))
-	} else {
+	default:
 		days := int(d.Hours() / 24)
 		return fmt.Sprintf("%d day%s", days, pluralize(days))
 	}
@@ -444,6 +504,7 @@ func pluralize(count int) string {
 	if count == 1 {
 		return ""
 	}
+
 	return "s"
 }
 
@@ -451,14 +512,17 @@ func truncateString(s string, maxLength int) string {
 	if len(s) <= maxLength {
 		return s
 	}
+
 	if maxLength <= 3 {
 		return "..."
 	}
+
 	return s[:maxLength-3] + "..."
 }
 
 func getAvailableSources(response *models.RecentsResponse) string {
 	sourceMap := make(map[string]bool)
+
 	for _, item := range response.Items {
 		if source := item.GetSource(); source != "" {
 			sourceMap[source] = true
@@ -469,6 +533,7 @@ func getAvailableSources(response *models.RecentsResponse) string {
 	for source := range sourceMap {
 		sources = append(sources, source)
 	}
+
 	sort.Strings(sources)
 
 	if len(sources) == 0 {

pkg/client/account_test.go

@@ -0,0 +1,718 @@
+package client
+
+import (
+	"encoding/xml"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gesellix/bose-soundtouch/pkg/models"
+)
+
+func TestClient_SetMusicServiceAccount(t *testing.T) {
+	tests := []struct {
+		name         string
+		credentials  *models.MusicServiceCredentials
+		serverStatus int
+		serverBody   string
+		wantError    bool
+		errorMessage string
+	}{
+		{
+			name:         "Valid Spotify credentials",
+			credentials:  models.NewSpotifyCredentials("user@spotify.com", "mypassword"),
+			serverStatus: http.StatusOK,
+			serverBody:   `<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`,
+			wantError:    false,
+		},
+		{
+			name:         "Valid Pandora credentials",
+			credentials:  models.NewPandoraCredentials("pandora_user", "pandora_pass"),
+			serverStatus: http.StatusOK,
+			serverBody:   `<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`,
+			wantError:    false,
+		},
+		{
+			name:         "Valid STORED_MUSIC credentials",
+			credentials:  models.NewStoredMusicCredentials("d09708a1-5953-44bc-a413-123456789012/0", "My NAS Library"),
+			serverStatus: http.StatusOK,
+			serverBody:   `<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`,
+			wantError:    false,
+		},
+		{
+			name:         "Nil credentials",
+			credentials:  nil,
+			wantError:    true,
+			errorMessage: "credentials cannot be nil",
+		},
+		{
+			name: "Invalid credentials - empty source",
+			credentials: &models.MusicServiceCredentials{
+				Source:      "",
+				DisplayName: "Test Service",
+				User:        "testuser",
+				Pass:        "testpass",
+			},
+			wantError:    true,
+			errorMessage: "invalid credentials: source cannot be empty",
+		},
+		{
+			name: "Invalid credentials - empty user",
+			credentials: &models.MusicServiceCredentials{
+				Source:      "SPOTIFY",
+				DisplayName: "Spotify",
+				User:        "",
+				Pass:        "testpass",
+			},
+			wantError:    true,
+			errorMessage: "invalid credentials: user cannot be empty",
+		},
+		{
+			name: "Invalid credentials - empty password for non-STORED_MUSIC",
+			credentials: &models.MusicServiceCredentials{
+				Source:      "SPOTIFY",
+				DisplayName: "Spotify",
+				User:        "testuser",
+				Pass:        "",
+			},
+			wantError:    true,
+			errorMessage: "invalid credentials: password cannot be empty for SPOTIFY",
+		},
+		{
+			name:         "Server error",
+			credentials:  models.NewSpotifyCredentials("user@spotify.com", "mypassword"),
+			serverStatus: http.StatusInternalServerError,
+			serverBody:   "Internal Server Error",
+			wantError:    true,
+			errorMessage: "failed to set music service account for SPOTIFY",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var receivedRequest *models.MusicServiceCredentials
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Path != "/setMusicServiceAccount" {
+					t.Errorf("Expected path /setMusicServiceAccount, got %s", r.URL.Path)
+				}
+
+				if r.Method != "POST" {
+					t.Errorf("Expected POST method, got %s", r.Method)
+				}
+
+				// Parse request body to verify credentials
+				if tt.credentials != nil {
+					var req models.MusicServiceCredentials
+					if err := xml.NewDecoder(r.Body).Decode(&req); err == nil {
+						receivedRequest = &req
+					}
+				}
+
+				w.WriteHeader(tt.serverStatus)
+
+				if tt.serverBody != "" {
+					_, _ = w.Write([]byte(tt.serverBody))
+				}
+			}))
+			defer server.Close()
+
+			config := &Config{
+				Host:    server.URL[7:],
+				Port:    80,
+				Timeout: testTimeout,
+			}
+			client := NewClient(config)
+			client.baseURL = server.URL
+
+			err := client.SetMusicServiceAccount(tt.credentials)
+
+			if tt.wantError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				} else if tt.errorMessage != "" && !strings.Contains(err.Error(), tt.errorMessage) {
+					t.Errorf("Expected error message to contain %q, got %q", tt.errorMessage, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				}
+
+				// Verify request was sent correctly
+				if receivedRequest != nil {
+					if receivedRequest.Source != tt.credentials.Source {
+						t.Errorf("Expected source %s, got %s", tt.credentials.Source, receivedRequest.Source)
+					}
+
+					if receivedRequest.User != tt.credentials.User {
+						t.Errorf("Expected user %s, got %s", tt.credentials.User, receivedRequest.User)
+					}
+
+					if receivedRequest.Pass != tt.credentials.Pass {
+						t.Errorf("Expected pass %s, got %s", tt.credentials.Pass, receivedRequest.Pass)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestClient_RemoveMusicServiceAccount(t *testing.T) {
+	tests := []struct {
+		name         string
+		credentials  *models.MusicServiceCredentials
+		serverStatus int
+		serverBody   string
+		wantError    bool
+		errorMessage string
+	}{
+		{
+			name:         "Valid Spotify removal",
+			credentials:  models.NewSpotifyCredentials("user@spotify.com", "mypassword"),
+			serverStatus: http.StatusOK,
+			serverBody:   `<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`,
+			wantError:    false,
+		},
+		{
+			name:         "Valid Pandora removal",
+			credentials:  models.NewPandoraCredentials("pandora_user", "pandora_pass"),
+			serverStatus: http.StatusOK,
+			serverBody:   `<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`,
+			wantError:    false,
+		},
+		{
+			name:         "Nil credentials",
+			credentials:  nil,
+			wantError:    true,
+			errorMessage: "credentials cannot be nil",
+		},
+		{
+			name: "Empty source",
+			credentials: &models.MusicServiceCredentials{
+				Source: "",
+				User:   "testuser",
+			},
+			wantError:    true,
+			errorMessage: "source cannot be empty",
+		},
+		{
+			name: "Empty user",
+			credentials: &models.MusicServiceCredentials{
+				Source: "SPOTIFY",
+				User:   "",
+			},
+			wantError:    true,
+			errorMessage: "user cannot be empty",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var receivedRequest *models.MusicServiceCredentials
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Path != "/removeMusicServiceAccount" {
+					t.Errorf("Expected path /removeMusicServiceAccount, got %s", r.URL.Path)
+				}
+
+				// Parse request body to verify credentials have empty password
+				if tt.credentials != nil {
+					var req models.MusicServiceCredentials
+					if err := xml.NewDecoder(r.Body).Decode(&req); err == nil {
+						receivedRequest = &req
+					}
+				}
+
+				w.WriteHeader(tt.serverStatus)
+
+				if tt.serverBody != "" {
+					_, _ = w.Write([]byte(tt.serverBody))
+				}
+			}))
+			defer server.Close()
+
+			config := &Config{
+				Host:    server.URL[7:],
+				Port:    80,
+				Timeout: testTimeout,
+			}
+			client := NewClient(config)
+			client.baseURL = server.URL
+
+			err := client.RemoveMusicServiceAccount(tt.credentials)
+
+			if tt.wantError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				} else if tt.errorMessage != "" && !strings.Contains(err.Error(), tt.errorMessage) {
+					t.Errorf("Expected error message to contain %q, got %q", tt.errorMessage, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				}
+
+				// Verify password was cleared for removal
+				if receivedRequest != nil && receivedRequest.Pass != "" {
+					t.Errorf("Expected empty password for removal, got %s", receivedRequest.Pass)
+				}
+			}
+		})
+	}
+}
+
+func TestClient_AddSpotifyAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/setMusicServiceAccount" {
+			t.Errorf("Expected path /setMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "SPOTIFY" {
+			t.Errorf("Expected source SPOTIFY, got %s", req.Source)
+		}
+
+		if req.User != "test@spotify.com" {
+			t.Errorf("Expected user test@spotify.com, got %s", req.User)
+		}
+
+		if req.Pass != "mypassword" {
+			t.Errorf("Expected password mypassword, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.AddSpotifyAccount("test@spotify.com", "mypassword")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_RemoveSpotifyAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/removeMusicServiceAccount" {
+			t.Errorf("Expected path /removeMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "SPOTIFY" {
+			t.Errorf("Expected source SPOTIFY, got %s", req.Source)
+		}
+
+		if req.User != "test@spotify.com" {
+			t.Errorf("Expected user test@spotify.com, got %s", req.User)
+		}
+
+		if req.Pass != "" {
+			t.Errorf("Expected empty password for removal, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.RemoveSpotifyAccount("test@spotify.com")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_AddStoredMusicAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "STORED_MUSIC" {
+			t.Errorf("Expected source STORED_MUSIC, got %s", req.Source)
+		}
+
+		if req.User != "d09708a1-5953-44bc-a413-123456789012/0" {
+			t.Errorf("Expected NAS user ID, got %s", req.User)
+		}
+
+		if req.DisplayName != "My NAS Library" {
+			t.Errorf("Expected display name 'My NAS Library', got %s", req.DisplayName)
+		}
+
+		// STORED_MUSIC should have empty password
+		if req.Pass != "" {
+			t.Errorf("Expected empty password for STORED_MUSIC, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.AddStoredMusicAccount("d09708a1-5953-44bc-a413-123456789012/0", "My NAS Library")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_AccountManagementErrors(t *testing.T) {
+	// Test network error
+	client := NewClient(&Config{
+		Host:    "non-existent-host.invalid",
+		Port:    8090,
+		Timeout: 1 * time.Second,
+	})
+
+	credentials := models.NewSpotifyCredentials("user@spotify.com", "password")
+
+	err := client.SetMusicServiceAccount(credentials)
+	if err == nil {
+		t.Error("Expected error for network error")
+	}
+
+	err = client.RemoveMusicServiceAccount(credentials)
+	if err == nil {
+		t.Error("Expected error for network error")
+	}
+}
+
+// Test convenience methods for all supported services
+func TestClient_AddAmazonMusicAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/setMusicServiceAccount" {
+			t.Errorf("Expected path /setMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "AMAZON" {
+			t.Errorf("Expected source AMAZON, got %s", req.Source)
+		}
+
+		if req.User != "test@amazon.com" {
+			t.Errorf("Expected user test@amazon.com, got %s", req.User)
+		}
+
+		if req.Pass != "mypassword" {
+			t.Errorf("Expected password mypassword, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.AddAmazonMusicAccount("test@amazon.com", "mypassword")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_RemoveAmazonMusicAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/removeMusicServiceAccount" {
+			t.Errorf("Expected path /removeMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "AMAZON" {
+			t.Errorf("Expected source AMAZON, got %s", req.Source)
+		}
+
+		if req.User != "test@amazon.com" {
+			t.Errorf("Expected user test@amazon.com, got %s", req.User)
+		}
+
+		if req.Pass != "" {
+			t.Errorf("Expected empty password for removal, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.RemoveAmazonMusicAccount("test@amazon.com")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_AddDeezerAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/setMusicServiceAccount" {
+			t.Errorf("Expected path /setMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "DEEZER" {
+			t.Errorf("Expected source DEEZER, got %s", req.Source)
+		}
+
+		if req.User != "deezer_user" {
+			t.Errorf("Expected user deezer_user, got %s", req.User)
+		}
+
+		if req.Pass != "deezer_pass" {
+			t.Errorf("Expected password deezer_pass, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.AddDeezerAccount("deezer_user", "deezer_pass")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_RemoveDeezerAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/removeMusicServiceAccount" {
+			t.Errorf("Expected path /removeMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "DEEZER" {
+			t.Errorf("Expected source DEEZER, got %s", req.Source)
+		}
+
+		if req.User != "deezer_user" {
+			t.Errorf("Expected user deezer_user, got %s", req.User)
+		}
+
+		if req.Pass != "" {
+			t.Errorf("Expected empty password for removal, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.RemoveDeezerAccount("deezer_user")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_AddIHeartRadioAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/setMusicServiceAccount" {
+			t.Errorf("Expected path /setMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "IHEART" {
+			t.Errorf("Expected source IHEART, got %s", req.Source)
+		}
+
+		if req.User != "iheart_user" {
+			t.Errorf("Expected user iheart_user, got %s", req.User)
+		}
+
+		if req.Pass != "iheart_pass" {
+			t.Errorf("Expected password iheart_pass, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/setMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.AddIHeartRadioAccount("iheart_user", "iheart_pass")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_RemoveIHeartRadioAccount(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/removeMusicServiceAccount" {
+			t.Errorf("Expected path /removeMusicServiceAccount, got %s", r.URL.Path)
+		}
+
+		var req models.MusicServiceCredentials
+		if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Errorf("Failed to decode request: %v", err)
+		}
+
+		if req.Source != "IHEART" {
+			t.Errorf("Expected source IHEART, got %s", req.Source)
+		}
+
+		if req.User != "iheart_user" {
+			t.Errorf("Expected user iheart_user, got %s", req.User)
+		}
+
+		if req.Pass != "" {
+			t.Errorf("Expected empty password for removal, got %s", req.Pass)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`<?xml version="1.0" encoding="UTF-8" ?><status>/removeMusicServiceAccount</status>`))
+	}))
+	defer server.Close()
+
+	config := &Config{
+		Host:    server.URL[7:],
+		Port:    80,
+		Timeout: testTimeout,
+	}
+	client := NewClient(config)
+	client.baseURL = server.URL
+
+	err := client.RemoveIHeartRadioAccount("iheart_user")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestClient_ConvenienceMethodsExist(_ *testing.T) {
+	client := NewClient(&Config{
+		Host:    "localhost",
+		Port:    8090,
+		Timeout: testTimeout,
+	})
+
+	// Test that convenience methods exist (compilation test)
+	var err error
+
+	// Spotify
+	err = client.AddSpotifyAccount("user", "pass")
+	_ = err // Expect network error, but method should exist
+
+	err = client.RemoveSpotifyAccount("user")
+	_ = err
+
+	// Pandora
+	err = client.AddPandoraAccount("user", "pass")
+	_ = err
+
+	err = client.RemovePandoraAccount("user")
+	_ = err
+
+	// Amazon Music
+	err = client.AddAmazonMusicAccount("user", "pass")
+	_ = err
+
+	err = client.RemoveAmazonMusicAccount("user")
+	_ = err
+
+	// Deezer
+	err = client.AddDeezerAccount("user", "pass")
+	_ = err
+
+	err = client.RemoveDeezerAccount("user")
+	_ = err
+
+	// iHeartRadio
+	err = client.AddIHeartRadioAccount("user", "pass")
+	_ = err
+
+	err = client.RemoveIHeartRadioAccount("user")
+	_ = err
+
+	// STORED_MUSIC
+	err = client.AddStoredMusicAccount("guid/0", "Display Name")
+	_ = err
+
+	err = client.RemoveStoredMusicAccount("guid/0", "Display Name")
+	_ = err
+}

pkg/client/client.go

@@ -1844,3 +1844,135 @@ func (c *Client) GetRecents() (*models.RecentsResponse, error) {
 func (c *Client) postPlayInfo(playInfo *models.PlayInfo) error {
 	return c.post("/speaker", playInfo)
 }
+
+// SetMusicServiceAccount adds or updates a music service account
+func (c *Client) SetMusicServiceAccount(credentials *models.MusicServiceCredentials) error {
+	if credentials == nil {
+		return fmt.Errorf("credentials cannot be nil")
+	}
+
+	if err := credentials.Validate(); err != nil {
+		return fmt.Errorf("invalid credentials: %w", err)
+	}
+
+	var response models.MusicServiceAccountResponse
+
+	err := c.postWithResponse("/setMusicServiceAccount", credentials, &response)
+	if err != nil {
+		return fmt.Errorf("failed to set music service account for %s: %w", credentials.Source, err)
+	}
+
+	if !response.IsSuccess() {
+		return fmt.Errorf("music service account operation failed: unexpected response %s", response.Status)
+	}
+
+	return nil
+}
+
+// RemoveMusicServiceAccount removes an existing music service account
+func (c *Client) RemoveMusicServiceAccount(credentials *models.MusicServiceCredentials) error {
+	if credentials == nil {
+		return fmt.Errorf("credentials cannot be nil")
+	}
+
+	if credentials.Source == "" {
+		return fmt.Errorf("source cannot be empty")
+	}
+
+	if credentials.User == "" {
+		return fmt.Errorf("user cannot be empty")
+	}
+
+	// For removal, ensure password is empty
+	removalCredentials := &models.MusicServiceCredentials{
+		Source:      credentials.Source,
+		DisplayName: credentials.DisplayName,
+		User:        credentials.User,
+		Pass:        "", // Empty password indicates removal
+	}
+
+	var response models.MusicServiceAccountResponse
+
+	err := c.postWithResponse("/removeMusicServiceAccount", removalCredentials, &response)
+	if err != nil {
+		return fmt.Errorf("failed to remove music service account for %s: %w", credentials.Source, err)
+	}
+
+	if !response.IsSuccess() {
+		return fmt.Errorf("music service account removal failed: unexpected response %s", response.Status)
+	}
+
+	return nil
+}
+
+// AddSpotifyAccount adds a Spotify Premium account
+func (c *Client) AddSpotifyAccount(user, password string) error {
+	credentials := models.NewSpotifyCredentials(user, password)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemoveSpotifyAccount removes a Spotify account
+func (c *Client) RemoveSpotifyAccount(user string) error {
+	credentials := models.NewSpotifyCredentials(user, "")
+	return c.RemoveMusicServiceAccount(credentials)
+}
+
+// AddPandoraAccount adds a Pandora account
+func (c *Client) AddPandoraAccount(user, password string) error {
+	credentials := models.NewPandoraCredentials(user, password)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemovePandoraAccount removes a Pandora account
+func (c *Client) RemovePandoraAccount(user string) error {
+	credentials := models.NewPandoraCredentials(user, "")
+	return c.RemoveMusicServiceAccount(credentials)
+}
+
+// AddStoredMusicAccount adds a STORED_MUSIC (NAS/UPnP) account
+func (c *Client) AddStoredMusicAccount(user, displayName string) error {
+	credentials := models.NewStoredMusicCredentials(user, displayName)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemoveStoredMusicAccount removes a STORED_MUSIC account
+func (c *Client) RemoveStoredMusicAccount(user, displayName string) error {
+	credentials := models.NewStoredMusicCredentials(user, displayName)
+	return c.RemoveMusicServiceAccount(credentials)
+}
+
+// AddAmazonMusicAccount adds an Amazon Music account
+func (c *Client) AddAmazonMusicAccount(user, password string) error {
+	credentials := models.NewAmazonMusicCredentials(user, password)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemoveAmazonMusicAccount removes an Amazon Music account
+func (c *Client) RemoveAmazonMusicAccount(user string) error {
+	credentials := models.NewAmazonMusicCredentials(user, "")
+	return c.RemoveMusicServiceAccount(credentials)
+}
+
+// AddDeezerAccount adds a Deezer Premium account
+func (c *Client) AddDeezerAccount(user, password string) error {
+	credentials := models.NewDeezerCredentials(user, password)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemoveDeezerAccount removes a Deezer account
+func (c *Client) RemoveDeezerAccount(user string) error {
+	credentials := models.NewDeezerCredentials(user, "")
+	return c.RemoveMusicServiceAccount(credentials)
+}
+
+// AddIHeartRadioAccount adds an iHeartRadio account
+func (c *Client) AddIHeartRadioAccount(user, password string) error {
+	credentials := models.NewIHeartRadioCredentials(user, password)
+	return c.SetMusicServiceAccount(credentials)
+}
+
+// RemoveIHeartRadioAccount removes an iHeartRadio account
+func (c *Client) RemoveIHeartRadioAccount(user string) error {
+	credentials := models.NewIHeartRadioCredentials(user, "")
+	return c.RemoveMusicServiceAccount(credentials)
+}

pkg/client/introspect_integration_test.go

@@ -62,9 +62,11 @@ func TestClient_Introspect_Integration(t *testing.T) {
 		if response.SupportsSkipPrevious() {
 			t.Log("Spotify supports skip previous")
 		}
+
 		if response.SupportsSeek() {
 			t.Log("Spotify supports seek")
 		}
+
 		if response.SupportsResume() {
 			t.Log("Spotify supports resume")
 		}
@@ -110,6 +112,7 @@ func TestClient_Introspect_Integration(t *testing.T) {
 		// Test Pandora if available
 		if serviceAvailability.HasPandora() {
 			t.Log("Testing Pandora introspect...")
+
 			response, err := client.Introspect("PANDORA", "")
 			if err != nil {
 				t.Logf("Pandora introspect failed (expected for some configurations): %v", err)
@@ -121,6 +124,7 @@ func TestClient_Introspect_Integration(t *testing.T) {
 		// Test TuneIn if available
 		if serviceAvailability.HasTuneIn() {
 			t.Log("Testing TuneIn introspect...")
+
 			response, err := client.Introspect("TUNEIN", "")
 			if err != nil {
 				t.Logf("TuneIn introspect failed (expected for some configurations): %v", err)
@@ -153,9 +157,11 @@ func TestClient_Introspect_ErrorCases_Integration(t *testing.T) {
 		if err == nil {
 			t.Error("expected error for invalid source, got nil")
 		}
+
 		if response != nil {
 			t.Error("expected nil response for invalid source, got non-nil")
 		}
+
 		t.Logf("Expected error for invalid source: %v", err)
 	})
 
@@ -165,6 +171,7 @@ func TestClient_Introspect_ErrorCases_Integration(t *testing.T) {
 		if err == nil {
 			t.Error("expected error for empty source, got nil")
 		}
+
 		if response != nil {
 			t.Error("expected nil response for empty source, got non-nil")
 		}
@@ -188,6 +195,7 @@ func ExampleClient_Introspect() {
 	// Check service state
 	if response.IsActive() {
 		println("Spotify service is active")
+
 		if response.IsPlaying {
 			println("Currently playing:", response.CurrentURI)
 		}
@@ -199,6 +207,7 @@ func ExampleClient_Introspect() {
 	if response.SupportsSeek() {
 		println("Seek is supported")
 	}
+
 	if response.SupportsSkipPrevious() {
 		println("Skip previous is supported")
 	}
@@ -222,6 +231,7 @@ func ExampleClient_IntrospectSpotify() {
 	if response.HasUser() {
 		println("Spotify user:", response.User)
 	}
+
 	if response.HasSubscription() {
 		println("Subscription type:", response.SubscriptionType)
 	}

pkg/client/introspect_test.go

@@ -100,6 +100,7 @@ func TestClient_Introspect(t *testing.T) {
 				if r.Method != "POST" {
 					t.Errorf("expected POST request, got %s", r.Method)
 				}
+
 				if r.URL.Path != "/introspect" {
 					t.Errorf("expected /introspect path, got %s", r.URL.Path)
 				}
@@ -113,6 +114,7 @@ func TestClient_Introspect(t *testing.T) {
 				if requestBody.Source != tt.source {
 					t.Errorf("expected source %s, got %s", tt.source, requestBody.Source)
 				}
+
 				if requestBody.SourceAccount != tt.sourceAccount {
 					t.Errorf("expected sourceAccount %s, got %s", tt.sourceAccount, requestBody.SourceAccount)
 				}
@@ -125,7 +127,7 @@ func TestClient_Introspect(t *testing.T) {
 
 				w.Header().Set("Content-Type", "application/xml")
 				w.WriteHeader(http.StatusOK)
-				w.Write([]byte(tt.responseXML))
+				_, _ = w.Write([]byte(tt.responseXML))
 			}))
 			defer server.Close()
 
@@ -144,9 +146,11 @@ func TestClient_Introspect(t *testing.T) {
 					t.Errorf("expected error containing %q, got nil", tt.expectedError)
 					return
 				}
+
 				if !containsString(err.Error(), tt.expectedError) {
 					t.Errorf("expected error containing %q, got %q", tt.expectedError, err.Error())
 				}
+
 				return
 			}
 
@@ -164,18 +168,23 @@ func TestClient_Introspect(t *testing.T) {
 			if response.State != tt.wantResponse.State {
 				t.Errorf("expected state %s, got %s", tt.wantResponse.State, response.State)
 			}
+
 			if response.User != tt.wantResponse.User {
 				t.Errorf("expected user %s, got %s", tt.wantResponse.User, response.User)
 			}
+
 			if response.IsPlaying != tt.wantResponse.IsPlaying {
 				t.Errorf("expected isPlaying %t, got %t", tt.wantResponse.IsPlaying, response.IsPlaying)
 			}
+
 			if response.ShuffleMode != tt.wantResponse.ShuffleMode {
 				t.Errorf("expected shuffleMode %s, got %s", tt.wantResponse.ShuffleMode, response.ShuffleMode)
 			}
+
 			if response.CurrentURI != tt.wantResponse.CurrentURI {
 				t.Errorf("expected currentUri %s, got %s", tt.wantResponse.CurrentURI, response.CurrentURI)
 			}
+
 			if response.SubscriptionType != tt.wantResponse.SubscriptionType {
 				t.Errorf("expected subscriptionType %s, got %s", tt.wantResponse.SubscriptionType, response.SubscriptionType)
 			}
@@ -190,16 +199,19 @@ func TestClient_Introspect(t *testing.T) {
 							tt.wantResponse.NowPlaying.SkipPreviousSupported,
 							response.NowPlaying.SkipPreviousSupported)
 					}
+
 					if response.NowPlaying.SeekSupported != tt.wantResponse.NowPlaying.SeekSupported {
 						t.Errorf("expected seekSupported %t, got %t",
 							tt.wantResponse.NowPlaying.SeekSupported,
 							response.NowPlaying.SeekSupported)
 					}
+
 					if response.NowPlaying.ResumeSupported != tt.wantResponse.NowPlaying.ResumeSupported {
 						t.Errorf("expected resumeSupported %t, got %t",
 							tt.wantResponse.NowPlaying.ResumeSupported,
 							response.NowPlaying.ResumeSupported)
 					}
+
 					if response.NowPlaying.CollectData != tt.wantResponse.NowPlaying.CollectData {
 						t.Errorf("expected collectData %t, got %t",
 							tt.wantResponse.NowPlaying.CollectData,
@@ -246,6 +258,7 @@ func TestIntrospectResponse_Methods(t *testing.T) {
 	if !response.IsActive() {
 		t.Error("expected IsActive() to return true")
 	}
+
 	if response.IsInactive() {
 		t.Error("expected IsInactive() to return false")
 	}
@@ -269,12 +282,15 @@ func TestIntrospectResponse_Methods(t *testing.T) {
 	if !response.SupportsSkipPrevious() {
 		t.Error("expected SupportsSkipPrevious() to return true")
 	}
+
 	if !response.SupportsSeek() {
 		t.Error("expected SupportsSeek() to return true")
 	}
+
 	if !response.SupportsResume() {
 		t.Error("expected SupportsResume() to return true")
 	}
+
 	if response.CollectsData() {
 		t.Error("expected CollectsData() to return false")
 	}
@@ -304,6 +320,7 @@ func TestIntrospectResponse_InactiveState(t *testing.T) {
 	if response.IsActive() {
 		t.Error("expected IsActive() to return false")
 	}
+
 	if !response.IsInactive() {
 		t.Error("expected IsInactive() to return true")
 	}
@@ -312,12 +329,15 @@ func TestIntrospectResponse_InactiveState(t *testing.T) {
 	if response.HasUser() {
 		t.Error("expected HasUser() to return false")
 	}
+
 	if response.IsShuffleEnabled() {
 		t.Error("expected IsShuffleEnabled() to return false")
 	}
+
 	if response.HasCurrentContent() {
 		t.Error("expected HasCurrentContent() to return false")
 	}
+
 	if response.HasSubscription() {
 		t.Error("expected HasSubscription() to return false")
 	}
@@ -353,6 +373,7 @@ func TestNewIntrospectRequest(t *testing.T) {
 			if request.Source != tt.source {
 				t.Errorf("expected source %s, got %s", tt.source, request.Source)
 			}
+
 			if request.SourceAccount != tt.sourceAccount {
 				t.Errorf("expected sourceAccount %s, got %s", tt.sourceAccount, request.SourceAccount)
 			}

pkg/client/recents_integration_test.go

@@ -85,6 +85,7 @@ func TestClient_GetRecents_Integration(t *testing.T) {
 		spotifyItems := response.GetSpotifyItems()
 		if len(spotifyItems) > 0 {
 			t.Logf("Spotify items: %d", len(spotifyItems))
+
 			for i, item := range spotifyItems {
 				if i < 3 { // Show first 3
 					t.Logf("  - %s", item.GetDisplayName())
@@ -135,6 +136,7 @@ func TestClient_GetRecents_Integration(t *testing.T) {
 
 		// Show all items with details
 		t.Log("\nAll recent items:")
+
 		for i, item := range response.Items {
 			if i >= 10 { // Limit to first 10 items to avoid spam
 				t.Logf("  ... and %d more items", len(response.Items)-i)
@@ -147,6 +149,7 @@ func TestClient_GetRecents_Integration(t *testing.T) {
 			utcTime := item.GetUTCTime()
 
 			timeStr := ""
+
 			if utcTime > 0 {
 				playTime := time.Unix(utcTime, 0)
 				timeStr = playTime.Format("2006-01-02 15:04:05")
@@ -214,9 +217,11 @@ func TestClient_GetRecents_ErrorConditions(t *testing.T) {
 		if err == nil {
 			t.Error("expected error for invalid host, got nil")
 		}
+
 		if response != nil {
 			t.Error("expected nil response for invalid host, got non-nil")
 		}
+
 		t.Logf("Expected error for invalid host: %v", err)
 	})
 
@@ -237,9 +242,11 @@ func TestClient_GetRecents_ErrorConditions(t *testing.T) {
 		if err == nil {
 			t.Log("Warning: expected timeout error, but request succeeded")
 		}
+
 		if response != nil && err != nil {
 			t.Error("got both response and error")
 		}
+
 		t.Logf("Timeout test result - error: %v, response nil: %t", err, response == nil)
 	})
 }
@@ -278,6 +285,7 @@ func ExampleClient_GetRecents() {
 	spotifyItems := response.GetSpotifyItems()
 	if len(spotifyItems) > 0 {
 		println("Recent Spotify tracks:")
+
 		for _, item := range spotifyItems {
 			println("-", item.GetDisplayName())
 		}
@@ -316,10 +324,12 @@ func ExampleRecentsResponse_filtering() {
 
 	// Get items from streaming services only
 	streamingItems := 0
+
 	for _, item := range response.Items {
 		if item.IsStreamingContent() {
 			streamingItems++
 		}
 	}
+
 	println("Streaming service items:", streamingItems)
 }

pkg/client/recents_test.go

@@ -172,6 +172,7 @@ func TestClient_GetRecents(t *testing.T) {
 				if r.Method != "GET" {
 					t.Errorf("expected GET request, got %s", r.Method)
 				}
+
 				if r.URL.Path != "/recents" {
 					t.Errorf("expected /recents path, got %s", r.URL.Path)
 				}
@@ -183,7 +184,7 @@ func TestClient_GetRecents(t *testing.T) {
 
 				w.Header().Set("Content-Type", "application/xml")
 				w.WriteHeader(http.StatusOK)
-				w.Write([]byte(tt.responseXML))
+				_, _ = w.Write([]byte(tt.responseXML))
 			}))
 			defer server.Close()
 
@@ -202,9 +203,11 @@ func TestClient_GetRecents(t *testing.T) {
 					t.Errorf("expected error containing %q, got nil", tt.expectedError)
 					return
 				}
+
 				if !containsString(err.Error(), tt.expectedError) {
 					t.Errorf("expected error containing %q, got %q", tt.expectedError, err.Error())
 				}
+
 				return
 			}
 
@@ -234,9 +237,11 @@ func TestClient_GetRecents(t *testing.T) {
 				if actualItem.DeviceID != expectedItem.DeviceID {
 					t.Errorf("item %d: expected deviceID %s, got %s", i, expectedItem.DeviceID, actualItem.DeviceID)
 				}
+
 				if actualItem.UTCTime != expectedItem.UTCTime {
 					t.Errorf("item %d: expected utcTime %d, got %d", i, expectedItem.UTCTime, actualItem.UTCTime)
 				}
+
 				if actualItem.ID != expectedItem.ID {
 					t.Errorf("item %d: expected id %s, got %s", i, expectedItem.ID, actualItem.ID)
 				}
@@ -251,18 +256,23 @@ func TestClient_GetRecents(t *testing.T) {
 					if actualItem.ContentItem.Source != expectedItem.ContentItem.Source {
 						t.Errorf("item %d: expected source %s, got %s", i, expectedItem.ContentItem.Source, actualItem.ContentItem.Source)
 					}
+
 					if actualItem.ContentItem.Type != expectedItem.ContentItem.Type {
 						t.Errorf("item %d: expected type %s, got %s", i, expectedItem.ContentItem.Type, actualItem.ContentItem.Type)
 					}
+
 					if actualItem.ContentItem.Location != expectedItem.ContentItem.Location {
 						t.Errorf("item %d: expected location %s, got %s", i, expectedItem.ContentItem.Location, actualItem.ContentItem.Location)
 					}
+
 					if actualItem.ContentItem.ItemName != expectedItem.ContentItem.ItemName {
 						t.Errorf("item %d: expected itemName %s, got %s", i, expectedItem.ContentItem.ItemName, actualItem.ContentItem.ItemName)
 					}
+
 					if actualItem.ContentItem.IsPresetable != expectedItem.ContentItem.IsPresetable {
 						t.Errorf("item %d: expected isPresetable %t, got %t", i, expectedItem.ContentItem.IsPresetable, actualItem.ContentItem.IsPresetable)
 					}
+
 					if actualItem.ContentItem.ContainerArt != expectedItem.ContentItem.ContainerArt {
 						t.Errorf("item %d: expected containerArt %s, got %s", i, expectedItem.ContentItem.ContainerArt, actualItem.ContentItem.ContainerArt)
 					}
@@ -300,6 +310,7 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 </recents>`
 
 	var response models.RecentsResponse
+
 	err := xml.Unmarshal([]byte(xmlData), &response)
 	if err != nil {
 		t.Fatalf("failed to unmarshal test data: %v", err)
@@ -339,6 +350,7 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 		if mostRecent.GetDisplayName() != "Spotify Track" {
 			t.Errorf("expected most recent to be 'Spotify Track', got %s", mostRecent.GetDisplayName())
 		}
+
 		if mostRecent.GetUTCTime() != 1701300000 {
 			t.Errorf("expected most recent UTC time 1701300000, got %d", mostRecent.GetUTCTime())
 		}
@@ -350,12 +362,15 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 			if !item.HasContent() {
 				t.Error("expected item to have content")
 			}
+
 			if item.GetDisplayName() == "" {
 				t.Error("expected item to have display name")
 			}
+
 			if item.GetSource() == "" {
 				t.Error("expected item to have source")
 			}
+
 			if item.GetUTCTime() == 0 {
 				t.Error("expected item to have UTC time")
 			}
@@ -366,9 +381,11 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 				if !item.IsSpotifyContent() {
 					t.Error("expected first item to be Spotify content")
 				}
+
 				if !item.IsTrack() {
 					t.Error("expected first item to be a track")
 				}
+
 				if !item.IsStreamingContent() {
 					t.Error("expected first item to be streaming content")
 				}
@@ -376,6 +393,7 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 				if !item.IsLocalContent() {
 					t.Error("expected second item to be local content")
 				}
+
 				if item.IsStreamingContent() {
 					t.Error("expected second item to not be streaming content")
 				}
@@ -383,6 +401,7 @@ func TestRecentsResponse_MethodsIntegration(t *testing.T) {
 				if !item.IsStation() {
 					t.Error("expected third item to be a station")
 				}
+
 				if item.IsTrack() {
 					t.Error("expected third item to not be a track")
 				}

pkg/client/source_selection_test.go

@@ -632,9 +632,11 @@ func TestClient_SelectContentItem(t *testing.T) {
 				if r.URL.Path != "/select" {
 					t.Errorf("Expected path /select, got %s", r.URL.Path)
 				}
+
 				if r.Method != "POST" {
 					t.Errorf("Expected POST method, got %s", r.Method)
 				}
+
 				w.WriteHeader(http.StatusOK)
 			}))
 			defer server.Close()
@@ -713,6 +715,7 @@ func TestClient_SelectLocalInternetRadio(t *testing.T) {
 				if r.URL.Path != "/select" {
 					t.Errorf("Expected path /select, got %s", r.URL.Path)
 				}
+
 				w.WriteHeader(http.StatusOK)
 			}))
 			defer server.Close()
@@ -791,6 +794,7 @@ func TestClient_SelectLocalMusic(t *testing.T) {
 				if r.URL.Path != "/select" {
 					t.Errorf("Expected path /select, got %s", r.URL.Path)
 				}
+
 				w.WriteHeader(http.StatusOK)
 			}))
 			defer server.Close()
@@ -869,6 +873,7 @@ func TestClient_SelectStoredMusic(t *testing.T) {
 				if r.URL.Path != "/select" {
 					t.Errorf("Expected path /select, got %s", r.URL.Path)
 				}
+
 				w.WriteHeader(http.StatusOK)
 			}))
 			defer server.Close()

pkg/models/account.go

@@ -0,0 +1,122 @@
+// Package models provides data structures and types for music service account management
+// on Bose SoundTouch devices.
+package models
+
+import (
+	"encoding/xml"
+	"fmt"
+)
+
+// MusicServiceCredentials represents credentials for music service account operations
+type MusicServiceCredentials struct {
+	XMLName     xml.Name `xml:"credentials"`
+	Source      string   `xml:"source,attr"`
+	DisplayName string   `xml:"displayName,attr,omitempty"`
+	User        string   `xml:"user"`
+	Pass        string   `xml:"pass"`
+}
+
+// NewMusicServiceCredentials creates new music service credentials
+func NewMusicServiceCredentials(source, displayName, user, pass string) *MusicServiceCredentials {
+	return &MusicServiceCredentials{
+		Source:      source,
+		DisplayName: displayName,
+		User:        user,
+		Pass:        pass,
+	}
+}
+
+// NewSpotifyCredentials creates credentials for Spotify service
+func NewSpotifyCredentials(user, pass string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("SPOTIFY", "Spotify Premium", user, pass)
+}
+
+// NewPandoraCredentials creates credentials for Pandora service
+func NewPandoraCredentials(user, pass string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("PANDORA", "Pandora Music Service", user, pass)
+}
+
+// NewStoredMusicCredentials creates credentials for STORED_MUSIC (NAS/UPnP) service
+func NewStoredMusicCredentials(user, displayName string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("STORED_MUSIC", displayName, user, "")
+}
+
+// NewAmazonMusicCredentials creates credentials for Amazon Music service
+func NewAmazonMusicCredentials(user, pass string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("AMAZON", "Amazon Music", user, pass)
+}
+
+// NewDeezerCredentials creates credentials for Deezer service
+func NewDeezerCredentials(user, pass string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("DEEZER", "Deezer Premium", user, pass)
+}
+
+// NewIHeartRadioCredentials creates credentials for iHeartRadio service
+func NewIHeartRadioCredentials(user, pass string) *MusicServiceCredentials {
+	return NewMusicServiceCredentials("IHEART", "iHeartRadio", user, pass)
+}
+
+// Validate ensures the credentials have required fields
+func (cred *MusicServiceCredentials) Validate() error {
+	if cred.Source == "" {
+		return fmt.Errorf("source cannot be empty")
+	}
+
+	if cred.User == "" {
+		return fmt.Errorf("user cannot be empty")
+	}
+
+	// STORED_MUSIC typically doesn't require a password
+	if cred.Source != "STORED_MUSIC" && cred.Pass == "" {
+		return fmt.Errorf("password cannot be empty for %s", cred.Source)
+	}
+
+	return nil
+}
+
+// IsForRemoval returns true if these credentials are for removing an account (empty password)
+func (cred *MusicServiceCredentials) IsForRemoval() bool {
+	return cred.Pass == ""
+}
+
+// HasPassword returns true if credentials include a password
+func (cred *MusicServiceCredentials) HasPassword() bool {
+	return cred.Pass != ""
+}
+
+// GetDescription returns a human-readable description of the service
+func (cred *MusicServiceCredentials) GetDescription() string {
+	if cred.DisplayName != "" {
+		return cred.DisplayName
+	}
+
+	switch cred.Source {
+	case "SPOTIFY":
+		return "Spotify Premium"
+	case "PANDORA":
+		return "Pandora Music Service"
+	case "AMAZON":
+		return "Amazon Music"
+	case "DEEZER":
+		return "Deezer Premium"
+	case "IHEART":
+		return "iHeartRadio"
+	case "STORED_MUSIC":
+		return "Network Music Library"
+	case "LOCAL_MUSIC":
+		return "Local Music Server"
+	default:
+		return cred.Source
+	}
+}
+
+// MusicServiceAccountResponse represents the response from account management operations
+type MusicServiceAccountResponse struct {
+	XMLName xml.Name `xml:"status"`
+	Status  string   `xml:",chardata"`
+}
+
+// IsSuccess returns true if the account operation was successful
+func (resp *MusicServiceAccountResponse) IsSuccess() bool {
+	return resp.Status == "/setMusicServiceAccount" || resp.Status == "/removeMusicServiceAccount"
+}

pkg/models/account_test.go

@@ -0,0 +1,514 @@
+package models
+
+import (
+	"encoding/xml"
+	"testing"
+)
+
+func TestNewMusicServiceCredentials(t *testing.T) {
+	tests := []struct {
+		name        string
+		source      string
+		displayName string
+		user        string
+		pass        string
+	}{
+		{
+			name:        "Valid credentials",
+			source:      "SPOTIFY",
+			displayName: "Spotify Premium",
+			user:        "user@spotify.com",
+			pass:        "password123",
+		},
+		{
+			name:        "Empty display name",
+			source:      "PANDORA",
+			displayName: "",
+			user:        "pandora_user",
+			pass:        "pandora_pass",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cred := NewMusicServiceCredentials(tt.source, tt.displayName, tt.user, tt.pass)
+
+			if cred.Source != tt.source {
+				t.Errorf("Expected source %s, got %s", tt.source, cred.Source)
+			}
+
+			if cred.DisplayName != tt.displayName {
+				t.Errorf("Expected displayName %s, got %s", tt.displayName, cred.DisplayName)
+			}
+
+			if cred.User != tt.user {
+				t.Errorf("Expected user %s, got %s", tt.user, cred.User)
+			}
+
+			if cred.Pass != tt.pass {
+				t.Errorf("Expected pass %s, got %s", tt.pass, cred.Pass)
+			}
+		})
+	}
+}
+
+func TestNewSpotifyCredentials(t *testing.T) {
+	cred := NewSpotifyCredentials("user@spotify.com", "mypassword")
+
+	if cred.Source != "SPOTIFY" {
+		t.Errorf("Expected source SPOTIFY, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "Spotify Premium" {
+		t.Errorf("Expected displayName 'Spotify Premium', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "user@spotify.com" {
+		t.Errorf("Expected user 'user@spotify.com', got %s", cred.User)
+	}
+
+	if cred.Pass != "mypassword" {
+		t.Errorf("Expected pass 'mypassword', got %s", cred.Pass)
+	}
+}
+
+func TestNewPandoraCredentials(t *testing.T) {
+	cred := NewPandoraCredentials("pandora_user", "pandora_pass")
+
+	if cred.Source != "PANDORA" {
+		t.Errorf("Expected source PANDORA, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "Pandora Music Service" {
+		t.Errorf("Expected displayName 'Pandora Music Service', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "pandora_user" {
+		t.Errorf("Expected user 'pandora_user', got %s", cred.User)
+	}
+
+	if cred.Pass != "pandora_pass" {
+		t.Errorf("Expected pass 'pandora_pass', got %s", cred.Pass)
+	}
+}
+
+func TestNewStoredMusicCredentials(t *testing.T) {
+	cred := NewStoredMusicCredentials("d09708a1-5953-44bc-a413-123456789012/0", "My NAS Library")
+
+	if cred.Source != "STORED_MUSIC" {
+		t.Errorf("Expected source STORED_MUSIC, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "My NAS Library" {
+		t.Errorf("Expected displayName 'My NAS Library', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "d09708a1-5953-44bc-a413-123456789012/0" {
+		t.Errorf("Expected user 'd09708a1-5953-44bc-a413-123456789012/0', got %s", cred.User)
+	}
+
+	if cred.Pass != "" {
+		t.Errorf("Expected empty pass for STORED_MUSIC, got %s", cred.Pass)
+	}
+}
+
+func TestNewAmazonMusicCredentials(t *testing.T) {
+	cred := NewAmazonMusicCredentials("amazon_user", "amazon_pass")
+
+	if cred.Source != "AMAZON" {
+		t.Errorf("Expected source AMAZON, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "Amazon Music" {
+		t.Errorf("Expected displayName 'Amazon Music', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "amazon_user" {
+		t.Errorf("Expected user 'amazon_user', got %s", cred.User)
+	}
+
+	if cred.Pass != "amazon_pass" {
+		t.Errorf("Expected pass 'amazon_pass', got %s", cred.Pass)
+	}
+}
+
+func TestNewDeezerCredentials(t *testing.T) {
+	cred := NewDeezerCredentials("deezer_user", "deezer_pass")
+
+	if cred.Source != "DEEZER" {
+		t.Errorf("Expected source DEEZER, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "Deezer Premium" {
+		t.Errorf("Expected displayName 'Deezer Premium', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "deezer_user" {
+		t.Errorf("Expected user 'deezer_user', got %s", cred.User)
+	}
+
+	if cred.Pass != "deezer_pass" {
+		t.Errorf("Expected pass 'deezer_pass', got %s", cred.Pass)
+	}
+}
+
+func TestNewIHeartRadioCredentials(t *testing.T) {
+	cred := NewIHeartRadioCredentials("iheart_user", "iheart_pass")
+
+	if cred.Source != "IHEART" {
+		t.Errorf("Expected source IHEART, got %s", cred.Source)
+	}
+
+	if cred.DisplayName != "iHeartRadio" {
+		t.Errorf("Expected displayName 'iHeartRadio', got %s", cred.DisplayName)
+	}
+
+	if cred.User != "iheart_user" {
+		t.Errorf("Expected user 'iheart_user', got %s", cred.User)
+	}
+
+	if cred.Pass != "iheart_pass" {
+		t.Errorf("Expected pass 'iheart_pass', got %s", cred.Pass)
+	}
+}
+
+func TestMusicServiceCredentials_Validate(t *testing.T) {
+	tests := []struct {
+		name        string
+		credentials *MusicServiceCredentials
+		wantError   bool
+		errorMsg    string
+	}{
+		{
+			name: "Valid Spotify credentials",
+			credentials: &MusicServiceCredentials{
+				Source: "SPOTIFY",
+				User:   "user@spotify.com",
+				Pass:   "password",
+			},
+			wantError: false,
+		},
+		{
+			name: "Valid STORED_MUSIC credentials (no password required)",
+			credentials: &MusicServiceCredentials{
+				Source: "STORED_MUSIC",
+				User:   "guid/0",
+				Pass:   "",
+			},
+			wantError: false,
+		},
+		{
+			name: "Empty source",
+			credentials: &MusicServiceCredentials{
+				Source: "",
+				User:   "user",
+				Pass:   "pass",
+			},
+			wantError: true,
+			errorMsg:  "source cannot be empty",
+		},
+		{
+			name: "Empty user",
+			credentials: &MusicServiceCredentials{
+				Source: "SPOTIFY",
+				User:   "",
+				Pass:   "pass",
+			},
+			wantError: true,
+			errorMsg:  "user cannot be empty",
+		},
+		{
+			name: "Empty password for non-STORED_MUSIC",
+			credentials: &MusicServiceCredentials{
+				Source: "SPOTIFY",
+				User:   "user",
+				Pass:   "",
+			},
+			wantError: true,
+			errorMsg:  "password cannot be empty for SPOTIFY",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.credentials.Validate()
+
+			if tt.wantError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				} else if tt.errorMsg != "" && err.Error() != tt.errorMsg {
+					t.Errorf("Expected error message %q, got %q", tt.errorMsg, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestMusicServiceCredentials_IsForRemoval(t *testing.T) {
+	tests := []struct {
+		name        string
+		credentials *MusicServiceCredentials
+		expected    bool
+	}{
+		{
+			name: "Has password - not for removal",
+			credentials: &MusicServiceCredentials{
+				Pass: "password",
+			},
+			expected: false,
+		},
+		{
+			name: "Empty password - for removal",
+			credentials: &MusicServiceCredentials{
+				Pass: "",
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.credentials.IsForRemoval()
+			if result != tt.expected {
+				t.Errorf("Expected %t, got %t", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestMusicServiceCredentials_HasPassword(t *testing.T) {
+	tests := []struct {
+		name        string
+		credentials *MusicServiceCredentials
+		expected    bool
+	}{
+		{
+			name: "Has password",
+			credentials: &MusicServiceCredentials{
+				Pass: "password",
+			},
+			expected: true,
+		},
+		{
+			name: "No password",
+			credentials: &MusicServiceCredentials{
+				Pass: "",
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.credentials.HasPassword()
+			if result != tt.expected {
+				t.Errorf("Expected %t, got %t", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestMusicServiceCredentials_GetDescription(t *testing.T) {
+	tests := []struct {
+		name        string
+		credentials *MusicServiceCredentials
+		expected    string
+	}{
+		{
+			name: "Has display name",
+			credentials: &MusicServiceCredentials{
+				Source:      "SPOTIFY",
+				DisplayName: "Custom Spotify Name",
+			},
+			expected: "Custom Spotify Name",
+		},
+		{
+			name: "Spotify default",
+			credentials: &MusicServiceCredentials{
+				Source: "SPOTIFY",
+			},
+			expected: "Spotify Premium",
+		},
+		{
+			name: "Pandora default",
+			credentials: &MusicServiceCredentials{
+				Source: "PANDORA",
+			},
+			expected: "Pandora Music Service",
+		},
+		{
+			name: "Amazon default",
+			credentials: &MusicServiceCredentials{
+				Source: "AMAZON",
+			},
+			expected: "Amazon Music",
+		},
+		{
+			name: "Deezer default",
+			credentials: &MusicServiceCredentials{
+				Source: "DEEZER",
+			},
+			expected: "Deezer Premium",
+		},
+		{
+			name: "iHeartRadio default",
+			credentials: &MusicServiceCredentials{
+				Source: "IHEART",
+			},
+			expected: "iHeartRadio",
+		},
+		{
+			name: "STORED_MUSIC default",
+			credentials: &MusicServiceCredentials{
+				Source: "STORED_MUSIC",
+			},
+			expected: "Network Music Library",
+		},
+		{
+			name: "LOCAL_MUSIC default",
+			credentials: &MusicServiceCredentials{
+				Source: "LOCAL_MUSIC",
+			},
+			expected: "Local Music Server",
+		},
+		{
+			name: "Unknown source",
+			credentials: &MusicServiceCredentials{
+				Source: "UNKNOWN",
+			},
+			expected: "UNKNOWN",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.credentials.GetDescription()
+			if result != tt.expected {
+				t.Errorf("Expected %s, got %s", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestMusicServiceAccountResponse_IsSuccess(t *testing.T) {
+	tests := []struct {
+		name     string
+		response *MusicServiceAccountResponse
+		expected bool
+	}{
+		{
+			name: "Set account success",
+			response: &MusicServiceAccountResponse{
+				Status: "/setMusicServiceAccount",
+			},
+			expected: true,
+		},
+		{
+			name: "Remove account success",
+			response: &MusicServiceAccountResponse{
+				Status: "/removeMusicServiceAccount",
+			},
+			expected: true,
+		},
+		{
+			name: "Other status",
+			response: &MusicServiceAccountResponse{
+				Status: "/someOtherEndpoint",
+			},
+			expected: false,
+		},
+		{
+			name: "Empty status",
+			response: &MusicServiceAccountResponse{
+				Status: "",
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.response.IsSuccess()
+			if result != tt.expected {
+				t.Errorf("Expected %t, got %t", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestMusicServiceCredentials_XMLMarshaling(t *testing.T) {
+	cred := &MusicServiceCredentials{
+		Source:      "SPOTIFY",
+		DisplayName: "Spotify Premium",
+		User:        "user@spotify.com",
+		Pass:        "mypassword",
+	}
+
+	// Test marshaling
+	data, err := xml.Marshal(cred)
+	if err != nil {
+		t.Errorf("Failed to marshal credentials: %v", err)
+	}
+
+	expectedXML := `<credentials source="SPOTIFY" displayName="Spotify Premium"><user>user@spotify.com</user><pass>mypassword</pass></credentials>`
+	if string(data) != expectedXML {
+		t.Errorf("Expected XML %s, got %s", expectedXML, string(data))
+	}
+
+	// Test unmarshaling
+	var unmarshaledCred MusicServiceCredentials
+
+	err = xml.Unmarshal(data, &unmarshaledCred)
+	if err != nil {
+		t.Errorf("Failed to unmarshal credentials: %v", err)
+	}
+
+	if unmarshaledCred.Source != cred.Source {
+		t.Errorf("Expected source %s, got %s", cred.Source, unmarshaledCred.Source)
+	}
+
+	if unmarshaledCred.DisplayName != cred.DisplayName {
+		t.Errorf("Expected displayName %s, got %s", cred.DisplayName, unmarshaledCred.DisplayName)
+	}
+
+	if unmarshaledCred.User != cred.User {
+		t.Errorf("Expected user %s, got %s", cred.User, unmarshaledCred.User)
+	}
+
+	if unmarshaledCred.Pass != cred.Pass {
+		t.Errorf("Expected pass %s, got %s", cred.Pass, unmarshaledCred.Pass)
+	}
+}
+
+func TestMusicServiceAccountResponse_XMLMarshaling(t *testing.T) {
+	response := &MusicServiceAccountResponse{
+		Status: "/setMusicServiceAccount",
+	}
+
+	// Test marshaling
+	data, err := xml.Marshal(response)
+	if err != nil {
+		t.Errorf("Failed to marshal response: %v", err)
+	}
+
+	expectedXML := `<status>/setMusicServiceAccount</status>`
+	if string(data) != expectedXML {
+		t.Errorf("Expected XML %s, got %s", expectedXML, string(data))
+	}
+
+	// Test unmarshaling
+	var unmarshaledResponse MusicServiceAccountResponse
+
+	err = xml.Unmarshal(data, &unmarshaledResponse)
+	if err != nil {
+		t.Errorf("Failed to unmarshal response: %v", err)
+	}
+
+	if unmarshaledResponse.Status != response.Status {
+		t.Errorf("Expected status %s, got %s", response.Status, unmarshaledResponse.Status)
+	}
+}

pkg/models/introspect.go

@@ -159,6 +159,7 @@ func (ir *IntrospectResponse) GetMaxHistorySize() int {
 	if ir.ContentItemHistory != nil {
 		return ir.ContentItemHistory.MaxSize
 	}
+
 	return 0
 }
 
@@ -237,6 +238,7 @@ func (sir *SpotifyIntrospectResponse) GetMaxHistorySize() int {
 	if sir.ContentItemHistory != nil {
 		return sir.ContentItemHistory.MaxSize
 	}
+
 	return 0
 }
 

pkg/models/introspect_test.go

@@ -116,12 +116,14 @@ func TestIntrospectResponse_Unmarshal(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var response IntrospectResponse
+
 			err := xml.Unmarshal([]byte(tt.xmlData), &response)
 
 			if tt.expectError {
 				if err == nil {
 					t.Error("expected error, got nil")
 				}
+
 				return
 			}
 
@@ -133,33 +135,42 @@ func TestIntrospectResponse_Unmarshal(t *testing.T) {
 			if response.State != tt.expected.State {
 				t.Errorf("expected state %s, got %s", tt.expected.State, response.State)
 			}
+
 			if response.User != tt.expected.User {
 				t.Errorf("expected user %s, got %s", tt.expected.User, response.User)
 			}
+
 			if response.IsPlaying != tt.expected.IsPlaying {
 				t.Errorf("expected isPlaying %t, got %t", tt.expected.IsPlaying, response.IsPlaying)
 			}
+
 			if response.TokenLastChangedTimeSeconds != tt.expected.TokenLastChangedTimeSeconds {
 				t.Errorf("expected tokenLastChangedTimeSeconds %d, got %d",
 					tt.expected.TokenLastChangedTimeSeconds, response.TokenLastChangedTimeSeconds)
 			}
+
 			if response.TokenLastChangedTimeMicroseconds != tt.expected.TokenLastChangedTimeMicroseconds {
 				t.Errorf("expected tokenLastChangedTimeMicroseconds %d, got %d",
 					tt.expected.TokenLastChangedTimeMicroseconds, response.TokenLastChangedTimeMicroseconds)
 			}
+
 			if response.ShuffleMode != tt.expected.ShuffleMode {
 				t.Errorf("expected shuffleMode %s, got %s", tt.expected.ShuffleMode, response.ShuffleMode)
 			}
+
 			if response.PlayStatusState != tt.expected.PlayStatusState {
 				t.Errorf("expected playStatusState %s, got %s", tt.expected.PlayStatusState, response.PlayStatusState)
 			}
+
 			if response.CurrentURI != tt.expected.CurrentURI {
 				t.Errorf("expected currentUri %s, got %s", tt.expected.CurrentURI, response.CurrentURI)
 			}
+
 			if response.ReceivedPlaybackRequest != tt.expected.ReceivedPlaybackRequest {
 				t.Errorf("expected receivedPlaybackRequest %t, got %t",
 					tt.expected.ReceivedPlaybackRequest, response.ReceivedPlaybackRequest)
 			}
+
 			if response.SubscriptionType != tt.expected.SubscriptionType {
 				t.Errorf("expected subscriptionType %s, got %s", tt.expected.SubscriptionType, response.SubscriptionType)
 			}
@@ -182,16 +193,19 @@ func TestIntrospectResponse_Unmarshal(t *testing.T) {
 							tt.expected.NowPlaying.SkipPreviousSupported,
 							response.NowPlaying.SkipPreviousSupported)
 					}
+
 					if response.NowPlaying.SeekSupported != tt.expected.NowPlaying.SeekSupported {
 						t.Errorf("expected seekSupported %t, got %t",
 							tt.expected.NowPlaying.SeekSupported,
 							response.NowPlaying.SeekSupported)
 					}
+
 					if response.NowPlaying.ResumeSupported != tt.expected.NowPlaying.ResumeSupported {
 						t.Errorf("expected resumeSupported %t, got %t",
 							tt.expected.NowPlaying.ResumeSupported,
 							response.NowPlaying.ResumeSupported)
 					}
+
 					if response.NowPlaying.CollectData != tt.expected.NowPlaying.CollectData {
 						t.Errorf("expected collectData %t, got %t",
 							tt.expected.NowPlaying.CollectData,
@@ -227,6 +241,7 @@ func TestSpotifyIntrospectResponse_Unmarshal(t *testing.T) {
 </spotifyAccountIntrospectResponse>`
 
 	var response SpotifyIntrospectResponse
+
 	err := xml.Unmarshal([]byte(xmlData), &response)
 	if err != nil {
 		t.Fatalf("failed to unmarshal spotify response: %v", err)
@@ -235,15 +250,19 @@ func TestSpotifyIntrospectResponse_Unmarshal(t *testing.T) {
 	if response.State != "InactiveUnselected" {
 		t.Errorf("expected state InactiveUnselected, got %s", response.State)
 	}
+
 	if response.User != "SpotifyConnectUserName" {
 		t.Errorf("expected user SpotifyConnectUserName, got %s", response.User)
 	}
+
 	if response.IsPlaying != false {
 		t.Errorf("expected isPlaying false, got %t", response.IsPlaying)
 	}
+
 	if response.TokenLastChangedTimeSeconds != 1702566495 {
 		t.Errorf("expected tokenLastChangedTimeSeconds 1702566495, got %d", response.TokenLastChangedTimeSeconds)
 	}
+
 	if response.ShuffleMode != "OFF" {
 		t.Errorf("expected shuffleMode OFF, got %s", response.ShuffleMode)
 	}
@@ -318,6 +337,7 @@ func TestNewIntrospectRequest(t *testing.T) {
 			if request.Source != tt.source {
 				t.Errorf("expected source %s, got %s", tt.source, request.Source)
 			}
+
 			if request.SourceAccount != tt.sourceAccount {
 				t.Errorf("expected sourceAccount %s, got %s", tt.sourceAccount, request.SourceAccount)
 			}
@@ -351,36 +371,48 @@ func TestIntrospectResponse_Methods(t *testing.T) {
 				},
 			},
 			testFunc: func(t *testing.T, r *IntrospectResponse) {
+				t.Helper()
+
 				if !r.IsActive() {
 					t.Error("expected IsActive() to return true")
 				}
+
 				if r.IsInactive() {
 					t.Error("expected IsInactive() to return false")
 				}
+
 				if !r.HasUser() {
 					t.Error("expected HasUser() to return true")
 				}
+
 				if !r.IsShuffleEnabled() {
 					t.Error("expected IsShuffleEnabled() to return true")
 				}
+
 				if !r.HasCurrentContent() {
 					t.Error("expected HasCurrentContent() to return true")
 				}
+
 				if !r.SupportsSkipPrevious() {
 					t.Error("expected SupportsSkipPrevious() to return true")
 				}
+
 				if !r.SupportsSeek() {
 					t.Error("expected SupportsSeek() to return true")
 				}
+
 				if !r.SupportsResume() {
 					t.Error("expected SupportsResume() to return true")
 				}
+
 				if r.CollectsData() {
 					t.Error("expected CollectsData() to return false")
 				}
+
 				if r.GetMaxHistorySize() != 15 {
 					t.Errorf("expected GetMaxHistorySize() to return 15, got %d", r.GetMaxHistorySize())
 				}
+
 				if !r.HasSubscription() {
 					t.Error("expected HasSubscription() to return true")
 				}
@@ -397,24 +429,32 @@ func TestIntrospectResponse_Methods(t *testing.T) {
 				SubscriptionType: "",
 			},
 			testFunc: func(t *testing.T, r *IntrospectResponse) {
+				t.Helper()
+
 				if r.IsActive() {
 					t.Error("expected IsActive() to return false")
 				}
+
 				if !r.IsInactive() {
 					t.Error("expected IsInactive() to return true")
 				}
+
 				if r.HasUser() {
 					t.Error("expected HasUser() to return false")
 				}
+
 				if r.IsShuffleEnabled() {
 					t.Error("expected IsShuffleEnabled() to return false")
 				}
+
 				if r.HasCurrentContent() {
 					t.Error("expected HasCurrentContent() to return false")
 				}
+
 				if r.HasSubscription() {
 					t.Error("expected HasSubscription() to return false")
 				}
+
 				if r.GetMaxHistorySize() != 0 {
 					t.Errorf("expected GetMaxHistorySize() to return 0, got %d", r.GetMaxHistorySize())
 				}
@@ -452,33 +492,43 @@ func TestSpotifyIntrospectResponse_Methods(t *testing.T) {
 	if !response.IsActive() {
 		t.Error("expected IsActive() to return true")
 	}
+
 	if response.IsInactive() {
 		t.Error("expected IsInactive() to return false")
 	}
+
 	if !response.HasUser() {
 		t.Error("expected HasUser() to return true")
 	}
+
 	if !response.IsShuffleEnabled() {
 		t.Error("expected IsShuffleEnabled() to return true")
 	}
+
 	if !response.HasCurrentContent() {
 		t.Error("expected HasCurrentContent() to return true")
 	}
+
 	if !response.SupportsSkipPrevious() {
 		t.Error("expected SupportsSkipPrevious() to return true")
 	}
+
 	if !response.SupportsSeek() {
 		t.Error("expected SupportsSeek() to return true")
 	}
+
 	if !response.SupportsResume() {
 		t.Error("expected SupportsResume() to return true")
 	}
+
 	if response.CollectsData() {
 		t.Error("expected CollectsData() to return false")
 	}
+
 	if response.GetMaxHistorySize() != 15 {
 		t.Errorf("expected GetMaxHistorySize() to return 15, got %d", response.GetMaxHistorySize())
 	}
+
 	if !response.HasSubscription() {
 		t.Error("expected HasSubscription() to return true")
 	}

pkg/models/recents.go

@@ -32,17 +32,20 @@ func (r *RecentsResponse) GetMostRecent() *RecentsResponseItem {
 	if len(r.Items) == 0 {
 		return nil
 	}
+
 	return &r.Items[0]
 }
 
 // GetItemsBySource returns recent items filtered by source type
 func (r *RecentsResponse) GetItemsBySource(source string) []RecentsResponseItem {
 	var filtered []RecentsResponseItem
+
 	for _, item := range r.Items {
 		if item.ContentItem != nil && item.ContentItem.Source == source {
 			filtered = append(filtered, item)
 		}
 	}
+
 	return filtered
 }
 
@@ -74,22 +77,26 @@ func (r *RecentsResponse) GetPandoraItems() []RecentsResponseItem {
 // GetPresetableItems returns recent items that can be saved as presets
 func (r *RecentsResponse) GetPresetableItems() []RecentsResponseItem {
 	var presetable []RecentsResponseItem
+
 	for _, item := range r.Items {
 		if item.ContentItem != nil && item.ContentItem.IsPresetable {
 			presetable = append(presetable, item)
 		}
 	}
+
 	return presetable
 }
 
 // GetItemsByType returns recent items filtered by content type
 func (r *RecentsResponse) GetItemsByType(contentType string) []RecentsResponseItem {
 	var filtered []RecentsResponseItem
+
 	for _, item := range r.Items {
 		if item.ContentItem != nil && item.ContentItem.Type == contentType {
 			filtered = append(filtered, item)
 		}
 	}
+
 	return filtered
 }
 
@@ -106,6 +113,7 @@ func (r *RecentsResponse) GetStations() []RecentsResponseItem {
 // GetPlaylistsAndAlbums returns playlist and album-type recent items
 func (r *RecentsResponse) GetPlaylistsAndAlbums() []RecentsResponseItem {
 	var items []RecentsResponseItem
+
 	for _, item := range r.Items {
 		if item.ContentItem != nil {
 			contentType := item.ContentItem.Type
@@ -114,6 +122,7 @@ func (r *RecentsResponse) GetPlaylistsAndAlbums() []RecentsResponseItem {
 			}
 		}
 	}
+
 	return items
 }
 
@@ -127,6 +136,7 @@ func (ri *RecentsResponseItem) GetDisplayName() string {
 	if ri.ContentItem != nil && ri.ContentItem.ItemName != "" {
 		return ri.ContentItem.ItemName
 	}
+
 	return "Unknown Item"
 }
 
@@ -135,6 +145,7 @@ func (ri *RecentsResponseItem) GetSource() string {
 	if ri.ContentItem != nil {
 		return ri.ContentItem.Source
 	}
+
 	return ""
 }
 
@@ -143,6 +154,7 @@ func (ri *RecentsResponseItem) GetSourceAccount() string {
 	if ri.ContentItem != nil {
 		return ri.ContentItem.SourceAccount
 	}
+
 	return ""
 }
 
@@ -151,6 +163,7 @@ func (ri *RecentsResponseItem) GetLocation() string {
 	if ri.ContentItem != nil {
 		return ri.ContentItem.Location
 	}
+
 	return ""
 }
 
@@ -159,6 +172,7 @@ func (ri *RecentsResponseItem) GetContentType() string {
 	if ri.ContentItem != nil {
 		return ri.ContentItem.Type
 	}
+
 	return ""
 }
 
@@ -207,6 +221,7 @@ func (ri *RecentsResponseItem) IsLocalContent() bool {
 // IsStreamingContent returns true if the recent item is from streaming services
 func (ri *RecentsResponseItem) IsStreamingContent() bool {
 	source := ri.GetSource()
+
 	return source == "SPOTIFY" || source == "PANDORA" || source == "TUNEIN" ||
 		source == "AMAZON" || source == "DEEZER" || source == "IHEART"
 }
@@ -216,6 +231,7 @@ func (ri *RecentsResponseItem) GetArtwork() string {
 	if ri.ContentItem != nil {
 		return ri.ContentItem.ContainerArt
 	}
+
 	return ""
 }
 

pkg/models/recents_test.go

@@ -97,12 +97,14 @@ func TestRecentsResponse_Unmarshal(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var response RecentsResponse
+
 			err := xml.Unmarshal([]byte(tt.xmlData), &response)
 
 			if tt.expectError {
 				if err == nil {
 					t.Error("expected error, got nil")
 				}
+
 				return
 			}
 
@@ -126,9 +128,11 @@ func TestRecentsResponse_Unmarshal(t *testing.T) {
 				if actualItem.DeviceID != expectedItem.DeviceID {
 					t.Errorf("item %d: expected deviceID %s, got %s", i, expectedItem.DeviceID, actualItem.DeviceID)
 				}
+
 				if actualItem.UTCTime != expectedItem.UTCTime {
 					t.Errorf("item %d: expected utcTime %d, got %d", i, expectedItem.UTCTime, actualItem.UTCTime)
 				}
+
 				if actualItem.ID != expectedItem.ID {
 					t.Errorf("item %d: expected id %s, got %s", i, expectedItem.ID, actualItem.ID)
 				}
@@ -143,15 +147,19 @@ func TestRecentsResponse_Unmarshal(t *testing.T) {
 					if actualItem.ContentItem.Source != expectedItem.ContentItem.Source {
 						t.Errorf("item %d: expected source %s, got %s", i, expectedItem.ContentItem.Source, actualItem.ContentItem.Source)
 					}
+
 					if actualItem.ContentItem.Type != expectedItem.ContentItem.Type {
 						t.Errorf("item %d: expected type %s, got %s", i, expectedItem.ContentItem.Type, actualItem.ContentItem.Type)
 					}
+
 					if actualItem.ContentItem.Location != expectedItem.ContentItem.Location {
 						t.Errorf("item %d: expected location %s, got %s", i, expectedItem.ContentItem.Location, actualItem.ContentItem.Location)
 					}
+
 					if actualItem.ContentItem.ItemName != expectedItem.ContentItem.ItemName {
 						t.Errorf("item %d: expected itemName %s, got %s", i, expectedItem.ContentItem.ItemName, actualItem.ContentItem.ItemName)
 					}
+
 					if actualItem.ContentItem.IsPresetable != expectedItem.ContentItem.IsPresetable {
 						t.Errorf("item %d: expected isPresetable %t, got %t", i, expectedItem.ContentItem.IsPresetable, actualItem.ContentItem.IsPresetable)
 					}
@@ -299,42 +307,56 @@ func TestRecentItem_Methods(t *testing.T) {
 				},
 			},
 			test: func(t *testing.T, item *RecentsResponseItem) {
+				t.Helper()
+
 				if !item.HasContent() {
 					t.Error("expected HasContent() to return true")
 				}
+
 				if item.GetDisplayName() != "Test Song" {
 					t.Errorf("expected display name 'Test Song', got %s", item.GetDisplayName())
 				}
+
 				if item.GetSource() != "SPOTIFY" {
 					t.Errorf("expected source 'SPOTIFY', got %s", item.GetSource())
 				}
+
 				if !item.IsTrack() {
 					t.Error("expected IsTrack() to return true")
 				}
+
 				if !item.IsSpotifyContent() {
 					t.Error("expected IsSpotifyContent() to return true")
 				}
+
 				if !item.IsStreamingContent() {
 					t.Error("expected IsStreamingContent() to return true")
 				}
+
 				if item.IsLocalContent() {
 					t.Error("expected IsLocalContent() to return false")
 				}
+
 				if !item.IsPresetable() {
 					t.Error("expected IsPresetable() to return true")
 				}
+
 				if !item.HasArtwork() {
 					t.Error("expected HasArtwork() to return true")
 				}
+
 				if item.GetArtwork() != "https://example.com/art.jpg" {
 					t.Errorf("expected artwork URL, got %s", item.GetArtwork())
 				}
+
 				if item.GetUTCTime() != 1701200000 {
 					t.Errorf("expected UTC time 1701200000, got %d", item.GetUTCTime())
 				}
+
 				if !item.HasID() {
 					t.Error("expected HasID() to return true")
 				}
+
 				if item.GetID() != "spotify123" {
 					t.Errorf("expected ID 'spotify123', got %s", item.GetID())
 				}
@@ -354,18 +376,24 @@ func TestRecentItem_Methods(t *testing.T) {
 				},
 			},
 			test: func(t *testing.T, item *RecentsResponseItem) {
+				t.Helper()
+
 				if !item.IsLocalContent() {
 					t.Error("expected IsLocalContent() to return true")
 				}
+
 				if item.IsStreamingContent() {
 					t.Error("expected IsStreamingContent() to return false")
 				}
+
 				if item.IsSpotifyContent() {
 					t.Error("expected IsSpotifyContent() to return false")
 				}
+
 				if item.HasArtwork() {
 					t.Error("expected HasArtwork() to return false")
 				}
+
 				if item.GetArtwork() != "" {
 					t.Errorf("expected empty artwork, got %s", item.GetArtwork())
 				}
@@ -385,12 +413,16 @@ func TestRecentItem_Methods(t *testing.T) {
 				},
 			},
 			test: func(t *testing.T, item *RecentsResponseItem) {
+				t.Helper()
+
 				if !item.IsStation() {
 					t.Error("expected IsStation() to return true")
 				}
+
 				if item.IsTrack() {
 					t.Error("expected IsTrack() to return false")
 				}
+
 				if !item.IsStreamingContent() {
 					t.Error("expected IsStreamingContent() to return true")
 				}
@@ -403,21 +435,28 @@ func TestRecentItem_Methods(t *testing.T) {
 				UTCTime:  1701000000,
 			},
 			test: func(t *testing.T, item *RecentsResponseItem) {
+				t.Helper()
+
 				if item.HasContent() {
 					t.Error("expected HasContent() to return false")
 				}
+
 				if item.GetDisplayName() != "Unknown Item" {
 					t.Errorf("expected display name 'Unknown Item', got %s", item.GetDisplayName())
 				}
+
 				if item.GetSource() != "" {
 					t.Errorf("expected empty source, got %s", item.GetSource())
 				}
+
 				if item.IsTrack() {
 					t.Error("expected IsTrack() to return false")
 				}
+
 				if item.IsPresetable() {
 					t.Error("expected IsPresetable() to return false")
 				}
+
 				if item.HasID() {
 					t.Error("expected HasID() to return false")
 				}