Stop command execution and exit process in raw mode

The following code executes a command, then enables you to exit the process with Ctrl + C:

use std::process::Command;

use termion::event::Key;
use termion::input::TermRead;
use termion::raw::IntoRawMode;

use std::io::{stdin, stdout, Write};

fn main() {
    let stdin = stdin();
    let mut stdout = stdout().into_raw_mode().unwrap();
    let mut command = Command::new("script");

    command
        .arg("-qec")
        .arg("sleep 5 && echo test")
        .arg("/dev/null");

    let output = command.output();

    println!("output: {:?}", output);

    for c in stdin.keys() {
        match c.unwrap() {
            Key::Char(c) => println!("{}\r\n", c),
            Key::Ctrl('c') => {
                println!("Ctrl + C\r\n");
                write!(stdout, "{}", termion::cursor::Show).unwrap();
                std::process::exit(0);
            }
            _ => {}
        }
        stdout.flush().unwrap();
    }
}

Rust Playground

You have to wait for the command to be executed to be able to press Ctrl + C and exit the program.

How to listen to Ctrl + C in the background so that the process can exit even when the command is running (interrupting the command like in non-raw mode)?

I'm not sure if this is the best method, but it works. I spawned three concurrent threads: one for stdout, another for stderr, and a third one for listening to Ctrl + C.

use std::{
    io::{BufRead, BufReader},
    process::{Command, Stdio},
};

use termion::event::Key;
use termion::input::TermRead;
use termion::raw::IntoRawMode;

use std::io::{stdin, stdout, Write};

fn main() {
    let stdin = stdin();
    
    std::thread::spawn(move || {
        for c in stdin().keys() {
            match c.unwrap() {
                Key::Ctrl('c') => {
                    println!("Ctrl + C\r\n");
                    std::process::exit(0);
                }
                _ => {}
            }
        }
    });
    
    let mut stdout = stdout().into_raw_mode().unwrap();
    
    stdout.flush().unwrap();

    let mut command = Command::new("script");

    command
        .arg("-qec")
        .arg("sleep 5 && echo test")
        .arg("/dev/null");

    command.stdout(Stdio::piped());
    command.stderr(Stdio::piped());

    let mut child = command.spawn().expect("failed to spawn command");
    let stdout_pipe = child.stdout.take().unwrap();
    let stdout_reader = BufReader::new(stdout_pipe);
    let stderr_pipe = child.stderr.take().unwrap();
    let stderr_reader = BufReader::new(stderr_pipe);

    let stdout_thread = std::thread::spawn(move || {
        for line in stdout_reader.lines() {
            if let Ok(line) = line {
                print!("{}\r\n", line);
            }
        }
    });

    let stderr_thread = std::thread::spawn(move || {
        for line in stderr_reader.lines() {
            if let Ok(line) = line {
                print!("{}\r\n", line);
            }
        }
    });

    let status = child.wait().expect("failed to wait for command");

    stdout_thread.join().expect("failed to join stdout thread");
    stderr_thread.join().expect("failed to join stderr thread");

    println!("status: {}", status);
}

Note: ctrl doesn't seem to work with Termion's raw mode.