From 415dba0344c66e996f4386eaee80b763b6e66fe3 Mon Sep 17 00:00:00 2001 From: Mark Gregory Date: Fri, 23 Oct 2026 09:28:19 +0100 Subject: [PATCH] updates --- .idea/OrionToolbar.iml | 13 +- OrionToolbar/OrionMenuView.swift | 55 +++ .../OrionMenuView.swift.bak-20261023-083234 | 162 +++++++++ OrionToolbar/OrionVMController.swift | 41 ++- ...rionVMController.swift.bak-20261023-083234 | 337 ++++++++++++++++++ OrionToolbar/SettingsView.swift | 34 +- .../SettingsView.swift.bak-20261023-083234 | 78 ++++ 7 files changed, 696 insertions(+), 24 deletions(-) create mode 100644 OrionToolbar/OrionMenuView.swift.bak-20261023-083234 create mode 100644 OrionToolbar/OrionVMController.swift.bak-20261023-083234 create mode 100644 OrionToolbar/SettingsView.swift.bak-20261023-083234 diff --git a/.idea/OrionToolbar.iml b/.idea/OrionToolbar.iml index c4a94a0..015e9c3 100644 --- a/.idea/OrionToolbar.iml +++ b/.idea/OrionToolbar.iml @@ -1,13 +1,2 @@ - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/OrionToolbar/OrionMenuView.swift b/OrionToolbar/OrionMenuView.swift index f058f2d..870392f 100644 --- a/OrionToolbar/OrionMenuView.swift +++ b/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) diff --git a/OrionToolbar/OrionMenuView.swift.bak-20261023-083234 b/OrionToolbar/OrionMenuView.swift.bak-20261023-083234 new file mode 100644 index 0000000..f058f2d --- /dev/null +++ b/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 = [] + @State private var expandedServers: Set = [] + + 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) + } +} diff --git a/OrionToolbar/OrionVMController.swift b/OrionToolbar/OrionVMController.swift index 617c5c5..9ac15a0 100644 --- a/OrionToolbar/OrionVMController.swift +++ b/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() diff --git a/OrionToolbar/OrionVMController.swift.bak-20261023-083234 b/OrionToolbar/OrionVMController.swift.bak-20261023-083234 new file mode 100644 index 0000000..617c5c5 --- /dev/null +++ b/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 = [] + @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), !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.. 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) } } } diff --git a/OrionToolbar/SettingsView.swift b/OrionToolbar/SettingsView.swift index 6479cb5..ab10484 100644 --- a/OrionToolbar/SettingsView.swift +++ b/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()) diff --git a/OrionToolbar/SettingsView.swift.bak-20261023-083234 b/OrionToolbar/SettingsView.swift.bak-20261023-083234 new file mode 100644 index 0000000..6479cb5 --- /dev/null +++ b/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) + } +}