polypty 0.1.0

Agent-aware terminal multiplexer with sidebar tabs and nested panes
Documentation
mod snapshot;
mod target;

use anyhow::{bail, Result};

use crate::control::{ControlRequest, ControlResponse, PaneCapture};

use super::App;

impl App {
    pub(crate) fn handle_control(&mut self, request: ControlRequest) -> ControlResponse {
        self.run_control(request)
            .unwrap_or_else(ControlResponse::error)
    }

    fn run_control(&mut self, request: ControlRequest) -> Result<ControlResponse> {
        match request {
            ControlRequest::Ping => Ok(ControlResponse::Pong {
                pid: std::process::id(),
            }),
            ControlRequest::ListSessions => Ok(ControlResponse::Sessions {
                sessions: vec![self.session_summary()],
            }),
            ControlRequest::ListTabs => Ok(ControlResponse::Tabs {
                tabs: self.tab_summaries(),
            }),
            ControlRequest::NewTab => {
                self.spawn_workspace()?;
                Ok(ControlResponse::Tab {
                    tab: self.active_tab_summary(),
                })
            }
            ControlRequest::SelectTab { target } => self.select_control_tab(&target),
            ControlRequest::CloseTab { target } => self.close_control_tab(&target),
            ControlRequest::CapturePane { tab, pane } => self.capture_control_pane(tab, pane),
            ControlRequest::SendKeys {
                tab,
                pane,
                text,
                enter,
            } => self.send_control_keys(tab, pane, text, enter),
        }
    }

    fn select_control_tab(&mut self, target: &str) -> Result<ControlResponse> {
        let index = self.resolve_tab(target)?;
        self.select_workspace(index)?;
        Ok(ControlResponse::Tab {
            tab: self.tab_summary(index),
        })
    }

    fn close_control_tab(&mut self, target: &str) -> Result<ControlResponse> {
        let index = self.resolve_tab(target)?;
        let final_tab = self.book.len() == 1;
        self.close_workspace(index)?;
        let message = if final_tab {
            "exit confirmation shown"
        } else {
            "tab closed"
        };
        Ok(ControlResponse::Ack {
            message: message.into(),
        })
    }

    fn capture_control_pane(
        &self,
        tab: Option<String>,
        pane: Option<u64>,
    ) -> Result<ControlResponse> {
        let (index, pane) = self.resolve_pane(tab.as_deref(), pane)?;
        let workspace = self.book.get(index).expect("resolved tab exists");
        let screen = workspace.pane_screen(pane).expect("resolved pane exists");
        Ok(ControlResponse::Capture {
            capture: PaneCapture {
                tab: index + 1,
                pane,
                text: capture_screen(screen),
            },
        })
    }

    fn send_control_keys(
        &mut self,
        tab: Option<String>,
        pane: Option<u64>,
        text: String,
        enter: bool,
    ) -> Result<ControlResponse> {
        let (index, pane) = self.resolve_pane(tab.as_deref(), pane)?;
        let mut bytes = text.into_bytes();
        if enter {
            bytes.push(b'\r');
        }
        let workspace = self.book.get_mut(index).expect("resolved tab exists");
        if !workspace.write_pane(pane, &bytes)? {
            bail!("pane %{pane} no longer exists");
        }
        Ok(ControlResponse::Ack {
            message: format!(
                "sent {} bytes to tab {} pane %{pane}",
                bytes.len(),
                index + 1
            ),
        })
    }
}

fn capture_screen(screen: &vt100::Screen) -> String {
    let (_, cols) = screen.size();
    let mut rows = screen
        .rows(0, cols)
        .map(|row| row.trim_end().to_owned())
        .collect::<Vec<_>>();
    while rows.last().is_some_and(String::is_empty) {
        rows.pop();
    }
    rows.join("\n")
}