Add ⌘R and ⌘. to Start and Stop Tasks, Add Tasks Menu

Author: thecoolwinter

CodeEdit/Features/Tasks/TaskManager.swift

@@ -93,7 +93,7 @@ class TaskManager: ObservableObject {
         }
     }
 
-    func terminateActiveTask() {
+    func terminateSelectedTask() {
         guard let taskID = selectedTaskID else {
             return
         }

CodeEdit/Features/Tasks/Views/StopTaskToolbarButton.swift

@@ -24,7 +24,7 @@ struct StopTaskToolbarButton: View {
         HStack {
             if let currentSelectedStatus, currentSelectedStatus == .running {
                     Button {
-                        taskManager.terminateActiveTask()
+                        taskManager.terminateSelectedTask()
                     } label: {
                         Label("Stop", systemImage: "stop.fill")
                             .labelStyle(.iconOnly)

CodeEdit/Features/WindowCommands/CodeEditCommands.swift

@@ -17,6 +17,7 @@ struct CodeEditCommands: Commands {
         ViewCommands()
         FindCommands()
         NavigateCommands()
+        TasksCommands()
         if sourceControlIsEnabled { SourceControlCommands() }
         ExtensionCommands()
         WindowCommands()

CodeEdit/Features/WindowCommands/TasksCommands.swift

@@ -0,0 +1,66 @@
+//
+//  TasksCommands.swift
+//  CodeEdit
+//
+//  Created by Khan Winter on 7/8/25.
+//
+
+import SwiftUI
+
+struct TasksCommands: Commands {
+    @UpdatingWindowController var windowController: CodeEditWindowController?
+
+    var taskManager: TaskManager? {
+        windowController?.workspace?.taskManager
+    }
+
+    var selectedTask: CETask? {
+        taskManager?.availableTasks.first(where: { $0.id == taskManager?.selectedTaskID })
+    }
+
+    var body: some Commands {
+        CommandMenu("Tasks") {
+            let selectedTaskName: String? = if let selectedTask {
+                "\"" + selectedTask.name + "\""
+            } else {
+                nil
+            }
+
+            Button("Run \(selectedTaskName ?? "(No Selected Task)")") {
+                taskManager?.executeActiveTask()
+            }
+            .keyboardShortcut("r", modifiers: .command)
+            .disabled(taskManager?.selectedTaskID == nil)
+
+            Button("Stop \(selectedTaskName ?? "(No Selected Task)")") {
+                taskManager?.terminateSelectedTask()
+            }
+            .keyboardShortcut(".", modifiers: .command)
+            .disabled(taskManager?.activeTasks.isEmpty == true)
+
+            Divider()
+
+            Menu {
+                if let taskManager {
+                    ForEach(taskManager.availableTasks) { task in
+                        Button(task.name) {
+                            taskManager.selectedTaskID = task.id
+                        }
+                    }
+                }
+            } label: {
+                Text("Choose Task...")
+            }
+            .disabled(taskManager?.availableTasks.isEmpty == true)
+
+            Button("Manage Tasks...") {
+                NSApp.sendAction(
+                    #selector(CodeEditWindowController.openWorkspaceSettings(_:)),
+                    to: windowController,
+                    from: nil
+                )
+            }
+            .disabled(windowController == nil)
+        }
+    }
+}

CodeEdit/Features/WindowCommands/Utils/WindowControllerPropertyWrapper.swift

@@ -36,10 +36,8 @@ struct UpdatingWindowController: DynamicProperty {
     class WindowControllerBox: ObservableObject {
         public private(set) weak var controller: CodeEditWindowController?
 
-        private var objectWillChangeCancellable: AnyCancellable?
-        private var utilityAreaCancellable: AnyCancellable? // ``ViewCommands`` needs this.
-        private var windowCancellable: AnyCancellable?
-        private var activeEditorCancellable: AnyCancellable?
+        private var windowCancellable: AnyCancellable? // Needs to stick around between window changes.
+        private var cancellables: Set<AnyCancellable> = []
 
         init() {
             windowCancellable = NSApp.publisher(for: \.keyWindow).receive(on: RunLoop.main).sink { [weak self] window in
@@ -50,25 +48,32 @@ struct UpdatingWindowController: DynamicProperty {
         }
 
         func setNewController(_ controller: CodeEditWindowController?) {
-            objectWillChangeCancellable?.cancel()
-            objectWillChangeCancellable = nil
-            utilityAreaCancellable?.cancel()
-            utilityAreaCancellable = nil
-            activeEditorCancellable?.cancel()
-            activeEditorCancellable = nil
+            cancellables.forEach { $0.cancel() }
+            cancellables.removeAll()
 
             self.controller = controller
 
-            objectWillChangeCancellable = controller?.objectWillChange.sink { [weak self] in
+            controller?.objectWillChange.sink { [weak self] in
                 self?.objectWillChange.send()
             }
-            utilityAreaCancellable = controller?.workspace?.utilityAreaModel?.objectWillChange.sink { [weak self] in
+            .store(in: &cancellables)
+
+            controller?.workspace?.utilityAreaModel?.objectWillChange.sink { [weak self] in
                 self?.objectWillChange.send()
             }
+            .store(in: &cancellables)
+
             let activeEditor = controller?.workspace?.editorManager?.activeEditor
-            activeEditorCancellable = activeEditor?.objectWillChange.sink { [weak self] in
+            activeEditor?.objectWillChange.sink { [weak self] in
+                self?.objectWillChange.send()
+            }
+            .store(in: &cancellables)
+
+            controller?.workspace?.taskManager?.objectWillChange.sink { [weak self] in
                 self?.objectWillChange.send()
             }
+            .store(in: &cancellables)
+
             self.objectWillChange.send()
         }
     }

CodeEditTests/Features/Tasks/TaskManagerTests.swift

@@ -59,7 +59,7 @@ final class TaskManagerTests: XCTestCase {
         let testExpectation1 = XCTestExpectation()
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
             XCTAssertEqual(self.taskManager.taskStatus(taskID: task.id), .running)
-            self.taskManager.terminateActiveTask()
+            self.taskManager.terminateSelectedTask()
             testExpectation1.fulfill()
         }