feat: wake speaker from standby when playing from queue (#30)

* feat: add seek command for jumping to position in tracks

Add new 'kefw2 seek <position>' command that allows jumping to a specific
position in the current track. Supports flexible time input formats:
- hh:mm:ss (e.g., 1:23:45)
- mm:ss (e.g., 5:30)
- seconds (e.g., 90)

Library changes:
- Add SeekTo(ctx, positionMS) method for programmatic seeking
- Add setActivateMap helper for player control commands with mixed types
- Add int64 type support to setTypedValue for i64_ values

The seek uses the player:player/control endpoint with the seekTime control,
matching the KEF Connect app's behavior.

* fix: improve airable browsing with multi-redirect support and caching

- GetRadioMenu/GetPodcastMenu now follow up to 5 redirects
- Fixed podcast entry point from ui:/airablefeeds to airable:linkService_airable.feeds
- GetRows() now uses cache when available for better performance

* Update year

* feat: wake speaker from standby when playing from queue

PlayOrResumeFromQueue now detects standby and automatically switches to
WiFi source, polls until the speaker is awake, then proceeds with normal
playback logic. The CLI play command allows standby through instead of
refusing, and prints a notice when the speaker was woken.

Also includes: AlbumsForArtist helper, goreleaser cask migration,
Airable redirect handling fixes, test improvements, and minor cleanups.

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

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023-2024 Jens Hilligsøe, https://github.com/hilli
+Copyright (c) 2023-2026 Jens Hilligsøe, https://github.com/hilli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

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