@moejay/wrightty 0.0.0 → 0.1.1

package/crates/wrightty-bridge-tmux/src/rpc.rs

@@ -1,291 +0,0 @@
-//! jsonrpsee RPC module that maps wrightty protocol methods to tmux CLI commands.
-
-use jsonrpsee::types::ErrorObjectOwned;
-use jsonrpsee::RpcModule;
-
-use wrightty_protocol::error;
-use wrightty_protocol::methods::*;
-use wrightty_protocol::types::*;
-
-use crate::tmux;
-
-fn proto_err(code: i32, msg: impl Into<String>) -> ErrorObjectOwned {
-    ErrorObjectOwned::owned(code, msg.into(), None::<()>)
-}
-
-fn not_supported(method: &str) -> ErrorObjectOwned {
-    proto_err(error::NOT_SUPPORTED, format!("{method} is not supported by the tmux bridge"))
-}
-
-/// Encode wrightty KeyInput values into tmux key name strings.
-///
-/// tmux `send-keys` without `-l` interprets key names like `Enter`, `C-c`, `M-x`, `Up`, etc.
-/// We use this for structured key events. For plain text we use `send-keys -l`.
-fn encode_key_to_tmux(key: &KeyInput) -> String {
-    match key {
-        KeyInput::Shorthand(s) => shorthand_to_tmux(s),
-        KeyInput::Structured(event) => key_event_to_tmux(event),
-    }
-}
-
-fn shorthand_to_tmux(s: &str) -> String {
-    // Modifier combos like "Ctrl+c" -> "C-c", "Alt+x" -> "M-x"
-    if let Some((modifier, key)) = s.split_once('+') {
-        match modifier {
-            "Ctrl" => return format!("C-{}", key.to_lowercase()),
-            "Alt" => return format!("M-{key}"),
-            _ => {}
-        }
-    }
-
-    // Named keys
-    match s {
-        "Enter" | "Return" => "Enter".to_string(),
-        "Tab" => "Tab".to_string(),
-        "Backspace" => "BSpace".to_string(),
-        "Delete" => "Delete".to_string(),
-        "Escape" | "Esc" => "Escape".to_string(),
-        "ArrowUp" | "Up" => "Up".to_string(),
-        "ArrowDown" | "Down" => "Down".to_string(),
-        "ArrowRight" | "Right" => "Right".to_string(),
-        "ArrowLeft" | "Left" => "Left".to_string(),
-        "Home" => "Home".to_string(),
-        "End" => "End".to_string(),
-        "PageUp" => "PPage".to_string(),
-        "PageDown" => "NPage".to_string(),
-        "Insert" => "Insert".to_string(),
-        _ => s.to_string(),
-    }
-}
-
-fn key_event_to_tmux(event: &KeyEvent) -> String {
-    let has_ctrl = event.modifiers.iter().any(|m| matches!(m, Modifier::Ctrl));
-    let has_alt = event.modifiers.iter().any(|m| matches!(m, Modifier::Alt));
-
-    let base = match &event.key {
-        KeyType::Char => event.char.as_deref().unwrap_or("").to_string(),
-        KeyType::Enter => "Enter".to_string(),
-        KeyType::Tab => "Tab".to_string(),
-        KeyType::Backspace => "BSpace".to_string(),
-        KeyType::Delete => "Delete".to_string(),
-        KeyType::Escape => "Escape".to_string(),
-        KeyType::ArrowUp => "Up".to_string(),
-        KeyType::ArrowDown => "Down".to_string(),
-        KeyType::ArrowRight => "Right".to_string(),
-        KeyType::ArrowLeft => "Left".to_string(),
-        KeyType::Home => "Home".to_string(),
-        KeyType::End => "End".to_string(),
-        KeyType::PageUp => "PPage".to_string(),
-        KeyType::PageDown => "NPage".to_string(),
-        KeyType::Insert => "Insert".to_string(),
-        KeyType::F => format!("F{}", event.n.unwrap_or(1)),
-    };
-
-    let mut result = base;
-    if has_ctrl {
-        result = format!("C-{result}");
-    }
-    if has_alt {
-        result = format!("M-{result}");
-    }
-    result
-}
-
-pub fn build_rpc_module() -> anyhow::Result<RpcModule<()>> {
-    let mut module = RpcModule::new(());
-
-    // --- Wrightty.getInfo ---
-    module.register_async_method("Wrightty.getInfo", |_params, _state, _| async move {
-        serde_json::to_value(GetInfoResult {
-            info: ServerInfo {
-                version: "0.1.0".to_string(),
-                implementation: "wrightty-bridge-tmux".to_string(),
-                capabilities: Capabilities {
-                    screenshot: vec![ScreenshotFormat::Text],
-                    max_sessions: 512,
-                    supports_resize: true,
-                    supports_scrollback: true,
-                    supports_mouse: false,
-                    supports_session_create: true,
-                    supports_color_palette: false,
-                    supports_raw_output: false,
-                    supports_shell_integration: false,
-                    events: vec![],
-                },
-            },
-        })
-        .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Session.create ---
-    module.register_async_method("Session.create", |_params, _state, _| async move {
-        let target = tmux::new_window(None)
-            .await
-            .map_err(|e| proto_err(error::SPAWN_FAILED, e.to_string()))?;
-
-        serde_json::to_value(SessionCreateResult { session_id: target })
-            .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Session.destroy ---
-    module.register_async_method("Session.destroy", |params, _state, _| async move {
-        let p: SessionDestroyParams = params.parse()?;
-
-        tmux::kill_pane(&p.session_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        serde_json::to_value(SessionDestroyResult { exit_code: None })
-            .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Session.list ---
-    module.register_async_method("Session.list", |_params, _state, _| async move {
-        let panes = tmux::list_panes()
-            .await
-            .map_err(|e| proto_err(-32603, e.to_string()))?;
-
-        let sessions: Vec<SessionInfo> = panes
-            .into_iter()
-            .map(|p| SessionInfo {
-                session_id: p.target,
-                title: if p.title.is_empty() {
-                    format!("{}:{}.{}", p.session_name, p.window_index, p.pane_index)
-                } else {
-                    p.title
-                },
-                cwd: None,
-                cols: p.cols,
-                rows: p.rows,
-                pid: if p.pid > 0 { Some(p.pid) } else { None },
-                running: true,
-                alternate_screen: false,
-            })
-            .collect();
-
-        serde_json::to_value(SessionListResult { sessions })
-            .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Session.getInfo ---
-    module.register_async_method("Session.getInfo", |params, _state, _| async move {
-        let p: SessionGetInfoParams = params.parse()?;
-
-        let pane = tmux::find_pane(&p.session_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        let info = SessionInfo {
-            session_id: pane.target,
-            title: if pane.title.is_empty() {
-                format!("{}:{}.{}", pane.session_name, pane.window_index, pane.pane_index)
-            } else {
-                pane.title
-            },
-            cwd: None,
-            cols: pane.cols,
-            rows: pane.rows,
-            pid: if pane.pid > 0 { Some(pane.pid) } else { None },
-            running: true,
-            alternate_screen: false,
-        };
-
-        serde_json::to_value(info).map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Input.sendText ---
-    module.register_async_method("Input.sendText", |params, _state, _| async move {
-        let p: InputSendTextParams = params.parse()?;
-
-        tmux::send_text(&p.session_id, &p.text)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        Ok::<_, ErrorObjectOwned>(serde_json::json!({}))
-    })?;
-
-    // --- Input.sendKeys ---
-    module.register_async_method("Input.sendKeys", |params, _state, _| async move {
-        let p: InputSendKeysParams = params.parse()?;
-
-        for key in &p.keys {
-            let tmux_key = encode_key_to_tmux(key);
-            // Determine if this is literal text (single char shorthand) or a key name
-            let is_literal = matches!(key, KeyInput::Shorthand(s) if s.len() == 1 && !s.contains('+'));
-            if is_literal {
-                tmux::send_text(&p.session_id, &tmux_key)
-                    .await
-                    .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-            } else {
-                tmux::send_key(&p.session_id, &tmux_key)
-                    .await
-                    .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-            }
-        }
-
-        Ok::<_, ErrorObjectOwned>(serde_json::json!({}))
-    })?;
-
-    // --- Screen.getText ---
-    module.register_async_method("Screen.getText", |params, _state, _| async move {
-        let p: ScreenGetTextParams = params.parse()?;
-
-        let mut text = tmux::capture_pane(&p.session_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        if p.trim_trailing_whitespace {
-            text = text
-                .lines()
-                .map(|line| line.trim_end())
-                .collect::<Vec<_>>()
-                .join("\n");
-        }
-
-        serde_json::to_value(ScreenGetTextResult { text })
-            .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Terminal.getSize ---
-    module.register_async_method("Terminal.getSize", |params, _state, _| async move {
-        let p: TerminalGetSizeParams = params.parse()?;
-
-        let pane = tmux::find_pane(&p.session_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        serde_json::to_value(TerminalGetSizeResult {
-            cols: pane.cols,
-            rows: pane.rows,
-        })
-        .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Terminal.resize ---
-    module.register_async_method("Terminal.resize", |params, _state, _| async move {
-        let p: TerminalResizeParams = params.parse()?;
-
-        tmux::resize_pane(&p.session_id, p.cols, p.rows)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        Ok::<_, ErrorObjectOwned>(serde_json::json!({}))
-    })?;
-
-    // --- Screen.getContents (not supported) ---
-    module.register_async_method("Screen.getContents", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Screen.getContents"))
-    })?;
-
-    // --- Screen.screenshot (not supported) ---
-    module.register_async_method("Screen.screenshot", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Screen.screenshot"))
-    })?;
-
-    // --- Input.sendMouse (not supported) ---
-    module.register_async_method("Input.sendMouse", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Input.sendMouse"))
-    })?;
-
-    Ok(module)
-}

package/crates/wrightty-bridge-tmux/src/tmux.rs

@@ -1,215 +0,0 @@
-//! Functions that shell out to `tmux` CLI commands.
-
-use tokio::process::Command;
-
-#[derive(Debug, Clone)]
-pub struct TmuxPane {
-    /// Full pane target in `<session>:<window>.<pane>` format, e.g. `main:0.1`
-    pub target: String,
-    pub session_name: String,
-    pub window_index: u32,
-    pub pane_index: u32,
-    pub cols: u16,
-    pub rows: u16,
-    pub title: String,
-    pub active: bool,
-    pub pid: u32,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum TmuxError {
-    #[error("tmux command failed: {0}")]
-    CommandFailed(String),
-    #[error("failed to parse tmux output: {0}")]
-    ParseError(String),
-    #[error("pane {0} not found")]
-    PaneNotFound(String),
-    #[error("io error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-fn tmux_cmd(args: &[&str]) -> Command {
-    let cmd_str = std::env::var("TMUX_CMD").unwrap_or_else(|_| "tmux".to_string());
-    let parts: Vec<&str> = cmd_str.split_whitespace().collect();
-    let (program, prefix_args) = parts.split_first().expect("TMUX_CMD must not be empty");
-
-    let mut cmd = Command::new(program);
-    for arg in prefix_args {
-        cmd.arg(arg);
-    }
-    for arg in args {
-        cmd.arg(arg);
-    }
-    cmd
-}
-
-/// Check if tmux server is reachable.
-pub async fn health_check() -> Result<(), TmuxError> {
-    let output = tmux_cmd(&["list-sessions"]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(format!("tmux not reachable: {stderr}")));
-    }
-
-    Ok(())
-}
-
-/// List all panes across all sessions.
-pub async fn list_panes() -> Result<Vec<TmuxPane>, TmuxError> {
-    // Format: session_name:window_index.pane_index|cols|rows|title|active|pid
-    let format = "#{session_name}:#{window_index}.#{pane_index}|#{pane_width}|#{pane_height}|#{pane_title}|#{pane_active}|#{pane_pid}";
-    let output = tmux_cmd(&["list-panes", "-a", "-F", format]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let mut panes = Vec::new();
-
-    for line in stdout.lines() {
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-        let parts: Vec<&str> = line.splitn(6, '|').collect();
-        if parts.len() < 6 {
-            continue;
-        }
-        let target = parts[0].to_string();
-        // Parse session:window.pane from target
-        let (session_name, window_pane) = target
-            .split_once(':')
-            .ok_or_else(|| TmuxError::ParseError(format!("bad target: {target}")))?;
-        let (window_str, pane_str) = window_pane
-            .split_once('.')
-            .ok_or_else(|| TmuxError::ParseError(format!("bad target: {target}")))?;
-
-        panes.push(TmuxPane {
-            target: target.clone(),
-            session_name: session_name.to_string(),
-            window_index: window_str.parse().unwrap_or(0),
-            pane_index: pane_str.parse().unwrap_or(0),
-            cols: parts[1].parse().unwrap_or(80),
-            rows: parts[2].parse().unwrap_or(24),
-            title: parts[3].to_string(),
-            active: parts[4] == "1",
-            pid: parts[5].trim().parse().unwrap_or(0),
-        });
-    }
-
-    Ok(panes)
-}
-
-/// Get visible screen text for a pane.
-pub async fn capture_pane(target: &str) -> Result<String, TmuxError> {
-    let output = tmux_cmd(&["capture-pane", "-t", target, "-p"]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
-}
-
-/// Get scrollback buffer for a pane.
-pub async fn capture_scrollback(target: &str) -> Result<String, TmuxError> {
-    // -S - means start from the beginning of history; -E - means end at current line
-    let output = tmux_cmd(&["capture-pane", "-t", target, "-p", "-S", "-", "-E", "-"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
-}
-
-/// Send literal text to a pane (no key name interpretation).
-pub async fn send_text(target: &str, text: &str) -> Result<(), TmuxError> {
-    let output = tmux_cmd(&["send-keys", "-t", target, "-l", text]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Send a key sequence to a pane (tmux key name format, e.g. "Enter", "C-c").
-pub async fn send_key(target: &str, key: &str) -> Result<(), TmuxError> {
-    let output = tmux_cmd(&["send-keys", "-t", target, key]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Create a new window and return its pane target.
-pub async fn new_window(session: Option<&str>) -> Result<String, TmuxError> {
-    let mut args = vec!["new-window", "-P", "-F",
-        "#{session_name}:#{window_index}.#{pane_index}"];
-    if let Some(s) = session {
-        args.push("-t");
-        args.push(s);
-    }
-    let output = tmux_cmd(&args).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    Ok(stdout.trim().to_string())
-}
-
-/// Kill a pane.
-pub async fn kill_pane(target: &str) -> Result<(), TmuxError> {
-    let output = tmux_cmd(&["kill-pane", "-t", target]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Resize a pane to exact dimensions.
-pub async fn resize_pane(target: &str, cols: u16, rows: u16) -> Result<(), TmuxError> {
-    let cols_str = cols.to_string();
-    let rows_str = rows.to_string();
-    let output = tmux_cmd(&[
-        "resize-pane", "-t", target,
-        "-x", &cols_str,
-        "-y", &rows_str,
-    ])
-    .output()
-    .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(TmuxError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Find a pane by its target string.
-pub async fn find_pane(target: &str) -> Result<TmuxPane, TmuxError> {
-    let panes = list_panes().await?;
-    panes
-        .into_iter()
-        .find(|p| p.target == target)
-        .ok_or_else(|| TmuxError::PaneNotFound(target.to_string()))
-}

package/crates/wrightty-bridge-wezterm/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "wrightty-bridge-wezterm"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-description = "Bridge that translates wrightty protocol calls into wezterm cli commands"
-
-[[bin]]
-name = "wrightty-bridge-wezterm"
-path = "src/main.rs"
-
-[dependencies]
-wrightty-protocol = { version = "0.1.0", path = "../wrightty-protocol" }
-
-jsonrpsee = { version = "0.24", features = ["server"] }
-tokio = { version = "1", features = ["full"] }
-clap = { version = "4", features = ["derive"] }
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-anyhow = "1"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-thiserror = "1"

package/crates/wrightty-bridge-wezterm/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod rpc;
-pub mod wezterm;

package/crates/wrightty-bridge-wezterm/src/main.rs

@@ -1,119 +0,0 @@
-use std::net::{SocketAddr, TcpListener};
-use std::process;
-use std::time::Duration;
-
-use clap::Parser;
-use jsonrpsee::server::Server;
-use tracing_subscriber::EnvFilter;
-
-use wrightty_bridge_wezterm::rpc::build_rpc_module;
-use wrightty_bridge_wezterm::wezterm;
-
-const PORT_RANGE_START: u16 = 9420;
-const PORT_RANGE_END: u16 = 9440;
-
-#[derive(Parser)]
-#[command(
-    name = "wrightty-bridge-wezterm",
-    about = "Bridge that translates wrightty protocol calls into wezterm cli commands"
-)]
-struct Cli {
-    #[arg(long, default_value = "127.0.0.1")]
-    host: String,
-
-    /// Port to listen on. If not specified, auto-selects the next available port starting at 9420.
-    #[arg(long)]
-    port: Option<u16>,
-
-    /// Interval in seconds to check if WezTerm is still running. 0 to disable.
-    #[arg(long, default_value_t = 5)]
-    watchdog_interval: u64,
-}
-
-fn find_available_port(host: &str, start: u16, end: u16) -> Option<u16> {
-    for port in start..=end {
-        if TcpListener::bind(format!("{host}:{port}")).is_ok() {
-            return Some(port);
-        }
-    }
-    None
-}
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::from_default_env()
-                .add_directive("wrightty_bridge_wezterm=info".parse()?),
-        )
-        .init();
-
-    let cli = Cli::parse();
-
-    // --- Startup health check ---
-    tracing::info!("Checking WezTerm connectivity...");
-    match wezterm::health_check().await {
-        Ok(()) => tracing::info!("WezTerm is reachable"),
-        Err(e) => {
-            eprintln!("error: Cannot connect to WezTerm: {e}");
-            eprintln!();
-            eprintln!("Make sure WezTerm is running. If using flatpak, set:");
-            eprintln!("  WEZTERM_CMD=\"flatpak run --command=wezterm org.wezfurlong.wezterm\"");
-            process::exit(1);
-        },
-    }
-
-    let port = match cli.port {
-        Some(p) => p,
-        None => find_available_port(&cli.host, PORT_RANGE_START, PORT_RANGE_END)
-            .ok_or_else(|| anyhow::anyhow!("No available port in range {PORT_RANGE_START}-{PORT_RANGE_END}"))?,
-    };
-
-    let addr: SocketAddr = format!("{}:{}", cli.host, port).parse()?;
-
-    let module = build_rpc_module()?;
-
-    let server = Server::builder().build(addr).await?;
-
-    let handle = server.start(module);
-
-    tracing::info!("wrightty-bridge-wezterm listening on ws://{addr}");
-    println!("wrightty-bridge-wezterm listening on ws://{addr}");
-
-    // --- Watchdog: periodically check WezTerm is still alive ---
-    if cli.watchdog_interval > 0 {
-        let interval = Duration::from_secs(cli.watchdog_interval);
-        let server_handle = handle.clone();
-        tokio::spawn(async move {
-            let mut consecutive_failures = 0u32;
-            loop {
-                tokio::time::sleep(interval).await;
-                match wezterm::health_check().await {
-                    Ok(()) => {
-                        if consecutive_failures > 0 {
-                            tracing::info!("WezTerm reconnected");
-                            consecutive_failures = 0;
-                        }
-                    },
-                    Err(e) => {
-                        consecutive_failures += 1;
-                        tracing::warn!(
-                            "WezTerm health check failed ({consecutive_failures}): {e}"
-                        );
-                        if consecutive_failures >= 3 {
-                            tracing::error!(
-                                "WezTerm unreachable after {consecutive_failures} checks, shutting down"
-                            );
-                            server_handle.stop().unwrap();
-                            return;
-                        }
-                    },
-                }
-            }
-        });
-    }
-
-    handle.stopped().await;
-
-    Ok(())
-}