Respect domain exclusions across reads

ComputelessComputer · ComputelessComputer · commit 375bc281bd43 · 2026-04-09T01:28:29.000+09:00
Apply current domain exclusions when loading, searching, and preparing activity data, drop stale journals whose source events are no longer visible, and add regression coverage for historical loads and prepared activity refreshes.
diff --git a/Sources/OpenbirdApp/AppModel.swift b/Sources/OpenbirdApp/AppModel.swift
@@ -93,6 +93,7 @@ final class AppModel: ObservableObject {
     private let store: OpenbirdStore
     private let currentActivityContextService = CurrentActivityContextService()
     private let installedApplicationService = InstalledApplicationService()
+    private let exclusionEngine = ExclusionEngine()
     private let journalGenerator: JournalGenerator
     private let retrievalService: RetrievalService
     private let chatService: ChatService
@@ -446,6 +447,13 @@ final class AppModel: ObservableObject {
         }
     }
 
+    nonisolated static func journalMatchesVisibleEvents(
+        _ journal: DailyJournal,
+        visibleEventIDs: Set<String>
+    ) -> Bool {
+        Set(journal.sections.flatMap(\.sourceEventIDs)).isSubset(of: visibleEventIDs)
+    }
+
     nonisolated static func updateStatusText(
         appVersionAvailable: Bool,
         isInstallingUpdate: Bool,
@@ -543,15 +551,18 @@ final class AppModel: ObservableObject {
                 title: "Reading captured activity",
                 detail: "Querying the local timeline database for raw events recorded on the selected day."
             )
-            let loadedRawEvents = try await store.loadActivityEvents(in: dayRange, includeExcluded: true)
+            let loadedRawEvents = try await store.loadActivityEvents(in: dayRange)
             await store.prepareActivityEventsInBackground(for: requestedDay)
             dayLoadStatus = Self.makeDayLoadStatus(
                 step: 3,
                 totalSteps: 5,
                 title: "Loading saved summary",
                 detail: "Checking whether Openbird already has a journal summary cached for this day."
             )
-            let loadedJournal = try await store.loadJournal(for: day)
+            let visibleEventIDs = Set(loadedRawEvents.map(\.id))
+            let loadedJournal = try await store.loadJournal(for: day).flatMap { journal in
+                Self.journalMatchesVisibleEvents(journal, visibleEventIDs: visibleEventIDs) ? journal : nil
+            }
             let totalDayLoadSteps = 5
 
             dayLoadStatus = Self.makeDayLoadStatus(
@@ -1141,7 +1152,7 @@ final class AppModel: ObservableObject {
 
     private func excludableDomainAction(for context: CurrentActivityContext?) -> StatusMenuExclusionState.Action? {
         guard let domain = context?.domain,
-              hasExclusion(kind: .domain, pattern: domain) == false
+              hasDomainExclusion(matching: domain) == false
         else {
             return nil
         }
@@ -1154,10 +1165,18 @@ final class AppModel: ObservableObject {
 
     private func hasExclusion(kind: ExclusionKind, pattern: String) -> Bool {
         exclusions.contains {
-            $0.kind == kind && $0.pattern.caseInsensitiveCompare(pattern) == .orderedSame
+            $0.isEnabled && $0.kind == kind && $0.pattern.caseInsensitiveCompare(pattern) == .orderedSame
         }
     }
 
+    private func hasDomainExclusion(matching domain: String) -> Bool {
+        exclusionEngine.isExcluded(
+            bundleID: "",
+            url: "https://\(domain)",
+            rules: exclusions.filter { $0.kind == .domain && $0.isEnabled }
+        )
+    }
+
     private func loadCurrentSettings() async throws -> AppSettings {
         var settings = try await store.loadSettings()
         if settings.normalizeCapturePause(sessionID: collectorOwnerID) {
@@ -1411,8 +1430,11 @@ final class AppModel: ObservableObject {
         lastAutomaticSelectedDayRefreshAt = now
 
         do {
-            let loadedRawEvents = try await store.loadActivityEvents(in: dayRange, includeExcluded: true)
-            let loadedJournal = try await store.loadJournal(for: requestedDayString)
+            let loadedRawEvents = try await store.loadActivityEvents(in: dayRange)
+            let visibleEventIDs = Set(loadedRawEvents.map(\.id))
+            let loadedJournal = try await store.loadJournal(for: requestedDayString).flatMap { journal in
+                Self.journalMatchesVisibleEvents(journal, visibleEventIDs: visibleEventIDs) ? journal : nil
+            }
 
             guard OpenbirdDateFormatting.dayString(for: selectedDay) == requestedDayString else {
                 return
diff --git a/Sources/OpenbirdKit/Storage/OpenbirdStore.swift b/Sources/OpenbirdKit/Storage/OpenbirdStore.swift
@@ -2,6 +2,7 @@ import Foundation
 
 public actor OpenbirdStore {
     private let database: SQLiteDatabase
+    private let exclusionEngine = ExclusionEngine()
     private var pendingPreparedActivityDays: Set<String> = []
     private var dirtyPreparedActivityDays: Set<String> = []
     private var preparedActivityRefreshTask: Task<Void, Never>?
@@ -44,10 +45,12 @@ public actor OpenbirdStore {
 
     public func saveExclusion(_ exclusion: ExclusionRule) throws {
         try database.saveExclusion(exclusion)
+        try invalidatePreparedActivityCacheForExclusionChange()
     }
 
     public func deleteExclusion(id: String) throws {
         try database.deleteExclusion(id: id)
+        try invalidatePreparedActivityCacheForExclusionChange()
     }
 
     public func saveActivityEvent(_ event: ActivityEvent) throws {
@@ -56,7 +59,12 @@ public actor OpenbirdStore {
     }
 
     public func loadActivityEvents(in range: ClosedRange<Date>, includeExcluded: Bool = false) throws -> [ActivityEvent] {
-        try database.loadActivityEvents(in: range, includeExcluded: includeExcluded)
+        let events = try database.loadActivityEvents(in: range, includeExcluded: includeExcluded)
+        guard includeExcluded == false else {
+            return events
+        }
+
+        return try filterCurrentExclusions(from: events)
     }
 
     public func searchActivityEvents(
@@ -65,7 +73,8 @@ public actor OpenbirdStore {
         appFilters: [String] = [],
         topK: Int = 8
     ) throws -> [ActivityEvent] {
-        try database.searchActivityEvents(query: query, in: range, appFilters: appFilters, topK: topK)
+        let events = try database.searchActivityEvents(query: query, in: range, appFilters: appFilters, topK: topK)
+        return try filterCurrentExclusions(from: events)
     }
 
     public func loadJournal(for day: String) throws -> DailyJournal? {
@@ -118,7 +127,7 @@ public actor OpenbirdStore {
         let day = OpenbirdDateFormatting.dayString(for: date)
         if dirtyPreparedActivityDays.contains(day) == false,
            let cached = try database.loadPreparedActivityEvents(for: day) {
-            return cached
+            return try filterCurrentExclusions(from: cached)
         }
 
         return try await rebuildPreparedActivityEvents(for: day, date: date)
@@ -133,10 +142,7 @@ public actor OpenbirdStore {
     }
 
     private func rebuildPreparedActivityEvents(for day: String, date: Date) async throws -> [GroupedActivityEvent] {
-        let rawEvents = try database.loadActivityEvents(
-            in: Calendar.autoupdatingCurrent.dayRange(for: date),
-            includeExcluded: true
-        )
+        let rawEvents = try loadActivityEvents(in: Calendar.autoupdatingCurrent.dayRange(for: date))
         let groupedEvents = await Task.detached(priority: .utility) {
             ActivityEvidencePreprocessor.groupedMeaningfulEvents(from: rawEvents)
         }.value
@@ -145,6 +151,48 @@ public actor OpenbirdStore {
         return groupedEvents
     }
 
+    private func filterCurrentExclusions(from events: [ActivityEvent]) throws -> [ActivityEvent] {
+        let exclusions = try activeExclusions()
+        guard exclusions.isEmpty == false else {
+            return events
+        }
+
+        return events.filter { event in
+            event.isExcluded == false &&
+            exclusionEngine.isExcluded(
+                bundleID: event.bundleId,
+                url: event.url,
+                rules: exclusions
+            ) == false
+        }
+    }
+
+    private func filterCurrentExclusions(from events: [GroupedActivityEvent]) throws -> [GroupedActivityEvent] {
+        let exclusions = try activeExclusions()
+        guard exclusions.isEmpty == false else {
+            return events.filter { $0.isExcluded == false }
+        }
+
+        return events.filter { event in
+            event.isExcluded == false &&
+            exclusionEngine.isExcluded(
+                bundleID: event.bundleId,
+                url: event.url,
+                rules: exclusions
+            ) == false
+        }
+    }
+
+    private func activeExclusions() throws -> [ExclusionRule] {
+        try database.loadExclusions().filter(\.isEnabled)
+    }
+
+    private func invalidatePreparedActivityCacheForExclusionChange() throws {
+        try database.deleteAllPreparedActivityEvents()
+        pendingPreparedActivityDays.removeAll()
+        dirtyPreparedActivityDays.removeAll()
+    }
+
     private func invalidatePreparedActivityDays<S: Sequence>(for days: S) where S.Element == String {
         let normalizedDays = Set(days).filter { $0.isEmpty == false }
         guard normalizedDays.isEmpty == false else {
diff --git a/Tests/OpenbirdKitTests/OpenbirdStoreTests.swift b/Tests/OpenbirdKitTests/OpenbirdStoreTests.swift
@@ -68,6 +68,78 @@ struct OpenbirdStoreTests {
         #expect(results.first?.appName == "VS Code")
     }
 
+    @Test func loadActivityEventsRespectsCurrentDomainExclusions() async throws {
+        let databaseURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("sqlite")
+        let store = try OpenbirdStore(databaseURL: databaseURL)
+        let now = Date()
+
+        try await store.saveActivityEvent(
+            ActivityEvent(
+                id: "public-event",
+                startedAt: now.addingTimeInterval(-300),
+                endedAt: now.addingTimeInterval(-240),
+                bundleId: "com.apple.Safari",
+                appName: "Safari",
+                windowTitle: "Public",
+                url: "https://openbird.app",
+                visibleText: "Reviewed the homepage",
+                source: "accessibility",
+                contentHash: "public-event",
+                isExcluded: false
+            )
+        )
+        try await store.saveActivityEvent(
+            ActivityEvent(
+                id: "private-event",
+                startedAt: now.addingTimeInterval(-180),
+                endedAt: now.addingTimeInterval(-120),
+                bundleId: "com.apple.Safari",
+                appName: "Safari",
+                windowTitle: "Private",
+                url: "https://mail.google.com",
+                visibleText: "Read private mail",
+                source: "accessibility",
+                contentHash: "private-event",
+                isExcluded: false
+            )
+        )
+        try await store.saveExclusion(ExclusionRule(kind: .domain, pattern: "google.com"))
+
+        let events = try await store.loadActivityEvents(in: Calendar.current.dayRange(for: now))
+
+        #expect(events.map(\.id) == ["public-event"])
+    }
+
+    @Test func searchActivityEventsRespectsCurrentDomainExclusions() async throws {
+        let databaseURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("sqlite")
+        let store = try OpenbirdStore(databaseURL: databaseURL)
+        let now = Date()
+
+        try await store.saveActivityEvent(
+            ActivityEvent(
+                startedAt: now.addingTimeInterval(-180),
+                endedAt: now,
+                bundleId: "com.apple.Safari",
+                appName: "Safari",
+                windowTitle: "Inbox",
+                url: "https://mail.google.com",
+                visibleText: "Reviewed a private launch plan",
+                source: "accessibility",
+                contentHash: "private-search",
+                isExcluded: false
+            )
+        )
+        try await store.saveExclusion(ExclusionRule(kind: .domain, pattern: "google.com"))
+
+        let results = try await store.searchActivityEvents(
+            query: "launch plan",
+            in: Calendar.current.dayRange(for: now),
+            topK: 5
+        )
+
+        #expect(results.isEmpty)
+    }
+
     @Test func mergesOverlappingEventsWithSameContentHash() async throws {
         let databaseURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("sqlite")
         let store = try OpenbirdStore(databaseURL: databaseURL)
@@ -391,6 +463,51 @@ struct OpenbirdStoreTests {
         #expect(refreshed.first?.sourceEventCount == 2)
     }
 
+    @Test func preparedActivityEventsRefreshWhenDomainExclusionChanges() async throws {
+        let databaseURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("sqlite")
+        let store = try OpenbirdStore(databaseURL: databaseURL)
+        let start = Date(timeIntervalSince1970: 1_720_000_000)
+
+        try await store.saveActivityEvent(
+            ActivityEvent(
+                id: "allowed-group",
+                startedAt: start,
+                endedAt: start.addingTimeInterval(30),
+                bundleId: "com.apple.Safari",
+                appName: "Safari",
+                windowTitle: "Openbird",
+                url: "https://openbird.app",
+                visibleText: "Reviewed the Openbird homepage",
+                source: "accessibility",
+                contentHash: "allowed-group",
+                isExcluded: false
+            )
+        )
+        try await store.saveActivityEvent(
+            ActivityEvent(
+                id: "excluded-group",
+                startedAt: start.addingTimeInterval(600),
+                endedAt: start.addingTimeInterval(630),
+                bundleId: "com.apple.Safari",
+                appName: "Safari",
+                windowTitle: "Mail",
+                url: "https://mail.google.com",
+                visibleText: "Reviewed private mail",
+                source: "accessibility",
+                contentHash: "excluded-group",
+                isExcluded: false
+            )
+        )
+
+        let initial = try await store.preparedActivityEvents(for: start)
+        #expect(initial.map(\.id) == ["allowed-group", "excluded-group"])
+
+        try await store.saveExclusion(ExclusionRule(kind: .domain, pattern: "google.com"))
+
+        let refreshed = try await store.preparedActivityEvents(for: start)
+        #expect(refreshed.map(\.id) == ["allowed-group"])
+    }
+
     @Test func backgroundPrepareKeepsFreshPreparedActivityCache() async throws {
         let databaseURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("sqlite")
         let store = try OpenbirdStore(databaseURL: databaseURL)
