refactor(process): Improve subprocess signaling and lifecycle management

[ChristianPraiss]

⚙️ Refactor(process): Improve Subprocess Signaling and Lifecycle Management

This pull request refactors how subprocesses are executed across key components (exec, main, and TUI) by implementing standardized, advanced signal forwarding logic.

✨ Motivation

Currently, graceful handling of signals upon process shutdown could be inconsistent. This change aims to align the component's behavior more closely with standard shell conventions for subprocess termination, ensuring a reliable user experience even when interrupts (like Ctrl+C) are issued.

🚀 Changes Implemented

The core change is the introduction and usage of runWithSignalForwarding. This function:

1. Standardizes Termination: It ensures that when a process needs to shut down gracefully, it first attempts a soft termination via SIGINT (the signal typically caught by Ctrl+C).
2. Improves Resilience: If multiple interruption signals occur, subsequent terminations fall back to a mandatory hard kill (kill()) for robust resource cleanup.
3. Extends Coverage: This pattern is applied not only to standard processes but also extended within the TUI component (tui.go) to manage the dedicated lifecycle of panels and subprocesses consistently.

Technical Details:

• The new signal flow improves reliability by clearly defining phases: graceful attempt $\rightarrow$ hard kill if needed.

✅ Verification & Testing

Please verify the following:

• Subprocesses initiated from the main execution path correctly respond to single Ctrl+C interruptions (SIGINT).
• Repeated interruption signals result in successful and timely cleanup using kill().
• The TUI component maintains signal integrity when panels or internal subprocesses are terminated.

📚 Review Notes

• This change is a critical structural refactor to the process handling layer, making our application more predictable during shutdowns.

[Copilot]

Pull request overview

Refactors subprocess execution to improve shutdown behavior by introducing centralized signal-handling logic and extending “graceful then force” termination semantics to the TUI’s panel subprocess lifecycle.

Changes:

• Replaces direct cmd.Run() usage with a shared runWithSignalForwarding() helper for consistent SIGINT/SIGTERM handling and escalation behavior.
• Enhances the TUI quit flow to first request graceful termination of running panels, then force-kill on repeated quit.
• Tracks per-panel subprocess handles so the TUI can signal them on exit instead of leaving them running.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 2 comments.

File	Description
tui.go	Adds panel process tracking and a two-phase quit flow (graceful interrupt, then force kill) with updated status bar messaging.
main.go	Switches the fallback docker compose <command> execution path to use runWithSignalForwarding().
exec.go	Introduces runWithSignalForwarding() and applies it to subprocess execution paths (scripts and exec).

Comments suppressed due to low confidence (1)

exec.go:130

• Forwarding SIGINT to cmd.Process here can double-deliver Ctrl+C to the child on Unix, because SIGINT is already sent by the terminal to the entire foreground process group (parent + child). Since we’re not creating a separate process group for cmd (no SysProcAttr.Setpgid usage in the repo), this means a single Ctrl+C can be seen twice by the child, defeating the intended “one Ctrl+C = graceful” behavior.

			case sig := <-sigCh:
				if !forwarded {
					forwarded = true
					_ = cmd.Process.Signal(sig)
				} else {

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.