@team-agent/installer 0.2.11 → 0.3.0

package/crates/team-agent/src/tmux_backend.rs

@@ -0,0 +1,758 @@
+//! Concrete tmux `Transport` backend (SKELETON) — the real executor that runs `tmux <argv>`.
+//!
+//! step 9 shipped the [`crate::transport::Transport`] trait + the pure tmux argv-builders
+//! (`tmux_spawn_argv`, `tmux_capture_argv`, `tmux_send_keys_argv`, `tmux_inject_text_argv`,
+//! `tmux_query_argv`, `tmux_cancel_mode_argv`) but NO concrete backend that actually executes them.
+//! This is that backend: each `Transport` method builds its argv via those builders, runs it through
+//! a [`CommandRunner`] seam, and parses the tmux output into the trait's typed return.
+//!
+//! THE SEAM: [`CommandRunner`] is the single OS edge. [`RealCommandRunner`] runs
+//! `std::process::Command::new("tmux") …`; tests inject a recording/canned runner so the argv
+//! construction + output parsing are unit-testable in-process, while the real subprocess execution
+//! stays the `#[ignore]` real-machine boundary (acceptance framework).
+//!
+//! §10: the implementation must be panic-free (porter adds the deny + bodies; this skeleton is
+//! `unimplemented!()`). MUST-NOT-13: a transport backend has no provider-client dependency.
+#![allow(dead_code)]
+
+use std::collections::BTreeMap;
+use std::hash::{Hash, Hasher};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+use std::time::{Duration, Instant};
+
+use crate::model::enums::PaneLiveness;
+use crate::transport::{
+    normalize_capture, tmux_capture_argv, tmux_empty_inject_argv, tmux_inject_text_argv,
+    tmux_query_argv, tmux_send_keys_argv, tmux_spawn_argv, AttachOutcome, BackendKind,
+    CaptureRange, CapturedText, InjectPayload, InjectReport, InjectStage, InjectVerification, Key,
+    PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome, SpawnResult, SubmitVerification,
+    Target, Transport, TransportError, TurnVerification, WindowName,
+};
+
+/// Result of running an external command — the typed output of the OS edge.
+#[derive(Debug, Clone)]
+pub struct CommandOutput {
+    /// process exit status was success (code 0).
+    pub success: bool,
+    /// exit code if the process exited normally.
+    pub code: Option<i32>,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+/// The single OS-edge seam: run an argv vector and return its output.
+/// Real impl spawns `std::process::Command`; tests inject canned/recording output so the
+/// argv-construction + output-parsing of [`TmuxBackend`] is testable without a live tmux server.
+pub trait CommandRunner: Send + Sync {
+    fn run(&self, argv: &[String]) -> Result<CommandOutput, std::io::Error>;
+
+    fn run_with_stdin(
+        &self,
+        argv: &[String],
+        stdin: &str,
+    ) -> Result<CommandOutput, std::io::Error> {
+        let _ = stdin;
+        self.run(argv)
+    }
+}
+
+/// Production runner: `std::process::Command::new(argv[0]).args(argv[1..]).output()`.
+pub struct RealCommandRunner;
+
+const COMMAND_TIMEOUT: Duration = Duration::from_secs(5);
+
+impl CommandRunner for RealCommandRunner {
+    fn run(&self, argv: &[String]) -> Result<CommandOutput, std::io::Error> {
+        self.run_inner(argv, None)
+    }
+
+    fn run_with_stdin(
+        &self,
+        argv: &[String],
+        stdin: &str,
+    ) -> Result<CommandOutput, std::io::Error> {
+        self.run_inner(argv, Some(stdin))
+    }
+}
+
+impl RealCommandRunner {
+    fn run_inner(
+        &self,
+        argv: &[String],
+        stdin_text: Option<&str>,
+    ) -> Result<CommandOutput, std::io::Error> {
+        let Some(program) = argv.first() else {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "empty argv",
+            ));
+        };
+        let mut child = std::process::Command::new(program)
+            .args(argv.iter().skip(1))
+            .stdin(if stdin_text.is_some() { Stdio::piped() } else { Stdio::null() })
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        if let Some(text) = stdin_text {
+            let mut stdin = child.stdin.take().ok_or_else(|| {
+                std::io::Error::other("stdin pipe missing")
+            })?;
+            stdin.write_all(text.as_bytes())?;
+        }
+        let stdout = child.stdout.take().ok_or_else(|| {
+            std::io::Error::other("stdout pipe missing")
+        })?;
+        let stderr = child.stderr.take().ok_or_else(|| {
+            std::io::Error::other("stderr pipe missing")
+        })?;
+        let stdout_thread = std::thread::spawn(move || read_pipe(stdout));
+        let stderr_thread = std::thread::spawn(move || read_pipe(stderr));
+        let deadline = Instant::now() + COMMAND_TIMEOUT;
+        let status = loop {
+            if let Some(status) = child.try_wait()? {
+                break status;
+            }
+            if Instant::now() >= deadline {
+                child.kill()?;
+                child.wait()?;
+                let _ = join_pipe_reader(stdout_thread)?;
+                let _ = join_pipe_reader(stderr_thread)?;
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::TimedOut,
+                    format!("{program} exceeded 5s timeout"),
+                ));
+            }
+            std::thread::sleep(Duration::from_millis(25));
+        };
+        let stdout = join_pipe_reader(stdout_thread)?;
+        let stderr = join_pipe_reader(stderr_thread)?;
+        Ok(CommandOutput {
+            success: status.success(),
+            code: status.code(),
+            stdout,
+            stderr,
+        })
+    }
+}
+
+fn read_pipe<R: Read>(mut reader: R) -> Result<String, std::io::Error> {
+    let mut bytes = Vec::new();
+    reader.read_to_end(&mut bytes)?;
+    Ok(String::from_utf8_lossy(&bytes).to_string())
+}
+
+fn join_pipe_reader(
+    handle: std::thread::JoinHandle<Result<String, std::io::Error>>,
+) -> Result<String, std::io::Error> {
+    handle
+        .join()
+        .map_err(|_| std::io::Error::other("pipe reader thread panicked"))?
+}
+
+/// Concrete tmux backend: builds argv via the `transport::tmux_*_argv` builders, runs them through
+/// the [`CommandRunner`], and parses tmux output into the [`Transport`] typed returns.
+///
+/// CP-1: a workspace-bound backend carries a PER-TEAM tmux socket (`socket = Some("ta-<hash>")`) so a
+/// dying shared `default` server can no longer tear the team down. The socket is injected at the RUN
+/// CHOKEPOINT ([`TmuxBackend::tmux_argv`]) — the `transport::tmux_*_argv` builders stay socket-free.
+pub struct TmuxBackend {
+    runner: Box<dyn CommandRunner>,
+    /// `Some(name)` for a per-team socket -> every `tmux` argv gets `-L <name>` injected after the
+    /// leading "tmux" token; `None` (default) -> bare `tmux` on the shared default socket.
+    socket: Option<String>,
+}
+
+impl TmuxBackend {
+    /// Backend bound to the real `tmux` subprocess on the SHARED default socket (no `-L`).
+    /// Non-team callers + existing argv/unit tests stay unaffected.
+    pub fn new() -> Self {
+        Self { runner: Box::new(RealCommandRunner), socket: None }
+    }
+
+    /// CP-1 team backend: bound to the real `tmux` subprocess on a PER-WORKSPACE socket, derived
+    /// deterministically from the canonicalized workspace path so the leader CLI, the daemon, and
+    /// every later op (spawn / inject / has_session / kill) hit the SAME `tmux -L <socket>` server.
+    pub fn for_workspace(workspace: &Path) -> Self {
+        Self {
+            runner: Box::new(RealCommandRunner),
+            socket: Some(socket_name_for_workspace(workspace)),
+        }
+    }
+
+    /// Backend with an injected runner (tests: canned/recording tmux output). Shared default socket.
+    pub fn with_runner(runner: Box<dyn CommandRunner>) -> Self {
+        Self { runner, socket: None }
+    }
+
+    /// Backend with an injected runner bound to a per-workspace socket (tests: assert the `-L` is in
+    /// the recorded argv for a workspace-bound backend).
+    pub fn with_runner_for_workspace(runner: Box<dyn CommandRunner>, workspace: &Path) -> Self {
+        Self { runner, socket: Some(socket_name_for_workspace(workspace)) }
+    }
+
+    /// THE RUN CHOKEPOINT: every executed `tmux` argv is funneled through here. When a per-team
+    /// socket is set, inject `-L <socket>` right after the leading "tmux" token; otherwise pass argv
+    /// through unchanged. Non-`tmux` argv (e.g. the spawned provider command) is never rewritten.
+    fn tmux_argv(&self, argv: &[String]) -> Vec<String> {
+        match &self.socket {
+            Some(socket) if argv.first().map(String::as_str) == Some("tmux") => {
+                let mut out = Vec::with_capacity(argv.len() + 2);
+                out.push("tmux".to_string());
+                out.push("-L".to_string());
+                out.push(socket.clone());
+                out.extend(argv.iter().skip(1).cloned());
+                out
+            }
+            _ => argv.to_vec(),
+        }
+    }
+
+    /// `tmux -L <socket> kill-server` (CP-1 cleanup): best-effort teardown of the per-team server on
+    /// shutdown so per-team sockets do not orphan. No-op (and never errors) for a default-socket
+    /// backend, and a "no server" failure is ignored.
+    pub fn kill_server(&self) {
+        if self.socket.is_none() {
+            return;
+        }
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "kill-server".to_string(),
+        ]);
+        let _ = self.runner.run(&argv);
+    }
+}
+
+/// CP-1 socket name: SHORT + DETERMINISTIC per canonical workspace path. `ta-` + 12 hex chars of a
+/// stable FNV-1a hash over the canonicalized path. AF_UNIX `sun_path` is ~104 chars and the socket
+/// lives at `/tmp/tmux-<uid>/<name>`, so we must NOT use the (~88-char) session name. §10: a
+/// canonicalize failure falls back to the raw path (never panics).
+pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
+    let canonical = workspace
+        .canonicalize()
+        .unwrap_or_else(|_| workspace.to_path_buf());
+    let mut hasher = Fnv1a::default();
+    canonical.as_os_str().hash(&mut hasher);
+    format!("ta-{:012x}", hasher.finish() & 0xffff_ffff_ffff)
+}
+
+/// Deterministic FNV-1a (64-bit) — std `DefaultHasher` is NOT stable across releases, so a fixed
+/// FNV keeps the socket identical for the CLI, the daemon, and every later op on the same workspace.
+struct Fnv1a(u64);
+
+impl Default for Fnv1a {
+    fn default() -> Self {
+        Self(0xcbf2_9ce4_8422_2325)
+    }
+}
+
+impl Hasher for Fnv1a {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        for &b in bytes {
+            self.0 ^= u64::from(b);
+            self.0 = self.0.wrapping_mul(0x0000_0100_0000_01b3);
+        }
+    }
+}
+
+impl Default for TmuxBackend {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TmuxBackend {
+    fn spawn(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        first: bool,
+    ) -> Result<SpawnResult, TransportError> {
+        let command = shell_command(argv, cwd, env);
+        let spawn_argv = tmux_spawn_argv(session, window, &command, first);
+        self.run_spawn(&spawn_argv)?;
+        let pane_argv = vec![
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            format!("{}:{}", session.as_str(), window.as_str()),
+            "#{pane_id}".to_string(),
+        ];
+        let output = self.run_spawn(&pane_argv)?;
+        let pane = output.stdout.trim();
+        let pane_id = if pane.is_empty() { "%0" } else { pane };
+        Ok(SpawnResult {
+            pane_id: PaneId::new(pane_id),
+            session: session.clone(),
+            window: window.clone(),
+            child_pid: None,
+        })
+    }
+
+    fn run_ok(&self, argv: &[String]) -> Result<(), TransportError> {
+        let argv = self.tmux_argv(argv);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            Ok(())
+        } else {
+            Err(subprocess_error(argv, output))
+        }
+    }
+
+    fn run_spawn(&self, argv: &[String]) -> Result<CommandOutput, TransportError> {
+        let argv = self.tmux_argv(argv);
+        let output = self.runner.run(&argv).map_err(|source| TransportError::Spawn {
+            backend: BackendKind::Tmux,
+            source,
+        })?;
+        if output.success {
+            Ok(output)
+        } else {
+            Err(subprocess_error(argv, output))
+        }
+    }
+
+    fn run_inject_stage(
+        &self,
+        argv: &[String],
+        stage: InjectStage,
+    ) -> Result<(), TransportError> {
+        let argv = self.tmux_argv(argv);
+        let output = self.runner.run(&argv).map_err(|source| TransportError::Inject {
+            stage,
+            source,
+        })?;
+        if output.success {
+            Ok(())
+        } else {
+            Err(subprocess_error(argv, output))
+        }
+    }
+
+    fn run_inject_stage_with_stdin(
+        &self,
+        argv: &[String],
+        stage: InjectStage,
+        stdin: &str,
+    ) -> Result<(), TransportError> {
+        let argv = self.tmux_argv(argv);
+        let output = self.runner.run_with_stdin(&argv, stdin).map_err(|source| TransportError::Inject {
+            stage,
+            source,
+        })?;
+        if output.success {
+            Ok(())
+        } else {
+            Err(subprocess_error(argv, output))
+        }
+    }
+}
+
+fn subprocess_error(argv: Vec<String>, output: CommandOutput) -> TransportError {
+    TransportError::Subprocess {
+        argv,
+        code: output.code,
+        stderr: output.stderr,
+    }
+}
+
+fn pane_from_target(target: &Target) -> PaneId {
+    match target {
+        Target::Pane(pane) => pane.clone(),
+        Target::SessionWindow { session, window } => {
+            PaneId::new(format!("{}:{}", session.as_str(), window.as_str()))
+        }
+    }
+}
+
+fn target_name(target: &Target) -> String {
+    match target {
+        Target::Pane(pane) => pane.as_str().to_string(),
+        Target::SessionWindow { session, window } => {
+            format!("{}:{}", session.as_str(), window.as_str())
+        }
+    }
+}
+
+fn inject_stage_for_argv(argv: &[String]) -> InjectStage {
+    match argv.get(1).map(String::as_str) {
+        Some("set-buffer") => InjectStage::SetBuffer,
+        Some("load-buffer") => InjectStage::LoadBuffer,
+        Some("paste-buffer") => InjectStage::PasteBuffer,
+        Some("delete-buffer") => InjectStage::DeleteBuffer,
+        Some("send-keys") => InjectStage::Submit,
+        _ => InjectStage::Submit,
+    }
+}
+
+fn pane_mode_from_raw(raw: Option<String>) -> Option<PaneMode> {
+    match raw.as_deref().map(str::trim) {
+        Some("") | Some("0") => None,
+        Some("copy-mode") => Some(PaneMode::Copy),
+        Some("tree-mode") => Some(PaneMode::Tree),
+        Some("view-mode") => Some(PaneMode::View),
+        Some("client-mode") => Some(PaneMode::Client),
+        _ => Some(PaneMode::Unknown),
+    }
+}
+
+fn buffer_name_for_text(text: &str) -> String {
+    const PREFIX: &str = "[team-agent-token:";
+    match text.find(PREFIX) {
+        Some(prefix_start) => {
+            let token_start = prefix_start.saturating_add(PREFIX.len());
+            let Some(rest) = text.get(token_start..) else {
+                return "team-agent-buf".to_string();
+            };
+            let Some(token_end) = rest.find(']') else {
+                return "team-agent-buf".to_string();
+            };
+            let Some(token) = rest.get(..token_end).filter(|s| !s.is_empty()) else {
+                return "team-agent-buf".to_string();
+            };
+            format!("team-agent-send-{token}")
+        }
+        None => "team-agent-buf".to_string(),
+    }
+}
+
+fn inject_verification_for_payload(payload: &InjectPayload) -> InjectVerification {
+    match payload {
+        InjectPayload::Empty => InjectVerification::EmptyTextSendKeys,
+        InjectPayload::Text(text) if text.contains("[team-agent-token:") => {
+            InjectVerification::CaptureContainsToken
+        }
+        InjectPayload::Text(_) => InjectVerification::NoToken,
+    }
+}
+
+fn submit_verification_for_key(key: Key) -> SubmitVerification {
+    match key {
+        Key::Enter => SubmitVerification::EnterSentWithoutPlaceholderCheck,
+        other => SubmitVerification::KeySentAfterVisibleToken { key: other },
+    }
+}
+
+fn shell_command(argv: &[String], cwd: &Path, env: &BTreeMap<String, String>) -> String {
+    let mut parts = Vec::new();
+    parts.push("cd".to_string());
+    parts.push(shell_quote(&cwd.to_string_lossy()));
+    parts.push("&&".to_string());
+    for (key, value) in env {
+        parts.push(format!("{key}={}", shell_quote(value)));
+    }
+    parts.push("exec".to_string());
+    parts.extend(argv.iter().map(|arg| shell_quote(arg)));
+    parts.join(" ")
+}
+
+fn shell_quote(raw: &str) -> String {
+    if raw.is_empty() {
+        return "''".to_string();
+    }
+    if raw
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || matches!(c, '/' | '.' | '_' | '-' | ':' | '='))
+    {
+        return raw.to_string();
+    }
+    let mut quoted = String::from("'");
+    for ch in raw.chars() {
+        if ch == '\'' {
+            quoted.push_str("'\\''");
+        } else {
+            quoted.push(ch);
+        }
+    }
+    quoted.push('\'');
+    quoted
+}
+
+impl Transport for TmuxBackend {
+    fn kind(&self) -> BackendKind {
+        BackendKind::Tmux
+    }
+
+    fn spawn_first(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        self.spawn(session, window, argv, cwd, env, true)
+    }
+
+    fn spawn_into(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        self.spawn(session, window, argv, cwd, env, false)
+    }
+
+    fn inject(
+        &self,
+        target: &Target,
+        payload: &InjectPayload,
+        submit: Key,
+        bracketed: bool,
+    ) -> Result<InjectReport, TransportError> {
+        let pane = pane_from_target(target);
+        match payload {
+            InjectPayload::Empty => {
+                let argv = tmux_empty_inject_argv(&pane, submit);
+                self.run_ok(&argv)?;
+            }
+            InjectPayload::Text(text) => {
+                let buffer = buffer_name_for_text(text);
+                for argv in tmux_inject_text_argv(&pane, &buffer, text, bracketed) {
+                    let stage = inject_stage_for_argv(&argv);
+                    if stage == InjectStage::LoadBuffer {
+                        self.run_inject_stage_with_stdin(&argv, stage, text)?;
+                    } else {
+                        self.run_inject_stage(&argv, stage)?;
+                    }
+                }
+                let submit_argv = tmux_send_keys_argv(&pane, &[submit]);
+                self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
+            }
+        }
+        Ok(InjectReport {
+            stage_reached: InjectStage::Submit,
+            inject_verification: inject_verification_for_payload(payload),
+            submit_verification: submit_verification_for_key(submit),
+            turn_verification: match payload {
+                InjectPayload::Empty => TurnVerification::NotRequired,
+                InjectPayload::Text(_) => TurnVerification::NotYetObserved,
+            },
+            attempts: 1,
+        })
+    }
+
+    fn send_keys(&self, target: &Target, keys: &[Key]) -> Result<(), TransportError> {
+        let pane = pane_from_target(target);
+        if keys.contains(&Key::CancelMode) {
+            if let Some(mode) = pane_mode_from_raw(self.query(target, PaneField::PaneMode)?) {
+                let argv = crate::transport::tmux_cancel_mode_argv(&pane, mode);
+                return self.run_ok(&argv);
+            }
+            return Ok(());
+        }
+        let argv = tmux_send_keys_argv(&pane, keys);
+        self.run_ok(&argv)
+    }
+
+    fn capture(
+        &self,
+        target: &Target,
+        range: CaptureRange,
+    ) -> Result<CapturedText, TransportError> {
+        let pane = pane_from_target(target);
+        let argv = self.tmux_argv(&tmux_capture_argv(&pane, range));
+        let output = self.runner.run(&argv).map_err(|source| TransportError::Capture { source })?;
+        if !output.success {
+            return Err(subprocess_error(argv, output));
+        }
+        Ok(CapturedText {
+            text: normalize_capture(&output.stdout),
+            range,
+        })
+    }
+
+    fn query(
+        &self,
+        target: &Target,
+        field: PaneField,
+    ) -> Result<Option<String>, TransportError> {
+        let pane = pane_from_target(target);
+        let argv = self.tmux_argv(&tmux_query_argv(&pane, field));
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(None);
+        }
+        Ok(Some(output.stdout.trim().to_string()))
+    }
+
+    fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            "#{pane_id}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            return Ok(PaneLiveness::Live);
+        }
+        if output.stderr.to_ascii_lowercase().contains("can't find pane") {
+            Ok(PaneLiveness::Dead)
+        } else {
+            Ok(PaneLiveness::Unknown)
+        }
+    }
+
+    fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+        const TMUX_PANE_FORMAT: &str = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}";
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "list-panes".to_string(),
+            "-a".to_string(),
+            "-F".to_string(),
+            TMUX_PANE_FORMAT.to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(Vec::new());
+        }
+        let mut panes = Vec::new();
+        for line in output.stdout.lines().filter(|line| !line.is_empty()) {
+            if let Some(pane) = parse_pane_info_line(line) {
+                panes.push(pane);
+            }
+        }
+        Ok(panes)
+    }
+
+    fn has_session(&self, session: &SessionName) -> Result<bool, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "has-session".to_string(),
+            "-t".to_string(),
+            session.as_str().to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        Ok(output.success)
+    }
+
+    fn list_windows(
+        &self,
+        session: &SessionName,
+    ) -> Result<Vec<WindowName>, TransportError> {
+        // golden runtime.py:1023-1029 `_tmux_window_exists`: `tmux list-windows -t <s> -F #{window_name}`;
+        // returncode != 0 -> false (here: an empty window set), else the window names by line.
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "list-windows".to_string(),
+            "-t".to_string(),
+            session.as_str().to_string(),
+            "-F".to_string(),
+            "#{window_name}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(Vec::new());
+        }
+        Ok(output
+            .stdout
+            .lines()
+            .filter(|line| !line.is_empty())
+            .map(WindowName::new)
+            .collect())
+    }
+
+    fn set_session_env(
+        &self,
+        session: &SessionName,
+        key: &str,
+        value: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
+        let argv = vec![
+            "tmux".to_string(),
+            "set-environment".to_string(),
+            "-t".to_string(),
+            session.as_str().to_string(),
+            key.to_string(),
+            value.to_string(),
+        ];
+        self.run_ok(&argv)?;
+        Ok(SetEnvOutcome::Applied)
+    }
+
+    fn kill_session(&self, session: &SessionName) -> Result<(), TransportError> {
+        let argv = vec![
+            "tmux".to_string(),
+            "kill-session".to_string(),
+            "-t".to_string(),
+            session.as_str().to_string(),
+        ];
+        self.run_ok(&argv)
+    }
+
+    fn kill_window(&self, target: &Target) -> Result<(), TransportError> {
+        let argv = vec![
+            "tmux".to_string(),
+            "kill-window".to_string(),
+            "-t".to_string(),
+            target_name(target),
+        ];
+        self.run_ok(&argv)
+    }
+
+    fn attach_session(
+        &self,
+        session: &SessionName,
+    ) -> Result<AttachOutcome, TransportError> {
+        let argv = [
+            "tmux".to_string(),
+            "attach-session".to_string(),
+            "-t".to_string(),
+            session.as_str().to_string(),
+        ];
+        self.run_ok(&argv)?;
+        Ok(AttachOutcome::Attached)
+    }
+}
+
+fn parse_pane_info_line(line: &str) -> Option<PaneInfo> {
+    let fields = line.split('\t').collect::<Vec<_>>();
+    if fields.len() < 11 {
+        return None;
+    }
+    Some(PaneInfo {
+        pane_id: PaneId::new(fields[0]),
+        session: SessionName::new(fields[1]),
+        window_index: parse_optional_u32(fields[2]),
+        window_name: non_empty(fields[3]).map(WindowName::new),
+        pane_index: parse_optional_u32(fields[4]),
+        tty: non_empty(fields[5]).map(str::to_string),
+        current_command: non_empty(fields[6]).map(str::to_string),
+        active: fields[7] == "1",
+        current_path: non_empty(fields[8]).map(PathBuf::from),
+        pane_pid: None,
+        leader_env: BTreeMap::new(),
+    })
+}
+
+fn parse_optional_u32(raw: &str) -> Option<u32> {
+    if raw.is_empty() {
+        return None;
+    }
+    raw.parse::<u32>().ok()
+}
+
+fn non_empty(raw: &str) -> Option<&str> {
+    if raw.is_empty() {
+        None
+    } else {
+        Some(raw)
+    }
+}
+
+#[cfg(test)]
+mod tests;