remove os_pipe dependency

Author: dsherret

Cargo.lock

@@ -11,15 +11,14 @@ description = "Cross platform scripting for deno task"
 
 [features]
 default = ["shell"]
-shell = ["deno_path_util", "futures", "glob", "nix", "os_pipe", "path-dedot", "tokio", "windows-sys", "sys_traits", "which"]
+shell = ["deno_path_util", "futures", "glob", "nix", "path-dedot", "tokio", "windows-sys", "sys_traits", "which"]
 serialization = ["serde"]
 
 [dependencies]
 anyhow = "1.0.75"
 futures = { version = "0.3.29", optional = true }
 glob = { version = "0.3.1", optional = true }
 path-dedot = { version = "3.1.1", optional = true }
-os_pipe = { version = "1.1.4", optional = true }
 serde = { version = "1", features = ["derive"], optional = true }
 monch = "0.5.0"
 thiserror = "2.0.9"

Cargo.toml

@@ -251,7 +251,7 @@ impl ExecuteResult {
 /// Reader side of a pipe.
 #[derive(Debug)]
 pub enum ShellPipeReader {
-  OsPipe(os_pipe::PipeReader),
+  OsPipe(std::io::PipeReader),
   StdFile(std::fs::File),
 }
 
@@ -266,10 +266,32 @@ impl Clone for ShellPipeReader {
 
 impl ShellPipeReader {
   pub fn stdin() -> ShellPipeReader {
-    ShellPipeReader::from_raw(os_pipe::dup_stdin().unwrap())
+    #[cfg(unix)]
+    pub fn dup_stdin_as_pipe_reader() -> std::io::PipeReader {
+        use std::os::fd::AsFd;
+        use std::os::fd::IntoRawFd;
+        use std::os::fd::FromRawFd;
+        let owned = std::io::stdin().as_fd().try_clone_to_owned().unwrap();
+        let raw = owned.into_raw_fd(); // transfer ownership
+        // SAFETY: `raw` is a fresh, owned fd; PipeReader will close it.
+        unsafe { std::io::PipeReader::from_raw_fd(raw) }
+    }
+
+    #[cfg(windows)]
+    pub fn dup_stdin_as_pipe_reader() -> io::Result<PipeReader> {
+        use std::os::windows::io::AsHandle;
+        use std::os::windows::io::IntoRawHandle;
+        use std::os::windows::io::FromRawHandle;
+        let owned = io::stdin().as_handle().try_clone_to_owned().unwrap();
+        let raw = owned.into_raw_handle(); // transfer ownership
+        // SAFETY: `raw` is a fresh, owned HANDLE; PipeReader will close it.
+        unsafe { std::io::PipeReader::from_raw_handle(raw) }
+    }
+
+    ShellPipeReader::OsPipe(dup_stdin_as_pipe_reader())
   }
 
-  pub fn from_raw(reader: os_pipe::PipeReader) -> Self {
+  pub fn from_raw(reader: std::io::PipeReader) -> Self {
     Self::OsPipe(reader)
   }
 
@@ -281,7 +303,7 @@ impl ShellPipeReader {
   #[allow(clippy::should_implement_trait)]
   pub fn from_str(data: &str) -> Self {
     use std::io::Write;
-    let (read, mut write) = os_pipe::pipe().unwrap();
+    let (read, mut write) = std::io::pipe().unwrap();
     write.write_all(data.as_bytes()).unwrap();
     Self::OsPipe(read)
   }
@@ -369,7 +391,7 @@ impl ShellPipeReader {
 /// prevent deadlocks where the reader hangs waiting for a read.
 #[derive(Debug)]
 pub enum ShellPipeWriter {
-  OsPipe(os_pipe::PipeWriter),
+  OsPipe(std::io::PipeWriter),
   StdFile(std::fs::File),
   // For stdout and stderr, instead of directly duplicating the raw pipes
   // and putting them in a ShellPipeWriter::OsPipe(...), we use Rust std's
@@ -468,7 +490,7 @@ impl ShellPipeWriter {
 
 /// Used to communicate between commands.
 pub fn pipe() -> (ShellPipeReader, ShellPipeWriter) {
-  let (reader, writer) = os_pipe::pipe().unwrap();
+  let (reader, writer) = std::io::pipe().unwrap();
   (
     ShellPipeReader::OsPipe(reader),
     ShellPipeWriter::OsPipe(writer),