feat: --write-to-stdout to write result to stdout (UNIX only)

Author: ynqa

Cargo.lock

@@ -17,6 +17,7 @@ duration-string = { version = "0.5.3", features = ["serde"] }
 derive_builder = "0.20.2"
 dirs = "6.0.0"
 futures = "0.3.32"
+libc = "0.2.177"
 serde = "1.0.228"
 termcfg = { version = "0.2.0", features = ["crossterm_0_29_0"] }
 tokio = { version = "1.49.0", features = ["full"] }

Cargo.toml

@@ -111,8 +111,12 @@ cargo install jnv
 
 ```bash
 cat data.json | jnv
+
 # or
 jnv data.json
+
+# or write current result to stdout on exit (UNIX only)
+cat data.json | jnv --write-to-stdout | some-command
 ```
 
 ## Keymap
@@ -180,6 +184,7 @@ Arguments:
 Options:
   -c, --config <CONFIG_FILE>             Path to the configuration file.
       --default-filter <DEFAULT_FILTER>  Default jq filter to apply to the input data
+      --write-to-stdout                  Write the current JSON result to stdout when exiting
   -h, --help                             Print help (see more with '--help')
   -V, --version                          Print version
 ```

README.md

@@ -1,6 +1,8 @@
+#[cfg(unix)]
+use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
 use std::{
     fs::File,
-    io::{self, Read, Write},
+    io::{self, IsTerminal, Read, Write},
     path::PathBuf,
 };
 
@@ -70,6 +72,12 @@ pub struct Args {
         "
     )]
     default_filter: Option<String>,
+
+    #[arg(
+        long = "write-to-stdout",
+        help = "Write the current JSON result to stdout when exiting"
+    )]
+    write_to_stdout: bool,
 }
 
 /// Parses the input based on the provided arguments.
@@ -141,6 +149,80 @@ fn determine_config_file(config_path: Option<PathBuf>) -> anyhow::Result<PathBuf
     Ok(default_path)
 }
 
+struct StdoutRedirect {
+    #[cfg(unix)]
+    saved_stdout: Option<OwnedFd>,
+}
+
+impl StdoutRedirect {
+    fn for_tui(write_to_stdout: bool) -> anyhow::Result<Self> {
+        if !write_to_stdout || io::stdout().is_terminal() {
+            return Ok(Self {
+                #[cfg(unix)]
+                saved_stdout: None,
+            });
+        }
+
+        #[cfg(unix)]
+        {
+            let tty = File::options()
+                .read(true)
+                .write(true)
+                .open("/dev/tty")
+                .map_err(|e| anyhow!("Failed to open /dev/tty for TUI rendering: {e}"))?;
+
+            let saved_fd = unsafe { libc::dup(libc::STDOUT_FILENO) };
+            if saved_fd < 0 {
+                return Err(anyhow!(
+                    "Failed to duplicate stdout: {}",
+                    io::Error::last_os_error()
+                ));
+            }
+
+            let redirected = unsafe { libc::dup2(tty.as_raw_fd(), libc::STDOUT_FILENO) };
+            if redirected < 0 {
+                let _ = unsafe { libc::close(saved_fd) };
+                return Err(anyhow!(
+                    "Failed to redirect stdout to /dev/tty: {}",
+                    io::Error::last_os_error()
+                ));
+            }
+
+            Ok(Self {
+                saved_stdout: Some(unsafe { OwnedFd::from_raw_fd(saved_fd) }),
+            })
+        }
+
+        #[cfg(not(unix))]
+        {
+            Err(anyhow!(
+                "`--write-to-stdout` with piped stdout is not supported on this platform"
+            ))
+        }
+    }
+
+    fn restore(&mut self) -> anyhow::Result<()> {
+        #[cfg(unix)]
+        if let Some(saved_stdout) = self.saved_stdout.take() {
+            let restored = unsafe { libc::dup2(saved_stdout.as_raw_fd(), libc::STDOUT_FILENO) };
+            if restored < 0 {
+                return Err(anyhow!(
+                    "Failed to restore stdout: {}",
+                    io::Error::last_os_error()
+                ));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Drop for StdoutRedirect {
+    fn drop(&mut self) {
+        let _ = self.restore();
+    }
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let args = Args::parse();
@@ -194,17 +276,31 @@ async fn main() -> anyhow::Result<()> {
         config.keybinds.on_editor.clone(),
     );
 
+    let mut stdout_redirect = StdoutRedirect::for_tui(args.write_to_stdout)?;
+
     // TODO: put all logics here.
-    prompt::run(
+    let maybe_output = prompt::run(
         item,
         config.reactivity_control,
         provider,
         editor,
         loading_suggestions_task,
         config.no_hint,
         config.keybinds,
+        args.write_to_stdout,
     )
-    .await?;
+    .await;
+
+    stdout_redirect.restore()?;
+    let maybe_output = maybe_output?;
+
+    if let Some(output) = maybe_output {
+        let mut stdout = io::stdout();
+        stdout.write_all(output.as_bytes())?;
+        if !output.ends_with('\n') {
+            stdout.write_all(b"\n")?;
+        }
+    }
 
     Ok(())
 }

src/main.rs

@@ -123,7 +123,8 @@ pub async fn run<T: ViewProvider + SearchProvider>(
     loading_suggestions_task: JoinHandle<anyhow::Result<()>>,
     no_hint: bool,
     keybinds: Keybinds,
-) -> anyhow::Result<()> {
+    write_to_stdout: bool,
+) -> anyhow::Result<Option<String>> {
     enable_raw_mode()?;
     execute!(io::stdout(), cursor::Hide)?;
 
@@ -385,11 +386,11 @@ pub async fn run<T: ViewProvider + SearchProvider>(
         })
     };
 
+    let shared_visualizer = Arc::new(Mutex::new(initializing.await?));
     let processor_task: JoinHandle<anyhow::Result<()>> = {
         let shared_renderer = shared_renderer.clone();
         let shared_editor = shared_editor.clone();
-        let visualizer = initializing.await?;
-        let shared_visualizer = Arc::new(Mutex::new(visualizer));
+        let shared_visualizer = shared_visualizer.clone();
         tokio::spawn(async move {
             loop {
                 tokio::select! {
@@ -460,6 +461,13 @@ pub async fn run<T: ViewProvider + SearchProvider>(
 
     main_task.await??;
 
+    let output = if write_to_stdout {
+        let visualizer = shared_visualizer.lock().await;
+        Some(visualizer.content_to_copy().await)
+    } else {
+        None
+    };
+
     loading_suggestions_task.abort();
     spinning.abort();
     query_debouncer.abort();
@@ -470,5 +478,5 @@ pub async fn run<T: ViewProvider + SearchProvider>(
     execute!(io::stdout(), cursor::Show, DisableMouseCapture)?;
     disable_raw_mode()?;
 
-    Ok(())
+    Ok(output)
 }