From 91aa1bd6a30e97745268632f226a594ac124adcc Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:05:56 +0200
Subject: [PATCH 01/10] spec: feature Music Search (Spotify + YouTube tabs)
 v1.8.1

---
 .../specs/2026-07-14-music-search-design.md   | 260 ++++++++++++++++++
 1 file changed, 260 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-07-14-music-search-design.md

diff --git a/docs/superpowers/specs/2026-07-14-music-search-design.md b/docs/superpowers/specs/2026-07-14-music-search-design.md
new file mode 100644
index 0000000..3ce331f
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-14-music-search-design.md
@@ -0,0 +1,260 @@
+# Music Search (Spotify + YouTube) — Design Spec
+
+- **Data:** 2026-07-14
+- **Autore:** LuZa + Claude
+- **Stato:** Approvato, pronto per implementation plan
+- **Target release:** MusicTools v1.8.1
+
+## Obiettivo
+
+Aggiungere due tab distinte all'app che permettano di **cercare brani/artisti/parole libere** e scaricarli:
+
+1. **Tab 🟢 Spotify** — ricerca via Spotify API (canonica, metadata pulita). Toggle "Solo artista" per ottenere tutta la discografia di un artista invece della ricerca libera.
+2. **Tab ▶ YouTube** — ricerca diretta via `yt-dlp ytsearch:` (grezza, senza distinzione artista/album, ma copre mix DJ, unreleased, bootleg, live, video-only content).
+
+Il download in entrambi i casi riusa la pipeline esistente (`start_tracks_download` in `api/bridge.py`) con licenza gate `_gate("audio")`.
+
+## Non-goals
+
+- Un'unica tab "Cerca" con radio Spotify/YouTube (scartato: UX molto diversa per le due sorgenti)
+- Ricerca combinata Spotify+YouTube in un'unica lista (nessuna deduplica cross-source affidabile)
+- Playlist temporanee salvabili
+- Preview audio
+- Filtri per genere/anno/BPM (non richiesto, YAGNI)
+- Ricerca album, artisti, playlist su Spotify (limitata a track)
+- Autocomplete / suggestions come digiti
+
+## Approcci scelti
+
+### Spotify
+
+- Free-form search: `GET /v1/search?q=<query>&type=track&limit=50`
+  - Ritorna fino a 50 track ordinati per rilevanza/popolarità (default Spotify)
+  - Query può essere qualsiasi cosa: titolo, artista, "artista - titolo", parola singola
+- Artist-mode (toggle attivo):
+  1. `GET /v1/search?q=<query>&type=artist&limit=5` → prendi il match con `name.lower() == query.lower()` altrimenti il più popolare
+  2. `GET /v1/artists/{id}/top-tracks?market=IT` → ~10 top track
+  3. `GET /v1/artists/{id}/albums?include_groups=album,single&limit=50&market=IT` → lista album
+  4. Per ogni album (max 50): `GET /v1/albums/{id}/tracks?limit=50` → tracce
+  5. Deduplica su `(name.lower().strip() + '|' + first_artist.lower().strip())`
+  6. Rate limit interno: `time.sleep(0.1)` tra chiamate `/albums/{id}/tracks`
+  7. Total: ~100-500 track per artista prolifico
+
+**Vantaggi:** metadata pulita, download pipeline già rodata (Spotify→YouTube via yt-dlp).
+
+### YouTube
+
+- `yt-dlp --flat-playlist --dump-single-json "ytsearch50:<query>"` → JSON con `entries[]`
+- Per ogni entry: `{title, uploader/channel, duration, id, url}`
+- Nessuna modalità artista (YouTube search non ha channel-exact disambiguation affidabile)
+
+**Vantaggi:** trova ciò che Spotify non ha (mix, unreleased, bootleg, live).
+
+## Architettura
+
+### Nuovi moduli / estensioni
+
+#### `core/spotify_client.py` (estensione)
+
+```python
+def search_tracks(token: str, query: str, limit: int = 50) -> list:
+    """Ricerca free-form. Ritorna list[dict] con {id, url, name, artists, album, duration_sec}."""
+
+def search_artist_discography(token: str, artist_name: str) -> list:
+    """Trova l'artista esatto e ritorna tutti i suoi brani (top tracks + tracce da album/singles).
+    Deduplica per (title, first_artist) normalizzato. Solleva ValueError se nessun artista trovato."""
+```
+
+Nota: la funzione `search_track` (singolare) aggiunta in Task 7 di Beatport resta com'è per retro-compatibilità. La nuova `search_tracks` (plurale, con limit) è quella usata da questa feature.
+
+#### `core/youtube_search.py` (nuovo)
+
+```python
+def search_youtube(query: str, limit: int = 50) -> list:
+    """Cerca su YouTube via `yt-dlp ytsearchN:query`.
+    Ritorna list[dict] con {id, url, title, channel, duration_sec}."""
+```
+
+Riusa `find_ytdlp()` e `subprocess_flags()` da `core/paths.py`. Timeout subprocess 30s.
+
+#### `api/bridge.py` — nuovi metodi
+
+- `spotify_search(query: str, artist_mode: bool) → dict` — salva query+toggle in config, poi chiama la funzione giusta e ritorna `{ok, tracks}` o `{ok:false, error, message}`
+- `spotify_search_download(tracks: list) → dict` — wrapper del pattern Beatport: converte in `[{name, artist}]` e chiama `start_tracks_download` con `subfolder="Spotify"`
+- `youtube_search(query: str) → dict` — salva query in config, chiama `core.youtube_search`, ritorna `{ok, tracks}`
+- `youtube_search_download(tracks: list) → dict` — chiama nuovo helper `start_urls_download` (see below) con URL YouTube e `subfolder="YouTube"`
+
+#### `api/bridge.py` — nuovo helper (se non c'è già)
+
+- `start_urls_download(payload: dict) → dict` — analogo a `start_tracks_download` ma accetta `{urls: [str], output_dir, subfolder}` e chiama `download_playlist_from_urls(urls, ...)` in `core/downloader.py`. Se non esiste una funzione equivalente in `downloader.py`, va aggiunta.
+
+  **Verifica in implementazione:** controlla se `download_playlist(tracks, ...)` può ricevere tracks contenenti solo `url` (bypass search); in tal caso riusa quella. Altrimenti aggiungi il nuovo path.
+
+### Frontend
+
+- 2 nuove tab in sidebar (`data-view="spotify"` e `data-view="youtube"`), entrambe con `data-feature="audio"` (stesso license gate del Beatport)
+- 2 nuove section `<section id="view-spotify">` e `<section id="view-youtube">` in `webui/index.html`
+- Modulo JS `SpotifyUI` e `YoutubeUI` in `webui/js/app.js`, entrambi con pattern init/loadResults/renderTable/updateSelection/startDownload (parallelo a `BeatportUI`)
+- Stili in `webui/css/style.css` — riusa `.beatport-table` come base, aggiunge varianti dove serve
+
+### Persistenza
+
+3 nuovi campi in `core/config.py::DEFAULTS`:
+- `spotify_search_last_query: str = ""`
+- `spotify_search_artist_mode: bool = False`
+- `youtube_search_last_query: str = ""`
+
+Salvati dal backend a ogni ricerca (analogo a `beatport_last_genre`).
+
+### Cartelle output
+
+- `{output_dir}/Spotify/` (piatta, nessun sub-folder per query)
+- `{output_dir}/YouTube/` (piatta)
+
+Sanitizzazione slash coerente con il pattern di `start_tracks_download` (subfolder singolo, no nested).
+
+## Data flow
+
+### Spotify search
+
+```
+[JS] User digita query, opzionale toggle "Solo artista", click Cerca
+  ↓
+[JS] api.spotify_search(query, artist_mode)
+  ↓
+[PY] api/bridge.py::spotify_search():
+    ├─ Salva {spotify_search_last_query, spotify_search_artist_mode} in config
+    ├─ Verifica creds Spotify (client_id, client_secret) → altrimenti {ok:false, error:"no_creds"}
+    ├─ Get token (spotify_client.get_access_token)
+    ├─ Se artist_mode:
+    │   └─ spotify_client.search_artist_discography(token, query)
+    ├─ Altrimenti:
+    │   └─ spotify_client.search_tracks(token, query, limit=50)
+    └─ Ritorna {ok:True, tracks: [...]}
+  ↓
+[JS] Riceve lista, chiama api.spotify_check_existing() per pre-deselezionare i già-scaricati
+  ↓
+[JS] Renderizza tabella (colonne: check, #, artista, titolo, album, durata, stato)
+  ↓
+[JS] User seleziona, click "Scarica selezionati"
+  ↓
+[JS] api.spotify_search_download(tracks_selected)
+  ↓
+[PY] converte in [{name, artist}] e chiama self.start_tracks_download({..., subfolder: "Spotify"})
+  ↓
+[EXISTING] pipeline yt-dlp, log/progress su canale "download"
+```
+
+### YouTube search
+
+```
+[JS] User digita query, click Cerca
+  ↓
+[JS] api.youtube_search(query)
+  ↓
+[PY] api/bridge.py::youtube_search():
+    ├─ Salva youtube_search_last_query in config
+    ├─ core.youtube_search.search_youtube(query, limit=50)
+    │   └─ subprocess: yt-dlp --flat-playlist --dump-single-json "ytsearch50:<query>"
+    └─ Ritorna {ok:True, tracks: [{id, url, title, channel, duration_sec}, ...]}
+  ↓
+[JS] Renderizza tabella (colonne: check, #, titolo video, canale, durata, stato)
+  ↓
+[JS] User seleziona, click "Scarica selezionati"
+  ↓
+[JS] api.youtube_search_download(tracks_selected)  # passa URL, non {name,artist}
+  ↓
+[PY] start_urls_download({urls, subfolder: "YouTube"})
+  ↓
+[EXISTING] pipeline yt-dlp diretto sugli URL
+```
+
+## Matrice errori & recovery
+
+| Errore | Dove | Comportamento |
+|---|---|---|
+| Query vuota | UI JS | Bottone "Cerca" disabilitato, nessuna richiesta |
+| Creds Spotify mancanti | spotify_search | `{ok:false, error:"no_creds"}` → banner giallo con link Impostazioni |
+| Spotify 401 (token scaduto/invalid) | get_access_token | Refresh token nel handler; se persiste, banner rosso |
+| Spotify 429 rate limit | search endpoint | `{ok:false, error:"rate_limit", message:"Attendi qualche secondo"}` → banner arancione, retry manuale |
+| Spotify 5xx | search endpoint | `{ok:false, error:"server", message:...}` → banner rosso, retry |
+| Nessun risultato Spotify | search endpoint | `{ok:true, tracks:[]}` → messaggio grigio "Nessun brano trovato per '<query>'" |
+| Artist-mode senza match esatto | search_artist_discography | Solleva ValueError → `{ok:false, error:"artist_not_found", message:"Artista '<q>' non trovato — disattiva toggle per ricerca libera"}` |
+| yt-dlp non trovato | search_youtube | RuntimeError → banner rosso "yt-dlp non installato" |
+| yt-dlp timeout (rete lenta) | search_youtube | subprocess.TimeoutExpired → banner rosso "Timeout ricerca YouTube" |
+| yt-dlp errore generico | search_youtube | Non-zero exit → banner rosso con stderr tail |
+| Nessun risultato YouTube | search_youtube | `{ok:true, tracks:[]}` → messaggio grigio |
+| User preme Stop durante download | download pipeline | Comportamento invariato (esistente) |
+
+## Licenza / piani
+
+Entrambe le tab sono audio download → gate `_gate("audio")` automatico via `start_tracks_download` / `start_urls_download`. Il `daily_limit` del piano si applica. Nessuna nuova feature-flag.
+
+## Testing
+
+### Unit tests
+
+**`tests/test_spotify_client.py` (estensione):**
+- `test_search_tracks_returns_list_up_to_limit` — mock response con 50 items, verifica list length
+- `test_search_tracks_maps_fields_correctly` — sample dict → verifica keys {id, url, name, artists, album, duration_sec}
+- `test_search_tracks_empty_query_returns_empty` — mock 0 items
+- `test_search_artist_discography_exact_match_wins` — mock search artist con 3 candidati diversi, verifica quello esatto (case-insensitive)
+- `test_search_artist_discography_top_tracks_and_albums_combined` — mock 3 endpoint, verifica deduplica
+- `test_search_artist_discography_raises_when_no_match` — mock search artist con 0 risultati → ValueError
+- `test_search_artist_discography_deduplicates` — mock top-tracks e album-tracks con overlap → verifica no duplicati
+
+**`tests/test_youtube_search.py` (nuovo):**
+- `test_search_youtube_parses_entries` — mock `subprocess.run` con JSON stub (5 entries), verifica list mapping
+- `test_search_youtube_empty_result` — mock JSON senza entries → []
+- `test_search_youtube_ytdlp_not_found` — mock `find_ytdlp` che ritorna None → RuntimeError
+- `test_search_youtube_timeout` — mock subprocess.TimeoutExpired → RuntimeError
+
+### Test manuale end-to-end
+
+**Tab Spotify:**
+1. Query semplice: "Solomun" senza toggle → 50 risultati, ordinati per rilevanza
+2. Query composta: "Kapuchon Hot Sauce" → 5-10 risultati pertinenti
+3. Artist mode: "Solomun" con toggle attivo → 100-300 risultati (top tracks + tutti album)
+4. Artist mode con nome inesistente: "sadgjhkasdg" → banner "Artista non trovato"
+5. Download di 3 brani → file in `MUSICA/Spotify/`
+6. Ricerca ripetuta → "già scaricato" mostrato correttamente
+7. Riavvio app → ultima query + toggle ricordati
+
+**Tab YouTube:**
+1. Query: "Kapuchon Hot Sauce" → 50 risultati con canali diversi
+2. Query set DJ: "Solomun Cocoricò 2024" → set lunghi (60+ min) in lista
+3. Download di 2 brani → file in `MUSICA/YouTube/`
+4. Query vuota → bottone disabilitato
+5. Riavvio → ultima query ricordata
+
+## Rollout
+
+1. Branch `feat/music-search`
+2. Bump `core/config.py::VERSION` → `v1.8.1`
+3. Note release `/tmp/notes-v1.8.1.md`:
+   > **Nuove tab Spotify e YouTube 🔎** — cerca brani per titolo o artista su Spotify (con toggle "solo artista" per scaricare tutta la discografia), oppure cerca su YouTube per trovare mix DJ, unreleased, bootleg e brani non presenti su Spotify.
+4. Commit + tag `v1.8.1` → CI + release notes background task
+5. Update DB `releases` tabella sul server (macos + windows rows)
+
+Zero cambi server-side backend, zero migration.
+
+## Struttura file impattati
+
+**Nuovi:**
+- `core/youtube_search.py`
+- `tests/test_youtube_search.py`
+
+**Modificati:**
+- `core/spotify_client.py` — 2 nuove funzioni pubbliche (`search_tracks`, `search_artist_discography`)
+- `core/downloader.py` — se serve, aggiunta `download_playlist_from_urls()` per il flusso YouTube
+- `core/config.py` — VERSION bump + 3 nuovi campi in DEFAULTS
+- `api/bridge.py` — 6 nuovi metodi Api: `spotify_search`, `spotify_check_existing`, `spotify_search_download`, `youtube_search`, `youtube_check_existing`, `youtube_search_download` + eventuale helper `start_urls_download`
+- `tests/test_spotify_client.py` — 7 nuovi test
+- `webui/index.html` — 2 nav-item + 2 sezioni view
+- `webui/js/app.js` — moduli `SpotifyUI` e `YoutubeUI` (~200 righe cadauno, parallelo a `BeatportUI`)
+- `webui/css/style.css` — piccole estensioni (o riuso classi Beatport)
+- `requirements.txt` — nessuna nuova dep
+
+## Riduzione della duplicazione
+
+Se durante l'implementazione emerge che i 3 pannelli (Beatport, Spotify, YouTube) hanno logica JS quasi identica (renderTable con checkbox, updateSelectionCount, startDownload wrapper), **valuta** l'estrazione di un `SelectableTracksTable` component in `webui/js/app.js`. Se l'astrazione è chiara e riduce codice significativamente, fallo. Se costringe a hooks/callbacks tortuosi per gestire differenze di colonne, lascia stare — 3 istanze non sono tante e YAGNI.

From 58d4896ffe3b0f52745fee090b69ea5692a37d96 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:11:13 +0200
Subject: [PATCH 02/10] plan: implementation Music Search (Spotify + YouTube)
 v1.8.1

---
 .../plans/2026-07-14-music-search.md          | 1747 +++++++++++++++++
 1 file changed, 1747 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-14-music-search.md

diff --git a/docs/superpowers/plans/2026-07-14-music-search.md b/docs/superpowers/plans/2026-07-14-music-search.md
new file mode 100644
index 0000000..f5dbc9c
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-14-music-search.md
@@ -0,0 +1,1747 @@
+# Music Search (Spotify + YouTube) Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 2 nuove tab in MusicTools ("🟢 Spotify" e "▶ YouTube") per cercare brani per titolo/artista e scaricarli. Spotify ha toggle "Solo artista" per discografia completa. YouTube è per mix DJ/unreleased/bootleg che Spotify non ha.
+
+**Architecture:** Estensione `core/spotify_client.py` + nuovo `core/youtube_search.py` + 6 metodi in `api/bridge.py` + 2 tab UI in `webui/`. Riuso completo del pipeline download esistente (`start_tracks_download` per Spotify, nuovo `start_urls_download` per YouTube). Zero cambi server.
+
+**Tech Stack:** Python 3.8+ (con `from __future__ import annotations`), `requests` (già in deps), `yt-dlp` via subprocess (già in bundle). `pytest` + `responses` + `unittest.mock` per test. Vanilla JS + HTML/CSS lato UI.
+
+**Spec:** `docs/superpowers/specs/2026-07-14-music-search-design.md`
+
+---
+
+## Note operative
+
+- **Branch:** `feat/music-search` (già creato, HEAD: `91aa1bd`)
+- **Git author:** ogni commit deve usare `git -c user.email=info@djluza.com commit ...`
+- **Test:** riusare pattern e infra dei test Beatport (`tests/`, `pytest`)
+- **Python 3.8 compat:** ogni nuovo file `.py` inizia con `from __future__ import annotations`
+- **Non toccare:** `server/`, `landing/`, `build_macos.py`, `build_windows.py`
+
+---
+
+## Task 1: `search_tracks(token, query, limit)` — TDD
+
+**Files:**
+- Modify: `core/spotify_client.py`
+- Modify: `tests/test_spotify_client.py`
+
+- [ ] **Step 1: Aggiungi test in `tests/test_spotify_client.py`**
+
+Aggiungi in fondo al file:
+
+```python
+class TestSearchTracks:
+    @responses.activate
+    def test_returns_list_of_tracks(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={
+                "tracks": {
+                    "items": [
+                        {
+                            "id": f"id{i}",
+                            "name": f"Track {i}",
+                            "artists": [{"name": "Solomun"}],
+                            "album": {"name": "Album X"},
+                            "duration_ms": 300000 + i * 1000,
+                            "external_urls": {"spotify": f"https://open.spotify.com/track/id{i}"},
+                        }
+                        for i in range(50)
+                    ]
+                }
+            },
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "solomun", limit=50)
+        assert isinstance(result, list)
+        assert len(result) == 50
+        first = result[0]
+        assert first["id"] == "id0"
+        assert first["name"] == "Track 0"
+        assert first["artists"] == "Solomun"
+        assert first["album"] == "Album X"
+        assert first["duration_sec"] == 300
+        assert first["url"] == "https://open.spotify.com/track/id0"
+
+    @responses.activate
+    def test_multiple_artists_joined_with_comma(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": [{
+                "id": "x", "name": "n",
+                "artists": [{"name": "A"}, {"name": "B"}, {"name": "C"}],
+                "album": {"name": "Alb"},
+                "duration_ms": 60000,
+                "external_urls": {"spotify": "u"},
+            }]}},
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "q", limit=1)
+        assert result[0]["artists"] == "A, B, C"
+
+    @responses.activate
+    def test_empty_query_returns_empty_list(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": []}},
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "no-match", limit=50)
+        assert result == []
+
+    @responses.activate
+    def test_query_params_include_limit(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": []}},
+            status=200,
+        )
+        spotify_client.search_tracks("t", "q", limit=25)
+        params = responses.calls[0].request.params
+        assert params["q"] == "q"
+        assert params["type"] == "track"
+        assert params["limit"] == "25"
+```
+
+- [ ] **Step 2: Verifica fail**
+Run: `python3 -m pytest tests/test_spotify_client.py::TestSearchTracks -v`
+Expected: FAIL con `AttributeError: module 'core.spotify_client' has no attribute 'search_tracks'`
+
+- [ ] **Step 3: Aggiungi `search_tracks` a `core/spotify_client.py`**
+
+Aggiungi in fondo al file (dopo `search_track`):
+
+```python
+def search_tracks(token: str, query: str, limit: int = 50) -> list:
+    """Cerca brani su Spotify e ritorna una lista di dict.
+
+    Args:
+        token: access token Spotify
+        query: query libera (titolo, artista, misto)
+        limit: max risultati (Spotify cap = 50)
+
+    Returns:
+        list[dict] con {id, url, name, artists, album, duration_sec}. Vuota se nessun match.
+    """
+    resp = requests.get(
+        "https://api.spotify.com/v1/search",
+        headers={"Authorization": f"Bearer {token}"},
+        params={"q": query, "type": "track", "limit": min(limit, 50)},
+        timeout=15,
+    )
+    resp.raise_for_status()
+    items = resp.json().get("tracks", {}).get("items", [])
+    return [_track_to_dict(t) for t in items]
+
+
+def _track_to_dict(t: dict) -> dict:
+    """Mappa il track object Spotify sul nostro schema uniforme."""
+    return {
+        "id": t.get("id", ""),
+        "url": t.get("external_urls", {}).get("spotify", ""),
+        "name": t.get("name", ""),
+        "artists": ", ".join(a.get("name", "") for a in t.get("artists", [])),
+        "album": t.get("album", {}).get("name", ""),
+        "duration_sec": int(t.get("duration_ms", 0)) // 1000,
+    }
+```
+
+- [ ] **Step 4: Verifica**
+Run: `python3 -m pytest tests/test_spotify_client.py -v`
+Expected: 8 test PASS (4 existing + 4 new)
+
+- [ ] **Step 5: Commit**
+```bash
+git add core/spotify_client.py tests/test_spotify_client.py
+git -c user.email=info@djluza.com commit -m "spotify: search_tracks() free-form con limit configurabile"
+```
+
+---
+
+## Task 2: `search_artist_discography(token, artist_name)` — TDD
+
+**Files:**
+- Modify: `core/spotify_client.py`
+- Modify: `tests/test_spotify_client.py`
+
+- [ ] **Step 1: Test in `tests/test_spotify_client.py`**
+
+Aggiungi in fondo:
+
+```python
+class TestSearchArtistDiscography:
+    @responses.activate
+    def test_exact_name_match_beats_popular(self):
+        # 3 candidati: uno esatto (case-insensitive), altri popolari
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [
+                {"id": "pop", "name": "Solomun Tribute", "popularity": 90},
+                {"id": "exact", "name": "SOLOMUN", "popularity": 60},
+                {"id": "unrelated", "name": "Other", "popularity": 70},
+            ]}},
+            status=200,
+        )
+        # Mock top-tracks vuoto per non allungare il test
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/exact/top-tracks",
+            json={"tracks": []},
+            status=200,
+        )
+        # Mock albums vuoto
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/exact/albums",
+            json={"items": []},
+            status=200,
+        )
+        result = spotify_client.search_artist_discography("t", "Solomun")
+        assert result == []
+        # Verifica che sia stato chiamato l'artista "exact", non "pop"
+        top_tracks_calls = [c for c in responses.calls if "/top-tracks" in c.request.url]
+        assert len(top_tracks_calls) == 1
+        assert "/exact/top-tracks" in top_tracks_calls[0].request.url
+
+    @responses.activate
+    def test_falls_back_to_most_popular_if_no_exact_match(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [
+                {"id": "a1", "name": "Solomun Fanpage", "popularity": 30},
+                {"id": "a2", "name": "Solomun Live", "popularity": 80},
+            ]}},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/a2/top-tracks",
+            json={"tracks": []},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/a2/albums",
+            json={"items": []},
+            status=200,
+        )
+        spotify_client.search_artist_discography("t", "solomun")
+        top_tracks_calls = [c for c in responses.calls if "/top-tracks" in c.request.url]
+        assert "/a2/top-tracks" in top_tracks_calls[0].request.url
+
+    @responses.activate
+    def test_raises_when_no_artist_found(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": []}},
+            status=200,
+        )
+        with pytest.raises(ValueError, match="Artista"):
+            spotify_client.search_artist_discography("t", "asdgjhkasdgj")
+
+    @responses.activate
+    def test_combines_top_tracks_and_album_tracks(self):
+        # 1 artista esatto
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [{"id": "artX", "name": "artX", "popularity": 50}]}},
+            status=200,
+        )
+        # 3 top-tracks
+        top_tracks_data = {"tracks": [
+            {
+                "id": f"t{i}", "name": f"Top{i}",
+                "artists": [{"name": "artX"}],
+                "album": {"name": "AlbTop"},
+                "duration_ms": 200000,
+                "external_urls": {"spotify": f"u{i}"},
+            } for i in range(3)
+        ]}
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/artX/top-tracks",
+            json=top_tracks_data,
+            status=200,
+        )
+        # 2 album
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/artX/albums",
+            json={"items": [
+                {"id": "alb1", "name": "Album 1"},
+                {"id": "alb2", "name": "Album 2"},
+            ]},
+            status=200,
+        )
+        # album 1: 2 tracce
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb1/tracks",
+            json={"items": [
+                {
+                    "id": f"a1t{i}", "name": f"Alb1Track{i}",
+                    "artists": [{"name": "artX"}],
+                    "duration_ms": 180000,
+                    "external_urls": {"spotify": f"a1u{i}"},
+                } for i in range(2)
+            ]},
+            status=200,
+        )
+        # album 2: 1 traccia
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb2/tracks",
+            json={"items": [
+                {
+                    "id": "a2t0", "name": "Alb2Track0",
+                    "artists": [{"name": "artX"}],
+                    "duration_ms": 240000,
+                    "external_urls": {"spotify": "a2u0"},
+                }
+            ]},
+            status=200,
+        )
+        with patch("core.spotify_client.time.sleep"):  # no wait
+            result = spotify_client.search_artist_discography("t", "artX")
+        # 3 top + 2 alb1 + 1 alb2 = 6
+        assert len(result) == 6
+        titles = {r["name"] for r in result}
+        assert "Top0" in titles
+        assert "Alb1Track0" in titles
+        assert "Alb2Track0" in titles
+
+    @responses.activate
+    def test_dedupe_across_top_and_album(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [{"id": "aX", "name": "aX", "popularity": 50}]}},
+            status=200,
+        )
+        # Stesso track name+artist in top-tracks e in album (id diverso)
+        common = {
+            "name": "Same Song",
+            "artists": [{"name": "aX"}],
+            "album": {"name": "OG Album"},
+            "duration_ms": 200000,
+            "external_urls": {"spotify": "u"},
+        }
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/aX/top-tracks",
+            json={"tracks": [{**common, "id": "top-id"}]},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/aX/albums",
+            json={"items": [{"id": "alb", "name": "OG"}]},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb/tracks",
+            json={"items": [{**common, "id": "alb-id"}]},
+            status=200,
+        )
+        with patch("core.spotify_client.time.sleep"):
+            result = spotify_client.search_artist_discography("t", "aX")
+        assert len(result) == 1
+```
+
+Aggiungi import in cima al file test (se non presente):
+```python
+from unittest.mock import patch
+```
+
+- [ ] **Step 2: Verifica fail**
+Run: `python3 -m pytest tests/test_spotify_client.py::TestSearchArtistDiscography -v`
+Expected: FAIL
+
+- [ ] **Step 3: Implementa `search_artist_discography` in `core/spotify_client.py`**
+
+Aggiungi in cima al file (se non presente):
+```python
+import time
+```
+
+Poi in fondo al file:
+
+```python
+def search_artist_discography(token: str, artist_name: str) -> list:
+    """Trova l'artista esatto (o il più popolare tra i match) e ritorna
+    tutti i suoi brani: top tracks + tracce di ogni album/single.
+    Deduplica per (name.lower().strip(), first_artist.lower().strip()).
+
+    Raises:
+        ValueError: se nessun artista trovato per il nome dato.
+    """
+    headers = {"Authorization": f"Bearer {token}"}
+
+    # 1. Cerca artista
+    resp = requests.get(
+        "https://api.spotify.com/v1/search",
+        headers=headers,
+        params={"q": artist_name, "type": "artist", "limit": 5},
+        timeout=15,
+    )
+    resp.raise_for_status()
+    candidates = resp.json().get("artists", {}).get("items", [])
+    if not candidates:
+        raise ValueError(f"Artista '{artist_name}' non trovato")
+
+    # Match esatto (case-insensitive) se possibile, altrimenti più popolare
+    query_lower = artist_name.lower().strip()
+    exact = [c for c in candidates if c.get("name", "").lower().strip() == query_lower]
+    if exact:
+        artist = exact[0]
+    else:
+        artist = max(candidates, key=lambda c: c.get("popularity", 0))
+    artist_id = artist["id"]
+
+    collected: list = []
+
+    # 2. Top tracks
+    r_top = requests.get(
+        f"https://api.spotify.com/v1/artists/{artist_id}/top-tracks",
+        headers=headers,
+        params={"market": "IT"},
+        timeout=15,
+    )
+    r_top.raise_for_status()
+    for t in r_top.json().get("tracks", []):
+        collected.append(_track_to_dict(t))
+
+    # 3. Albums (album + single)
+    r_alb = requests.get(
+        f"https://api.spotify.com/v1/artists/{artist_id}/albums",
+        headers=headers,
+        params={"include_groups": "album,single", "limit": 50, "market": "IT"},
+        timeout=15,
+    )
+    r_alb.raise_for_status()
+    albums = r_alb.json().get("items", [])
+
+    # 4. Per ogni album, tracce (album/track object non ha "album" sub-field,
+    # gliela aggiungiamo esplicitamente)
+    for alb in albums:
+        alb_id = alb.get("id")
+        alb_name = alb.get("name", "")
+        if not alb_id:
+            continue
+        time.sleep(0.1)  # rate limit interno
+        r_at = requests.get(
+            f"https://api.spotify.com/v1/albums/{alb_id}/tracks",
+            headers=headers,
+            params={"limit": 50},
+            timeout=15,
+        )
+        r_at.raise_for_status()
+        for t in r_at.json().get("items", []):
+            t = dict(t)
+            # Album tracks non hanno "album" nested; iniettiamo il nome
+            t.setdefault("album", {"name": alb_name})
+            collected.append(_track_to_dict(t))
+
+    # 5. Dedupe
+    seen: set = set()
+    unique: list = []
+    for t in collected:
+        key = (t["name"].lower().strip(), t["artists"].split(",")[0].lower().strip())
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(t)
+    return unique
+```
+
+- [ ] **Step 4: Verifica**
+Run: `python3 -m pytest tests/test_spotify_client.py -v`
+Expected: 13 test PASS (4 preesistenti + 4 search_tracks + 5 search_artist_discography)
+
+- [ ] **Step 5: Commit**
+```bash
+git add core/spotify_client.py tests/test_spotify_client.py
+git -c user.email=info@djluza.com commit -m "spotify: search_artist_discography con dedupe top-tracks+album"
+```
+
+---
+
+## Task 3: `core/youtube_search.py` — TDD
+
+**Files:**
+- Create: `core/youtube_search.py`
+- Create: `tests/test_youtube_search.py`
+
+- [ ] **Step 1: Test in `tests/test_youtube_search.py`**
+
+Crea il file:
+
+```python
+"""Test per core.youtube_search."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+from core import youtube_search
+
+
+def _mock_ytdlp_result(entries: list) -> MagicMock:
+    """Mock subprocess.CompletedProcess con JSON stub."""
+    result = MagicMock()
+    result.returncode = 0
+    result.stdout = json.dumps({"entries": entries})
+    result.stderr = ""
+    return result
+
+
+class TestSearchYoutube:
+    def test_parses_entries(self):
+        entries = [
+            {
+                "id": "abc123",
+                "url": "https://www.youtube.com/watch?v=abc123",
+                "title": "Kapuchon - Hot Sauce (Official Video)",
+                "uploader": "Kapuchon Official",
+                "duration": 336,
+            },
+            {
+                "id": "def456",
+                "url": "https://www.youtube.com/watch?v=def456",
+                "title": "Solomun @ Cocoricò 2024",
+                "uploader": "Cocoricò",
+                "duration": 3600,
+            },
+        ]
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result(entries)):
+            result = youtube_search.search_youtube("kapuchon hot sauce", limit=50)
+        assert len(result) == 2
+        assert result[0]["title"] == "Kapuchon - Hot Sauce (Official Video)"
+        assert result[0]["channel"] == "Kapuchon Official"
+        assert result[0]["duration_sec"] == 336
+        assert result[0]["url"] == "https://www.youtube.com/watch?v=abc123"
+
+    def test_empty_entries_returns_empty(self):
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result([])):
+            result = youtube_search.search_youtube("no-match", limit=50)
+        assert result == []
+
+    def test_raises_when_ytdlp_missing(self):
+        with patch("core.youtube_search.find_ytdlp", return_value=None):
+            with pytest.raises(RuntimeError, match="yt-dlp"):
+                youtube_search.search_youtube("q", limit=50)
+
+    def test_command_uses_ytsearch_with_limit(self):
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result([])) as mock_run:
+            youtube_search.search_youtube("solomun", limit=30)
+        args = mock_run.call_args.args[0]  # positional list
+        assert args[0] == "/fake/yt-dlp"
+        # Trova l'argomento ytsearchN:query
+        search_arg = [a for a in args if a.startswith("ytsearch")]
+        assert search_arg == ["ytsearch30:solomun"]
+
+    def test_timeout_raises_runtime_error(self):
+        import subprocess as sp
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", side_effect=sp.TimeoutExpired("yt-dlp", 30)):
+            with pytest.raises(RuntimeError, match="[Tt]imeout"):
+                youtube_search.search_youtube("q", limit=50)
+
+    def test_nonzero_exit_raises(self):
+        bad = MagicMock()
+        bad.returncode = 1
+        bad.stdout = ""
+        bad.stderr = "some yt-dlp error"
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=bad):
+            with pytest.raises(RuntimeError, match="yt-dlp"):
+                youtube_search.search_youtube("q", limit=50)
+```
+
+- [ ] **Step 2: Verifica fail**
+Run: `python3 -m pytest tests/test_youtube_search.py -v`
+Expected: FAIL con `ModuleNotFoundError: No module named 'core.youtube_search'`
+
+- [ ] **Step 3: Implementa `core/youtube_search.py`**
+
+Crea:
+
+```python
+"""Ricerca su YouTube via yt-dlp (subprocess, flat playlist metadata)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+
+from core.paths import find_ytdlp, subprocess_flags
+
+
+_TIMEOUT_SEC = 30
+
+
+def search_youtube(query: str, limit: int = 50) -> list:
+    """Cerca su YouTube (ytsearchN:query) e ritorna metadata "flat" (senza scaricare).
+
+    Args:
+        query: testo di ricerca libero
+        limit: numero massimo di risultati (default 50)
+
+    Returns:
+        list[dict] con {id, url, title, channel, duration_sec}. Vuota se nessun match.
+
+    Raises:
+        RuntimeError: se yt-dlp non disponibile, timeout, o exit non-zero.
+    """
+    ytdlp = find_ytdlp()
+    if not ytdlp:
+        raise RuntimeError("yt-dlp non trovato nel bundle / PATH")
+
+    cmd = [
+        ytdlp,
+        "--flat-playlist",
+        "--dump-single-json",
+        "--no-warnings",
+        f"ytsearch{limit}:{query}",
+    ]
+    try:
+        proc = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SEC,
+            **subprocess_flags(),
+        )
+    except subprocess.TimeoutExpired as e:
+        raise RuntimeError(f"Timeout ricerca YouTube ({_TIMEOUT_SEC}s)") from e
+
+    if proc.returncode != 0:
+        tail = (proc.stderr or "").strip().splitlines()[-3:]
+        raise RuntimeError(f"yt-dlp error: {' | '.join(tail) or 'unknown'}")
+
+    try:
+        data = json.loads(proc.stdout)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"yt-dlp output non-JSON: {e}") from e
+
+    entries = data.get("entries") or []
+    result: list = []
+    for e in entries:
+        if not isinstance(e, dict):
+            continue
+        video_id = e.get("id") or ""
+        url = e.get("url") or (f"https://www.youtube.com/watch?v={video_id}" if video_id else "")
+        result.append({
+            "id": video_id,
+            "url": url,
+            "title": e.get("title") or "",
+            "channel": e.get("uploader") or e.get("channel") or "",
+            "duration_sec": int(e.get("duration") or 0),
+        })
+    return result
+```
+
+**Nota:** `subprocess_flags()` è un helper esistente in `core/paths.py` che restituisce kwargs come `creationflags` su Windows per nascondere la console. Verifica: `grep subprocess_flags core/paths.py`. Se firma diversa, adatta.
+
+- [ ] **Step 4: Verifica**
+Run: `python3 -m pytest tests/test_youtube_search.py -v`
+Expected: 6 test PASS
+
+- [ ] **Step 5: Commit**
+```bash
+git add core/youtube_search.py tests/test_youtube_search.py
+git -c user.email=info@djluza.com commit -m "youtube: search_youtube via yt-dlp ytsearchN + parse JSON"
+```
+
+---
+
+## Task 4: Downloader supporto URL diretti + helper bridge
+
+**Files:**
+- Modify: `core/downloader.py` (potenzialmente — verifica prima)
+- Modify: `api/bridge.py` (aggiunta helper)
+
+- [ ] **Step 1: Verifica se `download_playlist` accetta già URL diretti**
+
+Ispeziona `core/downloader.py`:
+```bash
+sed -n '118,200p' core/downloader.py
+```
+
+Cerca: la funzione fa `_search_youtube(query, ...)` per ogni track. Se accetta come input `[{url: "https://..."}]` e salta la search quando `url` è presente, riusiamo. Altrimenti dobbiamo aggiungere una funzione parallela.
+
+- [ ] **Step 2A (se `download_playlist` NON supporta URL diretti): aggiungi `download_urls`**
+
+In `core/downloader.py`, aggiungi in fondo:
+
+```python
+def download_urls(
+    urls: list,
+    titles: list,
+    output_dir: str,
+    bitrate: str = "320K",
+    cookies_path: str = None,
+    progress_callback=None,
+) -> None:
+    """Scarica direttamente da URL YouTube (bypassa search).
+
+    Args:
+        urls: lista URL YouTube (parallela a titles)
+        titles: lista titoli video (per logging/dedupe)
+        output_dir: cartella destinazione
+        bitrate: qualita audio (default 320K)
+        cookies_path: file cookies opzionale
+        progress_callback: callback(idx, total, title, status, pct)
+    """
+    from pathlib import Path
+    reset_stop()
+    total = len(urls)
+    out_path = Path(output_dir)
+    out_path.mkdir(parents=True, exist_ok=True)
+    done_file = out_path / ".downloaded_tracks"
+    done_set = _load_done_set(done_file)
+    ytdlp = find_ytdlp()
+
+    for i, (url, title) in enumerate(zip(urls, titles)):
+        if is_stopped():
+            if progress_callback:
+                progress_callback(i, total, "", "stopped", 0)
+            return
+
+        key = title or url
+        if key in done_set:
+            if progress_callback:
+                progress_callback(i, total, key, "skipped", 100)
+            continue
+
+        if progress_callback:
+            progress_callback(i, total, key, "downloading", 0)
+
+        # Riusa la stessa logica di download del pipeline esistente
+        # (chiama il worker download interno o replica i flag yt-dlp).
+        # Vedi `_download_single_url` in questo file oppure la funzione
+        # equivalente usata da download_playlist.
+        try:
+            _download_single_url(ytdlp, url, str(out_path), bitrate, cookies_path)
+            _mark_done(done_file, key)
+            if progress_callback:
+                progress_callback(i, total, key, "done", 100)
+        except Exception as e:
+            if progress_callback:
+                progress_callback(i, total, key, f"error: {e}", 0)
+
+    if progress_callback:
+        progress_callback(total, total, "", "completed", 100)
+```
+
+**Nota:** `_download_single_url` non esiste ancora — devi identificare la funzione interna che `download_playlist` chiama per il singolo download e (a) esporla come helper riusabile, oppure (b) estrarla in una nuova funzione. Ispeziona il corpo di `download_playlist` (righe 143+) per vedere il codice che va estratto.
+
+**Alternativa più semplice:** invece di estrarre, chiama direttamente `subprocess.run([ytdlp, "-x", "--audio-format", "mp3", "--audio-quality", bitrate, "-o", <template>, url], ...)` con lo stesso set di flag usato da `download_playlist`. Copia i flag da lì.
+
+- [ ] **Step 2B (se `download_playlist` supporta già URL diretti): salta Step 2A e passa a Step 3**
+
+- [ ] **Step 3: Aggiungi helper `start_urls_download` a `api/bridge.py`**
+
+Trova il metodo `start_tracks_download` (linea ~511) e aggiungi subito dopo:
+
+```python
+    def start_urls_download(self, payload: dict) -> dict:
+        """Analogo a start_tracks_download ma accetta {urls, titles, output_dir, subfolder}.
+        Usato dal flusso YouTube search (URL già noti, no search)."""
+        if self._any_job_running():
+            return {"ok": False, "error": "Un download gia in corso"}
+
+        urls = payload.get("urls") or []
+        titles = payload.get("titles") or []
+        output_dir = (payload.get("output_dir") or "").strip()
+        subfolder = (payload.get("subfolder") or "").strip()
+        if not urls:
+            return {"ok": False, "error": "Nessuna URL fornita"}
+        if len(urls) != len(titles):
+            return {"ok": False, "error": "urls e titles devono avere stessa lunghezza"}
+        if not output_dir:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        if subfolder:
+            safe = subfolder.replace("/", "_").replace("\\", "_").strip()
+            if safe:
+                output_dir = os.path.join(output_dir, safe)
+
+        gate = self._gate("audio")
+        if gate:
+            return gate
+
+        self._download_thread = threading.Thread(
+            target=self._urls_worker,
+            args=(list(urls), list(titles), output_dir),
+            daemon=True,
+        )
+        self._download_thread.start()
+        return {"ok": True}
+
+    def _urls_worker(self, urls: list, titles: list, output_dir: str) -> None:
+        # Replica il pattern di _tracks_worker ma usa download_urls
+        from core.downloader import download_urls
+        reset_download_stop()
+        cfg = load_config()
+        bitrate = cfg.get("bitrate", "320K")
+        cookies_path = cfg.get("cookies_path", "")
+        view = "download"
+
+        self._log(view, f"[INFO] URL list: {len(urls)} da scaricare da YouTube")
+        self._log(view, f"[INFO] Destinazione: {output_dir}")
+
+        _last = [0.0]
+        _THROTTLE = 0.10
+
+        def progress_cb(idx, total, title, status, pct):
+            if status == "downloading":
+                import time
+                now = time.monotonic()
+                if now - _last[0] < _THROTTLE:
+                    return
+                _last[0] = now
+
+            payload_evt = {
+                "idx": idx, "total": total, "track": title,
+                "status": status, "pct": pct,
+                "url_idx": 0, "url_total": 1,
+            }
+            if status == "searching":
+                self._log(view, f"[CERCA] {title}")
+            elif status == "skipped":
+                self._log(view, f"[SKIP] {title} (gia scaricato)")
+                payload_evt["overall"] = min((idx + 1) / total, 1.0) if total else 1
+            elif status == "downloading":
+                payload_evt["overall"] = min((idx / total) + (pct / 100 / total), 1.0) if total else 0
+            elif status == "done":
+                self._log(view, f"[OK] {title}")
+                payload_evt["overall"] = min((idx + 1) / total, 1.0) if total else 1
+            elif status == "stopped":
+                self._log(view, "[INFO] Download interrotto.")
+            elif status == "completed":
+                payload_evt["overall"] = 1.0
+                self._log(view, "[INFO] Download completato!")
+            elif status.startswith("error"):
+                self._log(view, f"[ERRORE] {title}: {status}")
+
+            self._emit("download:progress", payload_evt)
+
+        download_urls(urls, titles, output_dir, bitrate, cookies_path, progress_cb)
+        self._emit("download:done", {"ok": True})
+```
+
+- [ ] **Step 4: Smoke test bridge**
+
+```bash
+python3 -c "from api.bridge import Api; a = Api(); print(a.start_urls_download({'urls':[],'titles':[],'output_dir':''}))"
+```
+Expected: `{'ok': False, 'error': 'Nessuna URL fornita'}` (validazione OK)
+
+- [ ] **Step 5: Full regression**
+
+Run: `python3 -m pytest tests/ -v`
+Expected: 19 test PASS (4 spotify + 6 youtube_search + 9 nuovi search_tracks e discography)
+
+Attenzione: il conto reale dipende dal totale Beatport già presente su questo branch — quindi conta i test come "nessuna regressione, tutti verdi".
+
+- [ ] **Step 6: Commit**
+```bash
+git add core/downloader.py api/bridge.py
+git -c user.email=info@djluza.com commit -m "downloader+bridge: supporto download da URL diretti (YouTube search flow)"
+```
+
+---
+
+## Task 5: Config — VERSION v1.8.1 + 3 nuovi campi DEFAULTS
+
+**Files:** `core/config.py`
+
+- [ ] **Step 1: Bump VERSION**
+
+In `core/config.py`, cambia:
+```python
+VERSION = "v1.8.0"
+```
+in:
+```python
+VERSION = "v1.8.1"
+```
+
+- [ ] **Step 2: Aggiungi 3 campi in DEFAULTS**
+
+Trova il blocco `# ---- Beatport ----` e aggiungi subito dopo (prima di `# ---- Licenza ----`):
+
+```python
+    # ---- Music Search (Spotify + YouTube) ----
+    "spotify_search_last_query": "",
+    "spotify_search_artist_mode": False,
+    "youtube_search_last_query": "",
+```
+
+- [ ] **Step 3: Verifica**
+```bash
+python3 -c "from core.config import load_config, VERSION; c = load_config(); print(VERSION, c.get('spotify_search_last_query',''), c.get('spotify_search_artist_mode'), c.get('youtube_search_last_query',''))"
+```
+Expected: `v1.8.1  False ` (i valori sono default)
+
+- [ ] **Step 4: Commit**
+```bash
+git add core/config.py
+git -c user.email=info@djluza.com commit -m "config: v1.8.1 + 3 campi DEFAULTS per music search"
+```
+
+---
+
+## Task 6: `api/bridge.py` — 6 metodi Api per Spotify + YouTube
+
+**Files:** `api/bridge.py`
+
+- [ ] **Step 1: Ispeziona pattern esistente Beatport**
+
+```bash
+grep -n "beatport_" api/bridge.py | head -10
+```
+
+Nota il pattern usato da `beatport_genres`, `beatport_fetch_chart`, `beatport_check_existing`, `beatport_download_selected` — replichiamo il layout.
+
+- [ ] **Step 2: Aggiungi in fondo a `class Api` (dopo i metodi Beatport)**
+
+```python
+    # ================================================================
+    # Music Search — Spotify + YouTube
+    # ================================================================
+
+    def _music_output_dir(self, out_root: str, source: str) -> Path:
+        """Cartella target per Spotify/YouTube search. Coerente col pattern
+        `start_tracks_download` (subfolder singolo, no nested)."""
+        safe = source.replace("/", "_").replace("\\", "_").strip()
+        return Path(out_root) / safe
+
+    # ---- Spotify ----
+
+    def spotify_search(self, query: str, artist_mode: bool = False) -> dict:
+        """Cerca su Spotify. Free-form (limit 50) o artist-mode (discografia)."""
+        query = (query or "").strip()
+        if not query:
+            return {"ok": False, "error": "empty_query", "message": "Query vuota"}
+
+        # Salva stato
+        try:
+            cfg = load_config()
+            cfg["spotify_search_last_query"] = query
+            cfg["spotify_search_artist_mode"] = bool(artist_mode)
+            save_config(cfg)
+        except Exception:
+            pass
+
+        cid = (load_config().get("client_id") or "").strip()
+        secret = (load_config().get("client_secret") or "").strip()
+        if not cid or not secret:
+            return {"ok": False, "error": "no_creds", "message": "Credenziali Spotify mancanti"}
+
+        try:
+            token = spotify_client.get_access_token(cid, secret)
+        except Exception as e:
+            return {"ok": False, "error": "auth", "message": str(e)}
+
+        try:
+            if artist_mode:
+                tracks = spotify_client.search_artist_discography(token, query)
+            else:
+                tracks = spotify_client.search_tracks(token, query, limit=50)
+        except ValueError as e:
+            return {"ok": False, "error": "artist_not_found", "message": str(e)}
+        except requests.HTTPError as e:
+            code = e.response.status_code if e.response is not None else 0
+            if code == 429:
+                return {"ok": False, "error": "rate_limit", "message": "Spotify limitante — attendi qualche secondo"}
+            return {"ok": False, "error": "server", "message": f"Spotify HTTP {code}"}
+        except Exception as e:
+            return {"ok": False, "error": "unknown", "message": str(e)}
+
+        return {"ok": True, "tracks": tracks}
+
+    def spotify_check_existing(self, tracks: list) -> list:
+        """True per ogni track già presente in output_dir/Spotify/."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return [False] * len(tracks)
+        out_dir = self._music_output_dir(out_root, "Spotify")
+        if not out_dir.exists():
+            return [False] * len(tracks)
+        existing_stems = [p.stem.lower() for p in out_dir.glob("*.mp3")]
+        result = []
+        for t in tracks:
+            title = (t.get("name") or "").lower().strip()
+            artists = (t.get("artists") or "")
+            first_artist = artists.split(",")[0].strip().lower()
+            if not title or not first_artist:
+                result.append(False)
+                continue
+            result.append(any((title in stem and first_artist in stem) for stem in existing_stems))
+        return result
+
+    def spotify_search_download(self, tracks: list) -> dict:
+        """Scarica i track Spotify selezionati (name+artist → YouTube search)."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        target = self._music_output_dir(out_root, "Spotify")
+        subfolder = target.name
+
+        converted = []
+        for t in tracks:
+            title = (t.get("name") or "").strip()
+            artists = (t.get("artists") or "").strip()
+            if not title:
+                continue
+            converted.append({"name": title, "artist": artists})
+
+        if not converted:
+            return {"ok": False, "error": "Nessun brano valido"}
+
+        return self.start_tracks_download({
+            "tracks": converted,
+            "output_dir": out_root,
+            "subfolder": subfolder,
+        })
+
+    # ---- YouTube ----
+
+    def youtube_search(self, query: str) -> dict:
+        """Cerca 50 risultati su YouTube via yt-dlp."""
+        from core import youtube_search as yts
+
+        query = (query or "").strip()
+        if not query:
+            return {"ok": False, "error": "empty_query", "message": "Query vuota"}
+
+        try:
+            cfg = load_config()
+            cfg["youtube_search_last_query"] = query
+            save_config(cfg)
+        except Exception:
+            pass
+
+        try:
+            results = yts.search_youtube(query, limit=50)
+        except RuntimeError as e:
+            return {"ok": False, "error": "ytdlp", "message": str(e)}
+        except Exception as e:
+            return {"ok": False, "error": "unknown", "message": str(e)}
+
+        return {"ok": True, "tracks": results}
+
+    def youtube_check_existing(self, tracks: list) -> list:
+        """True per ogni track già presente in output_dir/YouTube/. Match sul titolo video."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return [False] * len(tracks)
+        out_dir = self._music_output_dir(out_root, "YouTube")
+        if not out_dir.exists():
+            return [False] * len(tracks)
+        existing_stems = [p.stem.lower() for p in out_dir.glob("*.mp3")]
+        result = []
+        for t in tracks:
+            title = (t.get("title") or "").lower().strip()
+            if not title:
+                result.append(False)
+                continue
+            # Match: se il titolo del video è contenuto (o viceversa) in un filename esistente
+            result.append(any(
+                (title in stem or stem in title)
+                for stem in existing_stems
+            ))
+        return result
+
+    def youtube_search_download(self, tracks: list) -> dict:
+        """Scarica direttamente gli URL YouTube selezionati (no re-search)."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        target = self._music_output_dir(out_root, "YouTube")
+        subfolder = target.name
+
+        urls: list = []
+        titles: list = []
+        for t in tracks:
+            url = (t.get("url") or "").strip()
+            title = (t.get("title") or "").strip()
+            if not url or not title:
+                continue
+            urls.append(url)
+            titles.append(title)
+
+        if not urls:
+            return {"ok": False, "error": "Nessun URL valido"}
+
+        return self.start_urls_download({
+            "urls": urls,
+            "titles": titles,
+            "output_dir": out_root,
+            "subfolder": subfolder,
+        })
+```
+
+Verifica gli import in cima al file: `spotify_client`, `requests` — devono essere già presenti. Se `requests` manca, aggiungilo. Se `spotify_client` è importato come `from core import spotify_client` verifica coerenza.
+
+- [ ] **Step 3: Smoke test**
+```bash
+python3 -c "
+from api.bridge import Api
+a = Api()
+print('spotify_search empty:', a.spotify_search(''))
+print('youtube_search empty:', a.youtube_search(''))
+print('spotify_check empty tracks:', a.spotify_check_existing([]))
+print('youtube_check empty tracks:', a.youtube_check_existing([]))
+"
+```
+Expected: gli errori `empty_query` per le search, `[]` per check_existing.
+
+- [ ] **Step 4: Full pytest**
+Run: `python3 -m pytest tests/ -v`
+Expected: nessuna regressione, tutti verdi.
+
+- [ ] **Step 5: Commit**
+```bash
+git add api/bridge.py
+git -c user.email=info@djluza.com commit -m "bridge: 6 metodi Api per music search (Spotify + YouTube)"
+```
+
+---
+
+## Task 7: UI — 2 nuove tab (HTML + JS + CSS) in un unico blocco
+
+Combinato Task 7-9 dello spec in un unico task perché tutto UI, stesso pattern del `BeatportUI`.
+
+**Files:**
+- Modify: `webui/index.html`
+- Modify: `webui/js/app.js`
+- Modify: `webui/css/style.css`
+
+- [ ] **Step 1: Recon rapido pattern esistente Beatport**
+
+```bash
+grep -n 'data-view="beatport"\|view-beatport\|BeatportUI' webui/index.html webui/js/app.js | head -20
+```
+
+Il subagent Beatport ha usato: `.nav-item[data-view="beatport"][data-feature="audio"]`, `<section id="view-beatport" class="view">`, modulo `BeatportUI` in JS con `init/loadChart/renderTable/updateSelectionCount/startDownload`. Replica lo stesso pattern per `spotify` e `youtube`.
+
+- [ ] **Step 2: HTML — nuove nav-item + 2 sezioni**
+
+In `webui/index.html`, dopo il `nav-item` di Beatport (`data-view="beatport"`), aggiungi:
+
+```html
+<a class="nav-item" data-view="spotify" data-feature="audio" href="#">
+  <span class="ico">🟢</span><span>Spotify</span>
+</a>
+<a class="nav-item" data-view="youtube" data-feature="audio" href="#">
+  <span class="ico">▶</span><span>YouTube</span>
+</a>
+```
+
+Dopo `<section id="view-beatport">...</section>`, aggiungi:
+
+```html
+<section id="view-spotify" class="view">
+  <div class="hero hero-indigo">
+    <div class="hero-content">
+      <span class="hero-eyebrow indigo">RICERCA SPOTIFY</span>
+      <h1>Cerca brani su Spotify</h1>
+      <p>Digita un artista, un titolo, o entrambi. Attiva "Solo artista" per scaricare tutta la discografia.</p>
+    </div>
+  </div>
+
+  <section class="card">
+    <div class="beatport-header">
+      <input type="text" id="spotify-query" class="input pill" placeholder="Es: Solomun, Hot Sauce, Kapuchon Hot Sauce…" style="flex:1"/>
+      <label style="display:flex;gap:6px;align-items:center;">
+        <input type="checkbox" id="spotify-artist-mode"/>
+        <span>Solo artista</span>
+      </label>
+      <button id="spotify-search-btn" class="btn btn-primary pill">🔎 Cerca</button>
+    </div>
+    <div id="spotify-output-info" class="beatport-output-info"></div>
+    <div id="spotify-status" class="beatport-status"></div>
+
+    <div class="beatport-table-card" id="spotify-table-wrap" hidden>
+      <table class="beatport-table" id="spotify-table">
+        <thead><tr>
+          <th class="col-check"><input type="checkbox" id="spotify-select-all" checked/></th>
+          <th class="col-pos">#</th>
+          <th>Artista</th>
+          <th>Titolo</th>
+          <th>Album</th>
+          <th class="col-dur">Durata</th>
+          <th class="col-state"></th>
+        </tr></thead>
+        <tbody id="spotify-tbody"></tbody>
+      </table>
+    </div>
+
+    <div class="beatport-toolbar" id="spotify-toolbar" hidden>
+      <span class="counter" id="spotify-selected-count">0/0 selezionati</span>
+      <button id="spotify-download-btn" class="btn btn-primary pill" disabled>⬇ Scarica selezionati</button>
+      <button id="spotify-stop-btn" class="btn btn-danger pill" hidden>■ Interrompi</button>
+    </div>
+  </section>
+
+  <section class="log-card">
+    <div class="section-label">LOG</div>
+    <div id="spotify-log" class="log"></div>
+  </section>
+</section>
+
+<section id="view-youtube" class="view">
+  <div class="hero hero-indigo">
+    <div class="hero-content">
+      <span class="hero-eyebrow indigo">RICERCA YOUTUBE</span>
+      <h1>Cerca video su YouTube</h1>
+      <p>Perfetto per mix DJ, unreleased, bootleg e brani non presenti su Spotify.</p>
+    </div>
+  </div>
+
+  <section class="card">
+    <div class="beatport-header">
+      <input type="text" id="youtube-query" class="input pill" placeholder="Es: Solomun Cocoricò 2024, Kapuchon Hot Sauce remix…" style="flex:1"/>
+      <button id="youtube-search-btn" class="btn btn-primary pill">🔎 Cerca</button>
+    </div>
+    <div id="youtube-output-info" class="beatport-output-info"></div>
+    <div id="youtube-status" class="beatport-status"></div>
+
+    <div class="beatport-table-card" id="youtube-table-wrap" hidden>
+      <table class="beatport-table" id="youtube-table">
+        <thead><tr>
+          <th class="col-check"><input type="checkbox" id="youtube-select-all" checked/></th>
+          <th class="col-pos">#</th>
+          <th>Titolo video</th>
+          <th>Canale</th>
+          <th class="col-dur">Durata</th>
+          <th class="col-state"></th>
+        </tr></thead>
+        <tbody id="youtube-tbody"></tbody>
+      </table>
+    </div>
+
+    <div class="beatport-toolbar" id="youtube-toolbar" hidden>
+      <span class="counter" id="youtube-selected-count">0/0 selezionati</span>
+      <button id="youtube-download-btn" class="btn btn-primary pill" disabled>⬇ Scarica selezionati</button>
+      <button id="youtube-stop-btn" class="btn btn-danger pill" hidden>■ Interrompi</button>
+    </div>
+  </section>
+
+  <section class="log-card">
+    <div class="section-label">LOG</div>
+    <div id="youtube-log" class="log"></div>
+  </section>
+</section>
+```
+
+Adatta le classi CSS se il subagent Beatport ha usato nomi leggermente diversi (`beatport-table-card` vs `beatport-table-wrap`) — controlla il markup esistente.
+
+- [ ] **Step 3: JS — moduli SpotifyUI e YoutubeUI in `webui/js/app.js`**
+
+Dopo `BeatportUI`, aggiungi (in fondo, prima del bootstrap `// Boot`):
+
+```javascript
+// =====================================================================
+// Spotify search
+// =====================================================================
+const SpotifyUI = (() => {
+  const state = { tracks: [], existing: [], downloading: false };
+
+  function _escape(s) {
+    const d = document.createElement("div");
+    d.textContent = s ?? "";
+    return d.innerHTML;
+  }
+
+  function _fmtDuration(sec) {
+    const m = Math.floor((sec || 0) / 60), s = (sec || 0) % 60;
+    return `${m}:${String(s).padStart(2, "0")}`;
+  }
+
+  function updateSelectionCount() {
+    const boxes = document.querySelectorAll("#spotify-tbody input[type=checkbox]");
+    const total = boxes.length;
+    const selected = [...boxes].filter(b => b.checked).length;
+    document.getElementById("spotify-selected-count").textContent = `${selected}/${total} selezionati`;
+    const btn = document.getElementById("spotify-download-btn");
+    btn.disabled = selected === 0;
+    btn.textContent = `⬇ Scarica selezionati (${selected})`;
+    const sa = document.getElementById("spotify-select-all");
+    sa.checked = selected === total && total > 0;
+    sa.indeterminate = selected > 0 && selected < total;
+  }
+
+  function renderTable() {
+    const tbody = document.getElementById("spotify-tbody");
+    tbody.innerHTML = "";
+    state.tracks.forEach((t, i) => {
+      const already = state.existing[i];
+      const tr = document.createElement("tr");
+      tr.dataset.idx = i;
+      if (already) tr.classList.add("already-downloaded");
+      tr.innerHTML = `
+        <td class="col-check"><input type="checkbox" data-idx="${i}" ${already ? "" : "checked"}/></td>
+        <td class="col-pos">${i + 1}</td>
+        <td>${_escape(t.artists)}</td>
+        <td>${_escape(t.name)}</td>
+        <td>${_escape(t.album)}</td>
+        <td class="col-dur">${_fmtDuration(t.duration_sec)}</td>
+        <td class="col-state">${already ? "<span style='color:var(--green)'>✓ scaricato</span>" : ""}</td>
+      `;
+      tr.querySelector("input[type=checkbox]").addEventListener("change", updateSelectionCount);
+      tbody.appendChild(tr);
+    });
+    updateSelectionCount();
+  }
+
+  async function doSearch() {
+    const q = document.getElementById("spotify-query").value.trim();
+    if (!q) return;
+    const artistMode = document.getElementById("spotify-artist-mode").checked;
+    const status = document.getElementById("spotify-status");
+    const wrap = document.getElementById("spotify-table-wrap");
+    const toolbar = document.getElementById("spotify-toolbar");
+    status.textContent = "Ricerca in corso…";
+    status.className = "beatport-status loading";
+    wrap.hidden = true;
+    toolbar.hidden = true;
+
+    let res;
+    try {
+      res = await window.pywebview.api.spotify_search(q, artistMode);
+    } catch (e) {
+      status.textContent = `Errore: ${e}`;
+      status.className = "beatport-status error";
+      return;
+    }
+    if (!res.ok) {
+      const messages = {
+        empty_query: "Inserisci una query di ricerca.",
+        no_creds: "Credenziali Spotify mancanti. Vai su Impostazioni.",
+        auth: "Impossibile autenticarsi con Spotify. Verifica le credenziali.",
+        artist_not_found: res.message,
+        rate_limit: res.message,
+        server: res.message,
+      };
+      status.textContent = messages[res.error] || res.message || "Errore sconosciuto";
+      status.className = "beatport-status error";
+      return;
+    }
+
+    state.tracks = res.tracks || [];
+    if (state.tracks.length === 0) {
+      status.textContent = `Nessun brano trovato per "${q}".`;
+      status.className = "beatport-status";
+      return;
+    }
+    try {
+      state.existing = await window.pywebview.api.spotify_check_existing(state.tracks);
+    } catch { state.existing = state.tracks.map(() => false); }
+
+    status.textContent = "";
+    document.getElementById("spotify-output-info").textContent = "Cartella output: MUSICA/Spotify/";
+    renderTable();
+    wrap.hidden = false;
+    toolbar.hidden = false;
+  }
+
+  async function startDownload() {
+    const selected = [...document.querySelectorAll("#spotify-tbody input[type=checkbox]:checked")]
+      .map(b => state.tracks[parseInt(b.dataset.idx)]);
+    if (!selected.length) return;
+
+    state.downloading = true;
+    document.getElementById("spotify-download-btn").disabled = true;
+    document.getElementById("spotify-stop-btn").hidden = false;
+    document.getElementById("spotify-log").innerHTML = "";
+
+    try {
+      await window.pywebview.api.spotify_search_download(selected);
+    } catch (e) {
+      appendLog("spotify", `Errore: ${e}`);
+    }
+  }
+
+  async function stopDownload() {
+    try { await window.pywebview.api.stop_download(); } catch {}
+  }
+
+  async function init() {
+    const cfg = state?.config || (window.state?.config) || {};
+    try {
+      const q = cfg.spotify_search_last_query;
+      const am = cfg.spotify_search_artist_mode;
+      if (q) document.getElementById("spotify-query").value = q;
+      if (am) document.getElementById("spotify-artist-mode").checked = true;
+    } catch { /* ignora */ }
+
+    document.getElementById("spotify-search-btn").addEventListener("click", doSearch);
+    document.getElementById("spotify-query").addEventListener("keydown", (e) => {
+      if (e.key === "Enter") doSearch();
+    });
+    document.getElementById("spotify-select-all").addEventListener("change", (e) => {
+      document.querySelectorAll("#spotify-tbody input[type=checkbox]").forEach(b => b.checked = e.target.checked);
+      updateSelectionCount();
+    });
+    document.getElementById("spotify-download-btn").addEventListener("click", startDownload);
+    document.getElementById("spotify-stop-btn").addEventListener("click", stopDownload);
+
+    // Wrap bridge handlers per mostrare log/progress su questa tab durante download
+    const origLog = bridgeHandlers["log"];
+    bridgeHandlers["log"] = (payload) => {
+      if (origLog) origLog(payload);
+      if (state.downloading && payload?.view === "download") {
+        appendLog("spotify", payload.msg);
+      }
+    };
+    const origDone = bridgeHandlers["download:done"];
+    bridgeHandlers["download:done"] = (payload) => {
+      if (origDone) origDone(payload);
+      if (state.downloading) {
+        state.downloading = false;
+        document.getElementById("spotify-download-btn").disabled = false;
+        document.getElementById("spotify-stop-btn").hidden = true;
+        // Refresh existing
+        window.pywebview.api.spotify_check_existing(state.tracks).then(r => {
+          state.existing = r;
+          renderTable();
+        }).catch(() => {});
+      }
+    };
+  }
+
+  return { init };
+})();
+
+// =====================================================================
+// YouTube search
+// =====================================================================
+const YoutubeUI = (() => {
+  const state = { tracks: [], existing: [], downloading: false };
+
+  function _escape(s) {
+    const d = document.createElement("div");
+    d.textContent = s ?? "";
+    return d.innerHTML;
+  }
+  function _fmtDuration(sec) {
+    const m = Math.floor((sec || 0) / 60), s = (sec || 0) % 60;
+    return `${m}:${String(s).padStart(2, "0")}`;
+  }
+  function updateSelectionCount() {
+    const boxes = document.querySelectorAll("#youtube-tbody input[type=checkbox]");
+    const total = boxes.length;
+    const selected = [...boxes].filter(b => b.checked).length;
+    document.getElementById("youtube-selected-count").textContent = `${selected}/${total} selezionati`;
+    const btn = document.getElementById("youtube-download-btn");
+    btn.disabled = selected === 0;
+    btn.textContent = `⬇ Scarica selezionati (${selected})`;
+    const sa = document.getElementById("youtube-select-all");
+    sa.checked = selected === total && total > 0;
+    sa.indeterminate = selected > 0 && selected < total;
+  }
+  function renderTable() {
+    const tbody = document.getElementById("youtube-tbody");
+    tbody.innerHTML = "";
+    state.tracks.forEach((t, i) => {
+      const already = state.existing[i];
+      const tr = document.createElement("tr");
+      tr.dataset.idx = i;
+      if (already) tr.classList.add("already-downloaded");
+      tr.innerHTML = `
+        <td class="col-check"><input type="checkbox" data-idx="${i}" ${already ? "" : "checked"}/></td>
+        <td class="col-pos">${i + 1}</td>
+        <td>${_escape(t.title)}</td>
+        <td>${_escape(t.channel)}</td>
+        <td class="col-dur">${_fmtDuration(t.duration_sec)}</td>
+        <td class="col-state">${already ? "<span style='color:var(--green)'>✓ scaricato</span>" : ""}</td>
+      `;
+      tr.querySelector("input[type=checkbox]").addEventListener("change", updateSelectionCount);
+      tbody.appendChild(tr);
+    });
+    updateSelectionCount();
+  }
+  async function doSearch() {
+    const q = document.getElementById("youtube-query").value.trim();
+    if (!q) return;
+    const status = document.getElementById("youtube-status");
+    const wrap = document.getElementById("youtube-table-wrap");
+    const toolbar = document.getElementById("youtube-toolbar");
+    status.textContent = "Ricerca su YouTube in corso…";
+    status.className = "beatport-status loading";
+    wrap.hidden = true;
+    toolbar.hidden = true;
+
+    let res;
+    try { res = await window.pywebview.api.youtube_search(q); }
+    catch (e) { status.textContent = `Errore: ${e}`; status.className = "beatport-status error"; return; }
+
+    if (!res.ok) {
+      status.textContent = res.message || "Errore sconosciuto";
+      status.className = "beatport-status error";
+      return;
+    }
+    state.tracks = res.tracks || [];
+    if (state.tracks.length === 0) {
+      status.textContent = `Nessun video trovato per "${q}".`;
+      status.className = "beatport-status";
+      return;
+    }
+    try { state.existing = await window.pywebview.api.youtube_check_existing(state.tracks); }
+    catch { state.existing = state.tracks.map(() => false); }
+
+    status.textContent = "";
+    document.getElementById("youtube-output-info").textContent = "Cartella output: MUSICA/YouTube/";
+    renderTable();
+    wrap.hidden = false;
+    toolbar.hidden = false;
+  }
+  async function startDownload() {
+    const selected = [...document.querySelectorAll("#youtube-tbody input[type=checkbox]:checked")]
+      .map(b => state.tracks[parseInt(b.dataset.idx)]);
+    if (!selected.length) return;
+    state.downloading = true;
+    document.getElementById("youtube-download-btn").disabled = true;
+    document.getElementById("youtube-stop-btn").hidden = false;
+    document.getElementById("youtube-log").innerHTML = "";
+    try { await window.pywebview.api.youtube_search_download(selected); }
+    catch (e) { appendLog("youtube", `Errore: ${e}`); }
+  }
+  async function stopDownload() {
+    try { await window.pywebview.api.stop_download(); } catch {}
+  }
+  async function init() {
+    const cfg = state?.config || (window.state?.config) || {};
+    try {
+      const q = cfg.youtube_search_last_query;
+      if (q) document.getElementById("youtube-query").value = q;
+    } catch { /* ignora */ }
+
+    document.getElementById("youtube-search-btn").addEventListener("click", doSearch);
+    document.getElementById("youtube-query").addEventListener("keydown", (e) => {
+      if (e.key === "Enter") doSearch();
+    });
+    document.getElementById("youtube-select-all").addEventListener("change", (e) => {
+      document.querySelectorAll("#youtube-tbody input[type=checkbox]").forEach(b => b.checked = e.target.checked);
+      updateSelectionCount();
+    });
+    document.getElementById("youtube-download-btn").addEventListener("click", startDownload);
+    document.getElementById("youtube-stop-btn").addEventListener("click", stopDownload);
+
+    const origLog = bridgeHandlers["log"];
+    bridgeHandlers["log"] = (payload) => {
+      if (origLog) origLog(payload);
+      if (state.downloading && payload?.view === "download") {
+        appendLog("youtube", payload.msg);
+      }
+    };
+    const origDone = bridgeHandlers["download:done"];
+    bridgeHandlers["download:done"] = (payload) => {
+      if (origDone) origDone(payload);
+      if (state.downloading) {
+        state.downloading = false;
+        document.getElementById("youtube-download-btn").disabled = false;
+        document.getElementById("youtube-stop-btn").hidden = true;
+        window.pywebview.api.youtube_check_existing(state.tracks).then(r => {
+          state.existing = r;
+          renderTable();
+        }).catch(() => {});
+      }
+    };
+  }
+  return { init };
+})();
+```
+
+- [ ] **Step 4: Registra `logEls` per le nuove tab**
+
+Cerca in `app.js` la mappa `logEls = { download: ..., video: ..., upgrade: ... }` (probabile linea ~250-300). Aggiungi:
+
+```javascript
+  spotify: document.getElementById("spotify-log"),
+  youtube: document.getElementById("youtube-log"),
+```
+
+Verifica che `appendLog("spotify", msg)` e `appendLog("youtube", msg)` funzionino grazie a questa registrazione.
+
+- [ ] **Step 5: Aggancia le init al bootstrap**
+
+Trova dove `await BeatportUI.init();` è chiamato in fondo alla funzione `init()` del bootstrap, e aggiungi subito dopo:
+
+```javascript
+  await SpotifyUI.init();
+  await YoutubeUI.init();
+```
+
+- [ ] **Step 6: CSS — piccole estensioni in `webui/css/style.css`**
+
+Le classi Beatport (`.beatport-header`, `.beatport-table`, `.beatport-toolbar`, `.beatport-status`, ecc.) sono riusate — non serve aggiungere CSS a meno che qualche cosa non renda bene. Verifica visivamente.
+
+Se serve una differenziazione visiva (es. barra colore per Spotify verde, YouTube rosso), aggiungi variant classes. Optional per v1.8.1.
+
+- [ ] **Step 7: Verifiche pre-commit**
+
+```bash
+node --check webui/js/app.js  # syntax check
+python3 -m pytest tests/ -v   # no regression
+python3 -c "from api.bridge import Api; a=Api(); print(a.spotify_search(''))"
+```
+
+- [ ] **Step 8: Commit (3 separati per pulizia)**
+```bash
+git add webui/index.html
+git -c user.email=info@djluza.com commit -m "ui: markup tab Spotify + YouTube search"
+
+git add webui/js/app.js
+git -c user.email=info@djluza.com commit -m "ui: SpotifyUI + YoutubeUI (search, table, download, log)"
+
+# CSS solo se hai aggiunto qualcosa
+git status webui/css/ >/dev/null 2>&1 && [ -n "$(git diff --name-only webui/css/)" ] && {
+  git add webui/css/*.css
+  git -c user.email=info@djluza.com commit -m "ui: piccole estensioni CSS per tab Spotify+YouTube"
+}
+```
+
+---
+
+## Task 8: Manual test + release notes + tag + push + server DB update
+
+**Files:** `/tmp/notes-v1.8.1.md`
+
+- [ ] **Step 1: Full test suite finale**
+```bash
+python3 -m pytest tests/ -v
+```
+Expected: tutti verdi, zero regressioni.
+
+- [ ] **Step 2: Test manuale end-to-end**
+
+Segui la spec sez. "Test manuale end-to-end". 12 casi in tutto (6 Spotify + 5 YouTube + 1 riavvio).
+
+Se qualcosa fallisce: BLOCKED, torna al task pertinente.
+
+- [ ] **Step 3: Note release**
+
+Crea `/tmp/notes-v1.8.1.md`:
+
+```markdown
+# MusicTools v1.8.1
+
+## Novità
+
+**Nuove tab Spotify e YouTube 🔎** — cerca brani per titolo o artista.
+
+- **Spotify:** cerca brani via API ufficiale. Toggle "Solo artista" per ottenere tutta la discografia (top tracks + tutti gli album/single, deduplicati).
+- **YouTube:** cerca video via yt-dlp (fino a 50 risultati). Perfetto per mix DJ, unreleased, bootleg e brani non presenti su Spotify.
+- Entrambe le tab hanno anteprima con checkbox e riconoscimento file già scaricati.
+- File in `MUSICA/Spotify/` e `MUSICA/YouTube/`.
+
+## Bug fix
+
+Nessuno in questa release.
+```
+
+- [ ] **Step 4: Merge + tag + push**
+```bash
+git checkout main
+git merge --no-ff feat/music-search -m "Merge feat/music-search: MusicTools v1.8.1"
+# Se l'autore risulta sbagliato:
+git -c user.email=info@djluza.com commit --amend --author="luciano <info@djluza.com>" --no-edit
+git tag v1.8.1
+git push origin main
+git push origin v1.8.1
+```
+
+- [ ] **Step 5: Monitor CI + apply release notes**
+```bash
+# Trova il databaseId del run appena partito
+RUN_ID=$(gh run list --limit 1 --json databaseId --jq '.[0].databaseId')
+gh run watch "$RUN_ID" --exit-status && gh release edit v1.8.1 --notes-file /tmp/notes-v1.8.1.md
+```
+
+- [ ] **Step 6: Popola server `releases` table**
+
+```bash
+mkdir -p /tmp/release-v1.8.1
+gh release download v1.8.1 -D /tmp/release-v1.8.1
+cd /tmp/release-v1.8.1
+MAC_SHA=$(shasum -a 256 MusicTools-macOS.dmg | awk '{print $1}')
+WIN_SHA=$(shasum -a 256 MusicTools-Windows.zip | awk '{print $1}')
+MAC_SIZE=$(stat -f %z MusicTools-macOS.dmg)
+WIN_SIZE=$(stat -f %z MusicTools-Windows.zip)
+
+ssh musictools@musictools.djluza.com "mkdir -p ~/builds/v1.8.1"
+scp MusicTools-macOS.dmg MusicTools-Windows.zip musictools@musictools.djluza.com:~/builds/v1.8.1/
+
+ssh musictools@musictools.djluza.com "cd ~/api && node -e '
+import(\"node:fs\").then(({ default: fs }) => {
+  fs.readFileSync(\".env\", \"utf-8\").split(\"\n\").forEach((l) => {
+    const m = l.match(/^([A-Z_]+)=(.*)\$/);
+    if (m) process.env[m[1]] = m[2];
+  });
+  import(\"./src/db.js\").then(async ({ query }) => {
+    const notes = \"Nuove tab Spotify e YouTube per cercare brani per titolo o artista. Toggle solo artista su Spotify per scaricare tutta la discografia.\";
+    const now = Math.floor(Date.now()/1000);
+    await query(\"INSERT INTO releases (version, platform, file_path, size_bytes, sha256, notes, published_at) VALUES (?, ?, ?, ?, ?, ?, ?)\",
+      [\"v1.8.1\", \"macos\", \"v1.8.1/MusicTools-macOS.dmg\", ${MAC_SIZE}, \"${MAC_SHA}\", notes, now]);
+    await query(\"INSERT INTO releases (version, platform, file_path, size_bytes, sha256, notes, published_at) VALUES (?, ?, ?, ?, ?, ?, ?)\",
+      [\"v1.8.1\", \"windows\", \"v1.8.1/MusicTools-Windows.zip\", ${WIN_SIZE}, \"${WIN_SHA}\", notes, now]);
+    console.log(\"inserted 2 rows\");
+    process.exit(0);
+  });
+});
+'"
+
+rm -rf /tmp/release-v1.8.1
+```
+
+- [ ] **Step 7: Verifica endpoint update**
+```bash
+curl -s "https://musictools.djluza.com/api/latest?platform=macos&current=v1.7.15" | python3 -m json.tool
+```
+Expected: `"version": "v1.8.1"`
+
+---
+
+## Riepilogo test attesi
+
+- `tests/test_spotify_client.py`: **13 test** (4 pre-esistenti + 4 search_tracks + 5 search_artist_discography)
+- `tests/test_youtube_search.py`: **6 test** (nuovi)
+- `tests/test_beatport.py`: invariato (21 test)
+- **Totale:** 40 test verdi
+- Test manuali end-to-end passati
+
+## Se qualcosa va storto
+
+- **Spotify rate limit su artist mode** (troppi album chiamati): aumenta `time.sleep(0.1)` a 0.2s in `search_artist_discography`
+- **yt-dlp lento** (`ytsearch50:` timeout 30s): abbassa `limit` a 25 o alza `_TIMEOUT_SEC` a 60
+- **subprocess_flags() firma diversa da `**kwargs`**: adatta in `search_youtube` (potrebbe essere un dict standalone o un decorator)
+- **`start_urls_download` conflitto con `_any_job_running`**: se avvii un download YouTube mentre uno Spotify è in corso, blocca. Corretto — è il comportamento voluto (un solo download attivo alla volta).

From 252d76b907e61fb8ace268b2110b9976e0cf1ca1 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:14:02 +0200
Subject: [PATCH 03/10] spotify: search_tracks() free-form con limit
 configurabile

---
 core/spotify_client.py       | 34 ++++++++++++++++
 tests/test_spotify_client.py | 77 ++++++++++++++++++++++++++++++++++++
 2 files changed, 111 insertions(+)

diff --git a/core/spotify_client.py b/core/spotify_client.py
index 77570ed..8d61f19 100644
--- a/core/spotify_client.py
+++ b/core/spotify_client.py
@@ -280,3 +280,37 @@ def search_track(token: str, query: str):
         "name": t.get("name", ""),
         "artists": ", ".join(a.get("name", "") for a in t.get("artists", [])),
     }
+
+
+def search_tracks(token: str, query: str, limit: int = 50) -> list:
+    """Cerca brani su Spotify e ritorna una lista di dict.
+
+    Args:
+        token: access token Spotify
+        query: query libera (titolo, artista, misto)
+        limit: max risultati (Spotify cap = 50)
+
+    Returns:
+        list[dict] con {id, url, name, artists, album, duration_sec}. Vuota se nessun match.
+    """
+    resp = requests.get(
+        "https://api.spotify.com/v1/search",
+        headers={"Authorization": f"Bearer {token}"},
+        params={"q": query, "type": "track", "limit": min(limit, 50)},
+        timeout=15,
+    )
+    resp.raise_for_status()
+    items = resp.json().get("tracks", {}).get("items", [])
+    return [_track_to_dict(t) for t in items]
+
+
+def _track_to_dict(t: dict) -> dict:
+    """Mappa il track object Spotify sul nostro schema uniforme."""
+    return {
+        "id": t.get("id", ""),
+        "url": t.get("external_urls", {}).get("spotify", ""),
+        "name": t.get("name", ""),
+        "artists": ", ".join(a.get("name", "") for a in t.get("artists", [])),
+        "album": t.get("album", {}).get("name", ""),
+        "duration_sec": int(t.get("duration_ms", 0)) // 1000,
+    }
diff --git a/tests/test_spotify_client.py b/tests/test_spotify_client.py
index 0590c3e..f2e71fb 100644
--- a/tests/test_spotify_client.py
+++ b/tests/test_spotify_client.py
@@ -68,3 +68,80 @@ class TestSearchTrack:
         assert params["q"] == "Kapuchon Hot Sauce"
         assert params["type"] == "track"
         assert params["limit"] == "1"
+
+
+class TestSearchTracks:
+    @responses.activate
+    def test_returns_list_of_tracks(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={
+                "tracks": {
+                    "items": [
+                        {
+                            "id": f"id{i}",
+                            "name": f"Track {i}",
+                            "artists": [{"name": "Solomun"}],
+                            "album": {"name": "Album X"},
+                            "duration_ms": 300000 + i * 1000,
+                            "external_urls": {"spotify": f"https://open.spotify.com/track/id{i}"},
+                        }
+                        for i in range(50)
+                    ]
+                }
+            },
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "solomun", limit=50)
+        assert isinstance(result, list)
+        assert len(result) == 50
+        first = result[0]
+        assert first["id"] == "id0"
+        assert first["name"] == "Track 0"
+        assert first["artists"] == "Solomun"
+        assert first["album"] == "Album X"
+        assert first["duration_sec"] == 300
+        assert first["url"] == "https://open.spotify.com/track/id0"
+
+    @responses.activate
+    def test_multiple_artists_joined_with_comma(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": [{
+                "id": "x", "name": "n",
+                "artists": [{"name": "A"}, {"name": "B"}, {"name": "C"}],
+                "album": {"name": "Alb"},
+                "duration_ms": 60000,
+                "external_urls": {"spotify": "u"},
+            }]}},
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "q", limit=1)
+        assert result[0]["artists"] == "A, B, C"
+
+    @responses.activate
+    def test_empty_query_returns_empty_list(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": []}},
+            status=200,
+        )
+        result = spotify_client.search_tracks("t", "no-match", limit=50)
+        assert result == []
+
+    @responses.activate
+    def test_query_params_include_limit(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"tracks": {"items": []}},
+            status=200,
+        )
+        spotify_client.search_tracks("t", "q", limit=25)
+        params = responses.calls[0].request.params
+        assert params["q"] == "q"
+        assert params["type"] == "track"
+        assert params["limit"] == "25"

From 2771fa8075d13efe6f4cd7e74118c5efab95dd06 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:16:19 +0200
Subject: [PATCH 04/10] spotify: search_artist_discography con dedupe
 top-tracks+album

---
 core/spotify_client.py       |  88 +++++++++++++++++
 tests/test_spotify_client.py | 186 +++++++++++++++++++++++++++++++++++
 2 files changed, 274 insertions(+)

diff --git a/core/spotify_client.py b/core/spotify_client.py
index 8d61f19..34ea1c1 100644
--- a/core/spotify_client.py
+++ b/core/spotify_client.py
@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import re
+import time
+
 import requests
 
 
@@ -314,3 +316,89 @@ def _track_to_dict(t: dict) -> dict:
         "album": t.get("album", {}).get("name", ""),
         "duration_sec": int(t.get("duration_ms", 0)) // 1000,
     }
+
+
+def search_artist_discography(token: str, artist_name: str) -> list:
+    """Trova l'artista esatto (o il piu' popolare tra i match) e ritorna
+    tutti i suoi brani: top tracks + tracce di ogni album/single.
+    Deduplica per (name.lower().strip(), first_artist.lower().strip()).
+
+    Raises:
+        ValueError: se nessun artista trovato per il nome dato.
+    """
+    headers = {"Authorization": f"Bearer {token}"}
+
+    # 1. Cerca artista
+    resp = requests.get(
+        "https://api.spotify.com/v1/search",
+        headers=headers,
+        params={"q": artist_name, "type": "artist", "limit": 5},
+        timeout=15,
+    )
+    resp.raise_for_status()
+    candidates = resp.json().get("artists", {}).get("items", [])
+    if not candidates:
+        raise ValueError(f"Artista '{artist_name}' non trovato")
+
+    # Match esatto (case-insensitive) se possibile, altrimenti piu' popolare
+    query_lower = artist_name.lower().strip()
+    exact = [c for c in candidates if c.get("name", "").lower().strip() == query_lower]
+    if exact:
+        artist = exact[0]
+    else:
+        artist = max(candidates, key=lambda c: c.get("popularity", 0))
+    artist_id = artist["id"]
+
+    collected: list = []
+
+    # 2. Top tracks
+    r_top = requests.get(
+        f"https://api.spotify.com/v1/artists/{artist_id}/top-tracks",
+        headers=headers,
+        params={"market": "IT"},
+        timeout=15,
+    )
+    r_top.raise_for_status()
+    for t in r_top.json().get("tracks", []):
+        collected.append(_track_to_dict(t))
+
+    # 3. Albums (album + single)
+    r_alb = requests.get(
+        f"https://api.spotify.com/v1/artists/{artist_id}/albums",
+        headers=headers,
+        params={"include_groups": "album,single", "limit": 50, "market": "IT"},
+        timeout=15,
+    )
+    r_alb.raise_for_status()
+    albums = r_alb.json().get("items", [])
+
+    # 4. Per ogni album, tracce (album/track object non ha "album" sub-field, iniettiamola)
+    for alb in albums:
+        alb_id = alb.get("id")
+        alb_name = alb.get("name", "")
+        if not alb_id:
+            continue
+        time.sleep(0.1)  # rate limit interno
+        r_at = requests.get(
+            f"https://api.spotify.com/v1/albums/{alb_id}/tracks",
+            headers=headers,
+            params={"limit": 50},
+            timeout=15,
+        )
+        r_at.raise_for_status()
+        for t in r_at.json().get("items", []):
+            t = dict(t)
+            # Album tracks non hanno "album" nested; iniettiamo il nome
+            t.setdefault("album", {"name": alb_name})
+            collected.append(_track_to_dict(t))
+
+    # 5. Dedupe
+    seen: set = set()
+    unique: list = []
+    for t in collected:
+        key = (t["name"].lower().strip(), t["artists"].split(",")[0].lower().strip())
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(t)
+    return unique
diff --git a/tests/test_spotify_client.py b/tests/test_spotify_client.py
index f2e71fb..6b04d36 100644
--- a/tests/test_spotify_client.py
+++ b/tests/test_spotify_client.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from unittest.mock import patch
+
 import pytest
 import responses
 
@@ -145,3 +147,187 @@ class TestSearchTracks:
         assert params["q"] == "q"
         assert params["type"] == "track"
         assert params["limit"] == "25"
+
+
+class TestSearchArtistDiscography:
+    @responses.activate
+    def test_exact_name_match_beats_popular(self):
+        # 3 candidati: uno esatto (case-insensitive), altri popolari
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [
+                {"id": "pop", "name": "Solomun Tribute", "popularity": 90},
+                {"id": "exact", "name": "SOLOMUN", "popularity": 60},
+                {"id": "unrelated", "name": "Other", "popularity": 70},
+            ]}},
+            status=200,
+        )
+        # Mock top-tracks vuoto per non allungare il test
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/exact/top-tracks",
+            json={"tracks": []},
+            status=200,
+        )
+        # Mock albums vuoto
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/exact/albums",
+            json={"items": []},
+            status=200,
+        )
+        result = spotify_client.search_artist_discography("t", "Solomun")
+        assert result == []
+        # Verifica che sia stato chiamato l'artista "exact", non "pop"
+        top_tracks_calls = [c for c in responses.calls if "/top-tracks" in c.request.url]
+        assert len(top_tracks_calls) == 1
+        assert "/exact/top-tracks" in top_tracks_calls[0].request.url
+
+    @responses.activate
+    def test_falls_back_to_most_popular_if_no_exact_match(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [
+                {"id": "a1", "name": "Solomun Fanpage", "popularity": 30},
+                {"id": "a2", "name": "Solomun Live", "popularity": 80},
+            ]}},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/a2/top-tracks",
+            json={"tracks": []},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/a2/albums",
+            json={"items": []},
+            status=200,
+        )
+        spotify_client.search_artist_discography("t", "solomun")
+        top_tracks_calls = [c for c in responses.calls if "/top-tracks" in c.request.url]
+        assert "/a2/top-tracks" in top_tracks_calls[0].request.url
+
+    @responses.activate
+    def test_raises_when_no_artist_found(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": []}},
+            status=200,
+        )
+        with pytest.raises(ValueError, match="Artista"):
+            spotify_client.search_artist_discography("t", "asdgjhkasdgj")
+
+    @responses.activate
+    def test_combines_top_tracks_and_album_tracks(self):
+        # 1 artista esatto
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [{"id": "artX", "name": "artX", "popularity": 50}]}},
+            status=200,
+        )
+        # 3 top-tracks
+        top_tracks_data = {"tracks": [
+            {
+                "id": f"t{i}", "name": f"Top{i}",
+                "artists": [{"name": "artX"}],
+                "album": {"name": "AlbTop"},
+                "duration_ms": 200000,
+                "external_urls": {"spotify": f"u{i}"},
+            } for i in range(3)
+        ]}
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/artX/top-tracks",
+            json=top_tracks_data,
+            status=200,
+        )
+        # 2 album
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/artX/albums",
+            json={"items": [
+                {"id": "alb1", "name": "Album 1"},
+                {"id": "alb2", "name": "Album 2"},
+            ]},
+            status=200,
+        )
+        # album 1: 2 tracce
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb1/tracks",
+            json={"items": [
+                {
+                    "id": f"a1t{i}", "name": f"Alb1Track{i}",
+                    "artists": [{"name": "artX"}],
+                    "duration_ms": 180000,
+                    "external_urls": {"spotify": f"a1u{i}"},
+                } for i in range(2)
+            ]},
+            status=200,
+        )
+        # album 2: 1 traccia
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb2/tracks",
+            json={"items": [
+                {
+                    "id": "a2t0", "name": "Alb2Track0",
+                    "artists": [{"name": "artX"}],
+                    "duration_ms": 240000,
+                    "external_urls": {"spotify": "a2u0"},
+                }
+            ]},
+            status=200,
+        )
+        with patch("core.spotify_client.time.sleep"):  # no wait
+            result = spotify_client.search_artist_discography("t", "artX")
+        # 3 top + 2 alb1 + 1 alb2 = 6
+        assert len(result) == 6
+        titles = {r["name"] for r in result}
+        assert "Top0" in titles
+        assert "Alb1Track0" in titles
+        assert "Alb2Track0" in titles
+
+    @responses.activate
+    def test_dedupe_across_top_and_album(self):
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/search",
+            json={"artists": {"items": [{"id": "aX", "name": "aX", "popularity": 50}]}},
+            status=200,
+        )
+        # Stesso track name+artist in top-tracks e in album (id diverso)
+        common = {
+            "name": "Same Song",
+            "artists": [{"name": "aX"}],
+            "album": {"name": "OG Album"},
+            "duration_ms": 200000,
+            "external_urls": {"spotify": "u"},
+        }
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/aX/top-tracks",
+            json={"tracks": [{**common, "id": "top-id"}]},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/artists/aX/albums",
+            json={"items": [{"id": "alb", "name": "OG"}]},
+            status=200,
+        )
+        responses.add(
+            responses.GET,
+            "https://api.spotify.com/v1/albums/alb/tracks",
+            json={"items": [{**common, "id": "alb-id"}]},
+            status=200,
+        )
+        with patch("core.spotify_client.time.sleep"):
+            result = spotify_client.search_artist_discography("t", "aX")
+        assert len(result) == 1

From 0949df031ab618db984387d7693551173faf5a02 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:18:54 +0200
Subject: [PATCH 05/10] youtube: search_youtube via yt-dlp ytsearchN + parse
 JSON

---
 core/youtube_search.py       | 72 +++++++++++++++++++++++++++++++
 tests/test_youtube_search.py | 84 ++++++++++++++++++++++++++++++++++++
 2 files changed, 156 insertions(+)
 create mode 100644 core/youtube_search.py
 create mode 100644 tests/test_youtube_search.py

diff --git a/core/youtube_search.py b/core/youtube_search.py
new file mode 100644
index 0000000..30f2b10
--- /dev/null
+++ b/core/youtube_search.py
@@ -0,0 +1,72 @@
+"""Ricerca su YouTube via yt-dlp (subprocess, flat playlist metadata)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+
+from core.paths import find_ytdlp, subprocess_flags
+
+
+_TIMEOUT_SEC = 30
+
+
+def search_youtube(query: str, limit: int = 50) -> list:
+    """Cerca su YouTube (ytsearchN:query) e ritorna metadata "flat" (senza scaricare).
+
+    Args:
+        query: testo di ricerca libero
+        limit: numero massimo di risultati (default 50)
+
+    Returns:
+        list[dict] con {id, url, title, channel, duration_sec}. Vuota se nessun match.
+
+    Raises:
+        RuntimeError: se yt-dlp non disponibile, timeout, o exit non-zero.
+    """
+    ytdlp = find_ytdlp()
+    if not ytdlp:
+        raise RuntimeError("yt-dlp non trovato nel bundle / PATH")
+
+    cmd = [
+        ytdlp,
+        "--flat-playlist",
+        "--dump-single-json",
+        "--no-warnings",
+        f"ytsearch{limit}:{query}",
+    ]
+    try:
+        proc = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SEC,
+            **subprocess_flags(),
+        )
+    except subprocess.TimeoutExpired as e:
+        raise RuntimeError(f"Timeout ricerca YouTube ({_TIMEOUT_SEC}s)") from e
+
+    if proc.returncode != 0:
+        tail = (proc.stderr or "").strip().splitlines()[-3:]
+        raise RuntimeError(f"yt-dlp error: {' | '.join(tail) or 'unknown'}")
+
+    try:
+        data = json.loads(proc.stdout)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"yt-dlp output non-JSON: {e}") from e
+
+    entries = data.get("entries") or []
+    result: list = []
+    for e in entries:
+        if not isinstance(e, dict):
+            continue
+        video_id = e.get("id") or ""
+        url = e.get("url") or (f"https://www.youtube.com/watch?v={video_id}" if video_id else "")
+        result.append({
+            "id": video_id,
+            "url": url,
+            "title": e.get("title") or "",
+            "channel": e.get("uploader") or e.get("channel") or "",
+            "duration_sec": int(e.get("duration") or 0),
+        })
+    return result
diff --git a/tests/test_youtube_search.py b/tests/test_youtube_search.py
new file mode 100644
index 0000000..00dda03
--- /dev/null
+++ b/tests/test_youtube_search.py
@@ -0,0 +1,84 @@
+"""Test per core.youtube_search."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+from core import youtube_search
+
+
+def _mock_ytdlp_result(entries: list) -> MagicMock:
+    """Mock subprocess.CompletedProcess con JSON stub."""
+    result = MagicMock()
+    result.returncode = 0
+    result.stdout = json.dumps({"entries": entries})
+    result.stderr = ""
+    return result
+
+
+class TestSearchYoutube:
+    def test_parses_entries(self):
+        entries = [
+            {
+                "id": "abc123",
+                "url": "https://www.youtube.com/watch?v=abc123",
+                "title": "Kapuchon - Hot Sauce (Official Video)",
+                "uploader": "Kapuchon Official",
+                "duration": 336,
+            },
+            {
+                "id": "def456",
+                "url": "https://www.youtube.com/watch?v=def456",
+                "title": "Solomun @ Cocoricò 2024",
+                "uploader": "Cocoricò",
+                "duration": 3600,
+            },
+        ]
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result(entries)):
+            result = youtube_search.search_youtube("kapuchon hot sauce", limit=50)
+        assert len(result) == 2
+        assert result[0]["title"] == "Kapuchon - Hot Sauce (Official Video)"
+        assert result[0]["channel"] == "Kapuchon Official"
+        assert result[0]["duration_sec"] == 336
+        assert result[0]["url"] == "https://www.youtube.com/watch?v=abc123"
+
+    def test_empty_entries_returns_empty(self):
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result([])):
+            result = youtube_search.search_youtube("no-match", limit=50)
+        assert result == []
+
+    def test_raises_when_ytdlp_missing(self):
+        with patch("core.youtube_search.find_ytdlp", return_value=None):
+            with pytest.raises(RuntimeError, match="yt-dlp"):
+                youtube_search.search_youtube("q", limit=50)
+
+    def test_command_uses_ytsearch_with_limit(self):
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=_mock_ytdlp_result([])) as mock_run:
+            youtube_search.search_youtube("solomun", limit=30)
+        args = mock_run.call_args.args[0]
+        assert args[0] == "/fake/yt-dlp"
+        search_arg = [a for a in args if a.startswith("ytsearch")]
+        assert search_arg == ["ytsearch30:solomun"]
+
+    def test_timeout_raises_runtime_error(self):
+        import subprocess as sp
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", side_effect=sp.TimeoutExpired("yt-dlp", 30)):
+            with pytest.raises(RuntimeError, match="[Tt]imeout"):
+                youtube_search.search_youtube("q", limit=50)
+
+    def test_nonzero_exit_raises(self):
+        bad = MagicMock()
+        bad.returncode = 1
+        bad.stdout = ""
+        bad.stderr = "some yt-dlp error"
+        with patch("core.youtube_search.find_ytdlp", return_value="/fake/yt-dlp"), \
+             patch("core.youtube_search.subprocess.run", return_value=bad):
+            with pytest.raises(RuntimeError, match="yt-dlp"):
+                youtube_search.search_youtube("q", limit=50)

From 67e48e54f777c38ce7f6dc1eae5cc8f17bad5127 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:22:46 +0200
Subject: [PATCH 06/10] downloader+bridge: supporto download da URL diretti
 (YouTube search flow)

Aggiunge download_urls() in core/downloader.py che scarica direttamente da
URL YouTube gia noti (bypassa lo step di ricerca). Usa gli stessi flag di
download_playlist (mp3, embed thumbnail/metadata, output template, cookies,
ffmpeg location) e il parsing progress via stdout.

In api/bridge.py aggiunge start_urls_download() e _urls_worker() speculari a
start_tracks_download/_tracks_worker. Consumati dal tab "YouTube Search"
dopo che l'utente ha selezionato i risultati.
---
 api/bridge.py      |  81 ++++++++++++++++++++++++++++++
 core/downloader.py | 119 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 200 insertions(+)

diff --git a/api/bridge.py b/api/bridge.py
index fd47c6b..d2d253b 100644
--- a/api/bridge.py
+++ b/api/bridge.py
@@ -544,6 +544,40 @@ class Api:
         self._download_thread.start()
         return {"ok": True}
 
+    def start_urls_download(self, payload: dict) -> dict:
+        """Analogo a start_tracks_download ma accetta URL YouTube gia noti
+        (bypass search). Usato dal flow del tab 'YouTube Search'."""
+        if self._any_job_running():
+            return {"ok": False, "error": "Un download gia in corso"}
+
+        urls = payload.get("urls") or []
+        titles = payload.get("titles") or []
+        output_dir = (payload.get("output_dir") or "").strip()
+        subfolder = (payload.get("subfolder") or "").strip()
+        if not urls:
+            return {"ok": False, "error": "Nessuna URL fornita"}
+        if len(urls) != len(titles):
+            return {"ok": False, "error": "urls e titles devono avere stessa lunghezza"}
+        if not output_dir:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        if subfolder:
+            safe = subfolder.replace("/", "_").replace("\\", "_").strip()
+            if safe:
+                output_dir = os.path.join(output_dir, safe)
+
+        gate = self._gate("audio")
+        if gate:
+            return gate
+
+        self._download_thread = threading.Thread(
+            target=self._urls_worker,
+            args=(list(urls), list(titles), output_dir),
+            daemon=True,
+        )
+        self._download_thread.start()
+        return {"ok": True}
+
     def stop_download(self) -> dict:
         request_download_stop()
         self._log("download", "[INFO] Interruzione richiesta...")
@@ -601,6 +635,53 @@ class Api:
         download_playlist(tracks, output_dir, bitrate, cookies_path, progress_cb)
         self._emit("download:done", {"ok": True})
 
+    def _urls_worker(self, urls: list, titles: list, output_dir: str) -> None:
+        from core.downloader import download_urls
+        reset_download_stop()
+        cfg = load_config()
+        bitrate = cfg.get("bitrate", "320K")
+        cookies_path = cfg.get("cookies_path", "")
+        view = "download"
+
+        self._log(view, f"[INFO] URL list: {len(urls)} da scaricare da YouTube")
+        self._log(view, f"[INFO] Destinazione: {output_dir}")
+
+        _last = [0.0]
+        _THROTTLE = 0.10
+
+        def progress_cb(idx, total, title, status, pct):
+            if status == "downloading":
+                now = time.monotonic()
+                if now - _last[0] < _THROTTLE:
+                    return
+                _last[0] = now
+
+            payload_evt = {
+                "idx": idx, "total": total, "track": title,
+                "status": status, "pct": pct,
+                "url_idx": 0, "url_total": 1,
+            }
+            if status == "skipped":
+                self._log(view, f"[SKIP] {title} (gia scaricato)")
+                payload_evt["overall"] = min((idx + 1) / total, 1.0) if total else 1
+            elif status == "downloading":
+                payload_evt["overall"] = min((idx / total) + (pct / 100 / total), 1.0) if total else 0
+            elif status == "done":
+                self._log(view, f"[OK] {title}")
+                payload_evt["overall"] = min((idx + 1) / total, 1.0) if total else 1
+            elif status == "stopped":
+                self._log(view, "[INFO] Download interrotto.")
+            elif status == "completed":
+                payload_evt["overall"] = 1.0
+                self._log(view, "[INFO] Download completato!")
+            elif status.startswith("error"):
+                self._log(view, f"[ERRORE] {title}: {status}")
+
+            self._emit("download:progress", payload_evt)
+
+        download_urls(urls, titles, output_dir, bitrate, cookies_path, progress_cb)
+        self._emit("download:done", {"ok": True})
+
     def _download_worker(self, urls: list, output_dir: str) -> None:
         reset_download_stop()
         cfg = load_config()
diff --git a/core/downloader.py b/core/downloader.py
index e28151f..1aeaab6 100644
--- a/core/downloader.py
+++ b/core/downloader.py
@@ -399,6 +399,125 @@ def download_direct_url(
         progress_callback(total, total, "", "completed", 100)
 
 
+def download_urls(
+    urls: list,
+    titles: list,
+    output_dir: str,
+    bitrate: str = "320K",
+    cookies_path: Optional[str] = None,
+    progress_callback: Optional[Callable] = None,
+) -> None:
+    """Scarica direttamente da URL YouTube (bypassa search).
+
+    Usa gli stessi flag yt-dlp di download_playlist. La differenza e che
+    salta lo step di ricerca perche l'URL e gia noto (usato dal flow del
+    tab "YouTube Search" dopo che l'utente ha selezionato i risultati).
+
+    Args:
+        urls: lista URL YouTube (parallela a titles)
+        titles: lista titoli video (per logging/dedupe)
+        output_dir: cartella destinazione
+        bitrate: qualita audio (default 320K)
+        cookies_path: file cookies opzionale
+        progress_callback: callback(idx, total, title, status, percent)
+    """
+    global _current_process
+    reset_stop()
+    total = len(urls)
+    out_path = Path(output_dir)
+    out_path.mkdir(parents=True, exist_ok=True)
+    done_file = out_path / ".downloaded_tracks"
+    done_set = _load_done_set(done_file)
+    existing_files = _scan_existing_files(out_path)
+    ytdlp = find_ytdlp()
+
+    for i, (url, title) in enumerate(zip(urls, titles)):
+        if is_stopped():
+            if progress_callback:
+                progress_callback(i, total, "", "stopped", 0)
+            return
+
+        key = title or url
+
+        # Salta se gia scaricato (file di tracking)
+        if key in done_set:
+            if progress_callback:
+                progress_callback(i, total, key, "skipped", 100)
+            continue
+
+        # Salta se esiste gia un file corrispondente nella cartella
+        if title and _file_exists_for_query(title, existing_files):
+            _mark_done(done_file, key)
+            done_set.add(key)
+            if progress_callback:
+                progress_callback(i, total, key, "skipped", 100)
+            continue
+
+        if progress_callback:
+            progress_callback(i, total, key, "downloading", 0)
+
+        cmd = [
+            ytdlp,
+            "--extract-audio",
+            "--audio-format", "mp3",
+            "--audio-quality", bitrate.rstrip("Kk"),
+            "--embed-thumbnail",
+            "--add-metadata",
+            "--no-check-certificates",
+            "--newline",
+            "--output", str(Path(output_dir) / "%(title)s.%(ext)s"),
+            url,
+        ]
+        ffmpeg_dir = find_ffmpeg_dir()
+        if ffmpeg_dir:
+            cmd.extend(["--ffmpeg-location", ffmpeg_dir])
+        if cookies_path and Path(cookies_path).exists():
+            cmd.extend(["--cookies", cookies_path])
+
+        try:
+            with _process_lock:
+                _current_process = subprocess.Popen(
+                    cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+                    **subprocess_flags(),
+                )
+
+            for line in _current_process.stdout:
+                if is_stopped():
+                    _current_process.terminate()
+                    if progress_callback:
+                        progress_callback(i, total, key, "stopped", 0)
+                    return
+
+                pct_match = re.search(r"(\d+(?:\.\d+)?)%", line)
+                if pct_match and progress_callback:
+                    pct = int(float(pct_match.group(1)))
+                    progress_callback(i, total, key, "downloading", pct)
+
+            return_code = _current_process.wait()
+
+            with _process_lock:
+                _current_process = None
+
+            if return_code == 0:
+                _mark_done(done_file, key)
+                done_set.add(key)
+                existing_files = _scan_existing_files(out_path)
+                if progress_callback:
+                    progress_callback(i, total, key, "done", 100)
+            else:
+                if progress_callback:
+                    progress_callback(i, total, key, f"error: yt-dlp exit {return_code}", 0)
+
+        except Exception as e:
+            with _process_lock:
+                _current_process = None
+            if progress_callback:
+                progress_callback(i, total, key, f"error: {e}", 0)
+
+    if progress_callback and not is_stopped():
+        progress_callback(total, total, "", "completed", 100)
+
+
 def _video_format(quality: str) -> str:
     """Costruisce la format string yt-dlp per la qualita richiesta."""
     if not quality or quality == "best":

From 91cfc173d4d81d30d3627d5e385231430d7ee48b Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:23:49 +0200
Subject: [PATCH 07/10] config: v1.8.1 + 3 campi DEFAULTS per music search

---
 core/config.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/core/config.py b/core/config.py
index 5dddc45..96a759f 100644
--- a/core/config.py
+++ b/core/config.py
@@ -5,7 +5,7 @@ import os
 import sys
 from pathlib import Path
 
-VERSION = "v1.8.0"
+VERSION = "v1.8.1"
 
 
 APP_NAME = "MusicTools"
@@ -72,6 +72,10 @@ DEFAULTS = {
     "theme": "dark",
     # ---- Beatport ----
     "beatport_last_genre": "melodic-house-techno",  # ultimo genere Top 100 caricato
+    # ---- Music Search (Spotify + YouTube) ----
+    "spotify_search_last_query": "",
+    "spotify_search_artist_mode": False,
+    "youtube_search_last_query": "",
     # ---- Licenza ----
     "license_key": "",          # chiave fornita all'utente via email
     "license_email": "",        # email associata all'acquisto

From 9ea14eb81c80896b58afba8fe4c643720e964753 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:25:58 +0200
Subject: [PATCH 08/10] bridge: 6 metodi Api per music search (Spotify +
 YouTube)

---
 api/bridge.py | 185 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 184 insertions(+), 1 deletion(-)

diff --git a/api/bridge.py b/api/bridge.py
index d2d253b..f3d1033 100644
--- a/api/bridge.py
+++ b/api/bridge.py
@@ -12,8 +12,10 @@ from dataclasses import asdict
 from pathlib import Path
 from typing import Any, Optional
 
+import requests
+
 from core.config import load_config, save_config, VERSION, LICENSE_API_URL
-from core import beatport
+from core import beatport, spotify_client
 from core import license as license_mod
 from core.downloader import (
     download_playlist,
@@ -1087,3 +1089,184 @@ class Api:
             "output_dir": out_root,
             "subfolder": subfolder,
         })
+
+    # ================================================================
+    # Music Search — Spotify + YouTube
+    # ================================================================
+
+    def _music_output_dir(self, out_root: str, source: str) -> Path:
+        """Cartella target per Spotify/YouTube search. Coerente col pattern
+        di start_tracks_download (subfolder singolo, no nested)."""
+        safe = source.replace("/", "_").replace("\\", "_").strip()
+        return Path(out_root) / safe
+
+    # ---- Spotify ----
+
+    def spotify_search(self, query: str, artist_mode: bool = False) -> dict:
+        """Cerca su Spotify. Free-form (limit 50) o artist-mode (discografia)."""
+        query = (query or "").strip()
+        if not query:
+            return {"ok": False, "error": "empty_query", "message": "Query vuota"}
+
+        # Salva stato
+        try:
+            cfg = load_config()
+            cfg["spotify_search_last_query"] = query
+            cfg["spotify_search_artist_mode"] = bool(artist_mode)
+            save_config(cfg)
+        except Exception:
+            pass
+
+        cfg = load_config()
+        cid = (cfg.get("client_id") or "").strip()
+        secret = (cfg.get("client_secret") or "").strip()
+        if not cid or not secret:
+            return {"ok": False, "error": "no_creds", "message": "Credenziali Spotify mancanti"}
+
+        try:
+            token = spotify_client.get_access_token(cid, secret)
+        except Exception as e:
+            return {"ok": False, "error": "auth", "message": str(e)}
+
+        try:
+            if artist_mode:
+                tracks = spotify_client.search_artist_discography(token, query)
+            else:
+                tracks = spotify_client.search_tracks(token, query, limit=50)
+        except ValueError as e:
+            return {"ok": False, "error": "artist_not_found", "message": str(e)}
+        except requests.HTTPError as e:
+            code = e.response.status_code if e.response is not None else 0
+            if code == 429:
+                return {"ok": False, "error": "rate_limit", "message": "Spotify limitante - attendi qualche secondo"}
+            return {"ok": False, "error": "server", "message": f"Spotify HTTP {code}"}
+        except Exception as e:
+            return {"ok": False, "error": "unknown", "message": str(e)}
+
+        return {"ok": True, "tracks": tracks}
+
+    def spotify_check_existing(self, tracks: list) -> list:
+        """True per ogni track già presente in output_dir/Spotify/."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return [False] * len(tracks)
+        out_dir = self._music_output_dir(out_root, "Spotify")
+        if not out_dir.exists():
+            return [False] * len(tracks)
+        existing_stems = [p.stem.lower() for p in out_dir.glob("*.mp3")]
+        result = []
+        for t in tracks:
+            title = (t.get("name") or "").lower().strip()
+            artists = (t.get("artists") or "")
+            first_artist = artists.split(",")[0].strip().lower()
+            if not title or not first_artist:
+                result.append(False)
+                continue
+            result.append(any((title in stem and first_artist in stem) for stem in existing_stems))
+        return result
+
+    def spotify_search_download(self, tracks: list) -> dict:
+        """Scarica i track Spotify selezionati (name+artist → YouTube search)."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        target = self._music_output_dir(out_root, "Spotify")
+        subfolder = target.name
+
+        converted = []
+        for t in tracks:
+            title = (t.get("name") or "").strip()
+            artists = (t.get("artists") or "").strip()
+            if not title:
+                continue
+            converted.append({"name": title, "artist": artists})
+
+        if not converted:
+            return {"ok": False, "error": "Nessun brano valido"}
+
+        return self.start_tracks_download({
+            "tracks": converted,
+            "output_dir": out_root,
+            "subfolder": subfolder,
+        })
+
+    # ---- YouTube ----
+
+    def youtube_search(self, query: str) -> dict:
+        """Cerca 50 risultati su YouTube via yt-dlp."""
+        from core import youtube_search as yts
+
+        query = (query or "").strip()
+        if not query:
+            return {"ok": False, "error": "empty_query", "message": "Query vuota"}
+
+        try:
+            cfg = load_config()
+            cfg["youtube_search_last_query"] = query
+            save_config(cfg)
+        except Exception:
+            pass
+
+        try:
+            results = yts.search_youtube(query, limit=50)
+        except RuntimeError as e:
+            return {"ok": False, "error": "ytdlp", "message": str(e)}
+        except Exception as e:
+            return {"ok": False, "error": "unknown", "message": str(e)}
+
+        return {"ok": True, "tracks": results}
+
+    def youtube_check_existing(self, tracks: list) -> list:
+        """True per ogni track già presente in output_dir/YouTube/. Match sul titolo video."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return [False] * len(tracks)
+        out_dir = self._music_output_dir(out_root, "YouTube")
+        if not out_dir.exists():
+            return [False] * len(tracks)
+        existing_stems = [p.stem.lower() for p in out_dir.glob("*.mp3")]
+        result = []
+        for t in tracks:
+            title = (t.get("title") or "").lower().strip()
+            if not title:
+                result.append(False)
+                continue
+            result.append(any(
+                (title in stem or stem in title)
+                for stem in existing_stems
+            ))
+        return result
+
+    def youtube_search_download(self, tracks: list) -> dict:
+        """Scarica direttamente gli URL YouTube selezionati (no re-search)."""
+        cfg = load_config()
+        out_root = (cfg.get("output_dir") or "").strip()
+        if not out_root:
+            return {"ok": False, "error": "Cartella output non impostata"}
+
+        target = self._music_output_dir(out_root, "YouTube")
+        subfolder = target.name
+
+        urls: list = []
+        titles: list = []
+        for t in tracks:
+            url = (t.get("url") or "").strip()
+            title = (t.get("title") or "").strip()
+            if not url or not title:
+                continue
+            urls.append(url)
+            titles.append(title)
+
+        if not urls:
+            return {"ok": False, "error": "Nessun URL valido"}
+
+        return self.start_urls_download({
+            "urls": urls,
+            "titles": titles,
+            "output_dir": out_root,
+            "subfolder": subfolder,
+        })

From 83c47df29c74ad6e7a7cbbd1fbd04258626782f5 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:31:41 +0200
Subject: [PATCH 09/10] ui: markup tab Spotify + YouTube search

---
 webui/index.html | 125 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)

diff --git a/webui/index.html b/webui/index.html
index a54f68c..b67d72f 100644
--- a/webui/index.html
+++ b/webui/index.html
@@ -33,6 +33,14 @@
           <span class="nav-icon">🎧</span>
           <span>Beatport</span>
         </button>
+        <button class="nav-item" data-view="spotify" data-feature="audio">
+          <span class="nav-icon">🟢</span>
+          <span>Spotify</span>
+        </button>
+        <button class="nav-item" data-view="youtube" data-feature="audio">
+          <span class="nav-icon">▶</span>
+          <span>YouTube</span>
+        </button>
         <button class="nav-item" data-view="upgrade" data-feature="upgrade">
           <span class="nav-icon">⚡</span>
           <span>Upgrade</span>
@@ -910,6 +918,123 @@
         </div>
       </section>
 
+      <!-- ===== VIEW: SPOTIFY SEARCH ===== -->
+      <section class="view" id="view-spotify">
+        <header class="hero hero-indigo">
+          <div class="hero-content">
+            <div class="hero-eyebrow indigo">RICERCA SPOTIFY</div>
+            <h1 class="hero-title">Cerca brani su Spotify</h1>
+            <p class="hero-subtitle">Digita un artista, un titolo, o entrambi. Attiva "Solo artista" per scaricare tutta la discografia.</p>
+          </div>
+          <div class="hero-deco">🟢</div>
+        </header>
+
+        <h2 class="section-label">Ricerca</h2>
+        <div class="card">
+          <div class="beatport-header">
+            <input type="text" id="spotify-query" class="input pill" placeholder="Es: Solomun, Hot Sauce, Kapuchon Hot Sauce…" style="flex:1; min-width:260px;" />
+            <label style="display:flex; gap:6px; align-items:center; color:var(--text-2); font-size:13px;">
+              <input type="checkbox" id="spotify-artist-mode" />
+              <span>Solo artista (discografia)</span>
+            </label>
+            <button class="btn btn-primary pill" id="spotify-search-btn">
+              <span class="ico">🔎</span> Cerca
+            </button>
+          </div>
+          <div id="spotify-status" class="beatport-status"></div>
+          <div id="spotify-output-info" class="beatport-output-info"></div>
+        </div>
+
+        <div class="card beatport-table-card" id="spotify-table-wrap" hidden>
+          <div class="beatport-table-wrap">
+            <table class="beatport-table" id="spotify-table">
+              <thead>
+                <tr>
+                  <th class="col-check"><input type="checkbox" id="spotify-select-all" checked /></th>
+                  <th class="col-pos">#</th>
+                  <th>Artista</th>
+                  <th>Titolo</th>
+                  <th>Album</th>
+                  <th class="col-dur">Durata</th>
+                  <th class="col-state"></th>
+                </tr>
+              </thead>
+              <tbody id="spotify-tbody"></tbody>
+            </table>
+          </div>
+          <div class="beatport-toolbar" id="spotify-toolbar">
+            <span class="counter" id="spotify-selected-count">0/0 selezionati</span>
+            <button class="btn btn-primary pill" id="spotify-download-btn" disabled>
+              <span class="ico">▶</span> Scarica selezionati
+            </button>
+            <button class="btn btn-danger pill" id="spotify-stop-btn" hidden>
+              <span class="ico">◼</span> Interrompi
+            </button>
+          </div>
+        </div>
+
+        <h2 class="section-label">Log</h2>
+        <div class="card log-card">
+          <div class="log" id="spotify-log"></div>
+        </div>
+      </section>
+
+      <!-- ===== VIEW: YOUTUBE SEARCH ===== -->
+      <section class="view" id="view-youtube">
+        <header class="hero hero-indigo">
+          <div class="hero-content">
+            <div class="hero-eyebrow indigo">RICERCA YOUTUBE</div>
+            <h1 class="hero-title">Cerca video su YouTube</h1>
+            <p class="hero-subtitle">Perfetto per mix DJ, unreleased, bootleg e brani non presenti su Spotify.</p>
+          </div>
+          <div class="hero-deco">▶</div>
+        </header>
+
+        <h2 class="section-label">Ricerca</h2>
+        <div class="card">
+          <div class="beatport-header">
+            <input type="text" id="youtube-query" class="input pill" placeholder="Es: Solomun Cocoricò 2024, Kapuchon Hot Sauce remix…" style="flex:1; min-width:260px;" />
+            <button class="btn btn-primary pill" id="youtube-search-btn">
+              <span class="ico">🔎</span> Cerca
+            </button>
+          </div>
+          <div id="youtube-status" class="beatport-status"></div>
+          <div id="youtube-output-info" class="beatport-output-info"></div>
+        </div>
+
+        <div class="card beatport-table-card" id="youtube-table-wrap" hidden>
+          <div class="beatport-table-wrap">
+            <table class="beatport-table" id="youtube-table">
+              <thead>
+                <tr>
+                  <th class="col-check"><input type="checkbox" id="youtube-select-all" checked /></th>
+                  <th class="col-pos">#</th>
+                  <th>Titolo video</th>
+                  <th>Canale</th>
+                  <th class="col-dur">Durata</th>
+                  <th class="col-state"></th>
+                </tr>
+              </thead>
+              <tbody id="youtube-tbody"></tbody>
+            </table>
+          </div>
+          <div class="beatport-toolbar" id="youtube-toolbar">
+            <span class="counter" id="youtube-selected-count">0/0 selezionati</span>
+            <button class="btn btn-primary pill" id="youtube-download-btn" disabled>
+              <span class="ico">▶</span> Scarica selezionati
+            </button>
+            <button class="btn btn-danger pill" id="youtube-stop-btn" hidden>
+              <span class="ico">◼</span> Interrompi
+            </button>
+          </div>
+        </div>
+
+        <h2 class="section-label">Log</h2>
+        <div class="card log-card">
+          <div class="log" id="youtube-log"></div>
+        </div>
+      </section>
+
     </main>
   </div>
 

From 1fa49fabc4d57c21976fa43eefdf27bd20d2b600 Mon Sep 17 00:00:00 2001
From: luciano <info@djluza.com>
Date: Tue, 14 Jul 2026 17:31:48 +0200
Subject: [PATCH 10/10] ui: SpotifyUI + YoutubeUI (search, table, download,
 log)

---
 webui/js/app.js | 464 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 464 insertions(+)

diff --git a/webui/js/app.js b/webui/js/app.js
index 7443ddd..90c39b2 100644
--- a/webui/js/app.js
+++ b/webui/js/app.js
@@ -397,6 +397,8 @@ const logEls = {
   download: () => $("#dlLog"),
   upgrade: () => $("#upLog"),
   video: () => $("#videoLog"),
+  spotify: () => $("#spotify-log"),
+  youtube: () => $("#youtube-log"),
 };
 
 function classifyLog(msg) {
@@ -504,6 +506,10 @@ async function init() {
 
   // Beatport tab — popola generi, ripristina ultimo genere, aggancia handler
   await BeatportUI.init();
+
+  // Spotify + YouTube search tabs
+  await SpotifyUI.init();
+  await YoutubeUI.init();
 }
 
 async function refreshRecDevices() {
@@ -1463,6 +1469,464 @@ const BeatportUI = (function () {
   return { init };
 })();
 
+// =====================================================================
+// Spotify search
+// =====================================================================
+const SpotifyUI = (() => {
+  // NOTE: local module state — named `mstate` to NOT shadow the outer
+  // module-level `state` (which holds `state.config`).
+  const mstate = { tracks: [], existing: [], downloading: false };
+
+  function _escape(s) {
+    const d = document.createElement("div");
+    d.textContent = s == null ? "" : String(s);
+    return d.innerHTML;
+  }
+
+  function _fmtDuration(sec) {
+    const n = Math.max(0, Math.floor(Number(sec) || 0));
+    const m = Math.floor(n / 60);
+    const s = n % 60;
+    return `${m}:${String(s).padStart(2, "0")}`;
+  }
+
+  function updateSelectionCount() {
+    const boxes = $$("#spotify-tbody input[type=checkbox]");
+    const total = boxes.length;
+    const selected = boxes.filter((b) => b.checked).length;
+    $("#spotify-selected-count").textContent = `${selected}/${total} selezionati`;
+    const btn = $("#spotify-download-btn");
+    if (btn) {
+      btn.disabled = mstate.downloading || selected === 0;
+      btn.innerHTML = `<span class="ico">▶</span> Scarica selezionati${selected ? ` (${selected})` : ""}`;
+    }
+    const sa = $("#spotify-select-all");
+    if (sa) {
+      if (total === 0) { sa.checked = false; sa.indeterminate = false; }
+      else if (selected === 0) { sa.checked = false; sa.indeterminate = false; }
+      else if (selected === total) { sa.checked = true; sa.indeterminate = false; }
+      else { sa.checked = false; sa.indeterminate = true; }
+    }
+  }
+
+  function renderTable() {
+    const tbody = $("#spotify-tbody");
+    if (!tbody) return;
+    tbody.innerHTML = "";
+    mstate.tracks.forEach((t, i) => {
+      const already = !!mstate.existing[i];
+      const tr = document.createElement("tr");
+      tr.dataset.idx = String(i);
+      if (already) tr.classList.add("already-downloaded");
+      tr.innerHTML = `
+        <td class="col-check"><input type="checkbox" data-idx="${i}" ${already ? "" : "checked"} /></td>
+        <td class="col-pos">${i + 1}</td>
+        <td>${_escape(t.artists)}</td>
+        <td>${_escape(t.name)}</td>
+        <td>${_escape(t.album)}</td>
+        <td class="col-dur">${_fmtDuration(t.duration_sec)}</td>
+        <td class="col-state">${already ? "✓ già scaricato" : ""}</td>
+      `;
+      const cb = tr.querySelector("input[type=checkbox]");
+      if (cb) cb.addEventListener("change", updateSelectionCount);
+      tbody.appendChild(tr);
+    });
+    updateSelectionCount();
+  }
+
+  function setStatus(text, kind) {
+    const el = $("#spotify-status");
+    if (!el) return;
+    el.textContent = text || "";
+    el.className = "beatport-status" + (kind ? " " + kind : "");
+  }
+
+  function updateOutputInfo() {
+    const info = $("#spotify-output-info");
+    if (!info) return;
+    const root = (state.config && state.config.output_dir) || "";
+    if (!root) {
+      info.textContent = "⚠ Imposta la cartella output in Impostazioni prima di scaricare";
+      info.className = "beatport-output-info warn";
+    } else {
+      info.textContent = `Destinazione: ${root}/Spotify`;
+      info.className = "beatport-output-info";
+    }
+  }
+
+  async function doSearch() {
+    const q = ($("#spotify-query").value || "").trim();
+    if (!q) return;
+    const artistMode = $("#spotify-artist-mode").checked;
+    const wrap = $("#spotify-table-wrap");
+
+    setStatus("Ricerca in corso…", "loading");
+    if (wrap) wrap.hidden = true;
+
+    let res;
+    try {
+      res = await window.pywebview.api.spotify_search(q, artistMode);
+    } catch (e) {
+      setStatus("Errore: " + ((e && e.message) || e), "error");
+      return;
+    }
+    if (!res || !res.ok) {
+      const errKey = res && res.error;
+      const messages = {
+        empty_query: "Inserisci una query di ricerca.",
+        no_creds: "Credenziali Spotify mancanti. Vai su Impostazioni.",
+        auth: "Impossibile autenticarsi con Spotify. Verifica le credenziali.",
+      };
+      setStatus(messages[errKey] || (res && res.message) || "Errore sconosciuto", "error");
+      return;
+    }
+
+    mstate.tracks = res.tracks || [];
+    if (mstate.tracks.length === 0) {
+      setStatus(`Nessun brano trovato per "${q}".`, "");
+      return;
+    }
+    try {
+      mstate.existing = await window.pywebview.api.spotify_check_existing(mstate.tracks);
+    } catch (_e) {
+      mstate.existing = mstate.tracks.map(() => false);
+    }
+
+    setStatus(`${mstate.tracks.length} risultati`, "ok");
+    updateOutputInfo();
+    renderTable();
+    if (wrap) wrap.hidden = false;
+  }
+
+  function appendSpotifyLog(msg) {
+    const el = $("#spotify-log");
+    if (!el) return;
+    const cls = classifyLog(msg);
+    const line = document.createElement("div");
+    if (cls) line.className = cls;
+    line.textContent = msg;
+    el.appendChild(line);
+    el.scrollTop = el.scrollHeight;
+  }
+
+  async function startDownload() {
+    const boxes = $$("#spotify-tbody input[type=checkbox]");
+    const selected = [];
+    boxes.forEach((b) => {
+      if (b.checked) {
+        const idx = parseInt(b.dataset.idx, 10);
+        if (!isNaN(idx) && mstate.tracks[idx]) selected.push(mstate.tracks[idx]);
+      }
+    });
+    if (!selected.length) {
+      toast("Seleziona almeno un brano", "error");
+      return;
+    }
+    if (!state.config || !state.config.output_dir) {
+      toast("Imposta la cartella output in Impostazioni", "error");
+      return;
+    }
+
+    mstate.downloading = true;
+    $("#spotify-download-btn").disabled = true;
+    $("#spotify-stop-btn").hidden = false;
+    $("#spotify-stop-btn").disabled = false;
+    $("#spotify-log").innerHTML = "";
+    appendSpotifyLog(`[INFO] Avvio download di ${selected.length} brani…`);
+
+    let res;
+    try {
+      res = await window.pywebview.api.spotify_search_download(selected);
+    } catch (e) {
+      appendSpotifyLog("[ERRORE] " + ((e && e.message) || e));
+      finishDownload();
+      return;
+    }
+    if (!res || !res.ok) {
+      const errMsg = (res && (res.error || res.message)) || "Impossibile avviare il download";
+      appendSpotifyLog("[ERRORE] " + errMsg);
+      if (!handleGateBlock(res || {})) toast(errMsg, "error");
+      finishDownload();
+    }
+  }
+
+  async function stopDownload() {
+    try { await window.pywebview.api.stop_download(); } catch (e) { console.error(e); }
+  }
+
+  function finishDownload() {
+    mstate.downloading = false;
+    $("#spotify-stop-btn").hidden = true;
+    $("#spotify-stop-btn").disabled = true;
+    updateSelectionCount();
+    if (mstate.tracks.length) {
+      window.pywebview.api.spotify_check_existing(mstate.tracks)
+        .then((r) => { mstate.existing = r || mstate.existing; renderTable(); })
+        .catch(() => {});
+    }
+  }
+
+  async function init() {
+    // Pre-compila da config
+    try {
+      const q = (state.config && state.config.spotify_search_last_query) || "";
+      const am = !!(state.config && state.config.spotify_search_artist_mode);
+      const qi = $("#spotify-query");
+      if (qi && q) qi.value = q;
+      const ac = $("#spotify-artist-mode");
+      if (ac) ac.checked = am;
+    } catch (_e) { /* ignora */ }
+
+    updateOutputInfo();
+
+    $("#spotify-search-btn").addEventListener("click", doSearch);
+    $("#spotify-query").addEventListener("keydown", (e) => { if (e.key === "Enter") doSearch(); });
+    $("#spotify-select-all").addEventListener("change", (e) => {
+      $$("#spotify-tbody input[type=checkbox]").forEach((b) => { b.checked = e.target.checked; });
+      updateSelectionCount();
+    });
+    $("#spotify-download-btn").addEventListener("click", startDownload);
+    $("#spotify-stop-btn").addEventListener("click", stopDownload);
+
+    // Wrap bridge handlers additivamente
+    const origLog = bridgeHandlers["log"];
+    bridgeHandlers["log"] = (payload) => {
+      if (origLog) origLog(payload);
+      if (mstate.downloading && payload && payload.view === "download") {
+        appendSpotifyLog(payload.msg);
+      }
+    };
+    const origDone = bridgeHandlers["download:done"];
+    bridgeHandlers["download:done"] = (payload) => {
+      if (origDone) origDone(payload);
+      if (mstate.downloading) finishDownload();
+    };
+  }
+
+  return { init };
+})();
+
+// =====================================================================
+// YouTube search
+// =====================================================================
+const YoutubeUI = (() => {
+  const mstate = { tracks: [], existing: [], downloading: false };
+
+  function _escape(s) {
+    const d = document.createElement("div");
+    d.textContent = s == null ? "" : String(s);
+    return d.innerHTML;
+  }
+  function _fmtDuration(sec) {
+    const n = Math.max(0, Math.floor(Number(sec) || 0));
+    const m = Math.floor(n / 60);
+    const s = n % 60;
+    return `${m}:${String(s).padStart(2, "0")}`;
+  }
+
+  function updateSelectionCount() {
+    const boxes = $$("#youtube-tbody input[type=checkbox]");
+    const total = boxes.length;
+    const selected = boxes.filter((b) => b.checked).length;
+    $("#youtube-selected-count").textContent = `${selected}/${total} selezionati`;
+    const btn = $("#youtube-download-btn");
+    if (btn) {
+      btn.disabled = mstate.downloading || selected === 0;
+      btn.innerHTML = `<span class="ico">▶</span> Scarica selezionati${selected ? ` (${selected})` : ""}`;
+    }
+    const sa = $("#youtube-select-all");
+    if (sa) {
+      if (total === 0) { sa.checked = false; sa.indeterminate = false; }
+      else if (selected === 0) { sa.checked = false; sa.indeterminate = false; }
+      else if (selected === total) { sa.checked = true; sa.indeterminate = false; }
+      else { sa.checked = false; sa.indeterminate = true; }
+    }
+  }
+
+  function renderTable() {
+    const tbody = $("#youtube-tbody");
+    if (!tbody) return;
+    tbody.innerHTML = "";
+    mstate.tracks.forEach((t, i) => {
+      const already = !!mstate.existing[i];
+      const tr = document.createElement("tr");
+      tr.dataset.idx = String(i);
+      if (already) tr.classList.add("already-downloaded");
+      tr.innerHTML = `
+        <td class="col-check"><input type="checkbox" data-idx="${i}" ${already ? "" : "checked"} /></td>
+        <td class="col-pos">${i + 1}</td>
+        <td>${_escape(t.title)}</td>
+        <td>${_escape(t.channel)}</td>
+        <td class="col-dur">${_fmtDuration(t.duration_sec)}</td>
+        <td class="col-state">${already ? "✓ già scaricato" : ""}</td>
+      `;
+      const cb = tr.querySelector("input[type=checkbox]");
+      if (cb) cb.addEventListener("change", updateSelectionCount);
+      tbody.appendChild(tr);
+    });
+    updateSelectionCount();
+  }
+
+  function setStatus(text, kind) {
+    const el = $("#youtube-status");
+    if (!el) return;
+    el.textContent = text || "";
+    el.className = "beatport-status" + (kind ? " " + kind : "");
+  }
+
+  function updateOutputInfo() {
+    const info = $("#youtube-output-info");
+    if (!info) return;
+    const root = (state.config && state.config.output_dir) || "";
+    if (!root) {
+      info.textContent = "⚠ Imposta la cartella output in Impostazioni prima di scaricare";
+      info.className = "beatport-output-info warn";
+    } else {
+      info.textContent = `Destinazione: ${root}/YouTube`;
+      info.className = "beatport-output-info";
+    }
+  }
+
+  async function doSearch() {
+    const q = ($("#youtube-query").value || "").trim();
+    if (!q) return;
+    const wrap = $("#youtube-table-wrap");
+
+    setStatus("Ricerca su YouTube in corso…", "loading");
+    if (wrap) wrap.hidden = true;
+
+    let res;
+    try {
+      res = await window.pywebview.api.youtube_search(q);
+    } catch (e) {
+      setStatus("Errore: " + ((e && e.message) || e), "error");
+      return;
+    }
+    if (!res || !res.ok) {
+      setStatus((res && res.message) || "Errore sconosciuto", "error");
+      return;
+    }
+
+    mstate.tracks = res.tracks || [];
+    if (mstate.tracks.length === 0) {
+      setStatus(`Nessun video trovato per "${q}".`, "");
+      return;
+    }
+    try {
+      mstate.existing = await window.pywebview.api.youtube_check_existing(mstate.tracks);
+    } catch (_e) {
+      mstate.existing = mstate.tracks.map(() => false);
+    }
+
+    setStatus(`${mstate.tracks.length} risultati`, "ok");
+    updateOutputInfo();
+    renderTable();
+    if (wrap) wrap.hidden = false;
+  }
+
+  function appendYoutubeLog(msg) {
+    const el = $("#youtube-log");
+    if (!el) return;
+    const cls = classifyLog(msg);
+    const line = document.createElement("div");
+    if (cls) line.className = cls;
+    line.textContent = msg;
+    el.appendChild(line);
+    el.scrollTop = el.scrollHeight;
+  }
+
+  async function startDownload() {
+    const boxes = $$("#youtube-tbody input[type=checkbox]");
+    const selected = [];
+    boxes.forEach((b) => {
+      if (b.checked) {
+        const idx = parseInt(b.dataset.idx, 10);
+        if (!isNaN(idx) && mstate.tracks[idx]) selected.push(mstate.tracks[idx]);
+      }
+    });
+    if (!selected.length) {
+      toast("Seleziona almeno un video", "error");
+      return;
+    }
+    if (!state.config || !state.config.output_dir) {
+      toast("Imposta la cartella output in Impostazioni", "error");
+      return;
+    }
+
+    mstate.downloading = true;
+    $("#youtube-download-btn").disabled = true;
+    $("#youtube-stop-btn").hidden = false;
+    $("#youtube-stop-btn").disabled = false;
+    $("#youtube-log").innerHTML = "";
+    appendYoutubeLog(`[INFO] Avvio download di ${selected.length} video…`);
+
+    let res;
+    try {
+      res = await window.pywebview.api.youtube_search_download(selected);
+    } catch (e) {
+      appendYoutubeLog("[ERRORE] " + ((e && e.message) || e));
+      finishDownload();
+      return;
+    }
+    if (!res || !res.ok) {
+      const errMsg = (res && (res.error || res.message)) || "Impossibile avviare il download";
+      appendYoutubeLog("[ERRORE] " + errMsg);
+      if (!handleGateBlock(res || {})) toast(errMsg, "error");
+      finishDownload();
+    }
+  }
+
+  async function stopDownload() {
+    try { await window.pywebview.api.stop_download(); } catch (e) { console.error(e); }
+  }
+
+  function finishDownload() {
+    mstate.downloading = false;
+    $("#youtube-stop-btn").hidden = true;
+    $("#youtube-stop-btn").disabled = true;
+    updateSelectionCount();
+    if (mstate.tracks.length) {
+      window.pywebview.api.youtube_check_existing(mstate.tracks)
+        .then((r) => { mstate.existing = r || mstate.existing; renderTable(); })
+        .catch(() => {});
+    }
+  }
+
+  async function init() {
+    try {
+      const q = (state.config && state.config.youtube_search_last_query) || "";
+      const qi = $("#youtube-query");
+      if (qi && q) qi.value = q;
+    } catch (_e) { /* ignora */ }
+
+    updateOutputInfo();
+
+    $("#youtube-search-btn").addEventListener("click", doSearch);
+    $("#youtube-query").addEventListener("keydown", (e) => { if (e.key === "Enter") doSearch(); });
+    $("#youtube-select-all").addEventListener("change", (e) => {
+      $$("#youtube-tbody input[type=checkbox]").forEach((b) => { b.checked = e.target.checked; });
+      updateSelectionCount();
+    });
+    $("#youtube-download-btn").addEventListener("click", startDownload);
+    $("#youtube-stop-btn").addEventListener("click", stopDownload);
+
+    const origLog = bridgeHandlers["log"];
+    bridgeHandlers["log"] = (payload) => {
+      if (origLog) origLog(payload);
+      if (mstate.downloading && payload && payload.view === "download") {
+        appendYoutubeLog(payload.msg);
+      }
+    };
+    const origDone = bridgeHandlers["download:done"];
+    bridgeHandlers["download:done"] = (payload) => {
+      if (origDone) origDone(payload);
+      if (mstate.downloading) finishDownload();
+    };
+  }
+
+  return { init };
+})();
+
 // ============================================================
 // Boot
 // ============================================================