Initial PeerTube Support

Model/Applications/InvidiousAPI.swift

@@ -9,9 +9,12 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
     static let basePath = "/api/v1"
 
     @Published var account: Account!
-
     @Published var validInstance = true
 
+    static func withAnonymousAccountForInstanceURL(_ url: URL) -> InvidiousAPI {
+        .init(account: Instance(app: .invidious, apiURLString: url.absoluteString).anonymousAccount)
+    }
+
     var signedIn: Bool {
         guard let account else { return false }
 
@@ -452,7 +455,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
     }
 
     static func proxiedAsset(instance: Instance, asset: AVURLAsset) -> AVURLAsset? {
-        guard let instanceURLComponents = URLComponents(string: instance.apiURL),
+        guard let instanceURLComponents = URLComponents(url: instance.apiURL, resolvingAgainstBaseURL: false),
               var urlComponents = URLComponents(url: asset.url, resolvingAgainstBaseURL: false) else { return nil }
 
         urlComponents.scheme = instanceURLComponents.scheme
@@ -487,7 +490,9 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         let description = json["description"].stringValue
 
         return Video(
-            id: id,
+            instanceID: account.instanceID,
+            app: .invidious,
+            instanceURL: account.instance.apiURL,
             videoID: videoID,
             title: json["title"].stringValue,
             author: json["author"].stringValue,
@@ -518,7 +523,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         // append protocol to unproxied thumbnail URL if it's missing
         if thumbnailURL.count > 2,
            String(thumbnailURL[..<thumbnailURL.index(thumbnailURL.startIndex, offsetBy: 2)]) == "//",
-           let accountUrlComponents = URLComponents(string: account.url)
+           let accountUrlComponents = URLComponents(string: account.urlString)
         {
             thumbnailURL = "\(accountUrlComponents.scheme ?? "https"):\(thumbnailURL)"
         }
@@ -553,7 +558,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
             guard let url = json["url"].url,
                   var components = URLComponents(url: url, resolvingAgainstBaseURL: false),
                   let quality = json["quality"].string,
-                  let accountUrlComponents = URLComponents(string: account.url)
+                  let accountUrlComponents = URLComponents(string: account.urlString)
             else {
                 return nil
             }
@@ -677,8 +682,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
     private func extractCaptions(from content: JSON) -> [Captions] {
         content["captions"].arrayValue.compactMap { details in
-            let baseURL = account.url
-            guard let url = URL(string: baseURL + details["url"].stringValue) else { return nil }
+            guard let url = URL(string: details["url"].stringValue, relativeTo: account.url) else { return nil }
 
             return Captions(
                 label: details["label"].stringValue,

Model/Applications/PeerTubeAPI.swift

@@ -0,0 +1,592 @@
+import Alamofire
+import AVKit
+import Defaults
+import Foundation
+import Siesta
+import SwiftyJSON
+
+final class PeerTubeAPI: Service, ObservableObject, VideosAPI {
+    static let basePath = "/api/v1"
+
+    @Published var account: Account!
+
+    @Published var validInstance = true
+
+    var signedIn: Bool {
+        guard let account else { return false }
+
+        return !account.anonymous && !(account.token?.isEmpty ?? true)
+    }
+
+    static func withAnonymousAccountForInstanceURL(_ url: URL) -> PeerTubeAPI {
+        .init(account: Instance(app: .peerTube, apiURLString: url.absoluteString).anonymousAccount)
+    }
+
+    init(account: Account? = nil) {
+        super.init()
+
+        guard !account.isNil else {
+            self.account = .init(name: "Empty")
+            return
+        }
+
+        setAccount(account!)
+    }
+
+    func setAccount(_ account: Account) {
+        self.account = account
+
+        validInstance = account.anonymous
+
+        configure()
+
+        if !account.anonymous {
+            validate()
+        }
+    }
+
+    func validate() {
+        validateInstance()
+        validateSID()
+    }
+
+    func validateInstance() {
+        guard !validInstance else {
+            return
+        }
+
+        home?
+            .load()
+            .onSuccess { _ in
+                self.validInstance = true
+            }
+            .onFailure { _ in
+                self.validInstance = false
+            }
+    }
+
+    func validateSID() {
+        guard signedIn, !(account.token?.isEmpty ?? true) else {
+            return
+        }
+
+        feed?
+            .load()
+            .onFailure { _ in
+                self.updateToken(force: true)
+            }
+    }
+
+    func configure() {
+        invalidateConfiguration()
+
+        configure {
+            if let cookie = self.cookieHeader {
+                $0.headers["Cookie"] = cookie
+            }
+            $0.pipeline[.parsing].add(SwiftyJSONTransformer, contentTypes: ["*/json"])
+        }
+
+        configure("**", requestMethods: [.post]) {
+            $0.pipeline[.parsing].removeTransformers()
+        }
+
+        configureTransformer(pathPattern("popular"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
+            content.json.arrayValue.map(self.extractVideo)
+        }
+
+        configureTransformer(pathPattern("videos"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
+            content.json.dictionaryValue["data"]?.arrayValue.map(self.extractVideo) ?? []
+        }
+
+        configureTransformer(pathPattern("search/videos"), requestMethods: [.get]) { (content: Entity<JSON>) -> SearchPage in
+            let results = content.json.dictionaryValue["data"]?.arrayValue.compactMap { json -> ContentItem in .init(video: self.extractVideo(from: json)) } ?? []
+            return SearchPage(results: results, last: results.isEmpty)
+        }
+
+        configureTransformer(pathPattern("search/suggestions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [String] in
+            if let suggestions = content.json.dictionaryValue["suggestions"] {
+                return suggestions.arrayValue.map(String.init)
+            }
+
+            return []
+        }
+
+        configureTransformer(pathPattern("auth/playlists"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Playlist] in
+            content.json.arrayValue.map(self.extractPlaylist)
+        }
+
+        configureTransformer(pathPattern("auth/playlists/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Playlist in
+            self.extractPlaylist(from: content.json)
+        }
+
+        configureTransformer(pathPattern("auth/playlists"), requestMethods: [.post, .patch]) { (content: Entity<Data>) -> Playlist in
+            // hacky, to verify if possible to get it in easier way
+            Playlist(JSON(parseJSON: String(data: content.content, encoding: .utf8)!))
+        }
+
+        configureTransformer(pathPattern("auth/feed"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
+            if let feedVideos = content.json.dictionaryValue["videos"] {
+                return feedVideos.arrayValue.map(self.extractVideo)
+            }
+
+            return []
+        }
+
+        configureTransformer(pathPattern("auth/subscriptions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Channel] in
+            content.json.arrayValue.map(self.extractChannel)
+        }
+
+        configureTransformer(pathPattern("channels/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Channel in
+            self.extractChannel(from: content.json)
+        }
+
+        configureTransformer(pathPattern("channels/*/latest"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
+            content.json.arrayValue.map(self.extractVideo)
+        }
+
+        configureTransformer(pathPattern("channels/*/playlists"), requestMethods: [.get]) { (content: Entity<JSON>) -> [ContentItem] in
+            let playlists = (content.json.dictionaryValue["playlists"]?.arrayValue ?? []).compactMap { self.extractChannelPlaylist(from: $0) }
+            return ContentItem.array(of: playlists)
+        }
+
+        configureTransformer(pathPattern("playlists/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> ChannelPlaylist in
+            self.extractChannelPlaylist(from: content.json)
+        }
+
+        configureTransformer(pathPattern("videos/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Video in
+            self.extractVideo(from: content.json)
+        }
+
+        configureTransformer(pathPattern("comments/*")) { (content: Entity<JSON>) -> CommentsPage in
+            let details = content.json.dictionaryValue
+            let comments = details["comments"]?.arrayValue.compactMap { self.extractComment(from: $0) } ?? []
+            let nextPage = details["continuation"]?.string
+            let disabled = !details["error"].isNil
+
+            return CommentsPage(comments: comments, nextPage: nextPage, disabled: disabled)
+        }
+
+        updateToken()
+    }
+
+    func updateToken(force: Bool = false) {
+        let (username, password) = AccountsModel.getCredentials(account)
+        guard !account.anonymous,
+              (account.token?.isEmpty ?? true) || force
+        else {
+            return
+        }
+
+        guard let username,
+              let password,
+              !username.isEmpty,
+              !password.isEmpty
+        else {
+            NavigationModel.shared.presentAlert(
+                title: "Account Error",
+                message: "Remove and add your account again in Settings."
+            )
+            return
+        }
+
+        let presentTokenUpdateFailedAlert: (AFDataResponse<Data?>?, String?) -> Void = { response, message in
+            NavigationModel.shared.presentAlert(
+                title: "Account Error",
+                message: message ?? "\(response?.response?.statusCode ?? -1) - \(response?.error?.errorDescription ?? "unknown")\nIf this issue persists, try removing and adding your account again in Settings."
+            )
+        }
+
+        AF
+            .request(login.url, method: .post, parameters: ["email": username, "password": password], encoding: URLEncoding.default)
+            .redirect(using: .doNotFollow)
+            .response { response in
+                guard let headers = response.response?.headers,
+                      let cookies = headers["Set-Cookie"]
+                else {
+                    presentTokenUpdateFailedAlert(response, nil)
+                    return
+                }
+
+                let sidRegex = #"SID=(?<sid>[^;]*);"#
+                guard let sidRegex = try? NSRegularExpression(pattern: sidRegex),
+                      let match = sidRegex.matches(in: cookies, range: NSRange(cookies.startIndex..., in: cookies)).first
+                else {
+                    presentTokenUpdateFailedAlert(nil, String(format: "Could not extract SID from received cookies: %@".localized(), cookies))
+                    return
+                }
+
+                let matchRange = match.range(withName: "sid")
+
+                if let substringRange = Range(matchRange, in: cookies) {
+                    let sid = String(cookies[substringRange])
+                    AccountsModel.setToken(self.account, sid)
+                    self.objectWillChange.send()
+                } else {
+                    presentTokenUpdateFailedAlert(nil, String(format: "Could not extract SID from received cookies: %@".localized(), cookies))
+                }
+
+                self.configure()
+            }
+    }
+
+    var login: Resource {
+        resource(baseURL: account.url, path: "login")
+    }
+
+    private func pathPattern(_ path: String) -> String {
+        "**\(Self.basePath)/\(path)"
+    }
+
+    private func basePathAppending(_ path: String) -> String {
+        "\(Self.basePath)/\(path)"
+    }
+
+    private var cookieHeader: String? {
+        guard let token = account?.token, !token.isEmpty else { return nil }
+        return "SID=\(token)"
+    }
+
+    var popular: Resource? {
+        resource(baseURL: account.url, path: "\(Self.basePath)/popular")
+    }
+
+    func trending(country: Country, category: TrendingCategory?) -> Resource {
+        resource(baseURL: account.url, path: "\(Self.basePath)/videos")
+            .withParam("isLocal", "true")
+//            .withParam("type", category?.name)
+//            .withParam("region", country.rawValue)
+    }
+
+    var home: Resource? {
+        resource(baseURL: account.url, path: "/feed/subscriptions")
+    }
+
+    var feed: Resource? {
+        resource(baseURL: account.url, path: "\(Self.basePath)/auth/feed")
+    }
+
+    var subscriptions: Resource? {
+        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+    }
+
+    func subscribe(_ channelID: String, onCompletion: @escaping () -> Void = {}) {
+        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+            .child(channelID)
+            .request(.post)
+            .onCompletion { _ in onCompletion() }
+    }
+
+    func unsubscribe(_ channelID: String, onCompletion: @escaping () -> Void) {
+        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+            .child(channelID)
+            .request(.delete)
+            .onCompletion { _ in onCompletion() }
+    }
+
+    func channel(_ id: String, contentType: Channel.ContentType, data _: String?) -> Resource {
+        if contentType == .playlists {
+            return resource(baseURL: account.url, path: basePathAppending("channels/\(id)/playlists"))
+        }
+        return resource(baseURL: account.url, path: basePathAppending("channels/\(id)"))
+    }
+
+    func channelByName(_: String) -> Resource? {
+        nil
+    }
+
+    func channelByUsername(_: String) -> Resource? {
+        nil
+    }
+
+    func channelVideos(_ id: String) -> Resource {
+        resource(baseURL: account.url, path: basePathAppending("channels/\(id)/latest"))
+    }
+
+    func video(_ id: String) -> Resource {
+        resource(baseURL: account.url, path: basePathAppending("videos/\(id)"))
+    }
+
+    var playlists: Resource? {
+        if account.isNil || account.anonymous {
+            return nil
+        }
+
+        return resource(baseURL: account.url, path: basePathAppending("auth/playlists"))
+    }
+
+    func playlist(_ id: String) -> Resource? {
+        resource(baseURL: account.url, path: basePathAppending("auth/playlists/\(id)"))
+    }
+
+    func playlistVideos(_ id: String) -> Resource? {
+        playlist(id)?.child("videos")
+    }
+
+    func playlistVideo(_ playlistID: String, _ videoID: String) -> Resource? {
+        playlist(playlistID)?.child("videos").child(videoID)
+    }
+
+    func addVideoToPlaylist(
+        _ videoID: String,
+        _ playlistID: String,
+        onFailure: @escaping (RequestError) -> Void = { _ in },
+        onSuccess: @escaping () -> Void = {}
+    ) {
+        let resource = playlistVideos(playlistID)
+        let body = ["videoId": videoID]
+
+        resource?
+            .request(.post, json: body)
+            .onSuccess { _ in onSuccess() }
+            .onFailure(onFailure)
+    }
+
+    func removeVideoFromPlaylist(
+        _ index: String,
+        _ playlistID: String,
+        onFailure: @escaping (RequestError) -> Void,
+        onSuccess: @escaping () -> Void
+    ) {
+        let resource = playlistVideo(playlistID, index)
+
+        resource?
+            .request(.delete)
+            .onSuccess { _ in onSuccess() }
+            .onFailure(onFailure)
+    }
+
+    func playlistForm(
+        _ name: String,
+        _ visibility: String,
+        playlist: Playlist?,
+        onFailure: @escaping (RequestError) -> Void,
+        onSuccess: @escaping (Playlist?) -> Void
+    ) {
+        let body = ["title": name, "privacy": visibility]
+        let resource = !playlist.isNil ? self.playlist(playlist!.id) : playlists
+
+        resource?
+            .request(!playlist.isNil ? .patch : .post, json: body)
+            .onSuccess { response in
+                if let modifiedPlaylist: Playlist = response.typedContent() {
+                    onSuccess(modifiedPlaylist)
+                }
+            }
+            .onFailure(onFailure)
+    }
+
+    func deletePlaylist(
+        _ playlist: Playlist,
+        onFailure: @escaping (RequestError) -> Void,
+        onSuccess: @escaping () -> Void
+    ) {
+        self.playlist(playlist.id)?
+            .request(.delete)
+            .onSuccess { _ in onSuccess() }
+            .onFailure(onFailure)
+    }
+
+    func channelPlaylist(_ id: String) -> Resource? {
+        resource(baseURL: account.url, path: basePathAppending("playlists/\(id)"))
+    }
+
+    func search(_ query: SearchQuery, page: String?) -> Resource {
+        var resource = resource(baseURL: account.url, path: basePathAppending("search/videos"))
+            .withParam("search", query.query)
+//            .withParam("sort_by", query.sortBy.parameter)
+//            .withParam("type", "all")
+//
+//        if let date = query.date, date != .any {
+//            resource = resource.withParam("date", date.rawValue)
+//        }
+//
+//        if let duration = query.duration, duration != .any {
+//            resource = resource.withParam("duration", duration.rawValue)
+//        }
+//
+//        if let page {
+//            resource = resource.withParam("page", page)
+//        }
+
+        return resource
+    }
+
+    func searchSuggestions(query: String) -> Resource {
+        resource(baseURL: account.url, path: basePathAppending("search/suggestions"))
+            .withParam("q", query.lowercased())
+    }
+
+    func comments(_ id: Video.ID, page: String?) -> Resource? {
+        let resource = resource(baseURL: account.url, path: basePathAppending("comments/\(id)"))
+        guard let page else { return resource }
+
+        return resource.withParam("continuation", page)
+    }
+
+    static func proxiedAsset(instance: Instance, asset: AVURLAsset) -> AVURLAsset? {
+        guard let instanceURLComponents = URLComponents(string: instance.apiURLString),
+              var urlComponents = URLComponents(url: asset.url, resolvingAgainstBaseURL: false) else { return nil }
+
+        urlComponents.scheme = instanceURLComponents.scheme
+        urlComponents.host = instanceURLComponents.host
+
+        guard let url = urlComponents.url else {
+            return nil
+        }
+
+        return AVURLAsset(url: url)
+    }
+
+    func extractVideo(from json: JSON) -> Video {
+        let id = json["uuid"].stringValue
+        let url = json["url"].url
+        let dateFormatter = ISO8601DateFormatter()
+        dateFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let publishedAt = dateFormatter.date(from: json["publishedAt"].stringValue)
+
+        return Video(
+            instanceID: account.instanceID,
+            app: .peerTube,
+            instanceURL: account.instance.apiURL,
+            id: id,
+            videoID: id,
+            videoURL: url,
+            title: json["name"].stringValue,
+            author: json["channel"].dictionaryValue["name"]?.stringValue ?? "",
+            length: json["duration"].doubleValue,
+            views: json["views"].intValue,
+            description: json["description"].stringValue,
+            channel: extractChannel(from: json["channel"]),
+            thumbnails: extractThumbnails(from: json),
+            live: json["isLive"].boolValue,
+            publishedAt: publishedAt,
+            likes: json["likes"].int,
+            dislikes: json["dislikes"].int,
+            streams: extractStreams(from: json)
+//            related: extractRelated(from: json),
+//            chapters: extractChapters(from: description),
+//            captions: extractCaptions(from: json)
+        )
+    }
+
+    func extractChannel(from json: JSON) -> Channel {
+        Channel(
+            id: json["id"].stringValue,
+            name: json["name"].stringValue
+        )
+    }
+
+    func extractChannelPlaylist(from json: JSON) -> ChannelPlaylist {
+        let details = json.dictionaryValue
+        return ChannelPlaylist(
+            id: details["playlistId"]?.string ?? details["mixId"]?.string ?? UUID().uuidString,
+            title: details["title"]?.stringValue ?? "",
+            thumbnailURL: details["playlistThumbnail"]?.url,
+            channel: extractChannel(from: json),
+            videos: details["videos"]?.arrayValue.compactMap(extractVideo) ?? [],
+            videosCount: details["videoCount"]?.int
+        )
+    }
+
+    private func extractThumbnails(from details: JSON) -> [Thumbnail] {
+        if let thumbnailPath = details["thumbnailPath"].string {
+            return [Thumbnail(url: URL(string: thumbnailPath, relativeTo: account.url)!, quality: .medium)]
+        }
+        return []
+    }
+
+    private func extractStreams(from json: JSON) -> [Stream] {
+        let hls = extractHLSStreams(from: json)
+
+        if json["isLive"].boolValue {
+            return hls
+        }
+
+        return extractFormatStreams(from: json) +
+            extractAdaptiveFormats(from: json) +
+            hls
+    }
+
+    private func extractFormatStreams(from json: JSON) -> [Stream] {
+        var streams = [Stream]()
+        if let fileURL = json.dictionaryValue["streamingPlaylists"]?.arrayValue.first?
+            .dictionaryValue["files"]?.arrayValue.first?
+            .dictionaryValue["fileUrl"]?.url
+        {
+            streams.append(SingleAssetStream(instance: account.instance, avAsset: AVURLAsset(url: fileURL), resolution: .hd720p30, kind: .stream))
+        }
+
+        return streams
+    }
+
+    private func extractAdaptiveFormats(from json: JSON) -> [Stream] {
+        json.dictionaryValue["files"]?.arrayValue.compactMap { file in
+            if let resolution = file.dictionaryValue["resolution"]?.dictionaryValue["label"]?.stringValue, let url = file.dictionaryValue["fileUrl"]?.url {
+                return SingleAssetStream(instance: account.instance, avAsset: AVURLAsset(url: url), resolution: Stream.Resolution.from(resolution: resolution), kind: .adaptive, videoFormat: "mp4")
+            }
+
+            return nil
+        } ?? []
+    }
+
+    private func extractHLSStreams(from content: JSON) -> [Stream] {
+        if let hlsURL = content.dictionaryValue["streamingPlaylists"]?.arrayValue.first?.dictionaryValue["playlistUrl"]?.url {
+            return [Stream(instance: account.instance, hlsURL: hlsURL)]
+        }
+
+        return []
+    }
+
+    private func extractRelated(from content: JSON) -> [Video] {
+        content
+            .dictionaryValue["recommendedVideos"]?
+            .arrayValue
+            .compactMap(extractVideo(from:)) ?? []
+    }
+
+    private func extractPlaylist(from content: JSON) -> Playlist {
+        let id = content["playlistId"].stringValue
+        return Playlist(
+            id: id,
+            title: content["title"].stringValue,
+            visibility: content["isListed"].boolValue ? .public : .private,
+            editable: id.starts(with: "IV"),
+            updated: content["updated"].doubleValue,
+            videos: content["videos"].arrayValue.map { extractVideo(from: $0) }
+        )
+    }
+
+    private func extractComment(from content: JSON) -> Comment? {
+        let details = content.dictionaryValue
+        let author = details["author"]?.string ?? ""
+        let channelId = details["authorId"]?.string ?? UUID().uuidString
+        let authorAvatarURL = details["authorThumbnails"]?.arrayValue.last?.dictionaryValue["url"]?.string ?? ""
+        return Comment(
+            id: UUID().uuidString,
+            author: author,
+            authorAvatarURL: authorAvatarURL,
+            time: details["publishedText"]?.string ?? "",
+            pinned: false,
+            hearted: false,
+            likeCount: details["likeCount"]?.int ?? 0,
+            text: details["content"]?.string ?? "",
+            repliesPage: details["replies"]?.dictionaryValue["continuation"]?.string,
+            channel: Channel(id: channelId, name: author)
+        )
+    }
+
+    private func extractCaptions(from content: JSON) -> [Captions] {
+        content["captions"].arrayValue.compactMap { _ in
+            nil
+//            let baseURL = account.url
+//            guard let url = URL(string: baseURL + details["url"].stringValue) else { return nil }
+//
+//            return Captions(
+//                label: details["label"].stringValue,
+//                code: details["language_code"].stringValue,
+//                url: url
+//            )
+        }
+    }
+}

Model/Applications/PipedAPI.swift

@@ -9,6 +9,10 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
 
     @Published var account: Account!
 
+    static func withAnonymousAccountForInstanceURL(_ url: URL) -> PipedAPI {
+        .init(account: Instance(app: .piped, apiURLString: url.absoluteString).anonymousAccount)
+    }
+
     init(account: Account? = nil) {
         super.init()
 
@@ -473,6 +477,9 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
         }
 
         return Video(
+            instanceID: account.instanceID,
+            app: .piped,
+            instanceURL: account.instance.apiURL,
             videoID: extractID(from: content),
             title: details["title"]?.string ?? "",
             author: author,

Model/Applications/VideosAPI.swift

@@ -6,6 +6,8 @@ protocol VideosAPI {
     var account: Account! { get }
     var signedIn: Bool { get }
 
+    static func withAnonymousAccountForInstanceURL(_ url: URL) -> Self
+
     func channel(_ id: String, contentType: Channel.ContentType, data: String?) -> Resource
     func channelByName(_ name: String) -> Resource?
     func channelByUsername(_ username: String) -> Resource?

Model/Applications/VideosApp.swift

@@ -1,14 +1,17 @@
 import Foundation
 
 enum VideosApp: String, CaseIterable {
-    case invidious, piped
+    case local
+    case invidious
+    case piped
+    case peerTube
 
     var name: String {
         rawValue.capitalized
     }
 
     var supportsAccounts: Bool {
-        true
+        self != .local
     }
 
     var supportsPopular: Bool {
@@ -19,6 +22,10 @@ enum VideosApp: String, CaseIterable {
         self == .invidious
     }
 
+    var supportsSearchSuggestions: Bool {
+        self != .peerTube
+    }
+
     var supportsSubscriptions: Bool {
         supportsAccounts
     }
@@ -28,7 +35,7 @@ enum VideosApp: String, CaseIterable {
     }
 
     var supportsUserPlaylists: Bool {
-        true
+        self != .local
     }
 
     var userPlaylistsEndpointIncludesVideos: Bool {
@@ -64,6 +71,6 @@ enum VideosApp: String, CaseIterable {
     }
 
     var supportsOpeningVideosByID: Bool {
-        true
+        self != .local
     }
 }