Document cargo install in README.md

Cargo.lock

@@ -592,7 +592,7 @@ dependencies = [
 
 [[package]]
 name = "ntfy-run"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "clap",
  "itertools",

Cargo.toml

@@ -1,7 +1,19 @@
 [package]
 name = "ntfy-run"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
+authors = ["Quantum <me@quantum5.ca>"]
+description = "ntfy-run is a tool to run a command, capture its output, and send it to a ntfy server."
+readme = "README.md"
+homepage = "https://github.com/quantum5/ntfy-run"
+repository = "https://github.com/quantum5/ntfy-run"
+license = "GPL-3.0-or-later"
+keywords = ["ntfy", "cron", "notifications", "utility"]
+categories = ["command-line-interface"]
+
+exclude = [
+    ".github/*"
+]
 
 [dependencies]
 clap = { version = "4.5.20", features = ["derive", "env"] }

README.md

@@ -16,7 +16,13 @@ sudo wget https://github.com/quantum5/ntfy-run/releases/latest/download/ntfy-run
 sudo chmod a+x /usr/local/bin/ntfy-run
 ```
 
-Alternatively, build it yourself:
+You can also install the latest release with `cargo`:
+
+```bash
+cargo install ntfy-run
+```
+
+Finally, you can build the latest Git version yourself:
 
 ```bash
 git clone https://github.com/quantum5/ntfy-run.git

src/main.rs

@@ -1,13 +1,13 @@
-use crate::runner::CaptureError;
+use crate::runner::{CaptureError, CapturedOutput};
 use clap::Parser;
-use runner::CapturedOutput;
+use std::process::exit;
 
 mod quote;
 mod runner;
 mod tap_stream;
 
 #[derive(Parser)]
-/// Tool to run a command, capture its output, and send it to ntfy.
+#[command(version, about)]
 struct Cli {
     /// URL of the ntfy server and topic, e.g. https://ntfy.sh/topic
     #[arg(short = 'n', long = "ntfy-url", env = "NTFY_URL", alias = "url")]
@@ -100,7 +100,8 @@ fn format_post_body(output: CapturedOutput) -> String {
     }];
 
     if !output.errors.is_empty() {
-        fragments.push("==================== Errors ====================".to_string());
+        fragments.push("".to_string());
+        fragments.push("========== Errors ==========".to_string());
         for error in &output.errors {
             fragments.push(match error {
                 CaptureError::Spawn(error) => format!("Spawn error: {}", error),
@@ -109,19 +110,18 @@ fn format_post_body(output: CapturedOutput) -> String {
                 CaptureError::Wait(error) => format!("Error while waiting for process: {}", error),
             });
         }
-        fragments.push("\n".to_string());
     }
 
     if !output.stdout.is_empty() {
-        fragments.push("==================== STDOUT ====================".to_string());
+        fragments.push("".to_string());
-        fragments.push(String::from_utf8_lossy(&output.stdout).into_owned());
+        fragments.push("========== STDOUT ==========".to_string());
-        fragments.push("\n".to_string());
+        fragments.push(String::from_utf8_lossy(output.stdout.trim_ascii_end()).into_owned());
     }
 
     if !output.stderr.is_empty() {
-        fragments.push("==================== STDERR ====================".to_string());
+        fragments.push("".to_string());
-        fragments.push(String::from_utf8_lossy(&output.stderr).into_owned());
+        fragments.push("========== STDERR ==========".to_string());
-        fragments.push("\n".to_string());
+        fragments.push(String::from_utf8_lossy(output.stderr.trim_ascii_end()).into_owned());
     }
 
     fragments.join("\n")
@@ -210,7 +210,13 @@ async fn main() {
     };
 
     match request.send().await.and_then(|r| r.error_for_status()) {
-        Ok(_) => (),
+        Ok(_) => exit(match status {
-        Err(error) => eprintln!("Failed to send request to ntfy: {}", error),
+            Some(code) => code.code().unwrap_or(255),
+            None => 255,
+        }),
+        Err(error) => {
+            eprintln!("Failed to send request to ntfy: {}", error);
+            exit(37)
+        }
     }
 }

src/runner.rs

@@ -1,7 +1,6 @@
 use crate::tap_stream::{ReadOrWrite, TapStream};
 use std::process::{ExitStatus, Stdio};
-use tokio::process::Command;
+use tokio::{io, process::Command, select};
-use tokio::{io, select};
 
 pub enum CaptureError {
     Spawn(io::Error),
@@ -61,29 +60,20 @@ pub async fn run_forward_and_capture(cmdline: &Vec<String>) -> CapturedOutput {
             result = stdout_tap.step(), if !stdout_eof => match result {
                 Ok(ReadOrWrite::Read(bytes)) => stdout.extend_from_slice(bytes),
                 Ok(ReadOrWrite::Written) => (),
-                Ok(ReadOrWrite::EOF) => match (stderr_eof, maybe_status) {
+                Ok(ReadOrWrite::EOF) => stdout_eof = true,
-                    (true, Some(status)) => break status,
-                    _ => stdout_eof = true,
-                },
                 Err(error) => errors.push(CaptureError::Stdout(error)),
             },
             result = stderr_tap.step(), if !stderr_eof => match result {
                 Ok(ReadOrWrite::Read(bytes)) => stderr.extend_from_slice(bytes),
                 Ok(ReadOrWrite::Written) => (),
-                Ok(ReadOrWrite::EOF) => match (stdout_eof, maybe_status) {
+                Ok(ReadOrWrite::EOF) => stderr_eof = true,
-                    (true, Some(status)) => break status,
-                    _ => stderr_eof = true,
-                },
                 Err(error) => errors.push(CaptureError::Stderr(error)),
             },
             status = child.wait(), if maybe_status.is_none() => match status {
-                Ok(status) => if stdout_eof && stderr_eof {
+                Ok(status) => maybe_status = Some(status),
-                    break status;
-                } else {
-                    maybe_status = Some(status);
-                },
                 Err(error) => errors.push(CaptureError::Wait(error)),
-            }
+            },
+            else => break maybe_status.unwrap(),
         }
     };
 

src/tap_stream.rs

@@ -34,11 +34,11 @@ impl<R: AsyncRead + Unpin, W: AsyncWrite + Unpin> TapStream<R, W> {
             self.buf_start = 0;
             self.buf_end = bytes;
 
-            Ok(if bytes == 0 {
+            if bytes == 0 {
-                ReadOrWrite::EOF
+                Ok(ReadOrWrite::EOF)
             } else {
-                ReadOrWrite::Read(&self.buffer[0..bytes])
+                Ok(ReadOrWrite::Read(&self.buffer[0..bytes]))
-            })
+            }
         } else {
             let bytes = self
                 .target