How do I ensure my long running process terminates when my macOS app exits?

Below is an explanation of your options along with code examples outlining a common approach.

---

Why the Process Keeps Running

When you launch a child process (in your example a local server) with Process (or NSTask), that process is independent from your app’s life cycle. If your app is terminated normally it can still (and will) be left running. Furthermore, if the app is force quit (or killed with kill –9), there is no opportunity to perform cleanup and the child process is orphaned and adopted by launchd.

---

Option 1: Terminate the Process During Normal Termination

You can hold a reference to the launched process and, when your app is about to terminate (for example in your implementation of the App Delegate’s applicationWillTerminate(_:) method), explicitly call terminate() on the process. For example:

SWIFTCopied
class AppDelegate: NSObject, NSApplicationDelegate {
    var process: Process?

    func applicationDidFinishLaunching(_ notification: Notification) {
        let task = Process()
        task.launchPath = "/bin/zsh"
        task.arguments = ["-c", "'(command)'"]
        self.process = task
        
        do {
            try task.run()
        } catch {
            print("Failed to run process: \(error)")
        }
    }
    
    func applicationWillTerminate(_ notification: Notification) {
        // Ask the process to terminate gracefully.
        process?.terminate()
        // Optionally wait until it exits if needed.
        process?.waitUntilExit()
    }
}

Note: This approach works when the app can run termination code and is not abruptly killed.

---

Option 2: Have the Child Process Monitor Its Parent

Because there’s no way to intercept signals like SIGKILL or other abrupt terminations from the parent (force quit, crash, kill ­–9), a common workaround is to have the child process periodically check whether its parent is still alive. In UNIX-like environments, the child can check its parent process ID (using getppid()). If the parent is no longer alive (typically getppid() returns 1, meaning it is now adopted by launchd), then it can choose to terminate itself.

For example, in your server’s code (assuming it’s something you can modify):

SWIFTCopied
import Foundation

func monitorParent() {
    DispatchQueue.global(qos: .background).async {
        while true {
            // Check every second (or on an interval you deem appropriate).
            sleep(1)
            if getppid() == 1 {
                print("Parent process has exited, shutting down.")
                exit(0)
            }
        }
    }
}

// Call monitorParent() early in your server's execution.
monitorParent()

This pattern ensures that if your app dies in a non-graceful way, your child process can detect that it has been orphaned and exit on its own.

---

Limitations

Unfortunately, there is no foolproof method to ensure the child process is terminated if your app is killed abruptly (e.g., via kill –9) because:

• The operating system does not provide a mechanism for a process to run cleanup code when it is force-quit.
• System signals like SIGKILL cannot be intercepted to perform cleanup.

Therefore, using a combination of a termination handler (when possible) and having the child monitor its parent is a common and practical solution.

---

Summary

• During normal termination: Keep a reference to the Process and explicitly terminate it in applicationWillTerminate(_:).
• For abrupt termination (force quit/crash): Modify the child process to periodically check getppid(), and exit if it becomes orphaned.

By adopting these approaches, you can improve the likelihood that the long running process is shut down when your app terminates, even though there is no perfect solution for non-graceful exits.