From ad345b2f9e43384c864dc1b8bbbf78aacfc68b97 Mon Sep 17 00:00:00 2001 From: Mark Gregory Date: Fri, 23 Oct 2026 10:45:37 +0100 Subject: [PATCH] updates to launcer --- OrionToolbar/OrionMenuView.swift | 69 ++- OrionToolbar/OrionVMController.swift | 53 +++ .../OrionToolbar/OrionMenuView.swift | 408 ++++++++++++++++ .../OrionToolbar/OrionVMController.swift | 416 ++++++++++++++++ .../OrionToolbar/OrionMenuView.swift | 431 +++++++++++++++++ .../OrionToolbar/OrionVMController.swift | 447 ++++++++++++++++++ patches/oriontoolbar_hide_restore_vms.py | 92 ++++ patches/oriontoolbar_main_reorder_both.py | 134 ++++++ 8 files changed, 2041 insertions(+), 9 deletions(-) create mode 100644 backups/20261023-102430-660440/OrionToolbar/OrionMenuView.swift create mode 100644 backups/20261023-102430-660440/OrionToolbar/OrionVMController.swift create mode 100644 backups/20261023-103141-729356/OrionToolbar/OrionMenuView.swift create mode 100644 backups/20261023-103141-729356/OrionToolbar/OrionVMController.swift create mode 100644 patches/oriontoolbar_hide_restore_vms.py create mode 100644 patches/oriontoolbar_main_reorder_both.py diff --git a/OrionToolbar/OrionMenuView.swift b/OrionToolbar/OrionMenuView.swift index 33084a3..371cad7 100644 --- a/OrionToolbar/OrionMenuView.swift +++ b/OrionToolbar/OrionMenuView.swift @@ -19,7 +19,7 @@ struct OrionMenuView: View { @State private var pendingForceStop: ParallelsVM? private var running: [ParallelsVM] { - vm.discoveredVMs.filter { $0.status.lowercased() == "running" } + vm.visibleVMs.filter { $0.status.lowercased() == "running" } } var body: some View { @@ -37,11 +37,11 @@ struct OrionMenuView: View { } } } - section(icon: "desktopcomputer", title: "All Virtual Machines", count: "\(vm.discoveredVMs.count) VMs", accent: .cyan, expanded: $showAll) { - if vm.discoveredVMs.isEmpty { + section(icon: "desktopcomputer", title: "All Virtual Machines", count: "\(vm.visibleVMs.count) VMs", accent: .cyan, expanded: $showAll) { + if vm.visibleVMs.isEmpty { emptyState(vm.discovering ? "Discovering Parallels VMs…" : "No virtual machines found", icon: "desktopcomputer.trianglebadge.exclamationmark") } else { - ForEach(vm.discoveredVMs) { machine in + ForEach(vm.visibleVMs) { machine in machineRow(machine) } } @@ -50,7 +50,10 @@ struct OrionMenuView: View { if vm.servers.isEmpty { emptyState("No integrations. Add a VM using + above.", icon: "plus.circle") } else { - ForEach(vm.servers) { server in + ForEach(vm.servers.filter { server in + !vm.hiddenVMIDs.contains(server.vmUUID ?? + vm.discoveredVMs.first(where: { $0.name == server.vmName })?.id ?? "") + }) { server in integratedRow(server) } } @@ -102,6 +105,18 @@ struct OrionMenuView: View { Text(vm.discoveredVMs.isEmpty ? "Waiting for Parallels" : "Parallels Connected") .foregroundStyle(OrionStyle.muted).font(.subheadline) Spacer() + Menu { + if vm.hiddenVMs.isEmpty { + Text("No removed virtual machines") + } else { + ForEach(vm.hiddenVMs) { machine in + Button("Re-add " + machine.name) { vm.restoreVM(machine) } + } + } + } label: { + Label("Re-add VM", systemImage: "plus.rectangle.on.folder") + } + .help("Restore virtual machines removed from OrionToolbar") 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)) @@ -224,7 +239,15 @@ struct OrionMenuView: View { 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) + HStack(spacing: 6) { + Image(systemName: "line.3.horizontal") + .foregroundStyle(OrionStyle.muted) + Text(machine.name).lineLimit(1) + } + .font(.system(size: 12, weight: .semibold)) + .frame(width: 230, alignment: .leading) + .contentShape(Rectangle()) + .onDrag { NSItemProvider(object: ("vm:" + machine.id) as NSString) } state(machine.status) Text(machine.ipAddress.isEmpty ? "—" : machine.ipAddress) .font(.system(size: 11, design: .monospaced)) @@ -238,6 +261,14 @@ struct OrionMenuView: View { } else { action("Start", "play.fill", tint: OrionStyle.blue) { vm.operate(machine, action: "start") } } + Button { + vm.hideVM(machine) + } label: { + Image(systemName: "minus.circle") + .foregroundStyle(OrionStyle.muted) + } + .buttonStyle(.plain) + .help("Remove from OrionToolbar (keeps the Parallels VM)") if vm.isIntegrated(machine) { Image(systemName: "checkmark.circle.fill").foregroundStyle(OrionStyle.green) .frame(width: 28).help("Integrated") @@ -251,6 +282,23 @@ struct OrionMenuView: View { } .padding(.horizontal, 10).padding(.vertical, 7) .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10)) + .contextMenu { + Button("Remove from OrionToolbar", systemImage: "minus.circle") { + vm.hideVM(machine) + } + } + .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("vm:") else { return } + Task { @MainActor in + vm.reorderVM(draggedID: String(value.dropFirst(3)), onto: machine.id) + } + } + return true + } } private func integratedRow(_ server: ServerDefinition) -> some View { @@ -273,7 +321,7 @@ struct OrionMenuView: View { .font(.system(size: 12, weight: .semibold)) .frame(width: 185, alignment: .leading) .onDrag { - NSItemProvider(object: server.id.uuidString as NSString) + NSItemProvider(object: ("server:" + server.id.uuidString) as NSString) } state(status) Text(server.host.isEmpty ? "—" : server.host) @@ -298,8 +346,11 @@ struct OrionMenuView: View { .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10)) .onDrop(of: [.plainText], isTargeted: nil) { providers in guard let provider = providers.first else { return false } - _ = provider.loadObject(ofClass: NSString.self) { value, _ in - guard let text = value as? NSString, let dragged = UUID(uuidString: text as String) else { return } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("server:"), + let dragged = UUID(uuidString: String(value.dropFirst(7))) else { return } Task { @MainActor in vm.reorderServer(draggedID: dragged, onto: server.id) } diff --git a/OrionToolbar/OrionVMController.swift b/OrionToolbar/OrionVMController.swift index cf10237..d37cef1 100644 --- a/OrionToolbar/OrionVMController.swift +++ b/OrionToolbar/OrionVMController.swift @@ -71,11 +71,53 @@ final class OrionVMController: ObservableObject { @Published var busyServers: Set = [] @Published var lastError: String? @Published var discoveredVMs: [ParallelsVM] = [] + @Published private(set) var hiddenVMIDs: Set = Set( + UserDefaults.standard.stringArray(forKey: "orionHiddenVMIDs.v1") ?? [] + ) + + func hideVM(_ machine: ParallelsVM) { + hiddenVMIDs.insert(machine.id) + UserDefaults.standard.set(hiddenVMIDs.sorted(), forKey: "orionHiddenVMIDs.v1") + } + + func restoreVM(_ machine: ParallelsVM) { + hiddenVMIDs.remove(machine.id) + UserDefaults.standard.set(hiddenVMIDs.sorted(), forKey: "orionHiddenVMIDs.v1") + } + + var visibleVMs: [ParallelsVM] { + discoveredVMs.filter { !hiddenVMIDs.contains($0.id) } + } + + var hiddenVMs: [ParallelsVM] { + discoveredVMs.filter { hiddenVMIDs.contains($0.id) } + } + @Published var selectedVMIDs: Set = [] @Published var discovering = false @Published var busyVMIDs: Set = [] private var timer: Timer? private let defaultsKey = "serverDefinitions.v2" + private let vmOrderKey = "orionVMOrder.v1" + private var vmOrder: [String] { + get { UserDefaults.standard.stringArray(forKey: vmOrderKey) ?? [] } + set { UserDefaults.standard.set(newValue, forKey: vmOrderKey) } + } + + func reorderVM(draggedID: String, onto targetID: String) { + guard draggedID != targetID, + discoveredVMs.contains(where: { $0.id == draggedID }), + discoveredVMs.contains(where: { $0.id == targetID }) else { return } + var order = discoveredVMs.map(\.id) + guard let from = order.firstIndex(of: draggedID), + let to = order.firstIndex(of: targetID) else { return } + order.remove(at: from) + order.insert(draggedID, at: to) + vmOrder = order + let ranks = Dictionary(uniqueKeysWithValues: order.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { (ranks[$0.id] ?? Int.max) < (ranks[$1.id] ?? Int.max) } + } + init() { if let data = UserDefaults.standard.data(forKey: defaultsKey), let saved = try? JSONDecoder().decode([ServerDefinition].self, from: data) { servers = saved } @@ -136,6 +178,17 @@ final class OrionVMController: ObservableObject { == .orderedAscending } + // Keep the user's VM order through every 15-second discovery refresh. + // New VMs are appended in discovery order. + let savedOrder = vmOrder + let ranks = Dictionary(uniqueKeysWithValues: savedOrder.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { left, right in + let a = ranks[left.id] ?? Int.max + let b = ranks[right.id] ?? Int.max + if a != b { return a < b } + return left.name.localizedStandardCompare(right.name) == .orderedAscending + } + // Resolve Parallels VM bundles without requiring the guest to run. for i in discoveredVMs.indices where discoveredVMs[i].bundlePath == nil { if let detail = try? await runPrlctl(["list", "-i", discoveredVMs[i].id]) { diff --git a/backups/20261023-102430-660440/OrionToolbar/OrionMenuView.swift b/backups/20261023-102430-660440/OrionToolbar/OrionMenuView.swift new file mode 100644 index 0000000..33084a3 --- /dev/null +++ b/backups/20261023-102430-660440/OrionToolbar/OrionMenuView.swift @@ -0,0 +1,408 @@ +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(icon: String, title: String, count: String, accent: Color, expanded: Binding, @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") + } + + } + .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) { + Group { + if let image = vm.icon(for: server) { + Image(nsImage: image).resizable().scaledToFit() + } else if let machine { + icon(machine) + } else { + Image(systemName: "server.rack").foregroundStyle(.cyan) + } + }.frame(width: 36, height: 36) + HStack(spacing: 5) { + Image(systemName: "line.3.horizontal").foregroundStyle(OrionStyle.muted) + Text(server.name).lineLimit(1) + } + .font(.system(size: 12, weight: .semibold)) + .frame(width: 185, alignment: .leading) + .onDrag { + NSItemProvider(object: server.id.uuidString as NSString) + } + 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)) + .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { value, _ in + guard let text = value as? NSString, let dragged = UUID(uuidString: text as String) else { return } + Task { @MainActor in + vm.reorderServer(draggedID: dragged, onto: server.id) + } + } + return true + } + } + + 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) + } +} + + +// Keep Settings above its originating MenuBarExtra panel. +@MainActor +private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate { + private static var current: OrionSettingsWindowPresenter? + + private var window: NSWindow? + private weak var parentWindow: 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) { + // Capture the currently active menu-bar panel. + let parent = NSApp.keyWindow + ?? NSApp.windows.first(where: { $0.isVisible }) + + 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.center() + + self.window = window + self.parentWindow = parent + + if let parent { + parent.addChildWindow(window, ordered: .above) + } + + NSApp.activate(ignoringOtherApps: true) + window.makeKeyAndOrderFront(nil) + window.orderFrontRegardless() + } + + func windowWillClose(_ notification: Notification) { + if let window { + parentWindow?.removeChildWindow(window) + } + + window = nil + Self.current = nil + } +} diff --git a/backups/20261023-102430-660440/OrionToolbar/OrionVMController.swift b/backups/20261023-102430-660440/OrionToolbar/OrionVMController.swift new file mode 100644 index 0000000..cf10237 --- /dev/null +++ b/backups/20261023-102430-660440/OrionToolbar/OrionVMController.swift @@ -0,0 +1,416 @@ +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? + var customIconPath: String? = nil + + 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 = [] + @Published var lastError: String? + @Published var discoveredVMs: [ParallelsVM] = [] + @Published var selectedVMIDs: Set = [] + @Published var discovering = false + @Published var busyVMIDs: Set = [] + 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) { servers = saved } + else { servers = [.orion] } + Task { + await discoverVMs() + await refreshAll() + } + timer = Timer.scheduledTimer(withTimeInterval: 15, 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." + ) + } + + let knownBundlePaths = Dictionary(uniqueKeysWithValues: + discoveredVMs.compactMap { machine -> (String, String)? in + guard let path = machine.bundlePath else { return nil } + return (machine.id, path) + } + ) + 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: knownBundlePaths[uuid] + ) + } + .sorted { + $0.name.localizedStandardCompare($1.name) + == .orderedAscending + } + + // Resolve Parallels VM bundles without requiring the guest to run. + for i in discoveredVMs.indices where discoveredVMs[i].bundlePath == nil { + if let detail = try? await runPrlctl(["list", "-i", discoveredVMs[i].id]) { + // `Home:` ends with .pvm/ on this Parallels installation. + if let homeLine = detail.split(separator: "\n").first(where: { + $0.trimmingCharacters(in: .whitespaces).hasPrefix("Home:") + }) { + let trimmed = homeLine.trimmingCharacters(in: .whitespaces) + let raw = String(trimmed.dropFirst("Home:".count)) + .trimmingCharacters(in: .whitespacesAndNewlines) + .trimmingCharacters(in: CharacterSet(charactersIn: "\"'")) + let expanded = (raw as NSString).expandingTildeInPath + let normalized = (expanded as NSString).standardizingPath + if FileManager.default.fileExists(atPath: normalized) { + discoveredVMs[i].bundlePath = normalized + } + } + } + } + // 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 } + let bundle = URL(fileURLWithPath: path, isDirectory: true) + + // Parallels stores the per-VM application under .pvm/VM.app. + // The .pvm Finder icon itself is generic and must not be used. + let app = bundle.appendingPathComponent("VM.app", isDirectory: true) + let plist = app.appendingPathComponent("Contents/Info.plist") + if let info = NSDictionary(contentsOf: plist) as? [String: Any] { + let resourceDir = app.appendingPathComponent("Contents/Resources", isDirectory: true) + for key in ["CFBundleIconFile", "CFBundleIconName"] { + if let name = info[key] as? String, !name.isEmpty { + let names = name.lowercased().hasSuffix(".icns") ? [name] : [name + ".icns", name] + for candidate in names { + if let image = NSImage(contentsOf: resourceDir.appendingPathComponent(candidate)) { + return image + } + } + } + } + } + for name in ["icon.png", "Icon.png", "icon.icns", "Icon.icns", ".VolumeIcon.icns"] { + if let image = NSImage(contentsOf: bundle.appendingPathComponent(name)) { return image } + } + // Never return NSWorkspace.icon(forFile: path): it is the generic .pvm icon. + return nil + } + + 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 } + 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) } + 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 { + 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() + 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 moveServer(from source: IndexSet, to destination: Int) { + servers.move(fromOffsets: source, toOffset: destination) + } + + func moveServer(_ id: UUID, by delta: Int) { + guard let index = servers.firstIndex(where: { $0.id == id }) else { return } + let target = index + delta + guard servers.indices.contains(target) else { return } + servers.swapAt(index, target) + } + + func reorderServer(draggedID: UUID, onto targetID: UUID) { + guard draggedID != targetID, + let from = servers.firstIndex(where: { $0.id == draggedID }), + let to = servers.firstIndex(where: { $0.id == targetID }) else { return } + let moved = servers.remove(at: from) + servers.insert(moved, at: to) // @Published didSet persists the order. + } + + func icon(for server: ServerDefinition) -> NSImage? { + if let path = server.customIconPath, let image = NSImage(contentsOfFile: path) { + return image + } + + 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) } } } diff --git a/backups/20261023-103141-729356/OrionToolbar/OrionMenuView.swift b/backups/20261023-103141-729356/OrionToolbar/OrionMenuView.swift new file mode 100644 index 0000000..3308dd1 --- /dev/null +++ b/backups/20261023-103141-729356/OrionToolbar/OrionMenuView.swift @@ -0,0 +1,431 @@ +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(icon: String, title: String, count: String, accent: Color, expanded: Binding, @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) + HStack(spacing: 6) { + Image(systemName: "line.3.horizontal") + .foregroundStyle(OrionStyle.muted) + Text(machine.name).lineLimit(1) + } + .font(.system(size: 12, weight: .semibold)) + .frame(width: 230, alignment: .leading) + .contentShape(Rectangle()) + .onDrag { NSItemProvider(object: ("vm:" + machine.id) as NSString) } + 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") + } + + } + .padding(.horizontal, 10).padding(.vertical, 7) + .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10)) + .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("vm:") else { return } + Task { @MainActor in + vm.reorderVM(draggedID: String(value.dropFirst(3)), onto: machine.id) + } + } + return true + } + } + + 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) { + Group { + if let image = vm.icon(for: server) { + Image(nsImage: image).resizable().scaledToFit() + } else if let machine { + icon(machine) + } else { + Image(systemName: "server.rack").foregroundStyle(.cyan) + } + }.frame(width: 36, height: 36) + HStack(spacing: 5) { + Image(systemName: "line.3.horizontal").foregroundStyle(OrionStyle.muted) + Text(server.name).lineLimit(1) + } + .font(.system(size: 12, weight: .semibold)) + .frame(width: 185, alignment: .leading) + .onDrag { + NSItemProvider(object: ("server:" + server.id.uuidString) as NSString) + } + 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)) + .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("server:"), + let dragged = UUID(uuidString: String(value.dropFirst(7))) else { return } + Task { @MainActor in + vm.reorderServer(draggedID: dragged, onto: server.id) + } + } + return true + } + } + + 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) + } +} + + +// Keep Settings above its originating MenuBarExtra panel. +@MainActor +private final class OrionSettingsWindowPresenter: NSObject, NSWindowDelegate { + private static var current: OrionSettingsWindowPresenter? + + private var window: NSWindow? + private weak var parentWindow: 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) { + // Capture the currently active menu-bar panel. + let parent = NSApp.keyWindow + ?? NSApp.windows.first(where: { $0.isVisible }) + + 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.center() + + self.window = window + self.parentWindow = parent + + if let parent { + parent.addChildWindow(window, ordered: .above) + } + + NSApp.activate(ignoringOtherApps: true) + window.makeKeyAndOrderFront(nil) + window.orderFrontRegardless() + } + + func windowWillClose(_ notification: Notification) { + if let window { + parentWindow?.removeChildWindow(window) + } + + window = nil + Self.current = nil + } +} diff --git a/backups/20261023-103141-729356/OrionToolbar/OrionVMController.swift b/backups/20261023-103141-729356/OrionToolbar/OrionVMController.swift new file mode 100644 index 0000000..829df04 --- /dev/null +++ b/backups/20261023-103141-729356/OrionToolbar/OrionVMController.swift @@ -0,0 +1,447 @@ +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? + var customIconPath: String? = nil + + 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 = [] + @Published var lastError: String? + @Published var discoveredVMs: [ParallelsVM] = [] + @Published var selectedVMIDs: Set = [] + @Published var discovering = false + @Published var busyVMIDs: Set = [] + private var timer: Timer? + private let defaultsKey = "serverDefinitions.v2" + private let vmOrderKey = "orionVMOrder.v1" + private var vmOrder: [String] { + get { UserDefaults.standard.stringArray(forKey: vmOrderKey) ?? [] } + set { UserDefaults.standard.set(newValue, forKey: vmOrderKey) } + } + + func reorderVM(draggedID: String, onto targetID: String) { + guard draggedID != targetID, + discoveredVMs.contains(where: { $0.id == draggedID }), + discoveredVMs.contains(where: { $0.id == targetID }) else { return } + var order = discoveredVMs.map(\.id) + guard let from = order.firstIndex(of: draggedID), + let to = order.firstIndex(of: targetID) else { return } + order.remove(at: from) + order.insert(draggedID, at: to) + vmOrder = order + let ranks = Dictionary(uniqueKeysWithValues: order.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { (ranks[$0.id] ?? Int.max) < (ranks[$1.id] ?? Int.max) } + } + + + init() { + 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() + await refreshAll() + } + timer = Timer.scheduledTimer(withTimeInterval: 15, 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." + ) + } + + let knownBundlePaths = Dictionary(uniqueKeysWithValues: + discoveredVMs.compactMap { machine -> (String, String)? in + guard let path = machine.bundlePath else { return nil } + return (machine.id, path) + } + ) + 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: knownBundlePaths[uuid] + ) + } + .sorted { + $0.name.localizedStandardCompare($1.name) + == .orderedAscending + } + + // Keep the user's VM order through every 15-second discovery refresh. + // New VMs are appended in discovery order. + let savedOrder = vmOrder + let ranks = Dictionary(uniqueKeysWithValues: savedOrder.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { left, right in + let a = ranks[left.id] ?? Int.max + let b = ranks[right.id] ?? Int.max + if a != b { return a < b } + return left.name.localizedStandardCompare(right.name) == .orderedAscending + } + + // Resolve Parallels VM bundles without requiring the guest to run. + for i in discoveredVMs.indices where discoveredVMs[i].bundlePath == nil { + if let detail = try? await runPrlctl(["list", "-i", discoveredVMs[i].id]) { + // `Home:` ends with .pvm/ on this Parallels installation. + if let homeLine = detail.split(separator: "\n").first(where: { + $0.trimmingCharacters(in: .whitespaces).hasPrefix("Home:") + }) { + let trimmed = homeLine.trimmingCharacters(in: .whitespaces) + let raw = String(trimmed.dropFirst("Home:".count)) + .trimmingCharacters(in: .whitespacesAndNewlines) + .trimmingCharacters(in: CharacterSet(charactersIn: "\"'")) + let expanded = (raw as NSString).expandingTildeInPath + let normalized = (expanded as NSString).standardizingPath + if FileManager.default.fileExists(atPath: normalized) { + discoveredVMs[i].bundlePath = normalized + } + } + } + } + // 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 } + let bundle = URL(fileURLWithPath: path, isDirectory: true) + + // Parallels stores the per-VM application under .pvm/VM.app. + // The .pvm Finder icon itself is generic and must not be used. + let app = bundle.appendingPathComponent("VM.app", isDirectory: true) + let plist = app.appendingPathComponent("Contents/Info.plist") + if let info = NSDictionary(contentsOf: plist) as? [String: Any] { + let resourceDir = app.appendingPathComponent("Contents/Resources", isDirectory: true) + for key in ["CFBundleIconFile", "CFBundleIconName"] { + if let name = info[key] as? String, !name.isEmpty { + let names = name.lowercased().hasSuffix(".icns") ? [name] : [name + ".icns", name] + for candidate in names { + if let image = NSImage(contentsOf: resourceDir.appendingPathComponent(candidate)) { + return image + } + } + } + } + } + for name in ["icon.png", "Icon.png", "icon.icns", "Icon.icns", ".VolumeIcon.icns"] { + if let image = NSImage(contentsOf: bundle.appendingPathComponent(name)) { return image } + } + // Never return NSWorkspace.icon(forFile: path): it is the generic .pvm icon. + return nil + } + + 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 } + 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) } + 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 { + 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() + 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 moveServer(from source: IndexSet, to destination: Int) { + servers.move(fromOffsets: source, toOffset: destination) + } + + func moveServer(_ id: UUID, by delta: Int) { + guard let index = servers.firstIndex(where: { $0.id == id }) else { return } + let target = index + delta + guard servers.indices.contains(target) else { return } + servers.swapAt(index, target) + } + + func reorderServer(draggedID: UUID, onto targetID: UUID) { + guard draggedID != targetID, + let from = servers.firstIndex(where: { $0.id == draggedID }), + let to = servers.firstIndex(where: { $0.id == targetID }) else { return } + let moved = servers.remove(at: from) + servers.insert(moved, at: to) // @Published didSet persists the order. + } + + func icon(for server: ServerDefinition) -> NSImage? { + if let path = server.customIconPath, let image = NSImage(contentsOfFile: path) { + return image + } + + 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) } } } diff --git a/patches/oriontoolbar_hide_restore_vms.py b/patches/oriontoolbar_hide_restore_vms.py new file mode 100644 index 0000000..76c9cd6 --- /dev/null +++ b/patches/oriontoolbar_hide_restore_vms.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +"""Hide/re-add Parallels VMs in OrionToolbar only; never unregister/delete VMs.""" +from pathlib import Path +from datetime import datetime +import shutil +root=Path.cwd() +cpath=root/'OrionToolbar/OrionVMController.swift' +mpath=root/'OrionToolbar/OrionMenuView.swift' +if not cpath.is_file() or not mpath.is_file(): raise SystemExit('Run from OrionToolbar project root') +c=cpath.read_text(); m=mpath.read_text() +def once(s,old,new,desc): + n=s.count(old) + if n!=1: raise SystemExit(f'Expected exactly one {desc}, found {n}. No changes made.') + return s.replace(old,new,1) +if 'orionHiddenVMIDs.v1' in c: raise SystemExit('Already installed; no changes made') +c=once(c,' @Published var discoveredVMs: [ParallelsVM] = []',''' @Published var discoveredVMs: [ParallelsVM] = [] + @Published private(set) var hiddenVMIDs: Set = Set( + UserDefaults.standard.stringArray(forKey: "orionHiddenVMIDs.v1") ?? [] + ) + + func hideVM(_ machine: ParallelsVM) { + hiddenVMIDs.insert(machine.id) + UserDefaults.standard.set(hiddenVMIDs.sorted(), forKey: "orionHiddenVMIDs.v1") + } + + func restoreVM(_ machine: ParallelsVM) { + hiddenVMIDs.remove(machine.id) + UserDefaults.standard.set(hiddenVMIDs.sorted(), forKey: "orionHiddenVMIDs.v1") + } + + var visibleVMs: [ParallelsVM] { + discoveredVMs.filter { !hiddenVMIDs.contains($0.id) } + } + + var hiddenVMs: [ParallelsVM] { + discoveredVMs.filter { hiddenVMIDs.contains($0.id) } + } +''','published VM declaration') +m=once(m,'vm.discoveredVMs.filter { $0.status.lowercased() == "running" }','vm.visibleVMs.filter { $0.status.lowercased() == "running" }','running list') +m=once(m,'count: "\\(vm.discoveredVMs.count) VMs"','count: "\\(vm.visibleVMs.count) VMs"','VM count') +m=once(m,'if vm.discoveredVMs.isEmpty {','if vm.visibleVMs.isEmpty {','VM empty state') +m=once(m,'ForEach(vm.discoveredVMs) { machine in','ForEach(vm.visibleVMs) { machine in','All VM rows') +# Hide an integrated server's row if its Parallels VM has been hidden. +m=once(m,'ForEach(vm.servers) { server in\n integratedRow(server)','''ForEach(vm.servers.filter { server in + !vm.hiddenVMIDs.contains(server.vmUUID ?? + vm.discoveredVMs.first(where: { $0.name == server.vmName })?.id ?? "") + }) { server in + integratedRow(server)''','Integrated rows') +# Add a restore dropdown to the dashboard header; visible even if every VM is hidden. +anchor=''' if vm.discovering { ProgressView().controlSize(.small) }''' +m=once(m,anchor,''' Menu { + if vm.hiddenVMs.isEmpty { + Text("No removed virtual machines") + } else { + ForEach(vm.hiddenVMs) { machine in + Button("Re-add " + machine.name) { vm.restoreVM(machine) } + } + } + } label: { + Label("Re-add VM", systemImage: "plus.rectangle.on.folder") + } + .help("Restore virtual machines removed from OrionToolbar") +'''+anchor,'header restore menu') +# Add context menu to VM row; no changes to existing drag/drop modifiers. +start=m.index(' private func machineRow('); end=m.index(' private func integratedRow(',start) +block=m[start:end] +needle=''' .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10))''' +block=once(block,needle,needle+''' + .contextMenu { + Button("Remove from OrionToolbar", systemImage: "minus.circle") { + vm.hideVM(machine) + } + }''','All VM context menu') +# Also add a clearly visible Remove button, retaining existing start/stop/integrate actions. +needle=''' if vm.isIntegrated(machine) {''' +block=once(block,needle,''' Button { + vm.hideVM(machine) + } label: { + Image(systemName: "minus.circle") + .foregroundStyle(OrionStyle.muted) + } + .buttonStyle(.plain) + .help("Remove from OrionToolbar (keeps the Parallels VM)") +'''+needle,'VM remove button') +m=m[:start]+block+m[end:] +backup=root/'backups'/datetime.now().strftime('%Y%m%d-%H%M%S-%f') +for path in (cpath,mpath): + dest=backup/path.relative_to(root); dest.parent.mkdir(parents=True,exist_ok=True); shutil.copy2(path,dest) +cpath.write_text(c); mpath.write_text(m) +print('Updated:',cpath.relative_to(root),mpath.relative_to(root)) +print('Backups:',backup) +print('Parallels VMs are never deleted or unregistered. Icons and drag ordering untouched.') diff --git a/patches/oriontoolbar_main_reorder_both.py b/patches/oriontoolbar_main_reorder_both.py new file mode 100644 index 0000000..3842f28 --- /dev/null +++ b/patches/oriontoolbar_main_reorder_both.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +"""Drag reorder both dashboard lists; preserve icons and Settings.""" +from pathlib import Path +from datetime import datetime +import shutil, re +root=Path.cwd() +controller=root/'OrionToolbar/OrionVMController.swift' +menu=root/'OrionToolbar/OrionMenuView.swift' +for p in (controller,menu): + if not p.is_file(): raise SystemExit(f'Missing {p}; run from OrionToolbar root') +c=controller.read_text(); m=menu.read_text() +if 'orionVMOrder.v1' in c: raise SystemExit('This patch has already been applied.') + +def replace_once(src, old, new, label): + if src.count(old)!=1: raise SystemExit(f'Cannot uniquely locate {label} (found {src.count(old)}). No changes made.') + return src.replace(old,new,1) + +# Maintain a stable, persisted order separate from server definitions. +anchor=' private let defaultsKey = "serverDefinitions.v2"' +c=replace_once(c,anchor,anchor+''' + private let vmOrderKey = "orionVMOrder.v1" + private var vmOrder: [String] { + get { UserDefaults.standard.stringArray(forKey: vmOrderKey) ?? [] } + set { UserDefaults.standard.set(newValue, forKey: vmOrderKey) } + } + + func reorderVM(draggedID: String, onto targetID: String) { + guard draggedID != targetID, + discoveredVMs.contains(where: { $0.id == draggedID }), + discoveredVMs.contains(where: { $0.id == targetID }) else { return } + var order = discoveredVMs.map(\\.id) + guard let from = order.firstIndex(of: draggedID), + let to = order.firstIndex(of: targetID) else { return } + order.remove(at: from) + order.insert(draggedID, at: to) + vmOrder = order + let ranks = Dictionary(uniqueKeysWithValues: order.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { (ranks[$0.id] ?? Int.max) < (ranks[$1.id] ?? Int.max) } + } +''','controller ordering properties') +# Discovery sorts alphabetically initially; then apply persisted order, preserving newly discovered VMs. +anchor=''' // Resolve Parallels VM bundles without requiring the guest to run.''' +c=replace_once(c,anchor,''' // Keep the user's VM order through every 15-second discovery refresh. + // New VMs are appended in discovery order. + let savedOrder = vmOrder + let ranks = Dictionary(uniqueKeysWithValues: savedOrder.enumerated().map { ($0.element, $0.offset) }) + discoveredVMs.sort { left, right in + let a = ranks[left.id] ?? Int.max + let b = ranks[right.id] ?? Int.max + if a != b { return a < b } + return left.name.localizedStandardCompare(right.name) == .orderedAscending + } + +'''+anchor,'discovery sort persistence') +# Use NSItemProvider for consistent macOS drag and drop. Drag handle only: buttons remain clickable. +# The drag provider is explicitly NSString, and callback converts from NSItemProviderReading. +vm_name=''' Text(machine.name).font(.system(size: 12, weight: .semibold)).lineLimit(1).frame(width: 230, alignment: .leading)''' +vm_name_new=''' HStack(spacing: 6) { + Image(systemName: "line.3.horizontal") + .foregroundStyle(OrionStyle.muted) + Text(machine.name).lineLimit(1) + } + .font(.system(size: 12, weight: .semibold)) + .frame(width: 230, alignment: .leading) + .contentShape(Rectangle()) + .onDrag { NSItemProvider(object: ("vm:" + machine.id) as NSString) }''' +m=replace_once(m,vm_name,vm_name_new,'All Virtual Machines drag handle') +# Target only machineRow by isolating function boundaries. +start=m.index(' private func machineRow(') +end=m.index(' private func integratedRow(',start) +block=m[start:end] +background=''' .background(OrionStyle.card.opacity(0.75), in: RoundedRectangle(cornerRadius: 10))''' +vm_drop=''' .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("vm:") else { return } + Task { @MainActor in + vm.reorderVM(draggedID: String(value.dropFirst(3)), onto: machine.id) + } + } + return true + }''' +block=replace_once(block,background,background+'\n'+vm_drop,'All Virtual Machines drop target') +m=m[:start]+block+m[end:] +# Integrated server grip (may already be .onDrag or .draggable). +start=m.index(' private func integratedRow(') +end=m.index(' private func action(',start) +block=m[start:end] +block=block.replace('.draggable(server.id.uuidString)', '.onDrag { NSItemProvider(object: ("server:" + server.id.uuidString) as NSString) }') +# Prior patch may have installed .onDrag without a namespace; update its payload. +block=block.replace('NSItemProvider(object: server.id.uuidString as NSString)', 'NSItemProvider(object: ("server:" + server.id.uuidString) as NSString)') +# Replace only integratedRow drop handler, whether original .dropDestination or last .onDrop. +new_drop=''' .onDrop(of: [.plainText], isTargeted: nil) { providers in + guard let provider = providers.first else { return false } + _ = provider.loadObject(ofClass: NSString.self) { item, _ in + guard let string = item as? NSString else { return } + let value = string as String + guard value.hasPrefix("server:"), + let dragged = UUID(uuidString: String(value.dropFirst(7))) else { return } + Task { @MainActor in + vm.reorderServer(draggedID: dragged, onto: server.id) + } + } + return true + }''' +block,n=re.subn(r' \.onDrop\(of: \[\.plainText\], isTargeted: nil\) \{ providers in\n.*?\n \}',lambda _:new_drop,block,count=1,flags=re.S) +if n==0: + block,n=re.subn(r' \.dropDestination\(for: String\.self\) \{ items, _ in\n.*?\n \}',lambda _:new_drop,block,count=1,flags=re.S) +if n!=1: raise SystemExit('Cannot locate integrated server drop handler; no changes made') +if '.onDrag' not in block: raise SystemExit('Cannot locate integrated server drag handle; no changes made') +m=m[:start]+block+m[end:] +# Fix previous build error if it remains elsewhere, without modifying other behavior. +m=m.replace('guard let text = value as String?, let dragged = UUID(uuidString: text) else { return }', 'guard let text = value as? NSString, let dragged = UUID(uuidString: text as String) else { return }') +# Avoid duplicate right-hand chevron if prior patch was not applied. +chevron=''' 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)''' +m=m.replace(chevron,'') +backup=root/'backups'/datetime.now().strftime('%Y%m%d-%H%M%S-%f') +for path,source in ((controller,c),(menu,m)): + target=backup/path.relative_to(root) + target.parent.mkdir(parents=True,exist_ok=True) + shutil.copy2(path,target) +for path,source in ((controller,c),(menu,m)): path.write_text(source) +print('Updated OrionVMController.swift and OrionMenuView.swift') +print('Backups:',backup) +print('Icons and SettingsView.swift unchanged.')