running-process 3.3.0__tar.gz → 3.4.1__tar.gz

{running_process-3.3.0 → running_process-3.4.1}/Cargo.lock

@@ -210,7 +210,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "daemon-trampoline"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "libc",
  "serde",
@@ -1036,7 +1036,7 @@ checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "running-process-client"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "dirs",
  "interprocess",
@@ -1047,7 +1047,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-core"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "libc",
  "portable-pty",
@@ -1061,7 +1061,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-daemon"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "bytes",
  "clap",
@@ -1088,7 +1088,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-proto"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "prost",
  "prost-build",
@@ -1098,7 +1098,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "interprocess",
  "libc",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "runpm-cli"
-version = "3.3.0"
+version = "3.4.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -1368,6 +1368,10 @@ dependencies = [
  "running-process-core",
 ]
 
+[[package]]
+name = "testbin-emitter"
+version = "0.0.0"
+
 [[package]]
 name = "testbin-env-dump"
 version = "0.0.0"
@@ -1387,6 +1391,13 @@ dependencies = [
  "running-process-core",
 ]
 
+[[package]]
+name = "testbin-stubborn"
+version = "0.0.0"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"

{running_process-3.3.0 → running_process-3.4.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/running-process-core", "crates/running-process-proto", "crates/running-process-client", "crates/running-process-py", "crates/test-watchdog"]
 
 [workspace.package]
-version = "3.3.0"
+version = "3.4.1"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

{running_process-3.3.0 → running_process-3.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 3.3.0
+Version: 3.4.1
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process

{running_process-3.3.0 → running_process-3.4.1}/crates/running-process-client/Cargo.toml

@@ -9,7 +9,7 @@ homepage.workspace = true
 description = "Lightweight synchronous IPC client for the running-process daemon"
 
 [dependencies]
-running-process-proto = { path = "../running-process-proto", version = "3.3.0" }
+running-process-proto = { path = "../running-process-proto", version = "3.4.1" }
 prost = "0.14"
 interprocess = "2"
 dirs = "6"

{running_process-3.3.0 → running_process-3.4.1}/crates/running-process-client/src/client.rs

@@ -9,12 +9,14 @@ use interprocess::local_socket::Stream;
 use interprocess::TryClone;
 use prost::Message;
 use running_process_proto::daemon::{
-    DaemonRequest, DaemonResponse, GetProcessTreeRequest, KeyValue, KillTreeRequest,
-    KillZombiesRequest, ListActiveRequest, ListByOriginatorRequest, PingRequest, RequestType,
-    ServiceConfig, ServiceDeleteRequest, ServiceDescribeRequest, ServiceFlushRequest,
-    ServiceListRequest, ServiceLogsRequest, ServiceRestartRequest, ServiceResurrectRequest,
-    ServiceSaveRequest, ServiceStartRequest, ServiceStopRequest, ShutdownRequest,
-    SpawnDaemonRequest as ProtoSpawnDaemonRequest, StatusCode, StatusRequest,
+    BulkTerminateSessionsRequest, BulkTerminateSessionsResponse, DaemonRequest, DaemonResponse,
+    GetProcessTreeRequest, GetSessionBacklogRequest, GetSessionBacklogResponse, KeyValue,
+    KillTreeRequest, KillZombiesRequest, ListActiveRequest, ListByOriginatorRequest, PingRequest,
+    PipeStreamKind, PurgeExitedSessionsRequest, PurgeExitedSessionsResponse, RequestType,
+    ResizePtySessionRequest, ServiceConfig, ServiceDeleteRequest, ServiceDescribeRequest,
+    ServiceFlushRequest, ServiceListRequest, ServiceLogsRequest, ServiceRestartRequest,
+    ServiceResurrectRequest, ServiceSaveRequest, ServiceStartRequest, ServiceStopRequest,
+    ShutdownRequest, SpawnDaemonRequest as ProtoSpawnDaemonRequest, StatusCode, StatusRequest,
 };
 use std::io::{BufReader, BufWriter, Read, Write};
 use std::path::PathBuf;
@@ -270,7 +272,7 @@ impl DaemonClient {
     // -----------------------------------------------------------------------
 
     /// Allocate the next request ID.
-    fn next_request_id(&self) -> u64 {
+    pub(crate) fn next_request_id(&self) -> u64 {
         self.next_id.fetch_add(1, Ordering::Relaxed)
     }
 
@@ -615,6 +617,145 @@ impl DaemonClient {
         };
         self.send_request(request)
     }
+
+    /// Resize a PTY session without going through an attach
+    /// (#130 M5 follow-up). The new size persists for the lifetime of
+    /// the session; subsequent attaches can override it via their own
+    /// rows/cols fields.
+    pub fn resize_pty_session(
+        &mut self,
+        session_id: &str,
+        rows: u16,
+        cols: u16,
+    ) -> Result<(), ClientError> {
+        let request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::ResizePtySession.into(),
+            protocol_version: 1,
+            client_name: String::from("running-process-client"),
+            resize_pty_session: Some(ResizePtySessionRequest {
+                session_id: session_id.into(),
+                rows: rows as u32,
+                cols: cols as u32,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(request)?;
+        if response.code != StatusCode::Ok as i32 {
+            let code =
+                StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+            return Err(ClientError::Server {
+                code,
+                message: response.message,
+            });
+        }
+        Ok(())
+    }
+
+    /// Purge exited sessions from both daemon-side registries (#130 M9
+    /// H4). Returns counts of PTY and pipe sessions reaped.
+    pub fn purge_exited_sessions(
+        &mut self,
+        originator: &str,
+    ) -> Result<PurgeExitedSessionsResponse, ClientError> {
+        let request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::PurgeExitedSessions.into(),
+            protocol_version: 1,
+            client_name: String::from("running-process-client"),
+            purge_exited_sessions: Some(PurgeExitedSessionsRequest {
+                originator: originator.into(),
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(request)?;
+        if response.code != StatusCode::Ok as i32 {
+            let code =
+                StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+            return Err(ClientError::Server {
+                code,
+                message: response.message,
+            });
+        }
+        response
+            .purge_exited_sessions
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "purge_exited_sessions response missing payload".into(),
+            })
+    }
+
+    /// Schedule termination of every session older than the threshold
+    /// (#130 M9 H4). `older_than_secs=0` terminates everything in scope.
+    pub fn bulk_terminate_sessions(
+        &mut self,
+        older_than_secs: u64,
+        originator: &str,
+        grace_ms: u32,
+    ) -> Result<BulkTerminateSessionsResponse, ClientError> {
+        let request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::BulkTerminateSessions.into(),
+            protocol_version: 1,
+            client_name: String::from("running-process-client"),
+            bulk_terminate_sessions: Some(BulkTerminateSessionsRequest {
+                older_than_secs,
+                originator: originator.into(),
+                grace_ms,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(request)?;
+        if response.code != StatusCode::Ok as i32 {
+            let code =
+                StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+            return Err(ClientError::Server {
+                code,
+                message: response.message,
+            });
+        }
+        response
+            .bulk_terminate_sessions
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "bulk_terminate_sessions response missing payload".into(),
+            })
+    }
+
+    /// Snapshot a PTY or pipe session's output backlog without consuming
+    /// it. For pipe sessions, `pipe_stream` selects between stdout and
+    /// stderr (default stdout). For PTY sessions `pipe_stream` is ignored.
+    /// Returns `None` when the session is not found.
+    pub fn get_session_backlog(
+        &mut self,
+        session_id: &str,
+        pipe_stream: PipeStreamKind,
+    ) -> Result<Option<GetSessionBacklogResponse>, ClientError> {
+        let request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::GetSessionBacklog.into(),
+            protocol_version: 1,
+            client_name: String::from("running-process-client"),
+            get_session_backlog: Some(GetSessionBacklogRequest {
+                session_id: session_id.into(),
+                pipe_stream: pipe_stream as i32,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(request)?;
+        if response.code == StatusCode::NotFound as i32 {
+            return Ok(None);
+        }
+        if response.code != StatusCode::Ok as i32 {
+            let code =
+                StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+            return Err(ClientError::Server {
+                code,
+                message: response.message,
+            });
+        }
+        Ok(response.get_session_backlog)
+    }
 }
 
 // ---------------------------------------------------------------------------

running_process-3.4.1/crates/running-process-client/src/lib.rs

@@ -0,0 +1,11 @@
+pub mod client;
+pub mod paths;
+pub mod pipe_session;
+pub mod pty_session;
+
+pub use client::{
+    connect_or_start, daemonize_command, launch_detached, ClientError, DaemonClient,
+    SpawnCommandRequest, SpawnedDaemon,
+};
+pub use pipe_session::{PipeSpawnRequest, PipeStreamAttachment, SpawnedPipeSession};
+pub use pty_session::{AttachError, PtyAttachment, PtySpawnRequest, SpawnedPtySession};

running_process-3.4.1/crates/running-process-client/src/pipe_session.rs

@@ -0,0 +1,359 @@
+//! Client-side helpers for daemon-owned pipe-backed sessions
+//! (issue #130 milestone 3).
+//!
+//! Mirrors [`crate::pty_session`] for the pipe case. Sessions are spawned,
+//! listed, detached, and terminated via the regular [`DaemonClient`] RPC
+//! channel. Stdin is also an RPC (`write_pipe_stdin`). Stdout/stderr are
+//! attached via [`PipeStreamAttachment`], which owns its own connection
+//! and pumps `PipeStreamFrame` payloads.
+
+use crate::client::{ClientError, DaemonClient};
+use crate::paths;
+use interprocess::local_socket::Stream;
+use interprocess::TryClone;
+use prost::Message;
+use running_process_proto::daemon::{
+    AttachPipeStreamRequest, AttachPipeStreamResponse, DaemonRequest, DaemonResponse,
+    DetachPipeStreamRequest, KeyValue, ListPipeSessionsRequest, ListPipeSessionsResponse,
+    PipeSessionInfo, PipeStreamFrame, PipeStreamKind, RequestType, SpawnPipeSessionRequest,
+    SpawnPipeSessionResponse, StatusCode, TerminatePipeSessionRequest, WritePipeStdinRequest,
+    WritePipeStdinResponse,
+};
+use std::io::{BufReader, BufWriter, Read, Write};
+use std::path::PathBuf;
+
+// ---------------------------------------------------------------------------
+// Spawn / list / terminate / write helpers
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+pub struct PipeSpawnRequest {
+    pub argv: Vec<String>,
+    pub cwd: Option<PathBuf>,
+    pub env: Vec<(String, String)>,
+    pub clear_inherited_env: bool,
+    pub originator: Option<String>,
+    pub merge_stderr_into_stdout: bool,
+}
+
+impl PipeSpawnRequest {
+    pub fn new<S: Into<String>>(argv: impl IntoIterator<Item = S>) -> Self {
+        Self {
+            argv: argv.into_iter().map(Into::into).collect(),
+            cwd: None,
+            env: Vec::new(),
+            clear_inherited_env: false,
+            originator: None,
+            merge_stderr_into_stdout: false,
+        }
+    }
+
+    pub fn with_cwd(mut self, cwd: impl Into<PathBuf>) -> Self {
+        self.cwd = Some(cwd.into());
+        self
+    }
+
+    pub fn with_originator(mut self, originator: impl Into<String>) -> Self {
+        self.originator = Some(originator.into());
+        self
+    }
+
+    pub fn merge_stderr(mut self) -> Self {
+        self.merge_stderr_into_stdout = true;
+        self
+    }
+
+    pub fn with_envs<I, K, V>(mut self, env: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        self.env = env
+            .into_iter()
+            .map(|(k, v)| (k.into(), v.into()))
+            .collect();
+        self
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SpawnedPipeSession {
+    pub session_id: String,
+    pub pid: u32,
+    pub created_at: f64,
+}
+
+impl DaemonClient {
+    pub fn spawn_pipe_session(
+        &mut self,
+        request: &PipeSpawnRequest,
+    ) -> Result<SpawnedPipeSession, ClientError> {
+        let proto = SpawnPipeSessionRequest {
+            argv: request.argv.clone(),
+            cwd: request
+                .cwd
+                .as_ref()
+                .map(|p| p.to_string_lossy().into_owned())
+                .unwrap_or_default(),
+            env: request
+                .env
+                .iter()
+                .map(|(k, v)| KeyValue {
+                    key: k.clone(),
+                    value: v.clone(),
+                })
+                .collect(),
+            clear_inherited_env: request.clear_inherited_env,
+            originator: request.originator.clone().unwrap_or_default(),
+            merge_stderr_into_stdout: request.merge_stderr_into_stdout,
+        };
+        let daemon_request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::SpawnPipeSession.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            spawn_pipe_session: Some(proto),
+            ..Default::default()
+        };
+        let response = self.send_request(daemon_request)?;
+        ensure_ok(&response)?;
+        let payload: SpawnPipeSessionResponse = response
+            .spawn_pipe_session
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "spawn_pipe_session response missing payload".into(),
+            })?;
+        Ok(SpawnedPipeSession {
+            session_id: payload.session_id,
+            pid: payload.pid,
+            created_at: payload.created_at,
+        })
+    }
+
+    pub fn list_pipe_sessions(
+        &mut self,
+        originator_filter: &str,
+    ) -> Result<Vec<PipeSessionInfo>, ClientError> {
+        let req = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::ListPipeSessions.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            list_pipe_sessions: Some(ListPipeSessionsRequest {
+                originator: originator_filter.into(),
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(req)?;
+        ensure_ok(&response)?;
+        let payload: ListPipeSessionsResponse = response
+            .list_pipe_sessions
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "list_pipe_sessions response missing payload".into(),
+            })?;
+        Ok(payload.sessions)
+    }
+
+    pub fn detach_pipe_stream(
+        &mut self,
+        session_id: &str,
+        stream: PipeStreamKind,
+    ) -> Result<(), ClientError> {
+        let req = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::DetachPipeStream.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            detach_pipe_stream: Some(DetachPipeStreamRequest {
+                session_id: session_id.into(),
+                stream: stream as i32,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(req)?;
+        ensure_ok(&response)?;
+        Ok(())
+    }
+
+    pub fn terminate_pipe_session(
+        &mut self,
+        session_id: &str,
+        grace_ms: u32,
+    ) -> Result<(), ClientError> {
+        let req = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::TerminatePipeSession.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            terminate_pipe_session: Some(TerminatePipeSessionRequest {
+                session_id: session_id.into(),
+                grace_ms,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(req)?;
+        ensure_ok(&response)?;
+        Ok(())
+    }
+
+    pub fn write_pipe_stdin(
+        &mut self,
+        session_id: &str,
+        data: &[u8],
+        close_after: bool,
+    ) -> Result<u64, ClientError> {
+        let req = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::WritePipeStdin.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            write_pipe_stdin: Some(WritePipeStdinRequest {
+                session_id: session_id.into(),
+                data: data.to_vec(),
+                close: close_after,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(req)?;
+        ensure_ok(&response)?;
+        let payload: WritePipeStdinResponse = response
+            .write_pipe_stdin
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "write_pipe_stdin response missing payload".into(),
+            })?;
+        Ok(payload.bytes_written)
+    }
+}
+
+fn ensure_ok(response: &DaemonResponse) -> Result<(), ClientError> {
+    if response.code == StatusCode::Ok as i32 {
+        return Ok(());
+    }
+    let code = StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+    Err(ClientError::Server {
+        code,
+        message: response.message.clone(),
+    })
+}
+
+// ---------------------------------------------------------------------------
+// PipeStreamAttachment
+// ---------------------------------------------------------------------------
+
+pub struct PipeStreamAttachment {
+    reader: BufReader<Stream>,
+    pub initial_backlog: Vec<u8>,
+    pub bytes_missed: u64,
+}
+
+#[derive(Debug)]
+pub enum PipeAttachError {
+    Connect(std::io::Error),
+    Io(std::io::Error),
+    Decode(prost::DecodeError),
+    Server { code: StatusCode, message: String },
+    MissingPayload,
+}
+
+impl std::fmt::Display for PipeAttachError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Connect(e) => write!(f, "pipe attach connect failed: {e}"),
+            Self::Io(e) => write!(f, "pipe attach io error: {e}"),
+            Self::Decode(e) => write!(f, "pipe attach decode error: {e}"),
+            Self::Server { code, message } => {
+                write!(f, "pipe attach server error {code:?}: {message}")
+            }
+            Self::MissingPayload => write!(f, "pipe attach response missing payload"),
+        }
+    }
+}
+
+impl std::error::Error for PipeAttachError {}
+
+impl PipeStreamAttachment {
+    pub fn attach(
+        scope_hash: Option<&str>,
+        session_id: &str,
+        stream: PipeStreamKind,
+        steal: bool,
+    ) -> Result<Self, PipeAttachError> {
+        let socket_path = paths::socket_path(scope_hash);
+        Self::attach_to(&socket_path, session_id, stream, steal)
+    }
+
+    pub fn attach_to(
+        socket_path: &str,
+        session_id: &str,
+        stream: PipeStreamKind,
+        steal: bool,
+    ) -> Result<Self, PipeAttachError> {
+        let name = paths::make_socket_name(socket_path).map_err(PipeAttachError::Connect)?;
+        use interprocess::local_socket::traits::Stream as _;
+        let s = Stream::connect(name).map_err(PipeAttachError::Connect)?;
+        let s_clone = s.try_clone().map_err(PipeAttachError::Connect)?;
+        let mut reader = BufReader::new(s);
+        let mut writer = BufWriter::new(s_clone);
+
+        let attach_request = DaemonRequest {
+            id: 1,
+            r#type: RequestType::AttachPipeStream.into(),
+            protocol_version: 1,
+            client_name: "running-process-client".into(),
+            attach_pipe_stream: Some(AttachPipeStreamRequest {
+                session_id: session_id.into(),
+                stream: stream as i32,
+                steal,
+            }),
+            ..Default::default()
+        };
+        write_length_prefixed(&mut writer, &attach_request.encode_to_vec())
+            .map_err(PipeAttachError::Io)?;
+        // We do not need writer after this, but keep it alive via reader's
+        // duplex socket. Drop here.
+        drop(writer);
+
+        let response_bytes = read_length_prefixed(&mut reader).map_err(PipeAttachError::Io)?;
+        let response = DaemonResponse::decode(&response_bytes[..]).map_err(PipeAttachError::Decode)?;
+        if response.code != StatusCode::Ok as i32 {
+            let code = StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
+            return Err(PipeAttachError::Server {
+                code,
+                message: response.message,
+            });
+        }
+        let payload: AttachPipeStreamResponse = response
+            .attach_pipe_stream
+            .ok_or(PipeAttachError::MissingPayload)?;
+
+        Ok(Self {
+            reader,
+            initial_backlog: payload.backlog,
+            bytes_missed: payload.bytes_missed,
+        })
+    }
+
+    pub fn recv_frame(&mut self) -> Result<PipeStreamFrame, PipeAttachError> {
+        let bytes = read_length_prefixed(&mut self.reader).map_err(PipeAttachError::Io)?;
+        PipeStreamFrame::decode(&bytes[..]).map_err(PipeAttachError::Decode)
+    }
+}
+
+fn write_length_prefixed<W: Write>(w: &mut W, payload: &[u8]) -> Result<(), std::io::Error> {
+    let len = payload.len() as u32;
+    w.write_all(&len.to_be_bytes())?;
+    w.write_all(payload)?;
+    w.flush()
+}
+
+fn read_length_prefixed<R: Read>(r: &mut R) -> Result<Vec<u8>, std::io::Error> {
+    let mut len_buf = [0u8; 4];
+    r.read_exact(&mut len_buf)?;
+    let len = u32::from_be_bytes(len_buf) as usize;
+    let mut buf = vec![0u8; len];
+    r.read_exact(&mut buf)?;
+    Ok(buf)
+}