@moejay/wrightty 0.0.0 → 0.1.1

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

@@ -1,307 +0,0 @@
-//! jsonrpsee RPC module that maps wrightty protocol methods to Ghostty IPC.
-
-use jsonrpsee::types::ErrorObjectOwned;
-use jsonrpsee::RpcModule;
-
-use wrightty_protocol::error;
-use wrightty_protocol::methods::*;
-use wrightty_protocol::types::*;
-
-use crate::ghostty;
-
-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 ghostty bridge"),
-    )
-}
-
-/// Parse a session ID string into a Ghostty window ID (u64).
-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 an xdotool-compatible key name.
-///
-/// xdotool key names reference:
-/// <https://gitlab.com/cunidev/gestures/-/wikis/xdotool-list-of-key-codes>
-fn encode_key_to_xdotool(key: &KeyInput) -> String {
-    match key {
-        KeyInput::Shorthand(s) => shorthand_to_xdotool(s),
-        KeyInput::Structured(event) => key_event_to_xdotool(event),
-    }
-}
-
-fn shorthand_to_xdotool(s: &str) -> String {
-    // Handle modifier combos like "ctrl+c", "alt+shift+f"
-    if s.contains('+') {
-        // xdotool uses "ctrl+c" style, just lowercase it
-        return s
-            .split('+')
-            .map(normalize_key_name)
-            .collect::<Vec<_>>()
-            .join("+");
-    }
-    normalize_key_name(s)
-}
-
-fn normalize_key_name(name: &str) -> String {
-    match name {
-        "Enter" | "Return" => "Return".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(),
-        "ctrl" | "Ctrl" | "control" | "Control" => "ctrl".to_string(),
-        "alt" | "Alt" => "alt".to_string(),
-        "shift" | "Shift" => "shift".to_string(),
-        "super" | "Super" | "meta" | "Meta" => "super".to_string(),
-        _ => name.to_lowercase(),
-    }
-}
-
-fn key_event_to_xdotool(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()
-            .map(normalize_key_name)
-            .unwrap_or_default(),
-        KeyType::Enter => "Return".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 parts: Vec<&str> = vec![];
-    if has_ctrl {
-        parts.push("ctrl");
-    }
-    if has_alt {
-        parts.push("alt");
-    }
-    if has_shift {
-        parts.push("shift");
-    }
-
-    if parts.is_empty() {
-        base
-    } else {
-        format!("{}+{base}", parts.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-ghostty".to_string(),
-                capabilities: Capabilities {
-                    screenshot: vec![],
-                    max_sessions: 128,
-                    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 window_id = ghostty::new_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)?;
-
-        ghostty::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 = ghostty::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.cols,
-                rows: w.rows,
-                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 = ghostty::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.cols,
-            rows: w.rows,
-            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)?;
-
-        ghostty::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 {
-            // Single literal characters go via send_text for better compatibility
-            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!(),
-                };
-                ghostty::send_text(window_id, &text)
-                    .await
-                    .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-            } else {
-                let key_str = encode_key_to_xdotool(key);
-                ghostty::send_key(window_id, &key_str)
-                    .await
-                    .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-            }
-        }
-
-        Ok::<_, ErrorObjectOwned>(serde_json::json!({}))
-    })?;
-
-    // --- 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 = ghostty::find_window(window_id)
-            .await
-            .map_err(|e| proto_err(error::SESSION_NOT_FOUND, e.to_string()))?;
-
-        serde_json::to_value(TerminalGetSizeResult {
-            cols: w.cols,
-            rows: w.rows,
-        })
-        .map_err(|e| proto_err(-32603, e.to_string()))
-    })?;
-
-    // --- Unsupported methods ---
-
-    module.register_async_method("Screen.getText", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported(
-            "Screen.getText — Ghostty does not expose a screen-dump IPC; \
-             use wrightty-server with ghostty-native support instead",
-        ))
-    })?;
-
-    module.register_async_method("Screen.getContents", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Screen.getContents"))
-    })?;
-
-    module.register_async_method("Screen.screenshot", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Screen.screenshot"))
-    })?;
-
-    module.register_async_method("Terminal.resize", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported(
-            "Terminal.resize — Ghostty window sizing is not exposed via IPC",
-        ))
-    })?;
-
-    module.register_async_method("Input.sendMouse", |_params, _state, _| async move {
-        Err::<serde_json::Value, _>(not_supported("Input.sendMouse"))
-    })?;
-
-    Ok(module)
-}

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

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

@@ -1,269 +0,0 @@
-//! Functions that shell out to `kitty @` remote control commands.
-//!
-//! Requires kitty to be started with `allow_remote_control yes` in kitty.conf,
-//! or launched with `--listen-on unix:/path/to/socket`.
-//!
-//! Set `KITTY_LISTEN_ON` to the socket path if kitty is not using the default.
-
-use serde::Deserialize;
-use tokio::process::Command;
-
-/// A kitty window as returned by `kitty @ ls`.
-#[derive(Debug, Clone, Deserialize)]
-pub struct KittyWindow {
-    pub id: u64,
-    pub title: String,
-    pub is_focused: bool,
-    pub columns: u16,
-    pub lines: u16,
-    #[serde(default)]
-    pub pid: Option<u32>,
-    #[serde(default)]
-    pub cwd: Option<String>,
-}
-
-/// Intermediate structures for parsing `kitty @ ls` JSON output.
-#[derive(Debug, Deserialize)]
-struct KittyOsWindow {
-    tabs: Vec<KittyTab>,
-}
-
-#[derive(Debug, Deserialize)]
-struct KittyTab {
-    windows: Vec<KittyWindowRaw>,
-}
-
-#[derive(Debug, Deserialize)]
-struct KittyWindowRaw {
-    id: u64,
-    title: String,
-    is_focused: bool,
-    columns: u16,
-    lines: u16,
-    #[serde(default)]
-    pid: Option<u32>,
-    foreground_processes: Vec<KittyProcess>,
-}
-
-#[derive(Debug, Deserialize)]
-struct KittyProcess {
-    pid: u32,
-    cwd: String,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum KittyError {
-    #[error("kitty command failed: {0}")]
-    CommandFailed(String),
-    #[error("failed to parse kitty output: {0}")]
-    ParseError(String),
-    #[error("window {0} not found")]
-    WindowNotFound(u64),
-    #[error("io error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-fn kitty_cmd(args: &[&str]) -> Command {
-    let cmd_str = std::env::var("KITTY_CMD").unwrap_or_else(|_| "kitty".to_string());
-    let parts: Vec<&str> = cmd_str.split_whitespace().collect();
-    let (program, prefix_args) = parts.split_first().expect("KITTY_CMD must not be empty");
-
-    let mut cmd = Command::new(program);
-    for arg in prefix_args {
-        cmd.arg(arg);
-    }
-    // Always prepend "@" subcommand for remote control
-    cmd.arg("@");
-
-    // If KITTY_LISTEN_ON is set, pass it as the --to argument
-    if let Ok(socket) = std::env::var("KITTY_LISTEN_ON") {
-        cmd.arg("--to");
-        cmd.arg(socket);
-    }
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-    cmd
-}
-
-/// Check if kitty is reachable via remote control.
-pub async fn health_check() -> Result<(), KittyError> {
-    let output = kitty_cmd(&["ls"]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(format!("kitty not reachable: {stderr}")));
-    }
-
-    let os_windows: Vec<KittyOsWindow> = serde_json::from_slice(&output.stdout)
-        .map_err(|e| KittyError::ParseError(e.to_string()))?;
-
-    let total_windows: usize = os_windows
-        .iter()
-        .flat_map(|ow| ow.tabs.iter())
-        .map(|t| t.windows.len())
-        .sum();
-
-    if total_windows == 0 {
-        return Err(KittyError::CommandFailed("kitty has no windows".to_string()));
-    }
-
-    Ok(())
-}
-
-/// List all windows across all OS windows and tabs.
-pub async fn list_windows() -> Result<Vec<KittyWindow>, KittyError> {
-    let output = kitty_cmd(&["ls"]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    let os_windows: Vec<KittyOsWindow> = serde_json::from_slice(&output.stdout)
-        .map_err(|e| KittyError::ParseError(e.to_string()))?;
-
-    let windows: Vec<KittyWindow> = os_windows
-        .into_iter()
-        .flat_map(|ow| ow.tabs)
-        .flat_map(|t| t.windows)
-        .map(|w| {
-            let cwd = w.foreground_processes.first().map(|p| p.cwd.clone());
-            let pid = w.pid.or_else(|| w.foreground_processes.first().map(|p| p.pid));
-            KittyWindow {
-                id: w.id,
-                title: w.title,
-                is_focused: w.is_focused,
-                columns: w.columns,
-                lines: w.lines,
-                pid,
-                cwd,
-            }
-        })
-        .collect();
-
-    Ok(windows)
-}
-
-/// Get screen text for a window via `kitty @ get-text --match id:<id> --extent screen`.
-pub async fn get_text(window_id: u64) -> Result<String, KittyError> {
-    let match_str = format!("id:{window_id}");
-    let output = kitty_cmd(&["get-text", "--match", &match_str, "--extent", "screen"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
-}
-
-/// Get scrollback text for a window.
-pub async fn get_scrollback(window_id: u64) -> Result<String, KittyError> {
-    let match_str = format!("id:{window_id}");
-    let output = kitty_cmd(&["get-text", "--match", &match_str, "--extent", "all"])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
-}
-
-/// Send literal text to a window via `kitty @ send-text`.
-pub async fn send_text(window_id: u64, text: &str) -> Result<(), KittyError> {
-    let match_str = format!("id:{window_id}");
-    let output = kitty_cmd(&["send-text", "--match", &match_str, "--", text])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Send a key sequence to a window via `kitty @ send-key`.
-pub async fn send_key(window_id: u64, key: &str) -> Result<(), KittyError> {
-    let match_str = format!("id:{window_id}");
-    let output = kitty_cmd(&["send-key", "--match", &match_str, "--", key])
-        .output()
-        .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Launch a new kitty window. Returns the new window ID.
-pub async fn launch_window() -> Result<u64, KittyError> {
-    let output = kitty_cmd(&["launch", "--type=window"]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let window_id: u64 = stdout
-        .trim()
-        .parse()
-        .map_err(|e: std::num::ParseIntError| KittyError::ParseError(e.to_string()))?;
-
-    Ok(window_id)
-}
-
-/// Close a kitty window.
-pub async fn close_window(window_id: u64) -> Result<(), KittyError> {
-    let match_str = format!("id:{window_id}");
-    let output = kitty_cmd(&["close-window", "--match", &match_str]).output().await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Resize a kitty window.
-pub async fn resize_window(window_id: u64, cols: u16, rows: u16) -> Result<(), KittyError> {
-    let match_str = format!("id:{window_id}");
-    let cols_str = cols.to_string();
-    let rows_str = rows.to_string();
-    let output = kitty_cmd(&[
-        "resize-window",
-        "--match", &match_str,
-        "--width", &cols_str,
-        "--height", &rows_str,
-    ])
-    .output()
-    .await?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(KittyError::CommandFailed(stderr.into_owned()));
-    }
-
-    Ok(())
-}
-
-/// Find a window by ID.
-pub async fn find_window(window_id: u64) -> Result<KittyWindow, KittyError> {
-    let windows = list_windows().await?;
-    windows
-        .into_iter()
-        .find(|w| w.id == window_id)
-        .ok_or(KittyError::WindowNotFound(window_id))
-}

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

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