Listen for ctrl-c during provider request

[jamadeo]

Prior, we'd only start listening during the stream. So if the user hit ctrl-c while we waited for the provider response (before any streaming started), we wouldn't handle it.

fixes #4265

Also treats ctrl-D as exit, so we don't print "Error: EOF" when you exit this way.

[Copilot]

Pull Request Overview

This PR refactors interrupt handling to centralize Ctrl+C signal handling through a cancellation token pattern, and adds support for EOF (End of File) signal handling in user input.

Key changes:

• Centralized Ctrl+C handling via a spawned task that cancels a token instead of directly handling the signal in the select loop
• Modified the event loop to listen for cancellation token instead of raw Ctrl+C signals
• Added EOF signal handling to exit the session gracefully

Reviewed Changes

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

File	Description
crates/goose-cli/src/session/mod.rs	Refactored interrupt handling to use a spawned task for Ctrl+C that triggers cancellation token, and updated the select loop to listen for cancellation instead of raw signals
crates/goose-cli/src/session/input.rs	Added EOF (Ctrl+D) signal handling to exit the session, matching the behavior of Ctrl+C when the line is empty

---

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

[Copilot]

The spawned task is not tracked or joined, which could lead to it outliving the function scope. If process_agent_response returns before Ctrl+C is pressed, the spawned task will continue running and may trigger cancellation on an already-consumed token. Consider storing the task handle and aborting it before the function returns, or using tokio::select! with a scoped spawn pattern to ensure proper cleanup.

[Copilot]

The spawned task silently ignores any errors from the spawn itself and only checks if ctrl_c succeeded. Consider handling potential spawn failures or at minimum documenting why they can be safely ignored. Also, the task only handles a single Ctrl+C signal - subsequent signals won't be caught. Consider using a loop to handle multiple interrupts or documenting this single-signal behavior.

Suggested change

	tokio::spawn(async move {
	if tokio::signal::ctrl_c().await.is_ok() {
	cancel_token_interrupt.cancel();
	// Spawn a background task to listen for Ctrl+C signals and cancel the token.
	// We loop to handle multiple interrupts, and log any errors from ctrl_c.
	// Note: tokio::spawn is infallible unless the runtime is shutting down, in which case
	// the process is likely exiting anyway, so we can safely ignore errors from spawn.
	tokio::spawn(async move {
	loop {
	match tokio::signal::ctrl_c().await {
	Ok(_) => {
	cancel_token_interrupt.cancel();
	}
	Err(e) => {
	// Log the error and break the loop.
	eprintln!("Failed to listen for Ctrl+C: {}", e);
	break;
	}
	}