Merge branch 'main' of ssh://github.com/hilli/go-kef-w2

Author: hilli

.gitignore

@@ -6,4 +6,6 @@ fyne-cross
 dist/
 completions/
 research
+go.work
+go.work.sum
 

.goreleaser.yaml

@@ -64,30 +64,35 @@ archives:
       - LICENSE
       - completions/*
 
-brews:
+homebrew_casks:
   - name: kefw2
-    goarm: 7
     commit_author:
       name: Jens Hilligsøe
       email: github@hilli.dk
-    commit_msg_template: "Brew formula update for {{ .ProjectName }} version {{ .Tag }}"
+    commit_msg_template: "Brew cask update for {{ .ProjectName }} version {{ .Tag }}"
     homepage: "https://github.com/hilli/go-kef-w2"
-    description: "Command for handling KEF W2 platform speakers (LSX Wireless II (LT)/LS50 Wireless II/LS60 Wireless)"
-    license: "MIT"
-    url_template: "https://github.com/hilli/go-kef-w2/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
+    description: "CLI for controlling KEF W2 platform speakers"
+    url:
+      template: "https://github.com/hilli/go-kef-w2/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
+      verified: "github.com/hilli/go-kef-w2/"
     skip_upload: false
-    directory: Formula
+    completions:
+      bash: completions/kefw2.bash
+      zsh: completions/kefw2.zsh
+      fish: completions/kefw2.fish
+    hooks:
+      post:
+        install: |
+          if OS.mac?
+            system_command "/usr/bin/xattr", args: ["-dr", "com.apple.quarantine", "#{staged_path}/kefw2"]
+          end
     repository:
       owner: hilli
       name: homebrew-tap
       branch: release-go-kef-w2-{{.Tag}}
       pull_request:
         enabled: true
         draft: false
-    extra_install: |-
-      bash_completion.install "completions/kefw2.bash" => "kefw2"
-      zsh_completion.install "completions/kefw2.zsh" => "_kefw2"
-      fish_completion.install "completions/kefw2.fish"
 
 scoops:
   - repository:

CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.7] - 2026-02-11
+
+### Added
+
+- **Standby wake on play**: `PlayOrResumeFromQueue` now automatically switches to WiFi and waits for the speaker to wake when called from standby, then starts playback from the queue
+- **Library: `WokeFromStandby` field on `PlayResult`**: Callers can check whether a standby wake occurred during playback start
+- **Library: `AlbumsForArtist()` helper**: New function and `ArtistAlbum` type for extracting unique albums from artist search results
+
+### Changed
+
+- **`play` command wakes from standby**: The CLI play command now wakes the speaker from standby instead of refusing; still refuses on non-streamable physical sources (optical, coaxial, etc.)
+- **Goreleaser: Homebrew cask**: Switched from Homebrew formula to Homebrew cask with shell completion installation and macOS quarantine removal
+- **Renamed `min` to `mins` in seek**: Avoids shadowing the Go 1.21+ `min` builtin
+
+### Fixed
+
+- **PlayerTrackRoles documentation**: Corrected `Path` and `ID` field comments — these are internal item IDs, not display indices
+- **Airable redirect handling**: Radio and podcast menu endpoints now properly follow redirects and return rows from the redirected path
+- **Import ordering**: Fixed import grouping in `cache.go`
+
 ## [0.2.6] - 2026-02-06
 
 ### Added
@@ -417,7 +437,8 @@ Implemented by: `Source`, `SpeakerStatus`, `CableMode`
 
 7. **Update player ID field access**: If you access `playId.SystemMemberId`, change it to `playId.SystemMemberID`.
 
-[Unreleased]: https://github.com/hilli/go-kef-w2/compare/v0.2.6...HEAD
+[Unreleased]: https://github.com/hilli/go-kef-w2/compare/v0.2.7...HEAD
+[0.2.7]: https://github.com/hilli/go-kef-w2/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/hilli/go-kef-w2/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/hilli/go-kef-w2/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/hilli/go-kef-w2/compare/v0.2.3...v0.2.4

cmd/kefw2/cmd/cache.go

@@ -29,9 +29,10 @@ import (
 	"sync"
 	"time"
 
-	"github.com/hilli/go-kef-w2/kefw2"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+
+	"github.com/hilli/go-kef-w2/kefw2"
 )
 
 // CachedItem represents a cached content item for completion.

cmd/kefw2/cmd/play.go

@@ -22,28 +22,59 @@ THE SOFTWARE.
 package cmd
 
 import (
+	"fmt"
+
 	"github.com/spf13/cobra"
+
+	"github.com/hilli/go-kef-w2/kefw2"
 )
 
-// muteCmd toggles the mute state of the speakers.
+// playCmd resumes or starts playback on the speaker.
 var playCmd = &cobra.Command{
 	Use:   "play",
-	Short: "Resume playback when on WiFi/BT source if paused",
-	Long:  `Resume playback when on WiFi/BT source if paused`,
-	Args:  cobra.MaximumNArgs(0),
+	Short: "Resume or start playback",
+	Long: `Resume or start playback.
+
+If the speaker is in standby, it will be woken up by switching to WiFi
+before starting playback. If paused, playback is resumed. If stopped and
+the queue has tracks, playback starts from the top of the queue (or a
+random track if shuffle is enabled). If the queue is empty, a message is
+shown.`,
+	Args: cobra.MaximumNArgs(0),
 	Run: func(cmd *cobra.Command, _ []string) {
 		ctx := cmd.Context()
-		canControlPlayback, err := currentSpeaker.CanControlPlayback(ctx)
+
+		// Check current source - refuse if on a non-streamable physical input
+		// (optical, coaxial, etc.) but allow standby since PlayOrResumeFromQueue
+		// will wake the speaker by switching to WiFi.
+		source, err := currentSpeaker.Source(ctx)
 		exitOnError(err, "Can't query source")
-		if !canControlPlayback {
-			headerPrinter.Println("Can only play on WiFi/BT source.")
+		if source != kefw2.SourceWiFi && source != kefw2.SourceBluetooth && source != kefw2.SourceStandby {
+			headerPrinter.Printf("Can only play on WiFi/BT source (current: %s).\n", source)
 			return
 		}
-		isPlaying, err := currentSpeaker.IsPlaying(ctx)
-		exitOnError(err, "Can't check playback state")
-		if !isPlaying {
-			err = currentSpeaker.PlayPause(ctx)
-			exitOnError(err, "Can't resume playback")
+
+		client := kefw2.NewAirableClient(currentSpeaker)
+		result, err := client.PlayOrResumeFromQueue(ctx)
+		exitOnError(err, "Can't play")
+
+		switch result.Action {
+		case kefw2.PlayActionStartedFromQueue:
+			if result.WokeFromStandby {
+				headerPrinter.Print("Woke speaker from standby. ")
+			}
+			if result.Shuffled {
+				headerPrinter.Print("Shuffling queue, playing: ")
+			} else {
+				headerPrinter.Print("Playing from queue: ")
+			}
+			contentPrinter.Printf("%s", result.Track.Title)
+			if result.Track.MediaData != nil && result.Track.MediaData.MetaData.Artist != "" {
+				contentPrinter.Printf(" - %s", result.Track.MediaData.MetaData.Artist)
+			}
+			fmt.Println()
+		case kefw2.PlayActionNothingToPlay:
+			headerPrinter.Println("Nothing to play - queue is empty.")
 		}
 	},
 }

cmd/kefw2/cmd/seek.go

@@ -113,29 +113,29 @@ func parseTimePosition(s string) (int64, error) {
 
 	case 2:
 		// mm:ss
-		min, err := strconv.ParseInt(parts[0], 10, 64)
+		mins, err := strconv.ParseInt(parts[0], 10, 64)
 		if err != nil {
 			return 0, fmt.Errorf("invalid minutes: %s", parts[0])
 		}
 		sec, err := strconv.ParseInt(parts[1], 10, 64)
 		if err != nil {
 			return 0, fmt.Errorf("invalid seconds: %s", parts[1])
 		}
-		if min < 0 {
+		if mins < 0 {
 			return 0, fmt.Errorf("minutes cannot be negative")
 		}
 		if sec < 0 || sec >= 60 {
 			return 0, fmt.Errorf("seconds must be 0-59")
 		}
-		return (min*60 + sec) * 1000, nil
+		return (mins*60 + sec) * 1000, nil
 
 	case 3:
 		// hh:mm:ss
 		hours, err := strconv.ParseInt(parts[0], 10, 64)
 		if err != nil {
 			return 0, fmt.Errorf("invalid hours: %s", parts[0])
 		}
-		min, err := strconv.ParseInt(parts[1], 10, 64)
+		mins, err := strconv.ParseInt(parts[1], 10, 64)
 		if err != nil {
 			return 0, fmt.Errorf("invalid minutes: %s", parts[1])
 		}
@@ -146,13 +146,13 @@ func parseTimePosition(s string) (int64, error) {
 		if hours < 0 {
 			return 0, fmt.Errorf("hours cannot be negative")
 		}
-		if min < 0 || min >= 60 {
+		if mins < 0 || mins >= 60 {
 			return 0, fmt.Errorf("minutes must be 0-59")
 		}
 		if sec < 0 || sec >= 60 {
 			return 0, fmt.Errorf("seconds must be 0-59")
 		}
-		return (hours*3600 + min*60 + sec) * 1000, nil
+		return (hours*3600 + mins*60 + sec) * 1000, nil
 
 	default:
 		return 0, fmt.Errorf("invalid time format: %s (use hh:mm:ss, mm:ss, or seconds)", s)

kefw2/airable_podcast.go

@@ -214,7 +214,7 @@ func (a *AirableClient) PlayPodcastEpisode(episode *ContentItem) error {
 // We try to find the container path from:
 // 1. The contentPlayContextPath metadata (if it points to a container)
 // 2. Cached/known podcast feed paths
-// 3. Pattern matching on the episode path
+// 3. Pattern matching on the episode path.
 func (a *AirableClient) getEpisodesContainerPath(episode *ContentItem) string {
 	// The episode path format is: airable:https://xxx.airable.io/id/airable/feed.episode/EPISODE_ID
 	// We can't directly derive the podcast feed ID from this.

kefw2/airable_test.go

@@ -47,27 +47,45 @@ func TestAirableClient_GetRows(t *testing.T) {
 }
 
 func TestAirableClient_GetRadioMenu(t *testing.T) {
-	// Mock server to simulate the API
+	// Mock server to simulate the API with redirect handling
 	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/api/getRows" {
-			response := RowsResponse{
-				RowsCount:    0,
-				RowsRedirect: "airable:https://mock.airable.io/airable/radios",
+			path := r.URL.Query().Get("path")
+			if path == "airable:https://mock.airable.io/airable/radios" {
+				// Second request after redirect - return actual rows
+				response := RowsResponse{
+					RowsCount: 1,
+					Rows: []ContentItem{
+						{Title: "Popular", Type: "container", Path: "airable:https://mock.airable.io/airable/radios/popular"},
+					},
+				}
+				_ = json.NewEncoder(w).Encode(response)
+			} else {
+				// Initial request - return redirect
+				response := RowsResponse{
+					RowsCount:    0,
+					RowsRedirect: "airable:https://mock.airable.io/airable/radios",
+				}
+				_ = json.NewEncoder(w).Encode(response)
 			}
-			_ = json.NewEncoder(w).Encode(response)
 		}
 	}))
 	defer mockServer.Close()
 
 	// Initialize AirableClient with the mock server
 	client := NewAirableClient(&KEFSpeaker{IPAddress: mockServer.URL[7:]})
 
-	// Call GetRadioMenu - this should set RadioBaseURL from redirect
-	_, err := client.GetRadioMenu()
+	// Call GetRadioMenu - this should follow the redirect and set RadioBaseURL
+	resp, err := client.GetRadioMenu()
 	if err != nil {
 		t.Fatalf("GetRadioMenu failed: %v", err)
 	}
 
+	// Validate rows were returned
+	if len(resp.Rows) != 1 {
+		t.Errorf("Expected 1 row, got %d", len(resp.Rows))
+	}
+
 	// Validate RadioBaseURL was set
 	if client.RadioBaseURL != "airable:https://mock.airable.io/airable/radios" {
 		t.Errorf("Expected RadioBaseURL 'airable:https://mock.airable.io/airable/radios', got '%s'", client.RadioBaseURL)
@@ -227,27 +245,45 @@ func TestContentItem_GetThumbnail(t *testing.T) {
 }
 
 func TestAirableClient_GetPodcastMenu(t *testing.T) {
-	// Mock server to simulate the API
+	// Mock server to simulate the API with redirect handling
 	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/api/getRows" {
-			response := RowsResponse{
-				RowsCount:    0,
-				RowsRedirect: "airable:https://mock.airable.io/airable/feeds",
+			path := r.URL.Query().Get("path")
+			if path == "airable:https://mock.airable.io/airable/feeds" {
+				// Second request after redirect - return actual rows
+				response := RowsResponse{
+					RowsCount: 1,
+					Rows: []ContentItem{
+						{Title: "Popular", Type: "container", Path: "airable:https://mock.airable.io/airable/feeds/popular"},
+					},
+				}
+				_ = json.NewEncoder(w).Encode(response)
+			} else {
+				// Initial request - return redirect
+				response := RowsResponse{
+					RowsCount:    0,
+					RowsRedirect: "airable:https://mock.airable.io/airable/feeds",
+				}
+				_ = json.NewEncoder(w).Encode(response)
 			}
-			_ = json.NewEncoder(w).Encode(response)
 		}
 	}))
 	defer mockServer.Close()
 
 	// Initialize AirableClient with the mock server
 	client := NewAirableClient(&KEFSpeaker{IPAddress: mockServer.URL[7:]})
 
-	// Call GetPodcastMenu
-	_, err := client.GetPodcastMenu()
+	// Call GetPodcastMenu - this should follow the redirect and set PodcastBaseURL
+	resp, err := client.GetPodcastMenu()
 	if err != nil {
 		t.Fatalf("GetPodcastMenu failed: %v", err)
 	}
 
+	// Validate rows were returned
+	if len(resp.Rows) != 1 {
+		t.Errorf("Expected 1 row, got %d", len(resp.Rows))
+	}
+
 	// Validate PodcastBaseURL was set
 	if client.PodcastBaseURL != "airable:https://mock.airable.io/airable/feeds" {
 		t.Errorf("Expected PodcastBaseURL 'airable:https://mock.airable.io/airable/feeds', got '%s'", client.PodcastBaseURL)

kefw2/browse_cache.go

@@ -351,7 +351,7 @@ func (c *BrowseCache) ResolveDisplayPath(displayPath, service string) (apiPath s
 // ============================================
 
 // ParseHierarchicalPath splits a path into segments, handling escaped characters.
-// For example: "Rock/Classic Rock" -> ["Rock", "Classic Rock"]
+// For example: "Rock/Classic Rock" -> ["Rock", "Classic Rock"].
 func ParseHierarchicalPath(path string) []string {
 	if path == "" {
 		return nil

kefw2/player_data.go

@@ -31,8 +31,8 @@ type PlayerResource struct {
 
 // PlayerTrackRoles contains track metadata including title, icon, and media data.
 type PlayerTrackRoles struct {
-	Path      string          `json:"path"`      // "playlists:item/{index}" when playing from queue (1-based)
-	ID        string          `json:"id"`        // Queue index as string (1-based) when playing from queue
+	Path      string          `json:"path"`      // "playlists:item/{id}" when playing from queue (internal item ID, not display index)
+	ID        string          `json:"id"`        // Internal item ID as string when playing from queue (not the display index)
 	Icon      string          `json:"icon"`      // URL to album art or track icon
 	MediaData PlayerMediaData `json:"mediaData"` // Detailed media information
 	Title     string          `json:"title"`     // Track title