Anmeldung über die Plex-Seite statt über einen Code

Kein Code mehr zum Abtippen. Die Anmeldemaske kommt von Plex und öffnet
sich über ASWebAuthenticationSession in einem Fenster innerhalb der App;
nach dem Anmelden schickt Plex über forwardUrl auf ein eigenes Schema
zurück, das Fenster schließt sich von selbst.

Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem Plex
einen Token herausgibt. Sichtbar ist er nicht mehr.

Was das bringt:
- Kein Fernseher-Gefühl mehr.
- Zwei-Faktor läuft mit, weil Plex die Seite selbst ausliefert.
- Das Passwort erreicht Flixy nie. Steht auch so unter dem Knopf.
- prefersEphemeralWebBrowserSession = false: wer in Safari schon bei
  Plex angemeldet ist, braucht nur zu bestätigen.

Zwei Details, die sonst still scheitern:
- Die Rückadresse wird strenger kodiert als die übrigen Werte. `:` und
  `/` lässt urlQueryAllowed durch, und für Plex endete der Wert dann
  beim ersten Schrägstrich — der Rücksprung käme nie.
- Das Schema muss in CFBundleURLTypes stehen, sonst kennt iOS es nicht
  und das Fenster bliebe offen stehen.

Als Schema die Bundle-Kennung statt eines kurzen Worts wie „flixy":
ein kurzes könnte eine andere App beanspruchen und die Anmeldung
abfangen.

132 Tests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy/Session/FlixySession.swift

@@ -14,8 +14,8 @@ final class FlixySession {
         /// Beim Start: liegt ein Token im Schlüsselbund?
         case launching
         case signedOut
-        /// Der Code steht bereit, der Nutzer bestätigt ihn im Browser.
-        case awaitingAuthorization(PlexPin)
+        /// Das Anmeldefenster von Plex ist offen.
+        case authenticating
         /// Mehrere Server am Konto — einer muss gewählt werden.
         case choosingServer([PlexResource])
         /// Ein Weg zum Server wird gesucht.
@@ -27,8 +27,8 @@ final class FlixySession {
             switch (lhs, rhs) {
             case (.launching, .launching), (.signedOut, .signedOut), (.ready, .ready):
                 true
-            case (.awaitingAuthorization(let l), .awaitingAuthorization(let r)):
-                l.id == r.id
+            case (.authenticating, .authenticating):
+                true
             case (.choosingServer(let l), .choosingServer(let r)):
                 l.map(\.clientIdentifier) == r.map(\.clientIdentifier)
             case (.connecting(let l), .connecting(let r)):
@@ -58,6 +58,7 @@ final class FlixySession {
     private let identity: PlexClientIdentity
     private let tokenStore: any TokenStoring
     private let authenticator: PlexAuthenticator
+    private let webAuthenticator = PlexWebAuthenticator()
     private let defaults: UserDefaults
     private var authorizationTask: Task<Void, Never>?
 
@@ -85,11 +86,47 @@ final class FlixySession {
 
     // MARK: - Anmeldung
 
+    /// Öffnet die Anmeldeseite von Plex.
+    ///
+    /// Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem
+    /// Plex einen Token herausgibt. Sichtbar ist er nicht mehr: Plex liefert
+    /// seine eigene Anmeldemaske aus und schickt die App danach über
+    /// `forwardUrl` zurück.
     func beginSignIn() async {
+        phase = .authenticating
+
         do {
             let pin = try await authenticator.requestPin()
-            phase = .awaitingAuthorization(pin)
-            waitForAuthorization(of: pin)
+
+            guard let url = pin.authorizationURL(
+                clientIdentifier: identity.clientIdentifier,
+                product: Branding.plexProduct,
+                forwardURL: Branding.authCallbackURL
+            ) else {
+                phase = .failed(message: String(localized: "signIn.windowFailed"))
+                return
+            }
+
+            try await webAuthenticator.authenticate(
+                url: url,
+                callbackScheme: Branding.urlScheme
+            )
+
+            // Das Fenster ist zu, jetzt liegt der Token bereit. Kurz
+            // nachgefragt statt sofort erwartet: zwischen dem Rücksprung und
+            // dem Eintrag bei Plex liegen manchmal ein, zwei Sekunden.
+            let token = try await authenticator.waitForAuthorization(
+                pin: pin,
+                pollInterval: .milliseconds(500),
+                timeout: .seconds(20)
+            )
+            await connect(accountToken: token)
+
+        } catch PlexWebAuthenticator.Failure.cancelled {
+            // Fenster geschlossen. Kein Fehler — kommentarlos zurück.
+            phase = .signedOut
+        } catch let error as PlexWebAuthenticator.Failure {
+            phase = .failed(message: webAuthenticationMessage(for: error))
         } catch {
             phase = .failed(message: message(for: error))
         }
@@ -101,17 +138,10 @@ final class FlixySession {
         phase = .signedOut
     }
 
-    private func waitForAuthorization(of pin: PlexPin) {
-        authorizationTask?.cancel()
-        authorizationTask = Task { [authenticator] in
-            do {
-                let token = try await authenticator.waitForAuthorization(pin: pin)
-                guard !Task.isCancelled else { return }
-                await connect(accountToken: token)
-            } catch {
-                guard !Task.isCancelled else { return }
-                phase = .failed(message: message(for: error))
-            }
+    private func webAuthenticationMessage(for failure: PlexWebAuthenticator.Failure) -> String {
+        switch failure {
+        case .cancelled: String(localized: "signIn.cancelled")
+        case .presentationFailed(let description): description
         }
     }