@moejay/wrightty 0.0.0 → 0.1.1

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

@@ -1,254 +0,0 @@
-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

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

package/crates/wrightty-core/Cargo.toml

@@ -1,21 +0,0 @@
-[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

@@ -1,212 +0,0 @@
-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

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