wehub-resource-sync
465 lines
19 KiB
Swift
465 lines
19 KiB
Swift
import AppKit
|
|
import Foundation
|
|
|
|
struct StatusItemVisibilitySnapshot: Equatable {
|
|
let isVisible: Bool
|
|
let hasButton: Bool
|
|
let hasWindow: Bool
|
|
let hasScreen: Bool
|
|
let isOnCurrentScreen: Bool
|
|
let buttonWidth: CGFloat
|
|
|
|
init(
|
|
isVisible: Bool,
|
|
hasButton: Bool,
|
|
hasWindow: Bool,
|
|
hasScreen: Bool,
|
|
isOnCurrentScreen: Bool = true,
|
|
buttonWidth: CGFloat)
|
|
{
|
|
self.isVisible = isVisible
|
|
self.hasButton = hasButton
|
|
self.hasWindow = hasWindow
|
|
self.hasScreen = hasScreen
|
|
self.isOnCurrentScreen = isOnCurrentScreen
|
|
self.buttonWidth = buttonWidth
|
|
}
|
|
}
|
|
|
|
extension StatusItemVisibilitySnapshot: CustomStringConvertible {
|
|
var description: String {
|
|
"visible=\(self.isVisible),button=\(self.hasButton),window=\(self.hasWindow),"
|
|
+ "screen=\(self.hasScreen),currentScreen=\(self.isOnCurrentScreen),"
|
|
+ "width=\(String(format: "%.1f", Double(self.buttonWidth)))"
|
|
}
|
|
}
|
|
|
|
struct StatusItemStartupVisibilityEvidence: Equatable, CustomStringConvertible {
|
|
let autosaveName: String
|
|
let expectsVisibility: Bool
|
|
let visibilityDefault: Bool?
|
|
let snapshot: StatusItemVisibilitySnapshot
|
|
|
|
var description: String {
|
|
"name=\(self.autosaveName),expected=\(self.expectsVisibility),"
|
|
+ "default=\(self.visibilityDefault.map(String.init) ?? "unset"),\(self.snapshot)"
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
func isStatusItemBlocked(_ item: NSStatusItem) -> Bool {
|
|
MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: MenuBarVisibilityWatcher.visibilitySnapshot(item))
|
|
}
|
|
|
|
enum MenuBarVisibilityWatcher {
|
|
static let guidanceShownKey = "hasShownTahoeAllowListGuidance"
|
|
static let guidanceLastShownAtKey = "tahoeAllowListGuidanceLastShownAt"
|
|
static let guidanceRepeatInterval: TimeInterval = 24 * 60 * 60
|
|
static let startupFreshnessInterval: TimeInterval = 10
|
|
static let startupCheckDelay: TimeInterval = 2
|
|
static let screenChangeCheckDelay: Duration = .milliseconds(750)
|
|
static let screenChangeFollowUpDelay: Duration = .seconds(2)
|
|
static let settingsURL = URL(string: "x-apple.systempreferences:com.apple.MenuBarSettings")!
|
|
|
|
@MainActor
|
|
static func visibilitySnapshot(_ item: NSStatusItem) -> StatusItemVisibilitySnapshot {
|
|
let screen = item.button?.window?.screen
|
|
return StatusItemVisibilitySnapshot(
|
|
isVisible: item.isVisible,
|
|
hasButton: item.button != nil,
|
|
hasWindow: item.button?.window != nil,
|
|
hasScreen: screen != nil,
|
|
isOnCurrentScreen: screen.map(self.isCurrentScreen) ?? false,
|
|
buttonWidth: item.button?.frame.size.width ?? 0)
|
|
}
|
|
|
|
@MainActor
|
|
private static func isCurrentScreen(_ screen: NSScreen) -> Bool {
|
|
let screenNumber = self.screenNumber(screen)
|
|
return NSScreen.screens.contains { candidate in
|
|
if let screenNumber, let candidateNumber = self.screenNumber(candidate) {
|
|
return candidateNumber == screenNumber
|
|
}
|
|
return candidate === screen
|
|
}
|
|
}
|
|
|
|
private static func screenNumber(_ screen: NSScreen) -> NSNumber? {
|
|
screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber
|
|
}
|
|
|
|
static func isBlockedSnapshot(snapshot: StatusItemVisibilitySnapshot) -> Bool {
|
|
guard snapshot.isVisible else { return false }
|
|
guard snapshot.hasButton else { return true }
|
|
// Menu bar managers can park status-item windows off the current screen while preserving the
|
|
// underlying NSStatusItem. Recreating in that state makes those managers see a new item.
|
|
return !snapshot.hasWindow || snapshot.buttonWidth <= 0
|
|
}
|
|
|
|
static func isDisplacedSnapshot(snapshot: StatusItemVisibilitySnapshot) -> Bool {
|
|
guard snapshot.isVisible, snapshot.hasButton, snapshot.hasWindow, snapshot.buttonWidth > 0 else {
|
|
return false
|
|
}
|
|
return !snapshot.hasScreen || !snapshot.isOnCurrentScreen
|
|
}
|
|
|
|
static func hasBlockedVisibleSnapshots(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
|
|
let visibleItems = snapshots.filter(\.isVisible)
|
|
guard !visibleItems.isEmpty else { return false }
|
|
return visibleItems.allSatisfy { snapshot in
|
|
self.isBlockedSnapshot(snapshot: snapshot)
|
|
}
|
|
}
|
|
|
|
static func hasAnyBlockedVisibleSnapshot(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
|
|
snapshots.contains { snapshot in
|
|
snapshot.isVisible && self.isBlockedSnapshot(snapshot: snapshot)
|
|
}
|
|
}
|
|
|
|
static func hasAnyDisplacedVisibleSnapshot(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
|
|
snapshots.contains { snapshot in
|
|
self.isDisplacedSnapshot(snapshot: snapshot)
|
|
}
|
|
}
|
|
|
|
static func hasAnyStartupRecoveryCandidate(
|
|
snapshots: [StatusItemVisibilitySnapshot],
|
|
evidence: [StatusItemStartupVisibilityEvidence] = [],
|
|
windowSnapshots: [MenuBarStatusItemWindowSnapshot] = [],
|
|
detectTahoeBlockedStatusItem: Bool = false)
|
|
-> Bool
|
|
{
|
|
if self.hasAnyBlockedVisibleSnapshot(snapshots) {
|
|
return true
|
|
}
|
|
if detectTahoeBlockedStatusItem,
|
|
self.hasAnyTahoeHiddenNoProxyCandidate(evidence: evidence, windowSnapshots: windowSnapshots)
|
|
{
|
|
return true
|
|
}
|
|
guard detectTahoeBlockedStatusItem,
|
|
self.hasAnyDisplacedVisibleSnapshot(snapshots),
|
|
windowSnapshots.contains(where: \.isTahoeBlockedProxy)
|
|
else {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
static func hasAnyTahoeHiddenNoProxyCandidate(
|
|
evidence: [StatusItemStartupVisibilityEvidence],
|
|
windowSnapshots: [MenuBarStatusItemWindowSnapshot])
|
|
-> Bool
|
|
{
|
|
evidence.contains { item in
|
|
// Tahoe can destroy the Control Center scene while leaving its enabled default behind.
|
|
// Requiring both app intent and that default avoids treating ordinary hidden items as blocked.
|
|
item.expectsVisibility
|
|
&& item.visibilityDefault == true
|
|
&& !item.snapshot.isVisible
|
|
&& !item.snapshot.hasWindow
|
|
&& !windowSnapshots.contains {
|
|
$0.name == item.autosaveName && $0.isOnscreen && $0.isWithinDisplayBounds
|
|
}
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
static func visibilitySnapshots(_ items: [NSStatusItem]) -> [StatusItemVisibilitySnapshot] {
|
|
items.map { item in
|
|
self.visibilitySnapshot(item)
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
static func hasBlockedVisibleStatusItems(_ items: [NSStatusItem]) -> Bool {
|
|
self.hasBlockedVisibleSnapshots(self.visibilitySnapshots(items))
|
|
}
|
|
|
|
static func shouldAttemptStartupRecovery(
|
|
appLaunchedAt: Date,
|
|
now: Date = Date(),
|
|
snapshots: [StatusItemVisibilitySnapshot],
|
|
evidence: [StatusItemStartupVisibilityEvidence] = [],
|
|
windowSnapshots: [MenuBarStatusItemWindowSnapshot] = [],
|
|
detectTahoeBlockedStatusItem: Bool = false)
|
|
-> Bool
|
|
{
|
|
guard now.timeIntervalSince(appLaunchedAt) <= self.startupFreshnessInterval else { return false }
|
|
return self.hasAnyStartupRecoveryCandidate(
|
|
snapshots: snapshots,
|
|
evidence: evidence,
|
|
windowSnapshots: windowSnapshots,
|
|
detectTahoeBlockedStatusItem: detectTahoeBlockedStatusItem)
|
|
}
|
|
|
|
static func shouldRefreshScreenChangePlacement(
|
|
previousScreenCount _: Int,
|
|
currentScreenCount _: Int,
|
|
snapshots: [StatusItemVisibilitySnapshot])
|
|
-> Bool
|
|
{
|
|
self.hasAnyDisplacedVisibleSnapshot(snapshots)
|
|
}
|
|
|
|
static func shouldAttemptScreenChangeRecovery(snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
|
|
self.hasAnyBlockedVisibleSnapshot(snapshots)
|
|
}
|
|
|
|
static func shouldShowGuidance(defaults: UserDefaults, now: Date = Date()) -> Bool {
|
|
guard defaults.bool(forKey: self.guidanceShownKey) else { return true }
|
|
let lastShownAt = defaults.double(forKey: self.guidanceLastShownAtKey)
|
|
guard lastShownAt > 0 else { return false }
|
|
return now.timeIntervalSince1970 - lastShownAt >= self.guidanceRepeatInterval
|
|
}
|
|
|
|
static func markGuidanceShown(defaults: UserDefaults, now: Date = Date()) {
|
|
defaults.set(true, forKey: self.guidanceShownKey)
|
|
defaults.set(now.timeIntervalSince1970, forKey: self.guidanceLastShownAtKey)
|
|
}
|
|
|
|
@MainActor
|
|
static func presentGuidance(
|
|
defaults: UserDefaults,
|
|
now: Date = Date(),
|
|
openURL: (URL) -> Void = { NSWorkspace.shared.open($0) })
|
|
{
|
|
self.markGuidanceShown(defaults: defaults, now: now)
|
|
|
|
let alert = NSAlert()
|
|
alert.messageText = L("CodexBar can't show its menu bar icon")
|
|
alert.informativeText = L(
|
|
"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. "
|
|
+ "CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on.")
|
|
alert.alertStyle = .warning
|
|
alert.addButton(withTitle: L("Open Menu Bar Settings"))
|
|
alert.addButton(withTitle: L("Dismiss"))
|
|
|
|
if alert.runModal() == .alertFirstButtonReturn {
|
|
openURL(self.settingsURL)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension StatusItemController {
|
|
func scheduleStartupStatusItemVisibilityCheck(appLaunchedAt: Date = Date()) {
|
|
guard !SettingsStore.isRunningTests else { return }
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + MenuBarVisibilityWatcher.startupCheckDelay) { [weak self] in
|
|
Task { @MainActor [weak self] in
|
|
self?.checkStartupStatusItemVisibility(appLaunchedAt: appLaunchedAt)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func checkStartupStatusItemVisibility(appLaunchedAt: Date, now: Date = Date()) {
|
|
let evidence = self.startupStatusItemVisibilityEvidence()
|
|
let snapshots = evidence.map(\.snapshot)
|
|
let windowSnapshots = self.statusItemWindowSnapshots()
|
|
guard MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
|
|
appLaunchedAt: appLaunchedAt,
|
|
now: now,
|
|
snapshots: snapshots,
|
|
evidence: evidence,
|
|
windowSnapshots: windowSnapshots,
|
|
detectTahoeBlockedStatusItem: self.canDetectTahoeBlockedStatusItem)
|
|
else {
|
|
return
|
|
}
|
|
|
|
self.menuLogger.error(
|
|
"Status item failed to materialize or remained detached; recreating status items",
|
|
metadata: [
|
|
"snapshots": snapshots.map(\.description).joined(separator: " | "),
|
|
"evidence": evidence.map(\.description).joined(separator: " | "),
|
|
"windows": self.statusItemWindowDiagnosticsDescription(windowSnapshots),
|
|
])
|
|
self.recreateStatusItemsForVisibilityRecovery()
|
|
|
|
let recoveredEvidence = self.startupStatusItemVisibilityEvidence()
|
|
let recoveredSnapshots = recoveredEvidence.map(\.snapshot)
|
|
let recoveredWindowSnapshots = self.statusItemWindowSnapshots()
|
|
guard MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
|
|
appLaunchedAt: appLaunchedAt,
|
|
now: now,
|
|
snapshots: recoveredSnapshots,
|
|
evidence: recoveredEvidence,
|
|
windowSnapshots: recoveredWindowSnapshots,
|
|
detectTahoeBlockedStatusItem: self.canDetectTahoeBlockedStatusItem)
|
|
else {
|
|
self.menuLogger.info(
|
|
"Status item materialized after recreation",
|
|
metadata: ["snapshots": recoveredSnapshots.map(\.description).joined(separator: " | ")])
|
|
return
|
|
}
|
|
|
|
self.menuLogger.error(
|
|
"Status item still unavailable after recreation",
|
|
metadata: [
|
|
"snapshots": recoveredSnapshots.map(\.description).joined(separator: " | "),
|
|
"evidence": recoveredEvidence.map(\.description).joined(separator: " | "),
|
|
"windows": self.statusItemWindowDiagnosticsDescription(recoveredWindowSnapshots),
|
|
])
|
|
guard #available(macOS 26.0, *),
|
|
MenuBarVisibilityWatcher.shouldShowGuidance(defaults: self.settings.userDefaults, now: now)
|
|
else {
|
|
return
|
|
}
|
|
MenuBarVisibilityWatcher.presentGuidance(defaults: self.settings.userDefaults, now: now)
|
|
}
|
|
|
|
@objc func handleScreenParametersDidChange(_: Notification) {
|
|
let previousScreenCount = max(
|
|
self.pendingScreenChangePreviousCount ?? self.lastKnownScreenCount,
|
|
self.lastKnownScreenCount)
|
|
let currentScreenCount = NSScreen.screens.count
|
|
self.pendingScreenChangePreviousCount = previousScreenCount
|
|
self.lastKnownScreenCount = currentScreenCount
|
|
self.scheduleScreenChangeStatusItemVisibilityCheck(
|
|
previousScreenCount: previousScreenCount,
|
|
currentScreenCount: currentScreenCount)
|
|
}
|
|
|
|
private func scheduleScreenChangeStatusItemVisibilityCheck(
|
|
previousScreenCount: Int,
|
|
currentScreenCount: Int)
|
|
{
|
|
guard !SettingsStore.isRunningTests else { return }
|
|
self.screenChangeVisibilityTask?.cancel()
|
|
self.screenChangeVisibilityTask = Task { @MainActor [weak self] in
|
|
do {
|
|
try await Task.sleep(for: MenuBarVisibilityWatcher.screenChangeCheckDelay)
|
|
} catch {
|
|
return
|
|
}
|
|
self?.checkScreenChangeStatusItemVisibility(
|
|
previousScreenCount: previousScreenCount,
|
|
currentScreenCount: currentScreenCount)
|
|
}
|
|
}
|
|
|
|
private func checkScreenChangeStatusItemVisibility(previousScreenCount: Int, currentScreenCount: Int) {
|
|
self.pendingScreenChangePreviousCount = nil
|
|
let settledCurrentScreenCount = NSScreen.screens.count
|
|
self.lastKnownScreenCount = settledCurrentScreenCount
|
|
let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
|
|
if MenuBarVisibilityWatcher.shouldAttemptScreenChangeRecovery(snapshots: snapshots) {
|
|
self.menuLogger.error(
|
|
"Display configuration changed; recreating status items",
|
|
metadata: [
|
|
"previousScreenCount": "\(previousScreenCount)",
|
|
"currentScreenCount": "\(settledCurrentScreenCount)",
|
|
"capturedScreenCount": "\(currentScreenCount)",
|
|
"snapshots": snapshots.map(\.description).joined(separator: " | "),
|
|
"windows": self.statusItemWindowDiagnosticsDescription(),
|
|
])
|
|
self.recreateStatusItemsForVisibilityRecovery()
|
|
self.schedulePostScreenChangeRecoveryVerification(attempt: 1)
|
|
return
|
|
}
|
|
|
|
guard MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
|
|
previousScreenCount: previousScreenCount,
|
|
currentScreenCount: settledCurrentScreenCount,
|
|
snapshots: snapshots)
|
|
else {
|
|
return
|
|
}
|
|
|
|
self.menuLogger.info(
|
|
"Display configuration changed; refreshing existing status items",
|
|
metadata: [
|
|
"previousScreenCount": "\(previousScreenCount)",
|
|
"currentScreenCount": "\(settledCurrentScreenCount)",
|
|
"capturedScreenCount": "\(currentScreenCount)",
|
|
"snapshots": snapshots.map(\.description).joined(separator: " | "),
|
|
])
|
|
self.refreshExistingStatusItemsForVisibilityRecovery()
|
|
}
|
|
|
|
private func schedulePostScreenChangeRecoveryVerification(attempt: Int) {
|
|
self.screenChangeVisibilityTask = Task { @MainActor [weak self] in
|
|
do {
|
|
try await Task.sleep(for: MenuBarVisibilityWatcher.screenChangeFollowUpDelay)
|
|
} catch {
|
|
return
|
|
}
|
|
self?.verifyScreenChangeRecoveryIfNeeded(attempt: attempt)
|
|
}
|
|
}
|
|
|
|
private func verifyScreenChangeRecoveryIfNeeded(attempt: Int) {
|
|
let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
|
|
guard MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot(snapshots) else {
|
|
self.menuLogger.info(
|
|
"Status item recovered after display-change recovery",
|
|
metadata: ["attempt": "\(attempt)", "snapshots": snapshots.map(\.description).joined(separator: " | ")])
|
|
return
|
|
}
|
|
|
|
self.menuLogger.error(
|
|
"Status item still blocked after display-change recovery; recreating status items again",
|
|
metadata: [
|
|
"attempt": "\(attempt)",
|
|
"snapshots": snapshots.map(\.description).joined(separator: " | "),
|
|
"windows": self.statusItemWindowDiagnosticsDescription(),
|
|
])
|
|
self.recreateStatusItemsForVisibilityRecovery()
|
|
// No further async retries: a menu bar manager may park the newly recreated item in a state
|
|
// that still looks blocked, causing repeated NSStatusItem destruction that corrupts Control Center.
|
|
// Instead, do one synchronous re-check to surface guidance if macOS itself is blocking the item.
|
|
let finalSnapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
|
|
guard MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot(finalSnapshots) else { return }
|
|
self.menuLogger.error(
|
|
"Status item still blocked after display-change recovery recreation",
|
|
metadata: [
|
|
"snapshots": finalSnapshots.map(\.description).joined(separator: " | "),
|
|
"windows": self.statusItemWindowDiagnosticsDescription(),
|
|
])
|
|
guard #available(macOS 26.0, *),
|
|
MenuBarVisibilityWatcher.shouldShowGuidance(defaults: self.settings.userDefaults)
|
|
else { return }
|
|
MenuBarVisibilityWatcher.presentGuidance(defaults: self.settings.userDefaults)
|
|
}
|
|
|
|
private var startupVisibilityStatusItems: [NSStatusItem] {
|
|
[self.statusItem] + Array(self.statusItems.values)
|
|
}
|
|
|
|
private func startupStatusItemVisibilityEvidence() -> [StatusItemStartupVisibilityEvidence] {
|
|
self.startupVisibilityStatusItems.map { item in
|
|
let autosaveName = item.autosaveName ?? ""
|
|
return StatusItemStartupVisibilityEvidence(
|
|
autosaveName: autosaveName,
|
|
expectsVisibility: self.expectedVisibleStatusItemAutosaveNames.contains(autosaveName),
|
|
visibilityDefault: MenuBarStatusItemDefaultsRepair.visibilityDefault(
|
|
defaults: self.settings.userDefaults,
|
|
autosaveName: autosaveName),
|
|
snapshot: MenuBarVisibilityWatcher.visibilitySnapshot(item))
|
|
}
|
|
}
|
|
|
|
private var canDetectTahoeBlockedStatusItem: Bool {
|
|
if #available(macOS 26.0, *) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
private func statusItemWindowSnapshots() -> [MenuBarStatusItemWindowSnapshot] {
|
|
let names = Set(self.startupVisibilityStatusItems.compactMap { item in
|
|
item.autosaveName.isEmpty ? nil : item.autosaveName
|
|
})
|
|
return MenuBarStatusItemWindowProbe.snapshots(matching: names)
|
|
}
|
|
|
|
private func statusItemWindowDiagnosticsDescription(
|
|
_ snapshots: [MenuBarStatusItemWindowSnapshot]? = nil)
|
|
-> String
|
|
{
|
|
let snapshots = snapshots ?? self.statusItemWindowSnapshots()
|
|
guard !snapshots.isEmpty else { return "none" }
|
|
return snapshots.map(\.description).joined(separator: " | ")
|
|
}
|
|
}
|