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

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 4.0.2
+Version: 4.0.3
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process
@@ -47,6 +47,22 @@ On those platforms, `RunningProcess.pseudo_terminal(...)`, `wait_for_expect(...)
 
 `Pty.is_available()` remains as a compatibility shim and only reports `False` on unsupported platforms.
 
+## Terminal Graphics Capabilities
+
+Rust callers can inspect terminal graphics support with
+`running_process::current_terminal_capabilities()` or the pure
+`running_process::detect_terminal_capabilities(...)` helper. The result reports
+Sixel, Kitty graphics, and iTerm2 `File=` image support as structured
+capability records with `status`, `evidence`, `source`, and `risks` metadata.
+
+The detector intentionally distinguishes terminal hosts from shells. `cmd.exe`,
+PowerShell, Git Bash, bash, zsh, and fish are command interpreters; they do not
+prove graphics support. The terminal host or multiplexer does: Windows
+Terminal, xterm, foot, Konsole, WezTerm, Kitty, iTerm2, tmux, GNU screen, and
+similar programs provide the relevant evidence. Weak aliases such as
+`TERM=xterm-256color` are reported as unknown unless a live probe or stronger
+host signal confirms support.
+
 ## CLI Helpers
 
 The package installs a `running-process` wrapper CLI for supervised command execution:

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

@@ -33,6 +33,22 @@ On those platforms, `RunningProcess.pseudo_terminal(...)`, `wait_for_expect(...)
 
 `Pty.is_available()` remains as a compatibility shim and only reports `False` on unsupported platforms.
 
+## Terminal Graphics Capabilities
+
+Rust callers can inspect terminal graphics support with
+`running_process::current_terminal_capabilities()` or the pure
+`running_process::detect_terminal_capabilities(...)` helper. The result reports
+Sixel, Kitty graphics, and iTerm2 `File=` image support as structured
+capability records with `status`, `evidence`, `source`, and `risks` metadata.
+
+The detector intentionally distinguishes terminal hosts from shells. `cmd.exe`,
+PowerShell, Git Bash, bash, zsh, and fish are command interpreters; they do not
+prove graphics support. The terminal host or multiplexer does: Windows
+Terminal, xterm, foot, Konsole, WezTerm, Kitty, iTerm2, tmux, GNU screen, and
+similar programs provide the relevant evidence. Weak aliases such as
+`TERM=xterm-256color` are reported as unknown unless a live probe or stronger
+host signal confirms support.
+
 ## CLI Helpers
 
 The package installs a `running-process` wrapper CLI for supervised command execution:

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

@@ -90,6 +90,30 @@ enum ProcessState {
   PROCESS_STATE_ZOMBIE  = 3;
 }
 
+enum GraphicsProtocol {
+  GRAPHICS_PROTOCOL_UNSPECIFIED = 0;
+  GRAPHICS_PROTOCOL_SIXEL       = 1;
+  GRAPHICS_PROTOCOL_KITTY       = 2;
+  GRAPHICS_PROTOCOL_ITERM2_FILE = 3;
+}
+
+enum CapabilityStatus {
+  CAPABILITY_STATUS_UNSPECIFIED = 0;
+  CAPABILITY_STATUS_SUPPORTED   = 1;
+  CAPABILITY_STATUS_UNSUPPORTED = 2;
+  CAPABILITY_STATUS_UNKNOWN     = 3;
+  CAPABILITY_STATUS_BLOCKED     = 4;
+}
+
+enum EvidenceStrength {
+  EVIDENCE_STRENGTH_UNSPECIFIED        = 0;
+  EVIDENCE_STRENGTH_PROBE              = 1;
+  EVIDENCE_STRENGTH_STRONG_HOST_SIGNAL = 2;
+  EVIDENCE_STRENGTH_TERMINFO           = 3;
+  EVIDENCE_STRENGTH_WEAK_ENV           = 4;
+  EVIDENCE_STRENGTH_USER_OVERRIDE      = 5;
+}
+
 // ---------------------------------------------------------------------------
 // Envelope messages
 // ---------------------------------------------------------------------------
@@ -201,6 +225,19 @@ message KeyValue {
   string value = 2;
 }
 
+message TerminalGraphicsCapability {
+  GraphicsProtocol protocol = 1;
+  CapabilityStatus status   = 2;
+  EvidenceStrength evidence = 3;
+  string source             = 4;
+  repeated string risks     = 5;
+}
+
+message TerminalGraphicsCapabilities {
+  repeated TerminalGraphicsCapability protocols = 1;
+  GraphicsProtocol preferred = 2;
+}
+
 message RegisterRequest {
   uint32 pid        = 1;
   double created_at = 2;
@@ -494,6 +531,7 @@ message AttachPtySessionRequest {
   // Terminal capabilities for renegotiation; informational only for now.
   string term            = 5;
   bool   is_tty          = 6;
+  TerminalGraphicsCapabilities graphics_capabilities = 7;
 }
 
 message AttachPtySessionResponse {
@@ -552,6 +590,9 @@ message PtySessionInfo {
   // child's environment (you cannot change a live child's TERM).
   // Empty when no client is attached.
   string attached_term = 15;
+  // Graphics capability metadata supplied by the currently attached
+  // client. Missing metadata from older clients is treated as unknown.
+  TerminalGraphicsCapabilities attached_graphics_capabilities = 16;
 }
 
 message TerminatePtySessionRequest {

{running_process-4.0.2 → running_process-4.0.3}/crates/running-process/src/client/pty_session.rs

@@ -10,17 +10,21 @@
 //! send/receive helpers suitable for tests and small clients. Async
 //! clients can build on top of [`DaemonClient::attach_pty_session_raw`].
 
-use crate::client::{ClientError, DaemonClient};
 use crate::client::paths;
-use interprocess::local_socket::Stream;
-use interprocess::TryClone;
-use prost::Message;
+use crate::client::{ClientError, DaemonClient};
 use crate::proto::daemon::{
     pty_input_frame::Frame as InputOneof, AttachPtySessionRequest, AttachPtySessionResponse,
     DaemonRequest, DaemonResponse, DetachPtySessionRequest, KeyValue, ListPtySessionsRequest,
     ListPtySessionsResponse, PtyInputFrame, PtyResize, PtySessionInfo, PtyStreamFrame, RequestType,
     SpawnPtySessionRequest, SpawnPtySessionResponse, StatusCode, TerminatePtySessionRequest,
 };
+use crate::terminal_graphics::{
+    current_terminal_capabilities, terminal_graphics_capabilities_to_proto, TerminalCapabilities,
+    TerminalGraphicsCapabilities,
+};
+use interprocess::local_socket::Stream;
+use interprocess::TryClone;
+use prost::Message;
 use std::io::{BufReader, BufWriter, Read, Write};
 use std::path::PathBuf;
 use std::time::Duration;
@@ -76,10 +80,7 @@ impl PtySpawnRequest {
         K: Into<String>,
         V: Into<String>,
     {
-        self.env = env
-            .into_iter()
-            .map(|(k, v)| (k.into(), v.into()))
-            .collect();
+        self.env = env.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
         self
     }
 }
@@ -131,10 +132,12 @@ impl DaemonClient {
         let response = self.send_request(daemon_request)?;
         ensure_ok(&response)?;
         let payload: SpawnPtySessionResponse =
-            response.spawn_pty_session.ok_or_else(|| ClientError::Server {
-                code: StatusCode::Internal,
-                message: "spawn_pty_session response missing payload".into(),
-            })?;
+            response
+                .spawn_pty_session
+                .ok_or_else(|| ClientError::Server {
+                    code: StatusCode::Internal,
+                    message: "spawn_pty_session response missing payload".into(),
+                })?;
         Ok(SpawnedPtySession {
             session_id: payload.session_id,
             pid: payload.pid,
@@ -160,12 +163,13 @@ impl DaemonClient {
         };
         let response = self.send_request(req)?;
         ensure_ok(&response)?;
-        let payload: ListPtySessionsResponse = response
-            .list_pty_sessions
-            .ok_or_else(|| ClientError::Server {
-                code: StatusCode::Internal,
-                message: "list_pty_sessions response missing payload".into(),
-            })?;
+        let payload: ListPtySessionsResponse =
+            response
+                .list_pty_sessions
+                .ok_or_else(|| ClientError::Server {
+                    code: StatusCode::Internal,
+                    message: "list_pty_sessions response missing payload".into(),
+                })?;
         Ok(payload.sessions)
     }
 
@@ -210,7 +214,6 @@ impl DaemonClient {
         ensure_ok(&response)?;
         Ok(())
     }
-
 }
 
 fn ensure_ok(response: &DaemonResponse) -> Result<(), ClientError> {
@@ -249,7 +252,10 @@ pub enum AttachError {
     Connect(std::io::Error),
     Io(std::io::Error),
     Decode(prost::DecodeError),
-    Server { code: StatusCode, message: String },
+    Server {
+        code: StatusCode,
+        message: String,
+    },
     /// The daemon never sent an AttachPtySessionResponse payload.
     MissingPayload,
 }
@@ -290,6 +296,32 @@ impl PtyAttachment {
         rows: u16,
         cols: u16,
         steal: bool,
+    ) -> Result<Self, AttachError> {
+        let mut terminal_capabilities = current_terminal_capabilities();
+        if !terminal_capabilities.is_tty {
+            terminal_capabilities.is_tty = true;
+            terminal_capabilities.graphics = TerminalGraphicsCapabilities::unknown();
+        }
+        Self::attach_to_with_terminal_capabilities(
+            socket_path,
+            session_id,
+            rows,
+            cols,
+            steal,
+            terminal_capabilities,
+        )
+    }
+
+    /// Attach with explicit terminal metadata. This is useful for tests,
+    /// non-interactive attach clients, and callers that already performed
+    /// capability probing before opening the daemon socket.
+    pub fn attach_to_with_terminal_capabilities(
+        socket_path: &str,
+        session_id: &str,
+        rows: u16,
+        cols: u16,
+        steal: bool,
+        terminal_capabilities: TerminalCapabilities,
     ) -> Result<Self, AttachError> {
         let name = paths::make_socket_name(socket_path).map_err(AttachError::Connect)?;
         use interprocess::local_socket::traits::Stream as _;
@@ -309,8 +341,11 @@ impl PtyAttachment {
                 rows: rows as u32,
                 cols: cols as u32,
                 steal,
-                term: std::env::var("TERM").unwrap_or_default(),
-                is_tty: true,
+                term: terminal_capabilities.term.unwrap_or_default(),
+                is_tty: terminal_capabilities.is_tty,
+                graphics_capabilities: Some(terminal_graphics_capabilities_to_proto(
+                    &terminal_capabilities.graphics,
+                )),
             }),
             ..Default::default()
         };
@@ -319,8 +354,7 @@ impl PtyAttachment {
 
         // Read the initial response.
         let response_bytes = read_length_prefixed(&mut reader).map_err(AttachError::Io)?;
-        let response =
-            DaemonResponse::decode(&response_bytes[..]).map_err(AttachError::Decode)?;
+        let response = DaemonResponse::decode(&response_bytes[..]).map_err(AttachError::Decode)?;
         if response.code != StatusCode::Ok as i32 {
             let code = StatusCode::try_from(response.code).unwrap_or(StatusCode::UnknownRequest);
             return Err(AttachError::Server {

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

@@ -25,6 +25,9 @@ use crate::proto::daemon::{
 
 use crate::daemon::handlers::DaemonState;
 use crate::daemon::pty_sessions::{AttachError, AttachmentEnded, OutboundFrame};
+use crate::terminal_graphics::{
+    terminal_graphics_capabilities_from_proto, TerminalGraphicsCapabilities,
+};
 
 /// Drive the attach stream for the lifetime of one client connection.
 ///
@@ -73,6 +76,11 @@ where
         cols,
         attach_req.is_tty,
         attach_req.term.clone(),
+        attach_req
+            .graphics_capabilities
+            .as_ref()
+            .map(terminal_graphics_capabilities_from_proto)
+            .unwrap_or_else(TerminalGraphicsCapabilities::unknown),
     ) {
         Ok(h) => h,
         Err(AttachError::AlreadyAttached) => {

{running_process-4.0.2 → running_process-4.0.3}/crates/running-process/src/daemon/handlers/pty_sessions_handlers.rs

@@ -11,6 +11,7 @@ use crate::proto::daemon::{
     ListPtySessionsResponse, PtySessionInfo, ResizePtySessionResponse, SpawnPtySessionResponse,
     StatusCode, TerminatePtySessionResponse,
 };
+use crate::terminal_graphics::terminal_graphics_capabilities_to_proto;
 
 use super::util::{error_pty_response, termination_outcome_to_proto};
 use super::DaemonState;
@@ -167,6 +168,9 @@ pub fn handle_list_pty_sessions(request: &DaemonRequest, state: &DaemonState) ->
             termination_outcome: termination_outcome_to_proto(outcome) as i32,
             attached_is_tty: session.attached_is_tty(),
             attached_term: session.attached_term(),
+            attached_graphics_capabilities: Some(terminal_graphics_capabilities_to_proto(
+                &session.attached_graphics_capabilities(),
+            )),
         });
     }
 
@@ -208,7 +212,11 @@ pub fn handle_terminate_pty_session(
     // M4 will turn this into a configurable soft-then-hard schedule.
     // For M2 we issue an immediate terminate and let the reader thread
     // observe the exit + record exit state.
-    let grace_ms = if req.grace_ms == 0 { 2000 } else { req.grace_ms };
+    let grace_ms = if req.grace_ms == 0 {
+        2000
+    } else {
+        req.grace_ms
+    };
     if let Err(e) = session.terminate(std::time::Duration::from_millis(grace_ms as u64)) {
         return error_pty_response(request.id, StatusCode::Internal, e.to_string());
     }
@@ -237,8 +245,7 @@ pub fn handle_attach_pty_session(request: &DaemonRequest, _state: &DaemonState)
     DaemonResponse {
         request_id: request.id,
         code: StatusCode::Internal as i32,
-        message: "attach_pty_session must be intercepted by the streaming server path"
-            .into(),
+        message: "attach_pty_session must be intercepted by the streaming server path".into(),
         attach_pty_session: Some(AttachPtySessionResponse::default()),
         ..Default::default()
     }
@@ -248,10 +255,7 @@ pub fn handle_attach_pty_session(request: &DaemonRequest, _state: &DaemonState)
 /// follow-up). The new size persists for the lifetime of the session
 /// and overrides any per-attach size passed by future attach requests
 /// (they can still override it again by sending their own rows/cols).
-pub fn handle_resize_pty_session(
-    request: &DaemonRequest,
-    state: &DaemonState,
-) -> DaemonResponse {
+pub fn handle_resize_pty_session(request: &DaemonRequest, state: &DaemonState) -> DaemonResponse {
     let req = match request.resize_pty_session.as_ref() {
         Some(r) => r,
         None => {
@@ -272,8 +276,16 @@ pub fn handle_resize_pty_session(
             )
         }
     };
-    let rows = if req.rows == 0 { session.rows() } else { req.rows as u16 };
-    let cols = if req.cols == 0 { session.cols() } else { req.cols as u16 };
+    let rows = if req.rows == 0 {
+        session.rows()
+    } else {
+        req.rows as u16
+    };
+    let cols = if req.cols == 0 {
+        session.cols()
+    } else {
+        req.cols as u16
+    };
     if let Err(e) = session.resize(rows, cols) {
         return error_pty_response(request.id, StatusCode::Internal, e.to_string());
     }

{running_process-4.0.2 → running_process-4.0.3}/crates/running-process/src/daemon/pty_sessions.rs

@@ -25,6 +25,7 @@ use std::thread;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use crate::pty::NativePtyProcess;
+use crate::terminal_graphics::TerminalGraphicsCapabilities;
 use tokio::sync::mpsc;
 use tracing::{debug, warn};
 
@@ -154,6 +155,9 @@ struct AttachedClient {
     /// Client-supplied TERM value. Recorded for the session's lifetime
     /// so list/snapshot can surface it.
     term: String,
+    /// Client-supplied terminal graphics capability metadata. Missing
+    /// metadata from older clients is represented as unknown.
+    graphics_capabilities: TerminalGraphicsCapabilities,
 }
 
 /// Final state once the child exits.
@@ -395,6 +399,18 @@ impl OwnedPtySession {
             .unwrap_or_default()
     }
 
+    /// Graphics capability metadata supplied by the currently attached
+    /// client. Missing metadata from older clients is represented as
+    /// unknown rather than inferred from daemon environment.
+    pub fn attached_graphics_capabilities(&self) -> TerminalGraphicsCapabilities {
+        self.attached
+            .lock()
+            .unwrap()
+            .as_ref()
+            .map(|c| c.graphics_capabilities.clone())
+            .unwrap_or_else(TerminalGraphicsCapabilities::unknown)
+    }
+
     /// Install an attached client. Returns the receiver half + a snapshot of
     /// the current backlog (with the cumulative bytes-dropped counter).
     ///
@@ -408,7 +424,14 @@ impl OwnedPtySession {
         rows: u16,
         cols: u16,
     ) -> Result<(AttachmentHandle, Vec<u8>, u64), AttachError> {
-        self.attach_with_terminal_info(steal, rows, cols, true, String::new())
+        self.attach_with_terminal_info(
+            steal,
+            rows,
+            cols,
+            true,
+            String::new(),
+            TerminalGraphicsCapabilities::unknown(),
+        )
     }
 
     /// Like [`Self::attach`] but lets the caller record whether the
@@ -422,6 +445,7 @@ impl OwnedPtySession {
         cols: u16,
         is_tty: bool,
         term: String,
+        graphics_capabilities: TerminalGraphicsCapabilities,
     ) -> Result<(AttachmentHandle, Vec<u8>, u64), AttachError> {
         // If the session has already exited, surface that immediately rather
         // than handing out an attachment for a corpse.
@@ -461,6 +485,7 @@ impl OwnedPtySession {
             sender: tx,
             is_tty,
             term,
+            graphics_capabilities,
         });
         Ok((AttachmentHandle { receiver: rx }, backlog, dropped))
     }

{running_process-4.0.2 → running_process-4.0.3}/crates/running-process/src/lib.rs

@@ -39,6 +39,7 @@ pub mod pty;
 mod public_symbols;
 mod rust_debug;
 pub mod spawn;
+pub mod terminal_graphics;
 mod types;
 #[cfg(unix)]
 mod unix;
@@ -54,6 +55,12 @@ pub use spawn::{
     spawn, spawn_daemon, spawn_daemon_with_clear_env, DaemonChild, SpawnStdio, SpawnedChild,
     StdioSource,
 };
+pub use terminal_graphics::{
+    current_terminal_capabilities, current_terminal_capabilities_with_timeout,
+    detect_terminal_capabilities, CapabilityStatus, EvidenceStrength, GraphicsCapability,
+    GraphicsProtocol, TerminalCapabilities, TerminalCapabilityInput, TerminalGraphicsCapabilities,
+    TerminalProbeEvidence,
+};
 pub use types::{
     CommandSpec, ProcessConfig, ProcessError, ReadStatus, RunOutput, StderrMode, StdinMode,
     StreamEvent, StreamKind,
@@ -877,9 +884,7 @@ impl NativeProcess {
     fn pipe_done_callback(&self, stream: StreamKind) -> Box<dyn FnOnce() + Send> {
         let handles = Arc::clone(&self.capture_pipe_handles);
         Box::new(move || {
-            let mut guard = handles
-                .lock()
-                .expect("capture pipe handles mutex poisoned");
+            let mut guard = handles.lock().expect("capture pipe handles mutex poisoned");
             match stream {
                 StreamKind::Stdout => guard.stdout = None,
                 StreamKind::Stderr => guard.stderr = None,
@@ -930,9 +935,7 @@ impl NativeProcess {
     }
 
     fn wait_for_capture_completion_impl(&self) {
-        crate::rp_rust_debug_scope!(
-            "running_process::NativeProcess::wait_for_capture_completion"
-        );
+        crate::rp_rust_debug_scope!("running_process::NativeProcess::wait_for_capture_completion");
         if !self.config.capture {
             return;
         }