@moejay/wrightty 0.0.0

package/crates/wrightty-client/src/client.rs

@@ -0,0 +1,254 @@
+use jsonrpsee::core::client::ClientT;
+use jsonrpsee::core::params::ObjectParams;
+use jsonrpsee::core::traits::ToRpcParams;
+use jsonrpsee::ws_client::{WsClient, WsClientBuilder};
+use serde::Serialize;
+
+use wrightty_protocol::methods::*;
+use wrightty_protocol::types::*;
+
+pub struct WrighttyClient {
+    client: WsClient,
+}
+
+/// Wrapper to serialize a struct as named JSON-RPC params (object).
+struct NamedParams(serde_json::Value);
+
+impl ToRpcParams for NamedParams {
+    fn to_rpc_params(
+        self,
+    ) -> Result<Option<Box<serde_json::value::RawValue>>, serde_json::Error> {
+        let s = serde_json::to_string(&self.0)?;
+        let raw = serde_json::value::RawValue::from_string(s)?;
+        Ok(Some(raw))
+    }
+}
+
+fn to_params<T: Serialize>(val: &T) -> Result<NamedParams, Box<dyn std::error::Error>> {
+    Ok(NamedParams(serde_json::to_value(val)?))
+}
+
+impl WrighttyClient {
+    pub async fn connect(url: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let client = WsClientBuilder::default().build(url).await?;
+        Ok(Self { client })
+    }
+
+    pub async fn get_info(&self) -> Result<ServerInfo, Box<dyn std::error::Error>> {
+        let result: GetInfoResult = self
+            .client
+            .request("Wrightty.getInfo", ObjectParams::new())
+            .await?;
+        Ok(result.info)
+    }
+
+    pub async fn session_create(
+        &self,
+        params: SessionCreateParams,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        let result: SessionCreateResult = self
+            .client
+            .request("Session.create", to_params(&params)?)
+            .await?;
+        Ok(result.session_id)
+    }
+
+    pub async fn session_destroy(
+        &self,
+        session_id: &str,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let params = SessionDestroyParams {
+            session_id: session_id.to_string(),
+            signal: None,
+        };
+        let _: SessionDestroyResult = self
+            .client
+            .request("Session.destroy", to_params(&params)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn session_list(&self) -> Result<Vec<SessionInfo>, Box<dyn std::error::Error>> {
+        let result: SessionListResult = self
+            .client
+            .request("Session.list", ObjectParams::new())
+            .await?;
+        Ok(result.sessions)
+    }
+
+    pub async fn send_keys(
+        &self,
+        session_id: &str,
+        keys: Vec<KeyInput>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let params = InputSendKeysParams {
+            session_id: session_id.to_string(),
+            keys,
+        };
+        let _: serde_json::Value = self
+            .client
+            .request("Input.sendKeys", to_params(&params)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn send_text(
+        &self,
+        session_id: &str,
+        text: &str,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let params = InputSendTextParams {
+            session_id: session_id.to_string(),
+            text: text.to_string(),
+        };
+        let _: serde_json::Value = self
+            .client
+            .request("Input.sendText", to_params(&params)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn get_text(
+        &self,
+        session_id: &str,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        let params = ScreenGetTextParams {
+            session_id: session_id.to_string(),
+            region: None,
+            trim_trailing_whitespace: true,
+        };
+        let result: ScreenGetTextResult = self
+            .client
+            .request("Screen.getText", to_params(&params)?)
+            .await?;
+        Ok(result.text)
+    }
+
+    pub async fn resize(
+        &self,
+        session_id: &str,
+        cols: u16,
+        rows: u16,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let params = TerminalResizeParams {
+            session_id: session_id.to_string(),
+            cols,
+            rows,
+        };
+        let _: serde_json::Value = self
+            .client
+            .request("Terminal.resize", to_params(&params)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn get_contents(
+        &self,
+        session_id: &str,
+    ) -> Result<ScreenGetContentsResult, Box<dyn std::error::Error>> {
+        let params = ScreenGetContentsParams {
+            session_id: session_id.to_string(),
+            region: None,
+        };
+        let result: ScreenGetContentsResult = self
+            .client
+            .request("Screen.getContents", to_params(&params)?)
+            .await?;
+        Ok(result)
+    }
+
+    pub async fn get_scrollback(
+        &self,
+        session_id: &str,
+        lines: u32,
+        offset: u32,
+    ) -> Result<ScreenGetScrollbackResult, Box<dyn std::error::Error>> {
+        let params = ScreenGetScrollbackParams {
+            session_id: session_id.to_string(),
+            lines,
+            offset,
+        };
+        let result: ScreenGetScrollbackResult = self
+            .client
+            .request("Screen.getScrollback", to_params(&params)?)
+            .await?;
+        Ok(result)
+    }
+
+    pub async fn screenshot(
+        &self,
+        session_id: &str,
+        format: ScreenshotFormat,
+    ) -> Result<ScreenScreenshotResult, Box<dyn std::error::Error>> {
+        let params = ScreenScreenshotParams {
+            session_id: session_id.to_string(),
+            format,
+            theme: None,
+            font: None,
+        };
+        let result: ScreenScreenshotResult = self
+            .client
+            .request("Screen.screenshot", to_params(&params)?)
+            .await?;
+        Ok(result)
+    }
+
+    pub async fn wait_for_text(
+        &self,
+        session_id: &str,
+        pattern: &str,
+        is_regex: bool,
+        timeout_ms: u64,
+    ) -> Result<ScreenWaitForTextResult, Box<dyn std::error::Error>> {
+        let params = ScreenWaitForTextParams {
+            session_id: session_id.to_string(),
+            pattern: pattern.to_string(),
+            is_regex,
+            region: None,
+            timeout: timeout_ms,
+            interval: 50,
+        };
+        let result: ScreenWaitForTextResult = self
+            .client
+            .request("Screen.waitForText", to_params(&params)?)
+            .await?;
+        Ok(result)
+    }
+
+    pub async fn send_mouse(
+        &self,
+        session_id: &str,
+        event: &str,
+        button: &str,
+        row: u32,
+        col: u32,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let params = InputSendMouseParams {
+            session_id: session_id.to_string(),
+            event: event.to_string(),
+            button: button.to_string(),
+            row,
+            col,
+            modifiers: vec![],
+        };
+        let _: serde_json::Value = self
+            .client
+            .request("Input.sendMouse", to_params(&params)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn get_size(
+        &self,
+        session_id: &str,
+    ) -> Result<(u16, u16), Box<dyn std::error::Error>> {
+        let params = TerminalGetSizeParams {
+            session_id: session_id.to_string(),
+        };
+        let result: TerminalGetSizeResult = self
+            .client
+            .request("Terminal.getSize", to_params(&params)?)
+            .await?;
+        Ok((result.cols, result.rows))
+    }
+}

package/crates/wrightty-client/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub use client::WrighttyClient;

package/crates/wrightty-core/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "wrightty-core"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description = "Core terminal engine for Wrightty"
+
+[dependencies]
+wrightty-protocol = { version = "0.1.0", path = "../wrightty-protocol" }
+alacritty_terminal = "0.25.1"
+vte = { version = "0.15", features = ["ansi"] }
+portable-pty = "0.9"
+tokio = { version = "1", features = ["full"] }
+uuid = { version = "1", features = ["v4"] }
+regex = "1"
+log = "0.4"
+thiserror = "2"
+base64 = "0.22"

package/crates/wrightty-core/src/input.rs

@@ -0,0 +1,212 @@
+use wrightty_protocol::types::{KeyEvent, KeyInput, KeyType, Modifier};
+
+/// Encode a sequence of KeyInput values into bytes to write to a PTY.
+pub fn encode_keys(keys: &[KeyInput]) -> Vec<u8> {
+    let mut out = Vec::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 Vec<u8>) {
+    // Check for modifier combos like "Ctrl+c"
+    if let Some((modifier_str, key_str)) = s.split_once('+') {
+        let modifier = match modifier_str {
+            "Ctrl" => Some(Modifier::Ctrl),
+            "Alt" => Some(Modifier::Alt),
+            "Shift" => Some(Modifier::Shift),
+            "Meta" => Some(Modifier::Meta),
+            _ => None,
+        };
+
+        if let Some(m) = modifier {
+            // Try to parse the key part as a named key or single char
+            if key_str.len() == 1 {
+                let event = KeyEvent {
+                    key: KeyType::Char,
+                    char: Some(key_str.to_string()),
+                    n: None,
+                    modifiers: vec![m],
+                };
+                encode_key_event(&event, out);
+                return;
+            }
+            // Named key with modifier
+            if let Some(key_type) = parse_named_key(key_str) {
+                let event = KeyEvent {
+                    key: key_type,
+                    char: None,
+                    n: None,
+                    modifiers: vec![m],
+                };
+                encode_key_event(&event, out);
+                return;
+            }
+        }
+    }
+
+    // Check named keys
+    if let Some(key_type) = parse_named_key(s) {
+        let event = KeyEvent {
+            key: key_type,
+            char: None,
+            n: None,
+            modifiers: vec![],
+        };
+        encode_key_event(&event, out);
+        return;
+    }
+
+    // Single character
+    if s.len() == 1 {
+        out.extend_from_slice(s.as_bytes());
+        return;
+    }
+
+    // Function keys like "F5"
+    if let Some(rest) = s.strip_prefix('F') && let Ok(n) = rest.parse::<u8>() {
+        let event = KeyEvent {
+            key: KeyType::F,
+            char: None,
+            n: Some(n),
+            modifiers: vec![],
+        };
+        encode_key_event(&event, out);
+        return;
+    }
+
+    // Fallback: send as raw text
+    out.extend_from_slice(s.as_bytes());
+}
+
+fn parse_named_key(s: &str) -> Option<KeyType> {
+    match s {
+        "Enter" => Some(KeyType::Enter),
+        "Tab" => Some(KeyType::Tab),
+        "Backspace" => Some(KeyType::Backspace),
+        "Delete" => Some(KeyType::Delete),
+        "Escape" => Some(KeyType::Escape),
+        "ArrowUp" => Some(KeyType::ArrowUp),
+        "ArrowDown" => Some(KeyType::ArrowDown),
+        "ArrowLeft" => Some(KeyType::ArrowLeft),
+        "ArrowRight" => Some(KeyType::ArrowRight),
+        "Home" => Some(KeyType::Home),
+        "End" => Some(KeyType::End),
+        "PageUp" => Some(KeyType::PageUp),
+        "PageDown" => Some(KeyType::PageDown),
+        "Insert" => Some(KeyType::Insert),
+        _ => None,
+    }
+}
+
+fn encode_key_event(event: &KeyEvent, out: &mut Vec<u8>) {
+    let has_ctrl = event.modifiers.iter().any(|m| matches!(m, Modifier::Ctrl));
+    let has_alt = event.modifiers.iter().any(|m| matches!(m, Modifier::Alt));
+
+    match &event.key {
+        KeyType::Char => {
+            if let Some(ref ch) = event.char && let Some(c) = ch.chars().next() {
+                if has_ctrl {
+                    // Ctrl+letter = letter & 0x1f
+                    let ctrl_byte = (c.to_ascii_lowercase() as u8) & 0x1f;
+                    if has_alt {
+                        out.push(0x1b);
+                    }
+                    out.push(ctrl_byte);
+                } else if has_alt {
+                    out.push(0x1b);
+                    out.extend_from_slice(ch.as_bytes());
+                } else {
+                    out.extend_from_slice(ch.as_bytes());
+                }
+            }
+        }
+        KeyType::Enter => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.push(b'\r');
+        }
+        KeyType::Tab => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.push(b'\t');
+        }
+        KeyType::Backspace => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.push(0x7f);
+        }
+        KeyType::Escape => {
+            out.push(0x1b);
+        }
+        KeyType::Delete => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.extend_from_slice(b"\x1b[3~");
+        }
+        // Arrow keys — normal mode (not application mode for now)
+        KeyType::ArrowUp => encode_csi_key(b'A', has_alt, out),
+        KeyType::ArrowDown => encode_csi_key(b'B', has_alt, out),
+        KeyType::ArrowRight => encode_csi_key(b'C', has_alt, out),
+        KeyType::ArrowLeft => encode_csi_key(b'D', has_alt, out),
+        KeyType::Home => encode_csi_key(b'H', has_alt, out),
+        KeyType::End => encode_csi_key(b'F', has_alt, out),
+        KeyType::PageUp => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.extend_from_slice(b"\x1b[5~");
+        }
+        KeyType::PageDown => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.extend_from_slice(b"\x1b[6~");
+        }
+        KeyType::Insert => {
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.extend_from_slice(b"\x1b[2~");
+        }
+        KeyType::F => {
+            let n = event.n.unwrap_or(1);
+            let seq = match n {
+                1 => b"\x1bOP".as_slice(),
+                2 => b"\x1bOQ",
+                3 => b"\x1bOR",
+                4 => b"\x1bOS",
+                5 => b"\x1b[15~",
+                6 => b"\x1b[17~",
+                7 => b"\x1b[18~",
+                8 => b"\x1b[19~",
+                9 => b"\x1b[20~",
+                10 => b"\x1b[21~",
+                11 => b"\x1b[23~",
+                12 => b"\x1b[24~",
+                _ => return,
+            };
+            if has_alt {
+                out.push(0x1b);
+            }
+            out.extend_from_slice(seq);
+        }
+    }
+}
+
+fn encode_csi_key(code: u8, alt: bool, out: &mut Vec<u8>) {
+    if alt {
+        out.push(0x1b);
+    }
+    out.push(0x1b);
+    out.push(b'[');
+    out.push(code);
+}

package/crates/wrightty-core/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod session;
+pub mod session_manager;
+pub mod screen;
+pub mod input;