Struct StdioChild 

pub struct StdioChild { /* private fields */ }

A long-lived child process with piped stdio streams.

Wraps tokio::process::Child so the LSP code (and future callers like plugin-managed tool agents) doesn’t reach into concrete process types — that way a container authority can transparently run the child through docker exec -i while the caller keeps talking to an ordinary stdin/stdout pair.

Streams are Option-wrapped so callers can Self::take_stdin / Self::take_stdout / Self::take_stderr into their own reader and writer tasks. After all streams are taken, the StdioChild is still useful for lifecycle control via Self::kill and Self::wait.

spawned_locally tells callers whether id() names the real child process (true for local spawns) or an intermediate like docker / ssh (false). LSP’s cgroup-attachment step keys off this — applying a cgroup to the docker CLI PID doesn’t constrain the container- side server it exec’d.

Implementations

impl StdioChild

pub fn from_tokio_child(child: Child, spawned_locally: bool) -> Self

Construct a StdioChild from an already-spawned tokio::process::Child. Pulls the piped streams out of the child so callers can take them individually later.

This constructor is for spawners that don’t participate in host-side resource limiting (the Docker variant is the canonical example). Local spawners should prefer Self::from_local_tokio_child so a PostSpawnAction produced by ProcessLimits::apply_to_command is applied to the child’s PID before the spawner returns.

pub fn from_local_tokio_child(child: Child, post_spawn: PostSpawnAction) -> Self

Construct a StdioChild for a locally-spawned child while applying any host-side PostSpawnAction (cgroup attachment) returned by ProcessLimits::apply_to_command. Best-effort: failure to attach logs a warning but doesn’t fail the spawn, matching the pre-refactor behavior.

pub fn take_stdin(&mut self) -> Option<ChildStdin>

Take the stdin stream. Returns None after the first call.

pub fn take_stdout(&mut self) -> Option<ChildStdout>

Take the stdout stream. Returns None after the first call.

pub fn take_stderr(&mut self) -> Option<ChildStderr>

Take the stderr stream. Returns None after the first call.

pub fn id(&self) -> Option<u32>

PID of the immediate child process. For local spawns this is the LSP server itself; for docker/ssh this is the CLI wrapper. Use Self::spawned_locally to tell which.

pub fn spawned_locally(&self) -> bool

true when the child PID names the real target process. Callers that only apply host-side resource controls (cgroups, rlimits) should skip their application when this is false.

pub async fn kill(&mut self) -> Result<()>

Request termination. Forwards to tokio::process::Child::kill.

pub async fn wait(&mut self) -> Result<ExitStatus>

Await exit. Forwards to tokio::process::Child::wait.