Add provider search for Navidrome, Jellyfin, and Local

- Implement provider.Searcher on each: Subsonic search3 for Navidrome,
  /Items?searchTerm for Jellyfin, in-memory scan for Local playlists
- Wire Ctrl+F into the focusProvider key dispatcher and the Navidrome
  browser overlay so it works wherever the user is browsing
- Add S / L / R provider-switch shortcuts to focusProvider (matched J / N)
- Reorder overlay key dispatch so the search overlay claims keys above
  the nav browser
- Rename the search overlay title from "Spotify Search" to plain "Search"
- Tweak ColorKeyBG to use Accent instead of FG

Author: bjarneo

docs/keybindings.md

@@ -49,7 +49,7 @@ Press `Ctrl+K` in the player to see all keybindings.
 | Key | Action |
 |---|---|
 | `f` | Toggle bookmark ★ on selected track (or favorite radio station in radio browser) |
-| `Ctrl+F` | Search — active provider's native search (Spotify) or YouTube |
+| `Ctrl+F` | Search — active provider's native search (Spotify, Navidrome, Jellyfin, Plex, Local) or YouTube fallback. Available from playlist and provider-browser views. |
 | `u` | Load URL (stream/playlist) |
 | `y` | Show lyrics |
 | `Ctrl+S` | Save track to ~/Music |

external/jellyfin/client.go

@@ -9,6 +9,7 @@ import (
 	"net/url"
 	"path"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -372,6 +373,39 @@ func (c *Client) Tracks(albumID string) ([]Track, error) {
 	return out, nil
 }
 
+// Search searches the user's audio library for tracks matching query and
+// returns up to limit results.
+func (c *Client) Search(query string, limit int) ([]Track, error) {
+	userID, err := c.UserID()
+	if err != nil {
+		return nil, err
+	}
+	if limit <= 0 {
+		limit = 50
+	}
+
+	params := url.Values{
+		"userId":                 {userID},
+		"searchTerm":             {query},
+		"includeItemTypes":       {"Audio"},
+		"recursive":              {"true"},
+		"limit":                  {strconv.Itoa(limit)},
+		"fields":                 {"RunTimeTicks"},
+		"enableTotalRecordCount": {"false"},
+	}
+
+	var resp itemsResponseDTO
+	if err := c.get("/Items", params, &resp); err != nil {
+		return nil, err
+	}
+
+	out := make([]Track, 0, len(resp.Items))
+	for _, it := range resp.Items {
+		out = append(out, trackFromItem(it))
+	}
+	return out, nil
+}
+
 // IsStreamURL reports whether the given URL looks like a Jellyfin item download
 // endpoint. Used by the player to route these URLs through the buffered ffmpeg
 // pipeline instead of native HTTP streaming.

external/jellyfin/provider.go

@@ -1,6 +1,7 @@
 package jellyfin
 
 import (
+	"context"
 	"fmt"
 	"sync"
 	"time"
@@ -15,6 +16,7 @@ var (
 	_ provider.AlbumBrowser     = (*Provider)(nil)
 	_ provider.AlbumTrackLoader = (*Provider)(nil)
 	_ provider.PlaybackReporter = (*Provider)(nil)
+	_ provider.Searcher         = (*Provider)(nil)
 )
 
 // Provider implements playlist.Provider for a Jellyfin server.
@@ -117,6 +119,16 @@ func (p *Provider) Playlists() ([]playlist.PlaylistInfo, error) {
 	return out, nil
 }
 
+// SearchTracks searches the Jellyfin music library for tracks matching query.
+// Implements provider.Searcher.
+func (p *Provider) SearchTracks(_ context.Context, query string, limit int) ([]playlist.Track, error) {
+	jfTracks, err := p.client.Search(query, limit)
+	if err != nil {
+		return nil, err
+	}
+	return p.toPlaylistTracks(jfTracks), nil
+}
+
 // Tracks returns the tracks for one album item.
 // Results are cached per album id.
 func (p *Provider) Tracks(albumID string) ([]playlist.Track, error) {
@@ -134,6 +146,21 @@ func (p *Provider) Tracks(albumID string) ([]playlist.Track, error) {
 		return nil, err
 	}
 
+	out := p.toPlaylistTracks(jfTracks)
+
+	p.mu.Lock()
+	if p.trackCache == nil {
+		p.trackCache = make(map[string][]playlist.Track)
+	}
+	p.trackCache[albumID] = out
+	p.mu.Unlock()
+
+	return out, nil
+}
+
+// toPlaylistTracks converts Jellyfin Tracks to playlist.Tracks, attaching the
+// authenticated stream URL and Jellyfin item ID metadata.
+func (p *Provider) toPlaylistTracks(jfTracks []Track) []playlist.Track {
 	out := make([]playlist.Track, 0, len(jfTracks))
 	for _, t := range jfTracks {
 		out = append(out, playlist.Track{
@@ -148,13 +175,5 @@ func (p *Provider) Tracks(albumID string) ([]playlist.Track, error) {
 			ProviderMeta: map[string]string{provider.MetaJellyfinID: t.ID},
 		})
 	}
-
-	p.mu.Lock()
-	if p.trackCache == nil {
-		p.trackCache = make(map[string][]playlist.Track)
-	}
-	p.trackCache[albumID] = out
-	p.mu.Unlock()
-
-	return out, nil
+	return out
 }

external/local/provider.go

@@ -24,6 +24,7 @@ import (
 var (
 	_ provider.PlaylistWriter  = (*Provider)(nil)
 	_ provider.PlaylistDeleter = (*Provider)(nil)
+	_ provider.Searcher        = (*Provider)(nil)
 )
 
 // Provider reads and writes TOML-based playlists stored on disk.
@@ -225,6 +226,63 @@ func (p *Provider) AddTrackToPlaylist(_ context.Context, playlistID string, trac
 	return p.AddTrack(playlistID, track)
 }
 
+// SearchTracks does a case-insensitive substring search across every saved
+// playlist for tracks whose title, artist, or album match query. Returns up to
+// limit results (limit <= 0 means no cap). Implements provider.Searcher.
+func (p *Provider) SearchTracks(_ context.Context, query string, limit int) ([]playlist.Track, error) {
+	q := strings.ToLower(strings.TrimSpace(query))
+	if q == "" {
+		return nil, nil
+	}
+
+	entries, err := os.ReadDir(p.dir)
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var out []playlist.Track
+	seen := make(map[string]struct{})
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(strings.ToLower(e.Name()), ".toml") {
+			continue
+		}
+		tracks, err := p.loadTOML(filepath.Join(p.dir, e.Name()))
+		if err != nil {
+			continue
+		}
+		for _, t := range tracks {
+			if _, dup := seen[t.Path]; dup {
+				continue
+			}
+			if !trackMatches(t, q) {
+				continue
+			}
+			seen[t.Path] = struct{}{}
+			out = append(out, t)
+			if limit > 0 && len(out) >= limit {
+				return out, nil
+			}
+		}
+	}
+	return out, nil
+}
+
+func trackMatches(t playlist.Track, lowerQuery string) bool {
+	if strings.Contains(strings.ToLower(t.Title), lowerQuery) {
+		return true
+	}
+	if strings.Contains(strings.ToLower(t.Artist), lowerQuery) {
+		return true
+	}
+	if strings.Contains(strings.ToLower(t.Album), lowerQuery) {
+		return true
+	}
+	return false
+}
+
 // DeletePlaylist removes the TOML file for the named playlist.
 func (p *Provider) DeletePlaylist(name string) error {
 	path, err := p.safePath(name)

external/navidrome/client.go

@@ -1,6 +1,7 @@
 package navidrome
 
 import (
+	"context"
 	"crypto/md5"
 	"crypto/rand"
 	"encoding/hex"
@@ -10,6 +11,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -26,6 +28,7 @@ var (
 	_ provider.AlbumTrackLoader = (*NavidromeClient)(nil)
 	_ provider.AlbumSortSaver   = (*NavidromeClient)(nil)
 	_ provider.PlaybackReporter = (*NavidromeClient)(nil)
+	_ provider.Searcher         = (*NavidromeClient)(nil)
 )
 
 // httpClient is used for all Navidrome API calls with a finite timeout.
@@ -408,6 +411,35 @@ func (c *NavidromeClient) AlbumTracks(albumID string) ([]playlist.Track, error)
 	return tracks, nil
 }
 
+// SearchTracks searches the Subsonic library for songs matching query
+// using the search3.view endpoint. Implements provider.Searcher.
+func (c *NavidromeClient) SearchTracks(_ context.Context, query string, limit int) ([]playlist.Track, error) {
+	if limit <= 0 {
+		limit = 50
+	}
+	params := url.Values{
+		"query":       {query},
+		"songCount":   {strconv.Itoa(limit)},
+		"albumCount":  {"0"},
+		"artistCount": {"0"},
+	}
+	var result struct {
+		SubsonicResponse struct {
+			SearchResult3 struct {
+				Song []subsonicSong `json:"song"`
+			} `json:"searchResult3"`
+		} `json:"subsonic-response"`
+	}
+	if err := c.subsonicGet("search3", params, &result); err != nil {
+		return nil, err
+	}
+	tracks := make([]playlist.Track, 0, len(result.SubsonicResponse.SearchResult3.Song))
+	for _, s := range result.SubsonicResponse.SearchResult3.Song {
+		tracks = append(tracks, c.songToTrack(s))
+	}
+	return tracks, nil
+}
+
 // subsonicSong holds the common JSON fields returned by the Subsonic API
 // for tracks in both getPlaylist and getAlbum responses.
 type subsonicSong struct {

external/navidrome/client_test.go

@@ -107,6 +107,24 @@ func subsonicHandler(t *testing.T) http.HandlerFunc {
 					}
 				}
 			}`))
+		case strings.HasSuffix(path, "/rest/search3"):
+			w.Write([]byte(`{
+				"subsonic-response": {
+					"status": "ok",
+					"searchResult3": {
+						"song": [
+							{
+								"id":"song-1","title":"So What","artist":"Miles Davis",
+								"album":"Kind of Blue","year":1959,"track":1,"genre":"Jazz","duration":565
+							},
+							{
+								"id":"song-7","title":"What'd I Say","artist":"Ray Charles",
+								"album":"What'd I Say","year":1959,"track":1,"genre":"Soul","duration":380
+							}
+						]
+					}
+				}
+			}`))
 		case strings.HasSuffix(path, "/rest/scrobble"):
 			w.Write([]byte(`{"subsonic-response":{"status":"ok"}}`))
 		default:
@@ -320,6 +338,28 @@ func TestAlbumTracks(t *testing.T) {
 	}
 }
 
+func TestSearchTracks(t *testing.T) {
+	c, srv := newTestClient(t)
+	defer srv.Close()
+
+	tracks, err := c.SearchTracks(t.Context(), "what", 20)
+	if err != nil {
+		t.Fatalf("SearchTracks() error: %v", err)
+	}
+	if len(tracks) != 2 {
+		t.Fatalf("expected 2 tracks, got %d", len(tracks))
+	}
+	if tracks[0].Title != "So What" {
+		t.Errorf("tracks[0].Title = %q, want %q", tracks[0].Title, "So What")
+	}
+	if !tracks[0].Stream {
+		t.Error("tracks[0].Stream should be true")
+	}
+	if tracks[0].Meta(provider.MetaNavidromeID) != "song-1" {
+		t.Errorf("tracks[0] meta navidrome id = %q, want song-1", tracks[0].Meta(provider.MetaNavidromeID))
+	}
+}
+
 func TestSubsonicError(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")

site/index.html

@@ -1899,7 +1899,7 @@ <h3>Run the setup wizard</h3>
         <div class="keys-group-title">Search &amp; Browse</div>
         <div class="keys-group-body">
           <div class="key-row"><kbd>/</kbd><span>Search playlist</span></div>
-          <div class="key-row"><kbd>Ctrl+F</kbd><span>Search (active provider or YouTube)</span></div>
+          <div class="key-row"><kbd>Ctrl+F</kbd><span>Search active provider (Spotify, Navidrome, Jellyfin, Plex, Local) or YouTube fallback</span></div>
           <div class="key-row"><kbd>f</kbd><span>Toggle bookmark &#9733; / radio favorite</span></div>
           <div class="key-row"><kbd>u</kbd><span>Load URL (stream / playlist)</span></div>
           <div class="key-row"><kbd>o</kbd><span>Open file browser</span></div>