@moejay/wrightty 0.0.0 → 0.1.1

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

@@ -1,339 +0,0 @@
-//! jsonrpsee RPC module that maps wrightty protocol methods to wezterm cli commands.
-
-use jsonrpsee::types::ErrorObjectOwned;
-use jsonrpsee::RpcModule;
-
-use wrightty_protocol::error;
-use wrightty_protocol::methods::*;
-use wrightty_protocol::types::*;
-
-use crate::wezterm;
-
-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 WezTerm bridge"))
-}
-
-/// Parse a wrightty session ID string into a WezTerm pane ID.
-fn parse_pane_id(session_id: &str) -> Result<u64, ErrorObjectOwned> {
-    session_id
-        .parse::<u64>()
-        .map_err(|_| proto_err(error::SESSION_NOT_FOUND, format!("invalid session id: {session_id}")))
-}
-
-/// Encode a list of KeyInput values into a string for `wezterm cli send-text`.
-fn encode_keys_to_string(keys: &[KeyInput]) -> String {
-    let mut out = String::new();
-    for key in keys {
-        match key {
-            KeyInput::Shorthand(s) => encode_shorthand(s, &mut out),
-            KeyInput::Structured(event) => encode_key_event(event, &mut out),
-        }
-    }
-    out
-}
-
-fn encode_shorthand(s: &str, out: &mut String) {
-    // Check for modifier combos like "Ctrl+c"
-    if let Some((modifier_str, key_str)) = s.split_once('+') {
-        match modifier_str {
-            "Ctrl" => {
-                if key_str.len() == 1 {
-                    let ch = key_str.chars().next().unwrap();
-                    // Ctrl+letter: map to control character
-                    let ctrl = (ch.to_ascii_uppercase() as u8).wrapping_sub(b'@');
-                    out.push(ctrl as char);
-                    return;
-                }
-                if let Some(s) = named_key_str(key_str) {
-                    out.push_str(s);
-                    return;
-                }
-            }
-            "Alt" => {
-                out.push('\x1b');
-                if key_str.len() == 1 {
-                    out.push_str(key_str);
-                } else if let Some(s) = named_key_str(key_str) {
-                    out.push_str(s);
-                }
-                return;
-            }
-            _ => {}
-        }
-    }
-
-    // Named keys
-    if let Some(s) = named_key_str(s) {
-        out.push_str(s);
-        return;
-    }
-
-    // Literal text
-    out.push_str(s);
-}
-
-fn encode_key_event(event: &KeyEvent, out: &mut 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));
-
-    if has_alt {
-        out.push('\x1b');
-    }
-
-    let base = match &event.key {
-        KeyType::Char => {
-            let ch = event.char.as_deref().unwrap_or("");
-            if has_ctrl && ch.len() == 1 {
-                let c = ch.chars().next().unwrap();
-                let ctrl = (c.to_ascii_uppercase() as u8).wrapping_sub(b'@');
-                out.push(ctrl as char);
-                return;
-            }
-            ch
-        }
-        KeyType::Enter => "\r",
-        KeyType::Tab => "\t",
-        KeyType::Backspace => "\x7f",
-        KeyType::Delete => "\x1b[3~",
-        KeyType::Escape => "\x1b",
-        KeyType::ArrowUp => "\x1b[A",
-        KeyType::ArrowDown => "\x1b[B",
-        KeyType::ArrowRight => "\x1b[C",
-        KeyType::ArrowLeft => "\x1b[D",
-        KeyType::Home => "\x1b[H",
-        KeyType::End => "\x1b[F",
-        KeyType::PageUp => "\x1b[5~",
-        KeyType::PageDown => "\x1b[6~",
-        KeyType::Insert => "\x1b[2~",
-        KeyType::F => {
-            let n = event.n.unwrap_or(1);
-            match n {
-                1 => "\x1bOP",
-                2 => "\x1bOQ",
-                3 => "\x1bOR",
-                4 => "\x1bOS",
-                5 => "\x1b[15~",
-                6 => "\x1b[17~",
-                7 => "\x1b[18~",
-                8 => "\x1b[19~",
-                9 => "\x1b[20~",
-                10 => "\x1b[21~",
-                11 => "\x1b[23~",
-                12 => "\x1b[24~",
-                _ => "",
-            }
-        }
-    };
-    out.push_str(base);
-}
-
-fn named_key_str(name: &str) -> Option<&'static str> {
-    match name {
-        "Enter" | "Return" => Some("\r"),
-        "Tab" => Some("\t"),
-        "Backspace" => Some("\x7f"),
-        "Delete" => Some("\x1b[3~"),
-        "Escape" | "Esc" => Some("\x1b"),
-        "ArrowUp" | "Up" => Some("\x1b[A"),
-        "ArrowDown" | "Down" => Some("\x1b[B"),
-        "ArrowRight" | "Right" => Some("\x1b[C"),
-        "ArrowLeft" | "Left" => Some("\x1b[D"),
-        "Home" => Some("\x1b[H"),
-        "End" => Some("\x1b[F"),
-        "PageUp" => Some("\x1b[5~"),
-        "PageDown" => Some("\x1b[6~"),
-        "Insert" => Some("\x1b[2~"),
-        _ => None,
-    }
-}
-
-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-wezterm".to_string(),
-                capabilities: Capabilities {
-                    screenshot: vec![ScreenshotFormat::Text],
-                    max_sessions: 256,
-                    supports_resize: false,
-                    supports_scrollback: false,
-                    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 pane_id = wezterm::spawn_pane()
-            .await
-            .map_err(|e| proto_err(error::SPAWN_FAILED, e.to_string()))?;
-
-        serde_json::to_value(SessionCreateResult {
-            session_id: pane_id.to_string(),
-        })
-        .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()?;
-        let pane_id = parse_pane_id(&p.session_id)?;
-
-        wezterm::kill_pane(pane_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 = wezterm::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.pane_id.to_string(),
-                title: p.title,
-                cwd: if p.cwd.is_empty() { None } else { Some(p.cwd) },
-                cols: p.size.cols,
-                rows: p.size.rows,
-                pid: 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_id = parse_pane_id(&p.session_id)?;
-
-        let pane = wezterm::find_pane(pane_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        let info = SessionInfo {
-            session_id: pane.pane_id.to_string(),
-            title: pane.title,
-            cwd: if pane.cwd.is_empty() {
-                None
-            } else {
-                Some(pane.cwd)
-            },
-            cols: pane.size.cols,
-            rows: pane.size.rows,
-            pid: 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()?;
-        let pane_id = parse_pane_id(&p.session_id)?;
-
-        wezterm::send_text(pane_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()?;
-        let pane_id = parse_pane_id(&p.session_id)?;
-
-        let text = encode_keys_to_string(&p.keys);
-        wezterm::send_text(pane_id, &text)
-            .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 pane_id = parse_pane_id(&p.session_id)?;
-
-        let mut text = wezterm::get_text(pane_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_id = parse_pane_id(&p.session_id)?;
-
-        let pane = wezterm::find_pane(pane_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        serde_json::to_value(TerminalGetSizeResult {
-            cols: pane.size.cols,
-            rows: pane.size.rows,
-        })
-        .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Terminal.resize (not supported) ---
-    module.register_async_method("Terminal.resize", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Terminal.resize"))
-    })?;
-
-    // --- 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-wezterm/src/wezterm.rs

@@ -1,190 +0,0 @@
-//! Functions that shell out to `wezterm cli` and parse results.
-
-use serde::Deserialize;
-use tokio::process::Command;
-
-/// A pane entry as returned by `wezterm cli list --format json`.
-#[derive(Debug, Clone, Deserialize)]
-pub struct WezTermPane {
-    pub pane_id: u64,
-    pub tab_id: u64,
-    pub window_id: u64,
-    pub workspace: String,
-    pub size: PaneSize,
-    pub title: String,
-    pub cwd: String,
-    #[serde(default)]
-    pub is_active: bool,
-    #[serde(default)]
-    pub is_zoomed: bool,
-    #[serde(default)]
-    pub cursor_x: u64,
-    #[serde(default)]
-    pub cursor_y: u64,
-    #[serde(default)]
-    pub cursor_shape: Option<String>,
-    #[serde(default)]
-    pub cursor_visibility: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct PaneSize {
-    pub rows: u16,
-    pub cols: u16,
-    #[serde(default)]
-    pub pixel_width: u32,
-    #[serde(default)]
-    pub pixel_height: u32,
-    #[serde(default)]
-    pub dpi: u32,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum WezTermError {
-    #[error("wezterm cli failed: {0}")]
-    CommandFailed(String),
-    #[error("failed to parse wezterm output: {0}")]
-    ParseError(String),
-    #[error("pane {0} not found")]
-    PaneNotFound(u64),
-    #[error("io error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-/// Build a `Command` for wezterm CLI.
-///
-/// Checks `WEZTERM_CMD` env var for the command to use.
-/// Supports flatpak: set `WEZTERM_CMD=flatpak run --command=wezterm org.wezfurlong.wezterm`
-///
-/// Falls back to just `wezterm` if not set.
-fn wezterm_cmd(cli_args: &[&str]) -> Command {
-    let cmd_str = std::env::var("WEZTERM_CMD")
-        .unwrap_or_else(|_| "wezterm".to_string());
-
-    let parts: Vec<&str> = cmd_str.split_whitespace().collect();
-    let (program, prefix_args) = parts.split_first().expect("WEZTERM_CMD must not be empty");
-
-    let mut cmd = Command::new(program);
-    for arg in prefix_args {
-        cmd.arg(arg);
-    }
-    // Always prepend "cli" subcommand.
-    cmd.arg("cli");
-    for arg in cli_args {
-        cmd.arg(arg);
-    }
-    cmd
-}
-
-/// Check if WezTerm is reachable. Returns Ok(()) if `wezterm cli list` succeeds.
-pub async fn health_check() -> Result<(), WezTermError> {
-    let output = wezterm_cmd(&["list", "--format", "json"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(format!("WezTerm not reachable: {stderr}")));
-    }
-
-    // Verify we got valid JSON with at least one pane.
-    let panes: Vec<WezTermPane> = serde_json::from_slice(&output.stdout)
-        .map_err(|e| WezTermError::ParseError(e.to_string()))?;
-
-    if panes.is_empty() {
-        return Err(WezTermError::CommandFailed("WezTerm has no panes".to_string()));
-    }
-
-    Ok(())
-}
-
-/// List all panes via `wezterm cli list --format json`.
-pub async fn list_panes() -> Result<Vec<WezTermPane>, WezTermError> {
-    let output = wezterm_cmd(&["list", "--format", "json"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(stderr.into_owned()));
-    }
-
-    let panes: Vec<WezTermPane> = serde_json::from_slice(&output.stdout)
-        .map_err(|e| WezTermError::ParseError(e.to_string()))?;
-
-    Ok(panes)
-}
-
-/// Get the text content of a pane via `wezterm cli get-text --pane-id N`.
-pub async fn get_text(pane_id: u64) -> Result<String, WezTermError> {
-    let pane_str = pane_id.to_string();
-    let output = wezterm_cmd(&["get-text", "--pane-id", &pane_str])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
-}
-
-/// Send text to a pane via `wezterm cli send-text --pane-id N --no-paste "text"`.
-pub async fn send_text(pane_id: u64, text: &str) -> Result<(), WezTermError> {
-    let pane_str = pane_id.to_string();
-    let output = wezterm_cmd(&["send-text", "--pane-id", &pane_str, "--no-paste", text])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Spawn a new pane via `wezterm cli spawn`. Returns the new pane ID.
-pub async fn spawn_pane() -> Result<u64, WezTermError> {
-    let output = wezterm_cmd(&["spawn"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(stderr.into_owned()));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let pane_id: u64 = stdout
-        .trim()
-        .parse()
-        .map_err(|e: std::num::ParseIntError| WezTermError::ParseError(e.to_string()))?;
-
-    Ok(pane_id)
-}
-
-/// Kill a pane via `wezterm cli kill-pane --pane-id N`.
-pub async fn kill_pane(pane_id: u64) -> Result<(), WezTermError> {
-    let pane_str = pane_id.to_string();
-    let output = wezterm_cmd(&["kill-pane", "--pane-id", &pane_str])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(WezTermError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Find a specific pane by ID from the list output.
-pub async fn find_pane(pane_id: u64) -> Result<WezTermPane, WezTermError> {
-    let panes = list_panes().await?;
-    panes
-        .into_iter()
-        .find(|p| p.pane_id == pane_id)
-        .ok_or(WezTermError::PaneNotFound(pane_id))
-}

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

@@ -1,27 +0,0 @@
-[package]
-name = "wrightty-bridge-zellij"
-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 zellij CLI action commands"
-
-[[bin]]
-name = "wrightty-bridge-zellij"
-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"
-tempfile = "3"

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

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

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

@@ -1,125 +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_zellij::rpc::build_rpc_module;
-use wrightty_bridge_zellij::zellij;
-
-const PORT_RANGE_START: u16 = 9481;
-const PORT_RANGE_END: u16 = 9500;
-
-#[derive(Parser)]
-#[command(
-    name = "wrightty-bridge-zellij",
-    about = "Bridge that translates wrightty protocol calls into zellij CLI action 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 9481.
-    #[arg(long)]
-    port: Option<u16>,
-
-    /// Interval in seconds to check if zellij is still running. 0 to disable.
-    #[arg(long, default_value_t = 10)]
-    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_zellij=info".parse()?),
-        )
-        .init();
-
-    let cli = Cli::parse();
-
-    // --- Startup health check ---
-    tracing::info!("Checking zellij connectivity...");
-    match zellij::health_check().await {
-        Ok(()) => {
-            let session = zellij::session_name().unwrap_or_else(|_| "unknown".to_string());
-            tracing::info!("zellij is reachable (session: {session})");
-        },
-        Err(e) => {
-            eprintln!("error: Cannot connect to zellij: {e}");
-            eprintln!();
-            eprintln!("This bridge must run from within a zellij session.");
-            eprintln!("Start zellij first:");
-            eprintln!("  zellij");
-            eprintln!("Then run this bridge from within the session.");
-            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);
-
-    let session = zellij::session_name().unwrap_or_else(|_| "unknown".to_string());
-    tracing::info!("wrightty-bridge-zellij listening on ws://{addr} (session: {session})");
-    println!("wrightty-bridge-zellij listening on ws://{addr}");
-
-    // --- Watchdog: periodically check zellij 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 zellij::health_check().await {
-                    Ok(()) => {
-                        if consecutive_failures > 0 {
-                            tracing::info!("zellij reconnected");
-                            consecutive_failures = 0;
-                        }
-                    },
-                    Err(e) => {
-                        consecutive_failures += 1;
-                        tracing::warn!(
-                            "zellij health check failed ({consecutive_failures}): {e}"
-                        );
-                        if consecutive_failures >= 3 {
-                            tracing::error!(
-                                "zellij unreachable after {consecutive_failures} checks, shutting down"
-                            );
-                            server_handle.stop().unwrap();
-                            return;
-                        }
-                    },
-                }
-            }
-        });
-    }
-
-    handle.stopped().await;
-
-    Ok(())
-}