updates to launcer

OrionToolbar/OrionMenuView.swift

@@ -325,19 +325,24 @@ private struct OrionActionStyle: ButtonStyle {
 }
 
 
-// A MenuBarExtra window is transient. Sheets attached to it can disappear
-// when the user interacts with controls inside Settings. Use a real window.
+// Settings must be independent of the transient MenuBarExtra panel.
+// An AppKit modal session keeps Settings open and blocks other app windows.
 @MainActor
 private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate {
     private static var current: OrionSettingsWindowPresenter?
+
     private var window: NSWindow?
+    private var modalSession: NSApplication.ModalSession?
+    private var modalTimer: Timer?
 
     static func present(vm: OrionVMController) {
         if let current, let window = current.window {
             NSApp.activate(ignoringOtherApps: true)
             window.makeKeyAndOrderFront(nil)
+            window.orderFrontRegardless()
             return
         }
+
         let presenter = OrionSettingsWindowPresenter()
         current = presenter
         presenter.open(vm: vm)
@@ -347,24 +352,61 @@ private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate {
         let content = SettingsView()
             .environmentObject(vm)
             .preferredColorScheme(.dark)
+
         let window = NSWindow(
             contentRect: NSRect(x: 0, y: 0, width: 650, height: 380),
-            styleMask: [.titled, .closable, .miniaturizable],
+            styleMask: [.titled, .closable],
             backing: .buffered,
             defer: false
         )
+
         window.title = "OrionToolbar Settings"
         window.contentViewController = NSHostingController(rootView: content)
         window.delegate = self
         window.isReleasedWhenClosed = false
         window.level = .floating
         window.center()
+
         self.window = window
+
         NSApp.activate(ignoringOtherApps: true)
         window.makeKeyAndOrderFront(nil)
+        window.orderFrontRegardless()
+
+        // Begin a non-blocking AppKit modal session.
+        // Unlike runModal(for:), this does not block SwiftUI's event loop.
+        modalSession = NSApp.beginModalSession(for: window)
+
+        modalTimer = Timer.scheduledTimer(
+            withTimeInterval: 0.05,
+            repeats: true
+        ) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self, let session = self.modalSession else {
+                    return
+                }
+
+                let response = NSApp.runModalSession(session)
+
+                if response != .continue {
+                    self.closeModalSession()
+                }
+            }
+        }
+    }
+
+    private func closeModalSession() {
+        modalTimer?.invalidate()
+        modalTimer = nil
+
+        if let session = modalSession {
+            NSApp.endModalSession(session)
+            modalSession = nil
+        }
     }
 
     func windowWillClose(_ notification: Notification) {
+        closeModalSession()
         window = nil
         Self.current = nil
     }

backups/20261023-095622-914371/OrionToolbar/OrionMenuView.swift

@@ -0,0 +1,371 @@
+import AppKit
+import SwiftUI
+
+private enum OrionStyle {
+    static let panel = Color(red: 0.105, green: 0.14, blue: 0.20)
+    static let card = Color(red: 0.15, green: 0.19, blue: 0.25)
+    static let blue = Color(red: 0.08, green: 0.39, blue: 0.91)
+    static let green = Color(red: 0.05, green: 0.88, blue: 0.49)
+    static let red = Color(red: 0.91, green: 0.19, blue: 0.23)
+    static let muted = Color(red: 0.62, green: 0.73, blue: 0.86)
+}
+
+struct OrionMenuView: View {
+    @EnvironmentObject private var vm: OrionVMController
+    @State private var showRunning = true
+    @State private var showAll = true
+    @State private var showIntegrated = true
+    @State private var pendingRemoval: ServerDefinition?
+    @State private var pendingForceStop: ParallelsVM?
+
+    private var running: [ParallelsVM] {
+        vm.discoveredVMs.filter { $0.status.lowercased() == "running" }
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header
+            Divider().overlay(.white.opacity(0.10))
+            ScrollView {
+                VStack(alignment: .leading, spacing: 15) {
+                    section(icon: "play.fill", title: "Running Virtual Machines", count: "\(running.count) running", accent: OrionStyle.green, expanded: $showRunning) {
+                        if running.isEmpty {
+                            emptyState("No running virtual machines", icon: "moon.zzz")
+                        } else {
+                            ForEach(running) { machine in
+                                runningRow(machine)
+                            }
+                        }
+                    }
+                    section(icon: "desktopcomputer", title: "All Virtual Machines", count: "\(vm.discoveredVMs.count) VMs", accent: .cyan, expanded: $showAll) {
+                        if vm.discoveredVMs.isEmpty {
+                            emptyState(vm.discovering ? "Discovering Parallels VMs…" : "No virtual machines found", icon: "desktopcomputer.trianglebadge.exclamationmark")
+                        } else {
+                            ForEach(vm.discoveredVMs) { machine in
+                                machineRow(machine)
+                            }
+                        }
+                    }
+                    section(icon: "server.rack", title: "Integrated Servers", count: "\(vm.servers.count) servers", accent: OrionStyle.blue, expanded: $showIntegrated) {
+                        if vm.servers.isEmpty {
+                            emptyState("No integrations. Add a VM using + above.", icon: "plus.circle")
+                        } else {
+                            ForEach(vm.servers) { server in
+                                integratedRow(server)
+                            }
+                        }
+                    }
+                }
+                .padding(14)
+            }
+            .frame(height: 610)
+            Divider().overlay(.white.opacity(0.10))
+            footer
+        }
+        .frame(width: 960)
+        .background(
+            LinearGradient(colors: [Color(red: 0.10, green: 0.15, blue: 0.23), Color(red: 0.075, green: 0.09, blue: 0.13)], startPoint: .topTrailing, endPoint: .bottomLeading)
+        )
+
+        .preferredColorScheme(.dark)
+        .task { await vm.discoverVMs(); await vm.refreshAll() }
+        .alert("OrionToolbar", isPresented: Binding(get: { vm.lastError != nil }, set: { if !$0 { vm.lastError = nil } })) {
+            Button("OK") { vm.lastError = nil }
+        } message: { Text(vm.lastError ?? "") }
+        .confirmationDialog("Remove server integration?", isPresented: Binding(get: { pendingRemoval != nil }, set: { if !$0 { pendingRemoval = nil } }), titleVisibility: .visible) {
+            Button("Remove Integration", role: .destructive) {
+                if let server = pendingRemoval { vm.removeDefinition(server) }
+                pendingRemoval = nil
+            }
+            Button("Cancel", role: .cancel) { pendingRemoval = nil }
+        } message: {
+            Text("The Parallels virtual machine will not be deleted.")
+        }
+        .confirmationDialog("Force stop virtual machine?", isPresented: Binding(get: { pendingForceStop != nil }, set: { if !$0 { pendingForceStop = nil } }), titleVisibility: .visible) {
+            Button("Force Stop", role: .destructive) {
+                if let machine = pendingForceStop { vm.operate(machine, action: "force-stop") }
+                pendingForceStop = nil
+            }
+            Button("Cancel", role: .cancel) { pendingForceStop = nil }
+        } message: { Text("Force Stop immediately powers off the VM and can cause data loss.") }
+    }
+
+    private var header: some View {
+        HStack(spacing: 12) {
+            Image(systemName: "server.rack")
+                .font(.system(size: 22, weight: .bold))
+                .foregroundStyle(.cyan)
+                .frame(width: 37, height: 37)
+                .background(OrionStyle.blue.opacity(0.24), in: RoundedRectangle(cornerRadius: 10))
+            Text("OrionToolbar").font(.system(size: 21, weight: .bold))
+            Circle().fill(vm.discoveredVMs.isEmpty ? Color.orange : OrionStyle.green).frame(width: 8, height: 8)
+            Text(vm.discoveredVMs.isEmpty ? "Waiting for Parallels" : "Parallels Connected")
+                .foregroundStyle(OrionStyle.muted).font(.subheadline)
+            Spacer()
+            if vm.discovering { ProgressView().controlSize(.small) }
+            Button { Task { await vm.discoverVMs(); await vm.refreshAll() } } label: {
+                Image(systemName: "arrow.clockwise").font(.system(size: 16, weight: .semibold))
+            }.buttonStyle(OrionActionStyle(tint: OrionStyle.card)).help("Refresh virtual machines")
+            Button { showSettings() } label: {
+                Image(systemName: "gearshape.fill").font(.system(size: 16))
+            }.buttonStyle(OrionActionStyle(tint: OrionStyle.card)).help("Settings")
+        }.padding(.horizontal, 17).padding(.vertical, 13)
+    }
+
+    private func section<Content: View>(icon: String, title: String, count: String, accent: Color, expanded: Binding<Bool>, @ViewBuilder content: () -> Content) -> some View {
+        VStack(spacing: 4) {
+            Button { expanded.wrappedValue.toggle() } label: {
+                HStack(spacing: 10) {
+                    Image(systemName: icon).font(.system(size: 17, weight: .bold))
+                        .foregroundStyle(accent).frame(width: 27)
+                    Text(title).font(.system(size: 16, weight: .semibold))
+                    Spacer()
+                    Text(count).font(.caption.weight(.medium))
+                        .foregroundStyle(accent)
+                        .padding(.horizontal, 10).padding(.vertical, 5)
+                        .background(accent.opacity(0.13), in: RoundedRectangle(cornerRadius: 8))
+                    Image(systemName: expanded.wrappedValue ? "chevron.up" : "chevron.down")
+                        .font(.caption.weight(.bold)).foregroundStyle(OrionStyle.muted)
+                }
+                .contentShape(Rectangle())
+                .padding(.horizontal, 11).padding(.vertical, 10)
+            }.buttonStyle(.plain)
+            if expanded.wrappedValue {
+                VStack(spacing: 3) { content() }
+                    .padding(.horizontal, 5).padding(.bottom, 7)
+            }
+        }
+        .background(OrionStyle.panel.opacity(0.92), in: RoundedRectangle(cornerRadius: 16))
+        .overlay(RoundedRectangle(cornerRadius: 16).strokeBorder(.white.opacity(0.09)))
+    }
+
+    private func emptyState(_ title: String, icon: String) -> some View {
+        Label(title, systemImage: icon)
+            .font(.subheadline).foregroundStyle(OrionStyle.muted)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(15)
+    }
+
+    private func icon(_ machine: ParallelsVM) -> some View {
+        Group {
+            if let image = vm.icon(for: machine) {
+                Image(nsImage: image).resizable().scaledToFit()
+            } else {
+                Image(systemName: machine.operatingSystem == "Windows" ? "desktopcomputer" : "server.rack")
+                    .font(.system(size: 21, weight: .medium))
+                    .foregroundStyle(.white)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                    .background(osColor(machine.operatingSystem), in: Circle())
+            }
+        }.frame(width: 36, height: 36)
+    }
+
+    private func osColor(_ os: String) -> Color {
+        switch os {
+        case "Ubuntu": return .orange
+        case "Debian": return .pink
+        case "Fedora": return .blue
+        case "CentOS": return .purple
+        case "Alpine": return .teal
+        case "Windows": return .cyan
+        default: return OrionStyle.blue
+        }
+    }
+
+    private func state(_ status: String) -> some View {
+        let s = status.lowercased()
+        let color: Color = s == "running" ? OrionStyle.green : (s == "stopped" ? OrionStyle.muted : .orange)
+        return HStack(spacing: 6) {
+            Circle().fill(color).frame(width: 8, height: 8)
+            Text(status.capitalized).font(.system(size: 12, weight: .medium))
+                .foregroundStyle(color)
+        }.frame(width: 90, alignment: .leading)
+    }
+
+    private func integrated(_ machine: ParallelsVM) -> ServerDefinition? {
+        vm.servers.first { $0.vmUUID == machine.id || $0.vmName == machine.name }
+    }
+
+    private func runningRow(_ machine: ParallelsVM) -> some View {
+        HStack(spacing: 10) {
+            icon(machine)
+            Text(machine.name).font(.system(size: 12, weight: .semibold)).lineLimit(1).frame(width: 210, alignment: .leading)
+            state(machine.status)
+            Text(machine.ipAddress.isEmpty ? "—" : machine.ipAddress)
+                .font(.system(size: 11, design: .monospaced))
+                .foregroundStyle(OrionStyle.muted).lineLimit(1).frame(width: 125, alignment: .leading)
+            Spacer(minLength: 0)
+            if let server = integrated(machine) {
+                action("SSH", "terminal", tint: OrionStyle.blue) { vm.openSSH(server) }
+                    .disabled(server.host.isEmpty || server.sshUser.isEmpty)
+                action("Mailpit", "globe", tint: OrionStyle.blue) { vm.openMailpit(server) }
+                    .disabled(server.host.isEmpty || server.mailpitPort == nil)
+            }
+            if vm.busyVMIDs.contains(machine.id) {
+                ProgressView().controlSize(.small)
+                    .frame(width: 70)
+                    .help("Waiting for Parallels to complete the operation")
+            } else {
+                action("Restart", "arrow.clockwise", tint: OrionStyle.card) { vm.operate(machine, action: "restart") }
+                action("Stop", "stop.fill", tint: OrionStyle.red) { vm.operate(machine, action: "stop") }
+            }
+            Menu {
+                Button("Force Stop", role: .destructive) { pendingForceStop = machine }
+            } label: {
+                Image(systemName: "ellipsis").frame(width: 16)
+            }.menuStyle(.borderlessButton).frame(width: 22)
+            .help("More VM actions")
+        }
+        .disabled(vm.busyVMIDs.contains(machine.id))
+        .padding(.horizontal, 10).padding(.vertical, 7)
+        .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10))
+    }
+
+    private func machineRow(_ machine: ParallelsVM) -> some View {
+        HStack(spacing: 10) {
+            icon(machine)
+            Text(machine.name).font(.system(size: 12, weight: .semibold)).lineLimit(1).frame(width: 230, alignment: .leading)
+            state(machine.status)
+            Text(machine.ipAddress.isEmpty ? "—" : machine.ipAddress)
+                .font(.system(size: 11, design: .monospaced))
+                .foregroundStyle(OrionStyle.muted).lineLimit(1)
+            Spacer(minLength: 2)
+            if vm.busyVMIDs.contains(machine.id) { ProgressView().controlSize(.small) }
+            else if machine.status.lowercased() == "running" {
+                action("Stop", "stop.fill", tint: OrionStyle.red) { vm.operate(machine, action: "stop") }
+            } else if ["suspended", "paused"].contains(machine.status.lowercased()) {
+                action("Resume", "play.fill", tint: OrionStyle.blue) { vm.operate(machine, action: "resume") }
+            } else {
+                action("Start", "play.fill", tint: OrionStyle.blue) { vm.operate(machine, action: "start") }
+            }
+            if vm.isIntegrated(machine) {
+                Image(systemName: "checkmark.circle.fill").foregroundStyle(OrionStyle.green)
+                    .frame(width: 28).help("Integrated")
+            } else {
+                Button { vm.integrate(machine) } label: {
+                    Image(systemName: "plus.circle").font(.system(size: 20))
+                }.buttonStyle(.plain).foregroundStyle(OrionStyle.muted)
+                    .frame(width: 28).help("Integrate VM")
+            }
+            Menu {
+                Button("Open in Parallels") { vm.openParallels() }
+                if machine.status.lowercased() == "running" {
+                    Button("Restart") { vm.operate(machine, action: "restart") }
+                    Button("Force Stop", role: .destructive) { pendingForceStop = machine }
+                }
+            } label: { Image(systemName: "chevron.right").foregroundStyle(OrionStyle.muted) }
+                .menuStyle(.borderlessButton).frame(width: 22)
+        }
+        .padding(.horizontal, 10).padding(.vertical, 7)
+        .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10))
+    }
+
+    private func integratedRow(_ server: ServerDefinition) -> some View {
+        let machine = vm.discoveredVMs.first { $0.id == server.vmUUID || $0.name == server.vmName }
+        let status = machine?.status ?? "unavailable"
+        return HStack(spacing: 10) {
+            if let machine { icon(machine) }
+            else { Image(systemName: "server.rack").frame(width: 36, height: 36).foregroundStyle(.cyan) }
+            Text(server.name).font(.system(size: 12, weight: .semibold)).lineLimit(1).frame(width: 185, alignment: .leading)
+            state(status)
+            Text(server.host.isEmpty ? "—" : server.host)
+                .font(.system(size: 11, design: .monospaced)).foregroundStyle(OrionStyle.muted)
+                .lineLimit(1).frame(width: 125, alignment: .leading)
+            Spacer(minLength: 0)
+            if let machine {
+                if status.lowercased() == "running" {
+                    action("Stop", "stop.fill", tint: OrionStyle.red) { vm.operate(machine, action: "stop") }
+                } else {
+                    action("Start", "play.fill", tint: OrionStyle.blue) { vm.operate(machine, action: "start") }
+                }
+            }
+            action("SSH", "terminal", tint: OrionStyle.card) { vm.openSSH(server) }
+                .disabled(status.lowercased() != "running" || server.host.isEmpty || server.sshUser.isEmpty)
+            action("Mailpit", "globe", tint: OrionStyle.card) { vm.openMailpit(server) }
+                .disabled(status.lowercased() != "running" || server.host.isEmpty || server.mailpitPort == nil)
+            action("Remove", "trash", tint: OrionStyle.card) { pendingRemoval = server }
+        }
+        .disabled(machine.map { vm.busyVMIDs.contains($0.id) } ?? false)
+        .padding(.horizontal, 10).padding(.vertical, 7)
+        .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10))
+    }
+
+    private func action(_ title: String, _ symbol: String, tint: Color, perform: @escaping () -> Void) -> some View {
+        Button(action: perform) {
+            Label(title, systemImage: symbol)
+                .font(.system(size: 11, weight: .semibold))
+                .lineLimit(1)
+                .frame(minWidth: 48)
+        }.buttonStyle(OrionActionStyle(tint: tint))
+    }
+
+    private var footer: some View {
+        HStack {
+            action("Open Parallels", "macwindow", tint: OrionStyle.card) { vm.openParallels() }
+            Spacer()
+            action("Settings…", "gearshape", tint: OrionStyle.card) { showSettings() }
+            action("Quit", "power", tint: OrionStyle.card) { NSApplication.shared.terminate(nil) }
+        }.padding(.horizontal, 17).padding(.vertical, 12)
+    }
+
+    private func showSettings() {
+        OrionSettingsWindowPresenter.present(vm: vm)
+    }
+}
+
+private struct OrionActionStyle: ButtonStyle {
+    let tint: Color
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+            .foregroundStyle(.white)
+            .padding(.horizontal, 8).padding(.vertical, 7)
+            .background(tint.opacity(configuration.isPressed ? 0.65 : 1), in: RoundedRectangle(cornerRadius: 8))
+            .opacity(configuration.isPressed ? 0.8 : 1)
+    }
+}
+
+
+// A MenuBarExtra window is transient. Sheets attached to it can disappear
+// when the user interacts with controls inside Settings. Use a real window.
+@MainActor
+private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate {
+    private static var current: OrionSettingsWindowPresenter?
+    private var window: NSWindow?
+
+    static func present(vm: OrionVMController) {
+        if let current, let window = current.window {
+            NSApp.activate(ignoringOtherApps: true)
+            window.makeKeyAndOrderFront(nil)
+            return
+        }
+        let presenter = OrionSettingsWindowPresenter()
+        current = presenter
+        presenter.open(vm: vm)
+    }
+
+    private func open(vm: OrionVMController) {
+        let content = SettingsView()
+            .environmentObject(vm)
+            .preferredColorScheme(.dark)
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 650, height: 380),
+            styleMask: [.titled, .closable, .miniaturizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = "OrionToolbar Settings"
+        window.contentViewController = NSHostingController(rootView: content)
+        window.delegate = self
+        window.isReleasedWhenClosed = false
+        window.level = .floating
+        window.center()
+        self.window = window
+        NSApp.activate(ignoringOtherApps: true)
+        window.makeKeyAndOrderFront(nil)
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        window = nil
+        Self.current = nil
+    }
+}

patches/oriontoolbar_settings_modal_controller.py

@@ -0,0 +1,111 @@
+from pathlib import Path
+from datetime import datetime
+import shutil
+
+root = Path.cwd()
+source_file = root / "OrionToolbar/OrionMenuView.swift"
+controller_file = root / "OrionToolbar/OrionSettingsModal.swift"
+
+if not source_file.exists():
+    raise SystemExit("ERROR: OrionMenuView.swift not found")
+
+source = source_file.read_text()
+
+old = """    private func showSettings() {
+        openSettings()
+        NSApplication.shared.activate(ignoringOtherApps: true)
+    }"""
+
+new = """    private func showSettings() {
+        OrionSettingsModal.shared.present(vm: vm)
+    }"""
+
+if old not in source:
+    raise SystemExit(
+        "ERROR: Settings implementation differs from expected source. "
+        "No files changed. Inspect showSettings() before patching."
+    )
+
+timestamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+backup_dir = root / "backups" / timestamp
+
+for path in [source_file, controller_file]:
+    if path.exists():
+        destination = backup_dir / path.relative_to(root)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(path, destination)
+
+controller = r'''import AppKit
+import SwiftUI
+
+@MainActor
+final class OrionSettingsModal: NSObject, NSWindowDelegate {
+    static let shared = OrionSettingsModal()
+
+    private var window: NSWindow?
+    private var modalRunning = false
+
+    func present(vm: OrionVMController) {
+        if let window {
+            NSApplication.shared.activate(ignoringOtherApps: true)
+            window.makeKeyAndOrderFront(nil)
+            window.orderFrontRegardless()
+            return
+        }
+
+        let content = SettingsView()
+            .environmentObject(vm)
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 650, height: 380),
+            styleMask: [.titled, .closable, .miniaturizable],
+            backing: .buffered,
+            defer: false
+        )
+
+        window.title = "OrionToolbar Settings"
+        window.contentView = NSHostingView(rootView: content)
+        window.center()
+        window.level = .floating
+        window.isReleasedWhenClosed = false
+        window.delegate = self
+
+        self.window = window
+
+        NSApplication.shared.activate(ignoringOtherApps: true)
+        window.makeKeyAndOrderFront(nil)
+        window.orderFrontRegardless()
+
+        DispatchQueue.main.async { [weak self, weak window] in
+            guard let self,
+                  let window,
+                  self.window === window,
+                  !self.modalRunning else {
+                return
+            }
+
+            self.modalRunning = true
+            NSApplication.shared.runModal(for: window)
+            self.modalRunning = false
+        }
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        if modalRunning {
+            NSApplication.shared.stopModal()
+        }
+
+        window = nil
+    }
+}
+'''
+
+source_file.write_text(source.replace(old, new, 1))
+controller_file.write_text(controller)
+
+print("UPDATED:", source_file.relative_to(root))
+print("CREATED:", controller_file.relative_to(root))
+print("BACKUP:", backup_dir)
+print()
+print("IMPORTANT: Ensure OrionSettingsModal.swift is included")
+print("in the OrionToolbar Xcode application target.")

patches/oriontoolbar_settings_modal_fix.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+from datetime import datetime
+import shutil
+
+root = Path.cwd()
+path = root / "OrionToolbar/OrionMenuView.swift"
+
+if not path.is_file():
+    raise SystemExit("ERROR: OrionMenuView.swift not found.")
+
+source = path.read_text()
+
+marker = "// A MenuBarExtra window is transient."
+
+if marker not in source:
+    raise SystemExit(
+        "ERROR: Existing Settings presenter not found. "
+        "No changes made."
+    )
+
+# The presenter is the final declaration in the file.
+prefix, existing = source.split(marker, 1)
+
+if "private final class OrionSettingsWindowPresenter" not in existing:
+    raise SystemExit(
+        "ERROR: Unexpected Settings presenter. No changes made."
+    )
+
+replacement = r'''// Settings must be independent of the transient MenuBarExtra panel.
+// An AppKit modal session keeps Settings open and blocks other app windows.
+@MainActor
+private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate {
+    private static var current: OrionSettingsWindowPresenter?
+
+    private var window: NSWindow?
+    private var modalSession: NSApplication.ModalSession?
+    private var modalTimer: Timer?
+
+    static func present(vm: OrionVMController) {
+        if let current, let window = current.window {
+            NSApp.activate(ignoringOtherApps: true)
+            window.makeKeyAndOrderFront(nil)
+            window.orderFrontRegardless()
+            return
+        }
+
+        let presenter = OrionSettingsWindowPresenter()
+        current = presenter
+        presenter.open(vm: vm)
+    }
+
+    private func open(vm: OrionVMController) {
+        let content = SettingsView()
+            .environmentObject(vm)
+            .preferredColorScheme(.dark)
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 650, height: 380),
+            styleMask: [.titled, .closable],
+            backing: .buffered,
+            defer: false
+        )
+
+        window.title = "OrionToolbar Settings"
+        window.contentViewController = NSHostingController(rootView: content)
+        window.delegate = self
+        window.isReleasedWhenClosed = false
+        window.level = .floating
+        window.center()
+
+        self.window = window
+
+        NSApp.activate(ignoringOtherApps: true)
+        window.makeKeyAndOrderFront(nil)
+        window.orderFrontRegardless()
+
+        // Begin a non-blocking AppKit modal session.
+        // Unlike runModal(for:), this does not block SwiftUI's event loop.
+        modalSession = NSApp.beginModalSession(for: window)
+
+        modalTimer = Timer.scheduledTimer(
+            withTimeInterval: 0.05,
+            repeats: true
+        ) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self, let session = self.modalSession else {
+                    return
+                }
+
+                let response = NSApp.runModalSession(session)
+
+                if response != .continue {
+                    self.closeModalSession()
+                }
+            }
+        }
+    }
+
+    private func closeModalSession() {
+        modalTimer?.invalidate()
+        modalTimer = nil
+
+        if let session = modalSession {
+            NSApp.endModalSession(session)
+            modalSession = nil
+        }
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        closeModalSession()
+        window = nil
+        Self.current = nil
+    }
+}
+'''
+
+backup_dir = (
+    root / "backups"
+    / datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+)
+
+backup = backup_dir / path.relative_to(root)
+backup.parent.mkdir(parents=True, exist_ok=True)
+shutil.copy2(path, backup)
+
+path.write_text(prefix + replacement)
+
+print("UPDATED:", path.relative_to(root))
+print("BACKUP:", backup.relative_to(root))
+print("Settings now uses an AppKit modal session.")