running-process 4.8.2__tar.gz → 4.8.3__tar.gz

{running_process-4.8.2 → running_process-4.8.3}/Cargo.lock

@@ -2051,7 +2051,7 @@ dependencies = [
 
 [[package]]
 name = "running-process"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "anyhow",
  "blake3",
@@ -2068,6 +2068,7 @@ dependencies = [
  "prost-build",
  "prost-types",
  "protox",
+ "running-process-platform-internal",
  "running-process-probe",
  "rusqlite",
  "serde",
@@ -2091,9 +2092,18 @@ dependencies = [
  "zstd",
 ]
 
+[[package]]
+name = "running-process-platform-internal"
+version = "4.8.3"
+dependencies = [
+ "libc",
+ "tokio",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "running-process-probe"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "blake3",
  "crash-handler",
@@ -2116,7 +2126,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-daemon"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "axum",
  "blake3",
@@ -2150,21 +2160,21 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-interposer-linux"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-probe-interposer-macos"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-probe-interposer-windows"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "retour",
  "windows-sys 0.59.0",
@@ -2172,7 +2182,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-worker"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "addr2line",
  "lzma-rs",
@@ -2190,7 +2200,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "interprocess",
  "libc",
@@ -2205,7 +2215,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-win-gnu-bridge"
-version = "4.8.2"
+version = "4.8.3"
 dependencies = [
  "windows-sys 0.59.0",
 ]

{running_process-4.8.2 → running_process-4.8.3}/Cargo.toml

@@ -7,7 +7,7 @@ members = ["crates/running-process", "crates/running-process-probe", "crates/run
 exclude = ["testbins-tokio"]
 
 [workspace.package]
-version = "4.8.2"
+version = "4.8.3"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

running_process-4.8.2/README.md → running_process-4.8.3/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: running_process
+Version: 4.8.3
+License-File: LICENSE
+Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
+Home-Page: https://github.com/zackees/running-process
+Author-email: Your Name <your.email@example.com>
+License: BSD 3-Clause License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/zackees/running-process
+Project-URL: Issues, https://github.com/zackees/running-process/issues
+Project-URL: Repository, https://github.com/zackees/running-process
+
 # running-process
 
 [![PyPI](https://img.shields.io/pypi/v/running-process)](https://pypi.org/project/running-process/) [![Crates.io](https://img.shields.io/crates/v/running-process)](https://crates.io/crates/running-process) [![codecov](https://codecov.io/gh/zackees/running-process/graph/badge.svg)](https://codecov.io/gh/zackees/running-process) [![Dependency Check](https://github.com/zackees/running-process/actions/workflows/dependency-check.yml/badge.svg)](https://github.com/zackees/running-process/actions/workflows/dependency-check.yml)
@@ -140,9 +154,19 @@ The package installs a `running-process` wrapper CLI for supervised command exec
 
 ```bash
 running-process --timeout 30 -- python -m pytest tests/test_cli.py
+running-process --wall-clock-timeout 30 -- python worker.py
+running-process --terminate-tree 12345
 running-process --find-leaks -- python worker.py
 ```
 
+`--timeout` is an inactivity deadline: continuous stdout/stderr resets it. Use
+`--wall-clock-timeout` when a command must be terminated after a fixed elapsed
+budget even while it emits output. On either timeout, `running-process` kills
+and reaps the supervised process tree through its cross-platform native layer.
+Use `--terminate-tree PID` for an already-running tree; it returns non-zero
+when the bounded native cleanup cannot verify the tree is gone. Consumers must
+not invoke platform-specific tree-kill commands themselves.
+
 `--find-leaks` tags the wrapped process tree with a unique originator marker and reports any
 descendants still alive after the direct child exits.
 
@@ -580,3 +604,4 @@ python scripts/terminate_tracked_processes.py
 - `RunningProcess(..., use_pty=True)` is no longer the preferred path; use `RunningProcess.pseudo_terminal(...)` for PTY sessions.
 - On supported Windows builds, PTY support is provided by the native Rust extension rather than a Python `winpty` fallback.
 - The test suite checks that `running_process.__version__`, package metadata, and manifest versions stay in sync.
+

running_process-4.8.2/PKG-INFO → running_process-4.8.3/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: running_process
-Version: 4.8.2
-License-File: LICENSE
-Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
-Home-Page: https://github.com/zackees/running-process
-Author-email: Your Name <your.email@example.com>
-License: BSD 3-Clause License
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Homepage, https://github.com/zackees/running-process
-Project-URL: Issues, https://github.com/zackees/running-process/issues
-Project-URL: Repository, https://github.com/zackees/running-process
-
 # running-process
 
 [![PyPI](https://img.shields.io/pypi/v/running-process)](https://pypi.org/project/running-process/) [![Crates.io](https://img.shields.io/crates/v/running-process)](https://crates.io/crates/running-process) [![codecov](https://codecov.io/gh/zackees/running-process/graph/badge.svg)](https://codecov.io/gh/zackees/running-process) [![Dependency Check](https://github.com/zackees/running-process/actions/workflows/dependency-check.yml/badge.svg)](https://github.com/zackees/running-process/actions/workflows/dependency-check.yml)
@@ -154,9 +140,19 @@ The package installs a `running-process` wrapper CLI for supervised command exec
 
 ```bash
 running-process --timeout 30 -- python -m pytest tests/test_cli.py
+running-process --wall-clock-timeout 30 -- python worker.py
+running-process --terminate-tree 12345
 running-process --find-leaks -- python worker.py
 ```
 
+`--timeout` is an inactivity deadline: continuous stdout/stderr resets it. Use
+`--wall-clock-timeout` when a command must be terminated after a fixed elapsed
+budget even while it emits output. On either timeout, `running-process` kills
+and reaps the supervised process tree through its cross-platform native layer.
+Use `--terminate-tree PID` for an already-running tree; it returns non-zero
+when the bounded native cleanup cannot verify the tree is gone. Consumers must
+not invoke platform-specific tree-kill commands themselves.
+
 `--find-leaks` tags the wrapped process tree with a unique originator marker and reports any
 descendants still alive after the direct child exits.
 
@@ -594,4 +590,3 @@ python scripts/terminate_tracked_processes.py
 - `RunningProcess(..., use_pty=True)` is no longer the preferred path; use `RunningProcess.pseudo_terminal(...)` for PTY sessions.
 - On supported Windows builds, PTY support is provided by the native Rust extension rather than a Python `winpty` fallback.
 - The test suite checks that `running_process.__version__`, package metadata, and manifest versions stay in sync.
-

{running_process-4.8.2 → running_process-4.8.3}/crates/running-process/Cargo.toml

@@ -76,6 +76,7 @@ required-features = ["client"]
 # the `runpm` binary out of the box (per Q1 resolution in #165:
 # `required-features` are not auto-activated by cargo install).
 default = ["client", "pty", "conpty-sidecar"]
+async-process = ["dep:running-process-platform-internal", "dep:tokio"]
 core = []
 telemetry = []
 pty = ["dep:portable-pty"]
@@ -167,14 +168,15 @@ sha2 = { version = "0.10", optional = true }
 getrandom = { version = "0.4", optional = true }
 # #633: schema-only dependency for the probe client facade. default-features
 # off keeps the interposer/injection machinery out — see the `probe` feature.
-running-process-probe = { path = "../running-process-probe", version = "4.8.2", default-features = false, optional = true }
+running-process-probe = { path = "../running-process-probe", version = "4.8.3", default-features = false, optional = true }
+running-process-platform-internal = { path = "../running-process-platform-internal", version = "4.8.3", optional = true }
 # Wave 5 of #165: daemon-feature deps. All optional.
 # tokio: `client-async` (#414) only needs the `rt` (spawn_blocking)
 # and `time` (`tokio::time::timeout`) features; the `daemon` feature
 # layers `tokio/full` on top below. Cargo unifies feature sets, so
 # any consumer enabling both ends up with the daemon footprint
 # exactly as before.
-tokio = { version = "1", default-features = false, features = ["process", "rt", "time"], optional = true }
+tokio = { version = "1", default-features = false, features = ["io-util", "net", "process", "rt", "rt-multi-thread", "sync", "time"], optional = true }
 tokio-util = { version = "0.7", features = ["codec"], optional = true }
 bytes = { version = "1", optional = true }
 futures-util = { version = "0.3", features = ["sink"], optional = true }
@@ -213,6 +215,7 @@ test-watchdog = { path = "../test-watchdog" }
 # `BrokeredBackend` trait (#497) — every documented misuse pattern
 # gets its own compile-fail case under `tests/ui/`.
 trybuild = "1"
+tokio = { version = "1", default-features = false, features = ["macros", "process", "rt", "rt-multi-thread", "time"] }
 
 # #150: ConPTY passthrough rewrite uses windows-sys directly for the
 # new conpty_passthrough module. Kept alongside (not replacing) the

running_process-4.8.3/crates/running-process/src/async_process.rs

@@ -0,0 +1,232 @@
+//! Native asynchronous pipe-process API.
+//!
+//! The platform crate owns Tokio's process primitives. This module exposes a
+//! stable process-facing API without re-exporting `tokio::process` types.
+
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::process::{ExitStatus, Output};
+
+use running_process_platform_internal::{SpawnSpec, StreamMode};
+
+use crate::process_runtime::ActorProcess;
+use crate::{ProcessError, RunOutput};
+
+/// A process configured for asynchronous execution.
+pub struct AsyncProcess {
+    spec: SpawnSpec,
+    child: Option<ActorProcess>,
+}
+
+impl AsyncProcess {
+    /// Create a direct (non-shell) async process.
+    pub fn new(program: impl Into<OsString>) -> Self {
+        Self {
+            spec: SpawnSpec::new(program)
+                .stdin(StreamMode::Piped)
+                .stdout(StreamMode::Piped)
+                .stderr(StreamMode::Piped),
+            child: None,
+        }
+    }
+
+    /// Append an argument without requiring UTF-8.
+    pub fn arg(mut self, arg: impl Into<OsString>) -> Self {
+        self.spec = self.spec.arg(arg);
+        self
+    }
+
+    /// Set the child working directory.
+    pub fn current_dir(mut self, path: impl Into<PathBuf>) -> Self {
+        self.spec = self.spec.current_dir(path);
+        self
+    }
+
+    /// Add an environment override.
+    pub fn env(mut self, key: impl Into<OsString>, value: impl Into<OsString>) -> Self {
+        self.spec = self.spec.env(key, value);
+        self
+    }
+
+    /// Start the configured process.
+    pub async fn start(&mut self) -> Result<(), ProcessError> {
+        if self.child.is_some() {
+            return Err(ProcessError::AlreadyStarted);
+        }
+        self.child = Some(ActorProcess::start(self.spec.clone()).await?);
+        Ok(())
+    }
+
+    /// Return the child process identifier after [`Self::start`].
+    pub async fn pid(&self) -> Result<u32, ProcessError> {
+        self.child
+            .as_ref()
+            .ok_or(ProcessError::NotRunning)?
+            .pid()
+            .await
+    }
+
+    /// Wait for the started process without capturing output.
+    pub async fn wait(&mut self) -> Result<ExitStatus, ProcessError> {
+        self.child
+            .as_mut()
+            .ok_or(ProcessError::NotRunning)?
+            .wait()
+            .await
+    }
+
+    /// Kill the started process.
+    pub async fn kill(&mut self) -> Result<(), ProcessError> {
+        self.child
+            .as_mut()
+            .ok_or(ProcessError::NotRunning)?
+            .kill()
+            .await
+    }
+
+    /// Write bytes to the child's piped stdin without closing it.
+    ///
+    /// The actor owns the pipe for the complete operation. Cancelling this
+    /// future before actor acknowledgement leaves no guarantee whether a
+    /// dispatched write reached the child; callers that need an EOF must call
+    /// [`Self::close_stdin`] explicitly after a successful write.
+    pub async fn write_stdin(&mut self, bytes: impl AsRef<[u8]>) -> Result<(), ProcessError> {
+        self.child
+            .as_ref()
+            .ok_or(ProcessError::NotRunning)?
+            .write_stdin(bytes.as_ref().to_vec())
+            .await
+    }
+
+    /// Close the child's piped stdin and deliver EOF.
+    ///
+    /// The operation is idempotent after a successful start.
+    pub async fn close_stdin(&mut self) -> Result<(), ProcessError> {
+        self.child
+            .as_ref()
+            .ok_or(ProcessError::NotRunning)?
+            .close_stdin()
+            .await
+    }
+
+    /// Wait for completion and return captured stdout/stderr.
+    pub async fn output(&mut self) -> Result<RunOutput, ProcessError> {
+        let child = self.child.as_ref().ok_or(ProcessError::NotRunning)?;
+        let output = child.output().await?;
+        Ok(run_output(output))
+    }
+
+    /// Spawn, wait, and capture a process in one asynchronous operation.
+    pub async fn run(
+        program: impl Into<OsString>,
+        args: &[OsString],
+    ) -> Result<RunOutput, ProcessError> {
+        let mut process = Self::new(program);
+        for arg in args {
+            process = process.arg(arg.clone());
+        }
+        process.output_after_start().await
+    }
+
+    async fn output_after_start(mut self) -> Result<RunOutput, ProcessError> {
+        self.start().await?;
+        self.output().await
+    }
+}
+
+fn run_output(output: Output) -> RunOutput {
+    RunOutput {
+        stdout: output.stdout,
+        stderr: output.stderr,
+        exit_code: output.status.code().unwrap_or_else(|| {
+            #[cfg(unix)]
+            {
+                use std::os::unix::process::ExitStatusExt;
+                return -output.status.signal().unwrap_or(1);
+            }
+            #[cfg(not(unix))]
+            {
+                -1
+            }
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::AsyncProcess;
+
+    #[tokio::test]
+    async fn async_process_captures_stdout_and_stderr() {
+        #[cfg(windows)]
+        let process = AsyncProcess::new("cmd.exe")
+            .arg("/C")
+            .arg("echo out && echo err 1>&2");
+        #[cfg(not(windows))]
+        let process = AsyncProcess::new("/bin/sh")
+            .arg("-c")
+            .arg("printf out; printf err >&2");
+
+        let output = process.output_after_start().await.expect("async output");
+        let expected_stdout = if cfg!(windows) {
+            b"out \r\n".as_slice()
+        } else {
+            b"out".as_slice()
+        };
+        let expected_stderr = if cfg!(windows) {
+            b"err \r\n".as_slice()
+        } else {
+            b"err".as_slice()
+        };
+        assert_eq!(output.stdout, expected_stdout);
+        assert_eq!(output.stderr, expected_stderr);
+        assert_eq!(output.exit_code, 0);
+    }
+
+    #[tokio::test]
+    async fn async_process_rejects_double_start() {
+        #[cfg(windows)]
+        let mut process = AsyncProcess::new("cmd.exe").arg("/C").arg("exit 0");
+        #[cfg(not(windows))]
+        let mut process = AsyncProcess::new("/bin/true");
+        process.start().await.expect("first start");
+        assert!(matches!(
+            process.start().await,
+            Err(crate::ProcessError::AlreadyStarted)
+        ));
+        process.kill().await.ok();
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn async_process_writes_then_closes_stdin_through_the_actor() {
+        #[cfg(windows)]
+        let mut process = AsyncProcess::new("cmd.exe")
+            .arg("/V:ON")
+            .arg("/C")
+            .arg("set /p input= & echo got:!input!");
+        #[cfg(not(windows))]
+        let mut process = AsyncProcess::new("/bin/sh")
+            .arg("-c")
+            .arg("IFS= read -r input; printf got:%s \\\"$input\\\"");
+
+        process.start().await.expect("async process starts");
+        process
+            .write_stdin(b"actor-input")
+            .await
+            .expect("actor writes stdin");
+        process.close_stdin().await.expect("actor closes stdin");
+        process
+            .close_stdin()
+            .await
+            .expect("stdin close is idempotent");
+
+        let output = process.output().await.expect("actor captures output");
+        let expected = if cfg!(windows) {
+            b"got:actor-input\r\n".as_slice()
+        } else {
+            b"got:actor-input".as_slice()
+        };
+        assert_eq!(output.stdout, expected);
+        assert_eq!(output.exit_code, 0);
+    }
+}

{running_process-4.8.2 → running_process-4.8.3}/crates/running-process/src/bin/running-process-broker-v2.rs

@@ -149,7 +149,9 @@ fn install_shutdown_signal_handlers() -> std::io::Result<()> {
 
 /// Set when Windows delivers a console control event.
 ///
-/// The Windows counterpart of [`SIGNAL_SHUTDOWN_REQUESTED`]. Without it the
+/// The Windows counterpart of `SIGNAL_SHUTDOWN_REQUESTED` (backticks, not a
+/// link: that static is `#[cfg(unix)]`, so the link cannot resolve in a
+/// Windows doc build). Without it the
 /// accept loop on Windows polled a flag nothing ever set, so the broker never
 /// drained or unbound — it only ever died when killed.
 #[cfg(windows)]

{running_process-4.8.2 → running_process-4.8.3}/crates/running-process/src/broker/adopt.rs

@@ -146,7 +146,7 @@ pub struct OwnedBackendIo {
 
 impl OwnedBackendIo {
     #[cfg(unix)]
-    fn from_local_socket_stream(
+    pub(crate) fn from_local_socket_stream(
         stream: interprocess::local_socket::Stream,
     ) -> Result<Self, IntoBackendIoError> {
         match stream {
@@ -157,7 +157,7 @@ impl OwnedBackendIo {
     }
 
     #[cfg(windows)]
-    fn from_local_socket_stream(
+    pub(crate) fn from_local_socket_stream(
         _stream: interprocess::local_socket::Stream,
     ) -> Result<Self, IntoBackendIoError> {
         Err(IntoBackendIoError::WindowsUnsupported)