Create CEActiveTaskTerminalView

Author: thecoolwinter

CodeEdit/Features/Tasks/Models/CEActiveTask.swift

@@ -7,11 +7,14 @@
 
 import SwiftUI
 import Combine
+import SwiftTerm
 
 /// Stores the state of a task once it's executed
 class CEActiveTask: ObservableObject, Identifiable, Hashable {
     /// The current progress of the task.
-    @Published private(set) var output: String  = ""
+    @Published var output: CEActiveTaskTerminalView?
+
+    var hasOutputBeenConfigured: Bool = false
 
     /// The status of the task.
     @Published private(set) var status: CETaskStatus = .notRunning
@@ -22,138 +25,113 @@ class CEActiveTask: ObservableObject, Identifiable, Hashable {
     /// Prevents tasks overwriting each other.
     /// Say a user cancels one task, then runs it immediately, the cancel message should show and then the
     /// starting message should show. If we don't add this modifier the starting message will be deleted.
-    var activeTaskID: String = UUID().uuidString
+    var activeTaskID: UUID = UUID()
 
     var taskId: String {
-        task.id.uuidString + "-" + activeTaskID
+        task.id.uuidString + "-" + activeTaskID.uuidString
     }
 
-    var process: Process?
-    var outputPipe: Pipe?
     var workspaceURL: URL?
 
     private var cancellables = Set<AnyCancellable>()
 
     init(task: CETask) {
         self.task = task
-        self.process = Process()
-        self.outputPipe = Pipe()
 
         self.task.objectWillChange.sink { _ in
             self.objectWillChange.send()
         }.store(in: &cancellables)
     }
 
-    func run(workspaceURL: URL? = nil) {
+    func run(workspaceURL: URL) {
         self.workspaceURL = workspaceURL
-        self.activeTaskID = UUID().uuidString // generate a new ID for this run
-        Task {
-            // Reconstruct the full command to ensure it executes in the correct directory.
-            // Because: CETask only contains information about the relative path.
-            let fullCommand: String
-            if let workspaceURL = workspaceURL {
-                fullCommand = "cd \(workspaceURL.relativePath.escapedDirectory()) && \(task.fullCommand)"
-            } else {
-                fullCommand = task.fullCommand
-            }
-            guard let process, let outputPipe else { return }
+        self.activeTaskID = UUID() // generate a new ID for this run
 
-            await updateTaskStatus(to: .running)
-            createStatusTaskNotification()
+        updateTaskStatus(to: .running)
+        createStatusTaskNotification()
 
-            process.terminationHandler = { [weak self] capturedProcess in
-                if let self {
-                    Task {
-                        await self.handleProcessFinished(terminationStatus: capturedProcess.terminationStatus)
-                    }
-                }
-            }
+        let view = output ?? CEActiveTaskTerminalView(activeTask: self)
+        view.startProcess(workspaceURL: workspaceURL, shell: nil)
 
-            outputPipe.fileHandleForReading.readabilityHandler = { fileHandle in
-                if let data = String(bytes: fileHandle.availableData, encoding: .utf8),
-                   !data.isEmpty {
-                    Task {
-                        await self.updateOutput(data)
-                    }
-                }
-            }
-
-            do {
-                try Shell.executeCommandWithShell(
-                    process: process,
-                    command: fullCommand,
-                    environmentVariables: self.task.environmentVariablesDictionary,
-                    shell: Shell.zsh, // TODO: Let user decide which shell to use
-                    outputPipe: outputPipe
-                )
-            } catch { print(error) }
-        }
+        output = view
     }
 
-    func handleProcessFinished(terminationStatus: Int32) async {
-        handleTerminationStatus(terminationStatus)
-
+    func handleProcessFinished(terminationStatus: Int32) {
         if terminationStatus == 0 {
-            await updateOutput("\nFinished running \(task.name).\n\n")
-            await updateTaskStatus(to: .finished)
+            output?.newline()
+            output?.sendOutputMessage("Finished running \(task.name).")
+            output?.newline()
+
+            updateTaskStatus(to: .finished)
             updateTaskNotification(
                 title: "Finished Running \(task.name)",
                 message: "",
                 isLoading: false
             )
         } else if terminationStatus == 15 {
-            await updateOutput("\n\(task.name) cancelled.\n\n")
-            await updateTaskStatus(to: .notRunning)
+            output?.newline()
+            output?.sendOutputMessage("\(task.name) cancelled.")
+            output?.newline()
+
+            updateTaskStatus(to: .notRunning)
             updateTaskNotification(
                 title: "\(task.name) cancelled",
                 message: "",
                 isLoading: false
             )
         } else {
-            await updateOutput("\nFailed to run \(task.name).\n\n")
-            await updateTaskStatus(to: .failed)
+            output?.newline()
+            output?.sendOutputMessage("Failed to run \(task.name)")
+            output?.newline()
+
+            updateTaskStatus(to: .failed)
             updateTaskNotification(
                 title: "Failed Running \(task.name)",
                 message: "",
                 isLoading: false
             )
         }
-        outputPipe?.fileHandleForReading.readabilityHandler = nil
 
         deleteStatusTaskNotification()
     }
 
-    func renew() {
-        if let process {
-            if process.isRunning {
-                process.terminate()
-                process.waitUntilExit()
+    func suspend() {
+        if let output, status == .running {
+            for pid in output.runningChildProcesses() {
+                kill(pid, SIGSTOP)
             }
-            self.process = Process()
-            outputPipe = Pipe()
+            updateTaskStatus(to: .stopped)
         }
     }
 
-    func suspend() {
-        if let process, status == .running {
-            process.suspend()
-            Task {
-                await updateTaskStatus(to: .stopped)
+    func resume() {
+        if let output, status == .stopped {
+            for pid in output.runningChildProcesses() {
+                kill(pid, SIGCONT)
             }
+            updateTaskStatus(to: .running)
         }
     }
 
-    func resume() {
-        if let process, status == .stopped {
-            process.resume()
-            Task {
-                await updateTaskStatus(to: .running)
+    func terminate() {
+        if let output {
+            for pid in output.runningChildProcesses() {
+                kill(pid, SIGTERM)
+            }
+        }
+    }
+
+    func interrupt() {
+        if let output {
+            for pid in output.runningChildProcesses() {
+                kill(pid, SIGINT)
             }
         }
     }
 
     func clearOutput() {
-        output = ""
+        // TODO: - Clear Output
+//        output?.feed(text: "\033[2J") // same command as 'clear'
     }
 
     private func createStatusTaskNotification() {
@@ -199,23 +177,15 @@ class CEActiveTask: ObservableObject, Identifiable, Hashable {
         NotificationCenter.default.post(name: .taskNotification, object: nil, userInfo: userInfo)
     }
 
-    private func updateTaskStatus(to taskStatus: CETaskStatus) async {
-        await MainActor.run {
-            self.status = taskStatus
-        }
-    }
-
-    /// Updates the progress and output values on the main thread`
-    private func updateOutput(_ output: String) async {
-        await MainActor.run {
-            self.output += output
-        }
+    @MainActor
+    private func updateTaskStatus(to taskStatus: CETaskStatus) {
+        self.status = taskStatus
     }
 
     static func == (lhs: CEActiveTask, rhs: CEActiveTask) -> Bool {
         return lhs.output == rhs.output &&
         lhs.status == rhs.status &&
-        lhs.process == rhs.process &&
+        lhs.output?.process.shellPid == rhs.output?.process.shellPid &&
         lhs.task == rhs.task
     }
 
@@ -224,24 +194,4 @@ class CEActiveTask: ObservableObject, Identifiable, Hashable {
         hasher.combine(status)
         hasher.combine(task)
     }
-
-    // OPTIONAL
-    func handleTerminationStatus(_ status: Int32) {
-        switch status {
-        case 0:
-            print("Process completed successfully.")
-        case 1:
-            print("General error.")
-        case 2:
-            print("Misuse of shell builtins.")
-        case 126:
-            print("Command invoked cannot execute.")
-        case 127:
-            print("Command not found.")
-        case 128:
-            print("Invalid argument to exit.")
-        default:
-            print("Process ended with exit code \(status).")
-        }
-    }
 }

CodeEdit/Features/Tasks/TaskManager.swift

@@ -16,10 +16,10 @@ class TaskManager: ObservableObject {
 
     @ObservedObject var workspaceSettings: CEWorkspaceSettingsData
 
-    private var workspaceURL: URL?
+    private var workspaceURL: URL
     private var settingsListener: AnyCancellable?
 
-    init(workspaceSettings: CEWorkspaceSettingsData, workspaceURL: URL? = nil) {
+    init(workspaceSettings: CEWorkspaceSettingsData, workspaceURL: URL) {
         self.workspaceURL = workspaceURL
         self.workspaceSettings = workspaceSettings
 
@@ -71,7 +71,7 @@ class TaskManager: ObservableObject {
         // A process can only be started once, that means we have to renew the Process and Pipe
         // but don't initialize a new object.
         if let activeTask = activeTasks[task.id] {
-            activeTask.renew()
+            activeTask.terminate()
             // Wait until the task is no longer running.
             // The termination handler is asynchronous, so we avoid a race condition using this.
             while activeTask.status == .running {
@@ -138,10 +138,9 @@ class TaskManager: ObservableObject {
     ///
     /// - Parameter taskID: The ID of the task to terminate.
     func terminateTask(taskID: UUID) {
-        guard let process = activeTasks[taskID]?.process, process.isRunning else {
-            return
+        if let activeTask = activeTasks[taskID] {
+            activeTask.terminate()
         }
-        process.terminate()
     }
 
     /// Interrupts the task associated with the given task ID.
@@ -156,10 +155,9 @@ class TaskManager: ObservableObject {
     ///
     /// - Parameter taskID: The ID of the task to interrupt.
     func interruptTask(taskID: UUID) {
-        guard let process = activeTasks[taskID]?.process, process.isRunning else {
-            return
+        if let activeTask = activeTasks[taskID] {
+            activeTask.interrupt()
         }
-        process.interrupt()
     }
 
     func stopAllTasks() {