From 06fc09fab9150d3691d243cdd392c82bc4cf9894 Mon Sep 17 00:00:00 2001 From: Han Ngo Date: Tue, 17 Nov 2026 13:35:23 +0700 Subject: [PATCH 1/2] fix(native): treat apps run outside Applications as items macOS will not keep macOS 27 hides an app whose menu bar process runs from outside an Applications folder although its bundle id is on the allow list. iStat Menus 7 runs its menu bar from ~/Library/Application Support through a LaunchAgent, so it vanished on collapse even in the visible section (#521). Measured on 27.0.1 and 27.2.1: the App Support copy is hidden when allowed, the /Applications copy is kept. Such an app in the visible section is now listed under "macOS 27 also hides" in Preferences, and with "Pause hiding while macOS shows..." on, a collapse keeps the bar whole while it sits right of the arrow, the same path the unkeepable system extras take. /System stays exempt. --- HiddenBarTests/MenuBarEngineTests.swift | 48 +++++++++++++++++++ .../AdvancedSettingsViewController.swift | 1 + .../Engine/NativeVisibilityEngine.swift | 12 +++++ .../AccessibilityMenuBarInventory.swift | 28 +++++++++-- .../StatusBar/Layout/MenuBarLayout.swift | 19 ++++++++ 5 files changed, 103 insertions(+), 5 deletions(-) diff --git a/HiddenBarTests/MenuBarEngineTests.swift b/HiddenBarTests/MenuBarEngineTests.swift index 7736f1e9..b65cf4f6 100644 --- a/HiddenBarTests/MenuBarEngineTests.swift +++ b/HiddenBarTests/MenuBarEngineTests.swift @@ -398,6 +398,11 @@ private func systemExtra(_ identifier: String?, x: CGFloat) -> MenuBarInventoryI systemIdentifier: identifier) } +private func outsideApp(_ bundle: String, x: CGFloat) -> MenuBarInventoryItem { + return MenuBarInventoryItem(bundleIdentifier: bundle, frame: CGRect(x: x, y: 0, width: 24, height: 24), + ownerName: "iStat Menus", runsOutsideApplicationsFolder: true) +} + final class FailOpenClassificationTests: XCTestCase { private func resolve(_ inventory: [MenuBarInventoryItem], isLTR: Bool = true) -> MenuBarLayout { return MenuBarLayoutResolver.resolve(inventory: inventory, separatorFrame: separator, @@ -452,6 +457,34 @@ final class FailOpenClassificationTests: XCTestCase { XCTAssertNil(left.reasonToKeepBarWhole(unkeepableSystemItems: unkeepable)) } + // iStat Menus 7 runs its menu bar from ~/Library/Application Support (#521): + // macOS 27.0.1 hides it although its bundle id is allowed. + func testAppRunFromOutsideApplicationsRightOfArrowIsUnkeepable() { + let layout = resolve([outsideApp("com.bjango.istatmenus.status", x: 1400), item("com.app", x: 1100)]) + XCTAssertEqual(layout.sections["com.bjango.istatmenus.status"], .visible) + XCTAssertEqual(layout.unkeepableVisibleApps, ["iStat Menus"]) + XCTAssertNotNil(layout.reasonToKeepBarWhole(unkeepableSystemItems: [])) + } + + func testAppRunFromOutsideApplicationsLeftOfArrowCanBeHidden() { + let layout = resolve([outsideApp("com.bjango.istatmenus.status", x: 1100)]) + XCTAssertTrue(layout.unkeepableVisibleApps.isEmpty) + XCTAssertNil(layout.reasonToKeepBarWhole(unkeepableSystemItems: [])) + } + + func testWhereAnAppRunsDecidesWhetherMacOSCanKeepIt() { + let folders = [URL(fileURLWithPath: "/Applications")] + func outside(_ path: String?) -> Bool { + AccessibilityMenuBarInventory.runsOutsideApplicationsFolder(path.map { URL(fileURLWithPath: $0) }, + applicationFolders: folders) + } + XCTAssertTrue(outside("/Users/me/Library/Application Support/iStat Menus 7/iStat Menus Status.app")) + XCTAssertTrue(outside("/Users/me/Downloads/Some.app")) + XCTAssertFalse(outside("/Applications/iStat Menus.app/Contents/Library/LoginItems/iStat Menus Status.app")) + XCTAssertFalse(outside("/System/Library/CoreServices/Spotlight.app"), "macOS's own apps live in /System") + XCTAssertFalse(outside(nil), "a bare executable has no bundle id to allow anyway") + } + func testMissingSystemItemsAreThoseNoLongerListed() { let missing = MenuBarLayoutResolver.missingSystemItems( ["com.apple.menuextra.focusmode", "com.apple.menuextra.now-playing"], @@ -662,6 +695,21 @@ final class UnkeepableItemsOptInTests: XCTestCase { XCTAssertEqual(result, .unavailable) } + func testOptInKeepsAppRunFromOutsideApplicationsRightOfArrowShown() { + let (requests, result) = collapse([outsideApp("com.bjango.istatmenus.status", x: 1400), item("com.app", x: 1100)], + optIn: true) + XCTAssertEqual(requests, 0, "macOS would hide iStat Menus although it is allowed") + XCTAssertEqual(result, .unavailable) + XCTAssertTrue(NativeVisibilityEngine.knownUnkeepableApps.contains("iStat Menus")) + } + + func testDefaultHidesAppRunFromOutsideApplicationsAndListsIt() { + let (requests, _) = collapse([outsideApp("com.bjango.istatmenus.status", x: 1400), item("com.app", x: 1100)], + optIn: false) + XCTAssertEqual(requests, 1, "off by default: hiding goes on as before") + XCTAssertTrue(NativeVisibilityEngine.knownUnkeepableApps.contains("iStat Menus"), "Preferences names it") + } + func testOptInStillCollapsesWhenTheOwnerIsLeftOfArrow() { let (requests, _) = collapse([item(nil, x: 1100), item("com.app", x: 1100)], optIn: true) XCTAssertEqual(requests, 1) diff --git a/hidden/Features/Settings/AdvancedSettingsViewController.swift b/hidden/Features/Settings/AdvancedSettingsViewController.swift index 1f3178aa..2742ec9c 100644 --- a/hidden/Features/Settings/AdvancedSettingsViewController.swift +++ b/hidden/Features/Settings/AdvancedSettingsViewController.swift @@ -64,6 +64,7 @@ final class AdvancedSettingsViewController: SettingsPaneController { private func refreshMacOSAlsoHides() { let names = NativeVisibilityEngine.knownUnkeepableSystemItems.map(NativeVisibilityEngine.displayName(ofSystemItem:)) + + NativeVisibilityEngine.knownUnkeepableApps let help = "macOS 27 hides these items whenever an app hides icons. While one shows, Hidden Bar hides nothing.".localized macOSAlsoHidesCaption?.stringValue = names.isEmpty ? help diff --git a/hidden/Features/StatusBar/Engine/NativeVisibilityEngine.swift b/hidden/Features/StatusBar/Engine/NativeVisibilityEngine.swift index 5e37adaa..1a9ac960 100644 --- a/hidden/Features/StatusBar/Engine/NativeVisibilityEngine.swift +++ b/hidden/Features/StatusBar/Engine/NativeVisibilityEngine.swift @@ -66,6 +66,10 @@ import AppKit // one run from elsewhere (Downloads, a build folder): it hides that app's // icons although they are allowed, Hidden Bar's own arrow included, leaving no // arrow to expand with. Outside an Applications folder nothing is hidden. +// Another app run from elsewhere (iStat Menus 7 from Application Support, +// #521) is hidden the same way although it is allowed; Preferences lists it +// with the system items macOS will not keep, and the opt-in keeps the bar +// whole while one sits right of the arrow. // Everything one held restriction allows besides Hidden Bar itself. Two holds are // the same only when every part matches, so a swap between lists that name the // same apps but different system items is not skipped. @@ -486,6 +490,12 @@ final class NativeVisibilityEngine: MenuBarEngine { if !layout.unnameableVisibleItems.isEmpty || !layout.unprovenVisibleSystemItems.isEmpty { NSLog("NativeVisibility: visible without a bundle id \(layout.unnameableVisibleItems); visible system extras to check \(layout.unprovenVisibleSystemItems)") } + let unkeepableApps = layout.unkeepableVisibleApps + if !unkeepableApps.isEmpty, !Set(unkeepableApps).isSubset(of: Self.knownUnkeepableApps) { + NSLog("NativeVisibility: macOS hides \(unkeepableApps) although they are allowed: they run from outside an Applications folder") + Self.knownUnkeepableApps = Array(Set(Self.knownUnkeepableApps).union(unkeepableApps)).sorted() + NotificationCenter.default.post(name: .unkeepableSystemItemsChanged, object: nil) + } self.layout = layout body(layout) } @@ -1133,6 +1143,8 @@ final class NativeVisibilityEngine: MenuBarEngine { // What Preferences shows as "macOS 27 also hides". static private(set) var knownUnkeepableSystemItems: [String] = [] + // Same, for apps run from outside an Applications folder, by name. + static private(set) var knownUnkeepableApps: [String] = [] private func rememberUnkeepable(_ identifiers: [String]) { unkeepableSystemItems.formUnion(identifiers) diff --git a/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift b/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift index 6af55e61..76107884 100644 --- a/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift +++ b/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift @@ -19,7 +19,7 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { // more time, so a busy app is not dropped from the allow list and hidden. private static let retryTimeout: Float = 0.5 - private typealias App = (pid: pid_t, bundleIdentifier: String?, name: String?) + private typealias App = (pid: pid_t, bundleIdentifier: String?, name: String?, runsOutsideApplicationsFolder: Bool) private var hasRequestedAuthorization = false @@ -42,7 +42,8 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { let ownPID = ProcessInfo.processInfo.processIdentifier let apps: [App] = NSWorkspace.shared.runningApplications .filter { $0.processIdentifier != ownPID && Self.mayOwnStatusItems(bundleURL: $0.bundleURL, bundleIdentifier: $0.bundleIdentifier) } - .map { (pid: $0.processIdentifier, bundleIdentifier: $0.bundleIdentifier, name: $0.localizedName) } + .map { (pid: $0.processIdentifier, bundleIdentifier: $0.bundleIdentifier, name: $0.localizedName, + runsOutsideApplicationsFolder: Self.runsOutsideApplicationsFolder($0.bundleURL)) } DispatchQueue.global(qos: .userInitiated).async { let start = Date() let items = Self.statusItems(of: apps) @@ -51,6 +52,20 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { } } + // macOS 27 hides an app run from outside an Applications folder although its + // bundle id is allowed (#521), as it does Hidden Bar's own arrow. Measured + // with iStat Menus 7, whose LaunchAgent runs it from ~/Library/Application + // Support: hidden on 27.0.1 and 27.2.1, kept when run from /Applications. + // /System is left out: macOS's own apps live there, and SystemUIServer's + // extras are kept by bundle. + static func runsOutsideApplicationsFolder(_ bundleURL: URL?, + applicationFolders: [URL] = FileManager.default.urls(for: .applicationDirectory, + in: .localDomainMask)) -> Bool { + guard let url = bundleURL else { return false } + if url.resolvingSymlinksInPath().standardizedFileURL.path.hasPrefix("/System/") { return false } + return !NativeVisibilityEngine.isInApplicationsFolder(url, applicationFolders: applicationFolders) + } + // Apps and bare executables (scripts, helpers without an Info.plist) can own // status items. Skipping XPC services and extensions (dozens of WebKit // helpers, each of which would sit out the timeout) cuts the walk from ~2.8s @@ -94,7 +109,8 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { let app = apps[index] guard app.bundleIdentifier != nil else { return [] } return [MenuBarInventoryItem(bundleIdentifier: app.bundleIdentifier, frame: .zero, - isUnreadable: true, ownerName: app.name)] + isUnreadable: true, ownerName: app.name, + runsOutsideApplicationsFolder: app.runsOutsideApplicationsFolder)] }) } @@ -152,11 +168,13 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { return .items(children.map { child in guard let frame = frame(of: child) else { return MenuBarInventoryItem(bundleIdentifier: app.bundleIdentifier, frame: .zero, - isUnreadable: true, ownerName: app.name) + isUnreadable: true, ownerName: app.name, + runsOutsideApplicationsFolder: app.runsOutsideApplicationsFolder) } return MenuBarInventoryItem(bundleIdentifier: app.bundleIdentifier, frame: frame, systemIdentifier: isSystemOwner ? identifier(of: child) : nil, - ownerName: app.name) + ownerName: app.name, + runsOutsideApplicationsFolder: app.runsOutsideApplicationsFolder) }) } diff --git a/hidden/Features/StatusBar/Layout/MenuBarLayout.swift b/hidden/Features/StatusBar/Layout/MenuBarLayout.swift index 8e87c9ab..13c11c66 100644 --- a/hidden/Features/StatusBar/Layout/MenuBarLayout.swift +++ b/hidden/Features/StatusBar/Layout/MenuBarLayout.swift @@ -34,6 +34,10 @@ struct MenuBarInventoryItem: Equatable { // The owner did not answer Accessibility in time, so the frame is unknown. var isUnreadable: Bool = false var ownerName: String? = nil + // Run from outside an Applications folder (iStat Menus 7 runs its menu bar + // from Application Support, #521) on a macOS that then hides it although + // its bundle id is allowed. Set by the inventory only where that holds. + var runsOutsideApplicationsFolder: Bool = false } // One connected display. Every display has its own menu bar, but AppKit hands @@ -254,6 +258,10 @@ struct MenuBarLayout: Equatable { // Visible-section system extras that no system item identifier covers. Only // their bundle can try to keep them, so the engine checks they stay shown. var unprovenVisibleSystemItems: [String] = [] + // Apps macOS will not keep although their bundle id is allowed, by bundle, + // with the name Preferences shows. Kept whatever section they are in, as + // pinned sections may move them after the read. + var appsMacOSHides: [String: String] = [:] // The active display's menu bar overflowed (a narrow display), and macOS // lists only the items that fit, so apps are missing from `sections`. var isIncomplete = false @@ -262,6 +270,7 @@ struct MenuBarLayout: Equatable { func fillingIn(from earlier: MenuBarLayout) -> MenuBarLayout { var layout = self layout.sections.merge(earlier.sections) { current, _ in current } + layout.appsMacOSHides.merge(earlier.appsMacOSHides) { current, _ in current } return layout } @@ -269,6 +278,11 @@ struct MenuBarLayout: Equatable { return sections.filter { wanted.contains($0.value) }.map(\.key).sorted() } + // Names of the visible-section apps macOS hides whatever the allow-list says. + var unkeepableVisibleApps: [String] { + return bundles(in: [.visible]).compactMap { appsMacOSHides[$0] }.sorted() + } + // Why nothing may be hidden with this layout: fail open rather than hide an // item the user put in the visible section. func reasonToKeepBarWhole(unkeepableSystemItems: Set) -> String? { @@ -279,6 +293,9 @@ struct MenuBarLayout: Equatable { if !unkeepable.isEmpty { return "macOS hides these system items while hiding anything, and they sit right of the arrow: \(unkeepable)" } + if !unkeepableVisibleApps.isEmpty { + return "macOS hides these apps run from outside an Applications folder although they are allowed, and they sit right of the arrow: \(unkeepableVisibleApps)" + } return nil } } @@ -363,6 +380,8 @@ enum MenuBarLayoutResolver { layout.unprovenVisibleSystemItems.append(identifier) } key = systemExtrasBundle + } else if item.runsOutsideApplicationsFolder { + layout.appsMacOSHides[key] = item.ownerName ?? key } // One app can own several items, but hiding applies to the whole // bundle. The most visible item wins so an icon the user kept visible From 1f2f127516e0522970df711dc42405dd98669855 Mon Sep 17 00:00:00 2001 From: Han Ngo Date: Tue, 17 Nov 2026 13:41:48 +0700 Subject: [PATCH 2/2] fix(native): exempt macOS's own processes from the unkeepable apps sharingd runs from /usr/libexec and lists a menu bar item no one sees; seen on 27.0.1 in the 'also hides' list, and with pause on it would have kept the bar whole for good. --- HiddenBarTests/MenuBarEngineTests.swift | 1 + .../StatusBar/Layout/AccessibilityMenuBarInventory.swift | 7 ++++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/HiddenBarTests/MenuBarEngineTests.swift b/HiddenBarTests/MenuBarEngineTests.swift index b65cf4f6..319fa81c 100644 --- a/HiddenBarTests/MenuBarEngineTests.swift +++ b/HiddenBarTests/MenuBarEngineTests.swift @@ -482,6 +482,7 @@ final class FailOpenClassificationTests: XCTestCase { XCTAssertTrue(outside("/Users/me/Downloads/Some.app")) XCTAssertFalse(outside("/Applications/iStat Menus.app/Contents/Library/LoginItems/iStat Menus Status.app")) XCTAssertFalse(outside("/System/Library/CoreServices/Spotlight.app"), "macOS's own apps live in /System") + XCTAssertFalse(outside("/usr/libexec/sharingd"), "macOS's own daemons live in /usr (seen on 27.0.1)") XCTAssertFalse(outside(nil), "a bare executable has no bundle id to allow anyway") } diff --git a/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift b/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift index 76107884..0253d6b5 100644 --- a/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift +++ b/hidden/Features/StatusBar/Layout/AccessibilityMenuBarInventory.swift @@ -56,13 +56,14 @@ final class AccessibilityMenuBarInventory: MenuBarInventoryProviding { // bundle id is allowed (#521), as it does Hidden Bar's own arrow. Measured // with iStat Menus 7, whose LaunchAgent runs it from ~/Library/Application // Support: hidden on 27.0.1 and 27.2.1, kept when run from /Applications. - // /System is left out: macOS's own apps live there, and SystemUIServer's - // extras are kept by bundle. + // macOS's own processes are left out: SystemUIServer's extras are kept by + // bundle, and sharingd (/usr/libexec) lists an item no one sees. static func runsOutsideApplicationsFolder(_ bundleURL: URL?, applicationFolders: [URL] = FileManager.default.urls(for: .applicationDirectory, in: .localDomainMask)) -> Bool { guard let url = bundleURL else { return false } - if url.resolvingSymlinksInPath().standardizedFileURL.path.hasPrefix("/System/") { return false } + let path = url.resolvingSymlinksInPath().standardizedFileURL.path + if ["/System/", "/usr/", "/Library/Apple/"].contains(where: path.hasPrefix) { return false } return !NativeVisibilityEngine.isInApplicationsFolder(url, applicationFolders: applicationFolders) }