Add focus and Recently Closed history

.github/workflows/ci.yml

@@ -156,7 +156,7 @@ jobs:
 
   tests:
     runs-on: warp-macos-15-arm64-6x
-    timeout-minutes: 45
+    timeout-minutes: 75
     env:
       CMUX_SKIP_ZIG_BUILD: "1"
       # XCTest app-host crashes can leave xcodebuild waiting in Swift's crash

Sources/AppDelegate+ClosedItemHistory.swift

@@ -0,0 +1,171 @@
+import AppKit
+
+extension AppDelegate {
+    func clearRecentlyClosedHistory(preferredTabManager: TabManager? = nil) {
+        ClosedItemHistoryStore.shared.removeAll()
+
+        var clearedManagers: Set<ObjectIdentifier> = []
+        func clear(_ manager: TabManager?) {
+            guard let manager else { return }
+            guard clearedManagers.insert(ObjectIdentifier(manager)).inserted else { return }
+            manager.clearRecentlyClosedBrowserPanelHistory()
+        }
+
+        clear(preferredTabManager)
+        clear(tabManager)
+        for context in mainWindowContexts.values {
+            clear(context.tabManager)
+        }
+        for route in recoverableMainWindowRoutes() {
+            clear(route.tabManager)
+        }
+    }
+
+    @discardableResult
+    func reopenMostRecentlyClosedItem(
+        preferredTabManager: TabManager? = nil,
+        shouldActivate: Bool = true
+    ) -> Bool {
+        var failedStoreRecordIds: Set<UUID> = []
+        let restoreStoreItem: (Date?) -> Bool = { cutoff in
+            ClosedItemHistoryStore.shared.restoreFirstRestorable(
+                newerThan: cutoff,
+                excluding: failedStoreRecordIds,
+                onFailure: { failedStoreRecordIds.insert($0) },
+                using: { entry in
+                    self.restoreClosedItem(
+                        entry,
+                        preferredTabManager: preferredTabManager,
+                        shouldActivate: shouldActivate
+                    )
+                }
+            )
+        }
+
+        for manager in recentlyClosedLegacyBrowserManagers(preferredTabManager: preferredTabManager) {
+            guard let closedAt = manager.mostRecentLegacyClosedBrowserPanelClosedAt() else {
+                continue
+            }
+            if restoreStoreItem(closedAt) {
+                return true
+            }
+            if manager.reopenMostRecentlyClosedBrowserPanelFromLegacyStack() {
+                return true
+            }
+        }
+
+        return restoreStoreItem(nil)
+    }
+
+    private func recentlyClosedLegacyBrowserManagers(preferredTabManager: TabManager?) -> [TabManager] {
+        var managers: [TabManager] = []
+        var seen: Set<ObjectIdentifier> = []
+
+        func append(_ manager: TabManager?) {
+            guard let manager else { return }
+            guard manager.mostRecentLegacyClosedBrowserPanelClosedAt() != nil else { return }
+            guard seen.insert(ObjectIdentifier(manager)).inserted else { return }
+            managers.append(manager)
+        }
+
+        append(preferredTabManager)
+        append(tabManager)
+        for context in mainWindowContexts.values {
+            append(context.tabManager)
+        }
+        for route in recoverableMainWindowRoutes() {
+            append(route.tabManager)
+        }
+
+        return managers.sorted { lhs, rhs in
+            let lhsDate = lhs.mostRecentLegacyClosedBrowserPanelClosedAt() ?? .distantPast
+            let rhsDate = rhs.mostRecentLegacyClosedBrowserPanelClosedAt() ?? .distantPast
+            return lhsDate > rhsDate
+        }
+    }
+
+    @discardableResult
+    private func restoreClosedItem(
+        _ entry: ClosedItemHistoryEntry,
+        preferredTabManager: TabManager? = nil,
+        shouldActivate: Bool
+    ) -> Bool {
+        switch entry {
+        case .panel(let panelEntry):
+            let manager =
+                tabManagerFor(tabId: panelEntry.workspaceId)
+                ?? preferredTabManager
+                ?? tabManager
+            guard let manager, manager.restoreClosedPanel(panelEntry) else {
+                return false
+            }
+            activateMainWindowIfNeeded(for: manager, shouldActivate: shouldActivate)
+            return true
+        case .workspace(let workspaceEntry):
+            let manager =
+                workspaceEntry.windowId.flatMap { tabManagerFor(windowId: $0) }
+                ?? preferredTabManager
+                ?? tabManager
+            guard let manager, manager.restoreClosedWorkspace(workspaceEntry) else {
+                return false
+            }
+            activateMainWindowIfNeeded(for: manager, shouldActivate: shouldActivate)
+            return true
+        case .window(let windowEntry):
+            var restoredPanelIdsByWorkspaceIndex: [[UUID: UUID]] = []
+            var restoredTabManager: TabManager?
+            let windowId = createMainWindow(
+                sessionWindowSnapshot: windowEntry.snapshot,
+                shouldActivate: shouldActivate,
+                closedWindowHistoryWorkspaceIds: windowEntry.workspaceIds,
+                restoredSessionSnapshotHandler: { panelIdsByWorkspaceIndex, tabManager in
+                    restoredPanelIdsByWorkspaceIndex = panelIdsByWorkspaceIndex
+                    restoredTabManager = tabManager
+                }
+            )
+            let hasLivePanels = restoredTabManager?.tabs.contains { !$0.panels.isEmpty } == true
+            guard ClosedWindowRestoreValidation.hasUsableRestoredContent(
+                snapshot: windowEntry.snapshot,
+                restoredPanelIdsByWorkspaceIndex: restoredPanelIdsByWorkspaceIndex,
+                hasLivePanels: hasLivePanels
+            ) else {
+                discardMainWindowWithoutClosedHistory(windowId: windowId)
+                return false
+            }
+            if let oldWindowId = windowEntry.windowId {
+                ClosedItemHistoryStore.shared.remapWorkspaceWindowIds(from: oldWindowId, to: windowId)
+            }
+            return true
+        }
+    }
+
+    @discardableResult
+    func reopenClosedHistoryItem(
+        id: UUID,
+        preferredTabManager: TabManager? = nil,
+        shouldActivate: Bool = true
+    ) -> Bool {
+        guard let removed = ClosedItemHistoryStore.shared.removeRecord(id: id) else {
+            return false
+        }
+
+        if restoreClosedItem(
+            removed.record.entry,
+            preferredTabManager: preferredTabManager,
+            shouldActivate: shouldActivate
+        ) {
+            return true
+        }
+
+        ClosedItemHistoryStore.shared.insert(removed.record, at: removed.index)
+        return false
+    }
+
+    private func activateMainWindowIfNeeded(for manager: TabManager, shouldActivate: Bool) {
+        guard shouldActivate,
+              let windowId = windowId(for: manager) else {
+            return
+        }
+        _ = focusMainWindow(windowId: windowId)
+    }
+}

Sources/AppDelegate+FocusHistoryContextMenu.swift

@@ -0,0 +1,139 @@
+import AppKit
+
+private let focusHistoryContextMenuPreviewLimit = 12
+
+private final class FocusHistoryContextMenuItemBox: NSObject {
+    weak var tabManager: TabManager?
+    let item: FocusHistoryMenuItem
+
+    init(tabManager: TabManager, item: FocusHistoryMenuItem) {
+        self.tabManager = tabManager
+        self.item = item
+    }
+}
+
+private final class FocusHistoryShowFullContextMenuBox: NSObject {
+    weak var tabManager: TabManager?
+    weak var anchorView: NSView?
+    let direction: FocusHistoryMenuDirection
+
+    init(tabManager: TabManager, anchorView: NSView, direction: FocusHistoryMenuDirection) {
+        self.tabManager = tabManager
+        self.anchorView = anchorView
+        self.direction = direction
+    }
+}
+
+extension AppDelegate {
+    @discardableResult
+    func showFocusHistoryContextMenu(
+        anchorView: NSView,
+        event: NSEvent,
+        direction: FocusHistoryMenuDirection,
+        showFullHistory: Bool = false,
+        debugSource: String = "titlebar.focusHistory.contextMenu"
+    ) -> Bool {
+        let context = contextForMainWindow(anchorView.window)
+            ?? mainWindowContext(forShortcutEvent: event, debugSource: debugSource)
+        guard let context else { return false }
+
+        let menu = makeFocusHistoryContextMenu(
+            tabManager: context.tabManager,
+            anchorView: anchorView,
+            direction: direction,
+            showFullHistory: showFullHistory
+        )
+        guard menu.items.contains(where: { !$0.isSeparatorItem }) else { return false }
+
+        NSMenu.popUpContextMenu(menu, with: event, for: anchorView)
+        return true
+    }
+
+    private func makeFocusHistoryContextMenu(
+        tabManager: TabManager,
+        anchorView: NSView,
+        direction: FocusHistoryMenuDirection,
+        showFullHistory: Bool
+    ) -> NSMenu {
+        let snapshot = tabManager.focusHistoryMenuSnapshot(
+            direction: direction,
+            maxItemCount: showFullHistory ? nil : focusHistoryContextMenuPreviewLimit
+        )
+        let menu = NSMenu(title: String(localized: "menu.history.focusHistory", defaultValue: "Focus History"))
+
+        if snapshot.items.isEmpty {
+            let item = NSMenuItem(
+                title: String(localized: "menu.history.noFocusHistory", defaultValue: "No Focus History"),
+                action: nil,
+                keyEquivalent: ""
+            )
+            item.isEnabled = false
+            menu.addItem(item)
+            return menu
+        }
+
+        for itemSnapshot in snapshot.items {
+            let item = NSMenuItem(
+                title: focusHistoryContextMenuTitle(for: itemSnapshot),
+                action: #selector(performFocusHistoryContextMenuItem(_:)),
+                keyEquivalent: ""
+            )
+            item.target = self
+            item.representedObject = FocusHistoryContextMenuItemBox(tabManager: tabManager, item: itemSnapshot)
+            item.isEnabled = itemSnapshot.isNavigable
+            menu.addItem(item)
+        }
+
+        if snapshot.isLimited {
+            menu.addItem(.separator())
+            let item = NSMenuItem(
+                title: String(localized: "menu.history.showFullFocusHistory", defaultValue: "Show Full History"),
+                action: #selector(showFullFocusHistoryContextMenu(_:)),
+                keyEquivalent: ""
+            )
+            item.target = self
+            item.representedObject = FocusHistoryShowFullContextMenuBox(
+                tabManager: tabManager,
+                anchorView: anchorView,
+                direction: direction
+            )
+            menu.addItem(item)
+        }
+
+        return menu
+    }
+
+    private func focusHistoryContextMenuTitle(for item: FocusHistoryMenuItem) -> String {
+        FocusHistoryMenuFormatter.title(for: item)
+    }
+
+    @objc private func performFocusHistoryContextMenuItem(_ sender: NSMenuItem) {
+        guard let box = sender.representedObject as? FocusHistoryContextMenuItemBox,
+              let tabManager = box.tabManager,
+              tabManager.navigateToFocusHistoryMenuItem(box.item) else {
+            NSSound.beep()
+            return
+        }
+    }
+
+    @objc private func showFullFocusHistoryContextMenu(_ sender: NSMenuItem) {
+        guard let box = sender.representedObject as? FocusHistoryShowFullContextMenuBox,
+              let tabManager = box.tabManager,
+              let anchorView = box.anchorView else {
+            NSSound.beep()
+            return
+        }
+
+        let menu = makeFocusHistoryContextMenu(
+            tabManager: tabManager,
+            anchorView: anchorView,
+            direction: box.direction,
+            showFullHistory: true
+        )
+        guard menu.items.contains(where: { !$0.isSeparatorItem }) else {
+            NSSound.beep()
+            return
+        }
+        menu.popUp(positioning: nil, at: NSPoint(x: 0, y: anchorView.bounds.height), in: anchorView)
+    }
+}

Sources/AppDelegate+HistoryPane.swift

@@ -0,0 +1,23 @@
+import AppKit
+
+extension AppDelegate {
+    @discardableResult
+    func openHistoryPane(
+        preferredTabManager: TabManager? = nil,
+        preferredWindow: NSWindow? = nil
+    ) -> Bool {
+        let manager = preferredTabManager
+            ?? activeTabManagerForCommands(preferredWindow: preferredWindow ?? NSApp.keyWindow ?? NSApp.mainWindow)
+        guard let workspace = manager?.selectedWorkspace,
+              let paneId = workspace.bonsplitController.focusedPaneId ?? workspace.bonsplitController.allPaneIds.first else {
+            return false
+        }
+
+        workspace.clearSplitZoom()
+        return workspace.openOrFocusRightSidebarToolSurface(
+            inPane: paneId,
+            mode: .history,
+            focus: true
+        ) != nil
+    }
+}