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

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

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

{running_process-4.0.1 → 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.1"
+version = "4.0.3"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 4.0.1
+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:
@@ -200,6 +216,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 +304,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 +312,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:
+
+```bash
+uv run -m ci.test --live-only
+```
+
+For a narrower live-only selection, pass pytest targets and selectors through
+the same entrypoint:
+
+```bash
+uv run -m ci.test --live-only tests/test_pty_support.py interrupt
+```
 
-For direct Rust commands, prefer the repo trampolines, which prepend the shared `rustup` proxy location:
+For direct Cargo build commands, use `uvx soldr` directly:
 
 ```bash
-./_cargo check --workspace
-./_cargo fmt --all --check
-./_cargo clippy --workspace --all-targets -- -D warnings
+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.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:
@@ -186,6 +202,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 +290,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 +298,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:
+
+```bash
+uv run -m ci.test --live-only
+```
+
+For a narrower live-only selection, pass pytest targets and selectors through
+the same entrypoint:
 
-For direct Rust commands, prefer the repo trampolines, which prepend the shared `rustup` proxy location:
+```bash
+uv run -m ci.test --live-only tests/test_pty_support.py interrupt
+```
+
+For direct Cargo build commands, use `uvx soldr` directly:
 
 ```bash
-./_cargo check --workspace
-./_cargo fmt --all --check
-./_cargo clippy --workspace --all-targets -- -D warnings
+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.3}/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.3}/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 {
@@ -86,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
 // ---------------------------------------------------------------------------
@@ -133,6 +161,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 +208,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;
 }
 
 // ---------------------------------------------------------------------------
@@ -191,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;
@@ -484,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 {
@@ -542,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 {
@@ -763,6 +814,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.3}/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.1 → 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 {