updates

.idea/OrionToolbar.iml

@@ -1,13 +1,2 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<module type="EMPTY_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/build" />
-      <excludeFolder url="file://$MODULE_DIR$/build-logs" />
-      <excludeFolder url="file://$MODULE_DIR$/build/OrionToolbar.xcarchive/dSYMs" />
-      <excludeFolder url="file://$MODULE_DIR$/scripts/build" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
+<module classpath="CIDR" type="EMPTY_MODULE" version="4" />

OrionToolbar/OrionMenuView.swift

@@ -24,6 +24,8 @@ struct OrionMenuView: View {
             Divider()
             ScrollView {
                 VStack(alignment: .leading, spacing: 10) {
+                    runningSection
+                    Divider()
                     Text("PARALLELS VIRTUAL MACHINES").font(.caption.bold()).foregroundStyle(.secondary)
                     if vm.discoveredVMs.isEmpty {
                         Text(vm.discovering ? "Discovering virtual machines…" : "No VMs found. Use Refresh to try again.")
@@ -84,6 +86,51 @@ struct OrionMenuView: View {
         message: { Text(vm.lastError ?? "") }
     }
 
+    private var runningSection: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Label("RUNNING VIRTUAL MACHINES", systemImage: "play.circle.fill")
+                    .font(.caption.bold())
+                Spacer()
+                Text("\(vm.runningVMs.count) running")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+            if vm.runningVMs.isEmpty {
+                Text("No running VMs detected")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .padding(.vertical, 8)
+            }
+            ForEach(vm.runningVMs) { machine in
+                VStack(alignment: .leading, spacing: 6) {
+                    HStack {
+                        vmIcon(machine)
+                        VStack(alignment: .leading, spacing: 2) {
+                            Text(machine.name).fontWeight(.medium)
+                            Text("Running").font(.caption).foregroundStyle(.green)
+                        }
+                        Spacer()
+                        if vm.busyVMIDs.contains(machine.id) {
+                            ProgressView().controlSize(.small)
+                        }
+                    }
+                    HStack {
+                        Button("Stop") { vm.operate(machine, action: "stop") }
+                        Button("Restart") { vm.operate(machine, action: "restart") }
+                        Button("Force Stop", role: .destructive) {
+                            vm.operate(machine, action: "force-stop")
+                        }
+                    }
+                    .controlSize(.small)
+                    .disabled(vm.busyVMIDs.contains(machine.id))
+                }
+                .padding(9)
+                .background(.quaternary.opacity(0.3), in: RoundedRectangle(cornerRadius: 8))
+            }
+        }
+    }
+
     private func vmRow(_ machine: ParallelsVM) -> some View {
         HStack(spacing: 9) {
             Toggle("", isOn: Binding(
@@ -107,6 +154,9 @@ struct OrionMenuView: View {
                 Button("Stop") { vm.operate(machine, action: "stop") }
             } else if machine.status == "suspended" {
                 Button("Resume") { vm.operate(machine, action: "resume") }
+            } else {
+                Button("Start") { vm.operate(machine, action: "start") }
+                    .help("Try starting VM (Parallels reports: \(machine.status))")
             }
             if vm.isIntegrated(machine) {
                 Image(systemName: "checkmark.circle.fill").foregroundStyle(.green).help("Integrated")
@@ -155,6 +205,11 @@ struct OrionMenuView: View {
                         .disabled(status != .running || server.host.isEmpty || server.sshUser.isEmpty)
                     Button("Mailpit") { vm.openMailpit(server) }
                         .disabled(status != .running || server.host.isEmpty || server.mailpitPort == nil)
+                    Button("Remove", role: .destructive) {
+                        expandedServers.remove(server.id)
+                        vm.removeDefinition(server)
+                    }
+                    .help("Remove integration only; the VM is not deleted")
                 }.padding(.leading, 30)
             }
         }.padding(.vertical, 4)

OrionToolbar/OrionMenuView.swift.bak-20261023-083234

@@ -0,0 +1,162 @@
+import AppKit
+import SwiftUI
+
+struct OrionMenuView: View {
+    @EnvironmentObject private var vm: OrionVMController
+    @Environment(\.openSettings) private var openSettings
+    @State private var expanded: Set<String> = []
+    @State private var expandedServers: Set<UUID> = []
+
+    private var groups: [String] {
+        let order = ["Windows", "Ubuntu", "Debian", "Fedora", "CentOS", "Alpine", "Oracle Linux", "Rocky Linux", "AlmaLinux", "Arch Linux", "Gentoo", "FreeBSD", "Other"]
+        return order.filter { os in vm.discoveredVMs.contains { $0.operatingSystem == os } }
+    }
+
+    var body: some View {
+        VStack(spacing: 0) {
+            HStack {
+                Label("OrionToolbar", systemImage: "server.rack").font(.headline)
+                Spacer()
+                if vm.discovering { ProgressView().controlSize(.small) }
+                Button { Task { await vm.discoverVMs() } } label: { Image(systemName: "arrow.clockwise") }
+                    .buttonStyle(.borderless).help("Refresh virtual machines")
+            }.padding(14)
+            Divider()
+            ScrollView {
+                VStack(alignment: .leading, spacing: 10) {
+                    Text("PARALLELS VIRTUAL MACHINES").font(.caption.bold()).foregroundStyle(.secondary)
+                    if vm.discoveredVMs.isEmpty {
+                        Text(vm.discovering ? "Discovering virtual machines…" : "No VMs found. Use Refresh to try again.")
+                            .foregroundStyle(.secondary).padding(.vertical, 18)
+                    }
+                    ForEach(groups, id: \.self) { os in
+                        VStack(alignment: .leading, spacing: 4) {
+                            Button {
+                                if !expanded.insert(os).inserted { expanded.remove(os) }
+                            } label: {
+                                HStack {
+                                    Image(systemName: expanded.contains(os) ? "chevron.down" : "chevron.right")
+                                        .frame(width: 14)
+                                    Text(os).fontWeight(.semibold)
+                                    Spacer()
+                                    Text("\(vm.discoveredVMs.filter { $0.operatingSystem == os }.count)")
+                                        .foregroundStyle(.secondary)
+                                }.contentShape(Rectangle()).padding(.vertical, 5)
+                            }.buttonStyle(.plain)
+                            if expanded.contains(os) {
+                                ForEach(vm.discoveredVMs.filter { $0.operatingSystem == os }) { machine in
+                                    vmRow(machine)
+                                }
+                            }
+                        }
+                    }
+                    if !vm.discoveredVMs.isEmpty {
+                        HStack {
+                            Button("Select All") { vm.selectAllVMs() }
+                            Button("Clear") { vm.clearVMSelection() }
+                            Spacer()
+                            Button("Integrate Selected") { vm.integrateSelectedVMs() }
+                                .disabled(vm.selectedVMIDs.isEmpty)
+                        }.font(.caption)
+                    }
+                    Divider()
+                    Text("INTEGRATED SERVERS").font(.caption.bold()).foregroundStyle(.secondary)
+                    ForEach(vm.servers) { server in serverRow(server) }
+                }.padding(14)
+            }.frame(height: 490)
+            Divider()
+            HStack {
+                Button("Parallels") { vm.openParallels() }
+                Spacer()
+                Button("Settings…") {
+                    openSettings()
+                    NSApplication.shared.activate(ignoringOtherApps: true)
+                }
+                Button("Quit") { NSApplication.shared.terminate(nil) }
+            }.padding(14)
+        }
+        .frame(width: 460)
+        .task { await vm.discoverVMs() }
+        .alert("OrionToolbar", isPresented: Binding(
+            get: { vm.lastError != nil },
+            set: { if !$0 { vm.lastError = nil } }
+        )) { Button("OK") { vm.lastError = nil } }
+        message: { Text(vm.lastError ?? "") }
+    }
+
+    private func vmRow(_ machine: ParallelsVM) -> some View {
+        HStack(spacing: 9) {
+            Toggle("", isOn: Binding(
+                get: { vm.selectedVMIDs.contains(machine.id) },
+                set: { selected in
+                    if selected { vm.selectedVMIDs.insert(machine.id) }
+                    else { vm.selectedVMIDs.remove(machine.id) }
+                }
+            )).labelsHidden().toggleStyle(.checkbox)
+            vmIcon(machine)
+            VStack(alignment: .leading, spacing: 2) {
+                Text(machine.name).lineLimit(1)
+                Text(machine.status.capitalized).font(.caption)
+                    .foregroundStyle(machine.status == "running" ? Color.green : Color.secondary)
+            }
+            Spacer(minLength: 4)
+            if vm.busyVMIDs.contains(machine.id) { ProgressView().controlSize(.small) }
+            else if machine.status == "stopped" {
+                Button("Start") { vm.operate(machine, action: "start") }
+            } else if machine.status == "running" {
+                Button("Stop") { vm.operate(machine, action: "stop") }
+            } else if machine.status == "suspended" {
+                Button("Resume") { vm.operate(machine, action: "resume") }
+            }
+            if vm.isIntegrated(machine) {
+                Image(systemName: "checkmark.circle.fill").foregroundStyle(.green).help("Integrated")
+            } else {
+                Button { vm.integrate(machine) } label: { Image(systemName: "plus.circle") }
+                    .help("Integrate VM")
+            }
+        }.padding(.leading, 20).padding(.vertical, 4)
+    }
+
+    private func vmIcon(_ machine: ParallelsVM) -> some View {
+        Group {
+            if let icon = vm.icon(for: machine) {
+                Image(nsImage: icon).resizable().scaledToFit()
+            } else {
+                Image(systemName: machine.symbol).resizable().scaledToFit().padding(4)
+            }
+        }.frame(width: 30, height: 30)
+    }
+
+    private func serverRow(_ server: ServerDefinition) -> some View {
+        let status = vm.status(for: server)
+        return VStack(alignment: .leading, spacing: 6) {
+            Button {
+                if !expandedServers.insert(server.id).inserted { expandedServers.remove(server.id) }
+            } label: {
+                HStack {
+                    Image(systemName: expandedServers.contains(server.id) ? "chevron.down" : "chevron.right")
+                    if let icon = vm.icon(for: server) {
+                        Image(nsImage: icon).resizable().scaledToFit().frame(width: 25, height: 25)
+                    } else { Image(systemName: "server.rack") }
+                    Text(server.name)
+                    Spacer()
+                    Text(status.title).foregroundStyle(.secondary)
+                }.contentShape(Rectangle())
+            }.buttonStyle(.plain)
+            if expandedServers.contains(server.id) {
+                HStack {
+                    if status == .stopped {
+                        Button("Start") { vm.start(server) }
+                    } else if status == .running {
+                        Button("Stop") { vm.stop(server) }
+                        Button("Restart") { vm.restart(server) }
+                    }
+                    Button("SSH") { vm.openSSH(server) }
+                        .disabled(status != .running || server.host.isEmpty || server.sshUser.isEmpty)
+                    Button("Mailpit") { vm.openMailpit(server) }
+                        .disabled(status != .running || server.host.isEmpty || server.mailpitPort == nil)
+                }.padding(.leading, 30)
+            }
+        }.padding(.vertical, 4)
+    }
+}

OrionToolbar/OrionVMController.swift

@@ -77,7 +77,7 @@ final class OrionVMController: ObservableObject {
     private let defaultsKey = "serverDefinitions.v2"
 
     init() {
-        if let data = UserDefaults.standard.data(forKey: defaultsKey), let saved = try? JSONDecoder().decode([ServerDefinition].self, from: data), !saved.isEmpty { servers = saved }
+        if let data = UserDefaults.standard.data(forKey: defaultsKey), let saved = try? JSONDecoder().decode([ServerDefinition].self, from: data) { servers = saved }
         else { servers = [.orion] }
         Task {
             await discoverVMs()
@@ -227,16 +227,34 @@ final class OrionVMController: ObservableObject {
     func update(_ server: ServerDefinition) { if let i = servers.firstIndex(where: { $0.id == server.id }) { servers[i] = server; Task { await refreshStatus(server) } } }
     func delete(at offsets: IndexSet) { for i in offsets { statuses[servers[i].id] = nil }; servers.remove(atOffsets: offsets) }
 
-    func refreshAll() async { for server in servers { await refreshStatus(server) } }
+    func refreshAll() async {
+        for server in servers { await refreshStatus(server) }
+    }
+
     func refreshStatus(_ server: ServerDefinition) async {
         guard !isBusy(server) else { return }
-        do {
-            let output = try await runPrlctl(["status", server.vmUUID ?? server.vmName]); let value = output.lowercased()
-            if value.contains("running") { statuses[server.id] = .running }
-            else if value.contains("stopped") { statuses[server.id] = .stopped }
-            else if value.contains("suspended") || value.contains("paused") { statuses[server.id] = .suspended }
-            else { statuses[server.id] = .unavailable(output.trimmingCharacters(in: .whitespacesAndNewlines)) }
-        } catch { statuses[server.id] = .unavailable(error.localizedDescription) }
+        guard let machine = discoveredVMs.first(where: {
+            $0.id == server.vmUUID || $0.name == server.vmName
+        }) else {
+            statuses[server.id] = .unavailable("VM not found in Parallels")
+            return
+        }
+        switch machine.status.lowercased() {
+        case "running": statuses[server.id] = .running
+        case "stopped": statuses[server.id] = .stopped
+        case "suspended", "paused": statuses[server.id] = .suspended
+        default: statuses[server.id] = .unavailable(machine.status)
+        }
+    }
+
+    func removeDefinition(_ server: ServerDefinition) {
+        servers.removeAll { $0.id == server.id }
+        statuses.removeValue(forKey: server.id)
+        busyServers.remove(server.id)
+    }
+
+    var runningVMs: [ParallelsVM] {
+        discoveredVMs.filter { $0.status.lowercased() == "running" }
     }
 
     func start(_ s: ServerDefinition) { perform(["start", s.vmUUID ?? s.vmName], server: s) }
@@ -254,7 +272,10 @@ final class OrionVMController: ObservableObject {
         busyVMIDs.insert(machine.id)
         lastError = nil
         Task {
-            do { _ = try await runPrlctl([action, machine.id]) }
+            let arguments = action == "force-stop"
+                ? ["stop", machine.id, "--kill"]
+                : [action, machine.id]
+            do { _ = try await runPrlctl(arguments) }
             catch { lastError = error.localizedDescription }
             busyVMIDs.remove(machine.id)
             await discoverVMs()

OrionToolbar/OrionVMController.swift.bak-20261023-083234

@@ -0,0 +1,337 @@
+import AppKit
+import Foundation
+
+struct ServerDefinition: Identifiable, Codable, Hashable {
+    var id = UUID()
+    var name: String
+    var vmName: String
+    var vmUUID: String? = nil
+    var host: String
+    var sshUser: String
+    var sshPort: Int = 22
+    var sshIdentityFile: String = ""
+    var mailpitPort: Int?
+
+    static let orion = ServerDefinition(name: "Orion", vmName: "Ubuntu Linux Server", host: "10.211.55.100", sshUser: "sysadmin", sshPort: 22, sshIdentityFile: "", mailpitPort: 8025)
+}
+
+
+struct ParallelsVM: Identifiable, Hashable {
+    let id: String
+    let name: String
+    let status: String
+    let ipAddress: String
+    let operatingSystem: String
+    var bundlePath: String?
+
+    var symbol: String {
+        switch operatingSystem {
+        case "Windows": return "desktopcomputer"
+        case "Ubuntu": return "server.rack"
+        case "Debian": return "server.rack"
+        case "Fedora": return "server.rack"
+        case "CentOS": return "server.rack"
+        case "Alpine": return "server.rack"
+        case "Oracle Linux": return "server.rack"
+        default: return "desktopcomputer"
+        }
+    }
+
+    static func detectOS(_ name: String) -> String {
+        let value = name.lowercased()
+
+        if value.contains("windows") { return "Windows" }
+        if value.contains("ubuntu") { return "Ubuntu" }
+        if value.contains("debian") { return "Debian" }
+        if value.contains("fedora") { return "Fedora" }
+        if value.contains("centos") { return "CentOS" }
+        if value.contains("alpine") { return "Alpine" }
+        if value.contains("oracle") { return "Oracle Linux" }
+        if value.contains("rocky") { return "Rocky Linux" }
+        if value.contains("alma") { return "AlmaLinux" }
+        if value.contains("arch") { return "Arch Linux" }
+        if value.contains("gentoo") { return "Gentoo" }
+        if value.contains("freebsd") { return "FreeBSD" }
+
+        return "Other"
+    }
+}
+
+@MainActor
+final class OrionVMController: ObservableObject {
+    enum VMStatus: Equatable {
+        case checking, running, stopped, suspended, transitioning, unavailable(String)
+        var title: String { switch self { case .checking: "Checking…"; case .running: "Running"; case .stopped: "Stopped"; case .suspended: "Suspended"; case .transitioning: "Working…"; case .unavailable: "Unavailable" } }
+        var symbolName: String { switch self { case .running: "server.rack"; case .stopped: "power"; case .suspended: "pause.circle"; case .transitioning, .checking: "arrow.triangle.2.circlepath"; case .unavailable: "exclamationmark.triangle" } }
+    }
+
+    @Published var servers: [ServerDefinition] { didSet { saveServers() } }
+    @Published var statuses: [UUID: VMStatus] = [:]
+    @Published var busyServers: Set<UUID> = []
+    @Published var lastError: String?
+    @Published var discoveredVMs: [ParallelsVM] = []
+    @Published var selectedVMIDs: Set<String> = []
+    @Published var discovering = false
+    @Published var busyVMIDs: Set<String> = []
+    private var timer: Timer?
+    private let defaultsKey = "serverDefinitions.v2"
+
+    init() {
+        if let data = UserDefaults.standard.data(forKey: defaultsKey), let saved = try? JSONDecoder().decode([ServerDefinition].self, from: data), !saved.isEmpty { servers = saved }
+        else { servers = [.orion] }
+        Task {
+            await discoverVMs()
+            await refreshAll()
+        }
+        timer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { [weak self] _ in Task { @MainActor in guard let self else { return }; await self.discoverVMs(); await self.refreshAll() } }
+    }
+    deinit { timer?.invalidate() }
+
+
+    func discoverVMs() async {
+        guard !discovering else { return }
+
+        discovering = true
+        defer { discovering = false }
+
+        do {
+            let output = try await runPrlctl(["list", "-a", "-j"])
+
+            guard let data = output.data(using: .utf8),
+                  let records = try JSONSerialization.jsonObject(
+                    with: data
+                  ) as? [[String: Any]] else {
+                throw OrionError.commandFailed(
+                    "Invalid Parallels VM discovery response."
+                )
+            }
+
+            discoveredVMs = records.compactMap { record in
+                guard let uuid = record["uuid"] as? String,
+                      let name = record["name"] as? String else {
+                    return nil
+                }
+
+                let status = record["status"] as? String ?? "unknown"
+                let ip = record["ip_configured"] as? String ?? ""
+
+                return ParallelsVM(
+                    id: uuid,
+                    name: name,
+                    status: status,
+                    ipAddress: ip == "-" ? "" : ip,
+                    operatingSystem: ParallelsVM.detectOS(name),
+                    bundlePath: nil
+                )
+            }
+            .sorted {
+                $0.name.localizedStandardCompare($1.name)
+                    == .orderedAscending
+            }
+
+            // Resolve Parallels VM bundles without requiring the guest to run.
+            for i in discoveredVMs.indices {
+                if let detail = try? await runPrlctl(["list", "-i", discoveredVMs[i].id]) {
+                    let pattern = #"(?m)^\s*Home:\s*(.+?\.pvm)\s*$"#
+                    if let range = detail.range(of: pattern, options: .regularExpression) {
+                        let line = String(detail[range.lowerBound..<range.upperBound])
+                        let path = line.replacingOccurrences(of: #"^\s*Home:\s*"#, with: "", options: .regularExpression)
+                        discoveredVMs[i].bundlePath = path.trimmingCharacters(in: .whitespacesAndNewlines)
+                    }
+                }
+            }
+            // Keep selections only for VMs still present.
+            let available = Set(discoveredVMs.map(\.id))
+            selectedVMIDs.formIntersection(available)
+
+            // Associate existing configurations with discovered VMs.
+            // This preserves the original Orion configuration.
+            for machine in discoveredVMs {
+                guard let index = servers.firstIndex(where: {
+                    $0.vmUUID == machine.id ||
+                    ($0.vmUUID == nil && $0.vmName == machine.name)
+                }) else {
+                    continue
+                }
+
+                if servers[index].vmUUID == nil {
+                    servers[index].vmUUID = machine.id
+                }
+            }
+
+        } catch {
+            lastError = error.localizedDescription
+        }
+    }
+
+    func isIntegrated(_ machine: ParallelsVM) -> Bool {
+        servers.contains {
+            $0.vmUUID == machine.id ||
+            ($0.vmUUID == nil && $0.vmName == machine.name)
+        }
+    }
+
+    func toggleSelection(_ machine: ParallelsVM) {
+        if selectedVMIDs.contains(machine.id) {
+            selectedVMIDs.remove(machine.id)
+        } else {
+            selectedVMIDs.insert(machine.id)
+        }
+    }
+
+    func selectAllVMs() {
+        selectedVMIDs = Set(discoveredVMs.map(\.id))
+    }
+
+    func clearVMSelection() {
+        selectedVMIDs.removeAll()
+    }
+
+    func integrateSelectedVMs() {
+        let selected = discoveredVMs.filter {
+            selectedVMIDs.contains($0.id)
+        }
+
+        for machine in selected {
+            guard !isIntegrated(machine) else { continue }
+
+            let server = ServerDefinition(
+                name: machine.name,
+                vmName: machine.name,
+                vmUUID: machine.id,
+                host: machine.ipAddress,
+                sshUser: "sysadmin",
+                sshPort: 22,
+                sshIdentityFile: "",
+                mailpitPort: nil
+            )
+
+            add(server)
+        }
+
+        selectedVMIDs.removeAll()
+    }
+
+    func icon(for machine: ParallelsVM) -> NSImage? {
+        guard let path = machine.bundlePath,
+              FileManager.default.fileExists(atPath: path) else {
+            return nil
+        }
+
+        return NSWorkspace.shared.icon(forFile: path)
+    }
+
+    func status(for server: ServerDefinition) -> VMStatus { statuses[server.id] ?? .checking }
+    func isBusy(_ server: ServerDefinition) -> Bool { busyServers.contains(server.id) }
+    func add(_ server: ServerDefinition) { servers.append(server); Task { await refreshStatus(server) } }
+    func update(_ server: ServerDefinition) { if let i = servers.firstIndex(where: { $0.id == server.id }) { servers[i] = server; Task { await refreshStatus(server) } } }
+    func delete(at offsets: IndexSet) { for i in offsets { statuses[servers[i].id] = nil }; servers.remove(atOffsets: offsets) }
+
+    func refreshAll() async { for server in servers { await refreshStatus(server) } }
+    func refreshStatus(_ server: ServerDefinition) async {
+        guard !isBusy(server) else { return }
+        do {
+            let output = try await runPrlctl(["status", server.vmUUID ?? server.vmName]); let value = output.lowercased()
+            if value.contains("running") { statuses[server.id] = .running }
+            else if value.contains("stopped") { statuses[server.id] = .stopped }
+            else if value.contains("suspended") || value.contains("paused") { statuses[server.id] = .suspended }
+            else { statuses[server.id] = .unavailable(output.trimmingCharacters(in: .whitespacesAndNewlines)) }
+        } catch { statuses[server.id] = .unavailable(error.localizedDescription) }
+    }
+
+    func start(_ s: ServerDefinition) { perform(["start", s.vmUUID ?? s.vmName], server: s) }
+    func stop(_ s: ServerDefinition) { perform(["stop", s.vmUUID ?? s.vmName], server: s) }
+    func restart(_ s: ServerDefinition) { perform(["restart", s.vmUUID ?? s.vmName], server: s) }
+    func forceStop(_ s: ServerDefinition) { perform(["stop", s.vmUUID ?? s.vmName, "--kill"], server: s) }
+
+    private func perform(_ arguments: [String], server: ServerDefinition) {
+        guard !isBusy(server) else { return }; busyServers.insert(server.id); statuses[server.id] = .transitioning; lastError = nil
+        Task { do { _ = try await runPrlctl(arguments) } catch { lastError = error.localizedDescription }; busyServers.remove(server.id); try? await Task.sleep(for: .seconds(1)); await refreshStatus(server) }
+    }
+
+    func operate(_ machine: ParallelsVM, action: String) {
+        guard !busyVMIDs.contains(machine.id) else { return }
+        busyVMIDs.insert(machine.id)
+        lastError = nil
+        Task {
+            do { _ = try await runPrlctl([action, machine.id]) }
+            catch { lastError = error.localizedDescription }
+            busyVMIDs.remove(machine.id)
+            await discoverVMs()
+            await refreshAll()
+        }
+    }
+
+    func integrate(_ machine: ParallelsVM) {
+        guard !isIntegrated(machine) else { return }
+        add(ServerDefinition(name: machine.name, vmName: machine.name,
+            vmUUID: machine.id, host: machine.ipAddress, sshUser: "",
+            sshPort: 22, sshIdentityFile: "", mailpitPort: nil))
+    }
+
+    func icon(for server: ServerDefinition) -> NSImage? {
+        guard let machine = discoveredVMs.first(where: {
+            $0.id == server.vmUUID || $0.name == server.vmName
+        }) else { return nil }
+        return icon(for: machine)
+    }
+
+    func openSSH(_ s: ServerDefinition) {
+        let userHost = "\(s.sshUser)@\(s.host)"
+        var command = "/usr/bin/ssh -p \(s.sshPort)"
+        let identity = s.sshIdentityFile.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !identity.isEmpty {
+            command += " -i \(shellQuote((identity as NSString).expandingTildeInPath))"
+        }
+        command += " \(shellQuote(userHost))"
+
+        do {
+            // Terminal reliably opens executable .command files without requiring
+            // Apple Events/Automation permission from this menu-bar application.
+            let directory = FileManager.default.temporaryDirectory
+                .appendingPathComponent("OrionToolbar", isDirectory: true)
+            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+
+            let safeName = s.name.replacingOccurrences(of: "/", with: "-")
+            let scriptURL = directory.appendingPathComponent("SSH-\(safeName).command")
+            let script = """
+            #!/bin/zsh
+            clear
+            echo "Connecting to \(s.name) (\(userHost))..."
+            exec \(command)
+            """
+            try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+            try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: scriptURL.path)
+
+            guard let terminalURL = NSWorkspace.shared.urlForApplication(withBundleIdentifier: "com.apple.Terminal") else {
+                lastError = "Terminal.app could not be found."
+                return
+            }
+
+            let configuration = NSWorkspace.OpenConfiguration()
+            configuration.activates = true
+            NSWorkspace.shared.open([scriptURL], withApplicationAt: terminalURL, configuration: configuration) { _, error in
+                Task { @MainActor in
+                    if let error { self.lastError = "Could not open Terminal: \(error.localizedDescription)" }
+                }
+            }
+        } catch {
+            lastError = "Could not create SSH launcher: \(error.localizedDescription)"
+        }
+    }
+
+    private func shellQuote(_ value: String) -> String {
+        "'" + value.replacingOccurrences(of: "'", with: "'\"'\"'") + "'"
+    }
+    func openMailpit(_ s: ServerDefinition) { if let p = s.mailpitPort, let url = URL(string: "http://\(s.host):\(p)") { NSWorkspace.shared.open(url) } }
+    func openParallels() { NSWorkspace.shared.openApplication(at: URL(fileURLWithPath: "/Applications/Parallels Desktop.app"), configuration: .init()) }
+
+    private func saveServers() { if let data = try? JSONEncoder().encode(servers) { UserDefaults.standard.set(data, forKey: defaultsKey) } }
+    private func prlctlURL() -> URL? { ["/usr/local/bin/prlctl", "/Applications/Parallels Desktop.app/Contents/MacOS/prlctl"].map(URL.init(fileURLWithPath:)).first { FileManager.default.isExecutableFile(atPath: $0.path) } }
+    private func runPrlctl(_ arguments: [String]) async throws -> String {
+        guard let executable = prlctlURL() else { throw OrionError.prlctlNotFound }
+        return try await Task.detached(priority: .userInitiated) { let p = Process(); let pipe = Pipe(); p.executableURL = executable; p.arguments = arguments; p.standardOutput = pipe; p.standardError = pipe; try p.run(); let data = pipe.fileHandleForReading.readDataToEndOfFile(); p.waitUntilExit(); let out = String(decoding: data, as: UTF8.self); guard p.terminationStatus == 0 else { throw OrionError.commandFailed(out) }; return out }.value
+    }
+}
+
+enum OrionError: LocalizedError { case prlctlNotFound, commandFailed(String); var errorDescription: String? { switch self { case .prlctlNotFound: "Parallels prlctl was not found."; case .commandFailed(let o): o.trimmingCharacters(in: .whitespacesAndNewlines) } } }

OrionToolbar/SettingsView.swift

@@ -5,13 +5,17 @@ struct SettingsView: View {
     @State private var selection: UUID?
     @State private var editing: ServerDefinition?
     @State private var addingVMs = false
+    @State private var pendingRemoval: ServerDefinition?
     var body: some View {
         HStack(spacing: 0) {
             List(selection: $selection) { ForEach(vm.servers) { s in HStack {
                         if let icon = vm.icon(for: s) { Image(nsImage: icon).resizable().scaledToFit().frame(width: 22, height: 22) }
                         else { Image(systemName: vm.status(for: s).symbolName) }
                         Text(s.name)
-                    }.tag(s.id) } }
+                    }
+                    .contentShape(Rectangle())
+                    .onTapGesture { selection = s.id }
+                    .tag(s.id) } }
                 .frame(width: 190)
             Divider()
             VStack(alignment: .leading, spacing: 14) {
@@ -22,9 +26,35 @@ struct SettingsView: View {
                     Spacer()
                 } else { ContentUnavailableView("Select a Server", systemImage: "server.rack") }
                 Divider()
-                HStack { Button("Add Server…", systemImage: "plus") { addingVMs = true }; Spacer(); Button("Delete", role: .destructive) { if let id = selection, let i = vm.servers.firstIndex(where: {$0.id == id}) { vm.delete(at: IndexSet(integer: i)); selection = nil } }.disabled(selection == nil) }
+                HStack {
+                    Button("Add Server…", systemImage: "plus") { addingVMs = true }
+                    Spacer()
+                    Button("Remove Definition", role: .destructive) {
+                        pendingRemoval = vm.servers.first { $0.id == selection }
+                    }
+                    .disabled(selection == nil)
+                }
             }.padding(20)
         }.frame(width: 650, height: 380)
+        .confirmationDialog(
+            "Remove this server definition?",
+            isPresented: Binding(
+                get: { pendingRemoval != nil },
+                set: { if !$0 { pendingRemoval = nil } }
+            ),
+            titleVisibility: .visible
+        ) {
+            Button("Remove Definition", role: .destructive) {
+                if let server = pendingRemoval {
+                    vm.removeDefinition(server)
+                    selection = nil
+                }
+                pendingRemoval = nil
+            }
+            Button("Cancel", role: .cancel) { pendingRemoval = nil }
+        } message: {
+            Text("This removes the OrionToolbar integration only. The Parallels virtual machine is not deleted.")
+        }
         .sheet(isPresented: $addingVMs) {
             VStack(alignment: .leading, spacing: 12) {
                 Text("Add Parallels Virtual Machines").font(.title2.bold())

OrionToolbar/SettingsView.swift.bak-20261023-083234

@@ -0,0 +1,78 @@
+import SwiftUI
+
+struct SettingsView: View {
+    @EnvironmentObject var vm: OrionVMController
+    @State private var selection: UUID?
+    @State private var editing: ServerDefinition?
+    @State private var addingVMs = false
+    var body: some View {
+        HStack(spacing: 0) {
+            List(selection: $selection) { ForEach(vm.servers) { s in HStack {
+                        if let icon = vm.icon(for: s) { Image(nsImage: icon).resizable().scaledToFit().frame(width: 22, height: 22) }
+                        else { Image(systemName: vm.status(for: s).symbolName) }
+                        Text(s.name)
+                    }.tag(s.id) } }
+                .frame(width: 190)
+            Divider()
+            VStack(alignment: .leading, spacing: 14) {
+                if let id = selection, let server = vm.servers.first(where: { $0.id == id }) {
+                    Text(server.name).font(.title2).fontWeight(.semibold)
+                    LabeledContent("Parallels VM", value: server.vmName); LabeledContent("Host", value: server.host); LabeledContent("SSH user", value: server.sshUser); LabeledContent("SSH port", value: String(server.sshPort)); LabeledContent("SSH key", value: server.sshIdentityFile.isEmpty ? "Default SSH configuration" : server.sshIdentityFile); LabeledContent("Mailpit", value: server.mailpitPort.map(String.init) ?? "Disabled")
+                    HStack { Button("Edit…") { editing = server }; Button("Force Stop", role: .destructive) { vm.forceStop(server) }.disabled(vm.status(for: server) == .stopped) }
+                    Spacer()
+                } else { ContentUnavailableView("Select a Server", systemImage: "server.rack") }
+                Divider()
+                HStack { Button("Add Server…", systemImage: "plus") { addingVMs = true }; Spacer(); Button("Delete", role: .destructive) { if let id = selection, let i = vm.servers.firstIndex(where: {$0.id == id}) { vm.delete(at: IndexSet(integer: i)); selection = nil } }.disabled(selection == nil) }
+            }.padding(20)
+        }.frame(width: 650, height: 380)
+        .sheet(isPresented: $addingVMs) {
+            VStack(alignment: .leading, spacing: 12) {
+                Text("Add Parallels Virtual Machines").font(.title2.bold())
+                List(vm.discoveredVMs) { machine in
+                    HStack {
+                        Toggle(machine.name, isOn: Binding(
+                            get: { vm.selectedVMIDs.contains(machine.id) },
+                            set: { value in
+                                if value { vm.selectedVMIDs.insert(machine.id) }
+                                else { vm.selectedVMIDs.remove(machine.id) }
+                            }
+                        ))
+                        Spacer()
+                        if vm.isIntegrated(machine) { Text("Integrated").foregroundStyle(.secondary) }
+                    }
+                }
+                HStack {
+                    Button("Refresh") { Task { await vm.discoverVMs() } }
+                    Spacer()
+                    Button("Cancel") { addingVMs = false }
+                    Button("Integrate Selected") { vm.integrateSelectedVMs(); addingVMs = false }
+                        .disabled(vm.selectedVMIDs.isEmpty)
+                }
+            }.padding(20).frame(width: 530, height: 420)
+            .task { await vm.discoverVMs() }
+        }
+        .sheet(item: $editing) { server in ServerEditor(server: server, isNew: !vm.servers.contains(where: {$0.id == server.id})) { value, isNew in if isNew { vm.add(value) } else { vm.update(value) }; selection = value.id } }
+    }
+}
+
+struct ServerEditor: View {
+    @Environment(\.dismiss) private var dismiss
+    @State var server: ServerDefinition
+    let isNew: Bool
+    let save: (ServerDefinition, Bool) -> Void
+    var body: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            Text(isNew ? "Add Server" : "Edit Server").font(.title2).fontWeight(.semibold)
+            Form {
+                TextField("Display name", text: $server.name)
+                TextField("Parallels VM name", text: $server.vmName)
+                TextField("IP address / host", text: $server.host)
+                TextField("SSH user", text: $server.sshUser)
+                TextField("SSH port", value: $server.sshPort, format: .number)
+                TextField("SSH identity file (optional)", text: $server.sshIdentityFile, prompt: Text("~/.ssh/id_ed25519"))
+                TextField("Mailpit port (optional)", text: Binding(get: { server.mailpitPort.map(String.init) ?? "" }, set: { server.mailpitPort = Int($0) }))
+            }
+            HStack { Spacer(); Button("Cancel") { dismiss() }; Button("Save") { save(server, isNew); dismiss() }.keyboardShortcut(.defaultAction).disabled(server.name.isEmpty || server.vmName.isEmpty || server.sshPort < 1 || server.sshPort > 65535) }
+        }.padding(20).frame(width: 470)
+    }
+}