running-process 4.0.1__tar.gz → 4.0.2__tar.gz

{running_process-4.0.1 → running_process-4.0.2}/Cargo.lock

@@ -1026,7 +1026,7 @@ checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "running-process"
-version = "4.0.1"
+version = "4.0.2"
 dependencies = [
  "anyhow",
  "bytes",
@@ -1058,7 +1058,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "4.0.1"
+version = "4.0.2"
 dependencies = [
  "interprocess",
  "libc",

{running_process-4.0.1 → running_process-4.0.2}/Cargo.toml

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

{running_process-4.0.1 → running_process-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 4.0.1
+Version: 4.0.2
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process
@@ -200,6 +200,11 @@ PTY behavior:
 
 There is also a compatibility alias: `RunningProcess.psuedo_terminal(...)`.
 
+Rust consumers should make the same transport choice explicitly: use
+`NativeProcess` for one-shot noninteractive work and
+`InteractivePtySession` / `NativePtyProcess` only for real terminal sessions.
+See [Rust PTY guidance](docs/RUST_PTY.md).
+
 You can also inspect the intended interactive launch semantics without launching a child:
 
 ```python
@@ -283,7 +288,7 @@ PTY mode is intentionally more conservative:
 ./test
 ```
 
-`./install` bootstraps `rustup` into the shared user locations (`~/.cargo` and `~/.rustup`, or `CARGO_HOME` / `RUSTUP_HOME` if you override them), then installs the exact toolchain pinned in `rust-toolchain.toml`. Toolchain installs are serialized with a lock so concurrent repo bootstraps do not race the same shared version.
+`./install` bootstraps `rustup` into the shared user locations (`~/.cargo` and `~/.rustup`, or `CARGO_HOME` / `RUSTUP_HOME` if you override them), then installs the exact toolchain pinned in `rust-toolchain.toml`. Toolchain installs are serialized with a lock so concurrent repo bootstraps do not race the same shared version. Rust build commands run through `uvx soldr`, so there is no separate `soldr` install step to maintain.
 
 `./lint` applies `cargo fmt` and Ruff autofixes before running the remaining lint checks, so fixable issues are rewritten in place.
 
@@ -291,16 +296,32 @@ PTY mode is intentionally more conservative:
 
 On local developer machines, `./test` also runs the Linux Docker preflight so Windows and macOS development catches Linux wheel, lint, and non-live pytest regressions before push. GitHub-hosted Actions skip that Docker-only preflight and run the native platform suite directly.
 
-If you want to invoke pytest directly, set `RUNNING_PROCESS_LIVE_TESTS=1` and run `uv run pytest -m live`.
+For a live-only test run with the timeout crash watchdog and automatic thread
+dumps still enabled, use:
 
-For direct Rust commands, prefer the repo trampolines, which prepend the shared `rustup` proxy location:
+```bash
+uv run -m ci.test --live-only
+```
+
+For a narrower live-only selection, pass pytest targets and selectors through
+the same entrypoint:
 
 ```bash
-./_cargo check --workspace
-./_cargo fmt --all --check
-./_cargo clippy --workspace --all-targets -- -D warnings
+uv run -m ci.test --live-only tests/test_pty_support.py interrupt
 ```
 
+For direct Cargo build commands, use `uvx soldr` directly:
+
+```bash
+uvx soldr cargo check --workspace
+uvx soldr cargo test --workspace
+uvx soldr cargo package -p running-process --no-verify
+```
+
+Keep `maturin`, `cargo fmt`, and `cargo clippy` on their normal entrypoints.
+This repo's high-level scripts already choose the compatible path for those
+tools.
+
 On Windows, native rebuilds that compile bundled C code should run from a Visual Studio developer shell. When the environment is ambiguous, point `maturin` at the MSVC toolchain binaries directly rather than relying on the generic cargo proxy.
 
 For local extension rebuilds, prefer:

{running_process-4.0.1 → running_process-4.0.2}/README.md

@@ -186,6 +186,11 @@ PTY behavior:
 
 There is also a compatibility alias: `RunningProcess.psuedo_terminal(...)`.
 
+Rust consumers should make the same transport choice explicitly: use
+`NativeProcess` for one-shot noninteractive work and
+`InteractivePtySession` / `NativePtyProcess` only for real terminal sessions.
+See [Rust PTY guidance](docs/RUST_PTY.md).
+
 You can also inspect the intended interactive launch semantics without launching a child:
 
 ```python
@@ -269,7 +274,7 @@ PTY mode is intentionally more conservative:
 ./test
 ```
 
-`./install` bootstraps `rustup` into the shared user locations (`~/.cargo` and `~/.rustup`, or `CARGO_HOME` / `RUSTUP_HOME` if you override them), then installs the exact toolchain pinned in `rust-toolchain.toml`. Toolchain installs are serialized with a lock so concurrent repo bootstraps do not race the same shared version.
+`./install` bootstraps `rustup` into the shared user locations (`~/.cargo` and `~/.rustup`, or `CARGO_HOME` / `RUSTUP_HOME` if you override them), then installs the exact toolchain pinned in `rust-toolchain.toml`. Toolchain installs are serialized with a lock so concurrent repo bootstraps do not race the same shared version. Rust build commands run through `uvx soldr`, so there is no separate `soldr` install step to maintain.
 
 `./lint` applies `cargo fmt` and Ruff autofixes before running the remaining lint checks, so fixable issues are rewritten in place.
 
@@ -277,16 +282,32 @@ PTY mode is intentionally more conservative:
 
 On local developer machines, `./test` also runs the Linux Docker preflight so Windows and macOS development catches Linux wheel, lint, and non-live pytest regressions before push. GitHub-hosted Actions skip that Docker-only preflight and run the native platform suite directly.
 
-If you want to invoke pytest directly, set `RUNNING_PROCESS_LIVE_TESTS=1` and run `uv run pytest -m live`.
+For a live-only test run with the timeout crash watchdog and automatic thread
+dumps still enabled, use:
 
-For direct Rust commands, prefer the repo trampolines, which prepend the shared `rustup` proxy location:
+```bash
+uv run -m ci.test --live-only
+```
+
+For a narrower live-only selection, pass pytest targets and selectors through
+the same entrypoint:
 
 ```bash
-./_cargo check --workspace
-./_cargo fmt --all --check
-./_cargo clippy --workspace --all-targets -- -D warnings
+uv run -m ci.test --live-only tests/test_pty_support.py interrupt
 ```
 
+For direct Cargo build commands, use `uvx soldr` directly:
+
+```bash
+uvx soldr cargo check --workspace
+uvx soldr cargo test --workspace
+uvx soldr cargo package -p running-process --no-verify
+```
+
+Keep `maturin`, `cargo fmt`, and `cargo clippy` on their normal entrypoints.
+This repo's high-level scripts already choose the compatible path for those
+tools.
+
 On Windows, native rebuilds that compile bundled C code should run from a Visual Studio developer shell. When the environment is ambiguous, point `maturin` at the MSVC toolchain binaries directly rather than relying on the generic cargo proxy.
 
 For local extension rebuilds, prefer:

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/Cargo.toml

@@ -35,13 +35,15 @@ path = "src/bin/trampoline.rs"
 # Final feature scheme per #165:
 # * `core`   — always-available API (spawn / pty / containment).
 # * `client` — adds proto types + IPC client (prost, interprocess, dirs).
-# * `daemon` — superset of client; adds the full daemon runtime
-#              (tokio, rusqlite, tracing, etc.).
+# * `telemetry` — tee sink primitives without the full daemon runtime.
+# * `daemon`    — superset of client; adds the full daemon runtime
+#                 (tokio, rusqlite, tracing, etc.).
 # Default ships `client` so `cargo install running-process` installs
 # the `runpm` binary out of the box (per Q1 resolution in #165:
 # `required-features` are not auto-activated by cargo install).
 default = ["client"]
 core = []
+telemetry = []
 client = ["dep:prost", "dep:prost-types", "dep:interprocess", "dep:dirs", "dep:anyhow", "dep:clap"]
 daemon = [
     "client",

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/proto/daemon.proto

@@ -63,6 +63,10 @@ enum RequestType {
   REQUEST_TYPE_BULK_TERMINATE_SESSIONS = 73;
   // Resize a PTY session without attaching (#130 M5 follow-up).
   REQUEST_TYPE_RESIZE_PTY_SESSION     = 74;
+  // Optional daemon-owned tee telemetry (#131).
+  REQUEST_TYPE_REGISTER_SESSION_TEE   = 75;
+  REQUEST_TYPE_UNREGISTER_SESSION_TEE = 76;
+  REQUEST_TYPE_GET_SESSION_TEE_STATUS = 77;
 }
 
 enum StatusCode {
@@ -133,6 +137,9 @@ message DaemonRequest {
   PurgeExitedSessionsRequest  purge_exited_sessions  = 72;
   BulkTerminateSessionsRequest bulk_terminate_sessions = 73;
   ResizePtySessionRequest     resize_pty_session     = 74;
+  RegisterSessionTeeRequest   register_session_tee   = 75;
+  UnregisterSessionTeeRequest unregister_session_tee = 76;
+  GetSessionTeeStatusRequest  get_session_tee_status = 77;
 }
 
 message DaemonResponse {
@@ -177,6 +184,9 @@ message DaemonResponse {
   PurgeExitedSessionsResponse  purge_exited_sessions  = 72;
   BulkTerminateSessionsResponse bulk_terminate_sessions = 73;
   ResizePtySessionResponse     resize_pty_session     = 74;
+  RegisterSessionTeeResponse   register_session_tee   = 75;
+  UnregisterSessionTeeResponse unregister_session_tee = 76;
+  GetSessionTeeStatusResponse  get_session_tee_status = 77;
 }
 
 // ---------------------------------------------------------------------------
@@ -763,6 +773,79 @@ message ResizePtySessionRequest {
 }
 message ResizePtySessionResponse {}
 
+// ---------------------------------------------------------------------------
+// Optional session tee telemetry (#131).
+// ---------------------------------------------------------------------------
+
+enum TeeSessionKind {
+  TEE_SESSION_KIND_UNSPECIFIED = 0;
+  TEE_SESSION_KIND_PTY         = 1;
+  TEE_SESSION_KIND_PIPE        = 2;
+}
+
+enum TeeStreamKind {
+  TEE_STREAM_KIND_UNSPECIFIED = 0;
+  TEE_STREAM_KIND_PTY_OUTPUT  = 1;
+  TEE_STREAM_KIND_STDOUT      = 2;
+  TEE_STREAM_KIND_STDERR      = 3;
+  TEE_STREAM_KIND_STDIN       = 4;
+}
+
+enum TeeSinkKind {
+  TEE_SINK_KIND_UNSPECIFIED = 0;
+  // Daemon opens the path and owns the file descriptor until the tee is
+  // removed or the session ends. Path bytes are OS-native, not UTF-8.
+  TEE_SINK_KIND_FILE        = 1;
+}
+
+enum TeeFileMode {
+  TEE_FILE_MODE_APPEND   = 0;
+  TEE_FILE_MODE_TRUNCATE = 1;
+}
+
+enum TeeBackpressure {
+  TEE_BACKPRESSURE_DROP_OLDEST = 0;
+  TEE_BACKPRESSURE_BLOCK       = 1;
+}
+
+message RegisterSessionTeeRequest {
+  string session_id          = 1;
+  TeeSessionKind session_kind = 2;
+  TeeStreamKind stream       = 3;
+  TeeSinkKind sink_kind      = 4;
+  // OS-native path bytes: Unix = OsStr bytes; Windows = little-endian UTF-16.
+  bytes  file_path           = 5;
+  TeeFileMode file_mode      = 6;
+  // 0 means use the daemon default.
+  uint32 queue_capacity      = 7;
+  // false means write missed-byte markers, matching the Rust default.
+  bool   suppress_missed_markers = 8;
+  TeeBackpressure backpressure = 9;
+}
+
+message RegisterSessionTeeResponse {
+  uint64 tee_handle = 1;
+}
+
+message UnregisterSessionTeeRequest {
+  string session_id          = 1;
+  TeeSessionKind session_kind = 2;
+  uint64 tee_handle          = 3;
+}
+message UnregisterSessionTeeResponse {}
+
+message GetSessionTeeStatusRequest {
+  string session_id          = 1;
+  TeeSessionKind session_kind = 2;
+  uint64 tee_handle          = 3;
+}
+
+message GetSessionTeeStatusResponse {
+  TeeStreamKind stream       = 1;
+  uint64 missed_bytes        = 2;
+  bool   disconnected        = 3;
+}
+
 // Daemon -> client stream frame for an attached stdout/stderr.
 message PipeStreamFrame {
   oneof frame {

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/src/client/mod.rs

@@ -5,10 +5,12 @@
 //! previously imported from `running_process_client::*` keeps working
 //! when it switches to `running_process::client::*`.
 
+#[allow(clippy::module_inception)]
 pub mod client;
 pub mod paths;
 pub mod pipe_session;
 pub mod pty_session;
+pub mod telemetry;
 
 pub use client::{
     connect_or_start, daemonize_command, launch_detached, ClientError, DaemonClient,
@@ -16,3 +18,7 @@ pub use client::{
 };
 pub use pipe_session::{PipeSpawnRequest, PipeStreamAttachment, SpawnedPipeSession};
 pub use pty_session::{AttachError, PtyAttachment, PtySpawnRequest, SpawnedPtySession};
+pub use telemetry::{
+    SessionTeeBackpressure, SessionTeeFileMode, SessionTeeFileRequest, SessionTeeKind,
+    SessionTeeStatus, SessionTeeStream,
+};

running_process-4.0.2/crates/running-process/src/client/telemetry.rs

@@ -0,0 +1,264 @@
+//! Client helpers for daemon-owned session tee telemetry.
+
+use std::path::{Path, PathBuf};
+
+#[cfg(unix)]
+use std::os::unix::ffi::OsStrExt;
+#[cfg(windows)]
+use std::os::windows::ffi::OsStrExt;
+
+use crate::client::{ClientError, DaemonClient};
+use crate::proto::daemon::{
+    DaemonRequest, GetSessionTeeStatusRequest, RegisterSessionTeeRequest, RequestType, StatusCode,
+    TeeBackpressure as ProtoTeeBackpressure, TeeFileMode as ProtoTeeFileMode,
+    TeeSessionKind as ProtoTeeSessionKind, TeeSinkKind, TeeStreamKind as ProtoTeeStreamKind,
+    UnregisterSessionTeeRequest,
+};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SessionTeeKind {
+    Pty,
+    Pipe,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SessionTeeStream {
+    PtyOutput,
+    Stdout,
+    Stderr,
+    Stdin,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SessionTeeFileMode {
+    Append,
+    Truncate,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SessionTeeBackpressure {
+    DropOldest,
+    Block,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SessionTeeFileRequest {
+    pub session_id: String,
+    pub session_kind: SessionTeeKind,
+    pub stream: SessionTeeStream,
+    pub path: PathBuf,
+    pub mode: SessionTeeFileMode,
+    /// 0 means use the daemon default.
+    pub queue_capacity: u32,
+    pub write_missed_markers: bool,
+    pub backpressure: SessionTeeBackpressure,
+}
+
+impl SessionTeeFileRequest {
+    pub fn new<P>(
+        session_id: impl Into<String>,
+        session_kind: SessionTeeKind,
+        stream: SessionTeeStream,
+        path: P,
+    ) -> Self
+    where
+        P: AsRef<Path>,
+    {
+        Self {
+            session_id: session_id.into(),
+            session_kind,
+            stream,
+            path: path.as_ref().to_path_buf(),
+            mode: SessionTeeFileMode::Append,
+            queue_capacity: 0,
+            write_missed_markers: true,
+            backpressure: SessionTeeBackpressure::DropOldest,
+        }
+    }
+
+    pub fn truncate(mut self) -> Self {
+        self.mode = SessionTeeFileMode::Truncate;
+        self
+    }
+
+    pub fn queue_capacity(mut self, capacity: u32) -> Self {
+        self.queue_capacity = capacity;
+        self
+    }
+
+    pub fn suppress_missed_markers(mut self) -> Self {
+        self.write_missed_markers = false;
+        self
+    }
+
+    pub fn backpressure(mut self, backpressure: SessionTeeBackpressure) -> Self {
+        self.backpressure = backpressure;
+        self
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct SessionTeeStatus {
+    pub stream: SessionTeeStream,
+    pub missed_bytes: u64,
+    pub disconnected: bool,
+}
+
+impl DaemonClient {
+    pub fn register_session_file_tee(
+        &mut self,
+        request: &SessionTeeFileRequest,
+    ) -> Result<u64, ClientError> {
+        let daemon_request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::RegisterSessionTee.into(),
+            protocol_version: 1,
+            register_session_tee: Some(RegisterSessionTeeRequest {
+                session_id: request.session_id.clone(),
+                session_kind: proto_session_kind(request.session_kind) as i32,
+                stream: proto_stream_kind(request.stream) as i32,
+                sink_kind: TeeSinkKind::File as i32,
+                file_path: encode_os_path(&request.path),
+                file_mode: proto_file_mode(request.mode) as i32,
+                queue_capacity: request.queue_capacity,
+                suppress_missed_markers: !request.write_missed_markers,
+                backpressure: proto_backpressure(request.backpressure) as i32,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(daemon_request)?;
+        ensure_ok(&response)?;
+        let payload = response
+            .register_session_tee
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "register_session_tee response missing payload".into(),
+            })?;
+        Ok(payload.tee_handle)
+    }
+
+    pub fn unregister_session_tee(
+        &mut self,
+        session_kind: SessionTeeKind,
+        session_id: &str,
+        tee_handle: u64,
+    ) -> Result<(), ClientError> {
+        let daemon_request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::UnregisterSessionTee.into(),
+            protocol_version: 1,
+            unregister_session_tee: Some(UnregisterSessionTeeRequest {
+                session_id: session_id.to_string(),
+                session_kind: proto_session_kind(session_kind) as i32,
+                tee_handle,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(daemon_request)?;
+        ensure_ok(&response)
+    }
+
+    pub fn get_session_tee_status(
+        &mut self,
+        session_kind: SessionTeeKind,
+        session_id: &str,
+        tee_handle: u64,
+    ) -> Result<SessionTeeStatus, ClientError> {
+        let daemon_request = DaemonRequest {
+            id: self.next_request_id(),
+            r#type: RequestType::GetSessionTeeStatus.into(),
+            protocol_version: 1,
+            get_session_tee_status: Some(GetSessionTeeStatusRequest {
+                session_id: session_id.to_string(),
+                session_kind: proto_session_kind(session_kind) as i32,
+                tee_handle,
+            }),
+            ..Default::default()
+        };
+        let response = self.send_request(daemon_request)?;
+        ensure_ok(&response)?;
+        let payload = response
+            .get_session_tee_status
+            .ok_or_else(|| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "get_session_tee_status response missing payload".into(),
+            })?;
+        let stream =
+            ProtoTeeStreamKind::try_from(payload.stream).map_err(|_| ClientError::Server {
+                code: StatusCode::Internal,
+                message: "get_session_tee_status response has invalid stream".into(),
+            })?;
+        Ok(SessionTeeStatus {
+            stream: client_stream_kind(stream)?,
+            missed_bytes: payload.missed_bytes,
+            disconnected: payload.disconnected,
+        })
+    }
+}
+
+fn ensure_ok(response: &crate::proto::daemon::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(),
+    })
+}
+
+fn proto_session_kind(kind: SessionTeeKind) -> ProtoTeeSessionKind {
+    match kind {
+        SessionTeeKind::Pty => ProtoTeeSessionKind::Pty,
+        SessionTeeKind::Pipe => ProtoTeeSessionKind::Pipe,
+    }
+}
+
+fn proto_stream_kind(stream: SessionTeeStream) -> ProtoTeeStreamKind {
+    match stream {
+        SessionTeeStream::PtyOutput => ProtoTeeStreamKind::PtyOutput,
+        SessionTeeStream::Stdout => ProtoTeeStreamKind::Stdout,
+        SessionTeeStream::Stderr => ProtoTeeStreamKind::Stderr,
+        SessionTeeStream::Stdin => ProtoTeeStreamKind::Stdin,
+    }
+}
+
+fn client_stream_kind(stream: ProtoTeeStreamKind) -> Result<SessionTeeStream, ClientError> {
+    match stream {
+        ProtoTeeStreamKind::PtyOutput => Ok(SessionTeeStream::PtyOutput),
+        ProtoTeeStreamKind::Stdout => Ok(SessionTeeStream::Stdout),
+        ProtoTeeStreamKind::Stderr => Ok(SessionTeeStream::Stderr),
+        ProtoTeeStreamKind::Stdin => Ok(SessionTeeStream::Stdin),
+        ProtoTeeStreamKind::Unspecified => Err(ClientError::Server {
+            code: StatusCode::Internal,
+            message: "get_session_tee_status response has unspecified stream".into(),
+        }),
+    }
+}
+
+fn proto_file_mode(mode: SessionTeeFileMode) -> ProtoTeeFileMode {
+    match mode {
+        SessionTeeFileMode::Append => ProtoTeeFileMode::Append,
+        SessionTeeFileMode::Truncate => ProtoTeeFileMode::Truncate,
+    }
+}
+
+fn proto_backpressure(backpressure: SessionTeeBackpressure) -> ProtoTeeBackpressure {
+    match backpressure {
+        SessionTeeBackpressure::DropOldest => ProtoTeeBackpressure::DropOldest,
+        SessionTeeBackpressure::Block => ProtoTeeBackpressure::Block,
+    }
+}
+
+#[cfg(unix)]
+fn encode_os_path(path: &Path) -> Vec<u8> {
+    path.as_os_str().as_bytes().to_vec()
+}
+
+#[cfg(windows)]
+fn encode_os_path(path: &Path) -> Vec<u8> {
+    path.as_os_str()
+        .encode_wide()
+        .flat_map(u16::to_le_bytes)
+        .collect()
+}

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/src/containment.rs

@@ -86,6 +86,8 @@ impl ContainedProcessGroup {
     fn inject_originator_env(&self, command: &mut Command) {
         if let Some(ref originator) = self.originator {
             command.env(ORIGINATOR_ENV_VAR, format_originator_value(originator));
+        } else {
+            command.env_remove(ORIGINATOR_ENV_VAR);
         }
     }
 

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/src/daemon/attach_stream.rs

@@ -222,12 +222,7 @@ fn encode_outbound(frame: OutboundFrame) -> (bool, PtyStreamFrame) {
                 }
                 AttachmentEnded::Detached => StreamOneof::Error("detached".into()),
             };
-            (
-                true,
-                PtyStreamFrame {
-                    frame: Some(oneof),
-                },
-            )
+            (true, PtyStreamFrame { frame: Some(oneof) })
         }
     }
 }
@@ -289,3 +284,69 @@ where
     framed.send(Bytes::from(encoded)).await?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn encode_outbound_maps_non_terminal_frames() {
+        let (terminal, output) = encode_outbound(OutboundFrame::Output(b"abc".to_vec()));
+        assert!(!terminal);
+        assert!(matches!(
+            output.frame,
+            Some(StreamOneof::Output(bytes)) if bytes == b"abc"
+        ));
+
+        let (terminal, missed) = encode_outbound(OutboundFrame::MissedBytes(42));
+        assert!(!terminal);
+        assert!(matches!(missed.frame, Some(StreamOneof::MissedBytes(42))));
+    }
+
+    #[test]
+    fn encode_outbound_maps_terminal_frames() {
+        let (terminal, exit) = encode_outbound(OutboundFrame::Exit(7));
+        assert!(terminal);
+        assert!(matches!(exit.frame, Some(StreamOneof::ExitCode(7))));
+
+        let (terminal, stolen) = encode_outbound(OutboundFrame::Ended(AttachmentEnded::Stolen));
+        assert!(terminal);
+        assert!(matches!(
+            stolen.frame,
+            Some(StreamOneof::StolenBy(peer)) if peer == "peer"
+        ));
+
+        let (terminal, exited) =
+            encode_outbound(OutboundFrame::Ended(AttachmentEnded::SessionExited));
+        assert!(terminal);
+        assert!(matches!(
+            exited.frame,
+            Some(StreamOneof::Error(message)) if message == "session exited"
+        ));
+
+        let (terminal, terminated) =
+            encode_outbound(OutboundFrame::Ended(AttachmentEnded::Terminated));
+        assert!(terminal);
+        assert!(matches!(
+            terminated.frame,
+            Some(StreamOneof::Error(message)) if message == "session terminated by request"
+        ));
+
+        let (terminal, detached) = encode_outbound(OutboundFrame::Ended(AttachmentEnded::Detached));
+        assert!(terminal);
+        assert!(matches!(
+            detached.frame,
+            Some(StreamOneof::Error(message)) if message == "detached"
+        ));
+    }
+
+    #[test]
+    fn error_attach_response_uses_attach_payload() {
+        let response = error_attach_response(99, StatusCode::NotFound, "missing".into());
+
+        assert_eq!(response.request_id, 99);
+        assert_eq!(response.code, StatusCode::NotFound as i32);
+        assert_eq!(response.message, "missing");
+        assert!(response.attach_pty_session.is_some());
+    }
+}

{running_process-4.0.1 → running_process-4.0.2}/crates/running-process/src/daemon/handlers/mod.rs

@@ -28,6 +28,7 @@ mod pty_sessions_handlers;
 mod registry_handlers;
 mod services;
 mod spawn;
+mod telemetry;
 mod util;
 
 pub use self::core::{handle_ping, handle_shutdown, handle_status};
@@ -53,6 +54,9 @@ pub use self::services::{
     handle_service_start, handle_service_stop,
 };
 pub use self::spawn::handle_spawn_daemon;
+pub use self::telemetry::{
+    handle_get_session_tee_status, handle_register_session_tee, handle_unregister_session_tee,
+};
 
 // ---------------------------------------------------------------------------
 // Shared daemon state