@moejay/wrightty 0.0.0 → 0.1.1

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

@@ -1,325 +0,0 @@
-use alacritty_terminal::event::VoidListener;
-use alacritty_terminal::grid::Dimensions;
-use alacritty_terminal::index::{Column, Line, Point};
-use alacritty_terminal::term::cell::Flags;
-use alacritty_terminal::term::Term;
-use alacritty_terminal::vte::ansi::CursorShape as AlacCursorShape;
-
-use wrightty_protocol::types::*;
-
-/// Extract the visible screen as a grid of CellData.
-pub fn extract_contents(term: &Term<VoidListener>) -> ScreenGetContentsData {
-    let grid = term.grid();
-    let num_cols = grid.columns();
-    let num_lines = grid.screen_lines();
-
-    let mut cells = Vec::with_capacity(num_lines);
-
-    for line_idx in 0..num_lines {
-        let line = Line(line_idx as i32);
-        let mut row = Vec::with_capacity(num_cols);
-
-        for col_idx in 0..num_cols {
-            let point = Point::new(line, Column(col_idx));
-            let cell = &grid[point];
-
-            let c = cell.c;
-            let flags = cell.flags;
-
-            let width = if flags.contains(Flags::WIDE_CHAR) {
-                2u8
-            } else if flags.contains(Flags::WIDE_CHAR_SPACER) {
-                0u8
-            } else {
-                1u8
-            };
-
-            // Resolve colors to RGB
-            let fg = resolve_color(cell.fg);
-            let bg = resolve_color(cell.bg);
-
-            let underline = if flags.contains(Flags::DOUBLE_UNDERLINE) {
-                UnderlineStyle::Double
-            } else if flags.contains(Flags::UNDERCURL) {
-                UnderlineStyle::Curly
-            } else if flags.contains(Flags::DOTTED_UNDERLINE) {
-                UnderlineStyle::Dotted
-            } else if flags.contains(Flags::DASHED_UNDERLINE) {
-                UnderlineStyle::Dashed
-            } else if flags.contains(Flags::ALL_UNDERLINES) {
-                UnderlineStyle::Single
-            } else {
-                UnderlineStyle::None
-            };
-
-            row.push(CellData {
-                char: c.to_string(),
-                width,
-                fg,
-                bg,
-                attrs: CellAttrs {
-                    bold: flags.contains(Flags::BOLD),
-                    italic: flags.contains(Flags::ITALIC),
-                    underline,
-                    underline_color: None, // TODO: extract underline color
-                    strikethrough: flags.contains(Flags::STRIKEOUT),
-                    dim: flags.contains(Flags::DIM),
-                    blink: false, // alacritty_terminal doesn't track blink state on cells
-                    reverse: flags.contains(Flags::INVERSE),
-                    hidden: flags.contains(Flags::HIDDEN),
-                },
-                hyperlink: cell.hyperlink().map(|h| h.uri().to_string()),
-            });
-        }
-
-        cells.push(row);
-    }
-
-    let cursor = term.grid().cursor.point;
-    let style = term.cursor_style();
-    let cursor_state = CursorState {
-        row: cursor.line.0 as u32,
-        col: cursor.column.0 as u32,
-        visible: true,
-        shape: match style.shape {
-            AlacCursorShape::Block => CursorShape::Block,
-            AlacCursorShape::Underline => CursorShape::Underline,
-            AlacCursorShape::Beam => CursorShape::Bar,
-            _ => CursorShape::Block,
-        },
-    };
-
-    ScreenGetContentsData {
-        rows: num_lines as u32,
-        cols: num_cols as u32,
-        cursor: cursor_state,
-        cells,
-        alternate_screen: term.mode().contains(alacritty_terminal::term::TermMode::ALT_SCREEN),
-    }
-}
-
-/// Extract the visible screen as plain text.
-pub fn extract_text(term: &Term<VoidListener>) -> String {
-    let grid = term.grid();
-    let num_cols = grid.columns();
-    let num_lines = grid.screen_lines();
-    let mut lines = Vec::with_capacity(num_lines);
-
-    for line_idx in 0..num_lines {
-        let line = Line(line_idx as i32);
-        let mut row_text = String::with_capacity(num_cols);
-
-        for col_idx in 0..num_cols {
-            let point = Point::new(line, Column(col_idx));
-            let cell = &grid[point];
-
-            if cell.flags.contains(Flags::WIDE_CHAR_SPACER) {
-                continue;
-            }
-
-            row_text.push(cell.c);
-        }
-
-        // Trim trailing whitespace
-        let trimmed = row_text.trim_end();
-        lines.push(trimmed.to_string());
-    }
-
-    // Remove trailing empty lines
-    while lines.last().is_some_and(|l| l.is_empty()) {
-        lines.pop();
-    }
-
-    lines.join("\n")
-}
-
-/// Extract scrollback history lines as plain text.
-/// Returns up to `lines` lines starting from `offset` lines before the most recent history line.
-pub fn extract_scrollback(
-    term: &Term<VoidListener>,
-    lines: u32,
-    offset: u32,
-) -> (Vec<wrightty_protocol::methods::ScrollbackLine>, u32) {
-    let grid = term.grid();
-    let history = grid.history_size() as u32;
-    let num_cols = grid.columns();
-
-    let total_scrollback = history;
-    let start = offset;
-    let end = (offset + lines).min(history);
-
-    let mut result = Vec::new();
-    for i in start..end {
-        // Line(-(i+1)) is the (i+1)th most-recent history line
-        let line_idx = Line(-((i as i32) + 1));
-        let mut row_text = String::with_capacity(num_cols);
-        for col_idx in 0..num_cols {
-            let point = Point::new(line_idx, Column(col_idx));
-            let cell = &grid[point];
-            if cell.flags.contains(Flags::WIDE_CHAR_SPACER) {
-                continue;
-            }
-            row_text.push(cell.c);
-        }
-        let text = row_text.trim_end().to_string();
-        result.push(wrightty_protocol::methods::ScrollbackLine {
-            text,
-            line_number: -((i as i32) + 1),
-        });
-    }
-
-    (result, total_scrollback)
-}
-
-/// Data returned by extract_contents (before serialization to protocol type).
-pub struct ScreenGetContentsData {
-    pub rows: u32,
-    pub cols: u32,
-    pub cursor: CursorState,
-    pub cells: Vec<Vec<CellData>>,
-    pub alternate_screen: bool,
-}
-
-/// Resolve an alacritty color to RGB.
-/// For now, use a simple default palette. Full palette support comes later.
-fn resolve_color(color: alacritty_terminal::vte::ansi::Color) -> Rgb {
-    use alacritty_terminal::vte::ansi::Color;
-    use alacritty_terminal::vte::ansi::NamedColor;
-
-    match color {
-        Color::Spec(rgb) => Rgb {
-            r: rgb.r,
-            g: rgb.g,
-            b: rgb.b,
-        },
-        Color::Named(named) => {
-            // Default xterm colors
-            match named {
-                NamedColor::Black => Rgb { r: 0, g: 0, b: 0 },
-                NamedColor::Red => Rgb {
-                    r: 205,
-                    g: 0,
-                    b: 0,
-                },
-                NamedColor::Green => Rgb {
-                    r: 0,
-                    g: 205,
-                    b: 0,
-                },
-                NamedColor::Yellow => Rgb {
-                    r: 205,
-                    g: 205,
-                    b: 0,
-                },
-                NamedColor::Blue => Rgb {
-                    r: 0,
-                    g: 0,
-                    b: 238,
-                },
-                NamedColor::Magenta => Rgb {
-                    r: 205,
-                    g: 0,
-                    b: 205,
-                },
-                NamedColor::Cyan => Rgb {
-                    r: 0,
-                    g: 205,
-                    b: 205,
-                },
-                NamedColor::White => Rgb {
-                    r: 229,
-                    g: 229,
-                    b: 229,
-                },
-                NamedColor::BrightBlack => Rgb {
-                    r: 127,
-                    g: 127,
-                    b: 127,
-                },
-                NamedColor::BrightRed => Rgb {
-                    r: 255,
-                    g: 0,
-                    b: 0,
-                },
-                NamedColor::BrightGreen => Rgb {
-                    r: 0,
-                    g: 255,
-                    b: 0,
-                },
-                NamedColor::BrightYellow => Rgb {
-                    r: 255,
-                    g: 255,
-                    b: 0,
-                },
-                NamedColor::BrightBlue => Rgb {
-                    r: 92,
-                    g: 92,
-                    b: 255,
-                },
-                NamedColor::BrightMagenta => Rgb {
-                    r: 255,
-                    g: 0,
-                    b: 255,
-                },
-                NamedColor::BrightCyan => Rgb {
-                    r: 0,
-                    g: 255,
-                    b: 255,
-                },
-                NamedColor::BrightWhite => Rgb {
-                    r: 255,
-                    g: 255,
-                    b: 255,
-                },
-                NamedColor::Foreground => Rgb {
-                    r: 255,
-                    g: 255,
-                    b: 255,
-                },
-                NamedColor::Background => Rgb { r: 0, g: 0, b: 0 },
-                _ => Rgb {
-                    r: 200,
-                    g: 200,
-                    b: 200,
-                },
-            }
-        }
-        Color::Indexed(idx) => {
-            // 256-color palette
-            static ANSI_COLORS: [(u8, u8, u8); 16] = [
-                (0, 0, 0),       // 0 black
-                (205, 0, 0),     // 1 red
-                (0, 205, 0),     // 2 green
-                (205, 205, 0),   // 3 yellow
-                (0, 0, 238),     // 4 blue
-                (205, 0, 205),   // 5 magenta
-                (0, 205, 205),   // 6 cyan
-                (229, 229, 229), // 7 white
-                (127, 127, 127), // 8 bright black
-                (255, 0, 0),     // 9 bright red
-                (0, 255, 0),     // 10 bright green
-                (255, 255, 0),   // 11 bright yellow
-                (92, 92, 255),   // 12 bright blue
-                (255, 0, 255),   // 13 bright magenta
-                (0, 255, 255),   // 14 bright cyan
-                (255, 255, 255), // 15 bright white
-            ];
-
-            if (idx as usize) < 16 {
-                let (r, g, b) = ANSI_COLORS[idx as usize];
-                Rgb { r, g, b }
-            } else if idx < 232 {
-                // 6x6x6 color cube
-                let i = idx - 16;
-                let r = (i / 36) * 51;
-                let g = ((i / 6) % 6) * 51;
-                let b = (i % 6) * 51;
-                Rgb { r, g, b }
-            } else {
-                // Grayscale ramp
-                let v = 8 + (idx - 232) * 10;
-                Rgb { r: v, g: v, b: v }
-            }
-        }
-    }
-}

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

@@ -1,249 +0,0 @@
-use std::io::{Read, Write};
-use std::sync::{Arc, Mutex};
-
-use alacritty_terminal::event::VoidListener;
-use alacritty_terminal::grid::Dimensions;
-use alacritty_terminal::term::{Config as TermConfig, Term};
-use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize};
-use tokio::sync::broadcast;
-use vte::ansi::Processor;
-
-use wrightty_protocol::types::SessionId;
-
-use crate::screen;
-
-/// Terminal dimensions for alacritty_terminal.
-struct TermSize {
-    cols: usize,
-    lines: usize,
-}
-
-impl Dimensions for TermSize {
-    fn total_lines(&self) -> usize {
-        self.lines
-    }
-    fn screen_lines(&self) -> usize {
-        self.lines
-    }
-    fn columns(&self) -> usize {
-        self.cols
-    }
-}
-
-/// Internal terminal state protected by a mutex.
-pub struct TermState {
-    pub term: Term<VoidListener>,
-    pub parser: Processor,
-}
-
-/// A terminal session: owns a PTY, a virtual terminal, and the reader task.
-pub struct Session {
-    pub id: SessionId,
-    pub state: Arc<Mutex<TermState>>,
-    pub master: Box<dyn MasterPty + Send>,
-    pub writer: Box<dyn Write + Send>,
-    pub child: Box<dyn Child + Send + Sync>,
-    pub update_tx: broadcast::Sender<()>,
-    reader_handle: tokio::task::JoinHandle<()>,
-    cols: u16,
-    rows: u16,
-    pub title: String,
-}
-
-impl Session {
-    pub fn spawn(
-        id: SessionId,
-        shell: Option<String>,
-        args: Vec<String>,
-        cols: u16,
-        rows: u16,
-        env: std::collections::HashMap<String, String>,
-        cwd: Option<String>,
-    ) -> Result<Self, SessionError> {
-        let pty_system = native_pty_system();
-        let pair = pty_system
-            .openpty(PtySize {
-                rows,
-                cols,
-                pixel_width: 0,
-                pixel_height: 0,
-            })
-            .map_err(|e| SessionError::Spawn(e.to_string()))?;
-
-        let shell_path = shell.unwrap_or_else(|| {
-            std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string())
-        });
-
-        let mut cmd = CommandBuilder::new(&shell_path);
-        for arg in &args {
-            cmd.arg(arg);
-        }
-        cmd.env("TERM", "xterm-256color");
-        for (k, v) in &env {
-            cmd.env(k, v);
-        }
-        if let Some(ref dir) = cwd {
-            cmd.cwd(dir);
-        }
-
-        let child = pair
-            .slave
-            .spawn_command(cmd)
-            .map_err(|e| SessionError::Spawn(e.to_string()))?;
-
-        // Drop the slave side — we only talk through the master
-        drop(pair.slave);
-
-        let reader = pair
-            .master
-            .try_clone_reader()
-            .map_err(|e| SessionError::Spawn(e.to_string()))?;
-        let writer = pair
-            .master
-            .take_writer()
-            .map_err(|e| SessionError::Spawn(e.to_string()))?;
-
-        // Create the virtual terminal
-        let size = TermSize {
-            cols: cols as usize,
-            lines: rows as usize,
-        };
-        let term = Term::new(TermConfig::default(), &size, VoidListener);
-        let parser = Processor::new();
-
-        let state = Arc::new(Mutex::new(TermState { term, parser }));
-        let (update_tx, _) = broadcast::channel(64);
-
-        // Spawn a blocking reader task that feeds PTY output into the terminal
-        let reader_state = Arc::clone(&state);
-        let reader_tx = update_tx.clone();
-        let reader_handle = tokio::task::spawn_blocking(move || {
-            Self::reader_loop(reader, reader_state, reader_tx);
-        });
-
-        Ok(Session {
-            id,
-            state,
-            master: pair.master,
-            writer,
-            child,
-            update_tx,
-            reader_handle,
-            cols,
-            rows,
-            title: shell_path,
-        })
-    }
-
-    fn reader_loop(
-        mut reader: Box<dyn Read + Send>,
-        state: Arc<Mutex<TermState>>,
-        update_tx: broadcast::Sender<()>,
-    ) {
-        let mut buf = [0u8; 4096];
-        loop {
-            match reader.read(&mut buf) {
-                Ok(0) => break, // EOF — child exited
-                Ok(n) => {
-                    let mut s = state.lock().unwrap();
-                    let TermState { ref mut parser, ref mut term } = *s;
-                    parser.advance(term, &buf[..n]);
-                    drop(s);
-                    // Notify subscribers (ignore error if no receivers)
-                    let _ = update_tx.send(());
-                }
-                Err(_) => break,
-            }
-        }
-    }
-
-    /// Send raw bytes to the PTY.
-    pub fn write_bytes(&mut self, data: &[u8]) -> Result<(), SessionError> {
-        self.writer
-            .write_all(data)
-            .map_err(|e| SessionError::Io(e.to_string()))?;
-        self.writer
-            .flush()
-            .map_err(|e| SessionError::Io(e.to_string()))?;
-        Ok(())
-    }
-
-    /// Resize the PTY and terminal.
-    pub fn resize(&mut self, cols: u16, rows: u16) -> Result<(), SessionError> {
-        self.master
-            .resize(PtySize {
-                rows,
-                cols,
-                pixel_width: 0,
-                pixel_height: 0,
-            })
-            .map_err(|e| SessionError::Io(e.to_string()))?;
-
-        let size = TermSize {
-            cols: cols as usize,
-            lines: rows as usize,
-        };
-        let mut s = self.state.lock().unwrap();
-        s.term.resize(size);
-        drop(s);
-
-        self.cols = cols;
-        self.rows = rows;
-        Ok(())
-    }
-
-    /// Get the current screen as plain text.
-    pub fn get_text(&self) -> String {
-        let s = self.state.lock().unwrap();
-        screen::extract_text(&s.term)
-    }
-
-    /// Get the current screen as a structured cell grid.
-    pub fn get_contents(&self) -> screen::ScreenGetContentsData {
-        let s = self.state.lock().unwrap();
-        screen::extract_contents(&s.term)
-    }
-
-    /// Get scrollback history lines.
-    pub fn get_scrollback(
-        &self,
-        lines: u32,
-        offset: u32,
-    ) -> (Vec<wrightty_protocol::methods::ScrollbackLine>, u32) {
-        let s = self.state.lock().unwrap();
-        screen::extract_scrollback(&s.term, lines, offset)
-    }
-
-    /// Get the current terminal size.
-    pub fn size(&self) -> (u16, u16) {
-        (self.cols, self.rows)
-    }
-
-    /// Check if the child process is still running.
-    pub fn is_running(&self) -> bool {
-        // try_wait returns Ok(Some(status)) if exited, Ok(None) if still running
-        // portable-pty Child doesn't have try_wait in the trait, so we'll just
-        // return true for now and handle exit via the reader loop
-        true
-    }
-
-    /// Get a broadcast receiver for screen update notifications.
-    pub fn subscribe_updates(&self) -> broadcast::Receiver<()> {
-        self.update_tx.subscribe()
-    }
-}
-
-impl Drop for Session {
-    fn drop(&mut self) {
-        self.reader_handle.abort();
-        let _ = self.child.kill();
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum SessionError {
-    #[error("failed to spawn session: {0}")]
-    Spawn(String),
-    #[error("I/O error: {0}")]
-    Io(String),
-}

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

@@ -1,77 +0,0 @@
-use std::collections::HashMap;
-
-use wrightty_protocol::types::{SessionId, SessionInfo};
-
-use crate::session::{Session, SessionError};
-
-pub struct SessionManager {
-    sessions: HashMap<SessionId, Session>,
-    max_sessions: usize,
-}
-
-impl SessionManager {
-    pub fn new(max_sessions: usize) -> Self {
-        Self {
-            sessions: HashMap::new(),
-            max_sessions,
-        }
-    }
-
-    pub fn create(
-        &mut self,
-        shell: Option<String>,
-        args: Vec<String>,
-        cols: u16,
-        rows: u16,
-        env: std::collections::HashMap<String, String>,
-        cwd: Option<String>,
-    ) -> Result<SessionId, SessionError> {
-        if self.sessions.len() >= self.max_sessions {
-            return Err(SessionError::Spawn("max sessions reached".to_string()));
-        }
-
-        let id = uuid::Uuid::new_v4().to_string();
-        let session = Session::spawn(id.clone(), shell, args, cols, rows, env, cwd)?;
-        self.sessions.insert(id.clone(), session);
-        Ok(id)
-    }
-
-    pub fn destroy(&mut self, id: &str) -> Result<(), SessionError> {
-        self.sessions
-            .remove(id)
-            .ok_or_else(|| SessionError::Spawn(format!("session not found: {id}")))?;
-        // Session::drop will kill the child and abort the reader
-        Ok(())
-    }
-
-    pub fn get(&self, id: &str) -> Option<&Session> {
-        self.sessions.get(id)
-    }
-
-    pub fn get_mut(&mut self, id: &str) -> Option<&mut Session> {
-        self.sessions.get_mut(id)
-    }
-
-    pub fn list(&self) -> Vec<SessionInfo> {
-        self.sessions
-            .values()
-            .map(|s| {
-                let (cols, rows) = s.size();
-                SessionInfo {
-                    session_id: s.id.clone(),
-                    title: s.title.clone(),
-                    cwd: None,
-                    cols,
-                    rows,
-                    pid: None,
-                    running: s.is_running(),
-                    alternate_screen: false,
-                }
-            })
-            .collect()
-    }
-
-    pub fn session_count(&self) -> usize {
-        self.sessions.len()
-    }
-}

package/crates/wrightty-protocol/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "wrightty-protocol"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-description = "Protocol types for the Wrightty terminal automation protocol"
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"

package/crates/wrightty-protocol/src/error.rs

@@ -1,8 +0,0 @@
-pub const SESSION_NOT_FOUND: i32 = 1001;
-pub const SESSION_DESTROYED: i32 = 1002;
-pub const WAIT_TIMEOUT: i32 = 1003;
-pub const INVALID_PATTERN: i32 = 1004;
-pub const SPAWN_FAILED: i32 = 1005;
-pub const NOT_SUPPORTED: i32 = 1006;
-pub const MAX_SESSIONS_REACHED: i32 = 1007;
-pub const SUBSCRIPTION_NOT_FOUND: i32 = 1008;