Exempt the app under UI test from the single-instance guard

The guard's test-host check keys off the XCTest environment, which only a
unit test host has — those run inside a real MiniMe process. UI tests drive
MiniMe as its own process through XCUIApplication, which carries none of it,
so the guard was live inside the app under test. With any other copy running
(the installed one, usually) it exited before the runner could see it and
every UI test waited out its timeout.

The UI tests now pass MINIME_UI_TESTING and the guard honours it. The flag
is deliberately not "-"-prefixed, so it can't land in NSArgumentDomain and
shadow an @AppStorage key.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: marduc812

MiniMe/App/SingleInstanceGuard.swift

@@ -47,6 +47,25 @@ enum SingleInstanceGuard {
             || environment["XCTestBundlePath"] != nil
     }
 
+    /// Passed by the UI tests so the app under test keeps the guard switched off.
+    ///
+    /// Deliberately not `-`-prefixed: macOS folds `-key value` launch arguments
+    /// into `NSArgumentDomain`, where the name could shadow one of the app's
+    /// `@AppStorage` keys.
+    static let uiTestLaunchArgument = "MINIME_UI_TESTING"
+
+    /// Whether the UI test runner launched this process.
+    ///
+    /// `isTestHost` can't answer this. UI tests drive MiniMe as its own process
+    /// through `XCUIApplication`, which does not carry the XCTest environment a
+    /// unit test host has — so the guard was live inside the app under test, and
+    /// any other copy running on the machine (the installed one, usually) made
+    /// it exit before the runner could see it. Every UI test then waited out its
+    /// timeout.
+    static func isUITestRun(arguments: [String]) -> Bool {
+        arguments.contains(uiTestLaunchArgument)
+    }
+
     /// Exits the process if another MiniMe already holds the menu bar, bringing
     /// that one forward first so the launch still shows the user something.
     ///
@@ -55,6 +74,7 @@ enum SingleInstanceGuard {
     @MainActor
     static func yieldToRunningInstance() {
         guard !isTestHost(environment: ProcessInfo.processInfo.environment) else { return }
+        guard !isUITestRun(arguments: ProcessInfo.processInfo.arguments) else { return }
         guard let bundleID = Bundle.main.bundleIdentifier else { return }
 
         let running = NSRunningApplication.runningApplications(withBundleIdentifier: bundleID)

MiniMeTests/SingleInstanceGuardTests.swift

@@ -56,6 +56,33 @@ struct SingleInstanceGuardTests {
         #expect(!SingleInstanceGuard.isTestHost(environment: ["HOME": "/Users/someone"]))
     }
 
+    /// The UI tests launch MiniMe as its own process, which carries none of the
+    /// XCTest environment above — so they hand the exemption over explicitly.
+    /// Without this the guard fired inside the app under test and every UI test
+    /// timed out waiting for a window that had already exited.
+    @Test func theAppUnderUITestIsExemptFromTheGuard() {
+        #expect(SingleInstanceGuard.isUITestRun(
+            arguments: ["/path/to/MiniMe", SingleInstanceGuard.uiTestLaunchArgument]
+        ))
+    }
+
+    @Test func anOrdinaryLaunchIsNotAUITestRun() {
+        #expect(!SingleInstanceGuard.isUITestRun(arguments: []))
+        #expect(!SingleInstanceGuard.isUITestRun(arguments: ["/path/to/MiniMe"]))
+        #expect(!SingleInstanceGuard.isUITestRun(arguments: ["/path/to/MiniMe", "-psn_0_12345"]))
+    }
+
+    /// Pins the literal. `XCUIApplication.miniMe()` spells the same string out
+    /// on the UI test side — a target can't import the app module — so renaming
+    /// it here alone would silently arm the guard against the app under test.
+    ///
+    /// The leading character matters too: `NSArgumentDomain` only picks up
+    /// `-`-prefixed names, so this one can't shadow an `@AppStorage` key.
+    @Test func theUITestFlagIsTheOneTheUITestsPass() {
+        #expect(SingleInstanceGuard.uiTestLaunchArgument == "MINIME_UI_TESTING")
+        #expect(!SingleInstanceGuard.uiTestLaunchArgument.hasPrefix("-"))
+    }
+
     /// More than two copies can pile up over a long Xcode session; the guard
     /// reports every one so the caller can defer to the oldest.
     @Test func everyOtherCopyIsReported() {

MiniMeUITests/MiniMeUITests.swift

@@ -13,7 +13,7 @@ final class MiniMeUITests: XCTestCase {
 
     override func setUpWithError() throws {
         continueAfterFailure = false
-        app = XCUIApplication()
+        app = .miniMe()
         app.launch()
     }
 
@@ -87,7 +87,7 @@ final class MiniMeUITests: XCTestCase {
     func testLaunchPerformance() throws {
         if #available(macOS 10.15, *) {
             measure(metrics: [XCTApplicationLaunchMetric()]) {
-                XCUIApplication().launch()
+                XCUIApplication.miniMe().launch()
             }
         }
     }

MiniMeUITests/MiniMeUITestsLaunchTests.swift

@@ -19,7 +19,7 @@ final class MiniMeUITestsLaunchTests: XCTestCase {
 
     @MainActor
     func testLaunch() throws {
-        let app = XCUIApplication()
+        let app = XCUIApplication.miniMe()
         app.launch()
 
         // Insert steps here to perform after app launch but before taking a screenshot,

MiniMeUITests/OnboardingUITests.swift

@@ -19,7 +19,7 @@ final class OnboardingUITests: XCTestCase {
 
     override func setUpWithError() throws {
         continueAfterFailure = false
-        app = XCUIApplication()
+        app = .miniMe()
         app.launch()
         XCTAssertTrue(app.statusItems.firstMatch.waitForExistence(timeout: 10),
                       "MiniMe's status item never appeared")

MiniMeUITests/SettingsUITests.swift

@@ -11,7 +11,7 @@ final class SettingsUITests: XCTestCase {
 
     override func setUpWithError() throws {
         continueAfterFailure = false
-        app = XCUIApplication()
+        app = .miniMe()
         app.launch()
     }
 

MiniMeUITests/ToolToggleUITests.swift

@@ -18,7 +18,7 @@ final class ToolToggleUITests: XCTestCase {
 
     override func setUpWithError() throws {
         continueAfterFailure = false
-        app = XCUIApplication()
+        app = .miniMe()
         app.launch()
         XCTAssertTrue(app.statusItems.firstMatch.waitForExistence(timeout: 10),
                       "MiniMe's status item never appeared")

MiniMeUITests/XCUIApplication+MiniMe.swift

@@ -0,0 +1,27 @@
+//
+//  XCUIApplication+MiniMe.swift
+//  MiniMeUITests
+//
+
+import XCTest
+
+extension XCUIApplication {
+
+    /// Must match `SingleInstanceGuard.uiTestLaunchArgument`. A UI test target
+    /// can't import the app module, so the string is spelled out on both sides;
+    /// `theUITestFlagIsTheOneTheUITestsPass` in `SingleInstanceGuardTests` pins
+    /// the app's half to this same literal.
+    private static let uiTestLaunchArgument = "MINIME_UI_TESTING"
+
+    /// MiniMe with the single-instance guard switched off.
+    ///
+    /// The guard exits a second copy at launch, and it can't tell the app under
+    /// test apart from an ordinary launch — so without the flag every UI test on
+    /// a machine already running MiniMe waits out its timeout on a process that
+    /// quit before the runner reached it. Build every `XCUIApplication` here.
+    static func miniMe() -> XCUIApplication {
+        let app = XCUIApplication()
+        app.launchArguments.append(uiTestLaunchArgument)
+        return app
+    }
+}