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>

Packages/FlixyKit/Sources/PlexKit/Auth/PlexPin.swift

@@ -52,10 +52,17 @@ public struct PlexPin: Sendable, Equatable, Decodable {
     /// antwortet mit „Diese Anfrage konnte nicht abgeschlossen werden".
     /// Festgehalten in `AuthorizationURLTests`.
     ///
-    /// `forwardUrl` fehlt bewusst: der Rücksprung in die App wäre bequemer,
-    /// verlangt aber ein eigenes URL-Schema. Solange die App den Code ohnehin
-    /// im Hintergrund abfragt, merkt niemand einen Unterschied.
-    public func authorizationURL(clientIdentifier: String, product: String) -> URL? {
+    /// `forwardUrl` schickt den Browser nach der Anmeldung auf eine Adresse
+    /// mit eigenem Schema zurück. Genau darauf wartet
+    /// `ASWebAuthenticationSession`: das Anmeldefenster schließt sich von
+    /// selbst, und die App weiß, dass sie den Token abholen kann. Ohne diese
+    /// Rückadresse bliebe die Seite offen und der Nutzer müsste raten, wann er
+    /// fertig ist.
+    public func authorizationURL(
+        clientIdentifier: String,
+        product: String,
+        forwardURL: URL? = nil
+    ) -> URL? {
         // `&`, `=` und `+` müssen raus: sie trennen Parameter bzw. stehen für
         // ein Leerzeichen. In einem Wert würden sie die Adresse zerreißen.
         let allowed = CharacterSet.urlQueryAllowed.subtracting(CharacterSet(charactersIn: "&=+"))
@@ -68,9 +75,22 @@ public struct PlexPin: Sendable, Equatable, Decodable {
               let product = encode(product)
         else { return nil }
 
-        return URL(string: """
+        var text = """
             https://app.plex.tv/auth#?clientID=\(client)&code=\(code)\
             &context%5Bdevice%5D%5Bproduct%5D=\(product)
-            """)
+            """
+
+        // Strenger kodiert als die übrigen Werte: die Rückadresse enthält
+        // `:` und `/`, und die lässt `urlQueryAllowed` durch. Als Wert
+        // innerhalb einer Adresse, die Plex selbst noch einmal zerlegt, müssen
+        // sie kodiert sein — sonst endet der Wert für Plex beim ersten
+        // Schrägstrich.
+        let unreserved = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-._~"))
+        if let forwardURL,
+           let forward = forwardURL.absoluteString.addingPercentEncoding(withAllowedCharacters: unreserved) {
+            text += "&forwardUrl=\(forward)"
+        }
+
+        return URL(string: text)
     }
 }

Packages/FlixyKit/Tests/PlexKitTests/AuthorizationURLTests.swift

@@ -39,3 +39,43 @@ struct AuthorizationURLTests {
         #expect(!url.absoluteString.contains("Flixy Player"))
     }
 }
+
+@Suite("Anmelde-Adresse mit Rücksprung")
+struct AuthorizationForwardURLTests {
+    private let pin = PlexPin(id: 42, code: "5474")
+
+    @Test("Ohne Rückadresse bleibt die Adresse wie bisher")
+    func withoutForwardURL() throws {
+        let url = try #require(pin.authorizationURL(clientIdentifier: "abc", product: "Flixy"))
+        #expect(!url.absoluteString.contains("forwardUrl"))
+    }
+
+    @Test("Die Rückadresse wird angehängt und kodiert")
+    func forwardURLIsAppendedAndEncoded() throws {
+        // Das Schema enthält Doppelpunkte und Schrägstriche. Unkodiert
+        // zerrissen sie die Adresse, und Plex führte den Rücksprung nie aus —
+        // das Anmeldefenster bliebe offen stehen.
+        let url = try #require(pin.authorizationURL(
+            clientIdentifier: "abc",
+            product: "Flixy",
+            forwardURL: URL(string: "com.scarriffleservices.flixy://auth")!
+        ))
+
+        let text = url.absoluteString
+        #expect(text.contains("forwardUrl=com.scarriffleservices.flixy%3A%2F%2Fauth"))
+        #expect(!text.contains("%25"))
+    }
+
+    @Test("Die übrigen Parameter bleiben unversehrt")
+    func otherParametersSurvive() throws {
+        let url = try #require(pin.authorizationURL(
+            clientIdentifier: "abc",
+            product: "Flixy",
+            forwardURL: URL(string: "flixy://auth")!
+        ))
+        let text = url.absoluteString
+        #expect(text.contains("clientID=abc"))
+        #expect(text.contains("code=5474"))
+        #expect(text.contains("context%5Bdevice%5D%5Bproduct%5D=Flixy"))
+    }
+}