fix: bound sidebar snapshots and remove blocking discovery

.github/workflows/ci-macos.yml

@@ -2779,6 +2779,7 @@ jobs:
             CmuxNotifications
             CmuxSettings
             CmuxSettingsUI
+            CmuxSidebarGit
             CmuxSurfaceCatalogModel
             CmuxSudoBroker
             CmuxSudoBrokerUI

Packages/macOS/CmuxBrowser/Sources/CmuxBrowser/Import/Detection/BrowserInstalledBrowserDetectionService.swift

@@ -0,0 +1,40 @@
+internal import Dispatch
+
+/// Coalesces browser discovery and isolates synchronous system and profile reads.
+public actor BrowserInstalledBrowserDetectionService {
+    private let scan: @Sendable () -> [InstalledBrowserCandidate]
+    // Foundation/Launch Services discovery has no asynchronous API. This serial
+    // I/O lane prevents a blocked scan from occupying the UI or cooperative pool.
+    private let queue = DispatchQueue(label: "com.cmux.browser-discovery", qos: .utility)
+    private var inFlight: Task<[InstalledBrowserCandidate], Never>?
+
+    /// Creates a discovery owner.
+    ///
+    /// - Parameter scan: Synchronous discovery performed on the I/O lane. Tests
+    ///   provide a fixture-backed scanner; the default scans the current Mac.
+    public init(scan: @escaping @Sendable () -> [InstalledBrowserCandidate] = {
+        BrowserInstalledBrowserDetector().detectInstalledBrowsers()
+    }) {
+        self.scan = scan
+    }
+
+    /// Returns a fresh discovery snapshot, sharing any scan already in progress.
+    ///
+    /// Cancellation does not interrupt an in-progress Foundation call. The one
+    /// scan remains owned until it completes; callers discard canceled results.
+    /// - Returns: Ranked installed browsers and their importable profiles.
+    public func detectInstalledBrowsers() async -> [InstalledBrowserCandidate] {
+        if let inFlight { return await inFlight.value }
+        let scan = scan
+        let queue = queue
+        let task = Task {
+            await withCheckedContinuation { continuation in
+                queue.async { continuation.resume(returning: scan()) }
+            }
+        }
+        inFlight = task
+        let result = await task.value
+        inFlight = nil
+        return result
+    }
+}

Packages/macOS/CmuxBrowser/Sources/CmuxBrowser/Import/Values/BrowserImportDestinationResolver.swift

@@ -0,0 +1,63 @@
+public import Foundation
+
+/// Resolves browser-import destination selectors without touching app storage.
+public struct BrowserImportDestinationResolver: Sendable {
+    /// The result of resolving a destination selector.
+    public enum Resolution: Equatable, Sendable {
+        /// No destination selector was supplied.
+        case none
+        /// An existing profile was selected by its stable identifier.
+        case matched(UUID)
+        /// More than one profile matched the display name or slug.
+        case ambiguous([BrowserProfileDefinition])
+        /// No profile matched and creation was not requested.
+        case notFound(String)
+        /// The UUID-only selector was malformed or unknown.
+        case invalidIdentifier(String)
+        /// The caller requested creation after no existing profile matched.
+        case create(String)
+    }
+
+    /// Creates a stateless destination resolver.
+    public init() {}
+
+    /// Resolves an optional UUID or name/slug selector against profiles.
+    ///
+    /// - Parameters:
+    ///   - rawSelector: A display name or slug, when supplied.
+    ///   - rawIdentifier: The UUID-only selector, when supplied.
+    ///   - createIfMissing: Whether a missing name may create a profile.
+    ///   - profiles: The current profile definitions.
+    /// - Returns: A deterministic resolution result; no app state is mutated.
+    public func resolve(
+        rawSelector: String?,
+        rawIdentifier: String?,
+        createIfMissing: Bool,
+        profiles: [BrowserProfileDefinition]
+    ) -> Resolution {
+        let identifier = rawIdentifier?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let identifier, !identifier.isEmpty {
+            guard let id = UUID(uuidString: identifier),
+                  profiles.contains(where: { $0.id == id }) else {
+                return .invalidIdentifier(identifier)
+            }
+            return .matched(id)
+        }
+
+        guard let rawSelector else { return .none }
+        let selector = rawSelector.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !selector.isEmpty else { return .notFound(selector) }
+        if let id = UUID(uuidString: selector) {
+            return profiles.contains(where: { $0.id == id })
+                ? .matched(id)
+                : .invalidIdentifier(selector)
+        }
+        let matches = profiles.filter {
+            $0.displayName.localizedCaseInsensitiveCompare(selector) == .orderedSame
+                || $0.slug.localizedCaseInsensitiveCompare(selector) == .orderedSame
+        }
+        if matches.count == 1 { return .matched(matches[0].id) }
+        if matches.count > 1 { return .ambiguous(matches) }
+        return createIfMissing ? .create(selector) : .notFound(selector)
+    }
+}

Packages/macOS/CmuxBrowser/Tests/CmuxBrowserTests/Import/BrowserImportDestinationResolverTests.swift

@@ -0,0 +1,37 @@
+import Foundation
+import Testing
+@testable import CmuxBrowser
+
+@Suite("Browser import destination resolver")
+struct BrowserImportDestinationResolverTests {
+    @Test func UUIDSelectionWinsAndAmbiguousNamesFailClosed() throws {
+        let profiles = [
+            BrowserProfileDefinition(id: UUID(), displayName: "Shared", createdAt: .distantPast, isBuiltInDefault: false),
+            BrowserProfileDefinition(id: UUID(), displayName: "shared", createdAt: .distantPast, isBuiltInDefault: false),
+        ]
+        let resolver = BrowserImportDestinationResolver()
+        #expect(resolver.resolve(rawSelector: "SHARED", rawIdentifier: nil, createIfMissing: false, profiles: profiles) == .ambiguous(profiles))
+        #expect(resolver.resolve(rawSelector: "Shared", rawIdentifier: profiles[0].id.uuidString, createIfMissing: false, profiles: profiles) == .matched(profiles[0].id))
+        #expect(resolver.resolve(rawSelector: "new", rawIdentifier: nil, createIfMissing: true, profiles: profiles) == .create("new"))
+    }
+
+    @Test func blankIdentifierFallsBackToNameSelector() {
+        let profile = BrowserProfileDefinition(
+            id: UUID(), displayName: "Work", createdAt: .distantPast, isBuiltInDefault: false
+        )
+        let resolver = BrowserImportDestinationResolver()
+
+        #expect(resolver.resolve(
+            rawSelector: "work",
+            rawIdentifier: "  ",
+            createIfMissing: false,
+            profiles: [profile]
+        ) == .matched(profile.id))
+        #expect(resolver.resolve(
+            rawSelector: nil,
+            rawIdentifier: "\t",
+            createIfMissing: false,
+            profiles: [profile]
+        ) == .none)
+    }
+}

Packages/macOS/CmuxBrowser/Tests/CmuxBrowserTests/Import/BrowserInstalledBrowserDetectorAsyncTests.swift

@@ -0,0 +1,61 @@
+import Darwin
+import Dispatch
+import Foundation
+import Testing
+@testable import CmuxBrowser
+
+@Suite("Browser discovery executor")
+struct BrowserInstalledBrowserDetectorAsyncTests {
+    @MainActor
+    @Test("real profile discovery leaves the UI actor and preserves injected paths")
+    func offMainDetectionPreservesResults() async throws {
+        let home = FileManager.default.temporaryDirectory
+            .appendingPathComponent("cmux-browser-import-async-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+        let profile = home.appendingPathComponent(
+            "Library/Application Support/Google/Chrome/Default", isDirectory: true
+        )
+        try FileManager.default.createDirectory(at: profile, withIntermediateDirectories: true)
+        let marker = Data(UUID().uuidString.utf8)
+        try marker.write(to: profile.appendingPathComponent("History"))
+
+        let service = BrowserInstalledBrowserDetectionService {
+            #expect(pthread_main_np() == 0)
+            return BrowserInstalledBrowserDetector(
+                homeDirectoryURL: home,
+                bundleLookup: { _ in
+                    #expect(pthread_main_np() == 0)
+                    return nil
+                },
+                applicationSearchDirectories: []
+            ).detectInstalledBrowsers()
+        }
+        let candidates = await service.detectInstalledBrowsers()
+        let chrome = try #require(candidates.first { $0.id == "google-chrome" })
+        let foundProfile = try #require(chrome.profiles.first)
+        #expect(chrome.homeDirectoryURL == home)
+        #expect(foundProfile.rootURL.lastPathComponent == "Default")
+        #expect(try Data(contentsOf: foundProfile.rootURL.appendingPathComponent("History")) == marker)
+    }
+
+    @MainActor
+    @Test("a blocked system scan leaves the main actor runnable")
+    func slowScanDoesNotBlockMainActor() async {
+        let (started, continuation) = AsyncStream<Void>.makeStream()
+        // This semaphore deliberately simulates a blocking system call on the
+        // I/O lane. It is never waited on by the test's main actor.
+        let release = DispatchSemaphore(value: 0)
+        defer { release.signal(); continuation.finish() }
+        let service = BrowserInstalledBrowserDetectionService {
+            continuation.yield(())
+            release.wait()
+            return []
+        }
+        let discovery = Task { await service.detectInstalledBrowsers() }
+        var iterator = started.makeAsyncIterator()
+        _ = await iterator.next()
+        #expect(pthread_main_np() != 0)
+        release.signal()
+        #expect(await discovery.value.isEmpty)
+    }
+}

Packages/macOS/CmuxFoundation/Sources/CmuxFoundation/FileWatch/FileSystemEventReceiver.swift

@@ -0,0 +1,28 @@
+import CoreServices
+import Foundation
+
+/// Immutable callback context retained by FSEvents until queued teardown completes.
+final class FileSystemEventReceiver: Sendable {
+    let onEvent: @Sendable (FileSystemEventBatch) -> Void
+
+    init(onEvent: @escaping @Sendable (FileSystemEventBatch) -> Void) {
+        self.onEvent = onEvent
+    }
+
+    func makeContext() -> FSEventStreamContext {
+        FSEventStreamContext(
+            version: 0,
+            info: Unmanaged.passUnretained(self).toOpaque(),
+            retain: { pointer in
+                guard let pointer else { return nil }
+                _ = Unmanaged<FileSystemEventReceiver>.fromOpaque(pointer).retain()
+                return pointer
+            },
+            release: { pointer in
+                guard let pointer else { return }
+                Unmanaged<FileSystemEventReceiver>.fromOpaque(pointer).release()
+            },
+            copyDescription: nil
+        )
+    }
+}