From 2e14256dedbdbef48086d1d8b80a232487f6d110 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 20:33:22 +0200 Subject: [PATCH 01/12] =?UTF-8?q?Neuer=20GastZugang-Service=20f=C3=BCr=20d?= =?UTF-8?q?en=20anonymen=20YouTube-Gast-Zugang?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Analog zu BakaAuth, aber ohne Passwort: holt/speichert einen geräte-gebundenen Gast-Token vom neuen /api/guest-token-Endpunkt (siehe docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md). Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_$(uuidgen | cut -d- -f1) --- lib/services/gast_zugang.dart | 82 +++++++++++++++++++ test/services/gast_zugang_test.dart | 120 ++++++++++++++++++++++++++++ 2 files changed, 202 insertions(+) create mode 100644 lib/services/gast_zugang.dart create mode 100644 test/services/gast_zugang_test.dart diff --git a/lib/services/gast_zugang.dart b/lib/services/gast_zugang.dart new file mode 100644 index 0000000..4df938a --- /dev/null +++ b/lib/services/gast_zugang.dart @@ -0,0 +1,82 @@ +import 'dart:convert'; + +import 'package:flutter/foundation.dart'; +import 'package:http/http.dart' as http; + +import 'baka_auth.dart' show TokenSpeicher, SicherenSpeicher; +import 'yt_download_service.dart'; + +/// Anonymer Gast-Zugang zum YouTube-Proxy: kein Passwort, aber mit +/// serverseitig durchgesetztem Tages-Limit (der Proxy zählt und meldet den +/// Stand über `guest_remaining` in der yt-dl-Antwort zurück). Ergänzt +/// [BakaAuth]/`baka_auth.dart`, ersetzt es nicht. +class GastZugang extends ChangeNotifier { + GastZugang({http.Client? client, TokenSpeicher? speicher}) + : _client = client ?? http.Client(), + _speicher = speicher ?? const SicherenSpeicher(); + + static const proxyUrl = YtDownloadService.proxyUrl; + static const _tokenKey = 'guest_token'; + + final http.Client _client; + final TokenSpeicher _speicher; + + String? _token; + int? _verbleibend; + + bool get hatToken => _token != null && _token!.isNotEmpty; + + /// Zuletzt vom Server gemeldeter Kontingent-Stand — nur fürs Anzeigen, + /// die Wahrheit bleibt beim Server. `null` vor dem ersten Download. + int? get verbleibend => _verbleibend; + + /// Header für Anfragen an den Proxy. Ohne Token leer. + Map get gastHeader => + {if (hatToken) 'X-Guest-Token': _token!}; + + /// Stellt einen früher geholten Gast-Token wieder her (App-Start). + Future laden() async { + _token = await _speicher.lesen(_tokenKey); + notifyListeners(); + } + + /// Holt einen neuen Gast-Token vom Proxy. Gibt `null` bei Erfolg zurück, + /// sonst den Fehlertext. + Future holeToken() async { + final http.Response antwort; + try { + antwort = await _client + .post(Uri.parse('$proxyUrl/api/guest-token')) + .timeout(const Duration(seconds: 15)); + } catch (e) { + debugPrint('Gast-Token nicht erreichbar: $e'); + return 'Proxy nicht erreichbar'; + } + + if (antwort.statusCode != 200) { + return 'Gast-Zugang fehlgeschlagen (${antwort.statusCode})'; + } + + Map daten; + try { + daten = jsonDecode(antwort.body) as Map; + } catch (_) { + return 'Proxy antwortet unverständlich (${antwort.statusCode})'; + } + + final token = daten['guest_token'] as String?; + if (token == null || token.isEmpty) { + return 'Proxy hat keinen Gast-Token geliefert'; + } + _token = token; + await _speicher.schreiben(_tokenKey, token); + notifyListeners(); + return null; + } + + /// Übernimmt den zuletzt vom Server gemeldeten Kontingent-Stand. + void merkeVerbleibend(int n) { + _verbleibend = n; + notifyListeners(); + } +} diff --git a/test/services/gast_zugang_test.dart b/test/services/gast_zugang_test.dart new file mode 100644 index 0000000..cb54fa5 --- /dev/null +++ b/test/services/gast_zugang_test.dart @@ -0,0 +1,120 @@ +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:http/http.dart' as http; +import 'package:http/testing.dart'; +import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; + +class _MemorySpeicher implements TokenSpeicher { + final Map werte = {}; + @override + Future lesen(String key) async => werte[key]; + @override + Future schreiben(String key, String wert) async => werte[key] = wert; + @override + Future loeschen(String key) async => werte.remove(key); +} + +void main() { + test('Ohne Token ist gastHeader leer', () { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + expect(gast.hatToken, isFalse); + expect(gast.gastHeader, isEmpty); + }); + + test('holeToken() speichert den Token bei Erfolg', () async { + final speicher = _MemorySpeicher(); + final gast = GastZugang( + client: MockClient( + (_) async => http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: speicher, + ); + + final fehler = await gast.holeToken(); + + expect(fehler, isNull); + expect(gast.hatToken, isTrue); + expect(gast.gastHeader, {'X-Guest-Token': 'g-1'}); + expect(speicher.werte['guest_token'], 'g-1'); + }); + + test('holeToken() meldet einen Fehler bei einer toten Verbindung', + () async { + final gast = GastZugang( + client: MockClient((_) async => throw Exception('down')), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy nicht erreichbar'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler bei einem Server-Fehlerstatus', + () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Gast-Zugang fehlgeschlagen (500)'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler bei unlesbarer Antwort', () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response('nicht json', 200)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy antwortet unverständlich (200)'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler ohne guest_token-Feld', () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response(jsonEncode({}), 200)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy hat keinen Gast-Token geliefert'); + expect(gast.hatToken, isFalse); + }); + + test('laden() stellt einen gespeicherten Gast-Token wieder her', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'g-alt'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + + await gast.laden(); + + expect(gast.hatToken, isTrue); + expect(gast.gastHeader, {'X-Guest-Token': 'g-alt'}); + }); + + test('merkeVerbleibend übernimmt den zuletzt gemeldeten Stand', () { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + gast.merkeVerbleibend(3); + + expect(gast.verbleibend, 3); + }); +} -- 2.54.0 From 1ff03c96ed4a28c8f9d8c52cea613469426503a3 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 20:45:52 +0200 Subject: [PATCH 02/12] =?UTF-8?q?YtDownloadService:=20Gast-Zugang=20neben?= =?UTF-8?q?=20Baka-Auth=20unterst=C3=BCtzen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Optionaler gast-Parameter (GastZugang) — sendet bei fehlender Baka-Anmeldung X-Guest-Token statt Authorization, übernimmt guest_remaining aus der Erfolgsantwort, holt bei 401 automatisch einen neuen Gast-Token nach. Co-Authored-By: Claude Sonnet 5 --- lib/services/yt_download_service.dart | 21 ++++-- test/services/yt_download_test.dart | 96 +++++++++++++++++++++++++++ 2 files changed, 112 insertions(+), 5 deletions(-) diff --git a/lib/services/yt_download_service.dart b/lib/services/yt_download_service.dart index 006bdf8..ce33304 100644 --- a/lib/services/yt_download_service.dart +++ b/lib/services/yt_download_service.dart @@ -6,6 +6,7 @@ import 'package:flutter/foundation.dart'; import 'package:http/http.dart' as http; import 'baka_auth.dart'; +import 'gast_zugang.dart'; /// Entfernt alles, was in einem Dateinamen Ärger macht. String sichererDateiname(String titel) => @@ -35,12 +36,13 @@ class YtErgebnis { /// Lädt Musik über den Baka-YouTube-Proxy herunter. Der Proxy erledigt die /// eigentliche Arbeit und liefert eine fertige MP3; die App speichert sie nur. class YtDownloadService extends ChangeNotifier { - YtDownloadService({required this.auth, http.Client? client}) + YtDownloadService({required this.auth, this.gast, http.Client? client}) : _client = client ?? http.Client(); static const proxyUrl = 'https://yt.baka-net.de'; final BakaAuth auth; + final GastZugang? gast; final http.Client _client; bool _laeuft = false; @@ -95,7 +97,8 @@ class YtDownloadService extends ChangeNotifier { final abbruch = _abbruch = Completer(); notifyListeners(); - if (!auth.istAngemeldet) { + final gastAktiv = !auth.istAngemeldet && (gast?.hatToken ?? false); + if (!auth.istAngemeldet && !gastAktiv) { _scheitere('Bitte zuerst beim Baka-Konto anmelden'); return null; } @@ -103,6 +106,7 @@ class YtDownloadService extends ChangeNotifier { _scheitere('Das ist keine YouTube-Adresse'); return null; } + final zugangsHeader = gastAktiv ? gast!.gastHeader : auth.authHeader; // ─── 1/2: Proxy fragen — er lädt das Video und wandelt es um ─── _melde('Proxy wird gefragt …'); @@ -113,7 +117,7 @@ class YtDownloadService extends ChangeNotifier { .post( Uri.parse('$proxyUrl/api/yt-dl'), headers: { - ...auth.authHeader, + ...zugangsHeader, 'Content-Type': 'application/json' }, body: jsonEncode({'url': url, 'cookies': cookies}), @@ -137,7 +141,10 @@ class YtDownloadService extends ChangeNotifier { } if (antwort.statusCode == 401) { - _scheitere('Anmeldung abgelaufen — bitte neu anmelden'); + if (gastAktiv) unawaited(gast!.holeToken()); + _scheitere(gastAktiv + ? 'Gast-Zugang abgelaufen — bitte erneut versuchen' + : 'Anmeldung abgelaufen — bitte neu anmelden'); return null; } if (antwort.statusCode != 200) { @@ -149,6 +156,10 @@ class YtDownloadService extends ChangeNotifier { final titel = daten['titel'] as String? ?? 'Unbekannt'; final dauer = (daten['dauer'] as int?) ?? 0; final mp3Url = daten['mp3_url'] as String? ?? '/api/dl/audio.mp3'; + final gastRest = daten['guest_remaining'] as int?; + if (gastAktiv && gastRest != null) { + gast!.merkeVerbleibend(gastRest); + } // ─── 2/2: fertige MP3 abholen und speichern ─── _melde('Lade „$titel“ …'); @@ -161,7 +172,7 @@ class YtDownloadService extends ChangeNotifier { try { final mp3 = await _abbrechbar( _client - .get(Uri.parse('$proxyUrl$mp3Url'), headers: auth.authHeader) + .get(Uri.parse('$proxyUrl$mp3Url'), headers: zugangsHeader) .timeout(const Duration(seconds: 180)), abbruch, ); diff --git a/test/services/yt_download_test.dart b/test/services/yt_download_test.dart index b915abe..002894e 100644 --- a/test/services/yt_download_test.dart +++ b/test/services/yt_download_test.dart @@ -6,6 +6,7 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:http/http.dart' as http; import 'package:http/testing.dart'; import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/yt_download_service.dart'; class _MemorySpeicher implements TokenSpeicher { @@ -284,4 +285,99 @@ void main() { expect((jsonDecode(auftrag!) as Map)['cookies'], isFalse); }); + + group('Gast-Zugang', () { + test('Mit Gast-Token statt Anmeldung wird der Proxy trotzdem gefragt', + () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + expect(req.headers['X-Guest-Token'], 'gast-xyz'); + expect(req.headers.containsKey('Authorization'), isFalse); + return http.Response( + jsonEncode({ + 'titel': 'Gast-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/g.mp3', + 'guest_remaining': 4, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(gast.verbleibend, 4); + }); + + test('Ohne Anmeldung UND ohne Gast-Token wird gar nicht erst gefragt', + () async { + var aufrufe = 0; + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + client: MockClient((_) async { + aufrufe++; + return http.Response('', 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNull); + expect(dienst.fehler, 'Bitte zuerst beim Baka-Konto anmelden'); + expect(aufrufe, 0); + }); + + test('401 bei Gast-Zugang holt automatisch einen neuen Gast-Token', + () async { + var tokenAufrufe = 0; + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'alter-token'; + final gast = GastZugang( + client: MockClient((_) async { + tokenAufrufe++; + return http.Response( + jsonEncode({'guest_token': 'neuer-token'}), 200); + }), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((_) async => http.Response('Unauthorized', 401)), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + // Das Token-Nachholen läuft unawaited im Hintergrund. + await Future.delayed(Duration.zero); + + expect(ergebnis, isNull); + expect(dienst.fehler, 'Gast-Zugang abgelaufen — bitte erneut versuchen'); + expect(tokenAufrufe, 1); + }); + }); } -- 2.54.0 From 9e2294a48014be08127e1c8159e3a91a0a9b6018 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 20:56:58 +0200 Subject: [PATCH 03/12] =?UTF-8?q?YtSearchService:=20Gast-Zugang=20neben=20?= =?UTF-8?q?Baka-Auth=20unterst=C3=BCtzen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Analog zu YtDownloadService: optionaler gast-Parameter, X-Guest- Token statt Authorization, automatisches Token-Nachholen bei 401. Co-Authored-By: Claude Sonnet 5 --- lib/services/yt_search_service.dart | 14 ++++-- test/services/yt_search_service_test.dart | 57 +++++++++++++++++++++++ 2 files changed, 67 insertions(+), 4 deletions(-) diff --git a/lib/services/yt_search_service.dart b/lib/services/yt_search_service.dart index 69ee99a..0c08bd9 100644 --- a/lib/services/yt_search_service.dart +++ b/lib/services/yt_search_service.dart @@ -5,6 +5,7 @@ import 'package:flutter/foundation.dart'; import 'package:http/http.dart' as http; import 'baka_auth.dart'; +import 'gast_zugang.dart'; import 'yt_download_service.dart'; /// Ein Treffer der YouTube-Suche über den Baka-Proxy. @@ -44,12 +45,13 @@ String? youtubeVideoId(String url) { /// Durchsucht YouTube über den Baka-Proxy (`/api/search`, yt-dlp-gestützt) — /// dieselbe Anmeldung wie [YtDownloadService]. class YtSearchService extends ChangeNotifier { - YtSearchService({required this.auth, http.Client? client}) + YtSearchService({required this.auth, this.gast, http.Client? client}) : _client = client ?? http.Client(); static const proxyUrl = YtDownloadService.proxyUrl; final BakaAuth auth; + final GastZugang? gast; final http.Client _client; bool _laeuft = false; @@ -64,7 +66,8 @@ class YtSearchService extends ChangeNotifier { final q = query.trim(); if (q.isEmpty) return; - if (!auth.istAngemeldet) { + final gastAktiv = !auth.istAngemeldet && (gast?.hatToken ?? false); + if (!auth.istAngemeldet && !gastAktiv) { _treffer = const []; _fehler = 'Bitte zuerst beim Baka-Konto anmelden'; notifyListeners(); @@ -80,7 +83,7 @@ class YtSearchService extends ChangeNotifier { final http.Response antwort; try { antwort = await _client - .get(uri, headers: auth.authHeader) + .get(uri, headers: gastAktiv ? gast!.gastHeader : auth.authHeader) .timeout(const Duration(seconds: 20)); } on TimeoutException { _scheitere('Die Suche braucht zu lange — bitte später erneut versuchen'); @@ -92,7 +95,10 @@ class YtSearchService extends ChangeNotifier { } if (antwort.statusCode == 401) { - _scheitere('Anmeldung abgelaufen — bitte neu anmelden'); + if (gastAktiv) unawaited(gast!.holeToken()); + _scheitere(gastAktiv + ? 'Gast-Zugang abgelaufen — bitte erneut versuchen' + : 'Anmeldung abgelaufen — bitte neu anmelden'); return; } if (antwort.statusCode != 200) { diff --git a/test/services/yt_search_service_test.dart b/test/services/yt_search_service_test.dart index 181fd24..f033673 100644 --- a/test/services/yt_search_service_test.dart +++ b/test/services/yt_search_service_test.dart @@ -5,6 +5,7 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:http/http.dart' as http; import 'package:http/testing.dart'; import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/yt_search_service.dart'; class _MemorySpeicher implements TokenSpeicher { @@ -200,5 +201,61 @@ void main() { await dienst.suchen('zweite suche'); expect(dienst.treffer.single.title, 'Zweites'); }); + + test('Mit Gast-Token statt Anmeldung wird trotzdem gesucht', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtSearchService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((req) async { + expect(req.headers['X-Guest-Token'], 'gast-xyz'); + expect(req.headers.containsKey('Authorization'), isFalse); + return http.Response('[]', 200); + }), + ); + + await dienst.suchen('roses'); + + expect(dienst.fehler, isNull); + }); + + test('401 bei Gast-Zugang holt automatisch einen neuen Gast-Token', + () async { + var tokenAufrufe = 0; + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'alter-token'; + final gast = GastZugang( + client: MockClient((_) async { + tokenAufrufe++; + return http.Response( + jsonEncode({'guest_token': 'neuer-token'}), 200); + }), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtSearchService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((_) async => http.Response('Unauthorized', 401)), + ); + + await dienst.suchen('roses'); + await Future.delayed(Duration.zero); + + expect(dienst.fehler, 'Gast-Zugang abgelaufen — bitte erneut versuchen'); + expect(tokenAufrufe, 1); + }); }); } -- 2.54.0 From 5347797292450ae4278803c088b999360f2e370e Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 21:07:35 +0200 Subject: [PATCH 04/12] main.dart: GastZugang app-weit verdrahten Neue Instanz wird beim Start geladen (gespeicherten Gast-Token wiederherstellen), an YtDownloadService/YtSearchService gereicht und als Provider bereitgestellt. Co-Authored-By: Claude Sonnet 5 --- lib/main.dart | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/lib/main.dart b/lib/main.dart index e9fa0fc..b7a8d59 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -23,6 +23,7 @@ import 'services/baka_auth.dart'; import 'services/logger_service.dart'; import 'services/download_service.dart'; import 'services/geteilte_adresse.dart'; +import 'services/gast_zugang.dart'; import 'services/melo_cloud_service.dart'; import 'services/offline_mode.dart'; import 'services/navidrome_service.dart'; @@ -41,6 +42,7 @@ late final CategoryService _categories; late final AppSettings _settings; late final AudioEffects _effects; late final BakaAuth _bakaAuth; +late final GastZugang _gastZugang; late final YtDownloadService _ytDownload; late final YtSearchService _ytSearch; late final SyncService _sync; @@ -76,8 +78,10 @@ Future main() async { await _effects.init(); _bakaAuth = BakaAuth(); await _bakaAuth.laden(); - _ytDownload = YtDownloadService(auth: _bakaAuth); - _ytSearch = YtSearchService(auth: _bakaAuth); + _gastZugang = GastZugang(); + await _gastZugang.laden(); + _ytDownload = YtDownloadService(auth: _bakaAuth, gast: _gastZugang); + _ytSearch = YtSearchService(auth: _bakaAuth, gast: _gastZugang); _sync = SyncService( db: _db, cloud: MeloCloudService(auth: _bakaAuth), @@ -128,6 +132,7 @@ class MeloApp extends StatelessWidget { ChangeNotifierProvider.value(value: _settings), ChangeNotifierProvider.value(value: _effects), ChangeNotifierProvider.value(value: _bakaAuth), + ChangeNotifierProvider.value(value: _gastZugang), ChangeNotifierProvider.value(value: _ytDownload), ChangeNotifierProvider.value(value: _ytSearch), ChangeNotifierProvider.value(value: _sync), -- 2.54.0 From cfebcc03b5edaa11b8d669d890cd6164b52922af Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 21:24:08 +0200 Subject: [PATCH 05/12] =?UTF-8?q?Download-Tab:=20Gast-Zugang=20mit=20bewus?= =?UTF-8?q?ster=20Wahl=20+=20Tages-Z=C3=A4hler?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Echte Gäste sehen jetzt zwei Buttons: "Beim Baka-Konto anmelden" und "Als Gast fortfahren (5 Downloads/Tag)". Im Gast-Modus wird der Cookie-Schalter ausgeblendet (Server erzwingt cookies=false für Gast-Zugriffe ohnehin) und ein Zähler "noch N von 5 heute" gezeigt, sobald der Server ihn meldet. _YouTubeBereich.build() beobachtet jetzt app-weit GastZugang; das Qualitäts-Gate deckte auf, dass hauptmenue_test.dart und home_shell_test.dart eigene Provider-Bäume ohne GastZugang bauen (sie spiegeln main.dart nach, statt es zu importieren) — dort GastZugang ergänzt, analog zum bestehenden Muster für die anderen Dienste. Co-Authored-By: Claude Sonnet 5 --- lib/downloads/downloads_screen.dart | 74 ++++++++++++++++++++++---- test/downloads/online_screen_test.dart | 66 ++++++++++++++++++++++- test/hauptmenue_test.dart | 8 ++- test/home_shell_test.dart | 2 + 4 files changed, 136 insertions(+), 14 deletions(-) diff --git a/lib/downloads/downloads_screen.dart b/lib/downloads/downloads_screen.dart index fd2c99a..671d599 100644 --- a/lib/downloads/downloads_screen.dart +++ b/lib/downloads/downloads_screen.dart @@ -11,6 +11,7 @@ import '../player/audio_handler.dart'; import '../services/baka_auth.dart'; import '../services/media_store.dart'; import '../services/download_service.dart'; +import '../services/gast_zugang.dart'; import '../services/navidrome_service.dart'; import '../services/server_neuheiten.dart'; import '../services/yt_download_service.dart'; @@ -615,6 +616,9 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { /// sichtbar, sonst käme so ein User nie mehr an den Dialog heran. bool _autoLoginFehlgeschlagen = false; + /// Fehlertext, falls das Holen des Gast-Tokens scheitert. + String? _gastFehler; + @override void initState() { super.initState(); @@ -685,6 +689,14 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ); } + Future _alsGastFortfahren() async { + final gast = context.read(); + setState(() => _gastFehler = null); + final fehler = await gast.holeToken(); + if (!mounted) return; + if (fehler != null) setState(() => _gastFehler = fehler); + } + Future _herunterladen() async { final dienst = context.read(); final lib = context.read(); @@ -736,13 +748,17 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { @override Widget build(BuildContext context) { final auth = context.watch(); + final gast = context.watch(); final dienst = context.watch(); // Server-User gelten sofort als berechtigt — die Anmeldung passiert für // sie im Hintergrund (_pruefeServerUser). Nur wenn die automatische // Anmeldung nachweislich fehlgeschlagen ist, bleibt der manuelle Weg // als Rückfalloption sichtbar — sonst gäbe es keinen Weg mehr zurück. - final zugriffOk = - auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen); + // Ein Gast-Token zählt ebenfalls als Zugang, nur mit Tages-Limit. + final zugriffOk = auth.istAngemeldet || + (_serverUser && !_autoLoginFehlgeschlagen) || + gast.hatToken; + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; return ListView( padding: const EdgeInsets.fromLTRB(16, 12, 16, 24), @@ -769,8 +785,26 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { onPressed: _anmelden, ), ), - ] else ...[ if (!_serverUser) ...[ + const SizedBox(height: 8), + SizedBox( + width: double.infinity, + height: MeloTheme.minTouchTarget + 4, + child: OutlinedButton.icon( + icon: const Icon(Icons.person_outline), + label: const Text('Als Gast fortfahren (5 Downloads/Tag)', + style: TextStyle(fontSize: 16)), + onPressed: _alsGastFortfahren, + ), + ), + if (_gastFehler != null) ...[ + const SizedBox(height: 8), + Text(_gastFehler!, + style: const TextStyle(color: MeloTheme.red, fontSize: 13)), + ], + ], + ] else ...[ + if (!_serverUser && auth.istAngemeldet) ...[ Row( children: [ const Icon(Icons.verified_user, size: 18, color: MeloTheme.text3), @@ -787,6 +821,23 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ), const SizedBox(height: 8), ], + if (istGastModus) ...[ + Row( + children: [ + const Icon(Icons.person_outline, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + gast.verbleibend == null + ? 'Als Gast unterwegs (5 Downloads/Tag)' + : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + ], + ), + const SizedBox(height: 8), + ], TextField( controller: _url, enabled: !dienst.laeuft, @@ -798,14 +849,15 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ), const SizedBox(height: 12), _KategorieFeld(controller: _kategorie, aktiv: !dienst.laeuft), - SwitchListTile( - dense: true, - contentPadding: EdgeInsets.zero, - title: const Text('YouTube-Cookies des Servers verwenden'), - subtitle: const Text('Nötig für altersbeschränkte Videos'), - value: _cookies, - onChanged: dienst.laeuft ? null : _setzeCookies, - ), + if (!istGastModus) + SwitchListTile( + dense: true, + contentPadding: EdgeInsets.zero, + title: const Text('YouTube-Cookies des Servers verwenden'), + subtitle: const Text('Nötig für altersbeschränkte Videos'), + value: _cookies, + onChanged: dienst.laeuft ? null : _setzeCookies, + ), if (_orte.length > 1) ...[ const SizedBox(height: 4), DropdownButtonFormField( diff --git a/test/downloads/online_screen_test.dart b/test/downloads/online_screen_test.dart index 1d21203..d7219ad 100644 --- a/test/downloads/online_screen_test.dart +++ b/test/downloads/online_screen_test.dart @@ -11,6 +11,7 @@ import 'package:melo/library/category_service.dart'; import 'package:melo/library/database.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/yt_download_service.dart'; import 'package:provider/provider.dart'; @@ -29,7 +30,9 @@ class _MemorySpeicher implements TokenSpeicher { Widget _wrap(BakaAuth auth, {required MeloDb db, required CategoryService categories, - NavidromeService? navidrome}) { + NavidromeService? navidrome, + GastZugang? gast}) { + final gastZugang = gast ?? GastZugang(); return MultiProvider( providers: [ Provider.value(value: db), @@ -38,9 +41,11 @@ Widget _wrap(BakaAuth auth, // Aufräum-Timer von drift im Test-Rahmen hängen. ChangeNotifierProvider.value(value: categories), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gastZugang), ChangeNotifierProvider( create: (_) => YtDownloadService( auth: auth, + gast: gastZugang, client: MockClient((_) async => http.Response('', 500)), ), ), @@ -270,4 +275,63 @@ void main() { expect(gesendeterBenutzer, 'Tinker'); expect(auth.istAngemeldet, isTrue); }); + + testWidgets('Gast sieht zwei Buttons: Anmelden und Als Gast fortfahren', + (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + + await tester.pumpWidget(_wrap(auth, db: db, categories: categories)); + await tester.pumpAndSettle(); + + expect(find.text('Beim Baka-Konto anmelden'), findsOneWidget); + expect( + find.text('Als Gast fortfahren (5 Downloads/Tag)'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + }); + + testWidgets( + 'Als Gast fortfahren holt einen Token und schaltet das Adressfeld frei', + (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.text('YouTube-Adresse'), findsOneWidget); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + expect(find.text('YouTube-Cookies des Servers verwenden'), findsNothing); + }); + + testWidgets('Fehler beim Gast-Token wird angezeigt', (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.text('Gast-Zugang fehlgeschlagen (500)'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + }); } diff --git a/test/hauptmenue_test.dart b/test/hauptmenue_test.dart index 2f08869..56e9c3d 100644 --- a/test/hauptmenue_test.dart +++ b/test/hauptmenue_test.dart @@ -9,6 +9,7 @@ import 'package:melo/main.dart'; import 'package:melo/player/audio_handler.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -51,6 +52,7 @@ void main() { late YtSearchService ytSearch; late DownloadService downloads; late SyncService sync; + late GastZugang gast; MeloAudioHandler? handler; setUp(() { @@ -62,8 +64,9 @@ void main() { auth = BakaAuth(speicher: _MemorySpeicher()); einstellungen = AppSettings(); offline = OfflineMode(); - ytDownload = YtDownloadService(auth: auth); - ytSearch = YtSearchService(auth: auth); + gast = GastZugang(); + ytDownload = YtDownloadService(auth: auth, gast: gast); + ytSearch = YtSearchService(auth: auth, gast: gast); downloads = DownloadService(db: db, navidrome: NavidromeService()); sync = SyncService(db: db, cloud: MeloCloudService(auth: auth)); }); @@ -95,6 +98,7 @@ void main() { ChangeNotifierProvider.value(value: einstellungen), ChangeNotifierProvider.value(value: offline), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gast), ChangeNotifierProvider.value(value: ytDownload), ChangeNotifierProvider.value(value: ytSearch), ChangeNotifierProvider.value(value: downloads), diff --git a/test/home_shell_test.dart b/test/home_shell_test.dart index c5b87e7..6ad745b 100644 --- a/test/home_shell_test.dart +++ b/test/home_shell_test.dart @@ -9,6 +9,7 @@ import 'package:melo/main.dart'; import 'package:melo/player/audio_handler.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -50,6 +51,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( -- 2.54.0 From 81ec1e232b9ab0b5c94b5f50371eb1a4ecf94f95 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 21:25:25 +0200 Subject: [PATCH 06/12] CHANGELOG: Download-Tab-Gast-Zugang dokumentieren Co-Authored-By: Claude Sonnet 5 --- CHANGELOG.md | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 739cd5f..8298578 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,34 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). ## [Unreleased] +### 📺👤 Download-Tab: Gast-Zugang mit bewusster Wahl + Tages-Zähler (2026-08-26) + +- 👤 **Echte Gäste (kein Baka-Konto, kein Melo-Server) sehen jetzt zwei + Buttons** statt nur der Anmeldung: "Beim Baka-Konto anmelden" und neu + "Als Gast fortfahren (5 Downloads/Tag)". Der Gast-Button holt sich per + `GastZugang.holeToken()` (aus Task 1-4 dieser Reihe) einen anonymen + Token vom Proxy und schaltet damit den Downloader frei — ganz ohne + Konto. Schlägt das Holen fehl, erscheint der Fehlertext direkt unter + dem Button. +- 🔢 **Im Gast-Modus zeigt eine Statuszeile "Als Gast unterwegs — noch N + von 5 heute"**, sobald der Server den Kontingent-Stand gemeldet hat + (vorher nur der generische Hinweistext "5 Downloads/Tag"). Der + Cookie-Schalter ("YouTube-Cookies des Servers verwenden") ist im + Gast-Modus ausgeblendet — der Server erzwingt für Gast-Zugriffe ohnehin + `cookies=false`, ein sichtbarer Schalter hätte nur eine Wahl vorgetäuscht, + die es nicht gibt. +- 🐛 **Nebenbefund durchs Qualitäts-Gate:** `_YouTubeBereich.build()` + beobachtet jetzt `GastZugang` app-weit über den Provider-Baum. Zwei + Tests (`hauptmenue_test.dart`, `home_shell_test.dart`) bauen ihren + eigenen Provider-Baum nach, statt `main.dart` zu importieren, und + hatten `GastZugang` dort noch nicht — beide entsprechend ergänzt (analog + zum bestehenden Muster für `BakaAuth`/`YtDownloadService`). +- ✅ **Getestet:** volle Suite grün (598 Tests), `flutter analyze` ohne + Befund. 3 neue Widget-Tests in + `test/downloads/online_screen_test.dart`: beide Buttons sichtbar, + Gast-Token-Erfolg schaltet das Adressfeld frei, Gast-Token-Fehler wird + angezeigt. + ### 📺🔑 YouTube-Tab: Server-User brauchen keine eigene Baka-Anmeldung mehr (2026-08-26) - 🔑 **Server-User (Dustin, Baka, Tinker) sehen den Baka-Anmelde-Schritt nicht -- 2.54.0 From aecb8e336491e819035e644176b204a47abe8a69 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 21:37:08 +0200 Subject: [PATCH 07/12] =?UTF-8?q?YT-Suche-Tab:=20Gast-Zugang=20mit=20bewus?= =?UTF-8?q?ster=20Wahl=20+=20Tages-Z=C3=A4hler?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Analog zum Download-Tab: echte Gäste sehen zusätzlich zum bestehenden Hinweis den Button "Als Gast fortfahren (5 Downloads/Tag)"; im Gast-Modus ersetzt ein Zähler den Hinweis. Co-Authored-By: Claude Sonnet 5 --- lib/downloads/youtube_search_screen.dart | 61 +++++++++++++++++-- .../downloads/youtube_search_screen_test.dart | 49 +++++++++++++++ 2 files changed, 104 insertions(+), 6 deletions(-) diff --git a/lib/downloads/youtube_search_screen.dart b/lib/downloads/youtube_search_screen.dart index 6cd35df..9e7b44a 100644 --- a/lib/downloads/youtube_search_screen.dart +++ b/lib/downloads/youtube_search_screen.dart @@ -7,6 +7,7 @@ import '../library/database.dart'; import '../library/library_service.dart'; import '../services/baka_auth.dart'; import '../services/download_service.dart'; +import '../services/gast_zugang.dart'; import '../services/media_store.dart'; import '../services/yt_download_service.dart'; import '../services/yt_search_service.dart'; @@ -34,6 +35,9 @@ class _YoutubeSearchScreenState extends State { /// Hinweis auf die manuelle Anmeldung (siehe Download-Tab) sichtbar. bool _autoLoginFehlgeschlagen = false; + /// Fehlertext, falls das Holen des Gast-Tokens scheitert. + String? _gastFehler; + @override void initState() { super.initState(); @@ -51,6 +55,14 @@ class _YoutubeSearchScreenState extends State { }); } + Future _alsGastFortfahren() async { + final gast = context.read(); + setState(() => _gastFehler = null); + final fehler = await gast.holeToken(); + if (!mounted) return; + if (fehler != null) setState(() => _gastFehler = fehler); + } + @override void dispose() { _query.dispose(); @@ -67,9 +79,12 @@ class _YoutubeSearchScreenState extends State { @override Widget build(BuildContext context) { final auth = context.watch(); + final gast = context.watch(); final suche = context.watch(); - final zugriffOk = - auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen); + final zugriffOk = auth.istAngemeldet || + (_serverUser && !_autoLoginFehlgeschlagen) || + gast.hatToken; + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; return SafeArea( child: Column( @@ -97,13 +112,47 @@ class _YoutubeSearchScreenState extends State { ], ), ), - if (!zugriffOk) - const Padding( - padding: EdgeInsets.symmetric(horizontal: 16, vertical: 4), + if (!zugriffOk) ...[ + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), child: Text( 'Die Suche läuft über den Baka-Server. Dafür brauchst du ' 'deine Baka-Anmeldung (siehe Download-Tab).', - style: TextStyle(color: MeloTheme.text2, fontSize: 13), + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + if (!_serverUser) ...[ + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: SizedBox( + width: double.infinity, + height: MeloTheme.minTouchTarget + 4, + child: OutlinedButton.icon( + icon: const Icon(Icons.person_outline), + label: const Text('Als Gast fortfahren (5 Downloads/Tag)', + style: TextStyle(fontSize: 16)), + onPressed: _alsGastFortfahren, + ), + ), + ), + if (_gastFehler != null) + Padding( + padding: + const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Text(_gastFehler!, + style: + const TextStyle(color: MeloTheme.red, fontSize: 13)), + ), + ], + ], + if (istGastModus) + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Text( + gast.verbleibend == null + ? 'Als Gast unterwegs (5 Downloads/Tag)' + : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), ), ), if (suche.laeuft) const LinearProgressIndicator(), diff --git a/test/downloads/youtube_search_screen_test.dart b/test/downloads/youtube_search_screen_test.dart index 1123b9d..2a827b2 100644 --- a/test/downloads/youtube_search_screen_test.dart +++ b/test/downloads/youtube_search_screen_test.dart @@ -11,6 +11,7 @@ import 'package:melo/library/database.dart'; import 'package:melo/library/library_service.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/yt_download_service.dart'; import 'package:melo/services/yt_search_service.dart'; @@ -43,12 +44,14 @@ Widget _wrap({ required YtSearchService search, required YtDownloadService download, NavidromeService? navidrome, + GastZugang? gast, }) { return MultiProvider( providers: [ Provider.value(value: db), ChangeNotifierProvider.value(value: LibraryService(db)), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gast ?? GastZugang()), ChangeNotifierProvider.value(value: search), ChangeNotifierProvider.value(value: download), // Nur für die Server-User-Prüfung gebraucht (siehe @@ -182,4 +185,50 @@ void main() { // _YouTubeBereich (downloads_screen.dart) keinen eigenen Widget-Test — // die Download-Logik selbst ist über yt_download_test.dart ausführlich // abgedeckt. + + testWidgets('Gast sieht den Button "Als Gast fortfahren"', (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final search = YtSearchService(auth: auth); + final download = YtDownloadService(auth: auth); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download)); + await tester.pumpAndSettle(); + + expect( + find.text('Als Gast fortfahren (5 Downloads/Tag)'), findsOneWidget); + + await db.close(); + }); + + testWidgets( + 'Als Gast fortfahren blendet den Baka-Hinweis aus und zeigt den Zähler', + (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final search = YtSearchService(auth: auth); + final download = YtDownloadService(auth: auth); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.textContaining('Baka-Anmeldung'), findsNothing); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + + await db.close(); + }); } -- 2.54.0 From b32f3198f803c13f2cd8ba3b894273f5a58164bc Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 21:48:29 +0200 Subject: [PATCH 08/12] CHANGELOG: YouTube-Gast-Zugang (App-Seite) Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01CcDiyJdVRqh1TtJk5JiabX --- CHANGELOG.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8298578..919b7d6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). ## [Unreleased] -### 📺👤 Download-Tab: Gast-Zugang mit bewusster Wahl + Tages-Zähler (2026-08-26) +### 📺👤 YouTube-Gast-Zugang: bewusste Wahl + Tages-Zähler (Download-Tab + YT-Suche-Tab) (2026-08-26) - 👤 **Echte Gäste (kein Baka-Konto, kein Melo-Server) sehen jetzt zwei Buttons** statt nur der Anmeldung: "Beim Baka-Konto anmelden" und neu @@ -27,7 +27,12 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). eigenen Provider-Baum nach, statt `main.dart` zu importieren, und hatten `GastZugang` dort noch nicht — beide entsprechend ergänzt (analog zum bestehenden Muster für `BakaAuth`/`YtDownloadService`). -- ✅ **Getestet:** volle Suite grün (598 Tests), `flutter analyze` ohne +- 📺 **YT-Suche-Tab bekommt denselben Gast-Button und -Zähler** wie der + Download-Tab. Das alte "Baka-Anmeldung (siehe Download-Tab)" Hint für + Gäste ist weg — echte Gäste in `lib/downloads/youtube_search_screen.dart` + sehen jetzt "Als Gast fortfahren (5 Downloads/Tag)" und die Status-Zeile + "Als Gast unterwegs — noch N von 5 heute", genauso wie im Download-Tab. +- ✅ **Getestet:** volle Suite grün (600 Tests), `flutter analyze` ohne Befund. 3 neue Widget-Tests in `test/downloads/online_screen_test.dart`: beide Buttons sichtbar, Gast-Token-Erfolg schaltet das Adressfeld frei, Gast-Token-Fehler wird -- 2.54.0 From d20f01adeef809ea7d7e64c7e1e5a0d1f4373a04 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Wed, 26 Aug 2026 22:17:03 +0200 Subject: [PATCH 09/12] fix: Gast-Zugang-Sperre, veralteter Token, Doppel-Tap, Hinweistext (Branch-Review) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Behebt die Findings aus dem abschließenden Gesamt-Branch-Review für feature/youtube-gast-zugang, alle in einem Rutsch: - KRITISCH: Gast-Modus war eine Einbahnstraße — einmal "Als Gast fortfahren" getippt, war _AnmeldeDialog (einziger Baka-Login-Einstieg, auch für Melo-Cloud-Sync) dauerhaft unerreichbar. Neu: GastZugang.verwerfen() plus "Anmelden"-Knopf neben der Gast-Statuszeile in beiden Screens. - WICHTIG: zugriffOk prüfte den rohen gast.hatToken statt istGastModus — ein alter Gast-Token konnte den Auto-Login-Rückfallweg für Server-User verdecken. istGastModus wird jetzt vor zugriffOk berechnet und dort verwendet. - WICHTIG: CHANGELOG ergänzt — der Server-Endpunkt POST /api/guest-token fehlt noch (separates Vorhaben). - Doppel-Tap-Schutz für den Gast-Button in beiden Screens. - Widersprüchlicher Hinweistext im YT-Suche-Tab (verlangte Baka-Login direkt über dem Gast-Button) korrigiert. - Zwei Gast-Tests in youtube_search_screen_test.dart bekommen jetzt echtes gast:-Wiring in YtSearchService/YtDownloadService. - 2 neue Regressionstests fürs Anmelden-Escape-Hatch. Getestet: volle Suite grün (602 Tests, 1 skipped, 0 failed), flutter analyze ohne Befund. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01CcDiyJdVRqh1TtJk5JiabX --- CHANGELOG.md | 39 +++++++++++++++ lib/downloads/downloads_screen.dart | 24 ++++++++-- lib/downloads/youtube_search_screen.dart | 48 ++++++++++++++----- lib/services/gast_zugang.dart | 11 +++++ test/downloads/online_screen_test.dart | 28 +++++++++++ .../downloads/youtube_search_screen_test.dart | 48 ++++++++++++++++--- 6 files changed, 175 insertions(+), 23 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 919b7d6..ce34284 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,8 +5,47 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). ## [Unreleased] +### 🐛 Gast-Zugang: Fixe aus dem Branch-Abschluss-Review (2026-08-26) + +- 🔓 **Gast-Modus war eine Einbahnstraße.** Einmal "Als Gast fortfahren" + angetippt, blieb `gast.hatToken` dauerhaft `true` (Token steckt im + Secure Storage, wird bei jedem App-Start wiederhergestellt) — und damit + war `_AnmeldeDialog`, der EINZIGE Einstieg in der App für die + Baka-Anmeldung (auch für den Melo-Cloud-Sync-Login!), unerreichbar. + Neu: `GastZugang.verwerfen()` verwirft den Token wieder, und ein + "Anmelden"-Knopf neben der Gast-Statuszeile (Download-Tab und + YT-Suche-Tab) ruft ihn auf. +- 🔀 **Ein alter Gast-Token hat den Auto-Login-Rückfallweg für + Server-User verdeckt.** `zugriffOk` prüfte bisher den rohen + `gast.hatToken` statt `istGastModus` — ein Gerät, das früher mal als + Gast lief und jetzt als Server-User mit fehlgeschlagenem Auto-Login + dasteht, bekam die Fehlermeldung dazu nie zu sehen und lud still über + den (limitierten) Gast-Pfad. `istGastModus` wird jetzt vor `zugriffOk` + berechnet und dort statt des rohen Tokens verwendet. + (`lib/downloads/downloads_screen.dart`, + `lib/downloads/youtube_search_screen.dart`) +- ⏱️ **Doppel-Tap auf "Als Gast fortfahren" konnte zwei Anfragen + gleichzeitig auslösen.** Beide Screens sperren den Button jetzt während + `holeToken()` läuft (`_gastLaeuft`). +- 📝 **Widersprüchlicher Hinweistext im YT-Suche-Tab behoben** — der Text + über dem Gast-Button verlangte fälschlich eine Baka-Anmeldung. +- ⚠️ **CHANGELOG ergänzt:** der Abschnitt zum Gast-Zugang unten macht jetzt + klar, dass die Server-Seite (`POST /api/guest-token`) noch fehlt. +- ✅ **Getestet:** 2 neue Regressionstests fürs "Anmelden"-Escape-Hatch + (`test/downloads/online_screen_test.dart`, + `test/downloads/youtube_search_screen_test.dart`), 2 bestehende Gast-Tests + im YT-Suche-Tab jetzt mit echtem `gast:`-Wiring in + `YtSearchService`/`YtDownloadService`. Volle Suite grün, `flutter + analyze` ohne Befund. + ### 📺👤 YouTube-Gast-Zugang: bewusste Wahl + Tages-Zähler (Download-Tab + YT-Suche-Tab) (2026-08-26) +- ⚠️ **Braucht noch die Server-Seite.** Der neue Endpunkt `POST + /api/guest-token` und die Quota-Logik in `yt_proxy.py` existieren noch + nicht (separates Vorhaben, siehe + `docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md`). Bis + die Server-Seite steht, liefert der "Als Gast fortfahren"-Button + zuverlässig einen 404-Fehler. - 👤 **Echte Gäste (kein Baka-Konto, kein Melo-Server) sehen jetzt zwei Buttons** statt nur der Anmeldung: "Beim Baka-Konto anmelden" und neu "Als Gast fortfahren (5 Downloads/Tag)". Der Gast-Button holt sich per diff --git a/lib/downloads/downloads_screen.dart b/lib/downloads/downloads_screen.dart index 671d599..bc7063e 100644 --- a/lib/downloads/downloads_screen.dart +++ b/lib/downloads/downloads_screen.dart @@ -619,6 +619,9 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { /// Fehlertext, falls das Holen des Gast-Tokens scheitert. String? _gastFehler; + /// Verhindert Mehrfach-Anfragen bei schnellem Doppel-Antippen. + bool _gastLaeuft = false; + @override void initState() { super.initState(); @@ -690,11 +693,18 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { } Future _alsGastFortfahren() async { + if (_gastLaeuft) return; final gast = context.read(); - setState(() => _gastFehler = null); + setState(() { + _gastFehler = null; + _gastLaeuft = true; + }); final fehler = await gast.holeToken(); if (!mounted) return; - if (fehler != null) setState(() => _gastFehler = fehler); + setState(() { + _gastLaeuft = false; + if (fehler != null) _gastFehler = fehler; + }); } Future _herunterladen() async { @@ -755,10 +765,10 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { // Anmeldung nachweislich fehlgeschlagen ist, bleibt der manuelle Weg // als Rückfalloption sichtbar — sonst gäbe es keinen Weg mehr zurück. // Ein Gast-Token zählt ebenfalls als Zugang, nur mit Tages-Limit. + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; final zugriffOk = auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen) || - gast.hatToken; - final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; + istGastModus; return ListView( padding: const EdgeInsets.fromLTRB(16, 12, 16, 24), @@ -794,7 +804,7 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { icon: const Icon(Icons.person_outline), label: const Text('Als Gast fortfahren (5 Downloads/Tag)', style: TextStyle(fontSize: 16)), - onPressed: _alsGastFortfahren, + onPressed: _gastLaeuft ? null : _alsGastFortfahren, ), ), if (_gastFehler != null) ...[ @@ -834,6 +844,10 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { style: const TextStyle(color: MeloTheme.text2, fontSize: 13), ), ), + TextButton( + onPressed: gast.verwerfen, + child: const Text('Anmelden'), + ), ], ), const SizedBox(height: 8), diff --git a/lib/downloads/youtube_search_screen.dart b/lib/downloads/youtube_search_screen.dart index 9e7b44a..f3191c5 100644 --- a/lib/downloads/youtube_search_screen.dart +++ b/lib/downloads/youtube_search_screen.dart @@ -38,6 +38,9 @@ class _YoutubeSearchScreenState extends State { /// Fehlertext, falls das Holen des Gast-Tokens scheitert. String? _gastFehler; + /// Verhindert Mehrfach-Anfragen bei schnellem Doppel-Antippen. + bool _gastLaeuft = false; + @override void initState() { super.initState(); @@ -56,11 +59,18 @@ class _YoutubeSearchScreenState extends State { } Future _alsGastFortfahren() async { + if (_gastLaeuft) return; final gast = context.read(); - setState(() => _gastFehler = null); + setState(() { + _gastFehler = null; + _gastLaeuft = true; + }); final fehler = await gast.holeToken(); if (!mounted) return; - if (fehler != null) setState(() => _gastFehler = fehler); + setState(() { + _gastLaeuft = false; + if (fehler != null) _gastFehler = fehler; + }); } @override @@ -81,10 +91,10 @@ class _YoutubeSearchScreenState extends State { final auth = context.watch(); final gast = context.watch(); final suche = context.watch(); + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; final zugriffOk = auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen) || - gast.hatToken; - final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; + istGastModus; return SafeArea( child: Column( @@ -116,8 +126,12 @@ class _YoutubeSearchScreenState extends State { Padding( padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), child: Text( - 'Die Suche läuft über den Baka-Server. Dafür brauchst du ' - 'deine Baka-Anmeldung (siehe Download-Tab).', + _serverUser + ? 'Die Suche läuft über den Baka-Server. Dafür brauchst ' + 'du deine Baka-Anmeldung (siehe Download-Tab).' + : 'Die Suche läuft über den Baka-Server. Melde dich mit ' + 'deinem Baka-Konto an (siehe Download-Tab) oder ' + 'nutze sie eingeschränkt als Gast.', style: const TextStyle(color: MeloTheme.text2, fontSize: 13), ), ), @@ -131,7 +145,7 @@ class _YoutubeSearchScreenState extends State { icon: const Icon(Icons.person_outline), label: const Text('Als Gast fortfahren (5 Downloads/Tag)', style: TextStyle(fontSize: 16)), - onPressed: _alsGastFortfahren, + onPressed: _gastLaeuft ? null : _alsGastFortfahren, ), ), ), @@ -148,11 +162,21 @@ class _YoutubeSearchScreenState extends State { if (istGastModus) Padding( padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), - child: Text( - gast.verbleibend == null - ? 'Als Gast unterwegs (5 Downloads/Tag)' - : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', - style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + child: Row( + children: [ + Expanded( + child: Text( + gast.verbleibend == null + ? 'Als Gast unterwegs (5 Downloads/Tag)' + : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + TextButton( + onPressed: gast.verwerfen, + child: const Text('Anmelden'), + ), + ], ), ), if (suche.laeuft) const LinearProgressIndicator(), diff --git a/lib/services/gast_zugang.dart b/lib/services/gast_zugang.dart index 4df938a..5077395 100644 --- a/lib/services/gast_zugang.dart +++ b/lib/services/gast_zugang.dart @@ -79,4 +79,15 @@ class GastZugang extends ChangeNotifier { _verbleibend = n; notifyListeners(); } + + /// Verwirft den Gast-Zugang wieder — nötig, damit ein Gast doch noch zum + /// Baka-Konto wechseln kann. Ohne das wäre `_AnmeldeDialog` (der einzige + /// Einstieg in der App für Baka-Login, auch für den Melo-Cloud-Sync) + /// dauerhaft unerreichbar, sobald einmal ein Gast-Token besteht. + Future verwerfen() async { + _token = null; + _verbleibend = null; + await _speicher.loeschen(_tokenKey); + notifyListeners(); + } } diff --git a/test/downloads/online_screen_test.dart b/test/downloads/online_screen_test.dart index d7219ad..8f68dd1 100644 --- a/test/downloads/online_screen_test.dart +++ b/test/downloads/online_screen_test.dart @@ -334,4 +334,32 @@ void main() { expect(find.text('Gast-Zugang fehlgeschlagen (500)'), findsOneWidget); expect(find.text('YouTube-Adresse'), findsNothing); }); + + testWidgets( + 'Anmelden im Gast-Modus verwirft den Gast-Token und zeigt wieder die ' + 'Wahl', (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + expect(find.text('YouTube-Adresse'), findsOneWidget); + + await tester.tap(find.text('Anmelden')); + await tester.pumpAndSettle(); + + expect(find.text('Beim Baka-Konto anmelden'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + expect(gast.hatToken, isFalse); + }); } diff --git a/test/downloads/youtube_search_screen_test.dart b/test/downloads/youtube_search_screen_test.dart index 2a827b2..12a1ece 100644 --- a/test/downloads/youtube_search_screen_test.dart +++ b/test/downloads/youtube_search_screen_test.dart @@ -92,7 +92,7 @@ void main() { db: db, auth: auth, search: search, download: download)); await tester.pumpAndSettle(); - expect(find.textContaining('Baka-Anmeldung'), findsOneWidget); + expect(find.textContaining('Baka-Server'), findsOneWidget); expect(find.text('Nach Musikvideos suchen'), findsOneWidget); await db.close(); @@ -191,11 +191,15 @@ void main() { final auth = BakaAuth( client: MockClient((_) async => http.Response('', 500)), speicher: _MemorySpeicher()); - final search = YtSearchService(auth: auth); - final download = YtDownloadService(auth: auth); + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + final search = YtSearchService(auth: auth, gast: gast); + final download = YtDownloadService(auth: auth, gast: gast); await tester.pumpWidget(_wrap( - db: db, auth: auth, search: search, download: download)); + db: db, auth: auth, search: search, download: download, gast: gast)); await tester.pumpAndSettle(); expect( @@ -208,6 +212,34 @@ void main() { 'Als Gast fortfahren blendet den Baka-Hinweis aus und zeigt den Zähler', (tester) async { final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + final search = YtSearchService(auth: auth, gast: gast); + final download = YtDownloadService(auth: auth, gast: gast); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.textContaining('Baka-Anmeldung'), findsNothing); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + + await db.close(); + }); + + testWidgets( + 'Anmelden im Gast-Modus verwirft den Gast-Token und zeigt wieder den ' + 'Hinweis', (tester) async { + final db = MeloDb(NativeDatabase.memory()); final auth = BakaAuth( client: MockClient((_) async => http.Response('', 500)), speicher: _MemorySpeicher()); @@ -225,10 +257,14 @@ void main() { await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); await tester.pumpAndSettle(); - - expect(find.textContaining('Baka-Anmeldung'), findsNothing); expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + await tester.tap(find.text('Anmelden')); + await tester.pumpAndSettle(); + + expect(find.textContaining('Baka-Server'), findsOneWidget); + expect(gast.hatToken, isFalse); + await db.close(); }); } -- 2.54.0 From 86117381245e18c7150705b7ea79d53f81cb5ec8 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Sat, 29 Aug 2026 13:17:35 +0200 Subject: [PATCH 10/12] =?UTF-8?q?Spec-Nachtrag:=20100/Tag-Limit=20auch=20f?= =?UTF-8?q?=C3=BCr=20Cloud-Accounts=20(nicht=20mehr=20unbegrenzt)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Dustin hat beim Durchsprechen der Proxy-Architektur bestätigt: auch Dustin/Baka/Tinker bekommen ein Tages-Limit (100 statt 5 bei Gästen), nicht mehr unbegrenzt. Serverseitiger Vertrag (cloud_quota-Tabelle, cloud_remaining-Feld) und App-Seite (BakaAuth.verbleibend, UI-Text) dokumentiert, analog zum bestehenden Gast-Limit. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_012A2pmbnVNPiHdyf2GW8eLP --- .../2026-08-26-youtube-guest-quota-design.md | 84 ++++++++++++++++++- 1 file changed, 82 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md b/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md index bcc935d..bf82cfb 100644 --- a/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md +++ b/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md @@ -50,17 +50,97 @@ vorbehalten. | Reset-Zeitpunkt | Kalendertag nach Server-Zeit (Aingrad), kein rollierendes 24h-Fenster | | Suche fürs Limit | Suche bleibt für Gäste unbegrenzt — nur `POST /api/yt-dl` zählt | | Cookies für Gäste | Nein — nur Cloud-Accounts bekommen Dustins YouTube-Cookies; der `cookies`-Parameter wird bei Gast-Token-Anfragen ignoriert | +| Limit für Cloud-Accounts | **Nachtrag 2026-08-29:** 100 Downloads/Kalendertag je Nutzer (Dustin/Baka/Tinker je einzeln gezählt) — ersetzt das ursprüngliche „kein Limit". Grund: dieselbe Absicherung wie beim Gast-Limit, nur großzügiger, da Cloud-Accounts vertraute Nutzer mit Cookie-Zugriff sind. | ## Architektur Drei Zugangsklassen beim Proxy: -1. **Cloud-Account** (`Authorization: Bearer `, wie heute) — unbegrenzt, - Cookies automatisch. +1. **Cloud-Account** (`Authorization: Bearer `, wie heute) — **100 + Downloads/Kalendertag je Nutzer** (Nachtrag 2026-08-29, ersetzt + „unbegrenzt"), Cookies automatisch, Suche unbegrenzt (wie bei Gästen). 2. **Gast** (`X-Guest-Token: `, neu) — 5 Downloads/Kalendertag, Suche unbegrenzt, keine Cookies. 3. **Kein Zugang** — weder Bearer noch gültiger Gast-Token → 401 wie heute. +## Nachtrag 2026-08-29: 100/Tag-Limit auch für Cloud-Accounts + +Dustin hat beim erneuten Durchsprechen der Architektur (nach den +Login-Race-Fixes) bestätigt, dass auch Cloud-Accounts (Dustin, Baka, +Tinker) ein Tages-Limit bekommen sollen — 100 statt der ursprünglich +geplanten 5, aber nicht mehr unbegrenzt. Grund: dieselbe +Missbrauchs-/Kosten-Absicherung wie beim Gast-Limit (YouTube-Rate-Limits, +Serverlast), nur mit großzügigerem Kontingent, weil Cloud-Accounts +vertraute, bekannte Nutzer sind und zusätzlich Cookie-Zugriff haben. + +**Übernommene Entscheidungen des Gast-Limits (analog, keine neue +Diskussion nötig):** Reset zum Kalendertag (Server-Zeit), Suche zählt +nicht, nur `POST /api/yt-dl` zählt, Klartext-429-Fehlermeldung ohne +automatischen Retry. + +**Unterschied zum Gast-Limit:** Cloud-Accounts zählen **pro Nutzername** +(aus dem verifizierten JWT), nicht pro Gerät/Token — ein Nutzer, der die +App auf zwei Geräten installiert hat, teilt sich also ein gemeinsames +Kontingent (folgerichtig, da derselbe Baka-Account). + +### Server-seitige Änderungen (zusätzlich zu den bestehenden Abschnitten oben — Hermes/`claude-server`-Worktree) + +- Neue Tabelle (oder Erweiterung von `guest_quota`, falls strukturell + identisch — Entscheidung liegt bei der Server-Session) analog zu + `guest_quota`, aber mit `username` statt `token` als Schlüssel: + ```sql + CREATE TABLE IF NOT EXISTS cloud_quota ( + username TEXT PRIMARY KEY, + count INTEGER NOT NULL DEFAULT 0, + count_date TEXT NOT NULL + ); + ``` +- `POST /api/yt-dl` bei Cloud-Zugriff (gültiger Bearer-JWT): dieselbe + Tageswechsel-Reset-Logik wie bei Gästen, aber Schlüssel = Nutzername aus + dem JWT. Bei `count >= 100` → `429` mit + `{"error": "Tages-Limit erreicht (100/Tag) — ab morgen wieder verfügbar", "cooldown": }`. + Erfolgsantwort bekommt zusätzlich `"cloud_remaining": ` (nur bei + Cloud-Zugriff, analog zu `guest_remaining` bei Gästen — beide Felder + schließen sich gegenseitig aus, nie beide gleichzeitig gesetzt). +- `GET /api/search` bleibt für Cloud-Accounts unverändert unbegrenzt (wie + für Gäste). + +### App-seitige Änderungen (diese Seite implementiere ich) + +- `BakaAuth` (`lib/services/baka_auth.dart`) bekommt — analog zu + `GastZugang.verbleibend`/`.merkeVerbleibend(n)` — ein neues Feld + `int? verbleibend` (Getter) und `void merkeVerbleibend(int n)`, das den + zuletzt vom Server gemeldeten Kontingent-Stand hält (nur fürs Anzeigen, + `null` vor dem ersten Download in dieser Session). +- `YtDownloadService.herunterladen()` (`lib/services/yt_download_service.dart`): + liest nach einem erfolgreichen `POST /api/yt-dl` zusätzlich + `daten['cloud_remaining']` aus, und ruft bei `!gastAktiv` (also + Cloud-Zugriff) `auth.merkeVerbleibend(cloudRest)` auf — analog zur + bestehenden `gast!.merkeVerbleibend(gastRest)`-Zeile. Ein `429` läuft + bereits durch den bestehenden generischen `_fehlerText(antwort)`-Pfad + (kein neuer Fehlerfall nötig, der zeigt jeden Server-`error`-Text aus dem + 200-fremden Statuscode an — funktioniert für 429 genauso wie für 401 + außerhalb des Spezialfalls). +- UI (`_YouTubeBereich` in `lib/downloads/downloads_screen.dart`, + `YoutubeSearchScreen` in `lib/downloads/youtube_search_screen.dart`): + zeigt analog zum bestehenden Gast-Text („Als Gast unterwegs — noch N von + 5 heute") jetzt auch für angemeldete Cloud-Accounts einen Text „Noch N + von 100 heute", sobald `auth.verbleibend != null` — platziert an + vergleichbarer Stelle wie der Gast-Text, aber nur sichtbar wenn + `auth.istAngemeldet` (nicht für Gäste, die haben ihren eigenen Text). + +### Tests (Nachtrag) + +- **App:** `BakaAuth.merkeVerbleibend`, `YtDownloadService` liest + `cloud_remaining` bei Cloud-Zugriff (nicht bei Gast-Zugriff — die beiden + Felder dürfen sich nicht vermischen), Widget-Test für den neuen + „Noch N von 100 heute"-Text in beiden Bildschirmen. +- **Server** (Hermes): analog zu den bestehenden Gast-Tests, plus ein Test, + der sicherstellt, dass Gast- und Cloud-Kontingente unabhängig + voneinander gezählt werden (ein Cloud-Login verbraucht kein + Gast-Kontingent und umgekehrt — sie sind ohnehin durch unterschiedliche + Auth-Wege getrennt, aber das schadet nicht, explizit zu testen). + ## Server-seitige Komponenten **Betrifft `/home/dustin/scripts/yt_proxy.py` und ggf. `auth_common.py` — -- 2.54.0 From d03a4e93a05bc6fd7f2deac61be29d12005e2e05 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Sat, 29 Aug 2026 13:22:04 +0200 Subject: [PATCH 11/12] Cloud-Account-Kontingent: App liest cloud_remaining, sobald der Server es liefert MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit BakaAuth bekommt verbleibend/merkeVerbleibend analog zu GastZugang. YtDownloadService liest cloud_remaining bei Cloud-Zugriff (nicht bei Gast-Zugriff — Felder bleiben getrennt). UI zeigt "Noch N von 100 heute" für angemeldete Cloud-Accounts. Reine App-Seite, wirkungslos bis der Server (separates Vorhaben) cloud_remaining liefert. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_012A2pmbnVNPiHdyf2GW8eLP --- CHANGELOG.md | 36 ++++++++++ lib/downloads/downloads_screen.dart | 15 ++++ lib/downloads/youtube_search_screen.dart | 16 +++++ lib/services/baka_auth.dart | 12 ++++ lib/services/yt_download_service.dart | 4 ++ test/downloads/online_screen_test.dart | 15 ++++ .../downloads/youtube_search_screen_test.dart | 20 ++++++ test/services/baka_auth_test.dart | 14 ++++ test/services/yt_download_test.dart | 72 +++++++++++++++++++ 9 files changed, 204 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ce34284..234f36b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,42 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). ## [Unreleased] +### ☁️ Cloud-Account-Kontingent: App-Seite für das 100/Tag-Limit (2026-08-29) + +- ⚠️ **Reine App-Seite, ohne Wirkung bis der Server mitzieht.** Die + Server-Zählung (`cloud_quota`, 100/Tag je Nutzername) in `yt_proxy.py` + ist NICHT Teil dieser Änderung — das macht die `claude-server`-Session + separat (siehe Nachtrag "100/Tag-Limit auch für Cloud-Accounts" in + `docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md`). Bis + der Server das neue Feld `cloud_remaining` liefert, bleibt + `auth.verbleibend` einfach `null` — kein Fehler, kein sichtbarer + Unterschied zu heute. +- 🔢 **`BakaAuth` bekommt einen Kontingent-Stand** — analog zu + `GastZugang.verbleibend`/`.merkeVerbleibend(n)`: neues Feld `int? + verbleibend` (Getter) und `void merkeVerbleibend(int n)` + (`lib/services/baka_auth.dart`). +- 🔌 **`YtDownloadService.herunterladen()` liest `cloud_remaining`** aus + einer erfolgreichen `POST /api/yt-dl`-Antwort und ruft bei + Cloud-Zugriff (`!gastAktiv`) `auth.merkeVerbleibend(...)` auf — genau + wie beim bestehenden `guest_remaining`/`gast.merkeVerbleibend(...)` + fürs Gast-Kontingent, aber strikt getrennt (ein Gast-Zugriff liest das + Feld nie, ein Cloud-Zugriff nie `guest_remaining`). + (`lib/services/yt_download_service.dart`) +- 📟 **Angemeldete Cloud-Accounts sehen jetzt „Noch N von 100 heute“**, + sobald der Server den Stand gemeldet hat — an vergleichbarer Stelle wie + der bestehende Gast-Zähler, aber nur bei `auth.istAngemeldet` (Gäste + haben weiter ihren eigenen Text, beide schließen sich gegenseitig aus). + (`lib/downloads/downloads_screen.dart`, + `lib/downloads/youtube_search_screen.dart`) +- ✅ **Getestet (TDD, RED→GREEN):** `merkeVerbleibend` in + `test/services/baka_auth_test.dart`; Erfolgsfall mit `cloud_remaining` + plus eine Trennschärfe-Gegenprobe (Gast-Zugriff liest `cloud_remaining` + nie, selbst wenn es im Body steht) in + `test/services/yt_download_test.dart`; je ein Widget-Test für den neuen + „Noch N von 100 heute“-Text in `test/downloads/online_screen_test.dart` + und `test/downloads/youtube_search_screen_test.dart`. Volle Suite + grün, `flutter analyze` ohne Befund. + ### 🐛 Gast-Zugang: Fixe aus dem Branch-Abschluss-Review (2026-08-26) - 🔓 **Gast-Modus war eine Einbahnstraße.** Einmal "Als Gast fortfahren" diff --git a/lib/downloads/downloads_screen.dart b/lib/downloads/downloads_screen.dart index bc7063e..68cfbf9 100644 --- a/lib/downloads/downloads_screen.dart +++ b/lib/downloads/downloads_screen.dart @@ -831,6 +831,21 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ), const SizedBox(height: 8), ], + if (auth.istAngemeldet && auth.verbleibend != null) ...[ + Row( + children: [ + const Icon(Icons.cloud_outlined, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + 'Noch ${auth.verbleibend} von 100 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + ], + ), + const SizedBox(height: 8), + ], if (istGastModus) ...[ Row( children: [ diff --git a/lib/downloads/youtube_search_screen.dart b/lib/downloads/youtube_search_screen.dart index f3191c5..f8638a5 100644 --- a/lib/downloads/youtube_search_screen.dart +++ b/lib/downloads/youtube_search_screen.dart @@ -159,6 +159,22 @@ class _YoutubeSearchScreenState extends State { ), ], ], + if (auth.istAngemeldet && auth.verbleibend != null) + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Row( + children: [ + const Icon(Icons.cloud_outlined, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + 'Noch ${auth.verbleibend} von 100 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + ], + ), + ), if (istGastModus) Padding( padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), diff --git a/lib/services/baka_auth.dart b/lib/services/baka_auth.dart index ecfa178..1d47cdf 100644 --- a/lib/services/baka_auth.dart +++ b/lib/services/baka_auth.dart @@ -47,10 +47,16 @@ class BakaAuth extends ChangeNotifier { String? _token; String _benutzer = ''; + int? _verbleibend; bool get istAngemeldet => _token != null && _token!.isNotEmpty; String get benutzer => _benutzer; + /// Zuletzt vom Server gemeldeter Kontingent-Stand (100/Tag) — nur fürs + /// Anzeigen, die Wahrheit bleibt beim Server. `null` vor dem ersten + /// Download in dieser Session. + int? get verbleibend => _verbleibend; + /// Header für Anfragen an den Proxy. Ohne Anmeldung ohne `Authorization`. Map get authHeader => { if (istAngemeldet) 'Authorization': 'Bearer $_token', @@ -111,6 +117,12 @@ class BakaAuth extends ChangeNotifier { await anmelden(benutzer, passwort); } + /// Übernimmt den zuletzt vom Server gemeldeten Kontingent-Stand. + void merkeVerbleibend(int n) { + _verbleibend = n; + notifyListeners(); + } + Future abmelden() async { _token = null; _benutzer = ''; diff --git a/lib/services/yt_download_service.dart b/lib/services/yt_download_service.dart index ce33304..cf2e2cb 100644 --- a/lib/services/yt_download_service.dart +++ b/lib/services/yt_download_service.dart @@ -160,6 +160,10 @@ class YtDownloadService extends ChangeNotifier { if (gastAktiv && gastRest != null) { gast!.merkeVerbleibend(gastRest); } + final cloudRest = daten['cloud_remaining'] as int?; + if (!gastAktiv && cloudRest != null) { + auth.merkeVerbleibend(cloudRest); + } // ─── 2/2: fertige MP3 abholen und speichern ─── _melde('Lade „$titel“ …'); diff --git a/test/downloads/online_screen_test.dart b/test/downloads/online_screen_test.dart index 8f68dd1..3f6b988 100644 --- a/test/downloads/online_screen_test.dart +++ b/test/downloads/online_screen_test.dart @@ -253,6 +253,21 @@ void main() { findsOneWidget); }); + testWidgets( + 'Angemeldeter Cloud-Account sieht das Kontingent nach einem Download', + (tester) async { + final auth = await _angemeldet(); + + await tester.pumpWidget(_wrap(auth, db: db, categories: categories)); + await tester.pumpAndSettle(); + expect(find.textContaining('von 100 heute'), findsNothing); + + auth.merkeVerbleibend(63); + await tester.pump(); + + expect(find.text('Noch 63 von 100 heute'), findsOneWidget); + }); + testWidgets( 'Server-User meldet sich im Hintergrund mit denselben Zugangsdaten ' 'beim Baka-Konto an', (tester) async { diff --git a/test/downloads/youtube_search_screen_test.dart b/test/downloads/youtube_search_screen_test.dart index 12a1ece..3b93f26 100644 --- a/test/downloads/youtube_search_screen_test.dart +++ b/test/downloads/youtube_search_screen_test.dart @@ -176,6 +176,26 @@ void main() { await db.close(); }); + testWidgets('Angemeldeter Cloud-Account sieht das Kontingent nach Download', + (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = await _angemeldeteAuth(); + final search = YtSearchService(auth: auth); + final download = YtDownloadService(auth: auth); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download)); + await tester.pumpAndSettle(); + expect(find.textContaining('von 100 heute'), findsNothing); + + auth.merkeVerbleibend(98); + await tester.pump(); + + expect(find.text('Noch 98 von 100 heute'), findsOneWidget); + + await db.close(); + }); + // Kein Widget-Test für den Download-Knopf selbst: YtDownloadService. // herunterladen() kombiniert Future.any mit .timeout() — dessen Timer // bleibt unter Flutters fake_async-Testbindung immer als "pending" stehen diff --git a/test/services/baka_auth_test.dart b/test/services/baka_auth_test.dart index 6be2650..b992265 100644 --- a/test/services/baka_auth_test.dart +++ b/test/services/baka_auth_test.dart @@ -129,6 +129,20 @@ void main() { expect(auth.istAngemeldet, isFalse); }); + test('merkeVerbleibend übernimmt den Kontingent-Stand und meldet Listener', + () async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + var benachrichtigt = 0; + auth.addListener(() => benachrichtigt++); + + auth.merkeVerbleibend(37); + + expect(auth.verbleibend, 37); + expect(benachrichtigt, 1); + }); + test('Abmelden löscht Token und Benutzer aus dem Speicher', () async { final speicher = _MemorySpeicher(); final auth = BakaAuth( diff --git a/test/services/yt_download_test.dart b/test/services/yt_download_test.dart index 002894e..97c4798 100644 --- a/test/services/yt_download_test.dart +++ b/test/services/yt_download_test.dart @@ -380,4 +380,76 @@ void main() { expect(tokenAufrufe, 1); }); }); + + group('Cloud-Kontingent', () { + test('cloud_remaining aus der Erfolgsantwort landet in auth.verbleibend', + () async { + final auth = await _angemeldeteAuth(); + final dienst = YtDownloadService( + auth: auth, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + return http.Response( + jsonEncode({ + 'titel': 'Cloud-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/c.mp3', + 'cloud_remaining': 99, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(auth.verbleibend, 99); + }); + + test( + 'Bei Gast-Zugriff wird cloud_remaining nicht gelesen, selbst wenn es ' + 'im Body steht', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + + final dienst = YtDownloadService( + auth: auth, + gast: gast, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + return http.Response( + jsonEncode({ + 'titel': 'Gast-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/g.mp3', + 'guest_remaining': 4, + // Sollte serverseitig nie gleichzeitig vorkommen, aber + // falls doch: darf nicht in auth.verbleibend landen. + 'cloud_remaining': 77, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(gast.verbleibend, 4); + expect(auth.verbleibend, isNull); + }); + }); } -- 2.54.0 From c3f541f2663182cea8d32a997e8a7a4f0c9cf1a8 Mon Sep 17 00:00:00 2001 From: "Hermes (Server)" Date: Sat, 29 Aug 2026 13:27:44 +0200 Subject: [PATCH 12/12] =?UTF-8?q?BakaAuth.abmelden()=20setzt=20auch=20Kont?= =?UTF-8?q?ingent-Anzeige=20zur=C3=BCck?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review-Fix: abmelden() setzte _verbleibend bisher nicht zurück, anders als GastZugang.verwerfen() (_verbleibend = null). Ohne den Fix bliebe nach einem Account-Wechsel (z.B. Baka -> Tinker) der alte Kontingent-Stand sichtbar, bis der nächste Download einen frischen Stand liefert. Aktuell folgenlos (verbleibend ist bis zum Server-Rollout ohnehin immer null), aber ein latenter Bug. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_012A2pmbnVNPiHdyf2GW8eLP --- CHANGELOG.md | 15 +++++++++++++++ lib/services/baka_auth.dart | 1 + test/services/baka_auth_test.dart | 14 ++++++++++++++ 3 files changed, 30 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 234f36b..8013583 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,21 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/). ## [Unreleased] +### 🐛 Cloud-Kontingent-Fix aus dem Task-Review (2026-08-29) + +- 🔁 **`BakaAuth.abmelden()` setzt jetzt auch `verbleibend` zurück.** + Referenzmuster `GastZugang.verwerfen()` setzt `_verbleibend = null` mit, + `abmelden()` tat das bisher nicht — nur `_token`/`_benutzer` wurden + zurückgesetzt. Meldet sich ein Cloud-User ab und ein ANDERER Cloud-User + (Dustin/Baka/Tinker) danach an, wäre sonst bis zum nächsten Download der + alte Kontingent-Stand des vorherigen Accounts sichtbar geblieben. + Aktuell folgenlos (da `verbleibend` bis zum Server-Rollout ohnehin immer + `null` ist), aber ein latenter Bug, der beim Server-Rollout live + gegangen wäre. (`lib/services/baka_auth.dart`) +- ✅ **Getestet (RED→GREEN):** neuer Test „Abmelden setzt auch den + Kontingent-Stand zurück" in `test/services/baka_auth_test.dart`. Volle + Suite grün, `flutter analyze` ohne Befund. + ### ☁️ Cloud-Account-Kontingent: App-Seite für das 100/Tag-Limit (2026-08-29) - ⚠️ **Reine App-Seite, ohne Wirkung bis der Server mitzieht.** Die diff --git a/lib/services/baka_auth.dart b/lib/services/baka_auth.dart index 1d47cdf..4ef1421 100644 --- a/lib/services/baka_auth.dart +++ b/lib/services/baka_auth.dart @@ -126,6 +126,7 @@ class BakaAuth extends ChangeNotifier { Future abmelden() async { _token = null; _benutzer = ''; + _verbleibend = null; await _speicher.loeschen(_tokenKey); await _speicher.loeschen(_userKey); notifyListeners(); diff --git a/test/services/baka_auth_test.dart b/test/services/baka_auth_test.dart index b992265..6d3e4e7 100644 --- a/test/services/baka_auth_test.dart +++ b/test/services/baka_auth_test.dart @@ -143,6 +143,20 @@ void main() { expect(benachrichtigt, 1); }); + test('Abmelden setzt auch den Kontingent-Stand zurück', () async { + final speicher = _MemorySpeicher(); + final auth = BakaAuth( + client: MockClient( + (_) async => http.Response(jsonEncode({'token': 'jwt-abc'}), 200)), + speicher: speicher); + await auth.anmelden('Baka', 'geheim'); + auth.merkeVerbleibend(42); + + await auth.abmelden(); + + expect(auth.verbleibend, isNull); + }); + test('Abmelden löscht Token und Benutzer aus dem Speicher', () async { final speicher = _MemorySpeicher(); final auth = BakaAuth( -- 2.54.0