@moejay/wrightty 0.0.0 → 0.1.0

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

@@ -1,124 +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_kitty::kitty;
-use wrightty_bridge_kitty::rpc::build_rpc_module;
-
-const PORT_RANGE_START: u16 = 9461;
-const PORT_RANGE_END: u16 = 9480;
-
-#[derive(Parser)]
-#[command(
-    name = "wrightty-bridge-kitty",
-    about = "Bridge that translates wrightty protocol calls into kitty remote control 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 9461.
-    #[arg(long)]
-    port: Option<u16>,
-
-    /// Interval in seconds to check if kitty 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_kitty=info".parse()?),
-        )
-        .init();
-
-    let cli = Cli::parse();
-
-    // --- Startup health check ---
-    tracing::info!("Checking kitty connectivity...");
-    match kitty::health_check().await {
-        Ok(()) => tracing::info!("kitty is reachable"),
-        Err(e) => {
-            eprintln!("error: Cannot connect to kitty: {e}");
-            eprintln!();
-            eprintln!("Make sure kitty is running with remote control enabled.");
-            eprintln!("Add to kitty.conf:");
-            eprintln!("  allow_remote_control yes");
-            eprintln!("Or launch kitty with:");
-            eprintln!("  kitty --listen-on unix:/tmp/kitty.sock");
-            eprintln!("And set:");
-            eprintln!("  KITTY_LISTEN_ON=unix:/tmp/kitty.sock");
-            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-kitty listening on ws://{addr}");
-    println!("wrightty-bridge-kitty listening on ws://{addr}");
-
-    // --- Watchdog: periodically check kitty 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 kitty::health_check().await {
-                    Ok(()) => {
-                        if consecutive_failures > 0 {
-                            tracing::info!("kitty reconnected");
-                            consecutive_failures = 0;
-                        }
-                    },
-                    Err(e) => {
-                        consecutive_failures += 1;
-                        tracing::warn!(
-                            "kitty health check failed ({consecutive_failures}): {e}"
-                        );
-                        if consecutive_failures >= 3 {
-                            tracing::error!(
-                                "kitty unreachable after {consecutive_failures} checks, shutting down"
-                            );
-                            server_handle.stop().unwrap();
-                            return;
-                        }
-                    },
-                }
-            }
-        });
-    }
-
-    handle.stopped().await;
-
-    Ok(())
-}

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

@@ -1,304 +0,0 @@
-//! jsonrpsee RPC module that maps wrightty protocol methods to kitty remote control commands.
-
-use jsonrpsee::types::ErrorObjectOwned;
-use jsonrpsee::RpcModule;
-
-use wrightty_protocol::error;
-use wrightty_protocol::methods::*;
-use wrightty_protocol::types::*;
-
-use crate::kitty;
-
-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 kitty bridge"))
-}
-
-/// Parse a session ID string into a kitty window ID.
-fn parse_window_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}")))
-}
-
-/// Convert a wrightty KeyInput to a kitty key name string.
-///
-/// kitty `send-key` uses its own key naming convention:
-/// - Modifiers: `ctrl+c`, `alt+x`, `ctrl+shift+t`
-/// - Named keys: `enter`, `tab`, `backspace`, `delete`, `escape`
-/// - Arrows: `up`, `down`, `left`, `right`
-/// - Function keys: `f1`..`f12`
-fn encode_key_to_kitty(key: &KeyInput) -> String {
-    match key {
-        KeyInput::Shorthand(s) => shorthand_to_kitty(s),
-        KeyInput::Structured(event) => key_event_to_kitty(event),
-    }
-}
-
-fn shorthand_to_kitty(s: &str) -> String {
-    if let Some((modifier, key)) = s.split_once('+') {
-        let mod_lower = modifier.to_lowercase();
-        return format!("{}+{}", mod_lower, key.to_lowercase());
-    }
-
-    match s {
-        "Enter" | "Return" => "enter".to_string(),
-        "Tab" => "tab".to_string(),
-        "Backspace" => "backspace".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" => "page_up".to_string(),
-        "PageDown" => "page_down".to_string(),
-        "Insert" => "insert".to_string(),
-        _ => s.to_lowercase(),
-    }
-}
-
-fn key_event_to_kitty(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 has_shift = event.modifiers.iter().any(|m| matches!(m, Modifier::Shift));
-
-    let base = match &event.key {
-        KeyType::Char => event.char.as_deref().unwrap_or("").to_lowercase(),
-        KeyType::Enter => "enter".to_string(),
-        KeyType::Tab => "tab".to_string(),
-        KeyType::Backspace => "backspace".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 => "page_up".to_string(),
-        KeyType::PageDown => "page_down".to_string(),
-        KeyType::Insert => "insert".to_string(),
-        KeyType::F => format!("f{}", event.n.unwrap_or(1)),
-    };
-
-    let mut modifiers = Vec::new();
-    if has_ctrl { modifiers.push("ctrl"); }
-    if has_alt { modifiers.push("alt"); }
-    if has_shift { modifiers.push("shift"); }
-
-    if modifiers.is_empty() {
-        base
-    } else {
-        format!("{}+{base}", modifiers.join("+"))
-    }
-}
-
-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-kitty".to_string(),
-                capabilities: Capabilities {
-                    screenshot: vec![ScreenshotFormat::Text],
-                    max_sessions: 256,
-                    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 window_id = kitty::launch_window()
-            .await
-            .map_err(|e| proto_err(error::SPAWN_FAILED, e.to_string()))?;
-
-        serde_json::to_value(SessionCreateResult {
-            session_id: window_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 window_id = parse_window_id(&p.session_id)?;
-
-        kitty::close_window(window_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 windows = kitty::list_windows()
-            .await
-            .map_err(|e| proto_err(-32603, e.to_string()))?;
-
-        let sessions: Vec<SessionInfo> = windows
-            .into_iter()
-            .map(|w| SessionInfo {
-                session_id: w.id.to_string(),
-                title: w.title,
-                cwd: w.cwd,
-                cols: w.columns,
-                rows: w.lines,
-                pid: w.pid,
-                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 window_id = parse_window_id(&p.session_id)?;
-
-        let w = kitty::find_window(window_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        let info = SessionInfo {
-            session_id: w.id.to_string(),
-            title: w.title,
-            cwd: w.cwd,
-            cols: w.columns,
-            rows: w.lines,
-            pid: w.pid,
-            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 window_id = parse_window_id(&p.session_id)?;
-
-        kitty::send_text(window_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 window_id = parse_window_id(&p.session_id)?;
-
-        for key in &p.keys {
-            // Plain single characters go via send-text; everything else via send-key
-            let is_literal_char = matches!(key, KeyInput::Shorthand(s) if s.len() == 1 && !s.contains('+'));
-            if is_literal_char {
-                let text = match key {
-                    KeyInput::Shorthand(s) => s.clone(),
-                    _ => unreachable!(),
-                };
-                kitty::send_text(window_id, &text)
-                    .await
-                    .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-            } else {
-                let kitty_key = encode_key_to_kitty(key);
-                kitty::send_key(window_id, &kitty_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 window_id = parse_window_id(&p.session_id)?;
-
-        let mut text = kitty::get_text(window_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 window_id = parse_window_id(&p.session_id)?;
-
-        let w = kitty::find_window(window_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        serde_json::to_value(TerminalGetSizeResult {
-            cols: w.columns,
-            rows: w.lines,
-        })
-        .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()?;
-        let window_id = parse_window_id(&p.session_id)?;
-
-        kitty::resize_window(window_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/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "wrightty-bridge-tmux"
-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 tmux CLI commands"
-
-[[bin]]
-name = "wrightty-bridge-tmux"
-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-tmux/src/lib.rs

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

package/crates/wrightty-bridge-tmux/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_tmux::rpc::build_rpc_module;
-use wrightty_bridge_tmux::tmux;
-
-const PORT_RANGE_START: u16 = 9441;
-const PORT_RANGE_END: u16 = 9460;
-
-#[derive(Parser)]
-#[command(
-    name = "wrightty-bridge-tmux",
-    about = "Bridge that translates wrightty protocol calls into tmux 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 9441.
-    #[arg(long)]
-    port: Option<u16>,
-
-    /// Interval in seconds to check if tmux 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_tmux=info".parse()?),
-        )
-        .init();
-
-    let cli = Cli::parse();
-
-    // --- Startup health check ---
-    tracing::info!("Checking tmux connectivity...");
-    match tmux::health_check().await {
-        Ok(()) => tracing::info!("tmux is reachable"),
-        Err(e) => {
-            eprintln!("error: Cannot connect to tmux: {e}");
-            eprintln!();
-            eprintln!("Make sure a tmux server is running. Start one with:");
-            eprintln!("  tmux new-session -d -s main");
-            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-tmux listening on ws://{addr}");
-    println!("wrightty-bridge-tmux listening on ws://{addr}");
-
-    // --- Watchdog: periodically check tmux 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 tmux::health_check().await {
-                    Ok(()) => {
-                        if consecutive_failures > 0 {
-                            tracing::info!("tmux reconnected");
-                            consecutive_failures = 0;
-                        }
-                    },
-                    Err(e) => {
-                        consecutive_failures += 1;
-                        tracing::warn!(
-                            "tmux health check failed ({consecutive_failures}): {e}"
-                        );
-                        if consecutive_failures >= 3 {
-                            tracing::error!(
-                                "tmux unreachable after {consecutive_failures} checks, shutting down"
-                            );
-                            server_handle.stop().unwrap();
-                            return;
-                        }
-                    },
-                }
-            }
-        });
-    }
-
-    handle.stopped().await;
-
-    Ok(())
-}