@moejay/wrightty 0.0.0 → 0.1.0

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

@@ -1,422 +0,0 @@
-//! Ghostty IPC client.
-//!
-//! Ghostty exposes a Unix domain socket for inter-process communication.
-//! The socket path can be configured via the `GHOSTTY_SOCKET` environment variable,
-//! defaulting to `$XDG_RUNTIME_DIR/ghostty/sock` on Linux and
-//! `$TMPDIR/ghostty-<uid>.sock` on macOS.
-//!
-//! Messages are exchanged as newline-delimited JSON (one JSON object per line).
-//! Requests use `{"type":"<command>", ...fields}` and responses mirror the
-//! same structure with a `"result"` field.
-//!
-//! Input (text / key injection) is delegated to `xdotool` on Linux (X11) or
-//! `osascript` on macOS because Ghostty does not yet expose a send-text IPC
-//! call.  Set `GHOSTTY_INPUT_BACKEND=xdotool|osascript|none` to override.
-
-use std::env;
-
-use serde::{Deserialize, Serialize};
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use tokio::net::UnixStream;
-use tokio::process::Command;
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-/// A Ghostty window as returned by the `list_windows` IPC call.
-#[derive(Debug, Clone, Deserialize)]
-pub struct GhosttyWindow {
-    pub id: u64,
-    pub title: String,
-    pub is_focused: bool,
-    pub cols: u16,
-    pub rows: u16,
-    #[serde(default)]
-    pub pid: Option<u32>,
-    #[serde(default)]
-    pub cwd: Option<String>,
-}
-
-// ---------------------------------------------------------------------------
-// Error type
-// ---------------------------------------------------------------------------
-
-#[derive(Debug, thiserror::Error)]
-pub enum GhosttyError {
-    #[error("ghostty socket not found at {0}; is Ghostty running?")]
-    SocketNotFound(String),
-    #[error("ghostty IPC call failed: {0}")]
-    IpcFailed(String),
-    #[error("failed to parse ghostty response: {0}")]
-    ParseError(String),
-    #[error("window {0} not found")]
-    WindowNotFound(u64),
-    #[error("input backend error: {0}")]
-    InputBackend(String),
-    #[error("io error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-// ---------------------------------------------------------------------------
-// Socket helpers
-// ---------------------------------------------------------------------------
-
-fn socket_path() -> String {
-    if let Ok(p) = env::var("GHOSTTY_SOCKET") {
-        return p;
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        let uid = unsafe { libc::getuid() };
-        let tmp = env::var("TMPDIR").unwrap_or_else(|_| "/tmp".to_string());
-        return format!("{tmp}/ghostty-{uid}.sock");
-    }
-
-    // Linux default: $XDG_RUNTIME_DIR/ghostty/sock
-    let runtime_dir = env::var("XDG_RUNTIME_DIR")
-        .unwrap_or_else(|_| format!("/run/user/{}", unsafe { libc::getuid() }));
-    format!("{runtime_dir}/ghostty/sock")
-}
-
-/// Open a connection to the Ghostty IPC socket.
-async fn connect() -> Result<UnixStream, GhosttyError> {
-    let path = socket_path();
-    UnixStream::connect(&path)
-        .await
-        .map_err(|_| GhosttyError::SocketNotFound(path))
-}
-
-// ---------------------------------------------------------------------------
-// IPC request / response
-// ---------------------------------------------------------------------------
-
-#[derive(Serialize)]
-struct IpcRequest<'a, T: Serialize> {
-    #[serde(rename = "type")]
-    kind: &'a str,
-    #[serde(flatten)]
-    payload: T,
-}
-
-#[derive(Deserialize, Debug)]
-struct IpcResponse {
-    #[serde(default)]
-    error: Option<String>,
-    #[serde(flatten)]
-    fields: serde_json::Value,
-}
-
-/// Send one IPC request and read the response line.
-async fn ipc_call<T: Serialize>(
-    kind: &str,
-    payload: T,
-) -> Result<serde_json::Value, GhosttyError> {
-    let mut stream = connect().await?;
-
-    let req = IpcRequest { kind, payload };
-    let mut line = serde_json::to_string(&req)
-        .map_err(|e| GhosttyError::ParseError(e.to_string()))?;
-    line.push('\n');
-
-    stream
-        .write_all(line.as_bytes())
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    let mut reader = BufReader::new(stream);
-    let mut resp_line = String::new();
-    reader
-        .read_line(&mut resp_line)
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    let resp: IpcResponse = serde_json::from_str(resp_line.trim())
-        .map_err(|e| GhosttyError::ParseError(format!("{e}: {resp_line}")))?;
-
-    if let Some(err) = resp.error {
-        return Err(GhosttyError::IpcFailed(err));
-    }
-
-    Ok(resp.fields)
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/// Check that Ghostty is reachable by listing windows.
-pub async fn health_check() -> Result<(), GhosttyError> {
-    list_windows().await?;
-    Ok(())
-}
-
-/// List all Ghostty windows.
-pub async fn list_windows() -> Result<Vec<GhosttyWindow>, GhosttyError> {
-    #[derive(Serialize)]
-    struct Empty {}
-    let value = ipc_call("list_windows", Empty {}).await?;
-
-    let windows: Vec<GhosttyWindow> = serde_json::from_value(
-        value
-            .get("windows")
-            .cloned()
-            .unwrap_or(serde_json::Value::Array(vec![])),
-    )
-    .map_err(|e| GhosttyError::ParseError(e.to_string()))?;
-
-    Ok(windows)
-}
-
-/// Find a window by its numeric ID.
-pub async fn find_window(window_id: u64) -> Result<GhosttyWindow, GhosttyError> {
-    let windows = list_windows().await?;
-    windows
-        .into_iter()
-        .find(|w| w.id == window_id)
-        .ok_or(GhosttyError::WindowNotFound(window_id))
-}
-
-/// Open a new Ghostty window and return its ID.
-pub async fn new_window() -> Result<u64, GhosttyError> {
-    #[derive(Serialize)]
-    struct NewWindowReq {
-        action: &'static str,
-    }
-    let value = ipc_call("action", NewWindowReq { action: "new_window" }).await?;
-
-    let window_id = value
-        .get("window_id")
-        .and_then(|v| v.as_u64())
-        .ok_or_else(|| GhosttyError::ParseError("missing window_id in new_window response".into()))?;
-
-    Ok(window_id)
-}
-
-/// Close a Ghostty window.
-pub async fn close_window(window_id: u64) -> Result<(), GhosttyError> {
-    #[derive(Serialize)]
-    struct CloseReq {
-        action: &'static str,
-        window_id: u64,
-    }
-    ipc_call(
-        "action",
-        CloseReq {
-            action: "close_window",
-            window_id,
-        },
-    )
-    .await?;
-    Ok(())
-}
-
-/// Focus a Ghostty window (bring it to front).
-pub async fn focus_window(window_id: u64) -> Result<(), GhosttyError> {
-    #[derive(Serialize)]
-    struct FocusReq {
-        action: &'static str,
-        window_id: u64,
-    }
-    ipc_call(
-        "action",
-        FocusReq {
-            action: "focus_window",
-            window_id,
-        },
-    )
-    .await?;
-    Ok(())
-}
-
-// ---------------------------------------------------------------------------
-// Input injection
-// ---------------------------------------------------------------------------
-
-/// The backend to use for injecting keystrokes / text.
-#[derive(Debug, Clone, PartialEq)]
-pub enum InputBackend {
-    /// `xdotool type` / `xdotool key` (Linux X11)
-    Xdotool,
-    /// `osascript` System Events keystroke (macOS)
-    Osascript,
-    /// No-op (useful for testing or headless envs)
-    None,
-}
-
-impl InputBackend {
-    pub fn detect() -> Self {
-        if let Ok(val) = env::var("GHOSTTY_INPUT_BACKEND") {
-            return match val.to_lowercase().as_str() {
-                "xdotool" => Self::Xdotool,
-                "osascript" => Self::Osascript,
-                "none" => Self::None,
-                _ => Self::detect_auto(),
-            };
-        }
-        Self::detect_auto()
-    }
-
-    fn detect_auto() -> Self {
-        #[cfg(target_os = "macos")]
-        return Self::Osascript;
-
-        // Linux: probe xdotool
-        if std::process::Command::new("xdotool")
-            .arg("version")
-            .output()
-            .map(|o| o.status.success())
-            .unwrap_or(false)
-        {
-            return Self::Xdotool;
-        }
-
-        Self::None
-    }
-}
-
-/// Send literal text to the focused Ghostty window.
-///
-/// The caller is responsible for focusing the target window first.
-pub async fn send_text(window_id: u64, text: &str) -> Result<(), GhosttyError> {
-    focus_window(window_id).await?;
-    // Small yield to let the WM process the focus event before we inject
-    tokio::time::sleep(std::time::Duration::from_millis(30)).await;
-
-    match InputBackend::detect() {
-        InputBackend::Xdotool => xdotool_type(text).await,
-        InputBackend::Osascript => osascript_keystroke(text).await,
-        InputBackend::None => Err(GhosttyError::InputBackend(
-            "no input backend available; install xdotool or set GHOSTTY_INPUT_BACKEND".into(),
-        )),
-    }
-}
-
-/// Send a key name (e.g. `"ctrl+c"`, `"Return"`) to the focused window.
-pub async fn send_key(window_id: u64, key: &str) -> Result<(), GhosttyError> {
-    focus_window(window_id).await?;
-    tokio::time::sleep(std::time::Duration::from_millis(30)).await;
-
-    match InputBackend::detect() {
-        InputBackend::Xdotool => xdotool_key(key).await,
-        InputBackend::Osascript => osascript_key(key).await,
-        InputBackend::None => Err(GhosttyError::InputBackend(
-            "no input backend available; install xdotool or set GHOSTTY_INPUT_BACKEND".into(),
-        )),
-    }
-}
-
-// ---------------------------------------------------------------------------
-// xdotool helpers
-// ---------------------------------------------------------------------------
-
-async fn xdotool_type(text: &str) -> Result<(), GhosttyError> {
-    let output = Command::new("xdotool")
-        .args(["type", "--clearmodifiers", "--delay", "0", "--", text])
-        .output()
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(GhosttyError::InputBackend(format!(
-            "xdotool type failed: {stderr}"
-        )));
-    }
-    Ok(())
-}
-
-async fn xdotool_key(key: &str) -> Result<(), GhosttyError> {
-    let output = Command::new("xdotool")
-        .args(["key", "--clearmodifiers", "--", key])
-        .output()
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(GhosttyError::InputBackend(format!(
-            "xdotool key failed: {stderr}"
-        )));
-    }
-    Ok(())
-}
-
-// ---------------------------------------------------------------------------
-// osascript helpers (macOS)
-// ---------------------------------------------------------------------------
-
-async fn osascript_keystroke(text: &str) -> Result<(), GhosttyError> {
-    // Escape the string for AppleScript
-    let escaped = text.replace('\\', "\\\\").replace('"', "\\\"");
-    let script = format!(
-        r#"tell application "System Events" to keystroke "{escaped}""#
-    );
-    let output = Command::new("osascript")
-        .args(["-e", &script])
-        .output()
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(GhosttyError::InputBackend(format!(
-            "osascript keystroke failed: {stderr}"
-        )));
-    }
-    Ok(())
-}
-
-async fn osascript_key(key: &str) -> Result<(), GhosttyError> {
-    // Map wrightty key names to osascript key code names
-    let key_code = map_key_to_applescript(key);
-    let script = format!(
-        r#"tell application "System Events" to key code {key_code}"#
-    );
-    let output = Command::new("osascript")
-        .args(["-e", &script])
-        .output()
-        .await
-        .map_err(GhosttyError::Io)?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        return Err(GhosttyError::InputBackend(format!(
-            "osascript key code failed: {stderr}"
-        )));
-    }
-    Ok(())
-}
-
-/// Map a key name (xdotool-style) to an AppleScript key code number.
-fn map_key_to_applescript(key: &str) -> &'static str {
-    match key {
-        "Return" | "return" | "KP_Return" => "36",
-        "Tab" | "tab" => "48",
-        "BackSpace" | "backspace" => "51",
-        "Delete" | "delete" => "117",
-        "Escape" | "escape" => "53",
-        "Up" | "KP_Up" => "126",
-        "Down" | "KP_Down" => "125",
-        "Left" | "KP_Left" => "123",
-        "Right" | "KP_Right" => "124",
-        "Home" => "115",
-        "End" => "119",
-        "Page_Up" => "116",
-        "Page_Down" => "121",
-        "F1" => "122",
-        "F2" => "120",
-        "F3" => "99",
-        "F4" => "118",
-        "F5" => "96",
-        "F6" => "97",
-        "F7" => "98",
-        "F8" => "100",
-        "F9" => "101",
-        "F10" => "109",
-        "F11" => "103",
-        "F12" => "111",
-        _ => "36", // fall back to Return
-    }
-}

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

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

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

@@ -1,146 +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_ghostty::ghostty;
-use wrightty_bridge_ghostty::rpc::build_rpc_module;
-
-const PORT_RANGE_START: u16 = 9501;
-const PORT_RANGE_END: u16 = 9520;
-
-#[derive(Parser)]
-#[command(
-    name = "wrightty-bridge-ghostty",
-    about = "Bridge that translates wrightty protocol calls into Ghostty IPC commands",
-    long_about = "\
-Connects to a running Ghostty terminal emulator via its Unix IPC socket and \
-exposes the wrightty WebSocket JSON-RPC 2.0 interface.\n\n\
-REQUIREMENTS:\n\
-  - Ghostty must be running (the IPC socket is created on startup).\n\
-  - For text/key injection, xdotool must be installed on Linux (X11) or\n\
-    Accessibility must be enabled on macOS.\n\n\
-ENVIRONMENT:\n\
-  GHOSTTY_SOCKET          Override the IPC socket path.\n\
-  GHOSTTY_INPUT_BACKEND   Force input backend: xdotool | osascript | none."
-)]
-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 Ghostty 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_ghostty=info".parse()?),
-        )
-        .init();
-
-    let cli = Cli::parse();
-
-    // --- Startup health check ---
-    tracing::info!("Checking Ghostty connectivity...");
-    match ghostty::health_check().await {
-        Ok(()) => tracing::info!("Ghostty IPC socket is reachable"),
-        Err(e) => {
-            eprintln!("error: Cannot connect to Ghostty: {e}");
-            eprintln!();
-            eprintln!("Make sure Ghostty is running. The bridge connects to:");
-            eprintln!("  $XDG_RUNTIME_DIR/ghostty/sock  (Linux)");
-            eprintln!("  $TMPDIR/ghostty-<uid>.sock      (macOS)");
-            eprintln!("Override with: GHOSTTY_SOCKET=/path/to/sock");
-            process::exit(1);
-        }
-    }
-
-    // Report which input backend will be used
-    let backend = ghostty::InputBackend::detect();
-    if backend == ghostty::InputBackend::None {
-        tracing::warn!(
-            "No input backend detected. \
-             Install xdotool (Linux/X11) or enable Accessibility (macOS) for \
-             Input.sendText / Input.sendKeys support."
-        );
-    } else {
-        tracing::info!("Input backend: {:?}", backend);
-    }
-
-    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-ghostty listening on ws://{addr}");
-    println!("wrightty-bridge-ghostty listening on ws://{addr}");
-
-    // --- Watchdog: periodically check Ghostty is still running ---
-    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 ghostty::health_check().await {
-                    Ok(()) => {
-                        if consecutive_failures > 0 {
-                            tracing::info!("Ghostty reconnected");
-                            consecutive_failures = 0;
-                        }
-                    }
-                    Err(e) => {
-                        consecutive_failures += 1;
-                        tracing::warn!(
-                            "Ghostty health check failed ({consecutive_failures}): {e}"
-                        );
-                        if consecutive_failures >= 3 {
-                            tracing::error!(
-                                "Ghostty unreachable after {consecutive_failures} checks, shutting down"
-                            );
-                            server_handle.stop().unwrap();
-                            return;
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    handle.stopped().await;
-
-    Ok(())
-}