Adding cross-platform kill command (#1326)

* Adding kill command, unclean code

* Removing old comments

* Added quiet option, supports variable number of ids

* Made it per_item_command, calling commands directly without the shell

src/cli.rs

@@ -271,6 +271,7 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
             per_item_command(Calc),
             per_item_command(Mkdir),
             per_item_command(Move),
+            per_item_command(Kill),
             whole_stream_command(Version),
             whole_stream_command(Clear),
             whole_stream_command(What),

src/commands.rs

@@ -119,6 +119,8 @@ pub(crate) use default::Default;
 pub(crate) use du::Du;
 pub(crate) use echo::Echo;
 pub(crate) use edit::Edit;
+pub(crate) mod kill;
+pub(crate) use kill::Kill;
 pub(crate) mod clear;
 pub(crate) use clear::Clear;
 pub(crate) use enter::Enter;

src/commands/kill.rs

@@ -0,0 +1,104 @@
+use crate::commands::command::RunnablePerItemContext;
+use crate::context::CommandRegistry;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{CallInfo, Signature, SyntaxShape, Value};
+use nu_source::Tagged;
+use std::process::{Command, Stdio};
+
+pub struct Kill;
+
+#[derive(Deserialize)]
+pub struct KillArgs {
+    pub pid: Tagged<u64>,
+    pub rest: Vec<Tagged<u64>>,
+    pub force: Tagged<bool>,
+    pub quiet: Tagged<bool>,
+}
+
+impl PerItemCommand for Kill {
+    fn name(&self) -> &str {
+        "kill"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("kill")
+            .required(
+                "pid",
+                SyntaxShape::Int,
+                "process id of process that is to be killed",
+            )
+            .rest(SyntaxShape::Int, "rest of processes to kill")
+            .switch("force", "forcefully kill the process")
+            .switch("quiet", "won't print anything to the console")
+    }
+
+    fn usage(&self) -> &str {
+        "Kill a process using the process id."
+    }
+
+    fn run(
+        &self,
+        call_info: &CallInfo,
+        _registry: &CommandRegistry,
+        raw_args: &RawCommandArgs,
+        _input: Value,
+    ) -> Result<OutputStream, ShellError> {
+        call_info
+            .process(&raw_args.shell_manager, raw_args.ctrl_c.clone(), kill)?
+            .run()
+    }
+}
+
+fn kill(
+    KillArgs {
+        pid,
+        rest,
+        force,
+        quiet,
+    }: KillArgs,
+    _context: &RunnablePerItemContext,
+) -> Result<OutputStream, ShellError> {
+    let mut cmd = if cfg!(windows) {
+        let mut cmd = Command::new("taskkill");
+
+        if *force {
+            cmd.arg("/F");
+        }
+
+        cmd.arg("/PID");
+        cmd.arg(pid.item().to_string());
+
+        // each pid must written as `/PID 0` otherwise
+        // taskkill will act as `killall` unix command
+        for id in &rest {
+            cmd.arg("/PID");
+            cmd.arg(id.item().to_string());
+        }
+
+        cmd
+    } else {
+        let mut cmd = Command::new("kill");
+
+        if *force {
+            cmd.arg("-9");
+        }
+
+        cmd.arg(pid.item().to_string());
+
+        cmd.args(rest.iter().map(move |id| id.item().to_string()));
+
+        cmd
+    };
+
+    // pipe everything to null
+    if *quiet {
+        cmd.stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+    }
+
+    cmd.status().expect("failed to execute shell command");
+
+    Ok(OutputStream::empty())
+}