Add browser activity filter

WakaTime/Extensions/AXUIElementExtension.swift

@@ -74,7 +74,7 @@ extension AXUIElement {
         // swiftlint:enable force_cast
     }
 
-    func project(for app: MonitoredApp) -> String? {
+    func address(for app: MonitoredApp) -> String? {
         var address: String?
         switch app {
             case .brave:
@@ -98,12 +98,12 @@ extension AXUIElement {
                 address = addressField?.value
             default: return nil
         }
+        return address
+    }
 
-        if let address {
-            return extractProjectName(from: address)
-        }
-
-        return nil
+    func project(for app: MonitoredApp) -> String? {
+        guard let address = address(for: app) else { return nil }
+        return extractProjectName(from: address)
     }
 
     // swiftlint:disable cyclomatic_complexity

WakaTime/Extensions/NSRunningApplicationExtension.swift

@@ -43,6 +43,15 @@ enum MonitoredApp: String, CaseIterable {
         MonitoredApp.slack.rawValue,
     ]
 
+    static let browserAppIds = [
+        MonitoredApp.arcbrowser.rawValue,
+        MonitoredApp.brave.rawValue,
+        MonitoredApp.chrome.rawValue,
+        MonitoredApp.firefox.rawValue,
+        MonitoredApp.safari.rawValue,
+        MonitoredApp.safaripreview.rawValue,
+    ]
+
     // list apps which are enabled by default on first run
     static let defaultEnabledApps = [
         MonitoredApp.canva.rawValue,

WakaTime/Extensions/StringExtension.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+extension String {
+    func matchesRegex(_ pattern: String) -> Bool {
+        if let regex = try? NSRegularExpression(pattern: pattern) {
+            let range = NSRange(location: 0, length: self.utf16.count)
+            return regex.firstMatch(in: self, options: [], range: range) != nil
+        }
+        return false
+    }
+}

WakaTime/Helpers/FilterManager.swift

@@ -0,0 +1,46 @@
+import Cocoa
+
+class FilterManager {
+    static func filterBrowsedSites(app: NSRunningApplication, monitoredApp: MonitoredApp, activeWindow: AXUIElement) -> Bool {
+        guard MonitoringManager.isAppBrowser(app) else { return true }
+
+        if let address = activeWindow.address(for: monitoredApp) {
+            let patterns = Self.parseList(PropertiesManager.currentFilterList)
+            if patterns.isEmpty { return true }
+
+            // Create scheme-prefixed address versions to allow regular expressions
+            // that incorporate a scheme to match
+            let httpAddress = "http://" + address
+            let httpsAddress = "https://" + address
+
+            switch PropertiesManager.filterType {
+                case .denylist:
+                    for pattern in patterns {
+                        if httpAddress.matchesRegex(pattern) || httpsAddress.matchesRegex(pattern) {
+                            // Address matches a pattern on the denylist. Filter the site out.
+                            return false
+                        }
+                    }
+                case .allowlist:
+                    let addressMatchesAllowlist = patterns.contains { pattern in
+                        httpAddress.matchesRegex(pattern) || httpsAddress.matchesRegex(pattern)
+                    }
+                    // If none of the patterns on the allowlist match the given address, filter the site out
+                    if !addressMatchesAllowlist {
+                        return false
+                    }
+            }
+        }
+
+        // The given address passed all filters and will be included
+        return true
+    }
+
+    private static func parseList(_ listString: String) -> [String] {
+        Self.sanitizeList(listString.components(separatedBy: "\n"))
+    }
+
+    private static func sanitizeList(_ urls: [String]) -> [String] {
+        urls.map { $0.trimmingCharacters(in: CharacterSet.whitespaces) }
+    }
+}

WakaTime/Helpers/MonitoringManager.swift

@@ -51,6 +51,16 @@ class MonitoringManager {
         return bundleId == MonitoredApp.xcode.rawValue
     }
 
+    static func isAppBrowser(for bundleId: String) -> Bool {
+        MonitoredApp.browserAppIds.contains(bundleId)
+    }
+
+    static func isAppBrowser(_ app: NSRunningApplication) -> Bool {
+        guard let bundleId = app.bundleIdentifier else { return false }
+
+        return isAppBrowser(for: bundleId)
+    }
+
     static func heartbeatData(_ app: NSRunningApplication) -> HeartbeatData? {
         let pid = app.processIdentifier
 
@@ -60,6 +70,15 @@ class MonitoringManager {
             let title = activeWindow.title(for: monitoredApp)
         else { return nil }
 
+        // For browser apps, filter out deny/allowlisted sites and use the predefined project
+        // from the allowlist if applicable.
+        let included = FilterManager.filterBrowsedSites(
+            app: app,
+            monitoredApp: monitoredApp,
+            activeWindow: activeWindow
+        )
+        guard included else { return nil }
+
         let project = activeWindow.project(for: monitoredApp)
 
         switch monitoredApp {

WakaTime/Helpers/PropertiesManager.swift

@@ -1,11 +1,19 @@
 import Foundation
 
 class PropertiesManager {
+    enum FilterType: String {
+        case denylist
+        case allowlist
+    }
+
     enum Keys: String {
         case shouldLaunchOnLogin = "launch_on_login"
         case shouldLogToFile = "log_to_file"
         case shouldAutomaticallyDownloadUpdates = "should_automatically_download_updates"
         case hasLaunchedBefore = "has_launched_before"
+        case filterType = "filter_type"
+        case denylist = "denylist"
+        case allowlist = "allowlist"
     }
 
     static var shouldLaunchOnLogin: Bool {
@@ -71,4 +79,59 @@ class PropertiesManager {
             UserDefaults.standard.synchronize()
         }
     }
+
+    static var filterType: FilterType {
+        get {
+            guard let filterTypeString = UserDefaults.standard.string(forKey: Keys.filterType.rawValue) else {
+                return .allowlist
+            }
+
+            return FilterType(rawValue: filterTypeString) ?? .denylist
+        }
+        set {
+            UserDefaults.standard.set(newValue.rawValue, forKey: Keys.filterType.rawValue)
+            UserDefaults.standard.synchronize()
+        }
+    }
+
+    static var denylist: String {
+        get {
+            guard let denylist = UserDefaults.standard.string(forKey: Keys.denylist.rawValue) else {
+                return ""
+            }
+
+            return denylist
+        }
+        set {
+            UserDefaults.standard.set(newValue, forKey: Keys.denylist.rawValue)
+            UserDefaults.standard.synchronize()
+        }
+    }
+
+    static var allowlist: String {
+        get {
+            guard let allowlist = UserDefaults.standard.string(forKey: Keys.allowlist.rawValue) else {
+                return
+                    "https://github.com/\n" +
+                    "https://gitlab.com/\n" +
+                    "https://stackoverflow.com/\n" +
+                    "https://docs.python.org/\n" +
+                    "https://google.com/\n" +
+                    "https://npmjs.com"
+            }
+
+            return allowlist
+        }
+        set {
+            UserDefaults.standard.set(newValue, forKey: Keys.allowlist.rawValue)
+            UserDefaults.standard.synchronize()
+        }
+    }
+
+    static var currentFilterList: String {
+        switch Self.filterType {
+            case .denylist: return Self.denylist
+            case .allowlist: return Self.allowlist
+        }
+    }
 }