feat: add Last.fm scrobbling support (#104)

Author: sozercan

App/KasetApp.swift

@@ -31,6 +31,7 @@ struct KasetApp: App {
     @State private var favoritesManager = FavoritesManager.shared
     @State private var likeStatusManager = SongLikeStatusManager.shared
     @State private var accountService: AccountService?
+    @State private var scrobblingCoordinator: ScrobblingCoordinator
 
     /// Triggers search field focus when set to true.
     @State private var searchFocusTrigger = false
@@ -76,6 +77,16 @@ struct KasetApp: App {
         _notificationService = State(initialValue: NotificationService(playerService: player))
         _accountService = State(initialValue: account)
 
+        // Create scrobbling coordinator
+        let lastFMService = LastFMService(credentialStore: KeychainCredentialStore())
+        let scrobblingCoordinator = ScrobblingCoordinator(
+            playerService: player,
+            services: [lastFMService]
+        )
+        scrobblingCoordinator.restoreAuthState()
+        scrobblingCoordinator.startMonitoring()
+        _scrobblingCoordinator = State(initialValue: scrobblingCoordinator)
+
         // Wire up PlayerService to AppDelegate immediately (not in onAppear)
         // This ensures playerService is available for lifecycle events like queue restoration
         self.appDelegate.playerService = player
@@ -99,6 +110,7 @@ struct KasetApp: App {
                     .environment(self.favoritesManager)
                     .environment(self.likeStatusManager)
                     .environment(self.accountService)
+                    .environment(self.scrobblingCoordinator)
                     .environment(\.searchFocusTrigger, self.$searchFocusTrigger)
                     .environment(\.navigationSelection, self.$navigationSelection)
                     .environment(\.showCommandBar, self.$showCommandBar)
@@ -127,6 +139,7 @@ struct KasetApp: App {
             SettingsView()
                 .environment(self.authService)
                 .environment(self.updaterService)
+                .environment(self.scrobblingCoordinator)
         }
         .commands {
             // Check for Updates command in app menu
@@ -347,6 +360,7 @@ struct KasetApp: App {
 @available(macOS 26.0, *)
 struct SettingsView: View {
     @Environment(UpdaterService.self) private var updaterService
+    @Environment(ScrobblingCoordinator.self) private var scrobblingCoordinator
 
     var body: some View {
         TabView {
@@ -359,6 +373,12 @@ struct SettingsView: View {
                 .tabItem {
                     Label("Intelligence", systemImage: "sparkles")
                 }
+
+            ScrobblingSettingsView()
+                .environment(self.scrobblingCoordinator)
+                .tabItem {
+                    Label("Scrobbling", systemImage: "music.note.list")
+                }
         }
         .frame(width: 450, height: 400)
     }

Core/Services/Scrobbling/KeychainCredentialStore.swift

@@ -0,0 +1,136 @@
+import Foundation
+import Security
+
+// MARK: - KeychainCredentialStore
+
+/// Thin Keychain wrapper for storing scrobbling service credentials.
+/// Uses `kSecClassGenericPassword` with `kSecAttrAccessibleAfterFirstUnlock`.
+@MainActor
+final class KeychainCredentialStore {
+    private let servicePrefix: String
+
+    /// Creates a credential store with the given service prefix.
+    /// - Parameter servicePrefix: Prefix for Keychain entries (default: "com.sertacozercan.Kaset").
+    init(servicePrefix: String = "com.sertacozercan.Kaset") {
+        self.servicePrefix = servicePrefix
+    }
+
+    // MARK: - Public API
+
+    /// Saves the Last.fm session key to Keychain.
+    func saveLastFMSessionKey(_ sessionKey: String) throws {
+        try self.save(key: "lastFMSessionKey", value: sessionKey)
+    }
+
+    /// Retrieves the stored Last.fm session key, if any.
+    func getLastFMSessionKey() -> String? {
+        self.get(key: "lastFMSessionKey")
+    }
+
+    /// Saves the Last.fm username to Keychain.
+    func saveLastFMUsername(_ username: String) throws {
+        try self.save(key: "lastFMUsername", value: username)
+    }
+
+    /// Retrieves the stored Last.fm username, if any.
+    func getLastFMUsername() -> String? {
+        self.get(key: "lastFMUsername")
+    }
+
+    /// Removes all Last.fm credentials from Keychain.
+    func removeLastFMCredentials() {
+        self.delete(key: "lastFMSessionKey")
+        self.delete(key: "lastFMUsername")
+    }
+
+    // MARK: - Private Helpers
+
+    private func save(key: String, value: String) throws {
+        guard let data = value.data(using: .utf8) else {
+            throw KeychainError.encodingFailed
+        }
+
+        let account = "\(self.servicePrefix).\(key)"
+
+        // Try to update existing item first
+        let updateQuery: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: account,
+            kSecAttrService as String: self.servicePrefix,
+        ]
+
+        let updateAttributes: [String: Any] = [
+            kSecValueData as String: data,
+            kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock,
+        ]
+
+        let updateStatus = SecItemUpdate(updateQuery as CFDictionary, updateAttributes as CFDictionary)
+
+        if updateStatus == errSecItemNotFound {
+            // Item doesn't exist, add it
+            var addQuery = updateQuery
+            addQuery[kSecValueData as String] = data
+            addQuery[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
+
+            let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
+            guard addStatus == errSecSuccess else {
+                throw KeychainError.saveFailed(status: addStatus)
+            }
+        } else if updateStatus != errSecSuccess {
+            throw KeychainError.saveFailed(status: updateStatus)
+        }
+    }
+
+    private func get(key: String) -> String? {
+        let account = "\(self.servicePrefix).\(key)"
+
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: account,
+            kSecAttrService as String: self.servicePrefix,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+
+        guard status == errSecSuccess,
+              let data = result as? Data,
+              let value = String(data: data, encoding: .utf8)
+        else {
+            return nil
+        }
+
+        return value
+    }
+
+    private func delete(key: String) {
+        let account = "\(self.servicePrefix).\(key)"
+
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: account,
+            kSecAttrService as String: self.servicePrefix,
+        ]
+
+        SecItemDelete(query as CFDictionary)
+    }
+}
+
+// MARK: - KeychainError
+
+/// Errors that can occur during Keychain operations.
+enum KeychainError: Error, LocalizedError {
+    case encodingFailed
+    case saveFailed(status: OSStatus)
+
+    var errorDescription: String? {
+        switch self {
+        case .encodingFailed:
+            "Failed to encode value for Keychain storage."
+        case let .saveFailed(status):
+            "Keychain save failed with status: \(status)"
+        }
+    }
+}